/* Generic symbol file reading for the GNU debugger, GDB.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998
- Free Software Foundation, Inc.
+ Copyright 1990-1996, 1998, 2000 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
This file is part of GDB.
#include "gdb_stat.h"
#include <ctype.h>
#include <time.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
#ifndef O_BINARY
#define O_BINARY 0
} while (0)
#endif
-int (*ui_load_progress_hook) PARAMS ((char *, unsigned long));
-void (*pre_add_symbol_hook) PARAMS ((char *));
-void (*post_add_symbol_hook) PARAMS ((void));
+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);
/* Global variables owned by this file */
int readnow_symbol_files; /* Read full symbols immediately */
"Empty symbol table found for `%s'", 0, 0
};
+struct complaint unknown_option_complaint =
+{
+ "Unknown option `%s' ignored", 0, 0
+};
+
/* External variables and functions referenced. */
extern int info_verbose;
-extern void report_transfer_performance PARAMS ((unsigned long,
- time_t, time_t));
+extern void report_transfer_performance (unsigned long, time_t, time_t);
/* Functions this file defines */
#if 0
-static int simple_read_overlay_region_table PARAMS ((void));
-static void simple_free_overlay_region_table PARAMS ((void));
+static int simple_read_overlay_region_table (void);
+static void simple_free_overlay_region_table (void);
#endif
-static void set_initial_language PARAMS ((void));
+static void set_initial_language (void);
-static void load_command PARAMS ((char *, int));
+static void load_command (char *, int);
-static void add_symbol_file_command PARAMS ((char *, int));
+static void add_symbol_file_command (char *, int);
-static void add_shared_symbol_files_command PARAMS ((char *, int));
+static void add_shared_symbol_files_command (char *, int);
-static void cashier_psymtab PARAMS ((struct partial_symtab *));
+static void cashier_psymtab (struct partial_symtab *);
-static int compare_psymbols PARAMS ((const void *, const void *));
+static int compare_psymbols (const void *, const void *);
-static int compare_symbols PARAMS ((const void *, const void *));
+static int compare_symbols (const void *, const void *);
-bfd *symfile_bfd_open PARAMS ((char *));
+bfd *symfile_bfd_open (char *);
-static void find_sym_fns PARAMS ((struct objfile *));
+static void find_sym_fns (struct objfile *);
-static void decrement_reading_symtab PARAMS ((void *));
+static void decrement_reading_symtab (void *);
-static void overlay_invalidate_all PARAMS ((void));
+static void overlay_invalidate_all (void);
-static int overlay_is_mapped PARAMS ((struct obj_section *));
+static int overlay_is_mapped (struct obj_section *);
-void list_overlays_command PARAMS ((char *, int));
+void list_overlays_command (char *, int);
-void map_overlay_command PARAMS ((char *, int));
+void map_overlay_command (char *, int);
-void unmap_overlay_command PARAMS ((char *, int));
+void unmap_overlay_command (char *, int);
-static void overlay_auto_command PARAMS ((char *, int));
+static void overlay_auto_command (char *, int);
-static void overlay_manual_command PARAMS ((char *, int));
+static void overlay_manual_command (char *, int);
-static void overlay_off_command PARAMS ((char *, int));
+static void overlay_off_command (char *, int);
-static void overlay_load_command PARAMS ((char *, int));
+static void overlay_load_command (char *, int);
-static void overlay_command PARAMS ((char *, int));
+static void overlay_command (char *, int);
-static void simple_free_overlay_table PARAMS ((void));
+static void simple_free_overlay_table (void);
-static void read_target_long_array PARAMS ((CORE_ADDR, unsigned int *, int));
+static void read_target_long_array (CORE_ADDR, unsigned int *, int);
-static int simple_read_overlay_table PARAMS ((void));
+static int simple_read_overlay_table (void);
-static int simple_overlay_update_1 PARAMS ((struct obj_section *));
+static int simple_overlay_update_1 (struct obj_section *);
-static void add_filename_language PARAMS ((char *ext, enum language lang));
+static void add_filename_language (char *ext, enum language lang);
-static void set_ext_lang_command PARAMS ((char *args, int from_tty));
+static void set_ext_lang_command (char *args, int from_tty);
-static void info_ext_lang_command PARAMS ((char *args, int from_tty));
+static void info_ext_lang_command (char *args, int from_tty);
-static void init_filename_language_table PARAMS ((void));
+static void init_filename_language_table (void);
-void _initialize_symfile PARAMS ((void));
+void _initialize_symfile (void);
/* List of all available sym_fns. On gdb startup, each object file reader
calls add_symtab_fns() to register information on each format it is
comparison function takes two "void *" pointers. */
static int
-compare_symbols (s1p, s2p)
- const PTR s1p;
- const PTR s2p;
+compare_symbols (const PTR s1p, const PTR s2p)
{
register struct symbol **s1, **s2;
s1 = (struct symbol **) s1p;
s2 = (struct symbol **) s2p;
-
- return (STRCMP (SYMBOL_NAME (*s1), SYMBOL_NAME (*s2)));
+ return (STRCMP (SYMBOL_SOURCE_NAME (*s1), SYMBOL_SOURCE_NAME (*s2)));
}
/*
*/
static int
-compare_psymbols (s1p, s2p)
- const PTR s1p;
- const PTR s2p;
+compare_psymbols (const PTR s1p, const PTR s2p)
{
- register char *st1 = SYMBOL_NAME (*(struct partial_symbol **) s1p);
- register char *st2 = SYMBOL_NAME (*(struct partial_symbol **) 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])
{
}
void
-sort_pst_symbols (pst)
- struct partial_symtab *pst;
+sort_pst_symbols (struct partial_symtab *pst)
{
/* Sort the global list; don't sort the static list */
/* Call sort_block_syms to sort alphabetically the symbols of one block. */
void
-sort_block_syms (b)
- register struct block *b;
+sort_block_syms (register struct block *b)
{
qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
sizeof (struct symbol *), compare_symbols);
the symbols of each block of one symtab. */
void
-sort_symtab_syms (s)
- register struct symtab *s;
+sort_symtab_syms (register struct symtab *s)
{
register struct blockvector *bv;
int nbl;
may be part of a larger string and we are only saving a substring. */
char *
-obsavestring (ptr, size, obstackp)
- char *ptr;
- int size;
- struct obstack *obstackp;
+obsavestring (char *ptr, int size, struct obstack *obstackp)
{
register char *p = (char *) obstack_alloc (obstackp, size + 1);
/* Open-coded memcpy--saves function call time. These strings are usually
in the obstack pointed to by OBSTACKP. */
char *
-obconcat (obstackp, s1, s2, s3)
- struct obstack *obstackp;
- const char *s1, *s2, *s3;
+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);
int currently_reading_symtab = 0;
static void
-decrement_reading_symtab (dummy)
- void *dummy;
+decrement_reading_symtab (void *dummy)
{
currently_reading_symtab--;
}
case inline. */
struct symtab *
-psymtab_to_symtab (pst)
- register struct partial_symtab *pst;
+psymtab_to_symtab (register struct partial_symtab *pst)
{
/* If it's been looked up before, return it. */
if (pst->symtab)
/* Initialize entry point information for this objfile. */
void
-init_entry_point_info (objfile)
- struct objfile *objfile;
+init_entry_point_info (struct objfile *objfile)
{
/* Save startup file's range of PC addresses to help blockframe.c
decide where the bottom of the stack is. */
/* Get current entry point address. */
CORE_ADDR
-entry_point_address ()
+entry_point_address (void)
{
return symfile_objfile ? symfile_objfile->ei.entry_point : 0;
}
lowest-addressed loadable section. */
void
-find_lowest_section (abfd, sect, obj)
- bfd *abfd;
- asection *sect;
- PTR obj;
+find_lowest_section (bfd *abfd, asection *sect, PTR obj)
{
asection **lowest = (asection **) obj;
*lowest = sect;
}
+
+/* Build (allocate and populate) a section_addr_info struct from
+ an existing section table. */
+
+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 (stp->the_bfd_section->flags & (SEC_ALLOC | SEC_LOAD)
+ && oidx < MAX_SECTIONS)
+ {
+ sap->other[oidx].addr = stp->addr;
+ sap->other[oidx].name = xstrdup (stp->the_bfd_section->name);
+ sap->other[oidx].sectindex = stp->the_bfd_section->index;
+ oidx++;
+ }
+ }
+
+ return sap;
+}
+
+
+/* Free all memory allocated by build_section_addr_info_from_section_table. */
+
+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)
+ free (sap->other[idx].name);
+ free (sap);
+}
+
+
/* Parse the user's idea of an offset for dynamic linking, into our idea
of how to represent it for fast symbol reading. This is the default
version of the sym_fns.sym_offsets function for symbol readers that
don't need to do anything special. It allocates a section_offsets table
for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */
-struct section_offsets *
-default_symfile_offsets (objfile, addr)
- struct objfile *objfile;
- CORE_ADDR addr;
+void
+default_symfile_offsets (struct objfile *objfile,
+ struct section_addr_info *addrs)
{
- struct section_offsets *section_offsets;
int i;
+ asection *sect = NULL;
objfile->num_sections = SECT_OFF_MAX;
- section_offsets = (struct section_offsets *)
+ objfile->section_offsets = (struct section_offsets *)
obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
- memset (section_offsets, 0, SIZEOF_SECTION_OFFSETS);
+ memset (objfile->section_offsets, 0, SIZEOF_SECTION_OFFSETS);
- for (i = 0; i < SECT_OFF_MAX; i++)
- ANOFFSET (section_offsets, i) = addr;
+ /* Now calculate offsets for section that were specified by the
+ caller. */
+ for (i = 0; i < MAX_SECTIONS && addrs->other[i].name; i++)
+ {
+ struct other_sections *osp ;
- return section_offsets;
-}
+ osp = &addrs->other[i] ;
+ if (osp->addr == 0)
+ continue;
+
+ /* Record all sections in offsets */
+ /* The section_offsets in the objfile are here filled in using
+ the BFD index. */
+ (objfile->section_offsets)->offsets[osp->sectindex] = osp->addr;
+ }
+
+ /* Remember the bfd indexes for the .text, .data, .bss and
+ .rodata sections. */
+ sect = bfd_get_section_by_name (objfile->obfd, ".text");
+ if (sect)
+ objfile->sect_index_text = sect->index;
+
+ sect = bfd_get_section_by_name (objfile->obfd, ".data");
+ if (sect)
+ objfile->sect_index_data = sect->index;
+
+ sect = bfd_get_section_by_name (objfile->obfd, ".bss");
+ 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;
+
+}
/* Process a symbol file, as either the main file or as a dynamically
loaded file.
the symbol reading (and complaints can be more terse about it). */
void
-syms_from_objfile (objfile, addr, mainline, verbo)
- struct objfile *objfile;
- CORE_ADDR addr;
- int mainline;
- int verbo;
-{
- struct section_offsets *section_offsets;
- asection *lowest_sect;
+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 is NULL, initialize the local section_addr_info struct and
+ point ADDRS to it. We now establish the convention that an addr of
+ zero means no load address was specified. */
+
+ if (addrs == NULL)
+ {
+ memset (&local_addr, 0, sizeof (local_addr));
+ addrs = &local_addr;
+ }
init_entry_point_info (objfile);
find_sym_fns (objfile);
/* Make sure that partially constructed symbol tables will be cleaned up
if an error occurs during symbol reading. */
- old_chain = make_cleanup ((make_cleanup_func) free_objfile, objfile);
+ old_chain = make_cleanup_free_objfile (objfile);
if (mainline)
{
/* We will modify the main symbol table, make sure that all its users
will be cleaned up if an error occurs during symbol reading. */
- make_cleanup ((make_cleanup_func) clear_symtab_users, 0);
+ make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
/* Since no error yet, throw away the old symbol table. */
We no longer warn if the lowest section is not a text segment (as
happens for the PA64 port. */
- if (mainline)
- {
- addr = 0; /* No offset from objfile addresses. */
- }
- else
+ if (!mainline)
{
- lowest_sect = bfd_get_section_by_name (objfile->obfd, ".text");
- if (lowest_sect == NULL)
+ /* Find lowest loadable section to be used as starting point for
+ continguous sections. FIXME!! won't work without call to find
+ .text first, but this assumes text is lowest section. */
+ lower_sect = bfd_get_section_by_name (objfile->obfd, ".text");
+ if (lower_sect == NULL)
bfd_map_over_sections (objfile->obfd, find_lowest_section,
- (PTR) &lowest_sect);
-
- if (lowest_sect == NULL)
+ (PTR) &lower_sect);
+ if (lower_sect == NULL)
warning ("no loadable sections found in added symbol-file %s",
objfile->name);
-
- if (lowest_sect)
- addr -= bfd_section_vma (objfile->obfd, lowest_sect);
+ 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;
+
+ /* Calculate offsets for the loadable sections.
+ FIXME! Sections must be in order of increasing loadable section
+ so that contiguous sections can use the lower-offset!!!
+
+ Adjust offsets if the segments are not contiguous.
+ If the section is contiguous, its offset should be set to
+ the offset of the highest loadable section lower than it
+ (the loadable section directly below it in memory).
+ this_offset = lower_offset = lower_addr - lower_orig_addr */
+
+ /* Calculate offsets for sections. */
+ 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;
+ /* This is the index used by BFD. */
+ 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;
+ }
}
/* Initialize symbol reading routines for this objfile, allow complaints to
(*objfile->sf->sym_init) (objfile);
clear_complaints (1, verbo);
- section_offsets = (*objfile->sf->sym_offsets) (objfile, addr);
- objfile->section_offsets = section_offsets;
+ (*objfile->sf->sym_offsets) (objfile, addrs);
#ifndef IBM6000_TARGET
/* This is a SVR4/SunOS specific hack, I think. In any event, it
These should probably all be collapsed into some target
independent form of shared library support. FIXME. */
- if (addr)
+ if (addrs)
{
struct obj_section *s;
+ /* Map section offsets in "addr" back to the object's
+ sections by comparing the section names with bfd's
+ section names. Then adjust the section address by
+ the offset. */ /* for gdb/13815 */
+
ALL_OBJFILE_OSECTIONS (objfile, s)
{
+ CORE_ADDR s_addr = 0;
+ int i;
+
+ for (i = 0;
+ !s_addr && i < MAX_SECTIONS && addrs->other[i].name;
+ i++)
+ if (strcmp (s->the_bfd_section->name, addrs->other[i].name) == 0)
+ s_addr = addrs->other[i].addr; /* end added for gdb/13815 */
+
s->addr -= s->offset;
- s->addr += addr;
+ s->addr += s_addr;
s->endaddr -= s->offset;
- s->endaddr += addr;
- s->offset += addr;
+ s->endaddr += s_addr;
+ s->offset += s_addr;
}
}
#endif /* not IBM6000_TARGET */
discard_cleanups (old_chain);
/* Call this after reading in a new symbol table to give target
- dependant code a crack at the new symbols. For instance, this
+ dependent code a crack at the new symbols. For instance, this
could be used to update the values of target-specific symbols GDB
needs to keep track of (such as _sigtramp, or whatever). */
objfile. */
void
-new_symfile_objfile (objfile, mainline, verbo)
- struct objfile *objfile;
- int mainline;
- int verbo;
+new_symfile_objfile (struct objfile *objfile, int mainline, int verbo)
{
/* If this is the main symbol file we have to clean up all users of the
as dynamically loaded code. If !mainline, ADDR is the address
where the text segment was loaded.
- USER_LOADED is TRUE if the add-symbol-file command was how this
- symbol file came to be processed.
-
- IS_SOLIB is TRUE if this symbol file represents a solib, as discovered
- by the target's implementation of the solib package.
-
Upon success, returns a pointer to the objfile that was added.
Upon failure, jumps back to command level (never returns). */
struct objfile *
-symbol_file_add (name, from_tty, addr, mainline, mapped, readnow, user_loaded, is_solib)
- char *name;
- int from_tty;
- CORE_ADDR addr;
- int mainline;
- int mapped;
- int readnow;
- int user_loaded;
- int is_solib;
+symbol_file_add (char *name, int from_tty, struct section_addr_info *addrs,
+ int mainline, int flags)
{
struct objfile *objfile;
struct partial_symtab *psymtab;
&& !query ("Load new symbol table from \"%s\"? ", name))
error ("Not confirmed.");
- objfile = allocate_objfile (abfd, mapped, user_loaded, is_solib);
+ objfile = allocate_objfile (abfd, flags);
/* If the objfile uses a mapped symbol file, and we have a psymtab for
it, then skip reading any symbols at this time. */
gdb_flush (gdb_stdout);
}
}
- syms_from_objfile (objfile, addr, mainline, from_tty);
+ syms_from_objfile (objfile, addrs, mainline, from_tty);
}
/* We now have at least a partial symbol table. Check to see if the
the gdb startup command line or on a per symbol file basis. Expand
all partial symbol tables for this objfile if so. */
- if (readnow || readnow_symbol_files)
+ if ((flags & OBJF_READNOW) || readnow_symbol_files)
{
if (from_tty || info_verbose)
{
new_symfile_objfile (objfile, mainline, from_tty);
- target_new_objfile (objfile);
+ if (target_new_objfile_hook)
+ target_new_objfile_hook (objfile);
return (objfile);
}
used in GDB (perhaps "set mapped on", "set readnow on" would be
better), (3) the order of options matters, which is contrary to GNU
conventions (because it is confusing and inconvenient). */
+/* Note: ezannoni 2000-04-17. This function used to have support for
+ rombug (see remote-os9k.c). It consisted of a call to target_link()
+ (target.c) to get the address of the text segment from the target,
+ and pass that to symbol_file_add(). This is no longer supported. */
void
-symbol_file_command (args, from_tty)
- char *args;
- int from_tty;
+symbol_file_command (char *args, int from_tty)
{
char **argv;
char *name = NULL;
- CORE_ADDR text_relocation = 0; /* text_relocation */
struct cleanup *cleanups;
- int mapped = 0;
- int readnow = 0;
+ int flags = OBJF_USERLOADED;
dont_repeat ();
symfile_objfile = NULL;
if (from_tty)
- {
printf_unfiltered ("No symbol file now.\n");
- }
#ifdef HPUXHPPA
RESET_HP_UX_GLOBALS ();
#endif
while (*argv != NULL)
{
if (STREQ (*argv, "-mapped"))
- {
- mapped = 1;
- }
- else if (STREQ (*argv, "-readnow"))
- {
- readnow = 1;
- }
- else if (**argv == '-')
- {
- error ("unknown option `%s'", *argv);
- }
- else
- {
- char *p;
-
- name = *argv;
-
- /* this is for rombug remote only, to get the text relocation by
- using link command */
- p = strrchr (name, '/');
- if (p != NULL)
- p++;
+ flags |= OBJF_MAPPED;
+ else
+ if (STREQ (*argv, "-readnow"))
+ flags |= OBJF_READNOW;
+ else
+ if (**argv == '-')
+ error ("unknown option `%s'", *argv);
else
- p = name;
-
- target_link (p, &text_relocation);
-
- if (text_relocation == (CORE_ADDR) 0)
- return;
- else if (text_relocation == (CORE_ADDR) -1)
{
- symbol_file_add (name, from_tty, (CORE_ADDR) 0,
- 1, mapped, readnow, 1, 0);
+ name = *argv;
+ symbol_file_add (name, from_tty, NULL, 1, flags);
#ifdef HPUXHPPA
RESET_HP_UX_GLOBALS ();
#endif
- }
- else
- symbol_file_add (name, from_tty, (CORE_ADDR) text_relocation,
- 0, mapped, readnow, 1, 0);
+ /* Getting new symbols may change our opinion about
+ what is frameless. */
+ reinit_frame_cache ();
- /* Getting new symbols may change our opinion about what is
- frameless. */
- reinit_frame_cache ();
-
- set_initial_language ();
- }
+ set_initial_language ();
+ }
argv++;
}
FIXME. */
static void
-set_initial_language ()
+set_initial_language (void)
{
struct partial_symtab *pst;
enum language lang = language_unknown;
In case of trouble, error() is called. */
bfd *
-symfile_bfd_open (name)
- char *name;
+symfile_bfd_open (char *name)
{
bfd *sym_bfd;
int desc;
to handle. */
void
-add_symtab_fns (sf)
- struct sym_fns *sf;
+add_symtab_fns (struct sym_fns *sf)
{
sf->next = symtab_fns;
symtab_fns = sf;
symbol file. */
static void
-find_sym_fns (objfile)
- struct objfile *objfile;
+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);
- /* Special kludge for RS/6000 and PowerMac. See xcoffread.c. */
- if (STREQ (our_target, "aixcoff-rs6000") ||
- STREQ (our_target, "xcoff-powermac"))
- our_flavour = (enum bfd_flavour) -1;
-
/* Special kludge for apollo. See dstread.c. */
if (STREQN (our_target, "apollo", 6))
our_flavour = (enum bfd_flavour) -2;
/* This function runs the load command of our current target. */
static void
-load_command (arg, from_tty)
- char *arg;
- int from_tty;
+load_command (char *arg, int from_tty)
{
if (arg == NULL)
arg = get_exec_file (1);
to worry about finding it, and (b) On VMS, fork() is very slow and so
we don't want to run a subprocess. On the other hand, I'm not sure how
performance compares. */
-#define GENERIC_LOAD_CHUNK 256
-#define VALIDATE_DOWNLOAD 0
+
+static int download_write_size = 512;
+static int validate_download = 0;
+
void
-generic_load (filename, from_tty)
- char *filename;
- int from_tty;
+generic_load (char *args, int from_tty)
{
- struct cleanup *old_cleanups;
asection *s;
bfd *loadfile_bfd;
time_t start_time, end_time; /* Start and end times of download */
unsigned long data_count = 0; /* Number of bytes transferred to memory */
- int n;
- unsigned long load_offset = 0; /* offset to add to vma for each section */
- char buf[GENERIC_LOAD_CHUNK + 8];
-#if VALIDATE_DOWNLOAD
- char verify_buffer[GENERIC_LOAD_CHUNK + 8];
-#endif
-
- /* enable user to specify address for downloading as 2nd arg to load */
- n = sscanf (filename, "%s 0x%lx", buf, &load_offset);
- if (n > 1)
- filename = buf;
+ unsigned long write_count = 0; /* Number of writes needed. */
+ unsigned long load_offset; /* offset to add to vma for each section */
+ char *filename;
+ struct cleanup *old_cleanups;
+ char *offptr;
+ CORE_ADDR total_size = 0;
+ CORE_ADDR total_sent = 0;
+
+ /* Parse the input argument - the user can specify a load offset as
+ a second argument. */
+ filename = xmalloc (strlen (args) + 1);
+ old_cleanups = make_cleanup (free, filename);
+ strcpy (filename, args);
+ offptr = strchr (filename, ' ');
+ if (offptr != NULL)
+ {
+ char *endptr;
+ load_offset = strtoul (offptr, &endptr, 0);
+ if (offptr == endptr)
+ error ("Invalid download offset:%s\n", offptr);
+ *offptr = '\0';
+ }
else
load_offset = 0;
+ /* Open the file for loading. */
loadfile_bfd = bfd_openr (filename, gnutarget);
if (loadfile_bfd == NULL)
{
perror_with_name (filename);
return;
}
+
/* FIXME: should be checking for errors from bfd_close (for one thing,
on error it does not free all the storage associated with the
bfd). */
- old_cleanups = make_cleanup ((make_cleanup_func) bfd_close, loadfile_bfd);
+ make_cleanup_bfd_close (loadfile_bfd);
if (!bfd_check_format (loadfile_bfd, bfd_object))
{
bfd_errmsg (bfd_get_error ()));
}
+ for (s = loadfile_bfd->sections; s; s = s->next)
+ if (s->flags & SEC_LOAD)
+ total_size += bfd_get_section_size_before_reloc (s);
+
start_time = time (NULL);
for (s = loadfile_bfd->sections; s; s = s->next)
{
if (s->flags & SEC_LOAD)
{
- bfd_size_type size;
-
- size = bfd_get_section_size_before_reloc (s);
+ CORE_ADDR size = bfd_get_section_size_before_reloc (s);
if (size > 0)
{
char *buffer;
struct cleanup *old_chain;
- bfd_vma lma;
- unsigned long l = size;
+ CORE_ADDR lma = s->lma + load_offset;
+ CORE_ADDR block_size;
int err;
- char *sect;
- unsigned long sent;
- unsigned long len;
+ const char *sect_name = bfd_get_section_name (loadfile_bfd, s);
+ CORE_ADDR sent;
- l = l > GENERIC_LOAD_CHUNK ? GENERIC_LOAD_CHUNK : l;
+ 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 (free, buffer);
- lma = s->lma;
- lma += load_offset;
-
/* Is this really necessary? I guess it gives the user something
to look at during a long download. */
- printf_filtered ("Loading section %s, size 0x%lx lma ",
- bfd_get_section_name (loadfile_bfd, s),
- (unsigned long) size);
- print_address_numeric (lma, 1, gdb_stdout);
- printf_filtered ("\n");
+#ifdef UI_OUT
+ ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n",
+ sect_name, paddr_nz (size), paddr_nz (lma));
+#else
+ fprintf_unfiltered (gdb_stdout,
+ "Loading section %s, size 0x%s lma 0x%s\n",
+ sect_name, paddr_nz (size), paddr_nz (lma));
+#endif
bfd_get_section_contents (loadfile_bfd, s, buffer, 0, size);
- sect = (char *) bfd_get_section_name (loadfile_bfd, s);
sent = 0;
do
{
- len = (size - sent) < l ? (size - sent) : l;
- sent += len;
- err = target_write_memory (lma, buffer, len);
- if (ui_load_progress_hook)
- if (ui_load_progress_hook (sect, sent))
- error ("Canceled the download");
-#if VALIDATE_DOWNLOAD
- /* Broken memories and broken monitors manifest themselves
- here when bring new computers to life.
- This doubles already slow downloads.
- */
+ CORE_ADDR len;
+ CORE_ADDR 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;
- {
- target_read_memory (lma, verify_buffer, len);
- if (0 != bcmp (buffer, verify_buffer, len))
- error ("Download verify failed at %08x",
- (unsigned long) lma);
- }
-
-#endif
+ if (validate_download)
+ {
+ /* Broken memories and broken monitors manifest
+ themselves here when bring new computers to
+ life. This doubles already slow downloads. */
+ /* NOTE: cagney/1999-10-18: A more efficient
+ implementation might add a verify_memory()
+ method to the target vector and then use
+ that. remote.c could implement that method
+ using the ``qCRC'' packet. */
+ char *check = xmalloc (len);
+ struct cleanup *verify_cleanups = make_cleanup (free, 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);
+ }
data_count += len;
lma += len;
buffer += len;
- } /* od */
- while (err == 0 && sent < size);
+ write_count += 1;
+ sent += len;
+ total_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, total_sent, total_size);
+ }
+ while (sent < size);
if (err != 0)
- error ("Memory access error while loading section %s.",
- bfd_get_section_name (loadfile_bfd, s));
+ error ("Memory access error while loading section %s.", sect_name);
do_cleanups (old_chain);
}
end_time = time (NULL);
{
- unsigned long entry;
+ CORE_ADDR entry;
entry = bfd_get_start_address (loadfile_bfd);
- printf_filtered ("Start address 0x%lx , load size %d\n", entry, data_count);
+#ifdef UI_OUT
+ 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", "%ld" , data_count);
+ ui_out_text (uiout, "\n");
+
+#else
+ fprintf_unfiltered (gdb_stdout,
+ "Start address 0x%s , load size %ld\n",
+ paddr_nz (entry), data_count);
+#endif
/* We were doing this in remote-mips.c, I suspect it is right
for other targets too. */
write_pc (entry);
loaded in. remote-nindy.c had no call to symbol_file_add, but remote-vx.c
does. */
- report_transfer_performance (data_count, start_time, end_time);
+ print_transfer_performance (gdb_stdout, data_count, write_count,
+ end_time - start_time);
do_cleanups (old_cleanups);
}
/* Report how fast the transfer went. */
+/* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
+ replaced by print_transfer_performance (with a very different
+ function signature). */
+
void
-report_transfer_performance (data_count, start_time, end_time)
- unsigned long data_count;
- time_t start_time, end_time;
-{
- printf_filtered ("Transfer rate: ");
- if (end_time != start_time)
- printf_filtered ("%d bits/sec",
- (data_count * 8) / (end_time - start_time));
+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)
+{
+#ifdef UI_OUT
+ ui_out_text (uiout, "Transfer rate: ");
+ if (time_count > 0)
+ {
+ ui_out_field_fmt (uiout, "transfer-rate", "%ld",
+ (data_count * 8) / time_count);
+ ui_out_text (uiout, " bits/sec");
+ }
+ else
+ {
+ ui_out_field_fmt (uiout, "transferred-bits", "%ld", (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", "%ld", data_count / write_count);
+ ui_out_text (uiout, " bytes/write");
+ }
+ ui_out_text (uiout, ".\n");
+#else
+ fprintf_unfiltered (stream, "Transfer rate: ");
+ if (time_count > 0)
+ fprintf_unfiltered (stream, "%ld bits/sec", (data_count * 8) / time_count);
else
- printf_filtered ("%d bits in <1 sec", (data_count * 8));
- printf_filtered (".\n");
+ fprintf_unfiltered (stream, "%ld bits in <1 sec", (data_count * 8));
+ if (write_count > 0)
+ fprintf_unfiltered (stream, ", %ld bytes/write", data_count / write_count);
+ fprintf_unfiltered (stream, ".\n");
+#endif
}
/* This function allows the addition of incrementally linked object files.
It does not modify any state in the target, only in the debugger. */
+/* Note: ezannoni 2000-04-13 This function/command used to have a
+ special case syntax for the rombug target (Rombug is the boot
+ monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the
+ rombug case, the user doesn't need to supply a text address,
+ instead a call to target_link() (in target.c) would supply the
+ value to use. We are now discontinuing this type of ad hoc syntax. */
/* ARGSUSED */
static void
-add_symbol_file_command (args, from_tty)
- char *args;
- int from_tty;
+add_symbol_file_command (char *args, int from_tty)
{
- char *name = NULL;
- CORE_ADDR text_addr;
+ char *filename = NULL;
+ int flags = OBJF_USERLOADED;
char *arg;
- int readnow = 0;
- int mapped = 0;
+ 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;
+
+ struct
+ {
+ char *name;
+ char *value;
+ } sect_opts[SECT_OFF_MAX];
+
+ struct section_addr_info section_addrs;
+ struct cleanup *my_cleanups;
dont_repeat ();
if (args == NULL)
- {
- error ("add-symbol-file takes a file name and an address");
- }
+ error ("add-symbol-file takes a file name and an address");
/* Make a copy of the string that we can safely write into. */
+ args = xstrdup (args);
- args = strdup (args);
- make_cleanup (free, args);
+ /* Ensure section_addrs is initialized */
+ memset (§ion_addrs, 0, sizeof (section_addrs));
- /* Pick off any -option args and the file name. */
-
- while ((*args != '\000') && (name == NULL))
+ while (*args != '\000')
{
+ /* Any leading spaces? */
while (isspace (*args))
- {
- args++;
- }
+ args++;
+
+ /* Point arg to the beginning of the argument. */
arg = args;
+
+ /* Move args pointer over the argument. */
while ((*args != '\000') && !isspace (*args))
- {
- args++;
- }
+ args++;
+
+ /* If there are more arguments, terminate arg and
+ proceed past it. */
if (*args != '\000')
+ *args++ = '\000';
+
+ /* Now process the argument. */
+ if (argcnt == 0)
{
- *args++ = '\000';
- }
- if (*arg != '-')
- {
- name = arg;
- }
- else if (STREQ (arg, "-mapped"))
- {
- mapped = 1;
- }
- else if (STREQ (arg, "-readnow"))
- {
- readnow = 1;
+ /* The first argument is the file name. */
+ filename = tilde_expand (arg);
+ my_cleanups = make_cleanup (free, filename);
}
else
- {
- error ("unknown option `%s'", arg);
- }
- }
-
- /* After picking off any options and the file name, args should be
- left pointing at the remainder of the command line, which should
- be the address expression to evaluate. */
+ if (argcnt == 1)
+ {
+ /* The second argument is always the text address at which
+ to load the program. */
+ sect_opts[section_index].name = ".text";
+ sect_opts[section_index].value = arg;
+ section_index++;
+ }
+ else
+ {
+ /* It's an option (starting with '-') or it's an argument
+ to an option */
+
+ if (*arg == '-')
+ {
+ 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: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
+ }
+ }
+ argcnt++;
+ }
+
+ /* Print the prompt for the query below. And save the arguments into
+ a sect_addr_info structure to be passed around to other
+ functions. We have to split this up into separate print
+ statements because local_hex_string returns a local static
+ string. */
+
+ 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);
- if (name == NULL)
- {
- error ("add-symbol-file takes a file name");
- }
- name = tilde_expand (name);
- make_cleanup (free, name);
+ /* Here we store the section offsets in the order they were
+ entered on the command line. */
+ 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 (*args != '\000')
- {
- text_addr = parse_and_eval_address (args);
- }
- else
- {
- target_link (name, &text_addr);
- if (text_addr == (CORE_ADDR) -1)
- error ("Don't know how to get text start location for this file");
+ /* The object's sections are initialized when a
+ call is made to build_objfile_section_table (objfile).
+ This happens in reread_symbols.
+ At this point, we don't know what file type this is,
+ so we can't determine what section names are valid. */
}
- /* FIXME-32x64: Assumes text_addr fits in a long. */
- if ((from_tty)
- && (!query ("add symbol table from file \"%s\" at text_addr = %s?\n",
- name, local_hex_string ((unsigned long) text_addr))))
+ if (from_tty && (!query ("%s", "")))
error ("Not confirmed.");
- symbol_file_add (name, from_tty, text_addr, 0, mapped, readnow,
- 1, /* user_loaded */
- 0); /* We'll guess it's ! is_solib */
+ symbol_file_add (filename, from_tty, §ion_addrs, 0, flags);
/* Getting new symbols may change our opinion about what is
frameless. */
reinit_frame_cache ();
+ do_cleanups (my_cleanups);
}
\f
static void
-add_shared_symbol_files_command (args, from_tty)
- char *args;
- int from_tty;
+add_shared_symbol_files_command (char *args, int from_tty)
{
#ifdef ADD_SHARED_SYMBOL_FILES
ADD_SHARED_SYMBOL_FILES (args, from_tty);
\f
/* Re-read symbols if a symbol-file has changed. */
void
-reread_symbols ()
+reread_symbols (void)
{
struct objfile *objfile;
long new_modtime;
struct cleanup *old_cleanups;
struct section_offsets *offsets;
int num_offsets;
- int section_offsets_size;
char *obfd_filename;
printf_filtered ("`%s' has changed; re-reading symbols.\n",
/* If we get an error, blow away this objfile (not sure if
that is the correct response for things like shared
libraries). */
- old_cleanups = make_cleanup ((make_cleanup_func) free_objfile,
- objfile);
+ old_cleanups = make_cleanup_free_objfile (objfile);
/* We need to do this whenever any symbols go away. */
- make_cleanup ((make_cleanup_func) clear_symtab_users, 0);
+ make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
/* Clean up any state BFD has sitting around. We don't need
to close the descriptor but BFD lacks a way of closing the
/* Save the offsets, we will nuke them with the rest of the
psymbol_obstack. */
num_offsets = objfile->num_sections;
- section_offsets_size =
- sizeof (struct section_offsets)
- + sizeof (objfile->section_offsets->offsets) * num_offsets;
- offsets = (struct section_offsets *) alloca (section_offsets_size);
- memcpy (offsets, objfile->section_offsets, section_offsets_size);
+ offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
+ memcpy (offsets, objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
/* Nuke all the state that we will re-read. Much of the following
code which sets things to NULL really is necessary to tell
sizeof (objfile->static_psymbols));
/* Free the obstacks for non-reusable objfiles */
- obstack_free (&objfile->psymbol_cache.cache, 0);
- memset (&objfile->psymbol_cache, 0,
- sizeof (objfile->psymbol_cache));
+ free_bcache (&objfile->psymbol_cache);
obstack_free (&objfile->psymbol_obstack, 0);
obstack_free (&objfile->symbol_obstack, 0);
obstack_free (&objfile->type_obstack, 0);
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->fundamental_types = NULL;
if (objfile->sf != NULL)
{
/* We use the same section offsets as from last time. I'm not
sure whether that is always correct for shared libraries. */
objfile->section_offsets = (struct section_offsets *)
- obstack_alloc (&objfile->psymbol_obstack, section_offsets_size);
- memcpy (objfile->section_offsets, offsets, section_offsets_size);
+ obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
+ memcpy (objfile->section_offsets, offsets, SIZEOF_SECTION_OFFSETS);
objfile->num_sections = num_offsets;
/* What the hell is sym_new_init for, anyway? The concept of
reread_one = 1;
/* Call this after reading in a new symbol table to give target
- dependant code a crack at the new symbols. For instance, this
+ dependent code a crack at the new symbols. For instance, this
could be used to update the values of target-specific symbols GDB
needs to keep track of (such as _sigtramp, or whatever). */
static int fl_table_size, fl_table_next;
static void
-add_filename_language (ext, lang)
- char *ext;
- enum language lang;
+add_filename_language (char *ext, enum language lang)
{
if (fl_table_next >= fl_table_size)
{
static char *ext_args;
static void
-set_ext_lang_command (args, from_tty)
- char *args;
- int from_tty;
+set_ext_lang_command (char *args, int from_tty)
{
int i;
char *cp = ext_args;
}
static void
-info_ext_lang_command (args, from_tty)
- char *args;
- int from_tty;
+info_ext_lang_command (char *args, int from_tty)
{
int i;
}
static void
-init_filename_language_table ()
+init_filename_language_table (void)
{
if (fl_table_size == 0) /* protect against repetition */
{
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 (filename)
- char *filename;
+deduce_language_from_filename (char *filename)
{
int i;
char *cp;
*/
struct symtab *
-allocate_symtab (filename, objfile)
- char *filename;
- struct objfile *objfile;
+allocate_symtab (char *filename, struct objfile *objfile)
{
register struct symtab *symtab;
}
struct partial_symtab *
-allocate_psymtab (filename, objfile)
- char *filename;
- struct objfile *objfile;
+allocate_psymtab (char *filename, struct objfile *objfile)
{
struct partial_symtab *psymtab;
}
void
-discard_psymtab (pst)
- struct partial_symtab *pst;
+discard_psymtab (struct partial_symtab *pst)
{
struct partial_symtab **prev_pst;
table data. */
void
-clear_symtab_users ()
+clear_symtab_users (void)
{
/* Someday, we should do better than this, by only blowing away
the things that really need to be blown. */
current_source_symtab = 0;
current_source_line = 0;
clear_pc_function_cache ();
- target_new_objfile (NULL);
+ if (target_new_objfile_hook)
+ target_new_objfile_hook (NULL);
+}
+
+static void
+clear_symtab_users_cleanup (void *ignore)
+{
+ clear_symtab_users ();
}
/* clear_symtab_users_once:
#if 0
/* FIXME: As free_named_symtabs is currently a big noop this function
is no longer needed. */
-static void
-clear_symtab_users_once PARAMS ((void));
+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 ()
+clear_symtab_users_once (void)
{
/* Enforce once-per-`do_cleanups'-semantics */
if (clear_symtab_users_queued <= clear_symtab_users_done)
/* Delete the specified psymtab, and any others that reference it. */
static void
-cashier_psymtab (pst)
- struct partial_symtab *pst;
+cashier_psymtab (struct partial_symtab *pst)
{
struct partial_symtab *ps, *pprev = NULL;
int i;
it is not called for subsidiary files such as .h files.
Return value is 1 if we blew away the environment, 0 if not.
- FIXME. The return valu appears to never be used.
+ FIXME. The return value appears to never be used.
FIXME. I think this is not the best way to do this. We should
work on being gentler to the environment while still cleaning up
all stray pointers into the freed symtab. */
int
-free_named_symtabs (name)
- char *name;
+free_named_symtabs (char *name)
{
#if 0
/* FIXME: With the new method of each objfile having it's own
/* Allocate and partially fill a partial symtab. It will be
completely filled at the end of the symbol list.
- SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
- is the address relative to which its symbols are (incremental) or 0
- (normal). */
-
+ FILENAME is the name of the symbol-file we are reading from. */
struct partial_symtab *
-start_psymtab_common (objfile, section_offsets,
- filename, textlow, global_syms, static_syms)
- struct objfile *objfile;
- struct section_offsets *section_offsets;
- char *filename;
- CORE_ADDR textlow;
- struct partial_symbol **global_syms;
- struct partial_symbol **static_syms;
+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;
Since one arg is a struct, we pass in a ptr and deref it (sigh). */
void
-add_psymbol_to_list (name, namelength, namespace, class, list, val, coreaddr,
- language, objfile)
- char *name;
- int namelength;
- namespace_enum namespace;
- enum address_class class;
- struct psymbol_allocation_list *list;
- long val; /* Value as a long */
- CORE_ADDR coreaddr; /* Value as a CORE_ADDR */
- enum language language;
- struct objfile *objfile;
+add_psymbol_to_list (char *name, int namelength, namespace_enum namespace,
+ enum address_class class,
+ struct psymbol_allocation_list *list, long val, /* Value as a long */
+ CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
+ enum language language, struct objfile *objfile)
{
register struct partial_symbol *psym;
char *buf = alloca (namelength + 1);
* name. */
void
-add_psymbol_with_dem_name_to_list (name, namelength, dem_name, dem_namelength,
- namespace, class, list, val, coreaddr, language, objfile)
- char *name;
- int namelength;
- char *dem_name;
- int dem_namelength;
- namespace_enum namespace;
- enum address_class class;
- struct psymbol_allocation_list *list;
- long val; /* Value as a long */
- CORE_ADDR coreaddr; /* Value as a CORE_ADDR */
- enum language language;
- struct objfile *objfile;
+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, /* Value as a long */
+ CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
+ enum language language,
+ struct objfile *objfile)
{
register struct partial_symbol *psym;
char *buf = alloca (namelength + 1);
/* Initialize storage for partial symbols. */
void
-init_psymbol_list (objfile, total_symbols)
- struct objfile *objfile;
- int total_symbols;
+init_psymbol_list (struct objfile *objfile, int total_symbols)
{
/* Free any previously allocated psymbol lists. */
int overlay_cache_invalid = 0; /* True if need to refresh mapped state */
/* Target vector for refreshing overlay mapped state */
-static void simple_overlay_update PARAMS ((struct obj_section *));
-void (*target_overlay_update) PARAMS ((struct obj_section *))
-= simple_overlay_update;
+static void simple_overlay_update (struct obj_section *);
+void (*target_overlay_update) (struct obj_section *) = simple_overlay_update;
/* Function: section_is_overlay (SECTION)
Returns true if SECTION has VMA not equal to LMA, ie.
SECTION is loaded at an address different from where it will "run". */
int
-section_is_overlay (section)
- asection *section;
+section_is_overlay (asection *section)
{
if (overlay_debugging)
if (section && section->lma != 0 &&
Invalidate the mapped state of all overlay sections (mark it as stale). */
static void
-overlay_invalidate_all ()
+overlay_invalidate_all (void)
{
struct objfile *objfile;
struct obj_section *sect;
section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
static int
-overlay_is_mapped (osect)
- struct obj_section *osect;
+overlay_is_mapped (struct obj_section *osect)
{
if (osect == 0 || !section_is_overlay (osect->the_bfd_section))
return 0;
Returns true if section is an overlay, and is currently mapped. */
int
-section_is_mapped (section)
- asection *section;
+section_is_mapped (asection *section)
{
struct objfile *objfile;
struct obj_section *osect;
If PC falls into the lma range of SECTION, return true, else false. */
CORE_ADDR
-pc_in_unmapped_range (pc, section)
- CORE_ADDR pc;
- asection *section;
+pc_in_unmapped_range (CORE_ADDR pc, asection *section)
{
int size;
If PC falls into the vma range of SECTION, return true, else false. */
CORE_ADDR
-pc_in_mapped_range (pc, section)
- CORE_ADDR pc;
- asection *section;
+pc_in_mapped_range (CORE_ADDR pc, asection *section)
{
int size;
May be the same as PC. */
CORE_ADDR
-overlay_unmapped_address (pc, section)
- CORE_ADDR pc;
- asection *section;
+overlay_unmapped_address (CORE_ADDR pc, asection *section)
{
if (overlay_debugging)
if (section && section_is_overlay (section) &&
May be the same as PC. */
CORE_ADDR
-overlay_mapped_address (pc, section)
- CORE_ADDR pc;
- asection *section;
+overlay_mapped_address (CORE_ADDR pc, asection *section)
{
if (overlay_debugging)
if (section && section_is_overlay (section) &&
depending on whether the section is mapped or not. */
CORE_ADDR
-symbol_overlayed_address (address, section)
- CORE_ADDR address;
- asection *section;
+symbol_overlayed_address (CORE_ADDR address, asection *section)
{
if (overlay_debugging)
{
Else if PC matches an unmapped section's LMA, return that section. */
asection *
-find_pc_overlay (pc)
- CORE_ADDR pc;
+find_pc_overlay (CORE_ADDR pc)
{
struct objfile *objfile;
struct obj_section *osect, *best_match = NULL;
currently marked as MAPPED, return that section. Else return NULL. */
asection *
-find_pc_mapped_section (pc)
- CORE_ADDR pc;
+find_pc_mapped_section (CORE_ADDR pc)
{
struct objfile *objfile;
struct obj_section *osect;
Print a list of mapped sections and their PC ranges */
void
-list_overlays_command (args, from_tty)
- char *args;
- int from_tty;
+list_overlays_command (char *args, int from_tty)
{
int nmapped = 0;
struct objfile *objfile;
Mark the named section as mapped (ie. residing at its VMA address). */
void
-map_overlay_command (args, from_tty)
- char *args;
- int from_tty;
+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 the 'OVERLAY ON' command.");
+ 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");
(ie. resident in its LMA address range, rather than the VMA range). */
void
-unmap_overlay_command (args, from_tty)
- char *args;
- int from_tty;
+unmap_overlay_command (char *args, int from_tty)
{
struct objfile *objfile;
struct obj_section *sec;
if (!overlay_debugging)
- error ("Overlay debugging not enabled. Use the 'OVERLAY ON' command.");
+ 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");
Possibly this should be done via a set/show command. */
static void
-overlay_auto_command (args, from_tty)
- char *args;
- int from_tty;
+overlay_auto_command (char *args, int from_tty)
{
overlay_debugging = -1;
if (info_verbose)
Possibly this should be done via a set/show command. */
static void
-overlay_manual_command (args, from_tty)
- char *args;
- int from_tty;
+overlay_manual_command (char *args, int from_tty)
{
overlay_debugging = 1;
if (info_verbose)
Possibly this should be done via a set/show command. */
static void
-overlay_off_command (args, from_tty)
- char *args;
- int from_tty;
+overlay_off_command (char *args, int from_tty)
{
overlay_debugging = 0;
if (info_verbose)
}
static void
-overlay_load_command (args, from_tty)
- char *args;
- int from_tty;
+overlay_load_command (char *args, int from_tty)
{
if (target_overlay_update)
(*target_overlay_update) (NULL);
struct cmd_list_element *overlaylist;
static void
-overlay_command (args, from_tty)
- char *args;
- int from_tty;
+overlay_command (char *args, int from_tty)
{
printf_unfiltered
("\"overlay\" must be followed by the name of an overlay command.\n");
/* Throw away the cached copy of _ovly_table */
static void
-simple_free_overlay_table ()
+simple_free_overlay_table (void)
{
if (cache_ovly_table)
free (cache_ovly_table);
#if 0
/* Throw away the cached copy of _ovly_region_table */
static void
-simple_free_overlay_region_table ()
+simple_free_overlay_region_table (void)
{
if (cache_ovly_region_table)
free (cache_ovly_region_table);
/* Read an array of ints from the target into a local buffer.
Convert to host order. int LEN is number of ints */
static void
-read_target_long_array (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- unsigned int *myaddr;
- int len;
+read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr, int len)
{
char *buf = alloca (len * TARGET_LONG_BYTES);
int i;
/* Find and grab a copy of the target _ovly_table
(and _novlys, which is needed for the table's size) */
static int
-simple_read_overlay_table ()
+simple_read_overlay_table (void)
{
struct minimal_symbol *msym;
/* Find and grab a copy of the target _ovly_region_table
(and _novly_regions, which is needed for the table's size) */
static int
-simple_read_overlay_region_table ()
+simple_read_overlay_region_table (void)
{
struct minimal_symbol *msym;
success, 0 for failure. */
static int
-simple_overlay_update_1 (osect)
- struct obj_section *osect;
+simple_overlay_update_1 (struct obj_section *osect)
{
int i, size;
re-read the entire cache, and go ahead and update all sections. */
static void
-simple_overlay_update (osect)
- struct obj_section *osect;
+simple_overlay_update (struct obj_section *osect)
{
struct objfile *objfile;
void
-_initialize_symfile ()
+_initialize_symfile (void)
{
struct cmd_list_element *c;
c->completer = filename_completer;
c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command,
- "Usage: add-symbol-file FILE ADDR\n\
+ "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.",
+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);
c->completer = filename_completer;
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);
}