/* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger.
- Copyright (C) 2010-2017 Free Software Foundation, Inc.
+ Copyright (C) 2010-2022 Free Software Foundation, Inc.
This file is part of GDB.
of loaded shared objects. ``main_executable_lm_info'' provides
a way to get at this information so that it doesn't need to be
frequently recomputed. Initialized by dsbt_relocate_main_executable. */
- struct lm_info_dsbt *main_executable_lm_info;
+ struct lm_info_dsbt *main_executable_lm_info = nullptr;
/* Load maps for the main executable and the interpreter. These are obtained
from ptrace. They are the starting point for getting into the program,
and are required to find the solib list with the individual load maps for
each module. */
- struct int_elf32_dsbt_loadmap *exec_loadmap;
- struct int_elf32_dsbt_loadmap *interp_loadmap;
+ struct int_elf32_dsbt_loadmap *exec_loadmap = nullptr;
+ struct int_elf32_dsbt_loadmap *interp_loadmap = nullptr;
/* Cached value for lm_base, below. */
- CORE_ADDR lm_base_cache;
+ CORE_ADDR lm_base_cache = 0;
/* Link map address for main module. */
- CORE_ADDR main_lm_addr;
+ CORE_ADDR main_lm_addr = 0;
- CORE_ADDR interp_text_sect_low;
- CORE_ADDR interp_text_sect_high;
- CORE_ADDR interp_plt_sect_low;
- CORE_ADDR interp_plt_sect_high;
+ CORE_ADDR interp_text_sect_low = 0;
+ CORE_ADDR interp_text_sect_high = 0;
+ CORE_ADDR interp_plt_sect_low = 0;
+ CORE_ADDR interp_plt_sect_high = 0;
};
/* Per-program-space data key. */
-static const struct program_space_data *solib_dsbt_pspace_data;
-
-static void
-dsbt_pspace_data_cleanup (struct program_space *pspace, void *arg)
-{
- xfree (arg);
-}
+static program_space_key<dsbt_info> solib_dsbt_pspace_data;
/* Get the current dsbt data. If none is found yet, add it now. This
function always returns a valid object. */
{
struct dsbt_info *info;
- info = (struct dsbt_info *) program_space_data (current_program_space,
- solib_dsbt_pspace_data);
+ info = solib_dsbt_pspace_data.get (current_program_space);
if (info != NULL)
return info;
- info = XCNEW (struct dsbt_info);
- set_program_space_data (current_program_space, solib_dsbt_pspace_data, info);
-
- info->lm_base_cache = 0;
- info->main_lm_addr = 0;
-
- return info;
+ return solib_dsbt_pspace_data.emplace (current_program_space);
}
/* Decode int_elf32_dsbt_loadmap from BUF. */
static struct int_elf32_dsbt_loadmap *
-decode_loadmap (gdb_byte *buf)
+decode_loadmap (const gdb_byte *buf)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
- struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
+ const struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
struct int_elf32_dsbt_loadmap *int_ldmbuf;
int version, seg, nsegs;
byte_order);
}
- xfree (ext_ldmbuf);
return int_ldmbuf;
}
static void
dsbt_get_initial_loadmaps (void)
{
- gdb_byte *buf;
struct dsbt_info *info = get_dsbt_info ();
+ gdb::optional<gdb::byte_vector> buf
+ = target_read_alloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_FDPIC, "exec");
- if (0 >= target_read_alloc (¤t_target, TARGET_OBJECT_FDPIC,
- "exec", &buf))
+ if (!buf || buf->empty ())
{
info->exec_loadmap = NULL;
error (_("Error reading DSBT exec loadmap"));
}
- info->exec_loadmap = decode_loadmap (buf);
+ info->exec_loadmap = decode_loadmap (buf->data ());
if (solib_dsbt_debug)
dsbt_print_loadmap (info->exec_loadmap);
- if (0 >= target_read_alloc (¤t_target, TARGET_OBJECT_FDPIC,
- "interp", &buf))
+ buf = target_read_alloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_FDPIC, "exec");
+ if (!buf || buf->empty ())
{
info->interp_loadmap = NULL;
error (_("Error reading DSBT interp loadmap"));
}
- info->interp_loadmap = decode_loadmap (buf);
+ info->interp_loadmap = decode_loadmap (buf->data ());
if (solib_dsbt_debug)
dsbt_print_loadmap (info->interp_loadmap);
}
static void dsbt_relocate_main_executable (void);
static int enable_break (void);
-/* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
- returned and the corresponding PTR is set. */
-
-static int
-scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
-{
- int arch_size, step, sect_size;
- long dyn_tag;
- CORE_ADDR dyn_ptr, dyn_addr;
- gdb_byte *bufend, *bufstart, *buf;
- Elf32_External_Dyn *x_dynp_32;
- Elf64_External_Dyn *x_dynp_64;
- struct bfd_section *sect;
- struct target_section *target_section;
-
- if (abfd == NULL)
- return 0;
-
- if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
- return 0;
-
- arch_size = bfd_get_arch_size (abfd);
- if (arch_size == -1)
- return 0;
-
- /* Find the start address of the .dynamic section. */
- sect = bfd_get_section_by_name (abfd, ".dynamic");
- if (sect == NULL)
- return 0;
-
- for (target_section = current_target_sections->sections;
- target_section < current_target_sections->sections_end;
- target_section++)
- if (sect == target_section->the_bfd_section)
- break;
- if (target_section < current_target_sections->sections_end)
- dyn_addr = target_section->addr;
- else
- {
- /* ABFD may come from OBJFILE acting only as a symbol file without being
- loaded into the target (see add_symbol_file_command). This case is
- such fallback to the file VMA address without the possibility of
- having the section relocated to its actual in-memory address. */
-
- dyn_addr = bfd_section_vma (abfd, sect);
- }
-
- /* Read in .dynamic from the BFD. We will get the actual value
- from memory later. */
- sect_size = bfd_section_size (abfd, sect);
- buf = bufstart = (gdb_byte *) alloca (sect_size);
- if (!bfd_get_section_contents (abfd, sect,
- buf, 0, sect_size))
- 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)
- {
- if (arch_size == 32)
- {
- x_dynp_32 = (Elf32_External_Dyn *) buf;
- dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
- dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
- }
- else
- {
- x_dynp_64 = (Elf64_External_Dyn *) buf;
- dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
- dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
- }
- if (dyn_tag == DT_NULL)
- return 0;
- if (dyn_tag == dyntag)
- {
- /* If requested, try to read the runtime value of this .dynamic
- entry. */
- if (ptr)
- {
- struct type *ptr_type;
- gdb_byte ptr_buf[8];
- CORE_ADDR ptr_addr;
-
- ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
- ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
- if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
- dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
- *ptr = dyn_ptr;
- }
- return 1;
- }
- }
-
- return 0;
-}
-
-/* If no open symbol file, attempt to locate and open the main symbol
- file.
-
- If FROM_TTYP dereferences to a non-zero integer, allow messages to
- be printed. This parameter is a pointer rather than an int because
- open_symbol_file_object is called via catch_errors and
- catch_errors requires a pointer argument. */
+/* See solist.h. */
static int
-open_symbol_file_object (void *from_ttyp)
+open_symbol_file_object (int from_tty)
{
/* Unimplemented. */
return 0;
return info->lm_base_cache;
got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL,
- symfile_objfile);
+ current_program_space->symfile_object_file);
if (got_sym.minsym != 0)
{
"lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
(unsigned int) addr);
}
- else if (scan_dyntag (DT_PLTGOT, exec_bfd, &addr))
+ else if (gdb_bfd_scan_elf_dyntag (DT_PLTGOT,
+ current_program_space->exec_bfd (),
+ &addr, NULL))
{
struct int_elf32_dsbt_loadmap *ldm;
/* Locate the address of the first link map struct. */
lm_addr = lm_base ();
- /* We have at least one link map entry. Fetch the the lot of them,
+ /* We have at least one link map entry. Fetch the lot of them,
building the solist chain. */
while (lm_addr)
{
this in the list of shared objects. */
if (dsbt_index != 0)
{
- int errcode;
- char *name_buf;
struct int_elf32_dsbt_loadmap *loadmap;
struct so_list *sop;
CORE_ADDR addr;
addr = extract_unsigned_integer (lm_buf.l_name,
sizeof (lm_buf.l_name),
byte_order);
- target_read_string (addr, &name_buf, SO_NAME_MAX_PATH_SIZE - 1,
- &errcode);
+ gdb::unique_xmalloc_ptr<char> name_buf
+ = target_read_string (addr, SO_NAME_MAX_PATH_SIZE - 1);
- if (errcode != 0)
- warning (_("Can't read pathname for link map entry: %s."),
- safe_strerror (errcode));
+ if (name_buf == nullptr)
+ warning (_("Can't read pathname for link map entry."));
else
{
if (solib_dsbt_debug)
fprintf_unfiltered (gdb_stdlog, "current_sos: name = %s\n",
- name_buf);
+ name_buf.get ());
- strncpy (sop->so_name, name_buf, SO_NAME_MAX_PATH_SIZE - 1);
+ strncpy (sop->so_name, name_buf.get (), SO_NAME_MAX_PATH_SIZE - 1);
sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
- xfree (name_buf);
strcpy (sop->so_original_name, sop->so_name);
}
asection *interp_sect;
struct dsbt_info *info;
- if (exec_bfd == NULL)
+ if (current_program_space->exec_bfd () == NULL)
return 0;
- if (!target_has_execution)
+ if (!target_has_execution ())
return 0;
info = get_dsbt_info ();
/* Find the .interp section; if not found, warn the user and drop
into the old breakpoint at symbol code. */
- interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
+ interp_sect = bfd_get_section_by_name (current_program_space->exec_bfd (),
+ ".interp");
if (interp_sect)
{
unsigned int interp_sect_size;
/* Read the contents of the .interp section into a local buffer;
the contents specify the dynamic linker this program uses. */
- interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
+ interp_sect_size = bfd_section_size (interp_sect);
buf = (char *) alloca (interp_sect_size);
- bfd_get_section_contents (exec_bfd, interp_sect,
- buf, 0, interp_sect_size);
+ bfd_get_section_contents (current_program_space->exec_bfd (),
+ interp_sect, buf, 0, interp_sect_size);
/* Now we need to figure out where the dynamic linker was
loaded so that we can load its symbols and place a breakpoint
in the dynamic linker itself. */
gdb_bfd_ref_ptr tmp_bfd;
- TRY
+ try
{
tmp_bfd = solib_bfd_open (buf);
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (const gdb_exception &ex)
{
}
- END_CATCH
if (tmp_bfd == NULL)
{
interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".text");
if (interp_sect)
{
- info->interp_text_sect_low
- = bfd_section_vma (tmp_bfd.get (), interp_sect);
+ info->interp_text_sect_low = bfd_section_vma (interp_sect);
info->interp_text_sect_low
+= displacement_from_map (ldm, info->interp_text_sect_low);
info->interp_text_sect_high
- = info->interp_text_sect_low
- + bfd_section_size (tmp_bfd.get (), interp_sect);
+ = info->interp_text_sect_low + bfd_section_size (interp_sect);
}
interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".plt");
if (interp_sect)
{
- info->interp_plt_sect_low =
- bfd_section_vma (tmp_bfd.get (), interp_sect);
+ info->interp_plt_sect_low = bfd_section_vma (interp_sect);
info->interp_plt_sect_low
+= displacement_from_map (ldm, info->interp_plt_sect_low);
- info->interp_plt_sect_high =
- info->interp_plt_sect_low + bfd_section_size (tmp_bfd.get (),
- interp_sect);
+ info->interp_plt_sect_high
+ = info->interp_plt_sect_low + bfd_section_size (interp_sect);
}
addr = gdb_bfd_lookup_symbol (tmp_bfd.get (), cmp_name,
dsbt_relocate_main_executable (void)
{
struct int_elf32_dsbt_loadmap *ldm;
- struct cleanup *old_chain;
- struct section_offsets *new_offsets;
int changed;
struct obj_section *osect;
struct dsbt_info *info = get_dsbt_info ();
info->main_executable_lm_info = new lm_info_dsbt;
info->main_executable_lm_info->map = ldm;
- new_offsets = XCNEWVEC (struct section_offsets,
- symfile_objfile->num_sections);
- old_chain = make_cleanup (xfree, new_offsets);
+ objfile *objf = current_program_space->symfile_object_file;
+ section_offsets new_offsets (objf->section_offsets.size ());
changed = 0;
- ALL_OBJFILE_OSECTIONS (symfile_objfile, osect)
+ ALL_OBJFILE_OSECTIONS (objf, osect)
{
CORE_ADDR orig_addr, addr, offset;
int osect_idx;
int seg;
- osect_idx = osect - symfile_objfile->sections;
+ osect_idx = osect - objf->sections;
/* Current address of section. */
- addr = obj_section_addr (osect);
+ addr = osect->addr ();
/* Offset from where this section started. */
- offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx);
+ offset = objf->section_offsets[osect_idx];
/* Original address prior to any past relocations. */
orig_addr = addr - offset;
if (ldm->segs[seg].p_vaddr <= orig_addr
&& orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz)
{
- new_offsets->offsets[osect_idx]
+ new_offsets[osect_idx]
= ldm->segs[seg].addr - ldm->segs[seg].p_vaddr;
- if (new_offsets->offsets[osect_idx] != offset)
+ if (new_offsets[osect_idx] != offset)
changed = 1;
break;
}
}
if (changed)
- objfile_relocate (symfile_objfile, new_offsets);
+ objfile_relocate (objf, new_offsets);
- do_cleanups (old_chain);
-
- /* Now that symfile_objfile has been relocated, we can compute the
- GOT value and stash it away. */
+ /* Now that OBJF has been relocated, we can compute the GOT value
+ and stash it away. */
}
/* When gdb starts up the inferior, it nurses it along (through the
struct target_so_ops dsbt_so_ops;
+void _initialize_dsbt_solib ();
void
-_initialize_dsbt_solib (void)
+_initialize_dsbt_solib ()
{
- solib_dsbt_pspace_data
- = register_program_space_data_with_cleanup (NULL, dsbt_pspace_data_cleanup);
-
dsbt_so_ops.relocate_section_addresses = dsbt_relocate_section_addresses;
dsbt_so_ops.free_so = dsbt_free_so;
dsbt_so_ops.clear_solib = dsbt_clear_solib;