#include "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "gdbcore.h"
#include "frame.h"
#include "target.h"
#include "value.h"
#include "symfile.h"
#include "objfiles.h"
#include "source.h"
#include "gdbcmd.h"
#include "breakpoint.h"
#include "language.h"
#include "complaints.h"
#include "demangle.h"
#include "inferior.h"
#include "gdb-stabs.h"
#include "gdb_obstack.h"
#include "completer.h"
#include "bcache.h"
#include <sys/types.h>
#include <fcntl.h>
#include "gdb_string.h"
#include "gdb_stat.h"
#include <ctype.h>
#include <time.h>
#ifndef TEXT_SECTION_NAME
#define TEXT_SECTION_NAME ".text"
#endif
#ifndef DATA_SECTION_NAME
#define DATA_SECTION_NAME ".data"
#endif
#ifndef BSS_SECTION_NAME
#define BSS_SECTION_NAME ".bss"
#endif
#ifdef NM_NEXTSTEP
#include "macosx-nat-dyld.h"
#endif
#ifndef O_BINARY
#define O_BINARY 0
#endif
#if HAVE_MMAP
static int mmap_symbol_files_flag = 0;
#endif
#ifdef HPUXHPPA
extern int hp_som_som_object_present;
extern int hp_cxx_exception_support_initialized;
#define RESET_HP_UX_GLOBALS() do {\
hp_som_som_object_present = 0; \
hp_cxx_exception_support_initialized = 0; \
} while (0)
#endif
int (*ui_load_progress_hook) (const char *section, unsigned long num);
void (*show_load_progress) (const char *section,
unsigned long section_sent,
unsigned long section_size,
unsigned long total_sent,
unsigned long total_size);
void (*pre_add_symbol_hook) (char *);
void (*post_add_symbol_hook) (void);
void (*target_new_objfile_hook) (struct objfile *);
static void clear_symtab_users_cleanup (void *ignore);
int readnow_symbol_files;
extern void report_transfer_performance (unsigned long, time_t, time_t);
#if 0
static int simple_read_overlay_region_table (void);
static void simple_free_overlay_region_table (void);
#endif
static void set_initial_language (void);
static void load_command (char *, int);
static void symbol_file_add_main_1 (char *args, int from_tty, int flags);
static void add_symbol_file_command (char *, int);
static void add_shared_symbol_files_command (char *, int);
static void cashier_psymtab (struct partial_symtab *);
static int compare_psymbols (const void *, const void *);
static int compare_symbols (const void *, const void *);
bfd *symfile_bfd_open (const char *);
int get_section_index (struct objfile *, char *);
static void find_sym_fns (struct objfile *);
static void decrement_reading_symtab (void *);
static void overlay_invalidate_all (void);
static int overlay_is_mapped (struct obj_section *);
void list_overlays_command (char *, int);
void map_overlay_command (char *, int);
void unmap_overlay_command (char *, int);
static void overlay_auto_command (char *, int);
static void overlay_manual_command (char *, int);
static void overlay_off_command (char *, int);
static void overlay_load_command (char *, int);
static void overlay_command (char *, int);
static void simple_free_overlay_table (void);
static void read_target_long_array (CORE_ADDR, unsigned int *, int);
static int simple_read_overlay_table (void);
static int simple_overlay_update_1 (struct obj_section *);
static void add_filename_language (char *ext, enum language lang);
static void set_ext_lang_command (char *args, int from_tty);
static void info_ext_lang_command (char *args, int from_tty);
static void init_filename_language_table (void);
void _initialize_symfile (void);
static struct sym_fns *symtab_fns = NULL;
#ifdef SYMBOL_RELOADING_DEFAULT
int symbol_reloading = SYMBOL_RELOADING_DEFAULT;
#else
int symbol_reloading = 0;
#endif
int auto_solib_add = 1;
int auto_solib_limit;
static int
compare_symbols (const void *s1p, const void *s2p)
{
register struct symbol **s1, **s2;
s1 = (struct symbol **) s1p;
s2 = (struct symbol **) s2p;
return (strcmp (SYMBOL_SOURCE_NAME (*s1), SYMBOL_SOURCE_NAME (*s2)));
}
static int
compare_psymbols (const void *s1p, const void *s2p)
{
register struct partial_symbol **s1, **s2;
register char *st1, *st2;
s1 = (struct partial_symbol **) s1p;
s2 = (struct partial_symbol **) s2p;
st1 = SYMBOL_SOURCE_NAME (*s1);
st2 = SYMBOL_SOURCE_NAME (*s2);
if ((st1[0] - st2[0]) || !st1[0])
{
return (st1[0] - st2[0]);
}
else if ((st1[1] - st2[1]) || !st1[1])
{
return (st1[1] - st2[1]);
}
else
{
return (strcmp (st1, st2));
}
}
void
sort_pst_symbols (struct partial_symtab *pst)
{
qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
pst->n_global_syms, sizeof (struct partial_symbol *),
compare_psymbols);
}
void
sort_block_syms (register struct block *b)
{
qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
sizeof (struct symbol *), compare_symbols);
}
void
sort_symtab_syms (register struct symtab *s)
{
register struct blockvector *bv;
int nbl;
int i;
register struct block *b;
if (s == 0)
return;
bv = BLOCKVECTOR (s);
nbl = BLOCKVECTOR_NBLOCKS (bv);
for (i = 0; i < nbl; i++)
{
b = BLOCKVECTOR_BLOCK (bv, i);
if (BLOCK_SHOULD_SORT (b))
sort_block_syms (b);
}
}
char *
obsavestring (char *ptr, int size, struct obstack *obstackp)
{
register char *p = (char *) obstack_alloc (obstackp, size + 1);
{
register char *p1 = ptr;
register char *p2 = p;
char *end = ptr + size;
while (p1 != end)
*p2++ = *p1++;
}
p[size] = 0;
return p;
}
char *
obconcat (struct obstack *obstackp, const char *s1, const char *s2,
const char *s3)
{
register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
register char *val = (char *) obstack_alloc (obstackp, len);
strcpy (val, s1);
strcat (val, s2);
strcat (val, s3);
return val;
}
int currently_reading_symtab = 0;
static void
decrement_reading_symtab (void *dummy)
{
currently_reading_symtab--;
}
struct symtab *
psymtab_to_symtab (register struct partial_symtab *pst)
{
if (pst->symtab)
return pst->symtab;
if (!pst->readin)
{
struct cleanup *back_to = make_cleanup (decrement_reading_symtab, NULL);
currently_reading_symtab++;
(*pst->read_symtab) (pst);
do_cleanups (back_to);
}
return pst->symtab;
}
void
init_entry_point_info (struct objfile *objfile)
{
if (bfd_get_file_flags (objfile->obfd) & EXEC_P)
{
objfile->ei.entry_point = bfd_get_start_address (objfile->obfd);
}
else
{
objfile->ei.entry_point = INVALID_ENTRY_POINT;
}
objfile->ei.entry_file_lowpc = INVALID_ENTRY_LOWPC;
objfile->ei.entry_file_highpc = INVALID_ENTRY_HIGHPC;
objfile->ei.entry_func_lowpc = INVALID_ENTRY_LOWPC;
objfile->ei.entry_func_highpc = INVALID_ENTRY_HIGHPC;
objfile->ei.main_func_lowpc = INVALID_ENTRY_LOWPC;
objfile->ei.main_func_highpc = INVALID_ENTRY_HIGHPC;
}
CORE_ADDR
entry_point_address (void)
{
return symfile_objfile ? symfile_objfile->ei.entry_point : 0;
}
void
find_lowest_section (bfd *abfd, asection *sect, PTR obj)
{
asection **lowest = (asection **) obj;
if (0 == (bfd_get_section_flags (abfd, sect) & SEC_LOAD))
return;
if (!*lowest)
*lowest = sect;
else if (bfd_section_vma (abfd, *lowest) > bfd_section_vma (abfd, sect))
*lowest = sect;
else if (bfd_section_vma (abfd, *lowest) == bfd_section_vma (abfd, sect)
&& (bfd_section_size (abfd, (*lowest))
<= bfd_section_size (abfd, sect)))
*lowest = sect;
}
extern struct section_addr_info *
build_section_addr_info_from_section_table (const struct section_table *start,
const struct section_table *end)
{
struct section_addr_info *sap;
const struct section_table *stp;
int oidx;
sap = xmalloc (sizeof (struct section_addr_info));
memset (sap, 0, sizeof (struct section_addr_info));
for (stp = start, oidx = 0; stp != end; stp++)
{
if (bfd_get_section_flags (stp->bfd,
stp->the_bfd_section) & (SEC_ALLOC | SEC_LOAD)
&& oidx < MAX_SECTIONS)
{
sap->other[oidx].addr = stp->addr;
sap->other[oidx].name
= xstrdup (bfd_section_name (stp->bfd, stp->the_bfd_section));
sap->other[oidx].sectindex = stp->the_bfd_section->index;
oidx++;
}
}
return sap;
}
extern void
free_section_addr_info (struct section_addr_info *sap)
{
int idx;
for (idx = 0; idx < MAX_SECTIONS; idx++)
if (sap->other[idx].name)
xfree (sap->other[idx].name);
xfree (sap);
}
void
default_symfile_offsets (struct objfile *objfile,
struct section_addr_info *addrs)
{
int i;
asection *sect = NULL;
objfile->num_sections = SECT_OFF_MAX;
objfile->section_offsets = (struct section_offsets *)
obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
memset (objfile->section_offsets, 0, SIZEOF_SECTION_OFFSETS);
for (i = 0; i < MAX_SECTIONS && addrs->other[i].name; i++)
{
struct other_sections *osp ;
osp = &addrs->other[i] ;
if (osp->addr == 0)
continue;
(objfile->section_offsets)->offsets[osp->sectindex] = osp->addr;
}
sect = bfd_get_section_by_name (objfile->obfd, TEXT_SECTION_NAME);
if (sect)
objfile->sect_index_text = sect->index;
sect = bfd_get_section_by_name (objfile->obfd, DATA_SECTION_NAME);
if (sect)
objfile->sect_index_data = sect->index;
sect = bfd_get_section_by_name (objfile->obfd, BSS_SECTION_NAME);
if (sect)
objfile->sect_index_bss = sect->index;
sect = bfd_get_section_by_name (objfile->obfd, ".rodata");
if (sect)
objfile->sect_index_rodata = sect->index;
for (i = 0; i < objfile->num_sections; i++)
{
if (ANOFFSET (objfile->section_offsets, i) != 0)
{
break;
}
}
if (i == objfile->num_sections)
{
if (objfile->sect_index_text == -1)
objfile->sect_index_text = 0;
if (objfile->sect_index_data == -1)
objfile->sect_index_data = 0;
if (objfile->sect_index_bss == -1)
objfile->sect_index_bss = 0;
if (objfile->sect_index_rodata == -1)
objfile->sect_index_rodata = 0;
}
}
void
syms_from_objfile (struct objfile *objfile, struct section_addr_info *addrs,
int mainline, int verbo)
{
asection *lower_sect;
asection *sect;
CORE_ADDR lower_offset;
struct section_addr_info local_addr;
struct cleanup *old_chain;
int i;
if (addrs == NULL)
{
memset (&local_addr, 0, sizeof (local_addr));
addrs = &local_addr;
addrs -> addrs_are_offsets = 1;
}
init_entry_point_info (objfile);
find_sym_fns (objfile);
if (objfile->sf == NULL)
return;
old_chain = make_cleanup_free_objfile (objfile);
if (mainline)
{
make_cleanup (clear_symtab_users_cleanup, 0 );
if (symfile_objfile != NULL)
{
free_objfile (symfile_objfile);
symfile_objfile = NULL;
#ifdef NM_NEXTSTEP
macosx_init_dyld_symfile (symfile_objfile, exec_bfd);
#endif
}
(*objfile->sf->sym_new_init) (objfile);
}
if (mainline)
{
addrs -> addrs_are_offsets = 1;
}
if (!addrs->addrs_are_offsets)
{
lower_sect = bfd_get_section_by_name (objfile->obfd, TEXT_SECTION_NAME);
if (lower_sect == NULL)
bfd_map_over_sections (objfile->obfd, find_lowest_section,
(PTR) &lower_sect);
if (lower_sect == NULL)
warning ("no loadable sections found in added symbol-file %s",
objfile->name);
else
if ((bfd_get_section_flags (objfile->obfd, lower_sect) & SEC_CODE) == 0)
warning ("Lowest section in %s is %s at %s",
objfile->name,
bfd_section_name (objfile->obfd, lower_sect),
paddr (bfd_section_vma (objfile->obfd, lower_sect)));
if (lower_sect != NULL)
lower_offset = bfd_section_vma (objfile->obfd, lower_sect);
else
lower_offset = 0;
for (i=0 ; i < MAX_SECTIONS && addrs->other[i].name; i++)
{
if (addrs->other[i].addr != 0)
{
sect = bfd_get_section_by_name (objfile->obfd, addrs->other[i].name);
if (sect)
{
addrs->other[i].addr -= bfd_section_vma (objfile->obfd, sect);
lower_offset = addrs->other[i].addr;
addrs->other[i].sectindex = sect->index ;
}
else
{
warning ("section %s not found in %s", addrs->other[i].name,
objfile->name);
addrs->other[i].addr = 0;
}
}
else
addrs->other[i].addr = lower_offset;
}
addrs -> addrs_are_offsets = 1;
}
(*objfile->sf->sym_init) (objfile);
clear_complaints (&symfile_complaints, 1, verbo);
(*objfile->sf->sym_offsets) (objfile, addrs);
#if 0 && ! defined (IBM6000_TARGET)
if (addrs)
{
struct obj_section *s;
ALL_OBJFILE_OSECTIONS (objfile, s)
{
CORE_ADDR s_addr = 0;
int i;
if (strcmp (s->the_bfd_section->name, TEXT_SECTION_NAME) == 0)
s_addr = addrs->text_addr;
else if (strcmp (s->the_bfd_section->name, DATA_SECTION_NAME) == 0)
s_addr = addrs->data_addr;
else if (strcmp (s->the_bfd_section->name, BSS_SECTION_NAME) == 0)
s_addr = addrs->bss_addr;
else
for (i = 0;
!s_addr && i < MAX_SECTIONS && addrs->other[i].name;
i++)
if (strcmp (bfd_section_name (s->objfile->obfd,
s->the_bfd_section),
addrs->other[i].name) == 0)
s_addr = addrs->other[i].addr;
s->addr -= s->offset;
s->addr += s_addr;
s->endaddr -= s->offset;
s->endaddr += s_addr;
s->offset += s_addr;
}
}
#endif
if (objfile->symflags & ~OBJF_SYM_CONTAINER)
(*objfile->sf->sym_read) (objfile, mainline);
#if 0
if (!have_partial_symbols () && !have_full_symbols ())
{
wrap_here ("");
printf_filtered ("(no debugging symbols found)...");
wrap_here ("");
}
#endif
TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
TYPE_NAME (lookup_pointer_type (builtin_type_void)) = 0;
objfile->flags |= OBJF_SYMS;
discard_cleanups (old_chain);
TARGET_SYMFILE_POSTREAD (objfile);
}
void
new_symfile_objfile (struct objfile *objfile, int mainline, int verbo)
{
if (mainline)
{
symfile_objfile = objfile;
#ifdef NM_NEXTSTEP
macosx_init_dyld_symfile (symfile_objfile, exec_bfd);
#endif
clear_symtab_users ();
}
else
{
breakpoint_re_set ();
}
clear_complaints (&symfile_complaints, 0, verbo);
}
struct objfile *
symbol_file_add (const char *name, int from_tty,
struct section_addr_info *addrs,
int mainline, int flags, int symflags,
CORE_ADDR mapaddr, const char *prefix)
{
bfd *abfd;
abfd = symfile_bfd_open (name);
return symbol_file_add_bfd
(abfd, from_tty, addrs, mainline, flags, symflags, mapaddr, prefix);
}
struct objfile *
symbol_file_add_bfd (abfd, from_tty, addrs, mainline, flags, symflags, mapaddr, prefix)
bfd *abfd;
int from_tty;
struct section_addr_info *addrs;
int mainline;
int flags;
CORE_ADDR mapaddr;
const char *prefix;
{
struct objfile *objfile;
struct partial_symtab *psymtab;
if ((have_full_symbols () || have_partial_symbols ())
&& mainline
&& from_tty
&& !query ("Load new symbol table from \"%s\"? ", abfd->filename))
error ("Not confirmed.");
#ifdef ENABLE_INCREDIBLY_INAPPROPRIATE_MACOSX_SPECIFIC_HACKS_IN_GENERIC_CODE
objfile = allocate_objfile (abfd, flags, symflags, mapaddr);
#else
objfile = allocate_objfile (abfd, flags);
#endif
objfile->prefix = prefix;
if ((objfile->flags & OBJF_MAPPED) && (objfile->flags & OBJF_SYMS))
{
if (from_tty || info_verbose)
{
printf_filtered ("Mapped symbols for %s...", abfd->filename);
wrap_here ("");
gdb_flush (gdb_stdout);
}
init_entry_point_info (objfile);
find_sym_fns (objfile);
}
else
{
if (from_tty || info_verbose)
{
if (pre_add_symbol_hook)
pre_add_symbol_hook (abfd->filename);
else
{
printf_filtered ("Reading symbols from %s...", abfd->filename);
wrap_here ("");
gdb_flush (gdb_stdout);
}
}
syms_from_objfile (objfile, addrs, mainline, from_tty);
}
if ((flags & OBJF_READNOW) || readnow_symbol_files)
{
if (from_tty || info_verbose)
{
printf_filtered ("expanding to full symbols...");
wrap_here ("");
gdb_flush (gdb_stdout);
}
for (psymtab = objfile->psymtabs;
psymtab != NULL;
psymtab = psymtab->next)
{
psymtab_to_symtab (psymtab);
}
}
if (from_tty || info_verbose)
{
if (post_add_symbol_hook)
post_add_symbol_hook ();
else
{
printf_filtered ("done.\n");
gdb_flush (gdb_stdout);
}
}
#ifndef NM_NEXTSTEP
if (objfile->sf == NULL)
return objfile;
#endif
new_symfile_objfile (objfile, mainline, from_tty);
if (target_new_objfile_hook)
target_new_objfile_hook (objfile);
return (objfile);
}
void
symbol_file_add_main (char *args, int from_tty)
{
symbol_file_add_main_1 (args, from_tty, 0);
}
static void
symbol_file_add_main_1 (char *args, int from_tty, int flags)
{
symbol_file_add (args, from_tty, NULL, 1, flags, OBJF_SYM_ALL, 0, NULL);
#ifdef HPUXHPPA
RESET_HP_UX_GLOBALS ();
#endif
#ifdef NM_NEXTSTEP
macosx_init_dyld_symfile (symfile_objfile, exec_bfd);
#endif
reinit_frame_cache ();
set_initial_language ();
}
void
symbol_file_clear (int from_tty)
{
if ((have_full_symbols () || have_partial_symbols ())
&& from_tty
&& !query ("Discard symbol table from `%s'? ",
symfile_objfile->name))
error ("Not confirmed.");
#ifdef NM_NEXTSTEP
if (symfile_objfile != NULL)
{
free_objfile (symfile_objfile);
symfile_objfile = NULL;
macosx_init_dyld_symfile (symfile_objfile, exec_bfd);
}
#else
free_all_objfiles ();
#endif
#if defined(SOLIB_RESTART)
SOLIB_RESTART ();
#endif
symfile_objfile = NULL;
if (from_tty)
printf_unfiltered ("No symbol file now.\n");
if (state_change_hook)
state_change_hook (STATE_ACTIVE);
#ifdef HPUXHPPA
RESET_HP_UX_GLOBALS ();
#endif
}
void
symbol_file_command (char *args, int from_tty)
{
char **argv;
char *name = NULL;
struct cleanup *cleanups;
int flags = OBJF_USERLOADED;
int symflags = OBJF_SYM_ALL;
dont_repeat ();
if (args == NULL)
{
symbol_file_clear (from_tty);
}
else
{
if ((argv = buildargv (args)) == NULL)
{
nomem (0);
}
cleanups = make_cleanup_freeargv (argv);
while (*argv != NULL)
{
if (STREQ (*argv, "-mapped"))
flags |= OBJF_MAPPED;
else
if (STREQ (*argv, "-readnow"))
flags |= OBJF_READNOW;
else
if (**argv == '-')
error ("unknown option `%s'", *argv);
else
{
name = *argv;
symbol_file_add_main_1 (name, from_tty, flags);
}
argv++;
}
if (name == NULL)
{
error ("no symbol file name was specified");
}
do_cleanups (cleanups);
}
if (state_change_hook)
{
state_change_hook (STATE_INFERIOR_LOADED);
}
}
static void
set_initial_language (void)
{
struct partial_symtab *pst;
enum language lang = language_unknown;
pst = find_main_psymtab ();
if (pst != NULL)
{
if (pst->filename != NULL)
{
lang = deduce_language_from_filename (pst->filename);
}
if (lang == language_unknown)
{
lang = language_c;
}
set_language (lang);
expected_language = current_language;
}
}
bfd *
symfile_bfd_open (const char *name)
{
bfd *sym_bfd = NULL;
int desc;
char *absolute_name;
name = tilde_expand (name);
desc = openp (getenv ("PATH"), 1, name, O_RDONLY | O_BINARY, 0, &absolute_name);
#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
if (desc < 0)
{
char *exename = alloca (strlen (name) + 5);
strcat (strcpy (exename, name), ".exe");
desc = openp (getenv ("PATH"), 1, exename, O_RDONLY | O_BINARY,
0, &absolute_name);
}
#endif
if (desc < 0)
{
make_cleanup (xfree, name);
perror_with_name (name);
}
xfree (name);
name = absolute_name;
if (desc > 0)
sym_bfd = bfd_fdopenr (name, gnutarget, desc);
else
sym_bfd = NULL;
if (!sym_bfd)
{
close (desc);
make_cleanup (xfree, name);
error ("\"%s\": can't open to read symbols: %s.", name,
bfd_errmsg (bfd_get_error ()));
}
sym_bfd->cacheable = 1;
#if HAVE_MMAP
if (mmap_symbol_files_flag)
{
if (!bfd_mmap_file (sym_bfd, (void *) -1))
error ("\"%s\": could not mmap file for read: %s",
name, bfd_errmsg (bfd_get_error ()));
}
#endif
if (bfd_check_format (sym_bfd, bfd_archive))
{
bfd *abfd = NULL;
#if defined (__ppc__)
const bfd_arch_info_type *thisarch = bfd_lookup_arch (bfd_arch_powerpc, 0);
#elif defined (__i386__)
const bfd_arch_info_type *thisarch = bfd_lookup_arch (bfd_arch_i386, 0);
#else
const bfd_arch_info_type *thisarch = bfd_lookup_arch (bfd_arch_powerpc, 0);
#endif
for (;;)
{
abfd = bfd_openr_next_archived_file (sym_bfd, abfd);
if (abfd == NULL)
{
break;
}
if (!bfd_check_format (abfd, bfd_object))
{
abfd = NULL;
break;
}
if (thisarch == NULL)
{
abfd = NULL;
break;
}
if (bfd_default_compatible (bfd_get_arch_info (abfd), thisarch))
{
break;
}
}
if (abfd != NULL)
{
sym_bfd = abfd;
}
}
if (!bfd_check_format (sym_bfd, bfd_object))
{
bfd_close (sym_bfd);
make_cleanup (xfree, name);
error ("\"%s\": can't read symbols: %s.", name,
bfd_errmsg (bfd_get_error ()));
}
return (sym_bfd);
}
int
get_section_index (struct objfile *objfile, char *section_name)
{
asection *sect = bfd_get_section_by_name (objfile->obfd, section_name);
if (sect)
return sect->index;
else
return -1;
}
void
add_symtab_fns (struct sym_fns *sf)
{
sf->next = symtab_fns;
symtab_fns = sf;
}
static void
find_sym_fns (struct objfile *objfile)
{
struct sym_fns *sf;
enum bfd_flavour our_flavour = bfd_get_flavour (objfile->obfd);
char *our_target = bfd_get_target (objfile->obfd);
if (our_flavour == bfd_target_srec_flavour
|| our_flavour == bfd_target_ihex_flavour
|| our_flavour == bfd_target_tekhex_flavour)
return;
if (STREQN (our_target, "apollo", 6))
our_flavour = (enum bfd_flavour) -2;
for (sf = symtab_fns; sf != NULL; sf = sf->next)
{
if (our_flavour == sf->sym_flavour)
{
objfile->sf = sf;
return;
}
}
error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.",
bfd_get_target (objfile->obfd));
}
static void
load_command (char *arg, int from_tty)
{
if (arg == NULL)
arg = get_exec_file (1);
target_load (arg, from_tty);
overlay_cache_invalid = 1;
}
static int download_write_size = 512;
static int validate_download = 0;
static void
add_section_size_callback (bfd *abfd, asection *asec, void *data)
{
bfd_size_type *sum = data;
*sum += bfd_get_section_size_before_reloc (asec);
}
struct load_section_data {
unsigned long load_offset;
unsigned long write_count;
unsigned long data_count;
bfd_size_type total_size;
};
static void
load_section_callback (bfd *abfd, asection *asec, void *data)
{
struct load_section_data *args = data;
if (bfd_get_section_flags (abfd, asec) & SEC_LOAD)
{
bfd_size_type size = bfd_get_section_size_before_reloc (asec);
if (size > 0)
{
char *buffer;
struct cleanup *old_chain;
CORE_ADDR lma = bfd_section_lma (abfd, asec) + args->load_offset;
bfd_size_type block_size;
int err;
const char *sect_name = bfd_get_section_name (abfd, asec);
bfd_size_type sent;
if (download_write_size > 0 && size > download_write_size)
block_size = download_write_size;
else
block_size = size;
buffer = xmalloc (size);
old_chain = make_cleanup (xfree, buffer);
ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n",
sect_name, paddr_nz (size), paddr_nz (lma));
bfd_get_section_contents (abfd, asec, buffer, 0, size);
sent = 0;
do
{
int len;
bfd_size_type this_transfer = size - sent;
if (this_transfer >= block_size)
this_transfer = block_size;
len = target_write_memory_partial (lma, buffer,
this_transfer, &err);
if (err)
break;
if (validate_download)
{
char *check = xmalloc (len);
struct cleanup *verify_cleanups =
make_cleanup (xfree, check);
if (target_read_memory (lma, check, len) != 0)
error ("Download verify read failed at 0x%s",
paddr (lma));
if (memcmp (buffer, check, len) != 0)
error ("Download verify compare failed at 0x%s",
paddr (lma));
do_cleanups (verify_cleanups);
}
args->data_count += len;
lma += len;
buffer += len;
args->write_count += 1;
sent += len;
if (quit_flag
|| (ui_load_progress_hook != NULL
&& ui_load_progress_hook (sect_name, sent)))
error ("Canceled the download");
if (show_load_progress != NULL)
show_load_progress (sect_name, sent, size,
args->data_count, args->total_size);
}
while (sent < size);
if (err != 0)
error ("Memory access error while loading section %s.", sect_name);
do_cleanups (old_chain);
}
}
}
void
generic_load (char *args, int from_tty)
{
asection *s;
bfd *loadfile_bfd;
time_t start_time, end_time;
char *filename;
struct cleanup *old_cleanups;
char *offptr;
struct load_section_data cbdata;
CORE_ADDR entry;
cbdata.load_offset = 0;
cbdata.write_count = 0;
cbdata.data_count = 0;
cbdata.total_size = 0;
filename = xmalloc (strlen (args) + 1);
old_cleanups = make_cleanup (xfree, filename);
strcpy (filename, args);
offptr = strchr (filename, ' ');
if (offptr != NULL)
{
char *endptr;
cbdata.load_offset = strtoul (offptr, &endptr, 0);
if (offptr == endptr)
error ("Invalid download offset:%s\n", offptr);
*offptr = '\0';
}
else
cbdata.load_offset = 0;
loadfile_bfd = bfd_openr (filename, gnutarget);
if (loadfile_bfd == NULL)
{
perror_with_name (filename);
return;
}
make_cleanup_bfd_close (loadfile_bfd);
if (!bfd_check_format (loadfile_bfd, bfd_object))
{
error ("\"%s\" is not an object file: %s", filename,
bfd_errmsg (bfd_get_error ()));
}
bfd_map_over_sections (loadfile_bfd, add_section_size_callback,
(void *) &cbdata.total_size);
start_time = time (NULL);
bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
end_time = time (NULL);
entry = bfd_get_start_address (loadfile_bfd);
ui_out_text (uiout, "Start address ");
ui_out_field_fmt (uiout, "address", "0x%s", paddr_nz (entry));
ui_out_text (uiout, ", load size ");
ui_out_field_fmt (uiout, "load-size", "%lu", cbdata.data_count);
ui_out_text (uiout, "\n");
write_pc (entry);
print_transfer_performance (gdb_stdout, cbdata.data_count,
cbdata.write_count, end_time - start_time);
do_cleanups (old_cleanups);
}
void
report_transfer_performance (unsigned long data_count, time_t start_time,
time_t end_time)
{
print_transfer_performance (gdb_stdout, data_count,
end_time - start_time, 0);
}
void
print_transfer_performance (struct ui_file *stream,
unsigned long data_count,
unsigned long write_count,
unsigned long time_count)
{
ui_out_text (uiout, "Transfer rate: ");
if (time_count > 0)
{
ui_out_field_fmt (uiout, "transfer-rate", "%lu",
(data_count * 8) / time_count);
ui_out_text (uiout, " bits/sec");
}
else
{
ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8));
ui_out_text (uiout, " bits in <1 sec");
}
if (write_count > 0)
{
ui_out_text (uiout, ", ");
ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count);
ui_out_text (uiout, " bytes/write");
}
ui_out_text (uiout, ".\n");
}
static void
add_symbol_file_command (char *args, int from_tty)
{
char *filename = NULL;
char *prefix = NULL;
CORE_ADDR text_addr;
CORE_ADDR mapaddr = 0;
int flags = OBJF_USERLOADED;
int symflags = OBJF_SYM_ALL;
char *arg;
int expecting_option = 0;
int section_index = 0;
int argcnt = 0;
int sec_num = 0;
int i;
int expecting_sec_name = 0;
int expecting_sec_addr = 0;
static char *usage_string =
"USAGE: add-symbol-file <filename> [-mapped] [-readnow] [-s <secname> <addr>]*";
struct
{
char *name;
char *value;
} sect_opts[SECT_OFF_MAX];
struct section_addr_info section_addrs;
struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL);
dont_repeat ();
if (args == NULL)
error (usage_string);
args = xstrdup (args);
memset (§ion_addrs, 0, sizeof (section_addrs));
while (*args != '\000')
{
while (isspace (*args))
args++;
arg = args;
while ((*args != '\000') && !isspace (*args))
args++;
if (*args != '\000')
*args++ = '\000';
if (argcnt == 0)
{
filename = tilde_expand (arg);
make_cleanup (xfree, filename);
}
else
{
if (*arg == '-')
{
if (strcmp (arg, "-mapaddr") == 0)
{
char *atmp = args;
if (*atmp == '\000')
error ("usage: map address must be a valid address");
while ((*args != '\000') && !isspace (*args))
{
args++;
}
if (*args != '\000')
{
*args++ = '\000';
}
mapaddr = parse_and_eval_address (atmp);
}
if (strcmp (arg, "-prefix") == 0)
{
char *atmp = args;
if (*atmp == '\000')
error ("usage: prefix must be a valid string");
while ((*args != '\000') && !isspace (*args))
{
args++;
}
if (*args != '\000')
{
*args++ = '\000';
}
prefix = xstrdup (atmp);
}
else if (strcmp (arg, "-mapped") == 0)
flags |= OBJF_MAPPED;
else if (strcmp (arg, "-readnow") == 0)
flags |= OBJF_READNOW;
else if (strcmp (arg, "-s") == 0)
{
if (section_index >= SECT_OFF_MAX)
error ("Too many sections specified.");
expecting_sec_name = 1;
expecting_sec_addr = 1;
}
}
else
{
if (expecting_sec_name)
{
sect_opts[section_index].name = arg;
expecting_sec_name = 0;
}
else
if (expecting_sec_addr)
{
sect_opts[section_index].value = arg;
expecting_sec_addr = 0;
section_index++;
}
else
error (usage_string);
}
}
argcnt++;
}
printf_filtered ("add symbol table from file \"%s\" at\n", filename);
for (i = 0; i < section_index; i++)
{
CORE_ADDR addr;
char *val = sect_opts[i].value;
char *sec = sect_opts[i].name;
val = sect_opts[i].value;
if (val[0] == '0' && val[1] == 'x')
addr = strtoul (val+2, NULL, 16);
else
addr = strtoul (val, NULL, 10);
section_addrs.other[sec_num].name = sec;
section_addrs.other[sec_num].addr = addr;
printf_filtered ("\t%s_addr = %s\n",
sec,
local_hex_string ((unsigned long)addr));
sec_num++;
}
if (from_tty && (!query ("%s", "")))
error ("Not confirmed.");
symbol_file_add (filename, from_tty, §ion_addrs, 0, flags, symflags, mapaddr, prefix);
reinit_frame_cache ();
do_cleanups (my_cleanups);
}
static void
add_shared_symbol_files_command (char *args, int from_tty)
{
#ifdef ADD_SHARED_SYMBOL_FILES
ADD_SHARED_SYMBOL_FILES (args, from_tty);
#else
error ("This command is not available in this configuration of GDB.");
#endif
}
void
reread_symbols (void)
{
struct objfile *objfile;
long new_modtime;
int reread_one = 0;
struct stat new_statbuf;
int res;
bfd_cache_flush ();
for (objfile = object_files; objfile; objfile = objfile->next)
{
if (objfile->obfd)
{
new_modtime = bfd_get_mtime (objfile->obfd);
if (new_modtime != objfile->mtime)
{
struct cleanup *old_cleanups;
struct section_offsets *offsets;
int num_offsets;
char *obfd_filename;
printf_filtered ("`%s' has changed; re-reading symbols.\n",
objfile->name);
old_cleanups = make_cleanup_free_objfile (objfile);
make_cleanup (clear_symtab_users_cleanup, 0 );
obfd_filename = bfd_get_filename (objfile->obfd);
if (!bfd_close (objfile->obfd))
error ("Can't close BFD for %s: %s", objfile->name,
bfd_errmsg (bfd_get_error ()));
objfile->obfd = bfd_openr (obfd_filename, gnutarget);
if (objfile->obfd == NULL)
error ("Can't open %s to read symbols.", objfile->name);
if (bfd_check_format (objfile->obfd, bfd_archive))
{
bfd *abfd = NULL;
#if defined (__ppc__)
const bfd_arch_info_type *thisarch = bfd_lookup_arch (bfd_arch_powerpc, 0);
#elif defined (__i386__)
const bfd_arch_info_type *thisarch = bfd_lookup_arch (bfd_arch_i386, 0);
#else
const bfd_arch_info_type *thisarch = bfd_lookup_arch (bfd_arch_powerpc, 0);
#endif
for (;;)
{
abfd = bfd_openr_next_archived_file (objfile->obfd, abfd);
if (abfd == NULL)
{
break;
}
if (!bfd_check_format (abfd, bfd_object))
{
abfd = NULL;
break;
}
if (thisarch == NULL)
{
abfd = NULL;
break;
}
if (bfd_default_compatible (bfd_get_arch_info (abfd), thisarch))
{
break;
}
}
if (abfd != NULL)
{
objfile->obfd = abfd;
}
}
if (!bfd_check_format (objfile->obfd, bfd_object))
error ("Can't read symbols from %s: %s.", objfile->name,
bfd_errmsg (bfd_get_error ()));
num_offsets = objfile->num_sections;
offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
memcpy (offsets, objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
if (objfile->global_psymbols.list)
xmfree (objfile->md, objfile->global_psymbols.list);
memset (&objfile->global_psymbols, 0,
sizeof (objfile->global_psymbols));
if (objfile->static_psymbols.list)
xmfree (objfile->md, objfile->static_psymbols.list);
memset (&objfile->static_psymbols, 0,
sizeof (objfile->static_psymbols));
bcache_xfree (objfile->psymbol_cache);
objfile->psymbol_cache = bcache_xmalloc (NULL);
bcache_xfree (objfile->macro_cache);
objfile->macro_cache = bcache_xmalloc (NULL);
obstack_free (&objfile->psymbol_obstack, 0);
obstack_free (&objfile->symbol_obstack, 0);
obstack_free (&objfile->type_obstack, 0);
objfile->sections = NULL;
objfile->symtabs = NULL;
objfile->psymtabs = NULL;
objfile->free_psymtabs = NULL;
objfile->msymbols = NULL;
objfile->minimal_symbol_count = 0;
memset (&objfile->msymbol_hash, 0,
sizeof (objfile->msymbol_hash));
memset (&objfile->msymbol_demangled_hash, 0,
sizeof (objfile->msymbol_demangled_hash));
objfile->minimal_symbols_demangled = 0;
objfile->fundamental_types = NULL;
if (objfile->sf != NULL)
{
(*objfile->sf->sym_finish) (objfile);
}
objfile->md = NULL;
objfile->psymbol_cache = bcache_xmalloc (NULL);
objfile->macro_cache = bcache_xmalloc (NULL);
obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0,
xmalloc, xfree);
obstack_specify_allocation (&objfile->symbol_obstack, 0, 0,
xmalloc, xfree);
obstack_specify_allocation (&objfile->type_obstack, 0, 0,
xmalloc, xfree);
if (build_objfile_section_table (objfile))
{
error ("Can't find the file sections in `%s': %s",
objfile->name, bfd_errmsg (bfd_get_error ()));
}
objfile->section_offsets = (struct section_offsets *)
obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
memcpy (objfile->section_offsets, offsets, SIZEOF_SECTION_OFFSETS);
objfile->num_sections = num_offsets;
if (objfile == symfile_objfile)
{
(*objfile->sf->sym_new_init) (objfile);
#ifdef HPUXHPPA
RESET_HP_UX_GLOBALS ();
#endif
}
(*objfile->sf->sym_init) (objfile);
clear_complaints (&symfile_complaints, 1, 1);
if (objfile->symflags & ~OBJF_SYM_CONTAINER)
(*objfile->sf->sym_read) (objfile, 0);
if (!have_partial_symbols () && !have_full_symbols ())
{
wrap_here ("");
printf_filtered ("(no debugging symbols found)\n");
wrap_here ("");
}
objfile->flags |= OBJF_SYMS;
clear_complaints (&symfile_complaints, 0, 1);
reinit_frame_cache ();
discard_cleanups (old_cleanups);
objfile->mtime = new_modtime;
reread_one = 1;
TARGET_SYMFILE_POSTREAD (objfile);
}
}
}
if (reread_one)
clear_symtab_users ();
}
static void
reread_symbols_command (args, from_tty)
char *args;
int from_tty;
{
reread_symbols ();
}
struct objfile *
find_objfile (const char *name)
{
struct objfile *objfile = NULL;
struct objfile *o, *temp;
ALL_OBJFILES_SAFE (o, temp)
{
if (strcmp (name, o->name) == 0)
{
if (objfile == NULL)
{
objfile = o;
}
else
{
warning ("Multiple object files exist with name \"%s\": choosing first", o->name);
}
}
}
return objfile;
}
static void
remove_symbol_file_command (args, from_tty)
char *args;
int from_tty;
{
char *name = NULL;
struct objfile *objfile = NULL;
dont_repeat ();
if (args == NULL)
{
error ("remove-symbol-file takes a file name");
}
name = tilde_expand (args);
make_cleanup (free, name);
objfile = find_objfile (name);
if (objfile == NULL)
{
error ("unable to locate object file named \"%s\"", args);
}
free_objfile (objfile);
clear_symtab_users ();
reinit_frame_cache ();
}
typedef struct
{
char *ext;
enum language lang;
}
filename_language;
static filename_language *filename_language_table;
static int fl_table_size, fl_table_next;
static void
add_filename_language (char *ext, enum language lang)
{
if (fl_table_next >= fl_table_size)
{
fl_table_size += 10;
filename_language_table =
xrealloc (filename_language_table,
fl_table_size * sizeof (*filename_language_table));
}
filename_language_table[fl_table_next].ext = xstrdup (ext);
filename_language_table[fl_table_next].lang = lang;
fl_table_next++;
}
static char *ext_args;
static void
set_ext_lang_command (char *args, int from_tty)
{
int i;
char *cp = ext_args;
enum language lang;
if (*cp != '.')
error ("'%s': Filename extension must begin with '.'", ext_args);
while (*cp && !isspace (*cp))
cp++;
if (*cp == '\0')
error ("'%s': two arguments required -- filename extension and language",
ext_args);
*cp++ = '\0';
while (*cp && isspace (*cp))
cp++;
if (*cp == '\0')
error ("'%s': two arguments required -- filename extension and language",
ext_args);
lang = language_enum (cp);
for (i = 0; i < fl_table_next; i++)
if (0 == strcmp (ext_args, filename_language_table[i].ext))
break;
if (i >= fl_table_next)
{
add_filename_language (ext_args, lang);
}
else
{
xfree (filename_language_table[i].ext);
filename_language_table[i].ext = xstrdup (ext_args);
filename_language_table[i].lang = lang;
}
}
static void
info_ext_lang_command (char *args, int from_tty)
{
int i;
printf_filtered ("Filename extensions and the languages they represent:");
printf_filtered ("\n\n");
for (i = 0; i < fl_table_next; i++)
printf_filtered ("\t%s\t- %s\n",
filename_language_table[i].ext,
language_str (filename_language_table[i].lang));
}
static void
init_filename_language_table (void)
{
if (fl_table_size == 0)
{
fl_table_size = 20;
fl_table_next = 0;
filename_language_table =
xmalloc (fl_table_size * sizeof (*filename_language_table));
add_filename_language (".c", language_c);
add_filename_language (".C", language_cplus);
add_filename_language (".cc", language_cplus);
add_filename_language (".cp", language_cplus);
add_filename_language (".cpp", language_cplus);
add_filename_language (".cxx", language_cplus);
add_filename_language (".c++", language_cplus);
add_filename_language (".java", language_java);
add_filename_language (".class", language_java);
add_filename_language (".m", language_objc);
add_filename_language (".mm", language_objcplus);
add_filename_language (".M", language_objcplus);
add_filename_language (".f", language_fortran);
add_filename_language (".F", language_fortran);
add_filename_language (".s", language_asm);
add_filename_language (".S", language_asm);
add_filename_language (".pas", language_pascal);
add_filename_language (".p", language_pascal);
add_filename_language (".pp", language_pascal);
}
}
enum language
deduce_language_from_filename (char *filename)
{
int i;
char *cp;
if (filename != NULL)
if ((cp = strrchr (filename, '.')) != NULL)
for (i = 0; i < fl_table_next; i++)
if (strcmp (cp, filename_language_table[i].ext) == 0)
return filename_language_table[i].lang;
return language_unknown;
}
struct symtab *
allocate_symtab (char *filename, struct objfile *objfile)
{
register struct symtab *symtab;
symtab = (struct symtab *)
obstack_alloc (&objfile->symbol_obstack, sizeof (struct symtab));
memset (symtab, 0, sizeof (*symtab));
symtab->filename = obsavestring (filename, strlen (filename),
&objfile->symbol_obstack);
symtab->fullname = NULL;
symtab->language = deduce_language_from_filename (filename);
symtab->debugformat = obsavestring ("unknown", 7,
&objfile->symbol_obstack);
symtab->objfile = objfile;
symtab->next = objfile->symtabs;
objfile->symtabs = symtab;
#ifdef INIT_EXTRA_SYMTAB_INFO
INIT_EXTRA_SYMTAB_INFO (symtab);
#endif
return (symtab);
}
struct partial_symtab *
allocate_psymtab (char *filename, struct objfile *objfile)
{
struct partial_symtab *psymtab;
if (objfile->free_psymtabs)
{
psymtab = objfile->free_psymtabs;
objfile->free_psymtabs = psymtab->next;
}
else
psymtab = (struct partial_symtab *)
obstack_alloc (&objfile->psymbol_obstack,
sizeof (struct partial_symtab));
memset (psymtab, 0, sizeof (struct partial_symtab));
psymtab->filename = obsavestring (filename, strlen (filename),
&objfile->psymbol_obstack);
psymtab->symtab = NULL;
psymtab->objfile = objfile;
psymtab->next = objfile->psymtabs;
objfile->psymtabs = psymtab;
#if 0
{
struct partial_symtab **prev_pst;
psymtab->objfile = objfile;
psymtab->next = NULL;
prev_pst = &(objfile->psymtabs);
while ((*prev_pst) != NULL)
prev_pst = &((*prev_pst)->next);
(*prev_pst) = psymtab;
}
#endif
return (psymtab);
}
void
discard_psymtab (struct partial_symtab *pst)
{
struct partial_symtab **prev_pst;
prev_pst = &(pst->objfile->psymtabs);
while ((*prev_pst) != pst)
prev_pst = &((*prev_pst)->next);
(*prev_pst) = pst->next;
pst->next = pst->objfile->free_psymtabs;
pst->objfile->free_psymtabs = pst;
}
void
clear_symtab_users (void)
{
clear_value_history ();
clear_displays ();
clear_internalvars ();
breakpoint_re_set ();
set_default_breakpoint (0, 0, 0, 0);
clear_current_source_symtab_and_line ();
clear_pc_function_cache ();
if (target_new_objfile_hook)
target_new_objfile_hook (NULL);
}
static void
clear_symtab_users_cleanup (void *ignore)
{
clear_symtab_users ();
}
#if 0
static void clear_symtab_users_once (void);
static int clear_symtab_users_queued;
static int clear_symtab_users_done;
static void
clear_symtab_users_once (void)
{
if (clear_symtab_users_queued <= clear_symtab_users_done)
return;
clear_symtab_users_done = clear_symtab_users_queued;
clear_symtab_users ();
}
#endif
static void
cashier_psymtab (struct partial_symtab *pst)
{
struct partial_symtab *ps, *pprev = NULL;
int i;
for (ps = pst->objfile->psymtabs; ps; ps = ps->next)
{
if (ps == pst)
break;
pprev = ps;
}
if (ps)
{
if (ps == pst->objfile->psymtabs)
pst->objfile->psymtabs = ps->next;
else
pprev->next = ps->next;
again:
for (ps = pst->objfile->psymtabs; ps; ps = ps->next)
{
for (i = 0; i < ps->number_of_dependencies; i++)
{
if (ps->dependencies[i] == pst)
{
cashier_psymtab (ps);
goto again;
}
}
}
}
}
int
free_named_symtabs (char *name)
{
#if 0
register struct symtab *s;
register struct symtab *prev;
register struct partial_symtab *ps;
struct blockvector *bv;
int blewit = 0;
if (!symbol_reloading)
return 0;
if (name == 0 || *name == '\0')
return 0;
again2:
for (ps = partial_symtab_list; ps; ps = ps->next)
{
if (STREQ (name, ps->filename))
{
cashier_psymtab (ps);
goto again2;
}
}
for (s = symtab_list; s; s = s->next)
{
if (STREQ (name, s->filename))
break;
prev = s;
}
if (s)
{
if (s == symtab_list)
symtab_list = s->next;
else
prev->next = s->next;
bv = BLOCKVECTOR (s);
if (BLOCKVECTOR_NBLOCKS (bv) > 2
|| BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
|| BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)))
{
complaint (&symfile_complaints, "Replacing old symbols for `%s'",
name);
clear_symtab_users_queued++;
make_cleanup (clear_symtab_users_once, 0);
blewit = 1;
}
else
{
complaint (&symfile_complaints, "Empty symbol table found for `%s'",
name);
}
free_symtab (s);
}
else
{
;
}
return blewit;
#else
return (0);
#endif
}
struct partial_symtab *
start_psymtab_common (struct objfile *objfile,
struct section_offsets *section_offsets, char *filename,
CORE_ADDR textlow, struct partial_symbol **global_syms,
struct partial_symbol **static_syms)
{
struct partial_symtab *psymtab;
psymtab = allocate_psymtab (filename, objfile);
psymtab->section_offsets = section_offsets;
psymtab->textlow = textlow;
psymtab->texthigh = psymtab->textlow;
psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
return (psymtab);
}
void
add_psymbol_to_list (char *name, int namelength, namespace_enum namespace,
enum address_class class,
struct psymbol_allocation_list *list, long val,
CORE_ADDR coreaddr,
enum language language, struct objfile *objfile)
{
register struct partial_symbol *psym;
char *buf = alloca (namelength + 1);
static struct partial_symbol psymbol;
memcpy (buf, name, namelength);
buf[namelength] = '\0';
SYMBOL_NAME (&psymbol) = bcache (buf, namelength + 1, objfile->psymbol_cache);
if (val != 0)
{
SYMBOL_VALUE (&psymbol) = val;
}
else
{
SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
}
SYMBOL_SECTION (&psymbol) = 0;
SYMBOL_LANGUAGE (&psymbol) = language;
PSYMBOL_NAMESPACE (&psymbol) = namespace;
PSYMBOL_CLASS (&psymbol) = class;
SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol, language);
psym = bcache (&psymbol, sizeof (struct partial_symbol), objfile->psymbol_cache);
if (list->next >= list->list + list->size)
{
extend_psymbol_list (list, objfile);
}
*list->next++ = psym;
OBJSTAT (objfile, n_psyms++);
}
void
add_psymbol_with_dem_name_to_list (char *name, int namelength, char *dem_name,
int dem_namelength, namespace_enum namespace,
enum address_class class,
struct psymbol_allocation_list *list, long val,
CORE_ADDR coreaddr,
enum language language,
struct objfile *objfile)
{
register struct partial_symbol *psym;
char *buf = alloca (namelength + 1);
static struct partial_symbol psymbol;
memcpy (buf, name, namelength);
buf[namelength] = '\0';
SYMBOL_NAME (&psymbol) = bcache (buf, namelength + 1, objfile->psymbol_cache);
buf = alloca (dem_namelength + 1);
memcpy (buf, dem_name, dem_namelength);
buf[dem_namelength] = '\0';
switch (language)
{
case language_c:
case language_cplus:
SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol) =
bcache (buf, dem_namelength + 1, objfile->psymbol_cache);
break;
default:
internal_error (__FILE__, __LINE__, "unhandled case");
break;
}
if (val != 0)
{
SYMBOL_VALUE (&psymbol) = val;
}
else
{
SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
}
SYMBOL_SECTION (&psymbol) = 0;
SYMBOL_LANGUAGE (&psymbol) = language;
PSYMBOL_NAMESPACE (&psymbol) = namespace;
PSYMBOL_CLASS (&psymbol) = class;
SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol, language);
psym = bcache (&psymbol, sizeof (struct partial_symbol), objfile->psymbol_cache);
if (list->next >= list->list + list->size)
{
extend_psymbol_list (list, objfile);
}
*list->next++ = psym;
OBJSTAT (objfile, n_psyms++);
}
void
init_psymbol_list (struct objfile *objfile, int total_symbols)
{
if (objfile->global_psymbols.list)
{
xmfree (objfile->md, (PTR) objfile->global_psymbols.list);
}
if (objfile->static_psymbols.list)
{
xmfree (objfile->md, (PTR) objfile->static_psymbols.list);
}
objfile->global_psymbols.size = total_symbols / 10;
objfile->static_psymbols.size = total_symbols / 10;
if (objfile->global_psymbols.size > 0)
{
objfile->global_psymbols.next =
objfile->global_psymbols.list = (struct partial_symbol **)
xmmalloc (objfile->md, (objfile->global_psymbols.size
* sizeof (struct partial_symbol *)));
}
if (objfile->static_psymbols.size > 0)
{
objfile->static_psymbols.next =
objfile->static_psymbols.list = (struct partial_symbol **)
xmmalloc (objfile->md, (objfile->static_psymbols.size
* sizeof (struct partial_symbol *)));
}
}
enum overlay_debugging_state overlay_debugging = ovly_off;
int overlay_cache_invalid = 0;
static void simple_overlay_update (struct obj_section *);
void (*target_overlay_update) (struct obj_section *) = simple_overlay_update;
int
section_is_overlay (asection *section)
{
if (overlay_debugging)
if (section && section->lma != 0 &&
section->vma != section->lma)
return 1;
return 0;
}
static void
overlay_invalidate_all (void)
{
struct objfile *objfile;
struct obj_section *sect;
ALL_OBJSECTIONS (objfile, sect)
if (section_is_overlay (sect->the_bfd_section))
sect->ovly_mapped = -1;
}
static int
overlay_is_mapped (struct obj_section *osect)
{
if (osect == 0 || !section_is_overlay (osect->the_bfd_section))
return 0;
switch (overlay_debugging)
{
default:
case ovly_off:
return 0;
case ovly_auto:
if (target_overlay_update)
{
if (overlay_cache_invalid)
{
overlay_invalidate_all ();
overlay_cache_invalid = 0;
}
if (osect->ovly_mapped == -1)
(*target_overlay_update) (osect);
}
case ovly_on:
return osect->ovly_mapped == 1;
}
}
int
section_is_mapped (asection *section)
{
struct objfile *objfile;
struct obj_section *osect;
if (overlay_debugging)
if (section && section_is_overlay (section))
ALL_OBJSECTIONS (objfile, osect)
if (osect->the_bfd_section == section)
return overlay_is_mapped (osect);
return 0;
}
CORE_ADDR
pc_in_unmapped_range (CORE_ADDR pc, asection *section)
{
int size;
if (overlay_debugging)
if (section && section_is_overlay (section))
{
size = bfd_get_section_size_before_reloc (section);
if (section->lma <= pc && pc < section->lma + size)
return 1;
}
return 0;
}
CORE_ADDR
pc_in_mapped_range (CORE_ADDR pc, asection *section)
{
int size;
if (overlay_debugging)
if (section && section_is_overlay (section))
{
size = bfd_get_section_size_before_reloc (section);
if (section->vma <= pc && pc < section->vma + size)
return 1;
}
return 0;
}
int
sections_overlap (asection *a, asection *b)
{
CORE_ADDR a_start = a->vma;
CORE_ADDR a_end = a->vma + bfd_get_section_size_before_reloc (a);
CORE_ADDR b_start = b->vma;
CORE_ADDR b_end = b->vma + bfd_get_section_size_before_reloc (b);
return (a_start < b_end && b_start < a_end);
}
CORE_ADDR
overlay_unmapped_address (CORE_ADDR pc, asection *section)
{
if (overlay_debugging)
if (section && section_is_overlay (section) &&
pc_in_mapped_range (pc, section))
return pc + section->lma - section->vma;
return pc;
}
CORE_ADDR
overlay_mapped_address (CORE_ADDR pc, asection *section)
{
if (overlay_debugging)
if (section && section_is_overlay (section) &&
pc_in_unmapped_range (pc, section))
return pc + section->vma - section->lma;
return pc;
}
CORE_ADDR
symbol_overlayed_address (CORE_ADDR address, asection *section)
{
if (overlay_debugging)
{
if (section == 0)
return address;
if (!section_is_overlay (section))
return address;
if (section_is_mapped (section))
return address;
return overlay_unmapped_address (address, section);
}
return address;
}
asection *
find_pc_overlay (CORE_ADDR pc)
{
struct objfile *objfile;
struct obj_section *osect, *best_match = NULL;
if (overlay_debugging)
ALL_OBJSECTIONS (objfile, osect)
if (section_is_overlay (osect->the_bfd_section))
{
if (pc_in_mapped_range (pc, osect->the_bfd_section))
{
if (overlay_is_mapped (osect))
return osect->the_bfd_section;
else
best_match = osect;
}
else if (pc_in_unmapped_range (pc, osect->the_bfd_section))
best_match = osect;
}
return best_match ? best_match->the_bfd_section : NULL;
}
asection *
find_pc_mapped_section (CORE_ADDR pc)
{
struct objfile *objfile;
struct obj_section *osect;
if (overlay_debugging)
ALL_OBJSECTIONS (objfile, osect)
if (pc_in_mapped_range (pc, osect->the_bfd_section) &&
overlay_is_mapped (osect))
return osect->the_bfd_section;
return NULL;
}
void
list_overlays_command (char *args, int from_tty)
{
int nmapped = 0;
struct objfile *objfile;
struct obj_section *osect;
if (overlay_debugging)
ALL_OBJSECTIONS (objfile, osect)
if (overlay_is_mapped (osect))
{
const char *name;
bfd_vma lma, vma;
int size;
vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section);
lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section);
size = bfd_get_section_size_before_reloc (osect->the_bfd_section);
name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
printf_filtered ("Section %s, loaded at ", name);
print_address_numeric (lma, 1, gdb_stdout);
puts_filtered (" - ");
print_address_numeric (lma + size, 1, gdb_stdout);
printf_filtered (", mapped at ");
print_address_numeric (vma, 1, gdb_stdout);
puts_filtered (" - ");
print_address_numeric (vma + size, 1, gdb_stdout);
puts_filtered ("\n");
nmapped++;
}
if (nmapped == 0)
printf_filtered ("No sections are mapped.\n");
}
void
map_overlay_command (char *args, int from_tty)
{
struct objfile *objfile, *objfile2;
struct obj_section *sec, *sec2;
asection *bfdsec;
if (!overlay_debugging)
error ("\
Overlay debugging not enabled. Use either the 'overlay auto' or\n\
the 'overlay manual' command.");
if (args == 0 || *args == 0)
error ("Argument required: name of an overlay section");
ALL_OBJSECTIONS (objfile, sec)
if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
{
bfdsec = sec->the_bfd_section;
if (!section_is_overlay (bfdsec))
continue;
sec->ovly_mapped = 1;
ALL_OBJSECTIONS (objfile2, sec2)
if (sec2->ovly_mapped
&& sec != sec2
&& sec->the_bfd_section != sec2->the_bfd_section
&& sections_overlap (sec->the_bfd_section,
sec2->the_bfd_section))
{
if (info_verbose)
printf_filtered ("Note: section %s unmapped by overlap\n",
bfd_section_name (objfile->obfd,
sec2->the_bfd_section));
sec2->ovly_mapped = 0;
}
return;
}
error ("No overlay section called %s", args);
}
void
unmap_overlay_command (char *args, int from_tty)
{
struct objfile *objfile;
struct obj_section *sec;
if (!overlay_debugging)
error ("\
Overlay debugging not enabled. Use either the 'overlay auto' or\n\
the 'overlay manual' command.");
if (args == 0 || *args == 0)
error ("Argument required: name of an overlay section");
ALL_OBJSECTIONS (objfile, sec)
if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
{
if (!sec->ovly_mapped)
error ("Section %s is not mapped", args);
sec->ovly_mapped = 0;
return;
}
error ("No overlay section called %s", args);
}
static void
overlay_auto_command (char *args, int from_tty)
{
overlay_debugging = ovly_auto;
enable_overlay_breakpoints ();
if (info_verbose)
printf_filtered ("Automatic overlay debugging enabled.");
}
static void
overlay_manual_command (char *args, int from_tty)
{
overlay_debugging = ovly_on;
disable_overlay_breakpoints ();
if (info_verbose)
printf_filtered ("Overlay debugging enabled.");
}
static void
overlay_off_command (char *args, int from_tty)
{
overlay_debugging = ovly_off;
disable_overlay_breakpoints ();
if (info_verbose)
printf_filtered ("Overlay debugging disabled.");
}
static void
overlay_load_command (char *args, int from_tty)
{
if (target_overlay_update)
(*target_overlay_update) (NULL);
else
error ("This target does not know how to read its overlay state.");
}
struct cmd_list_element *overlaylist;
static void
overlay_command (char *args, int from_tty)
{
printf_unfiltered
("\"overlay\" must be followed by the name of an overlay command.\n");
help_list (overlaylist, "overlay ", -1, gdb_stdout);
}
static unsigned (*cache_ovly_table)[4] = 0;
#if 0
static unsigned (*cache_ovly_region_table)[3] = 0;
#endif
static unsigned cache_novlys = 0;
#if 0
static unsigned cache_novly_regions = 0;
#endif
static CORE_ADDR cache_ovly_table_base = 0;
#if 0
static CORE_ADDR cache_ovly_region_table_base = 0;
#endif
enum ovly_index
{
VMA, SIZE, LMA, MAPPED
};
#define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT)
static void
simple_free_overlay_table (void)
{
if (cache_ovly_table)
xfree (cache_ovly_table);
cache_novlys = 0;
cache_ovly_table = NULL;
cache_ovly_table_base = 0;
}
#if 0
static void
simple_free_overlay_region_table (void)
{
if (cache_ovly_region_table)
xfree (cache_ovly_region_table);
cache_novly_regions = 0;
cache_ovly_region_table = NULL;
cache_ovly_region_table_base = 0;
}
#endif
static void
read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr, int len)
{
char *buf = alloca (len * TARGET_LONG_BYTES);
int i;
read_memory (memaddr, buf, len * TARGET_LONG_BYTES);
for (i = 0; i < len; i++)
myaddr[i] = extract_unsigned_integer (TARGET_LONG_BYTES * i + buf,
TARGET_LONG_BYTES);
}
static int
simple_read_overlay_table (void)
{
struct minimal_symbol *novlys_msym, *ovly_table_msym;
simple_free_overlay_table ();
novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL);
if (! novlys_msym)
{
error ("Error reading inferior's overlay table: "
"couldn't find `_novlys' variable\n"
"in inferior. Use `overlay manual' mode.");
return 0;
}
ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
if (! ovly_table_msym)
{
error ("Error reading inferior's overlay table: couldn't find "
"`_ovly_table' array\n"
"in inferior. Use `overlay manual' mode.");
return 0;
}
cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym), 4);
cache_ovly_table
= (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym);
read_target_long_array (cache_ovly_table_base,
(int *) cache_ovly_table,
cache_novlys * 4);
return 1;
}
#if 0
static int
simple_read_overlay_region_table (void)
{
struct minimal_symbol *msym;
simple_free_overlay_region_table ();
msym = lookup_minimal_symbol ("_novly_regions", NULL, NULL);
if (msym != NULL)
cache_novly_regions = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym), 4);
else
return 0;
cache_ovly_region_table = (void *) xmalloc (cache_novly_regions * 12);
if (cache_ovly_region_table != NULL)
{
msym = lookup_minimal_symbol ("_ovly_region_table", NULL, NULL);
if (msym != NULL)
{
cache_ovly_region_table_base = SYMBOL_VALUE_ADDRESS (msym);
read_target_long_array (cache_ovly_region_table_base,
(int *) cache_ovly_region_table,
cache_novly_regions * 3);
}
else
return 0;
}
else
return 0;
return 1;
}
#endif
static int
simple_overlay_update_1 (struct obj_section *osect)
{
int i, size;
bfd *obfd = osect->objfile->obfd;
asection *bsect = osect->the_bfd_section;
size = bfd_get_section_size_before_reloc (osect->the_bfd_section);
for (i = 0; i < cache_novlys; i++)
if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
&& cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
)
{
read_target_long_array (cache_ovly_table_base + i * TARGET_LONG_BYTES,
(int *) cache_ovly_table[i], 4);
if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
&& cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
)
{
osect->ovly_mapped = cache_ovly_table[i][MAPPED];
return 1;
}
else
return 0;
}
return 0;
}
static void
simple_overlay_update (struct obj_section *osect)
{
struct objfile *objfile;
if (osect)
if (cache_ovly_table != NULL)
if (cache_ovly_table_base ==
SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL, NULL)))
if (simple_overlay_update_1 (osect))
return;
if (! simple_read_overlay_table ())
return;
ALL_OBJSECTIONS (objfile, osect)
if (section_is_overlay (osect->the_bfd_section))
{
int i, size;
bfd *obfd = osect->objfile->obfd;
asection *bsect = osect->the_bfd_section;
size = bfd_get_section_size_before_reloc (osect->the_bfd_section);
for (i = 0; i < cache_novlys; i++)
if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
&& cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
)
{
osect->ovly_mapped = cache_ovly_table[i][MAPPED];
break;
}
}
}
struct symbol_file_info {
bfd *abfd;
int from_tty;
struct section_addr_info *addrs;
int mainline;
int flags;
int symflags;
CORE_ADDR mapaddr;
const char *prefix;
struct objfile *result;
};
int symbol_file_add_bfd_helper (char *v)
{
struct symbol_file_info *s = (struct symbol_file_info *) v;
s->result = symbol_file_add_bfd
(s->abfd, s->from_tty, s->addrs, s->mainline, s->flags, s->symflags, s->mapaddr, s->prefix);
return 1;
}
struct objfile *symbol_file_add_bfd_safe
(bfd *abfd, int from_tty, struct section_addr_info *addrs,
int mainline, int flags, int symflags, CORE_ADDR mapaddr, const char *prefix)
{
struct symbol_file_info s;
int ret;
s.abfd = abfd;
s.from_tty = from_tty;
s.addrs = addrs;
s.mainline = mainline;
s.flags = flags;
s.symflags = symflags;
s.mapaddr = mapaddr;
s.prefix = prefix;
s.result = NULL;
ret = catch_errors
(symbol_file_add_bfd_helper, &s, "unable to load symbol file: ", RETURN_MASK_ALL);
return s.result;
}
struct bfd_file_info {
const char *filename;
bfd *result;
};
int symfile_bfd_open_helper
(char *v)
{
struct bfd_file_info *s = (struct bfd_file_info *) v;
s->result = symfile_bfd_open (s->filename);
return 1;
}
bfd *symfile_bfd_open_safe
(const char *filename)
{
struct bfd_file_info s;
int ret;
s.filename = filename;
s.result = NULL;
ret = catch_errors
(symfile_bfd_open_helper, &s, "unable to open symbol file: ", RETURN_MASK_ALL);
return s.result;
}
void
_initialize_symfile (void)
{
struct cmd_list_element *c;
#if HAVE_MMAP
c = add_set_cmd ("mmap-symbol-files", class_obscure, var_boolean,
(char *) &mmap_symbol_files_flag,
"Set if GDB should use mmap() to read from external symbol files.",
&setlist);
add_show_from_set (c, &showlist);
#endif
c = add_cmd ("reread-symbols", class_files, reread_symbols_command,
"Usage: reread-symbols\n\
Re-load the symbols from all known object files.",
&cmdlist);
c = add_cmd ("remove-symbol-file", class_files, remove_symbol_file_command,
"Usage: remove-symbol-file FILE\n\
Unload the symbols from FILE.",
&cmdlist);
set_cmd_completer (c, filename_completer);
c = add_cmd ("symbol-file", class_files, symbol_file_command,
"Load symbol table from executable file FILE.\n\
The `file' command can also load symbol tables, as well as setting the file\n\
to execute.", &cmdlist);
set_cmd_completer (c, filename_completer);
c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command,
"Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
ADDR is the starting address of the file's text.\n\
The optional arguments are section-name section-address pairs and\n\
should be specified if the data and bss segments are not contiguous\n\
with the text. SECT is a section name to be loaded at SECT_ADDR.",
&cmdlist);
set_cmd_completer (c, filename_completer);
c = add_cmd ("add-shared-symbol-files", class_files,
add_shared_symbol_files_command,
"Load the symbols from shared objects in the dynamic linker's link map.",
&cmdlist);
c = add_alias_cmd ("assf", "add-shared-symbol-files", class_files, 1,
&cmdlist);
c = add_cmd ("load", class_files, load_command,
"Dynamically load FILE into the running program, and record its symbols\n\
for access from GDB.", &cmdlist);
set_cmd_completer (c, filename_completer);
add_show_from_set
(add_set_cmd ("symbol-reloading", class_support, var_boolean,
(char *) &symbol_reloading,
"Set dynamic symbol table reloading multiple times in one run.",
&setlist),
&showlist);
add_prefix_cmd ("overlay", class_support, overlay_command,
"Commands for debugging overlays.", &overlaylist,
"overlay ", 0, &cmdlist);
add_com_alias ("ovly", "overlay", class_alias, 1);
add_com_alias ("ov", "overlay", class_alias, 1);
add_cmd ("map-overlay", class_support, map_overlay_command,
"Assert that an overlay section is mapped.", &overlaylist);
add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
"Assert that an overlay section is unmapped.", &overlaylist);
add_cmd ("list-overlays", class_support, list_overlays_command,
"List mappings of overlay sections.", &overlaylist);
add_cmd ("manual", class_support, overlay_manual_command,
"Enable overlay debugging.", &overlaylist);
add_cmd ("off", class_support, overlay_off_command,
"Disable overlay debugging.", &overlaylist);
add_cmd ("auto", class_support, overlay_auto_command,
"Enable automatic overlay debugging.", &overlaylist);
add_cmd ("load-target", class_support, overlay_load_command,
"Read the overlay mapping state from the target.", &overlaylist);
init_filename_language_table ();
c = add_set_cmd ("extension-language", class_files, var_string_noescape,
(char *) &ext_args,
"Set mapping between filename extension and source language.\n\
Usage: set extension-language .foo bar",
&setlist);
set_cmd_cfunc (c, set_ext_lang_command);
add_info ("extensions", info_ext_lang_command,
"All filename extensions associated with a source language.");
add_show_from_set
(add_set_cmd ("download-write-size", class_obscure,
var_integer, (char *) &download_write_size,
"Set the write size used when downloading a program.\n"
"Only used when downloading a program onto a remote\n"
"target. Specify zero, or a negative value, to disable\n"
"blocked writes. The actual size of each transfer is also\n"
"limited by the size of the target packet and the memory\n"
"cache.\n",
&setlist),
&showlist);
}