Use MAP_ANON instead of MAP_ANONYMOUS.
[kopensolaris-gnu/glibc.git] / elf / dl-minimal.c
1 /* Minimal replacements for basic facilities used in the dynamic linker.
2    Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #include <errno.h>
21 #include <limits.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <sys/types.h>
25 #include <sys/mman.h>
26 #include <elf/ldsodefs.h>
27 #include <stdio-common/_itoa.h>
28
29 #include <assert.h>
30
31 /* Minimal `malloc' allocator for use while loading shared libraries.
32    No block is ever freed.  */
33
34 static void *alloc_ptr, *alloc_end, *alloc_last_block;
35
36 void * weak_function
37 malloc (size_t n)
38 {
39 #ifdef MAP_ANON
40 #define _dl_zerofd (-1)
41 #else
42   extern int _dl_zerofd;
43
44   if (_dl_zerofd == -1)
45     _dl_zerofd = _dl_sysdep_open_zero_fill ();
46 #define MAP_ANON 0
47 #endif
48
49   if (alloc_end == 0)
50     {
51       /* Consume any unused space in the last page of our data segment.  */
52       extern int _end;
53       alloc_ptr = &_end;
54       alloc_end = (void *) 0 + (((alloc_ptr - (void *) 0) + _dl_pagesize - 1)
55                                 & ~(_dl_pagesize - 1));
56     }
57
58   /* Make sure the allocation pointer is ideally aligned.  */
59   alloc_ptr = (void *) 0 + (((alloc_ptr - (void *) 0) + sizeof (double) - 1)
60                             & ~(sizeof (double) - 1));
61
62   if (alloc_ptr + n >= alloc_end)
63     {
64       /* Insufficient space left; allocate another page.  */
65       caddr_t page;
66       size_t nup = (n + _dl_pagesize - 1) & ~(_dl_pagesize - 1);
67       page = __mmap (0, nup, PROT_READ|PROT_WRITE,
68                      MAP_ANON|MAP_PRIVATE, _dl_zerofd, 0);
69       assert (page != MAP_FAILED);
70       if (page != alloc_end)
71         alloc_ptr = page;
72       alloc_end = page + nup;
73     }
74
75   alloc_last_block = (void *) alloc_ptr;
76   alloc_ptr += n;
77   return alloc_last_block;
78 }
79
80 /* We use this function occasionally since the real implementation may
81    be optimized when it can assume the memory it returns already is
82    set to NUL.  */
83 void * weak_function
84 calloc (size_t nmemb, size_t size)
85 {
86   size_t total = nmemb * size;
87   void *result = malloc (total);
88   return memset (result, '\0', total);
89 }
90
91 /* This will rarely be called.  */
92 void weak_function
93 free (void *ptr)
94 {
95   /* We can free only the last block allocated.  */
96   if (ptr == alloc_last_block)
97     alloc_ptr = alloc_last_block;
98 }
99
100 /* This is only called with the most recent block returned by malloc.  */
101 void * weak_function
102 realloc (void *ptr, size_t n)
103 {
104   void *new;
105   assert (ptr == alloc_last_block);
106   alloc_ptr = alloc_last_block;
107   new = malloc (n);
108   assert (new == ptr);
109   return new;
110 }
111 \f
112 /* Avoid signal frobnication in setjmp/longjmp.  Keeps things smaller.  */
113
114 #include <setjmp.h>
115
116 int weak_function
117 __sigjmp_save (sigjmp_buf env, int savemask)
118 {
119   env[0].__mask_was_saved = savemask;
120   return 0;
121 }
122
123 void weak_function
124 longjmp (jmp_buf env, int val)
125 {
126   __longjmp (env[0].__jmpbuf, val);
127 }
128 \f
129 /* Define our own version of the internal function used by strerror.  We
130    only provide the messages for some common errors.  This avoids pulling
131    in the whole error list.  */
132
133 char * weak_function
134 __strerror_r (int errnum, char *buf, size_t buflen)
135 {
136   char *msg;
137
138   switch (errnum)
139     {
140     case ENOMEM:
141       msg = (char *) "Cannot allocate memory";
142       break;
143     case EINVAL:
144       msg = (char *) "Invalid argument";
145       break;
146     case ENOENT:
147       msg = (char *) "No such file or directory";
148       break;
149     case EPERM:
150       msg = (char *) "Operation not permitted";
151       break;
152     case EIO:
153       msg = (char *) "Input/output error";
154       break;
155     case EACCES:
156       msg = (char *) "Permission denied";
157       break;
158     default:
159       /* No need to check buffer size, all calls in the dynamic linker
160          provide enough space.  */
161       buf[buflen - 1] = '\0';
162       msg = _itoa_word (errnum, buf + buflen - 1, 10, 0);
163       msg = memcpy (msg - (sizeof ("Error ") - 1), "Error ",
164                     sizeof ("Error ") - 1);
165       break;
166     }
167
168   return msg;
169 }
170 \f
171 #ifndef NDEBUG
172
173 /* Define (weakly) our own assert failure function which doesn't use stdio.
174    If we are linked into the user program (-ldl), the normal __assert_fail
175    defn can override this one.  */
176
177 void weak_function
178 __assert_fail (const char *assertion,
179                const char *file, unsigned int line, const char *function)
180 {
181   char buf[64];
182   buf[sizeof buf - 1] = '\0';
183   _dl_sysdep_fatal ("BUG IN DYNAMIC LINKER ld.so: ",
184                     file, ": ", _itoa_word (line, buf + sizeof buf - 1, 10, 0),
185                     ": ", function ?: "", function ? ": " : "",
186                     "Assertion `", assertion, "' failed!\n",
187                     NULL);
188
189 }
190
191 void weak_function
192 __assert_perror_fail (int errnum,
193                       const char *file, unsigned int line,
194                       const char *function)
195 {
196   char errbuf[64];
197   char buf[64];
198   buf[sizeof buf - 1] = '\0';
199   _dl_sysdep_fatal ("BUG IN DYNAMIC LINKER ld.so: ",
200                     file, ": ", _itoa_word (line, buf + sizeof buf - 1, 10, 0),
201                     ": ", function ?: "", function ? ": " : "",
202                     "Unexpected error: ",
203                     __strerror_r (errnum, errbuf, sizeof (errbuf)), "\n",
204                     NULL);
205
206 }
207
208 #endif
209
210 /* This function is only used in eval.c.  */
211 long int weak_function
212 __strtol_internal (const char *nptr, char **endptr, int base, int group)
213 {
214   unsigned long int result = 0;
215   long int sign = 1;
216
217   while (*nptr == ' ' || *nptr == '\t')
218     ++nptr;
219
220   if (*nptr == '-')
221     {
222       sign = -1;
223       ++nptr;
224     }
225   else if (*nptr == '+')
226     ++nptr;
227
228   if (*nptr < '0' || *nptr > '9')
229     {
230       if (endptr != NULL)
231         *endptr = (char *) nptr;
232       return 0L;
233     }
234
235   assert (base == 0);
236   base = 10;
237   if (*nptr == '0')
238     {
239       if (nptr[1] == 'x' || nptr[1] == 'X')
240         {
241           base = 16;
242           nptr += 2;
243         }
244       else
245         base = 8;
246     }
247
248   while (*nptr >= '0' && *nptr <= '9')
249     {
250       unsigned long int digval = *nptr - '0';
251       if (result > LONG_MAX / 10
252           || (sign > 0 ? result == LONG_MAX / 10 && digval > LONG_MAX % 10
253               : (result == ((unsigned long int) LONG_MAX + 1) / 10
254                  && digval > ((unsigned long int) LONG_MAX + 1) % 10)))
255         {
256           errno = ERANGE;
257           return sign > 0 ? LONG_MAX : LONG_MIN;
258         }
259       result *= base;
260       result += digval;
261       ++nptr;
262     }
263
264   return (long int) result * sign;
265 }
266
267 long int weak_function
268 strtol (const char *nptr, char **endptr, int base)
269 {
270   return __strtol_internal (nptr, endptr, base, 0);
271 }
272
273 unsigned long int weak_function
274 __strtoul_internal (const char *nptr, char **endptr, int base, int group)
275 {
276   unsigned long int result = 0;
277   long int sign = 1;
278
279   while (*nptr == ' ' || *nptr == '\t')
280     ++nptr;
281
282   if (*nptr == '-')
283     {
284       sign = -1;
285       ++nptr;
286     }
287   else if (*nptr == '+')
288     ++nptr;
289
290   if (*nptr < '0' || *nptr > '9')
291     {
292       if (endptr != NULL)
293         *endptr = (char *) nptr;
294       return 0UL;
295     }
296
297   assert (base == 0);
298   base = 10;
299   if (*nptr == '0')
300     {
301       if (nptr[1] == 'x' || nptr[1] == 'X')
302         {
303           base = 16;
304           nptr += 2;
305         }
306       else
307         base = 8;
308     }
309
310   while (*nptr >= '0' && *nptr <= '9')
311     {
312       unsigned long int digval = *nptr - '0';
313       if (result > LONG_MAX / 10
314           || (result == ULONG_MAX / 10 && digval > ULONG_MAX % 10))
315         {
316           errno = ERANGE;
317           return ULONG_MAX;
318         }
319       result *= base;
320       result += digval;
321       ++nptr;
322     }
323
324   return result * sign;
325 }
326
327 unsigned long int weak_function
328 strtoul (const char *nptr, char **endptr, int base)
329 {
330   return (unsigned long int) __strtoul_internal (nptr, endptr, base, 0);
331 }