/* Handle SOM shared libraries.
- Copyright (C) 2004-2005, 2007-2012 Free Software Foundation, Inc.
+ Copyright (C) 2004-2014 Free Software Foundation, Inc.
This file is part of GDB.
static void
som_solib_create_inferior_hook (int from_tty)
{
- enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
- struct minimal_symbol *msymbol;
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+ struct bound_minimal_symbol msymbol;
unsigned int dld_flags, status, have_endo;
asection *shlib_info;
- char buf[4];
+ gdb_byte buf[4];
CORE_ADDR anaddr;
if (symfile_objfile == NULL)
annoyance to users of modern systems and foul up the testsuite as
well. As a result, the warnings have been disabled. */
msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
- if (msymbol == NULL)
+ if (msymbol.minsym == NULL)
goto keep_going;
- anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
- store_unsigned_integer (buf, 4, byte_order, PIDGET (inferior_ptid));
+ anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
+ store_unsigned_integer (buf, 4, byte_order, ptid_get_pid (inferior_ptid));
status = target_write_memory (anaddr, buf, 4);
if (status != 0)
{
We'll look first for the old flavor and then the new. */
msymbol = lookup_minimal_symbol ("_DLD_HOOK", NULL, symfile_objfile);
- if (msymbol == NULL)
+ if (msymbol.minsym == NULL)
msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
- if (msymbol == NULL)
+ if (msymbol.minsym == NULL)
{
warning (_("\
Unable to find _DLD_HOOK symbol in object file.\n\
GDB will be unable to track shl_load/shl_unload calls"));
goto keep_going;
}
- anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+ anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
dld_cache.hook.address = anaddr;
/* Grrr, this might not be an export symbol! We have to find the
export stub. */
- msymbol = hppa_lookup_stub_minimal_symbol (SYMBOL_LINKAGE_NAME (msymbol),
- EXPORT);
- if (msymbol != NULL)
+ msymbol
+ = hppa_lookup_stub_minimal_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
+ EXPORT);
+ if (msymbol.minsym != NULL)
{
- anaddr = SYMBOL_VALUE (msymbol);
+ anaddr = MSYMBOL_VALUE (msymbol.minsym);
dld_cache.hook_stub.address = anaddr;
}
store_unsigned_integer (buf, 4, byte_order, anaddr);
msymbol = lookup_minimal_symbol ("__dld_hook", NULL, symfile_objfile);
- if (msymbol == NULL)
+ if (msymbol.minsym == NULL)
{
warning (_("\
Unable to find __dld_hook symbol in object file.\n\
GDB will be unable to track shl_load/shl_unload calls"));
goto keep_going;
}
- anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+ anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
status = target_write_memory (anaddr, buf, 4);
/* Now set a shlib_event breakpoint at __d_trap so we can track
significant shared library events. */
msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
- if (msymbol == NULL)
+ if (msymbol.minsym == NULL)
{
warning (_("\
Unable to find __dld_d_trap symbol in object file.\n\
GDB will be unable to track shl_load/shl_unload calls"));
goto keep_going;
}
- create_solib_event_breakpoint (target_gdbarch,
- SYMBOL_VALUE_ADDRESS (msymbol));
+ create_solib_event_breakpoint (target_gdbarch (),
+ BMSYMBOL_VALUE_ADDRESS (msymbol));
/* We have all the support usually found in end.o, so we can track
shl_load and shl_unload calls. */
/* Get the address of __dld_flags, if no such symbol exists, then we can
not debug the shared code. */
msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
- if (msymbol == NULL)
+ if (msymbol.minsym == NULL)
{
error (_("Unable to find __dld_flags symbol in object file."));
}
- anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+ anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
/* Read the current contents. */
status = target_read_memory (anaddr, buf, 4);
loaded at startup time (what a crock). */
msymbol = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
- if (msymbol == NULL)
+ if (msymbol.minsym == NULL)
error (_("Unable to find _start symbol in object file."));
- anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+ anaddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
/* Make the breakpoint at "_start" a shared library event breakpoint. */
- create_solib_event_breakpoint (target_gdbarch, anaddr);
+ create_solib_event_breakpoint (target_gdbarch (), anaddr);
clear_symtab_users (0);
}
{
struct objfile *objfile;
struct unwind_table_entry *u;
- struct minimal_symbol *dld_msymbol;
+ struct bound_minimal_symbol dld_msymbol;
/* Do we already know the value of these symbols? If so, then
we've no work to do.
ALL_OBJFILES (objfile)
{
dld_msymbol = lookup_minimal_symbol ("shl_load", NULL, objfile);
- if (dld_msymbol != NULL)
+ if (dld_msymbol.minsym != NULL)
{
- dld_cache.load.address = SYMBOL_VALUE (dld_msymbol);
+ dld_cache.load.address = MSYMBOL_VALUE (dld_msymbol.minsym);
dld_cache.load.unwind = find_unwind_entry (dld_cache.load.address);
}
dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_load",
objfile);
- if (dld_msymbol != NULL)
+ if (dld_msymbol.minsym != NULL)
{
- if (MSYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
+ if (MSYMBOL_TYPE (dld_msymbol.minsym) == mst_solib_trampoline)
{
- u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
+ u = find_unwind_entry (MSYMBOL_VALUE (dld_msymbol.minsym));
if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
{
- dld_cache.load_stub.address = SYMBOL_VALUE (dld_msymbol);
+ dld_cache.load_stub.address
+ = MSYMBOL_VALUE (dld_msymbol.minsym);
dld_cache.load_stub.unwind = u;
}
}
}
dld_msymbol = lookup_minimal_symbol ("shl_unload", NULL, objfile);
- if (dld_msymbol != NULL)
+ if (dld_msymbol.minsym != NULL)
{
- dld_cache.unload.address = SYMBOL_VALUE (dld_msymbol);
+ dld_cache.unload.address = MSYMBOL_VALUE (dld_msymbol.minsym);
dld_cache.unload.unwind = find_unwind_entry (dld_cache.unload.address);
/* ??rehrauer: I'm not sure exactly what this is, but it appears
dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_unload",
objfile);
- if (dld_msymbol != NULL)
+ if (dld_msymbol.minsym != NULL)
{
- if (MSYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
+ if (MSYMBOL_TYPE (dld_msymbol.minsym) == mst_solib_trampoline)
{
- u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
+ u = find_unwind_entry (MSYMBOL_VALUE (dld_msymbol.minsym));
if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
{
- dld_cache.unload_stub.address = SYMBOL_VALUE (dld_msymbol);
+ dld_cache.unload_stub.address
+ = MSYMBOL_VALUE (dld_msymbol.minsym);
dld_cache.unload_stub.unwind = u;
}
}
static CORE_ADDR
link_map_start (void)
{
- enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
- struct minimal_symbol *sym;
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+ struct bound_minimal_symbol sym;
CORE_ADDR addr;
- char buf[4];
+ gdb_byte buf[4];
unsigned int dld_flags;
sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
- if (!sym)
+ if (!sym.minsym)
error (_("Unable to find __dld_flags symbol in object file."));
- addr = SYMBOL_VALUE_ADDRESS (sym);
+ addr = BMSYMBOL_VALUE_ADDRESS (sym);
read_memory (addr, buf, 4);
dld_flags = extract_unsigned_integer (buf, 4, byte_order);
if ((dld_flags & DLD_FLAGS_LISTVALID) == 0)
error (_("__dld_list is not valid according to __dld_flags."));
sym = lookup_minimal_symbol ("__dld_list", NULL, NULL);
- if (!sym)
+ if (!sym.minsym)
{
/* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
but the data is still available if you know where to look. */
sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
- if (!sym)
+ if (!sym.minsym)
{
error (_("Unable to find dynamic library list."));
return 0;
}
- addr = SYMBOL_VALUE_ADDRESS (sym) - 8;
+ addr = BMSYMBOL_VALUE_ADDRESS (sym) - 8;
}
else
- addr = SYMBOL_VALUE_ADDRESS (sym);
+ addr = BMSYMBOL_VALUE_ADDRESS (sym);
read_memory (addr, buf, 4);
addr = extract_unsigned_integer (buf, 4, byte_order);
static int
match_main (const char *name)
{
- return strcmp (name, symfile_objfile->name) == 0;
+ return strcmp (name, objfile_name (symfile_objfile)) == 0;
}
static struct so_list *
som_current_sos (void)
{
- enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR lm;
struct so_list *head = 0;
struct so_list **link_ptr = &head;
struct cleanup *old_chain;
int errcode;
struct dld_list dbuf;
- char tsdbuf[4];
+ gdb_byte tsdbuf[4];
new = (struct so_list *) xmalloc (sizeof (struct so_list));
old_chain = make_cleanup (xfree, new);
#ifdef SOLIB_SOM_DBG
printf ("\n+ library \"%s\" is described at %s\n", new->so_name,
- paddress (target_gdbarch, lm));
+ paddress (target_gdbarch (), lm));
printf (" 'version' is %d\n", new->lm_info->struct_version);
printf (" 'bind_mode' is %d\n", new->lm_info->bind_mode);
printf (" 'library_version' is %d\n",
new->lm_info->library_version);
printf (" 'text_addr' is %s\n",
- paddress (target_gdbarch, new->lm_info->text_addr));
+ paddress (target_gdbarch (), new->lm_info->text_addr));
printf (" 'text_link_addr' is %s\n",
- paddress (target_gdbarch, new->lm_info->text_link_addr));
+ paddress (target_gdbarch (), new->lm_info->text_link_addr));
printf (" 'text_end' is %s\n",
- paddress (target_gdbarch, new->lm_info->text_end));
+ paddress (target_gdbarch (), new->lm_info->text_end));
printf (" 'data_start' is %s\n",
- paddress (target_gdbarch, new->lm_info->data_start));
+ paddress (target_gdbarch (), new->lm_info->data_start));
printf (" 'bss_start' is %s\n",
- paddress (target_gdbarch, new->lm_info->bss_start));
+ paddress (target_gdbarch (), new->lm_info->bss_start));
printf (" 'data_end' is %s\n",
- paddress (target_gdbarch, new->lm_info->data_end));
+ paddress (target_gdbarch (), new->lm_info->data_end));
printf (" 'got_value' is %s\n",
- paddress (target_gdbarch, new->lm_info->got_value));
+ paddress (target_gdbarch (), new->lm_info->got_value));
printf (" 'tsd_start_addr' is %s\n",
- paddress (target_gdbarch, new->lm_info->tsd_start_addr));
+ paddress (target_gdbarch (), new->lm_info->tsd_start_addr));
#endif
new->addr_low = lmi->text_addr;
static int
som_open_symbol_file_object (void *from_ttyp)
{
- enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR lm, l_name;
char *filename;
int errcode;
int from_tty = *(int *)from_ttyp;
- char buf[4];
+ gdb_byte buf[4];
+ struct cleanup *cleanup;
if (symfile_objfile)
if (!query (_("Attempt to reload symbols from process? ")))
return 0;
}
- make_cleanup (xfree, filename);
+ cleanup = make_cleanup (xfree, filename);
/* Have a pathname: read the symbol file. */
symbol_file_add_main (filename, from_tty);
+ do_cleanups (cleanup);
return 1;
}
{
/* Oh what a pain! We need the offsets before so_list->objfile
is valid. The BFDs will never match. Make a best guess. */
- if (strstr (objfile->name, so_list->so_name))
+ if (strstr (objfile_name (objfile), so_list->so_name))
{
asection *private_section;
+ struct obj_section *sect;
/* The text offset is easy. */
offsets->offsets[SECT_OFF_TEXT (objfile)]
= (so_list->lm_info->text_addr
- so_list->lm_info->text_link_addr);
- offsets->offsets[SECT_OFF_RODATA (objfile)]
- = ANOFFSET (offsets, SECT_OFF_TEXT (objfile));
/* We should look at presumed_dp in the SOM header, but
that's not easily available. This should be OK though. */
offsets->offsets[SECT_OFF_BSS (objfile)] = 0;
return 1;
}
- offsets->offsets[SECT_OFF_DATA (objfile)]
- = (so_list->lm_info->data_start - private_section->vma);
- offsets->offsets[SECT_OFF_BSS (objfile)]
- = ANOFFSET (offsets, SECT_OFF_DATA (objfile));
+ if (objfile->sect_index_data != -1)
+ {
+ offsets->offsets[SECT_OFF_DATA (objfile)]
+ = (so_list->lm_info->data_start - private_section->vma);
+ if (objfile->sect_index_bss != -1)
+ offsets->offsets[SECT_OFF_BSS (objfile)]
+ = ANOFFSET (offsets, SECT_OFF_DATA (objfile));
+ }
+
+ ALL_OBJFILE_OSECTIONS (objfile, sect)
+ {
+ flagword flags = bfd_get_section_flags (objfile->obfd,
+ sect->the_bfd_section);
+
+ if ((flags & SEC_CODE) != 0)
+ offsets->offsets[sect->the_bfd_section->index]
+ = offsets->offsets[SECT_OFF_TEXT (objfile)];
+ else
+ offsets->offsets[sect->the_bfd_section->index]
+ = offsets->offsets[SECT_OFF_DATA (objfile)];
+ }
+
return 1;
}
so_list = so_list->next;
projects / deliverable / binutils-gdb.git / blobdiff