← Back to branch summary

~ubuntu-branches/ubuntu/trusty/bash/trusty-security

« back to all changes in this revision

Viewing changes to lib/malloc/imalloc.h

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2014-03-03 22:52:05 UTC
  • mfrom: (1.3.5) (2.2.6 experimental)
  • Revision ID: package-import@ubuntu.com-20140303225205-87ltrt5kspeq0g1b
Tags: 4.3-1ubuntu1
* Merge with Debian; remaining changes:
  - skel.bashrc:
    - Run lesspipe.
    - Enable ls aliases.
    - Set options in ll alias to -alF.
    - Define an alert alias.
    - Enabled colored grep aliases.
  - etc.bash.bashrc:
    - Add sudo hint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/malloc/imalloc.h
 
1
/* imalloc.h -- internal malloc definitions shared by source files. */
 
2
 
 
3
/* Copyright (C) 2001-2003 Free Software Foundation, Inc.
 
4
 
 
5
   This file is part of GNU Bash, the Bourne Again SHell.
 
6
 
 
7
   Bash is free software: you can redistribute it and/or modify
 
8
   it under the terms of the GNU General Public License as published by
 
9
   the Free Software Foundation, either version 3 of the License, or
 
10
   (at your option) any later version.
 
11
 
 
12
   Bash is distributed in the hope that it will be useful,
 
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
   GNU General Public License for more details.
 
16
 
 
17
   You should have received a copy of the GNU General Public License
 
18
   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
 
19
*/
 
20
 
 
21
/* Must be included *after* config.h */
 
22
 
 
23
#ifndef _IMALLOC_H
 
24
#define _IMALLOC_H
 
25
 
 
26
#ifdef MALLOC_DEBUG
 
27
#define MALLOC_STATS
 
28
#define MALLOC_TRACE
 
29
#define MALLOC_REGISTER
 
30
#define MALLOC_WATCH
 
31
#endif
 
32
 
 
33
#define MALLOC_WRAPFUNCS
 
34
 
 
35
/* Generic pointer type. */
 
36
#ifndef PTR_T
 
37
#  if defined (__STDC__)
 
38
#    define PTR_T void *
 
39
#  else
 
40
#    define PTR_T char *
 
41
#  endif
 
42
#endif
 
43
 
 
44
#if !defined (NULL)
 
45
#  define NULL 0
 
46
#endif
 
47
 
 
48
#if !defined (CPP_STRING)
 
49
#  if defined (HAVE_STRINGIZE)
 
50
#    define CPP_STRING(x) #x
 
51
#  else
 
52
#    define CPP_STRING(x) "x"
 
53
#  endif /* !HAVE_STRINGIZE */
 
54
#endif /* !__STRING */
 
55
 
 
56
#if __GNUC__ > 1
 
57
#  define FASTCOPY(s, d, n)  __builtin_memcpy (d, s, n)
 
58
#else /* !__GNUC__ */
 
59
#  if !defined (HAVE_BCOPY)
 
60
#    if !defined (HAVE_MEMMOVE)
 
61
#      define FASTCOPY(s, d, n)  memcpy (d, s, n)
 
62
#    else
 
63
#      define FASTCOPY(s, d, n)  memmove (d, s, n)
 
64
#    endif /* !HAVE_MEMMOVE */
 
65
#  else /* HAVE_BCOPY */
 
66
#    define FASTCOPY(s, d, n)  bcopy (s, d, n)
 
67
#  endif /* HAVE_BCOPY */
 
68
#endif /* !__GNUC__ */
 
69
 
 
70
#if !defined (__P)
 
71
#  if defined (__STDC__) || defined (__GNUC__) || defined (__cplusplus) || defined (PROTOTYPES)
 
72
#    define __P(protos) protos
 
73
#  else 
 
74
#    define __P(protos) ()
 
75
#  endif
 
76
#endif
 
77
 
 
78
/* Use Duff's device for good zeroing/copying performance.  DO NOT call the
 
79
   Duff's device macros with NBYTES == 0. */
 
80
 
 
81
#define MALLOC_BZERO(charp, nbytes)                                     \
 
82
do {                                                                    \
 
83
  if ((nbytes) <= 32) {                                                 \
 
84
    size_t * mzp = (size_t *)(charp);                                   \
 
85
    unsigned long mctmp = (nbytes)/sizeof(size_t);                      \
 
86
    long mcn;                                                           \
 
87
    if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp &= 7; }     \
 
88
    switch (mctmp) {                                                    \
 
89
      case 0: for(;;) { *mzp++ = 0;                                     \
 
90
      case 7:      *mzp++ = 0;                                          \
 
91
      case 6:      *mzp++ = 0;                                          \
 
92
      case 5:      *mzp++ = 0;                                          \
 
93
      case 4:      *mzp++ = 0;                                          \
 
94
      case 3:      *mzp++ = 0;                                          \
 
95
      case 2:      *mzp++ = 0;                                          \
 
96
      case 1:      *mzp++ = 0; if(mcn <= 0) break; mcn--; }             \
 
97
    }                                                                   \
 
98
  else                                                                  \
 
99
    memset ((charp), 0, (nbytes));                                      \
 
100
} while(0)
 
101
 
 
102
#define MALLOC_ZERO(charp, nbytes) \
 
103
do {                                                            \
 
104
  size_t mzsz = (nbytes);                                       \
 
105
  if (mzsz <= 9 * sizeof(mzsz) {                                \
 
106
    size_t *mz = (size_t *)(charp);                             \
 
107
    if(mzsz >= 5*sizeof(mzsz)) {        *mz++ = 0;              \
 
108
                                        *mz++ = 0;              \
 
109
      if(mzsz >= 7*sizeof(mzsz)) {      *mz++ = 0;              \
 
110
                                        *mz++ = 0;              \
 
111
        if(mzsz >= 9*sizeof(mzsz)) {    *mz++ = 0;              \
 
112
                                        *mz++ = 0; }}}          \
 
113
                                        *mz++ = 0;              \
 
114
                                        *mz++ = 0;              \
 
115
                                        *mz = 0;                \
 
116
  } else                                                        \
 
117
    memset ((charp), 0, mzsz);                                  \
 
118
} while (0)
 
119
 
 
120
#define MALLOC_MEMSET(charp, xch, nbytes)                               \
 
121
do {                                                                    \
 
122
  if ((nbytes) <= 32) {                                                 \
 
123
    register char * mzp = (charp);                                      \
 
124
    unsigned long mctmp = (nbytes);                                     \
 
125
    register long mcn;                                                  \
 
126
    if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp &= 7; }     \
 
127
    switch (mctmp) {                                                    \
 
128
      case 0: for(;;) { *mzp++ = xch;                                   \
 
129
      case 7:      *mzp++ = xch;                                        \
 
130
      case 6:      *mzp++ = xch;                                        \
 
131
      case 5:      *mzp++ = xch;                                        \
 
132
      case 4:      *mzp++ = xch;                                        \
 
133
      case 3:      *mzp++ = xch;                                        \
 
134
      case 2:      *mzp++ = xch;                                        \
 
135
      case 1:      *mzp++ = xch; if(mcn <= 0) break; mcn--; }           \
 
136
    }                                                                   \
 
137
  } else                                                                \
 
138
    memset ((charp), (xch), (nbytes));                                  \
 
139
} while(0)
 
140
 
 
141
#define MALLOC_MEMCPY(dest,src,nbytes)                                  \
 
142
do {                                                                    \
 
143
  if ((nbytes) <= 32) {                                                 \
 
144
    size_t* mcsrc = (size_t*) src;                                      \
 
145
    size_t* mcdst = (size_t*) dest;                                     \
 
146
    unsigned long mctmp = (nbytes)/sizeof(size_t);                      \
 
147
    long mcn;                                                           \
 
148
    if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp &= 7; }     \
 
149
    switch (mctmp) {                                                    \
 
150
      case 0: for(;;) { *mcdst++ = *mcsrc++;                            \
 
151
      case 7:      *mcdst++ = *mcsrc++;                                 \
 
152
      case 6:      *mcdst++ = *mcsrc++;                                 \
 
153
      case 5:      *mcdst++ = *mcsrc++;                                 \
 
154
      case 4:      *mcdst++ = *mcsrc++;                                 \
 
155
      case 3:      *mcdst++ = *mcsrc++;                                 \
 
156
      case 2:      *mcdst++ = *mcsrc++;                                 \
 
157
      case 1:      *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; }    \
 
158
  } else                                                                \
 
159
    memcpy ((dest), (src), (nbytes))                                    \
 
160
} while(0)
 
161
 
 
162
#if defined (SHELL)
 
163
#  include "bashintl.h"
 
164
#else
 
165
#  define _(x)  x
 
166
#endif
 
167
 
 
168
#include <signal.h>
 
169
 
 
170
extern void _malloc_block_signals __P((sigset_t *, sigset_t *));
 
171
extern void _malloc_unblock_signals __P((sigset_t *, sigset_t *));
 
172
 
 
173
#endif /* _IMALLOC_H */