m68k: update libm test ULPs
[glibc.git] / elf / dl-minimal.c
blobec7fe88d301ffb9972f8ea6bcf095d2fca32627e
1 /* Minimal replacements for basic facilities used in the dynamic linker.
2 Copyright (C) 1995-2015 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
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 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
19 #include <errno.h>
20 #include <limits.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <tls.h>
24 #include <unistd.h>
25 #include <sys/mman.h>
26 #include <sys/param.h>
27 #include <sys/types.h>
28 #include <ldsodefs.h>
29 #include <_itoa.h>
31 #include <assert.h>
33 /* Minimal `malloc' allocator for use while loading shared libraries.
34 No block is ever freed. */
36 static void *alloc_ptr, *alloc_end, *alloc_last_block;
38 /* Declarations of global functions. */
39 extern void weak_function free (void *ptr);
40 extern void * weak_function realloc (void *ptr, size_t n);
41 extern unsigned long int weak_function __strtoul_internal (const char *nptr,
42 char **endptr,
43 int base,
44 int group);
45 extern unsigned long int weak_function strtoul (const char *nptr,
46 char **endptr, int base);
49 /* Allocate an aligned memory block. */
50 void * weak_function
51 __libc_memalign (size_t align, size_t n)
53 if (alloc_end == 0)
55 /* Consume any unused space in the last page of our data segment. */
56 extern int _end attribute_hidden;
57 alloc_ptr = &_end;
58 alloc_end = (void *) 0 + (((alloc_ptr - (void *) 0)
59 + GLRO(dl_pagesize) - 1)
60 & ~(GLRO(dl_pagesize) - 1));
63 /* Make sure the allocation pointer is ideally aligned. */
64 alloc_ptr = (void *) 0 + (((alloc_ptr - (void *) 0) + align - 1)
65 & ~(align - 1));
67 if (alloc_ptr + n >= alloc_end || n >= -(uintptr_t) alloc_ptr)
69 /* Insufficient space left; allocate another page. */
70 caddr_t page;
71 size_t nup = (n + GLRO(dl_pagesize) - 1) & ~(GLRO(dl_pagesize) - 1);
72 if (__glibc_unlikely (nup == 0))
74 if (n)
75 return NULL;
76 nup = GLRO(dl_pagesize);
78 page = __mmap (0, nup, PROT_READ|PROT_WRITE,
79 MAP_ANON|MAP_PRIVATE, -1, 0);
80 if (page == MAP_FAILED)
81 return NULL;
82 if (page != alloc_end)
83 alloc_ptr = page;
84 alloc_end = page + nup;
87 alloc_last_block = (void *) alloc_ptr;
88 alloc_ptr += n;
89 return alloc_last_block;
92 void * weak_function
93 malloc (size_t n)
95 return __libc_memalign (sizeof (double), n);
98 /* We use this function occasionally since the real implementation may
99 be optimized when it can assume the memory it returns already is
100 set to NUL. */
101 void * weak_function
102 calloc (size_t nmemb, size_t size)
104 /* New memory from the trivial malloc above is always already cleared.
105 (We make sure that's true in the rare occasion it might not be,
106 by clearing memory in free, below.) */
107 size_t bytes = nmemb * size;
109 #define HALF_SIZE_T (((size_t) 1) << (8 * sizeof (size_t) / 2))
110 if (__builtin_expect ((nmemb | size) >= HALF_SIZE_T, 0)
111 && size != 0 && bytes / size != nmemb)
112 return NULL;
114 return malloc (bytes);
117 /* This will rarely be called. */
118 void weak_function
119 free (void *ptr)
121 /* We can free only the last block allocated. */
122 if (ptr == alloc_last_block)
124 /* Since this is rare, we clear the freed block here
125 so that calloc can presume malloc returns cleared memory. */
126 memset (alloc_last_block, '\0', alloc_ptr - alloc_last_block);
127 alloc_ptr = alloc_last_block;
131 /* This is only called with the most recent block returned by malloc. */
132 void * weak_function
133 realloc (void *ptr, size_t n)
135 if (ptr == NULL)
136 return malloc (n);
137 assert (ptr == alloc_last_block);
138 size_t old_size = alloc_ptr - alloc_last_block;
139 alloc_ptr = alloc_last_block;
140 void *new = malloc (n);
141 return new != ptr ? memcpy (new, ptr, old_size) : new;
144 /* Avoid signal frobnication in setjmp/longjmp. Keeps things smaller. */
146 #include <setjmp.h>
148 int weak_function
149 __sigjmp_save (sigjmp_buf env, int savemask __attribute__ ((unused)))
151 env[0].__mask_was_saved = 0;
152 return 0;
155 /* Define our own version of the internal function used by strerror. We
156 only provide the messages for some common errors. This avoids pulling
157 in the whole error list. */
159 char * weak_function
160 __strerror_r (int errnum, char *buf, size_t buflen)
162 char *msg;
164 switch (errnum)
166 case ENOMEM:
167 msg = (char *) "Cannot allocate memory";
168 break;
169 case EINVAL:
170 msg = (char *) "Invalid argument";
171 break;
172 case ENOENT:
173 msg = (char *) "No such file or directory";
174 break;
175 case EPERM:
176 msg = (char *) "Operation not permitted";
177 break;
178 case EIO:
179 msg = (char *) "Input/output error";
180 break;
181 case EACCES:
182 msg = (char *) "Permission denied";
183 break;
184 default:
185 /* No need to check buffer size, all calls in the dynamic linker
186 provide enough space. */
187 buf[buflen - 1] = '\0';
188 msg = _itoa (errnum, buf + buflen - 1, 10, 0);
189 msg = memcpy (msg - (sizeof ("Error ") - 1), "Error ",
190 sizeof ("Error ") - 1);
191 break;
194 return msg;
197 void
198 __libc_fatal (const char *message)
200 _dl_fatal_printf ("%s", message);
202 rtld_hidden_def (__libc_fatal)
204 void
205 __attribute__ ((noreturn))
206 __chk_fail (void)
208 _exit (127);
210 rtld_hidden_def (__chk_fail)
212 #ifndef NDEBUG
213 /* Define (weakly) our own assert failure function which doesn't use stdio.
214 If we are linked into the user program (-ldl), the normal __assert_fail
215 defn can override this one. */
217 void weak_function
218 __assert_fail (const char *assertion,
219 const char *file, unsigned int line, const char *function)
221 _dl_fatal_printf ("\
222 Inconsistency detected by ld.so: %s: %u: %s%sAssertion `%s' failed!\n",
223 file, line, function ?: "", function ? ": " : "",
224 assertion);
227 rtld_hidden_weak (__assert_fail)
229 void weak_function
230 __assert_perror_fail (int errnum,
231 const char *file, unsigned int line,
232 const char *function)
234 char errbuf[400];
235 _dl_fatal_printf ("\
236 Inconsistency detected by ld.so: %s: %u: %s%sUnexpected error: %s.\n",
237 file, line, function ?: "", function ? ": " : "",
238 __strerror_r (errnum, errbuf, sizeof errbuf));
241 rtld_hidden_weak (__assert_perror_fail)
242 #endif
244 unsigned long int weak_function
245 __strtoul_internal (const char *nptr, char **endptr, int base, int group)
247 unsigned long int result = 0;
248 long int sign = 1;
249 unsigned max_digit;
251 while (*nptr == ' ' || *nptr == '\t')
252 ++nptr;
254 if (*nptr == '-')
256 sign = -1;
257 ++nptr;
259 else if (*nptr == '+')
260 ++nptr;
262 if (*nptr < '0' || *nptr > '9')
264 if (endptr != NULL)
265 *endptr = (char *) nptr;
266 return 0UL;
269 assert (base == 0);
270 base = 10;
271 max_digit = 9;
272 if (*nptr == '0')
274 if (nptr[1] == 'x' || nptr[1] == 'X')
276 base = 16;
277 nptr += 2;
279 else
281 base = 8;
282 max_digit = 7;
286 while (1)
288 unsigned long int digval;
289 if (*nptr >= '0' && *nptr <= '0' + max_digit)
290 digval = *nptr - '0';
291 else if (base == 16)
293 if (*nptr >= 'a' && *nptr <= 'f')
294 digval = *nptr - 'a' + 10;
295 else if (*nptr >= 'A' && *nptr <= 'F')
296 digval = *nptr - 'A' + 10;
297 else
298 break;
300 else
301 break;
303 if (result > ULONG_MAX / base
304 || (result == ULONG_MAX / base && digval > ULONG_MAX % base))
306 errno = ERANGE;
307 if (endptr != NULL)
308 *endptr = (char *) nptr;
309 return ULONG_MAX;
311 result *= base;
312 result += digval;
313 ++nptr;
316 if (endptr != NULL)
317 *endptr = (char *) nptr;
318 return result * sign;
322 #undef _itoa
323 /* We always use _itoa instead of _itoa_word in ld.so since the former
324 also has to be present and it is never about speed when these
325 functions are used. */
326 char *
327 _itoa (value, buflim, base, upper_case)
328 unsigned long long int value;
329 char *buflim;
330 unsigned int base;
331 int upper_case;
333 assert (! upper_case);
336 *--buflim = _itoa_lower_digits[value % base];
337 while ((value /= base) != 0);
339 return buflim;
342 /* The '_itoa_lower_digits' variable in libc.so is able to handle bases
343 up to 36. We don't need this here. */
344 const char _itoa_lower_digits[16] = "0123456789abcdef";
345 rtld_hidden_data_def (_itoa_lower_digits)
347 /* The following is not a complete strsep implementation. It cannot
348 handle empty delimiter strings. But this isn't necessary for the
349 execution of ld.so. */
350 #undef strsep
351 #undef __strsep
352 char *
353 __strsep (char **stringp, const char *delim)
355 char *begin;
357 assert (delim[0] != '\0');
359 begin = *stringp;
360 if (begin != NULL)
362 char *end = begin;
364 while (*end != '\0' || (end = NULL))
366 const char *dp = delim;
369 if (*dp == *end)
370 break;
371 while (*++dp != '\0');
373 if (*dp != '\0')
375 *end++ = '\0';
376 break;
379 ++end;
382 *stringp = end;
385 return begin;
387 weak_alias (__strsep, strsep)
388 strong_alias (__strsep, __strsep_g)