ldso/include/dl-string.h

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