l4/pkg/uclibc/lib/contrib/uclibc/ldso/include/dl-string.h

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Copyright (C) 2000-2005 by Erik Andersen <andersen@codepoet.org>
   4  *
   5  * GNU Lesser General Public License version 2.1 or later.
   6  */
   7
   8 #ifndef _DL_STRING_H
   9 #define _DL_STRING_H
  10
  11 #include <features.h>
  12
  13 #define __need_NULL
  14 #include <stddef.h>
  15
  16 #include <dl-defs.h> /* for do_rem by dl-sysdep.h */
  17
  18 /* provide some sane defaults */
  19 #ifndef do_rem
  20 # define do_rem(result, n, base) ((result) = (n) % (base))
  21 #endif
  22 #ifndef do_div_10
  23 # define do_div_10(result, remain) ((result) /= 10)
  24 #endif
  25
  26 #ifdef IS_IN_rtld
  27 static __always_inline size_t _dl_strlen(const char *str)
  28 {
  29         register const char *ptr = (char *) str-1;
  30         while (*++ptr)
  31                 ;/* empty */
  32         return (ptr - str);
  33 }
  34
  35 static __always_inline char * _dl_strcat(char *dst, const char *src)
  36 {
  37         register char *ptr = dst-1;
  38
  39         src--;
  40         while (*++ptr)
  41                 ;/* empty */
  42         ptr--;
  43         while ((*++ptr = *++src) != 0)
  44                 ;/* empty */
  45         return dst;
  46 }
  47
  48 static __always_inline char * _dl_strcpy(char *dst, const char *src)
  49 {
  50         register char *ptr = dst;
  51
  52         dst--;src--;
  53         while ((*++dst = *++src) != 0)
  54                 ;/* empty */
  55
  56         return ptr;
  57 }
  58
  59 static __always_inline int _dl_strcmp(const char *s1, const char *s2)
  60 {
  61         register unsigned char c1, c2;
  62         s1--;s2--;
  63         do {
  64                 c1 = (unsigned char) *++s1;
  65                 c2 = (unsigned char) *++s2;
  66                 if (c1 == '\0')
  67                         return c1 - c2;
  68         } while (c1 == c2);
  69
  70         return c1 - c2;
  71 }
  72
  73 static __always_inline char * _dl_strchr(const char *str, int c)
  74 {
  75         register char ch;
  76         str--;
  77         do {
  78                 if ((ch = *++str) == c)
  79                         return (char *) str;
  80         }
  81         while (ch);
  82
  83         return 0;
  84 }
  85
  86 static __always_inline char * _dl_strrchr(const char *str, int c)
  87 {
  88         register char *prev = 0;
  89         register char *ptr = (char *) str-1;
  90
  91         while (*++ptr != '\0') {
  92                 if (*ptr == c)
  93                         prev = ptr;
  94         }
  95         if (c == '\0')
  96                 return(ptr);
  97         return(prev);
  98 }
  99
 100 static __always_inline char * _dl_strstr(const char *s1, const char *s2)
 101 {
 102         register const char *s = s1;
 103         register const char *p = s2;
 104
 105         do {
 106                 if (!*p)
 107                         return (char *) s1;;
 108                 if (*p == *s) {
 109                         ++p;
 110                         ++s;
 111                 } else {
 112                         p = s2;
 113                         if (!*s)
 114                                 return NULL;
 115                         s = ++s1;
 116                 }
 117         } while (1);
 118 }
 119
 120 static __always_inline void * _dl_memcpy(void *dst, const void *src, size_t len)
 121 {
 122         register char *a = dst-1;
 123         register const char *b = src-1;
 124
 125         while (len) {
 126                 *++a = *++b;
 127                 --len;
 128         }
 129         return dst;
 130 }
 131
 132 static __always_inline int _dl_memcmp(const void *s1, const void *s2, size_t len)
 133 {
 134         unsigned char *c1 = (unsigned char *)s1-1;
 135         unsigned char *c2 = (unsigned char *)s2-1;
 136
 137         while (len) {
 138                 if (*++c1 != *++c2)
 139                         return *c1 - *c2;
 140                 len--;
 141         }
 142         return 0;
 143 }
 144
 145 #if defined(__powerpc__)
 146 /* Will generate smaller and faster code due to loop unrolling.*/
 147 static __always_inline void * _dl_memset(void *to, int c, size_t n)
 148 {
 149         unsigned long chunks;
 150         unsigned long *tmp_to;
 151         unsigned char *tmp_char;
 152
 153         chunks = n / 4;
 154         tmp_to = to + n;
 155         c = c << 8 | c;
 156         c = c << 16 | c;
 157         if (!chunks)
 158                 goto lessthan4;
 159         do {
 160                 *--tmp_to = c;
 161         } while (--chunks);
 162 lessthan4:
 163         n = n % 4;
 164         if (!n)
 165                 return to;
 166         tmp_char = (unsigned char *)tmp_to;
 167         do {
 168                 *--tmp_char = c;
 169         } while (--n);
 170         return to;
 171 }
 172 #else
 173 static __always_inline void * _dl_memset(void *str, int c, size_t len)
 174 {
 175         register char *a = str;
 176
 177         while (len--)
 178                 *a++ = c;
 179
 180         return str;
 181 }
 182 #endif
 183
 184 static __always_inline char * _dl_get_last_path_component(char *path)
 185 {
 186         register char *ptr = path-1;
 187
 188         while (*++ptr)
 189                 ;/* empty */
 190
 191         /* strip trailing slashes */
 192         while (ptr != path && *--ptr == '/') {
 193                 *ptr = '\0';
 194         }
 195
 196         /* find last component */
 197         while (ptr != path && *--ptr != '/')
 198                 ;/* empty */
 199         return ptr == path ? ptr : ptr+1;
 200 }
 201 #else /* IS_IN_rtld */
 202 # include <string.h>
 203 # define _dl_strlen strlen
 204 # define _dl_strcat strcat
 205 # define _dl_strcpy strcpy
 206 # define _dl_strcmp strcmp
 207 # define _dl_strrchr strrchr
 208 # define _dl_memcpy memcpy
 209 # define _dl_memcmp memcmp
 210 # define _dl_memset memset
 211 #endif /* IS_IN_rtld */
 212
 213 #if defined IS_IN_rtld || defined __SUPPORT_LD_DEBUG__
 214 /* Early on, we can't call printf, so use this to print out
 215  * numbers using the SEND_STDERR() macro.  Avoid using mod
 216  * or using long division */
 217 static __always_inline char * _dl_simple_ltoa(char *local, unsigned long i)
 218 {
 219         /* 20 digits plus a null terminator should be good for
 220          * 64-bit or smaller ints (2^64 - 1)*/
 221         char *p = &local[22];
 222         *--p = '\0';
 223         do {
 224                 char temp;
 225                 do_rem(temp, i, 10);
 226                 *--p = '0' + temp;
 227                 do_div_10(i, temp);
 228         } while (i > 0);
 229         return p;
 230 }
 231 #endif
 232
 233 #ifdef IS_IN_rtld
 234 static __always_inline char * _dl_simple_ltoahex(char *local, unsigned long i)
 235 {
 236         /* 16 digits plus a leading "0x" plus a null terminator,
 237          * should be good for 64-bit or smaller ints */
 238         char *p = &local[22];
 239         *--p = '\0';
 240         do {
 241                 char temp = i & 0xf;
 242                 if (temp <= 0x09)
 243                         *--p = '0' + temp;
 244                 else
 245                         *--p = 'a' - 0x0a + temp;
 246                 i >>= 4;
 247         } while (i > 0);
 248         *--p = 'x';
 249         *--p = '0';
 250         return p;
 251 }
 252
 253 /* The following macros may be used in dl-startup.c to debug
 254  * ldso before ldso has fixed itself up to make function calls */
 255
 256 /* On some (wierd) arches, none of this stuff works at all, so
 257  * disable the whole lot... */
 258 #if defined(__mips__)
 259
 260 # define SEND_STDERR(X)
 261 # define SEND_ADDRESS_STDERR(X, add_a_newline)
 262 # define SEND_NUMBER_STDERR(X, add_a_newline)
 263
 264 #else
 265
 266 /* On some arches constant strings are referenced through the GOT.
 267  * This requires that load_addr must already be defined... */
 268 #if defined(mc68000)  || defined(__arm__) || defined(__thumb__) || \
 269     defined(__sh__) || defined(__powerpc__) || \
 270     defined(__avr32__) || defined(__xtensa__) || defined(__sparc__) || defined(__microblaze__)
 271 # define CONSTANT_STRING_GOT_FIXUP(X) \
 272         if ((X) < (const char *) load_addr) (X) += load_addr
 273 # define NO_EARLY_SEND_STDERR
 274 #else
 275 # define CONSTANT_STRING_GOT_FIXUP(X)
 276 #endif
 277
 278 #define SEND_STDERR(X) \
 279 { \
 280         const char *tmp1 = (X); \
 281         CONSTANT_STRING_GOT_FIXUP(tmp1); \
 282         _dl_write(2, tmp1, _dl_strlen(tmp1)); \
 283 }
 284
 285 #define SEND_ADDRESS_STDERR(ADR, add_a_newline) \
 286 { \
 287         char tmp[26], v, *tmp2, *tmp1 = tmp; \
 288         unsigned long X = (unsigned long)(ADR); \
 289         CONSTANT_STRING_GOT_FIXUP(tmp1); \
 290         tmp2 = tmp1 + sizeof(tmp); \
 291         *--tmp2 = '\0'; \
 292         if (add_a_newline) *--tmp2 = '\n'; \
 293         do { \
 294                 v = (X) & 0xf; \
 295                 if (v <= 0x09) \
 296                         *--tmp2 = '0' + v; \
 297                 else \
 298                         *--tmp2 = 'a' - 0x0a + v; \
 299                 (X) >>= 4; \
 300         } while ((X) > 0); \
 301         *--tmp2 = 'x'; \
 302         *--tmp2 = '0'; \
 303         _dl_write(2, tmp2, tmp1 - tmp2 + sizeof(tmp) - 1); \
 304 }
 305
 306 #define SEND_NUMBER_STDERR(NUM, add_a_newline) \
 307 { \
 308         char tmp[26], v, *tmp2, *tmp1 = tmp; \
 309         unsigned long X = (unsigned long)(NUM); \
 310         CONSTANT_STRING_GOT_FIXUP(tmp1); \
 311         tmp2 = tmp1 + sizeof(tmp); \
 312         *--tmp2 = '\0'; \
 313         if (add_a_newline) *--tmp2 = '\n'; \
 314         do { \
 315                 do_rem(v, (X), 10); \
 316                 *--tmp2 = '0' + v; \
 317                 do_div_10((X), v); \
 318         } while ((X) > 0); \
 319         _dl_write(2, tmp2, tmp1 - tmp2 + sizeof(tmp) - 1); \
 320 }
 321 #endif
 322
 323 /* Some targets may have to override this to something that doesn't
 324  * reference constant strings through the GOT.  This macro should be
 325  * preferred over SEND_STDERR for constant strings before we complete
 326  * bootstrap.
 327  */
 328 #ifndef SEND_EARLY_STDERR
 329 # define SEND_EARLY_STDERR(S) SEND_STDERR(S)
 330 #else
 331 # define EARLY_STDERR_SPECIAL
 332 #endif
 333
 334 #ifdef __SUPPORT_LD_DEBUG_EARLY__
 335 # define SEND_STDERR_DEBUG(X) SEND_STDERR(X)
 336 # define SEND_EARLY_STDERR_DEBUG(X) SEND_EARLY_STDERR(X)
 337 # define SEND_NUMBER_STDERR_DEBUG(X, add_a_newline) SEND_NUMBER_STDERR(X, add_a_newline)
 338 # define SEND_ADDRESS_STDERR_DEBUG(X, add_a_newline) SEND_ADDRESS_STDERR(X, add_a_newline)
 339 #else
 340 # define SEND_STDERR_DEBUG(X)
 341 # define SEND_EARLY_STDERR_DEBUG(X)
 342 # define SEND_NUMBER_STDERR_DEBUG(X, add_a_newline)
 343 # define SEND_ADDRESS_STDERR_DEBUG(X, add_a_newline)
 344 #endif
 345
 346 #endif /* IS_IN_rtld */
 347
 348 #endif /* _DL_STRING_H */