/* Handle SVR4 shared libraries for GDB, the GNU Debugger.
- Copyright (C) 1990-2018 Free Software Foundation, Inc.
+ Copyright (C) 1990-2019 Free Software Foundation, Inc.
This file is part of GDB.
&& strcmp (inferior_so_name, "/lib/ld.so.1") == 0)
return 1;
- /* Similarly, we observed the same issue with sparc64, but with
+ /* Similarly, we observed the same issue with amd64 and sparcv9, but with
different locations. */
+ if (strcmp (gdb_so_name, "/usr/lib/amd64/ld.so.1") == 0
+ && strcmp (inferior_so_name, "/lib/amd64/ld.so.1") == 0)
+ return 1;
+
if (strcmp (gdb_so_name, "/usr/lib/sparcv9/ld.so.1") == 0
&& strcmp (inferior_so_name, "/lib/sparcv9/ld.so.1") == 0)
return 1;
static int match_main (const char *);
/* Read program header TYPE from inferior memory. The header is found
- by scanning the OS auxillary vector.
+ by scanning the OS auxiliary vector.
If TYPE == -1, return the program headers instead of the contents of
one program header.
- Return a pointer to allocated memory holding the program header contents,
- or NULL on failure. If sucessful, and unless P_SECT_SIZE is NULL, the
- size of those contents is returned to P_SECT_SIZE. Likewise, the target
- architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE and
- the base address of the section is returned in BASE_ADDR. */
+ Return vector of bytes holding the program header contents, or an empty
+ optional on failure. If successful and P_ARCH_SIZE is non-NULL, the target
+ architecture size (32-bit or 64-bit) is returned to *P_ARCH_SIZE. Likewise,
+ the base address of the section is returned in *BASE_ADDR. */
-static gdb_byte *
-read_program_header (int type, int *p_sect_size, int *p_arch_size,
- CORE_ADDR *base_addr)
+static gdb::optional<gdb::byte_vector>
+read_program_header (int type, int *p_arch_size, CORE_ADDR *base_addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
int arch_size, sect_size;
CORE_ADDR sect_addr;
- gdb_byte *buf;
int pt_phdr_p = 0;
/* Get required auxv elements from target. */
- if (target_auxv_search (¤t_target, AT_PHDR, &at_phdr) <= 0)
- return 0;
- if (target_auxv_search (¤t_target, AT_PHENT, &at_phent) <= 0)
- return 0;
- if (target_auxv_search (¤t_target, AT_PHNUM, &at_phnum) <= 0)
- return 0;
+ if (target_auxv_search (current_top_target (), AT_PHDR, &at_phdr) <= 0)
+ return {};
+ if (target_auxv_search (current_top_target (), AT_PHENT, &at_phent) <= 0)
+ return {};
+ if (target_auxv_search (current_top_target (), AT_PHNUM, &at_phnum) <= 0)
+ return {};
if (!at_phdr || !at_phnum)
- return 0;
+ return {};
/* Determine ELF architecture type. */
if (at_phent == sizeof (Elf32_External_Phdr))
else if (at_phent == sizeof (Elf64_External_Phdr))
arch_size = 64;
else
- return 0;
+ return {};
/* Find the requested segment. */
if (type == -1)
if (target_read_memory (at_phdr + i * sizeof (phdr),
(gdb_byte *)&phdr, sizeof (phdr)))
- return 0;
+ return {};
p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
4, byte_order);
}
if (i == at_phnum)
- return 0;
+ return {};
/* Retrieve address and size. */
sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
if (target_read_memory (at_phdr + i * sizeof (phdr),
(gdb_byte *)&phdr, sizeof (phdr)))
- return 0;
+ return {};
p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
4, byte_order);
}
if (i == at_phnum)
- return 0;
+ return {};
/* Retrieve address and size. */
sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
}
/* Read in requested program header. */
- buf = (gdb_byte *) xmalloc (sect_size);
- if (target_read_memory (sect_addr, buf, sect_size))
- {
- xfree (buf);
- return NULL;
- }
+ gdb::byte_vector buf (sect_size);
+ if (target_read_memory (sect_addr, buf.data (), sect_size))
+ return {};
if (p_arch_size)
*p_arch_size = arch_size;
- if (p_sect_size)
- *p_sect_size = sect_size;
if (base_addr)
*base_addr = sect_addr;
/* Return program interpreter string. */
-static char *
+static gdb::optional<gdb::byte_vector>
find_program_interpreter (void)
{
- gdb_byte *buf = NULL;
-
/* If we have an exec_bfd, use its section table. */
if (exec_bfd
&& bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
{
int sect_size = bfd_section_size (exec_bfd, interp_sect);
- buf = (gdb_byte *) xmalloc (sect_size);
- bfd_get_section_contents (exec_bfd, interp_sect, buf, 0, sect_size);
+ gdb::byte_vector buf (sect_size);
+ bfd_get_section_contents (exec_bfd, interp_sect, buf.data (), 0,
+ sect_size);
+ return buf;
}
}
- /* If we didn't find it, use the target auxillary vector. */
- if (!buf)
- buf = read_program_header (PT_INTERP, NULL, NULL, NULL);
-
- return (char *) buf;
+ /* If we didn't find it, use the target auxiliary vector. */
+ return read_program_header (PT_INTERP, NULL, NULL);
}
CORE_ADDR *ptr_addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
- int sect_size, arch_size, step;
+ int arch_size, step;
long current_dyntag;
CORE_ADDR dyn_ptr;
CORE_ADDR base_addr;
- gdb_byte *bufend, *bufstart, *buf;
/* Read in .dynamic section. */
- buf = bufstart = read_program_header (PT_DYNAMIC, §_size, &arch_size,
- &base_addr);
- if (!buf)
+ gdb::optional<gdb::byte_vector> ph_data
+ = read_program_header (PT_DYNAMIC, &arch_size, &base_addr);
+ if (!ph_data)
return 0;
/* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
: sizeof (Elf64_External_Dyn);
- for (bufend = buf + sect_size;
- buf < bufend;
- buf += step)
+ for (gdb_byte *buf = ph_data->data (), *bufend = buf + ph_data->size ();
+ buf < bufend; buf += step)
{
if (arch_size == 32)
{
*ptr = dyn_ptr;
if (ptr_addr)
- *ptr_addr = base_addr + buf - bufstart;
+ *ptr_addr = base_addr + buf - ph_data->data ();
- xfree (bufstart);
return 1;
}
}
- xfree (bufstart);
return 0;
}
static int
svr4_parse_libraries (const char *document, struct svr4_library_list *list)
{
- struct cleanup *back_to = make_cleanup (svr4_free_library_list,
- &list->head);
+ auto cleanup = make_scope_exit ([&] ()
+ {
+ svr4_free_library_list (&list->head);
+ });
memset (list, 0, sizeof (*list));
list->tailp = &list->head;
svr4_library_list_elements, document, list) == 0)
{
/* Parsed successfully, keep the result. */
- discard_cleanups (back_to);
+ cleanup.release ();
return 1;
}
- do_cleanups (back_to);
return 0;
}
gdb_assert (annex == NULL || target_augmented_libraries_svr4_read ());
/* Fetch the list of shared libraries. */
- gdb::unique_xmalloc_ptr<char> svr4_library_document
- = target_read_stralloc (¤t_target, TARGET_OBJECT_LIBRARIES_SVR4,
+ gdb::optional<gdb::char_vector> svr4_library_document
+ = target_read_stralloc (current_top_target (), TARGET_OBJECT_LIBRARIES_SVR4,
annex);
- if (svr4_library_document == NULL)
+ if (!svr4_library_document)
return 0;
- return svr4_parse_libraries (svr4_library_document.get (), list);
+ return svr4_parse_libraries (svr4_library_document->data (), list);
}
#else
CORE_ADDR lm;
struct so_list *head = NULL;
struct so_list **link_ptr = &head;
- struct cleanup *back_to;
int ignore_first;
struct svr4_library_list library_list;
else
ignore_first = 1;
- back_to = make_cleanup (svr4_free_library_list, &head);
+ auto cleanup = make_scope_exit ([&] ()
+ {
+ svr4_free_library_list (&head);
+ });
/* Walk the inferior's link map list, and build our list of
`struct so_list' nodes. */
if (lm)
svr4_read_so_list (lm, 0, &link_ptr, 0);
- discard_cleanups (back_to);
+ cleanup.release ();
if (head == NULL)
return svr4_default_sos ();
if (objfile == symfile_objfile)
return info->main_lm_addr;
+ /* If OBJFILE is a separate debug object file, look for the
+ original object file. */
+ if (objfile->separate_debug_objfile_backlink != NULL)
+ objfile = objfile->separate_debug_objfile_backlink;
+
/* The other link map addresses may be found by examining the list
of shared libraries. */
for (so = master_so_list (); so; so = so->next)
ones set up for the probes-based interface are adequate. */
static void
-disable_probes_interface_cleanup (void *arg)
+disable_probes_interface ()
{
struct svr4_info *info = get_svr4_info ();
struct svr4_info *info = get_svr4_info ();
struct probe_and_action *pa;
enum probe_action action;
- struct cleanup *old_chain, *usm_chain;
struct value *val = NULL;
CORE_ADDR pc, debug_base, lm = 0;
struct frame_info *frame = get_current_frame ();
/* If anything goes wrong we revert to the original linker
interface. */
- old_chain = make_cleanup (disable_probes_interface_cleanup, NULL);
+ auto cleanup = make_scope_exit (disable_probes_interface);
pc = regcache_read_pc (get_current_regcache ());
pa = solib_event_probe_at (info, pc);
if (pa == NULL)
- {
- do_cleanups (old_chain);
- return;
- }
+ return;
action = solib_event_probe_action (pa);
if (action == PROBES_INTERFACE_FAILED)
- {
- do_cleanups (old_chain);
- return;
- }
+ return;
if (action == DO_NOTHING)
{
- discard_cleanups (old_chain);
+ cleanup.release ();
return;
}
so we can guarantee that the dynamic linker's sections are in the
section map. We can therefore inhibit section map updates across
these calls to evaluate_argument and save a lot of time. */
- inhibit_section_map_updates (current_program_space);
- usm_chain = make_cleanup (resume_section_map_updates_cleanup,
- current_program_space);
+ {
+ scoped_restore inhibit_updates
+ = inhibit_section_map_updates (current_program_space);
- TRY
- {
- val = pa->prob->evaluate_argument (1, frame);
- }
- CATCH (ex, RETURN_MASK_ERROR)
- {
- exception_print (gdb_stderr, ex);
- val = NULL;
- }
- END_CATCH
+ TRY
+ {
+ val = pa->prob->evaluate_argument (1, frame);
+ }
+ CATCH (ex, RETURN_MASK_ERROR)
+ {
+ exception_print (gdb_stderr, ex);
+ val = NULL;
+ }
+ END_CATCH
- if (val == NULL)
- {
- do_cleanups (old_chain);
+ if (val == NULL)
return;
- }
- debug_base = value_as_address (val);
- if (debug_base == 0)
- {
- do_cleanups (old_chain);
+ debug_base = value_as_address (val);
+ if (debug_base == 0)
return;
- }
- /* Always locate the debug struct, in case it moved. */
- info->debug_base = 0;
- if (locate_base (info) == 0)
- {
- do_cleanups (old_chain);
+ /* Always locate the debug struct, in case it moved. */
+ info->debug_base = 0;
+ if (locate_base (info) == 0)
return;
- }
- /* GDB does not currently support libraries loaded via dlmopen
- into namespaces other than the initial one. We must ignore
- any namespace other than the initial namespace here until
- support for this is added to GDB. */
- if (debug_base != info->debug_base)
- action = DO_NOTHING;
+ /* GDB does not currently support libraries loaded via dlmopen
+ into namespaces other than the initial one. We must ignore
+ any namespace other than the initial namespace here until
+ support for this is added to GDB. */
+ if (debug_base != info->debug_base)
+ action = DO_NOTHING;
- if (action == UPDATE_OR_RELOAD)
- {
- TRY
- {
- val = pa->prob->evaluate_argument (2, frame);
- }
- CATCH (ex, RETURN_MASK_ERROR)
- {
- exception_print (gdb_stderr, ex);
- do_cleanups (old_chain);
- return;
- }
- END_CATCH
+ if (action == UPDATE_OR_RELOAD)
+ {
+ TRY
+ {
+ val = pa->prob->evaluate_argument (2, frame);
+ }
+ CATCH (ex, RETURN_MASK_ERROR)
+ {
+ exception_print (gdb_stderr, ex);
+ return;
+ }
+ END_CATCH
- if (val != NULL)
- lm = value_as_address (val);
+ if (val != NULL)
+ lm = value_as_address (val);
- if (lm == 0)
- action = FULL_RELOAD;
- }
+ if (lm == 0)
+ action = FULL_RELOAD;
+ }
- /* Resume section map updates. */
- do_cleanups (usm_chain);
+ /* Resume section map updates. Closing the scope is
+ sufficient. */
+ }
if (action == UPDATE_OR_RELOAD)
{
if (action == FULL_RELOAD)
{
if (!solist_update_full (info))
- {
- do_cleanups (old_chain);
- return;
- }
+ return;
}
- discard_cleanups (old_chain);
+ cleanup.release ();
}
/* Helper function for svr4_update_solib_event_breakpoints. */
struct bound_minimal_symbol msymbol;
const char * const *bkpt_namep;
asection *interp_sect;
- char *interp_name;
CORE_ADDR sym_addr;
info->interp_text_sect_low = info->interp_text_sect_high = 0;
struct obj_section *os;
sym_addr = gdbarch_addr_bits_remove
- (target_gdbarch (), gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
- sym_addr,
- ¤t_target));
+ (target_gdbarch (),
+ gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
+ sym_addr,
+ current_top_target ()));
/* On at least some versions of Solaris there's a dynamic relocation
on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
/* Find the program interpreter; if not found, warn the user and drop
into the old breakpoint at symbol code. */
- interp_name = find_program_interpreter ();
- if (interp_name)
+ gdb::optional<gdb::byte_vector> interp_name_holder
+ = find_program_interpreter ();
+ if (interp_name_holder)
{
+ const char *interp_name = (const char *) interp_name_holder->data ();
CORE_ADDR load_addr = 0;
int load_addr_found = 0;
int loader_found_in_list = 0;
/* If we were not able to find the base address of the loader
from our so_list, then try using the AT_BASE auxilliary entry. */
if (!load_addr_found)
- if (target_auxv_search (¤t_target, AT_BASE, &load_addr) > 0)
+ if (target_auxv_search (current_top_target (), AT_BASE, &load_addr) > 0)
{
int addr_bit = gdbarch_addr_bit (target_gdbarch ());
{
svr4_create_solib_event_breakpoints (target_gdbarch (),
load_addr + sym_addr);
- xfree (interp_name);
return 1;
}
/* For whatever reason we couldn't set a breakpoint in the dynamic
linker. Warn and drop into the old code. */
bkpt_at_symbol:
- xfree (interp_name);
warning (_("Unable to find dynamic linker breakpoint function.\n"
"GDB will be unable to debug shared library initializers\n"
"and track explicitly loaded dynamic code."));
sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
sym_addr,
- ¤t_target);
+ current_top_target ());
svr4_create_solib_event_breakpoints (target_gdbarch (), sym_addr);
return 1;
}
}
- if (interp_name != NULL && !current_inferior ()->attach_flag)
+ if (interp_name_holder && !current_inferior ()->attach_flag)
{
for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
{
sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
sym_addr,
- ¤t_target);
+ current_top_target ());
svr4_create_solib_event_breakpoints (target_gdbarch (), sym_addr);
return 1;
}
return 0;
}
-/* Read the ELF program headers from ABFD. Return the contents and
- set *PHDRS_SIZE to the size of the program headers. */
+/* Read the ELF program headers from ABFD. */
-static gdb_byte *
-read_program_headers_from_bfd (bfd *abfd, int *phdrs_size)
+static gdb::optional<gdb::byte_vector>
+read_program_headers_from_bfd (bfd *abfd)
{
- Elf_Internal_Ehdr *ehdr;
- gdb_byte *buf;
-
- ehdr = elf_elfheader (abfd);
-
- *phdrs_size = ehdr->e_phnum * ehdr->e_phentsize;
- if (*phdrs_size == 0)
- return NULL;
+ Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
+ int phdrs_size = ehdr->e_phnum * ehdr->e_phentsize;
+ if (phdrs_size == 0)
+ return {};
- buf = (gdb_byte *) xmalloc (*phdrs_size);
+ gdb::byte_vector buf (phdrs_size);
if (bfd_seek (abfd, ehdr->e_phoff, SEEK_SET) != 0
- || bfd_bread (buf, *phdrs_size, abfd) != *phdrs_size)
- {
- xfree (buf);
- return NULL;
- }
+ || bfd_bread (buf.data (), phdrs_size, abfd) != phdrs_size)
+ return {};
return buf;
}
if ((bfd_get_file_flags (exec_bfd) & DYNAMIC) == 0)
return 0;
- if (target_auxv_search (¤t_target, AT_ENTRY, &entry_point) <= 0)
+ if (target_auxv_search (current_top_target (), AT_ENTRY, &entry_point) <= 0)
return 0;
exec_displacement = entry_point - bfd_get_start_address (exec_bfd);
if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
{
- /* Be optimistic and clear OK only if GDB was able to verify the headers
+ /* Be optimistic and return 0 only if GDB was able to verify the headers
really do not match. */
- int phdrs_size, phdrs2_size, ok = 1;
- gdb_byte *buf, *buf2;
int arch_size;
- buf = read_program_header (-1, &phdrs_size, &arch_size, NULL);
- buf2 = read_program_headers_from_bfd (exec_bfd, &phdrs2_size);
- if (buf != NULL && buf2 != NULL)
+ gdb::optional<gdb::byte_vector> phdrs_target
+ = read_program_header (-1, &arch_size, NULL);
+ gdb::optional<gdb::byte_vector> phdrs_binary
+ = read_program_headers_from_bfd (exec_bfd);
+ if (phdrs_target && phdrs_binary)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
content offset for the verification purpose. */
- if (phdrs_size != phdrs2_size
+ if (phdrs_target->size () != phdrs_binary->size ()
|| bfd_get_arch_size (exec_bfd) != arch_size)
- ok = 0;
+ return 0;
else if (arch_size == 32
- && phdrs_size >= sizeof (Elf32_External_Phdr)
- && phdrs_size % sizeof (Elf32_External_Phdr) == 0)
+ && phdrs_target->size () >= sizeof (Elf32_External_Phdr)
+ && phdrs_target->size () % sizeof (Elf32_External_Phdr) == 0)
{
Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
CORE_ADDR displacement_vaddr = 0;
CORE_ADDR displacement_paddr = 0;
- phdrp = &((Elf32_External_Phdr *) buf)[i];
+ phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i];
buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
break;
}
- /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
+ /* Now compare program headers from the target and the binary
+ with optional DISPLACEMENT. */
- for (i = 0; i < phdrs_size / sizeof (Elf32_External_Phdr); i++)
+ for (i = 0;
+ i < phdrs_target->size () / sizeof (Elf32_External_Phdr);
+ i++)
{
Elf32_External_Phdr *phdrp;
Elf32_External_Phdr *phdr2p;
CORE_ADDR vaddr, paddr;
asection *plt2_asect;
- phdrp = &((Elf32_External_Phdr *) buf)[i];
+ phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i];
buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
- phdr2p = &((Elf32_External_Phdr *) buf2)[i];
+ phdr2p = &((Elf32_External_Phdr *) phdrs_binary->data ())[i];
/* PT_GNU_STACK is an exception by being never relocated by
prelink as its addresses are always zero. */
/* Strip modifies the flags and alignment of PT_GNU_RELRO.
CentOS-5 has problems with filesz, memsz as well.
+ Strip also modifies memsz of PT_TLS.
See PR 11786. */
- if (phdr2[i].p_type == PT_GNU_RELRO)
+ if (phdr2[i].p_type == PT_GNU_RELRO
+ || phdr2[i].p_type == PT_TLS)
{
Elf32_External_Phdr tmp_phdr = *phdrp;
Elf32_External_Phdr tmp_phdr2 = *phdr2p;
continue;
}
- ok = 0;
- break;
+ return 0;
}
}
else if (arch_size == 64
- && phdrs_size >= sizeof (Elf64_External_Phdr)
- && phdrs_size % sizeof (Elf64_External_Phdr) == 0)
+ && phdrs_target->size () >= sizeof (Elf64_External_Phdr)
+ && phdrs_target->size () % sizeof (Elf64_External_Phdr) == 0)
{
Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
CORE_ADDR displacement_vaddr = 0;
CORE_ADDR displacement_paddr = 0;
- phdrp = &((Elf64_External_Phdr *) buf)[i];
+ phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i];
buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
/* Now compare BUF and BUF2 with optional DISPLACEMENT. */
- for (i = 0; i < phdrs_size / sizeof (Elf64_External_Phdr); i++)
+ for (i = 0;
+ i < phdrs_target->size () / sizeof (Elf64_External_Phdr);
+ i++)
{
Elf64_External_Phdr *phdrp;
Elf64_External_Phdr *phdr2p;
CORE_ADDR vaddr, paddr;
asection *plt2_asect;
- phdrp = &((Elf64_External_Phdr *) buf)[i];
+ phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i];
buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
- phdr2p = &((Elf64_External_Phdr *) buf2)[i];
+ phdr2p = &((Elf64_External_Phdr *) phdrs_binary->data ())[i];
/* PT_GNU_STACK is an exception by being never relocated by
prelink as its addresses are always zero. */
/* Strip modifies the flags and alignment of PT_GNU_RELRO.
CentOS-5 has problems with filesz, memsz as well.
+ Strip also modifies memsz of PT_TLS.
See PR 11786. */
- if (phdr2[i].p_type == PT_GNU_RELRO)
+ if (phdr2[i].p_type == PT_GNU_RELRO
+ || phdr2[i].p_type == PT_TLS)
{
Elf64_External_Phdr tmp_phdr = *phdrp;
Elf64_External_Phdr tmp_phdr2 = *phdr2p;
continue;
}
- ok = 0;
- break;
+ return 0;
}
}
else
- ok = 0;
+ return 0;
}
-
- xfree (buf);
- xfree (buf2);
-
- if (!ok)
- return 0;
}
if (info_verbose)
}
if (abfd == NULL || scan_dyntag (DT_SYMBOLIC, abfd, NULL, NULL) != 1)
- return (struct block_symbol) {NULL, NULL};
+ return {};
return lookup_global_symbol_from_objfile (objfile, name, domain);
}
projects / deliverable / binutils-gdb.git / blobdiff