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 _LINUX_STRING_H_
   9 #define _LINUX_STRING_H_
  10
  11 #include <dl-sysdep.h> /* for do_rem */
  12 #include <features.h>
  13
  14 /* provide some sane defaults */
  15 #ifndef do_rem
  16 # define do_rem(result, n, base) ((result) = (n) % (base))
  17 #endif
  18 #ifndef do_div_10
  19 # define do_div_10(result, remain) ((result) /= 10)
  20 #endif
  21
  22 #ifndef NULL
  23 #define NULL ((void *) 0)
  24 #endif
  25
  26 #ifndef IS_IN_libdl
  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_libdl */
 202 # define _dl_strlen strlen
 203 # define _dl_strcat strcat
 204 # define _dl_strcpy strcpy
 205 # define _dl_strcmp strcmp
 206 # define _dl_strrchr strrchr
 207 # define _dl_memcpy memcpy
 208 # define _dl_memcmp memcmp
 209 # define _dl_memset memset
 210 #endif /* IS_IN_libdl */
 211
 212 /* Early on, we can't call printf, so use this to print out
 213  * numbers using the SEND_STDERR() macro.  Avoid using mod
 214  * or using long division */
 215 static __always_inline char * _dl_simple_ltoa(char *local, unsigned long i)
 216 {
 217         /* 20 digits plus a null terminator should be good for
 218          * 64-bit or smaller ints (2^64 - 1)*/
 219         char *p = &local[22];
 220         *--p = '\0';
 221         do {
 222                 char temp;
 223                 do_rem(temp, i, 10);
 224                 *--p = '0' + temp;
 225                 do_div_10(i, temp);
 226         } while (i > 0);
 227         return p;
 228 }
 229
 230 static __always_inline char * _dl_simple_ltoahex(char *local, unsigned long i)
 231 {
 232         /* 16 digits plus a leading "0x" plus a null terminator,
 233          * should be good for 64-bit or smaller ints */
 234         char *p = &local[22];
 235         *--p = '\0';
 236         do {
 237                 char temp = i & 0xf;
 238                 if (temp <= 0x09)
 239                         *--p = '0' + temp;
 240                 else
 241                         *--p = 'a' - 0x0a + temp;
 242                 i >>= 4;
 243         } while (i > 0);
 244         *--p = 'x';
 245         *--p = '0';
 246         return p;
 247 }
 248
 249
 250
 251
 252 /* The following macros may be used in dl-startup.c to debug
 253  * ldso before ldso has fixed itself up to make function calls */
 254
 255 /* On some (wierd) arches, none of this stuff works at all, so
 256  * disable the whole lot... */
 257 #if defined(__mips__)
 258
 259 # define SEND_STDERR(X)
 260 # define SEND_ADDRESS_STDERR(X, add_a_newline)
 261 # define SEND_NUMBER_STDERR(X, add_a_newline)
 262
 263 #else
 264
 265 /* On some arches constant strings are referenced through the GOT.
 266  * This requires that load_addr must already be defined... */
 267 #if defined(mc68000)  || defined(__arm__) || defined(__thumb__) || \
 268     defined(__sh__) || defined(__powerpc__) || \
 269     defined(__avr32__) || defined(__xtensa__) || defined(__sparc__) || defined(__microblaze__)
 270 # define CONSTANT_STRING_GOT_FIXUP(X) \
 271         if ((X) < (const char *) load_addr) (X) += load_addr
 272 # define NO_EARLY_SEND_STDERR
 273 #else
 274 # define CONSTANT_STRING_GOT_FIXUP(X)
 275 #endif
 276
 277 #define SEND_STDERR(X) \
 278 { \
 279         const char *tmp1 = (X); \
 280         CONSTANT_STRING_GOT_FIXUP(tmp1); \
 281         _dl_write(2, tmp1, _dl_strlen(tmp1)); \
 282 }
 283
 284 #define SEND_ADDRESS_STDERR(ADR, add_a_newline) \
 285 { \
 286         char tmp[26], v, *tmp2, *tmp1 = tmp; \
 287         unsigned long X = (unsigned long)(ADR); \
 288         CONSTANT_STRING_GOT_FIXUP(tmp1); \
 289         tmp2 = tmp1 + sizeof(tmp); \
 290         *--tmp2 = '\0'; \
 291         if (add_a_newline) *--tmp2 = '\n'; \
 292         do { \
 293                 v = (X) & 0xf; \
 294                 if (v <= 0x09) \
 295                         *--tmp2 = '0' + v; \
 296                 else \
 297                         *--tmp2 = 'a' - 0x0a + v; \
 298                 (X) >>= 4; \
 299         } while ((X) > 0); \
 300         *--tmp2 = 'x'; \
 301         *--tmp2 = '0'; \
 302         _dl_write(2, tmp2, tmp1 - tmp2 + sizeof(tmp) - 1); \
 303 }
 304
 305 #define SEND_NUMBER_STDERR(NUM, add_a_newline) \
 306 { \
 307         char tmp[26], v, *tmp2, *tmp1 = tmp; \
 308         unsigned long X = (unsigned long)(NUM); \
 309         CONSTANT_STRING_GOT_FIXUP(tmp1); \
 310         tmp2 = tmp1 + sizeof(tmp); \
 311         *--tmp2 = '\0'; \
 312         if (add_a_newline) *--tmp2 = '\n'; \
 313         do { \
 314                 do_rem(v, (X), 10); \
 315                 *--tmp2 = '0' + v; \
 316                 do_div_10((X), v); \
 317         } while ((X) > 0); \
 318         _dl_write(2, tmp2, tmp1 - tmp2 + sizeof(tmp) - 1); \
 319 }
 320 #endif
 321
 322 /* Some targets may have to override this to something that doesn't
 323  * reference constant strings through the GOT.  This macro should be
 324  * preferred over SEND_STDERR for constant strings before we complete
 325  * bootstrap.
 326  */
 327 #ifndef SEND_EARLY_STDERR
 328 # define SEND_EARLY_STDERR(S) SEND_STDERR(S)
 329 #else
 330 # define EARLY_STDERR_SPECIAL
 331 #endif
 332
 333 #ifdef __SUPPORT_LD_DEBUG_EARLY__
 334 # define SEND_STDERR_DEBUG(X) SEND_STDERR(X)
 335 # define SEND_EARLY_STDERR_DEBUG(X) SEND_EARLY_STDERR(X)
 336 # define SEND_NUMBER_STDERR_DEBUG(X, add_a_newline) SEND_NUMBER_STDERR(X, add_a_newline)
 337 # define SEND_ADDRESS_STDERR_DEBUG(X, add_a_newline) SEND_ADDRESS_STDERR(X, add_a_newline)
 338 #else
 339 # define SEND_STDERR_DEBUG(X)
 340 # define SEND_EARLY_STDERR_DEBUG(X)
 341 # define SEND_NUMBER_STDERR_DEBUG(X, add_a_newline)
 342 # define SEND_ADDRESS_STDERR_DEBUG(X, add_a_newline)
 343 #endif
 344
 345 #endif