elf/dl-sysdep.c

   1 /* Operating system support for run-time dynamic linker.  Generic Unix version.
   2    Copyright (C) 1995-2012 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 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.
   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    Lesser General Public License for more details.
  14
  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/>.  */
  18
  19 /* We conditionalize the whole of this file rather than simply eliding it
  20    from the static build, because other sysdeps/ versions of this file
  21    might define things needed by a static build.  */
  22
  23 #ifdef SHARED
  24
  25 #include <assert.h>
  26 #include <elf.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <libintl.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <sys/mman.h>
  36 #include <ldsodefs.h>
  37 #include <_itoa.h>
  38 #include <fpu_control.h>
  39
  40 #include <entry.h>
  41 #include <dl-machine.h>
  42 #include <dl-procinfo.h>
  43 #include <dl-osinfo.h>
  44 #include <hp-timing.h>
  45 #include <tls.h>
  46
  47 #ifdef _DL_FIRST_PLATFORM
  48 # define _DL_FIRST_EXTRA (_DL_FIRST_PLATFORM + _DL_PLATFORMS_COUNT)
  49 #else
  50 # define _DL_FIRST_EXTRA _DL_HWCAP_COUNT
  51 #endif
  52
  53 extern char **_environ attribute_hidden;
  54 extern char _end[] attribute_hidden;
  55
  56 /* Protect SUID program against misuse of file descriptors.  */
  57 extern void __libc_check_standard_fds (void);
  58
  59 #ifdef NEED_DL_BASE_ADDR
  60 ElfW(Addr) _dl_base_addr;
  61 #endif
  62 int __libc_enable_secure attribute_relro = 0;
  63 INTVARDEF(__libc_enable_secure)
  64 int __libc_multiple_libcs = 0;  /* Defining this here avoids the inclusion
  65                                    of init-first.  */
  66 /* This variable contains the lowest stack address ever used.  */
  67 void *__libc_stack_end attribute_relro = NULL;
  68 rtld_hidden_data_def(__libc_stack_end)
  69 void *_dl_random attribute_relro = NULL;
  70
  71 #ifndef DL_FIND_ARG_COMPONENTS
  72 # define DL_FIND_ARG_COMPONENTS(cookie, argc, argv, envp, auxp) \
  73   do {                                                                        \
  74     void **_tmp;                                                              \
  75     (argc) = *(long int *) cookie;                                            \
  76     (argv) = (char **) ((long int *) cookie + 1);                             \
  77     (envp) = (argv) + (argc) + 1;                                             \
  78     for (_tmp = (void **) (envp); *_tmp; ++_tmp)                              \
  79       continue;                                                               \
  80     (auxp) = (void *) ++_tmp;                                                 \
  81   } while (0)
  82 #endif
  83
  84 #ifndef DL_STACK_END
  85 # define DL_STACK_END(cookie) ((void *) (cookie))
  86 #endif
  87
  88 ElfW(Addr)
  89 _dl_sysdep_start (void **start_argptr,
  90                   void (*dl_main) (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
  91                                    ElfW(Addr) *user_entry, ElfW(auxv_t) *auxv))
  92 {
  93   const ElfW(Phdr) *phdr = NULL;
  94   ElfW(Word) phnum = 0;
  95   ElfW(Addr) user_entry;
  96   ElfW(auxv_t) *av;
  97 #ifdef HAVE_AUX_SECURE
  98 # define set_seen(tag) (tag)    /* Evaluate for the side effects.  */
  99 # define set_seen_secure() ((void) 0)
 100 #else
 101   uid_t uid = 0;
 102   gid_t gid = 0;
 103   unsigned int seen = 0;
 104 # define set_seen_secure() (seen = -1)
 105 # ifdef HAVE_AUX_XID
 106 #  define set_seen(tag) (tag)   /* Evaluate for the side effects.  */
 107 # else
 108 #  define M(type) (1 << (type))
 109 #  define set_seen(tag) seen |= M ((tag)->a_type)
 110 # endif
 111 #endif
 112 #ifdef NEED_DL_SYSINFO
 113   uintptr_t new_sysinfo = 0;
 114 #endif
 115
 116   __libc_stack_end = DL_STACK_END (start_argptr);
 117   DL_FIND_ARG_COMPONENTS (start_argptr, _dl_argc, INTUSE(_dl_argv), _environ,
 118                           GLRO(dl_auxv));
 119
 120   user_entry = (ElfW(Addr)) ENTRY_POINT;
 121   GLRO(dl_platform) = NULL; /* Default to nothing known about the platform.  */
 122
 123   for (av = GLRO(dl_auxv); av->a_type != AT_NULL; set_seen (av++))
 124     switch (av->a_type)
 125       {
 126       case AT_PHDR:
 127         phdr = (void *) av->a_un.a_val;
 128         break;
 129       case AT_PHNUM:
 130         phnum = av->a_un.a_val;
 131         break;
 132       case AT_PAGESZ:
 133         GLRO(dl_pagesize) = av->a_un.a_val;
 134         break;
 135       case AT_ENTRY:
 136         user_entry = av->a_un.a_val;
 137         break;
 138 #ifdef NEED_DL_BASE_ADDR
 139       case AT_BASE:
 140         _dl_base_addr = av->a_un.a_val;
 141         break;
 142 #endif
 143 #ifndef HAVE_AUX_SECURE
 144       case AT_UID:
 145       case AT_EUID:
 146         uid ^= av->a_un.a_val;
 147         break;
 148       case AT_GID:
 149       case AT_EGID:
 150         gid ^= av->a_un.a_val;
 151         break;
 152 #endif
 153       case AT_SECURE:
 154 #ifndef HAVE_AUX_SECURE
 155         seen = -1;
 156 #endif
 157         INTUSE(__libc_enable_secure) = av->a_un.a_val;
 158         break;
 159       case AT_PLATFORM:
 160         GLRO(dl_platform) = (void *) av->a_un.a_val;
 161         break;
 162       case AT_HWCAP:
 163         GLRO(dl_hwcap) = (unsigned long int) av->a_un.a_val;
 164         break;
 165       case AT_CLKTCK:
 166         GLRO(dl_clktck) = av->a_un.a_val;
 167         break;
 168       case AT_FPUCW:
 169         GLRO(dl_fpu_control) = av->a_un.a_val;
 170         break;
 171 #ifdef NEED_DL_SYSINFO
 172       case AT_SYSINFO:
 173         new_sysinfo = av->a_un.a_val;
 174         break;
 175 #endif
 176 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
 177       case AT_SYSINFO_EHDR:
 178         GLRO(dl_sysinfo_dso) = (void *) av->a_un.a_val;
 179         break;
 180 #endif
 181       case AT_RANDOM:
 182         _dl_random = (void *) av->a_un.a_val;
 183         break;
 184 #ifdef DL_PLATFORM_AUXV
 185       DL_PLATFORM_AUXV
 186 #endif
 187       }
 188
 189 #ifndef HAVE_AUX_SECURE
 190   if (seen != -1)
 191     {
 192       /* Fill in the values we have not gotten from the kernel through the
 193          auxiliary vector.  */
 194 # ifndef HAVE_AUX_XID
 195 #  define SEE(UID, var, uid) \
 196    if ((seen & M (AT_##UID)) == 0) var ^= __get##uid ()
 197       SEE (UID, uid, uid);
 198       SEE (EUID, uid, euid);
 199       SEE (GID, gid, gid);
 200       SEE (EGID, gid, egid);
 201 # endif
 202
 203       /* If one of the two pairs of IDs does not match this is a setuid
 204          or setgid run.  */
 205       INTUSE(__libc_enable_secure) = uid | gid;
 206     }
 207 #endif
 208
 209 #ifndef HAVE_AUX_PAGESIZE
 210   if (GLRO(dl_pagesize) == 0)
 211     GLRO(dl_pagesize) = __getpagesize ();
 212 #endif
 213
 214 #if defined NEED_DL_SYSINFO
 215   /* Only set the sysinfo value if we also have the vsyscall DSO.  */
 216   if (GLRO(dl_sysinfo_dso) != 0 && new_sysinfo)
 217     GLRO(dl_sysinfo) = new_sysinfo;
 218 #endif
 219
 220 #ifdef DL_SYSDEP_INIT
 221   DL_SYSDEP_INIT;
 222 #endif
 223
 224 #ifdef DL_PLATFORM_INIT
 225   DL_PLATFORM_INIT;
 226 #endif
 227
 228   /* Determine the length of the platform name.  */
 229   if (GLRO(dl_platform) != NULL)
 230     GLRO(dl_platformlen) = strlen (GLRO(dl_platform));
 231
 232   if (__sbrk (0) == _end)
 233     /* The dynamic linker was run as a program, and so the initial break
 234        starts just after our bss, at &_end.  The malloc in dl-minimal.c
 235        will consume the rest of this page, so tell the kernel to move the
 236        break up that far.  When the user program examines its break, it
 237        will see this new value and not clobber our data.  */
 238     __sbrk (GLRO(dl_pagesize)
 239             - ((_end - (char *) 0) & (GLRO(dl_pagesize) - 1)));
 240
 241   /* If this is a SUID program we make sure that FDs 0, 1, and 2 are
 242      allocated.  If necessary we are doing it ourself.  If it is not
 243      possible we stop the program.  */
 244   if (__builtin_expect (INTUSE(__libc_enable_secure), 0))
 245     __libc_check_standard_fds ();
 246
 247   (*dl_main) (phdr, phnum, &user_entry, GLRO(dl_auxv));
 248   return user_entry;
 249 }
 250
 251 void
 252 internal_function
 253 _dl_sysdep_start_cleanup (void)
 254 {
 255 }
 256
 257 void
 258 internal_function
 259 _dl_show_auxv (void)
 260 {
 261   char buf[64];
 262   ElfW(auxv_t) *av;
 263
 264   /* Terminate string.  */
 265   buf[63] = '\0';
 266
 267   /* The following code assumes that the AT_* values are encoded
 268      starting from 0 with AT_NULL, 1 for AT_IGNORE, and all other values
 269      close by (otherwise the array will be too large).  In case we have
 270      to support a platform where these requirements are not fulfilled
 271      some alternative implementation has to be used.  */
 272   for (av = GLRO(dl_auxv); av->a_type != AT_NULL; ++av)
 273     {
 274       static const struct
 275       {
 276         const char label[17];
 277         enum { unknown = 0, dec, hex, str, ignore } form : 8;
 278       } auxvars[] =
 279         {
 280           [AT_EXECFD - 2] =             { "EXECFD:       ", dec },
 281           [AT_EXECFN - 2] =             { "EXECFN:       ", str },
 282           [AT_PHDR - 2] =               { "PHDR:         0x", hex },
 283           [AT_PHENT - 2] =              { "PHENT:        ", dec },
 284           [AT_PHNUM - 2] =              { "PHNUM:        ", dec },
 285           [AT_PAGESZ - 2] =             { "PAGESZ:       ", dec },
 286           [AT_BASE - 2] =               { "BASE:         0x", hex },
 287           [AT_FLAGS - 2] =              { "FLAGS:        0x", hex },
 288           [AT_ENTRY - 2] =              { "ENTRY:        0x", hex },
 289           [AT_NOTELF - 2] =             { "NOTELF:       ", hex },
 290           [AT_UID - 2] =                { "UID:          ", dec },
 291           [AT_EUID - 2] =               { "EUID:         ", dec },
 292           [AT_GID - 2] =                { "GID:          ", dec },
 293           [AT_EGID - 2] =               { "EGID:         ", dec },
 294           [AT_PLATFORM - 2] =           { "PLATFORM:     ", str },
 295           [AT_HWCAP - 2] =              { "HWCAP:        ", hex },
 296           [AT_CLKTCK - 2] =             { "CLKTCK:       ", dec },
 297           [AT_FPUCW - 2] =              { "FPUCW:        ", hex },
 298           [AT_DCACHEBSIZE - 2] =        { "DCACHEBSIZE:  0x", hex },
 299           [AT_ICACHEBSIZE - 2] =        { "ICACHEBSIZE:  0x", hex },
 300           [AT_UCACHEBSIZE - 2] =        { "UCACHEBSIZE:  0x", hex },
 301           [AT_IGNOREPPC - 2] =          { "IGNOREPPC", ignore },
 302           [AT_SECURE - 2] =             { "SECURE:       ", dec },
 303           [AT_BASE_PLATFORM - 2] =      { "BASE_PLATFORM:", str },
 304           [AT_SYSINFO - 2] =            { "SYSINFO:      0x", hex },
 305           [AT_SYSINFO_EHDR - 2] =       { "SYSINFO_EHDR: 0x", hex },
 306           [AT_RANDOM - 2] =             { "RANDOM:       0x", hex },
 307         };
 308       unsigned int idx = (unsigned int) (av->a_type - 2);
 309
 310       if ((unsigned int) av->a_type < 2u
 311           || (idx < sizeof (auxvars) / sizeof (auxvars[0])
 312               && auxvars[idx].form == ignore))
 313         continue;
 314
 315       assert (AT_NULL == 0);
 316       assert (AT_IGNORE == 1);
 317
 318       if (av->a_type == AT_HWCAP)
 319         {
 320           /* This is handled special.  */
 321           if (_dl_procinfo (av->a_un.a_val) == 0)
 322             continue;
 323         }
 324
 325       if (idx < sizeof (auxvars) / sizeof (auxvars[0])
 326           && auxvars[idx].form != unknown)
 327         {
 328           const char *val = (char *) av->a_un.a_val;
 329
 330           if (__builtin_expect (auxvars[idx].form, dec) == dec)
 331             val = _itoa ((unsigned long int) av->a_un.a_val,
 332                          buf + sizeof buf - 1, 10, 0);
 333           else if (__builtin_expect (auxvars[idx].form, hex) == hex)
 334             val = _itoa ((unsigned long int) av->a_un.a_val,
 335                          buf + sizeof buf - 1, 16, 0);
 336
 337           _dl_printf ("AT_%s%s\n", auxvars[idx].label, val);
 338
 339           continue;
 340         }
 341
 342       /* Unknown value: print a generic line.  */
 343       char buf2[17];
 344       buf2[sizeof (buf2) - 1] = '\0';
 345       const char *val2 = _itoa ((unsigned long int) av->a_un.a_val,
 346                                 buf2 + sizeof buf2 - 1, 16, 0);
 347       const char *val =  _itoa ((unsigned long int) av->a_type,
 348                                 buf + sizeof buf - 1, 16, 0);
 349       _dl_printf ("AT_??? (0x%s): 0x%s\n", val, val2);
 350     }
 351 }
 352
 353
 354 /* Return an array of useful/necessary hardware capability names.  */
 355 const struct r_strlenpair *
 356 internal_function
 357 _dl_important_hwcaps (const char *platform, size_t platform_len, size_t *sz,
 358                       size_t *max_capstrlen)
 359 {
 360   /* Determine how many important bits are set.  */
 361   uint64_t masked = GLRO(dl_hwcap) & GLRO(dl_hwcap_mask);
 362   size_t cnt = platform != NULL;
 363   size_t n, m;
 364   size_t total;
 365   struct r_strlenpair *temp;
 366   struct r_strlenpair *result;
 367   struct r_strlenpair *rp;
 368   char *cp;
 369
 370   /* Count the number of bits set in the masked value.  */
 371   for (n = 0; (~((1ULL << n) - 1) & masked) != 0; ++n)
 372     if ((masked & (1ULL << n)) != 0)
 373       ++cnt;
 374
 375 #if (defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO) && defined SHARED
 376   /* The system-supplied DSO can contain a note of type 2, vendor "GNU".
 377      This gives us a list of names to treat as fake hwcap bits.  */
 378
 379   const char *dsocaps = NULL;
 380   size_t dsocapslen = 0;
 381   if (GLRO(dl_sysinfo_map) != NULL)
 382     {
 383       const ElfW(Phdr) *const phdr = GLRO(dl_sysinfo_map)->l_phdr;
 384       const ElfW(Word) phnum = GLRO(dl_sysinfo_map)->l_phnum;
 385       for (uint_fast16_t i = 0; i < phnum; ++i)
 386         if (phdr[i].p_type == PT_NOTE)
 387           {
 388             const ElfW(Addr) start = (phdr[i].p_vaddr
 389                                       + GLRO(dl_sysinfo_map)->l_addr);
 390             const struct
 391             {
 392               ElfW(Word) vendorlen;
 393               ElfW(Word) datalen;
 394               ElfW(Word) type;
 395             } *note = (const void *) start;
 396             while ((ElfW(Addr)) (note + 1) - start < phdr[i].p_memsz)
 397               {
 398 #define ROUND(len) (((len) + sizeof (ElfW(Word)) - 1) & -sizeof (ElfW(Word)))
 399                 if (note->type == NT_GNU_HWCAP
 400                     && note->vendorlen == sizeof "GNU"
 401                     && !memcmp ((note + 1), "GNU", sizeof "GNU")
 402                     && note->datalen > 2 * sizeof (ElfW(Word)) + 2)
 403                   {
 404                     const ElfW(Word) *p = ((const void *) (note + 1)
 405                                            + ROUND (sizeof "GNU"));
 406                     cnt += *p++;
 407                     ++p;        /* Skip mask word.  */
 408                     dsocaps = (const char *) p;
 409                     dsocapslen = note->datalen - sizeof *p * 2;
 410                     break;
 411                   }
 412                 note = ((const void *) (note + 1)
 413                         + ROUND (note->vendorlen) + ROUND (note->datalen));
 414 #undef ROUND
 415               }
 416             if (dsocaps != NULL)
 417               break;
 418           }
 419     }
 420 #endif
 421
 422   /* For TLS enabled builds always add 'tls'.  */
 423   ++cnt;
 424
 425   /* Create temporary data structure to generate result table.  */
 426   temp = (struct r_strlenpair *) alloca (cnt * sizeof (*temp));
 427   m = 0;
 428 #if (defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO) && defined SHARED
 429   if (dsocaps != NULL)
 430     {
 431       const ElfW(Word) mask = ((const ElfW(Word) *) dsocaps)[-1];
 432       GLRO(dl_hwcap) |= (uint64_t) mask << _DL_FIRST_EXTRA;
 433       /* Note that we add the dsocaps to the set already chosen by the
 434          LD_HWCAP_MASK environment variable (or default HWCAP_IMPORTANT).
 435          So there is no way to request ignoring an OS-supplied dsocap
 436          string and bit like you can ignore an OS-supplied HWCAP bit.  */
 437       GLRO(dl_hwcap_mask) |= (uint64_t) mask << _DL_FIRST_EXTRA;
 438       size_t len;
 439       for (const char *p = dsocaps; p < dsocaps + dsocapslen; p += len + 1)
 440         {
 441           uint_fast8_t bit = *p++;
 442           len = strlen (p);
 443
 444           /* Skip entries that are not enabled in the mask word.  */
 445           if (__builtin_expect (mask & ((ElfW(Word)) 1 << bit), 1))
 446             {
 447               temp[m].str = p;
 448               temp[m].len = len;
 449               ++m;
 450             }
 451           else
 452             --cnt;
 453         }
 454     }
 455 #endif
 456   for (n = 0; masked != 0; ++n)
 457     if ((masked & (1ULL << n)) != 0)
 458       {
 459         temp[m].str = _dl_hwcap_string (n);
 460         temp[m].len = strlen (temp[m].str);
 461         masked ^= 1ULL << n;
 462         ++m;
 463       }
 464   if (platform != NULL)
 465     {
 466       temp[m].str = platform;
 467       temp[m].len = platform_len;
 468       ++m;
 469     }
 470
 471   temp[m].str = "tls";
 472   temp[m].len = 3;
 473   ++m;
 474
 475   assert (m == cnt);
 476
 477   /* Determine the total size of all strings together.  */
 478   if (cnt == 1)
 479     total = temp[0].len + 1;
 480   else
 481     {
 482       total = temp[0].len + temp[cnt - 1].len + 2;
 483       if (cnt > 2)
 484         {
 485           total <<= 1;
 486           for (n = 1; n + 1 < cnt; ++n)
 487             total += temp[n].len + 1;
 488           if (cnt > 3
 489               && (cnt >= sizeof (size_t) * 8
 490                   || total + (sizeof (*result) << 3)
 491                      >= (1UL << (sizeof (size_t) * 8 - cnt + 3))))
 492             _dl_signal_error (ENOMEM, NULL, NULL,
 493                               N_("cannot create capability list"));
 494
 495           total <<= cnt - 3;
 496         }
 497     }
 498
 499   /* The result structure: we use a very compressed way to store the
 500      various combinations of capability names.  */
 501   *sz = 1 << cnt;
 502   result = (struct r_strlenpair *) malloc (*sz * sizeof (*result) + total);
 503   if (result == NULL)
 504     _dl_signal_error (ENOMEM, NULL, NULL,
 505                       N_("cannot create capability list"));
 506
 507   if (cnt == 1)
 508     {
 509       result[0].str = (char *) (result + *sz);
 510       result[0].len = temp[0].len + 1;
 511       result[1].str = (char *) (result + *sz);
 512       result[1].len = 0;
 513       cp = __mempcpy ((char *) (result + *sz), temp[0].str, temp[0].len);
 514       *cp = '/';
 515       *sz = 2;
 516       *max_capstrlen = result[0].len;
 517
 518       return result;
 519     }
 520
 521   /* Fill in the information.  This follows the following scheme
 522      (indeces from TEMP for four strings):
 523         entry #0: 0, 1, 2, 3    binary: 1111
 524               #1: 0, 1, 3               1101
 525               #2: 0, 2, 3               1011
 526               #3: 0, 3                  1001
 527      This allows the representation of all possible combinations of
 528      capability names in the string.  First generate the strings.  */
 529   result[1].str = result[0].str = cp = (char *) (result + *sz);
 530 #define add(idx) \
 531       cp = __mempcpy (__mempcpy (cp, temp[idx].str, temp[idx].len), "/", 1);
 532   if (cnt == 2)
 533     {
 534       add (1);
 535       add (0);
 536     }
 537   else
 538     {
 539       n = 1 << (cnt - 1);
 540       do
 541         {
 542           n -= 2;
 543
 544           /* We always add the last string.  */
 545           add (cnt - 1);
 546
 547           /* Add the strings which have the bit set in N.  */
 548           for (m = cnt - 2; m > 0; --m)
 549             if ((n & (1 << m)) != 0)
 550               add (m);
 551
 552           /* Always add the first string.  */
 553           add (0);
 554         }
 555       while (n != 0);
 556     }
 557 #undef add
 558
 559   /* Now we are ready to install the string pointers and length.  */
 560   for (n = 0; n < (1UL << cnt); ++n)
 561     result[n].len = 0;
 562   n = cnt;
 563   do
 564     {
 565       size_t mask = 1 << --n;
 566
 567       rp = result;
 568       for (m = 1 << cnt; m > 0; ++rp)
 569         if ((--m & mask) != 0)
 570           rp->len += temp[n].len + 1;
 571     }
 572   while (n != 0);
 573
 574   /* The first half of the strings all include the first string.  */
 575   n = (1 << cnt) - 2;
 576   rp = &result[2];
 577   while (n != (1UL << (cnt - 1)))
 578     {
 579       if ((--n & 1) != 0)
 580         rp[0].str = rp[-2].str + rp[-2].len;
 581       else
 582         rp[0].str = rp[-1].str;
 583       ++rp;
 584     }
 585
 586   /* The second half starts right after the first part of the string of
 587      the corresponding entry in the first half.  */
 588   do
 589     {
 590       rp[0].str = rp[-(1 << (cnt - 1))].str + temp[cnt - 1].len + 1;
 591       ++rp;
 592     }
 593   while (--n != 0);
 594
 595   /* The maximum string length.  */
 596   *max_capstrlen = result[0].len;
 597
 598   return result;
 599 }
 600
 601 #endif