", l->l_name[0] ? l->l_name : (_dl_argv_internal[0]) ?: "

", (int) sizeof l->l_map_start * 2, (size_t) l->l_map_start, (int) sizeof l->l_addr * 2, (size_t) l->l_addr); # 1898 "rtld.c" if (l->l_tls_modid) _dl_dprintf (1, " TLS(0x%Zx, 0x%0*Zx)\n", l->l_tls_modid, (int) sizeof l->l_tls_offset * 2, (size_t) l->l_tls_offset); else _dl_dprintf (1, "\n"); } } else if (_rtld_local_ro._dl_debug_mask & (1 << 8)) { struct link_map *l = main_map; struct relocate_args args = { .l = l, .lazy = _rtld_local_ro._dl_lazy }; _dl_receive_error (print_unresolved, relocate_doit, &args); Elf64_Dyn *dyn = main_map->l_ld; _Bool first = 1; while (dyn->d_tag != 0) { if (dyn->d_tag == 1) { l = l->l_next; if (!l->l_used) { if (first) { _dl_dprintf (1, "Unused direct dependencies:\n"); first = 0; } _dl_dprintf (1, "\t%s\n", l->l_name); } } ++dyn; } exit_internal (first != 1); } else if (! main_map->l_info[1]) _dl_dprintf (1, "\tstatically linked\n"); else { for (l = main_map->l_next; l; l = l->l_next) if (l->l_faked) _dl_dprintf (1, "\t%s => not found\n", l->l_libname->name); else if (__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (l->l_libname->name) && __builtin_constant_p (l->l_name) && (__s1_len = strlen (l->l_libname->name), __s2_len = strlen (l->l_name), (!((size_t)(const void *)((l->l_libname->name) + 1) - (size_t)(const void *)(l->l_libname->name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((l->l_name) + 1) - (size_t)(const void *)(l->l_name) == 1) || __s2_len >= 4)) ? __builtin_strcmp (l->l_libname->name, l->l_name) : (__builtin_constant_p (l->l_libname->name) && ((size_t)(const void *)((l->l_libname->name) + 1) - (size_t)(const void *)(l->l_libname->name) == 1) && (__s1_len = strlen (l->l_libname->name), __s1_len < 4) ? (__builtin_constant_p (l->l_name) && ((size_t)(const void *)((l->l_name) + 1) - (size_t)(const void *)(l->l_name) == 1) ? __builtin_strcmp (l->l_libname->name, l->l_name) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (l->l_name); register int __result = (((__const unsigned char *) (__const char *) (l->l_libname->name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (l->l_libname->name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (l->l_libname->name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (l->l_libname->name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (l->l_name) && ((size_t)(const void *)((l->l_name) + 1) - (size_t)(const void *)(l->l_name) == 1) && (__s2_len = strlen (l->l_name), __s2_len < 4) ? (__builtin_constant_p (l->l_libname->name) && ((size_t)(const void *)((l->l_libname->name) + 1) - (size_t)(const void *)(l->l_libname->name) == 1) ? __builtin_strcmp (l->l_libname->name, l->l_name) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (l->l_libname->name); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (l->l_name))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (l->l_name))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (l->l_name))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (l->l_name))[3]); } } __result; }))) : __builtin_strcmp (l->l_libname->name, l->l_name)))); }) == 0) _dl_dprintf (1, "\t%s (0x%0*Zx)\n", l->l_libname->name, (int) sizeof l->l_map_start * 2, (size_t) l->l_map_start); else _dl_dprintf (1, "\t%s => %s (0x%0*Zx)\n", l->l_libname->name, l->l_name, (int) sizeof l->l_map_start * 2, (size_t) l->l_map_start); } if (__builtin_expect (mode, trace) != trace) for (i = 1; i < (unsigned int) _dl_argc; ++i) { const Elf64_Sym *ref = ((void *)0); Elf64_Addr loadbase; lookup_t result; result = _dl_lookup_symbol_x (_dl_argv_internal[i], main_map, &ref, main_map->l_scope, ((void *)0), 1, DL_LOOKUP_ADD_DEPENDENCY, ((void *)0)); loadbase = ((result) ? (result)->l_addr : 0); _dl_dprintf (1, "%s found at 0x%0*Zd in object at 0x%0*Zd\n", _dl_argv_internal[i], (int) sizeof ref->st_value * 2, (size_t) ref->st_value, (int) sizeof loadbase * 2, (size_t) loadbase); } else { if (_rtld_local_ro._dl_lazy >= 0 && _rtld_local_ro._dl_verbose) { struct relocate_args args; struct link_map *l; args.lazy = _rtld_local_ro._dl_lazy; l = main_map; while (l->l_next != ((void *)0)) l = l->l_next; do { if (l != &_rtld_local._dl_rtld_map && ! l->l_faked) { args.l = l; _dl_receive_error (print_unresolved, relocate_doit, &args); } l = l->l_prev; } while (l != ((void *)0)); if ((_rtld_local_ro._dl_debug_mask & (1 << 10)) && rtld_multiple_ref) { _rtld_local._dl_rtld_map.l_relocated = 0; _dl_relocate_object (&_rtld_local._dl_rtld_map, main_map->l_scope, 0, 0); } } if (version_info) { int first = 1; struct link_map *map; for (map = main_map; map != ((void *)0); map = map->l_next) { const char *strtab; Elf64_Dyn *dyn = map->l_info[(34 + 0 + (0x6fffffff - (0x6ffffffe)))]; Elf64_Verneed *ent; if (dyn == ((void *)0)) continue; strtab = (const void *) (map)->l_info[5]->d_un.d_ptr; ent = (Elf64_Verneed *) (map->l_addr + dyn->d_un.d_ptr); if (first) { _dl_dprintf (1, "\n\tVersion information:\n"); first = 0; } _dl_dprintf (1, "\t%s:\n", map->l_name[0] ? map->l_name : (_dl_argv_internal[0])); while (1) { Elf64_Vernaux *aux; struct link_map *needed; needed = find_needed (strtab + ent->vn_file); aux = (Elf64_Vernaux *) ((char *) ent + ent->vn_aux); while (1) { const char *fname = ((void *)0); if (needed != ((void *)0) && match_version (strtab + aux->vna_name, needed)) fname = needed->l_name; _dl_dprintf (1, "\t\t%s (%s) %s=> %s\n", strtab + ent->vn_file, strtab + aux->vna_name, aux->vna_flags & 0x2 ? "[WEAK] " : "", fname ?: "not found"); if (aux->vna_next == 0) break; aux = (Elf64_Vernaux *) ((char *) aux + aux->vna_next); } if (ent->vn_next == 0) break; ent = (Elf64_Verneed *) ((char *) ent + ent->vn_next); } } } } exit_internal (0); } if (main_map->l_info[(34 + 0 + 16 + 3 + 12 + (0x6ffffeff - (0x6ffffef9)))] && ! __builtin_expect (_rtld_local_ro._dl_profile != ((void *)0), 0)) { Elf64_Lib *liblist, *liblistend; struct link_map **r_list, **r_listend, *l; const char *strtab = (const void *) (main_map)->l_info[5]->d_un.d_ptr; ((void) ((main_map->l_info[(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf7)))] != ((void *)0)) ? 0 : (__assert_fail ("main_map->l_info[(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf7)))] != ((void *)0)", "rtld.c", 2101, __PRETTY_FUNCTION__), 0))); liblist = (Elf64_Lib *) main_map->l_info[(34 + 0 + 16 + 3 + 12 + (0x6ffffeff - (0x6ffffef9)))]->d_un.d_ptr; liblistend = (Elf64_Lib *) ((char *) liblist + main_map->l_info[(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf7)))]->d_un.d_val); r_list = main_map->l_searchlist.r_list; r_listend = r_list + main_map->l_searchlist.r_nlist; for (; r_list < r_listend && liblist < liblistend; r_list++) { l = *r_list; if (l == main_map) continue; if (l->l_addr) break; if (l->l_info [(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf8)))] == ((void *)0) || l->l_info [(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf8)))]->d_un.d_val != liblist->l_checksum) break; if (l->l_info [(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf5)))] == ((void *)0) || l->l_info [(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf5)))]->d_un.d_val != liblist->l_time_stamp) break; if (! _dl_name_match_p (strtab + liblist->l_name, l)) break; ++liblist; } if (r_list == r_listend && liblist == liblistend) prelinked = 1; if (__builtin_expect (_rtld_local_ro._dl_debug_mask & (1 << 0), 0)) _dl_debug_printf ("\nprelink checking: %s\n", prelinked ? "ok" : "failed"); } _rtld_local._dl_ns[0]._ns_main_searchlist = &main_map->l_searchlist; _rtld_local._dl_ns[0]._ns_global_scope[0] = &main_map->l_searchlist; _rtld_local_ro._dl_initial_searchlist = *_rtld_local._dl_ns[0]._ns_main_searchlist; if (prelinked) { if (main_map->l_info [(34 + 0 + 16 + 3 + 12 + (0x6ffffeff - (0x6ffffef8)))] != ((void *)0)) { Elf64_Rela *conflict, *conflictend; ; ((void) ((main_map->l_info [(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf6)))] != ((void *)0)) ? 0 : (__assert_fail ("main_map->l_info [(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf6)))] != ((void *)0)", "rtld.c", 2167, __PRETTY_FUNCTION__), 0))); conflict = (Elf64_Rela *) main_map->l_info [(34 + 0 + 16 + 3 + 12 + (0x6ffffeff - (0x6ffffef8)))]->d_un.d_ptr; conflictend = (Elf64_Rela *) ((char *) conflict + main_map->l_info [(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf6)))]->d_un.d_val); _dl_resolve_conflicts (main_map, conflict, conflictend); ; ; } for (struct link_map *l = main_map; l != ((void *)0); l = l->l_next) { l->l_relocated = 1; if (l->l_relro_size) _dl_protect_relro (l); if (l->l_tls_blocksize != 0 && tls_init_tp_called) _dl_add_to_slotinfo (l); } _dl_sysdep_start_cleanup (); } else { # 2206 "rtld.c" int consider_profiling = _rtld_local_ro._dl_profile != ((void *)0); _rtld_local_ro._dl_lazy |= consider_profiling; struct link_map *l = main_map; while (l->l_next) l = l->l_next; ; do { struct libname_list *lnp = l->l_libname->next; while (__builtin_expect (lnp != ((void *)0), 0)) { lnp->dont_free = 1; lnp = lnp->next; } if (l != &_rtld_local._dl_rtld_map) _dl_relocate_object (l, l->l_scope, _rtld_local_ro._dl_lazy, consider_profiling); if (l->l_tls_blocksize != 0 && tls_init_tp_called) _dl_add_to_slotinfo (l); l = l->l_prev; } while (l); ; ; _dl_sysdep_start_cleanup (); if (__builtin_expect (_rtld_local._dl_profile_map != ((void *)0), 0)) _dl_start_profile (); if (rtld_multiple_ref) { ; _rtld_local._dl_rtld_map.l_relocated = 0; _dl_relocate_object (&_rtld_local._dl_rtld_map, main_map->l_scope, 0, 0); ; ; ; } } if (!was_tls_init_tp_called && _rtld_local._dl_tls_max_dtv_idx > 0) ++_rtld_local._dl_tls_generation; _dl_allocate_tls_init (tcbp); if (! tls_init_tp_called) { const char *lossage = ({ void *_thrdescr = (tcbp); tcbhead_t *_head = _thrdescr; _head->tcb = _thrdescr; _head->self = _thrdescr; ; __builtin_set_thread_pointer (_thrdescr); ((void *)0); }); if (__builtin_expect (lossage != ((void *)0), 0)) do { _dl_dprintf (2, "cannot set up thread-local storage: %s\n", lossage); exit_internal (127); } while (1); } if (__builtin_expect (_rtld_local_ro._dl_naudit > 0, 0)) { struct link_map *head = _rtld_local._dl_ns[0]._ns_loaded; if (head->l_auditing == 0) { struct audit_ifaces *afct = _rtld_local_ro._dl_audit; for (unsigned int cnt = 0; cnt < _rtld_local_ro._dl_naudit; ++cnt) { if (afct->activity != ((void *)0)) afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT); afct = afct->next; } } } r = _dl_debug_initialize (0, 0); r->r_state = RT_CONSISTENT; _dl_debug_state (); _dl_unload_cache (); } static void print_unresolved (int errcode __attribute__ ((unused)), const char *objname, const char *errstring) { if (objname[0] == '\0') objname = (_dl_argv_internal[0]) ?: "

"; _dl_dprintf (2, "%s (%s)\n", errstring, objname); } static void print_missing_version (int errcode __attribute__ ((unused)), const char *objname, const char *errstring) { _dl_dprintf (2, "%s: %s: %s\n", (_dl_argv_internal[0]) ?: "", objname, errstring); } static int any_debug __attribute__ ((section (".data.rel.ro"))); static void process_dl_debug (const char *dl_debug) { static const struct { unsigned char len; const char name[10]; const char helptext[41]; unsigned short int mask; } debopts[] = { { sizeof ("libs") - 1, "libs", "display library search paths", (1 << 0) | (1 << 1) }, { sizeof ("reloc") - 1, "reloc", "display relocation processing", (1 << 5) | (1 << 1) }, { sizeof ("files") - 1, "files", "display progress for input file", (1 << 6) | (1 << 1) }, { sizeof ("symbols") - 1, "symbols", "display symbol table processing", (1 << 3) | (1 << 1) }, { sizeof ("bindings") - 1, "bindings", "display information about symbol binding", (1 << 2) | (1 << 1) }, { sizeof ("versions") - 1, "versions", "display version dependencies", (1 << 4) | (1 << 1) }, { sizeof ("all") - 1, "all", "all previous options combined", (1 << 0) | (1 << 5) | (1 << 6) | (1 << 3) | (1 << 2) | (1 << 4) | (1 << 1) }, { sizeof ("statistics") - 1, "statistics", "display relocation statistics", (1 << 7) }, { sizeof ("unused") - 1, "unused", "determined unused DSOs", (1 << 8) }, { sizeof ("help") - 1, "help", "display this help message and exit", (1 << 9) }, }; while (*dl_debug != '\0') { if (*dl_debug != ' ' && *dl_debug != ',' && *dl_debug != ':') { size_t cnt; size_t len = 1; while (dl_debug[len] != '\0' && dl_debug[len] != ' ' && dl_debug[len] != ',' && dl_debug[len] != ':') ++len; for (cnt = 0; cnt < (sizeof (debopts) / sizeof (debopts[0])); ++cnt) if (debopts[cnt].len == len && memcmp (dl_debug, debopts[cnt].name, len) == 0) { _rtld_local_ro._dl_debug_mask |= debopts[cnt].mask; any_debug = 1; break; } if (cnt == (sizeof (debopts) / sizeof (debopts[0]))) { char *copy = (__extension__ ({ __const char *__old = (dl_debug); size_t __len = __strnlen (__old, (len)); char *__new = (char *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old, __len); })); _dl_dprintf (2, "warning: debug option `%s' unknown; try LD_DEBUG=help\n", copy); } dl_debug += len; continue; } ++dl_debug; } if (_rtld_local_ro._dl_debug_mask & (1 << 9)) { size_t cnt; _dl_dprintf (1, "Valid options for the LD_DEBUG environment variable are:\n\n"); for (cnt = 0; cnt < (sizeof (debopts) / sizeof (debopts[0])); ++cnt) _dl_dprintf (1, " %.*s%s%s\n", debopts[cnt].len, debopts[cnt].name, " " + debopts[cnt].len - 3, debopts[cnt].helptext); _dl_dprintf (1, "\nTo direct the debugging output into a file instead of standard output\na filename can be specified using the LD_DEBUG_OUTPUT environment variable.\n"); exit_internal (0); } } static void process_dl_audit (char *str) { char *p; while ((p = (strsep) (&str, ":")) != ((void *)0)) if (p[0] != '\0' && (__builtin_expect (! __libc_enable_secure_internal, 1) || (__extension__ (__builtin_constant_p ('/') && !__builtin_constant_p (p) && ('/') == '\0' ? (char *) __rawmemchr (p, '/') : __builtin_strchr (p, '/'))) == ((void *)0))) { struct audit_list *newp = malloc (sizeof (*newp)); newp->name = p; if (audit_list == ((void *)0)) audit_list = newp->next = newp; else { newp->next = audit_list->next; audit_list = audit_list->next = newp; } } } extern char **_environ __attribute__ ((visibility ("hidden"))); static void process_envvars (enum mode *modep) { char **runp = _environ; char *envline; enum mode mode = normal; char *debug_output = ((void *)0); _rtld_local_ro._dl_profile_output = &"/var/tmp\0/var/profile"[__libc_enable_secure_internal ? 9 : 0]; while ((envline = _dl_next_ld_env_entry (&runp)) != ((void *)0)) { size_t len = 0; while (envline[len] != '\0' && envline[len] != '=') ++len; if (envline[len] != '=') continue; switch (len) { case 4: if (memcmp (envline, "WARN", 4) == 0) _rtld_local_ro._dl_verbose = envline[5] != '\0'; break; case 5: if (memcmp (envline, "DEBUG", 5) == 0) { process_dl_debug (&envline[6]); break; } if (memcmp (envline, "AUDIT", 5) == 0) process_dl_audit (&envline[6]); break; case 7: if (memcmp (envline, "VERBOSE", 7) == 0) { version_info = envline[8] != '\0'; break; } if (memcmp (envline, "PRELOAD", 7) == 0) { preloadlist = &envline[8]; break; } if (memcmp (envline, "PROFILE", 7) == 0 && envline[8] != '\0') _rtld_local_ro._dl_profile = &envline[8]; break; case 8: if (memcmp (envline, "BIND_NOW", 8) == 0) { _rtld_local_ro._dl_lazy = envline[9] == '\0'; break; } if (memcmp (envline, "BIND_NOT", 8) == 0) _rtld_local_ro._dl_bind_not = envline[9] != '\0'; break; case 9: if (!__libc_enable_secure_internal && memcmp (envline, "SHOW_AUXV", 9) == 0) _dl_show_auxv (); break; case 10: if (memcmp (envline, "HWCAP_MASK", 10) == 0) _rtld_local_ro._dl_hwcap_mask = __strtoul_internal (&envline[11], ((void *)0), 0, 0); break; case 11: if (!__libc_enable_secure_internal && memcmp (envline, "ORIGIN_PATH", 11) == 0) _rtld_local_ro._dl_origin_path = &envline[12]; break; case 12: if (memcmp (envline, "LIBRARY_PATH", 12) == 0) { library_path = &envline[13]; break; } if (memcmp (envline, "DEBUG_OUTPUT", 12) == 0) { debug_output = &envline[13]; break; } if (!__libc_enable_secure_internal && memcmp (envline, "DYNAMIC_WEAK", 12) == 0) _rtld_local_ro._dl_dynamic_weak = 1; break; case 13: if (memcmp (envline, "ASSUME_KERNEL", 13) == 0) { _dl_osversion_init (&envline[14]); break; } if (!__libc_enable_secure_internal && memcmp (envline, "USE_LOAD_BIAS", 13) == 0) { _rtld_local_ro._dl_use_load_bias = envline[14] == '1' ? -1 : 0; break; } if (memcmp (envline, "POINTER_GUARD", 13) == 0) _rtld_local_ro._dl_pointer_guard = envline[14] != '0'; break; case 14: if (!__libc_enable_secure_internal && memcmp (envline, "PROFILE_OUTPUT", 14) == 0 && envline[15] != '\0') _rtld_local_ro._dl_profile_output = &envline[15]; break; case 16: if (memcmp (envline, "TRACE_PRELINKING", 16) == 0) { mode = trace; _rtld_local_ro._dl_verbose = 1; _rtld_local_ro._dl_debug_mask |= (1 << 10); _rtld_local_ro._dl_trace_prelink = &envline[17]; } break; case 20: if (memcmp (envline, "TRACE_LOADED_OBJECTS", 20) == 0) mode = trace; break; # 2659 "rtld.c" } } *modep = mode; if (__builtin_expect (__libc_enable_secure_internal, 0)) { static const char unsecure_envvars[] = "GCONV_PATH\0" "GETCONF_DIR\0" "HOSTALIASES\0" "LD_AUDIT\0" "LD_DEBUG\0" "LD_DEBUG_OUTPUT\0" "LD_DYNAMIC_WEAK\0" "LD_LIBRARY_PATH\0" "LD_ORIGIN_PATH\0" "LD_PRELOAD\0" "LD_PROFILE\0" "LD_SHOW_AUXV\0" "LD_USE_LOAD_BIAS\0" "LOCALDOMAIN\0" "LOCPATH\0" "MALLOC_TRACE\0" "NLSPATH\0" "RESOLV_HOST_CONF\0" "RES_OPTIONS\0" "TMPDIR\0" "TZDIR\0"; const char *nextp; nextp = unsecure_envvars; do { unsetenv (nextp); nextp = (char *) (strchr) (nextp, '\0') + 1; } while (*nextp != '\0'); if (__access ("/etc/suid-debug", 0) != 0) { unsetenv ("MALLOC_CHECK_"); _rtld_local_ro._dl_debug_mask = 0; } if (mode != normal) exit_internal (5); } else if (any_debug && debug_output != ((void *)0)) { const int flags = 01 | 02000 | 0100 | 0400000; size_t name_len = strlen (debug_output); char buf[name_len + 12]; char *startp; buf[name_len + 11] = '\0'; startp = _itoa (__getpid (), &buf[name_len + 11], 10, 0); *--startp = '.'; startp = memcpy (startp - name_len, debug_output, name_len); _rtld_local_ro._dl_debug_fd = __open (startp, flags, (0400|0200|(0400 >> 3)|(0200 >> 3)|((0400 >> 3) >> 3)|((0200 >> 3) >> 3))); if (_rtld_local_ro._dl_debug_fd == -1) _rtld_local_ro._dl_debug_fd = 1; } } static void __attribute ((noinline)) print_statistics (hp_timing_t *rtld_total_timep) { # 2760 "rtld.c" unsigned long int num_relative_relocations = 0; for (Lmid_t ns = 0; ns < 16; ++ns) { if (_rtld_local._dl_ns[ns]._ns_loaded == ((void *)0)) continue; struct r_scope_elem *scope = &_rtld_local._dl_ns[ns]._ns_loaded->l_searchlist; for (unsigned int i = 0; i < scope->r_nlist; i++) { struct link_map *l = scope->r_list [i]; if (l->l_addr != 0 && l->l_info[(34 + 0 + (0x6fffffff - (0x6ffffffa)))]) num_relative_relocations += l->l_info[(34 + 0 + (0x6fffffff - (0x6ffffffa)))]->d_un.d_val; if ((l->l_addr != 0 || !l->l_info[(34 + 0 + 16 + 3 + (0x6ffffdff - (0x6ffffdf5)))]) && l->l_info[(34 + 0 + (0x6fffffff - (0x6ffffff9)))]) num_relative_relocations += l->l_info[(34 + 0 + (0x6fffffff - (0x6ffffff9)))]->d_un.d_val; } } _dl_debug_printf (" number of relocations: %lu\n" " number of relocations from cache: %lu\n" " number of relative relocations: %lu\n", _rtld_local._dl_num_relocations, _rtld_local._dl_num_cache_relocations, num_relative_relocations); # 2823 "rtld.c" }