vx-share
xcoffexec.c
xcoffread.c
+xcoffsolib.c
+xcoffsolib.h
xm-3b1.h
xm-m88k.h
xm-altos.h
+Sun Mar 29 14:16:22 1992 Per Bothner (bothner@cygnus.com)
+
+ * Merged in latest RS6000 diffs from Metin G. Ozisik.
+ * xcoffsolib.c, xcoffsolib.h: New files, from Metin.
+ * Various files: Changed #ifdef IBM6000 to IBM6000_HOST
+ or IBM6000_TARGET as (approximately) appropriate.
+
Sat Mar 28 13:00:10 1992 Fred Fish (fnf@cygnus.com)
* objfiles.h (OBJF_SYMS): Define flag bit for objfile flags.
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
-#include <ctype.h>
#include "defs.h"
+#include <ctype.h>
#include "symtab.h"
#include "frame.h"
#include "breakpoint.h"
create_longjmp_breakpoint("siglongjmp");
create_longjmp_breakpoint(NULL);
+#if 0
+ /* Took this out (temporaliy at least), since it produces an extra
+ blank line at startup. This messes up the gdbtests. -PB */
/* Blank line to finish off all those mention() messages we just printed. */
printf_filtered ("\n");
+#endif
}
\f
/* Set ignore-count of breakpoint number BPTNUM to COUNT.
"Status of all watchpoints, or watchpoint number NUMBER.\n\
Second column is \"y\" for enabled watchpoints, \"n\" for disabled.");
}
+
+#ifdef IBM6000_HOST
+/* Where should this function go? It is used by AIX only. FIXME. */
+
+/* Breakpoint address relocation used to be done in breakpoint_re_set(). That
+ approach the following problem:
+
+ before running the program, if a file is list, then a breakpoint is
+ set (just the line number), then if we switch into another file and run
+ the program, just a line number as a breakpoint address was not
+ descriptive enough and breakpoint was ending up in a different file's
+ similar line.
+
+ I don't think any other platform has this breakpoint relocation problem, so this
+ is not an issue for other platforms. */
+
+void
+fixup_breakpoints (low, high, delta)
+ CORE_ADDR low;
+ CORE_ADDR high;
+ CORE_ADDR delta;
+{
+ struct breakpoint *b;
+ extern struct breakpoint *breakpoint_chain;
+
+ ALL_BREAKPOINTS (b)
+ {
+ if (b->address >= low && b->address <= high)
+ b->address += delta;
+ }
+}
+#endif
struct symbol *sym = find_symbol_in_list (symbols, name, pp-name);
if (!sym)
{
-#ifndef IBM6000
+#ifndef IBM6000_TARGET
printf ("ERROR! stab symbol not found!\n"); /* FIXME */
#endif
}
symtab->free_code = free_linetable;
symtab->free_ptr = 0;
-#if 0 /* defined(IBM6000) */
+#ifdef IBM6000_TARGET
/* In case we need to duplicate symbol tables (to represent include
files), and in case our system needs relocation, we want to
relocate the main symbol table node only (for the main file,
free (subfile);
}
-#if 0 /* defined(IBM6000) */
+#ifdef IBM6000_TARGET
/* all include symbol tables are non-relocatable, except the main source
file's. */
- if (symtab_list)
- symtab_list->nonreloc = FALSE;
+ if (symtab)
+ symtab->nonreloc = FALSE;
#endif
if (type_vector)
case '*':
type1 = read_type (pp, objfile);
/* FIXME -- we should be doing smash_to_XXX types here. */
-#if 0
+#ifdef IBM6000_TARGET
/* postponed type decoration should be allowed. */
if (typenums[1] > 0 && typenums[1] < type_vector_length &&
(type = type_vector[typenums[1]])) {
# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
#TDEPFILES= exec.o rs6k-pinsn.o rs6k-tdep.o
-TDEPFILES= rs6000-pinsn.o rs6000-tdep.o
+TDEPFILES= rs6000-pinsn.o rs6000-tdep.o xcoffsolib.o
TM_FILE= tm-rs6000.h
#define SKIP_TRAMPOLINE_CODE(pc) 0
#endif
+/* For SVR4 shared libraries, each call goes through a small piece of
+ trampoline code in the ".init" section. IN_SOLIB_TRAMPOLINE evaluates
+ to nonzero if we are current stopped in one of these. */
+#ifndef IN_SOLIB_TRAMPOLINE
+#define IN_SOLIB_TRAMPOLINE(pc,name) 0
+#endif
#ifdef TDESC
#include "tdesc.h"
target_wait (&w);
+#ifdef SIGTRAP_STOP_AFTER_LOAD
+
+ /* Somebody called load(2), and it gave us a "trap signal after load".
+ Ignore it gracefully. */
+
+ SIGTRAP_STOP_AFTER_LOAD (w);
+#endif
+
/* See if the process still exists; clean up if it doesn't. */
if (WIFEXITED (w))
{
/* ==> See comments at top of file on this algorithm. <==*/
- if (stop_pc == stop_func_start
- && (stop_func_start != prev_func_start
- || prologue_pc != stop_func_start
- || stop_sp != prev_sp))
+ if ((stop_pc == stop_func_start
+ || IN_SOLIB_TRAMPOLINE (stop_pc, stop_func_name))
+ && (stop_func_start != prev_func_start
+ || prologue_pc != stop_func_start
+ || stop_sp != prev_sp))
{
/* It's a subroutine call.
(0) If we are not stepping over any calls ("stepi"), we
if (signal (SIGHUP, do_nothing) != SIG_IGN)
signal (SIGHUP, disconnect);
signal (SIGFPE, float_handler);
+
+#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
+ signal (SIGWINCH, SIGWINCH_HANDLER);
+#endif
}
\f
/* Read one line from the command input stream `instream'
struct objfile *objfile;
struct minimal_symbol *msymbol;
struct minimal_symbol *found_symbol = NULL;
-#ifdef IBM6000
+#ifdef IBM6000_TARGET
struct minimal_symbol *trampoline_symbol = NULL;
#endif
{
if (strcmp (msymbol -> name, name) == 0)
{
+#ifdef IBM6000_TARGET
/* I *think* all platforms using shared libraries (and trampoline code)
* will suffer this problem. Consider a case where there are 5 shared
* libraries, each referencing `foo' with a trampoline entry. When someone
* wants to put a breakpoint on `foo' and the only info we have is minimal
* symbol vector, we want to use the real `foo', rather than one of those
* trampoline entries. MGO */
-#ifdef IBM6000
/* If a trampoline symbol is found, we prefer to keep looking
for the *real* symbol. If the actual symbol not found,
then we'll use the trampoline entry. Sorry for the machine
}
}
}
-#ifdef IBM6000
+#ifdef IBM6000_TARGET
return found_symbol ? found_symbol : trampoline_symbol;
#endif
Warning: this code is trickier than it would appear at first. */
+ /* Should also requires that pc is <= end of objfile. FIXME! */
if (pc >= msymbol[lo].address)
{
while (msymbol[hi].address > pc)
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
-#include <string.h>
#include "defs.h"
+#include <string.h>
#include "frame.h"
#include "symtab.h"
#include "gdbtypes.h"
two entries (one a parameter, one a register or local), and the one
we want is the non-parm, which lookup_symbol will find for
us. After this, sym could be any SYMBOL_CLASS... */
-#ifdef IBM6000
+#ifdef IBM6000_TARGET
/* AIX/RS6000 implements a concept of traceback tables, in which case
it creates nameless parameters. Looking for those parameter symbols
will result in an error. */
if ((op & 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
pc += 4;
op = read_memory_integer (pc, 4);
+
+ /* At this point, make sure this is not a trampoline function
+ (a function that simply calls another functions, and nothing else).
+ If the next is not a nop, this branch was part of the function
+ prologue. */
+
+ if (op == 0x4def7b82 || /* crorc 15, 15, 15 */
+ op == 0x0)
+ return pc - 4; /* don't skip over this branch */
}
if ((op & 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
if ((op & 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
pc += 4;
op = read_memory_integer (pc, 4);
+ /* At this point, make sure this is not a trampoline function
+ (a function that simply calls another functions, and nothing else).
+ If the next is not a nop, this branch was part of the function
+ prologue. */
+
+ if (op == 0x4def7b82 || /* crorc 15, 15, 15 */
+ op == 0x0)
+ return; /* prologue is over */
}
if ((op & 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
}
+#if 0
+
+ *** not needed anymore ***
+
/* Return the number of initial trap signals we need to ignore once the inferior
process starts running. This will be `2' for aix-3.1, `3' for aix-3.2 */
else
return 3;
}
+#endif
the_big_top:
for (objfile = object_files; objfile; objfile = objfile->next) {
if (objfile->obfd) {
-#ifdef IBM6000
+#ifdef IBM6000_TARGET
/* If this object is from a shared library, then you should
stat on the library name, not member name. */
if (!symtab_relocated && !inferior_pid && (PC) > TEXT_SEGMENT_BASE) \
(PC) -= ( TEXT_SEGMENT_BASE + text_adjustment (exec_bfd));
+/* Load segment of a given pc value. */
+
+#define PC_LOAD_SEGMENT(PC) pc_load_segment_name(PC)
+
+
/* Conversion between a register number in stab string to actual register num. */
#define STAB_REG_TO_REGNUM(value) (value)
} while (0)
+#if 0
+ The following comment is not correct anymore. AIX has a trap signal
+ that might be sent with a "stopped after a load" status. This might
+ show up when the inferior is just started, or anytime inferior
+ loads something else. It is incorrect to try to skip over it *only* in
+ startup-time. It always has to be ignored and should not be mixed up
+ with breakpoint traps. See the macro SIGTRAP_STOP_AFTER_LOAD and its
+ usage in infrun.c.
+
/* In aix, number of the trap signals we need to skip over once the
inferior process starts running is different in version 3.1 and 3.2.
This will be 2 for version 3.1x, 3 for version 3.2x. */
#define START_INFERIOR_TRAPS_EXPECTED aix_starting_inferior_traps ()
+#endif /* 0 */
+
+#define START_INFERIOR_TRAPS_EXPECTED 2
+
+/* AIX might return a sigtrap, with a "stop after load" status. It should
+ be ignored by gdb, shouldn't be mixed up with breakpoint traps. */
+
+#define SIGTRAP_STOP_AFTER_LOAD(W) \
+ if ( (W) == 0x57c ) { \
+ if (breakpoints_inserted) { \
+ mark_breakpoints_out (); \
+ insert_breakpoints (); \
+ insert_step_breakpoint (); \
+ } \
+ resume (0, 0); \
+ continue; \
+ }
/* In aixcoff, we cannot process line numbers when we see them. This is
mainly because we don't know the boundaries of the include files. So,
#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
fi->initial_sp = 0; \
- fi->cache_fsr = 0; \
- if (fromleaf) { \
- int tmp = 0; \
- read_memory ((fi)->frame, &tmp, sizeof (int)); \
- (fi)->frame = tmp; \
- }
+ fi->cache_fsr = 0;
#define FRAME_SAVED_PC(FRAME) \
read_memory_integer (read_memory_integer ((FRAME)->frame, 4)+8, 4)
#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, using_gcc) \
fix_call_dummy(dummyname, pc, fun, nargs, type)
+
+/* Signal handler for SIGWINCH `window size changed'. */
+
+#define SIGWINCH_HANDLER aix_resizewindow
+extern void aix_resizewindow ();
+
+/* `lines_per_page' and `chars_per_line' are local to utils.c. Rectify this. */
+
+#define SIGWINCH_HANDLER_BODY \
+ \
+/* Respond to SIGWINCH `window size changed' signal, and reset GDB's \
+ window settings approproatelt. */ \
+ \
+void \
+aix_resizewindow () \
+{ \
+ int fd = fileno (stdout); \
+ if (isatty (fd)) { \
+ int val; \
+ \
+ val = atoi (termdef (fd, 'l')); \
+ if (val > 0) \
+ lines_per_page = val; \
+ val = atoi (termdef (fd, 'c')); \
+ if (val > 0) \
+ chars_per_line = val; \
+ } \
+}
+
+
/* Flag for machine-specific stuff in shared files. FIXME */
-#ifndef IBM6000
-#define IBM6000
-#endif
+#define IBM6000_TARGET
}
}
+#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
+
+ /* If tere is a better way to determine window size, use it. */
+ SIGWINCH_HANDLER ();
+#endif
+
/* If the output is not a terminal, don't paginate it. */
if (!ISATTY (stdout))
lines_per_page = UINT_MAX;
&setprintlist),
&showprintlist);
}
+
+/* Machine specific function to handle SIGWINCH signal. */
+
+#ifdef SIGWINCH_HANDLER_BODY
+ SIGWINCH_HANDLER_BODY
+#endif
#include "objfiles.h"
#include "libbfd.h" /* BFD internals (sigh!) FIXME */
+#include "xcoffsolib.h"
/* Prototypes for local functions */
static void exec_files_info();
extern struct objfile *lookup_objfile_bfd ();
+#if 0
/*
* the vmap struct is used to describe the virtual address space of
* the target we are manipulating. The first entry is always the "exec"
};
static struct vmap *vmap; /* current vmap */
+#endif /* 0 */
+
+struct vmap *vmap; /* current vmap */
extern struct target_ops exec_ops;
struct objfile *obj;
vp = (void*) xmalloc (sizeof (*vp));
+ bzero (vp, sizeof (*vp));
vp->nxt = 0;
vp->bfd = bf;
vp->name = bfd_get_filename(arch ? arch : bf);
obj = lookup_objfile_bfd (bf);
if (exec_bfd && !obj) {
obj = allocate_objfile (bf, 0);
+
+#if 0
+ This is only needed if we want to load shared libraries no matter what.
+ Since we provide the choice of incremental loading of shared objects now,
+ we don't have to load them as default anymore.
+
syms_from_objfile (obj, 0, 0, 0);
+#endif
}
/* find the end of the list, and append. */
if (fstat(fileno(io), &si) < 0)
fatal("cannot fstat BFD for sym");
- if (si.st_dev != vip->st_dev
- || si.st_ino != vip->st_ino)
+ if (vip && (si.st_dev != vip->st_dev
+ || si.st_ino != vip->st_ino))
continue;
}
, name);
retry:
for (got_one = 0, vp = vmap; vp; vp = vp->nxt) {
- FILE *io;
+ FILE *io;
+
+ /* First try to find a `vp', which is the same as in ldinfo.
+ If not the same, just continue and grep the next `vp'. If same,
+ relocate its tstart, tend, dstart, dend values. If no such `vp'
+ found, get out of this for loop, add this ldi entry as a new vmap
+ (add_vmap) and come back, fins its `vp' and so on... */
+
+ /* The filenames are not always sufficient to match on. */
- /* The filenames are not always sufficient to match on. */
- if ((name[0] == "/"
- && !eq(name, vp->name))
- || (memb[0] && !eq(memb, vp->member)))
- continue;
+ if ((name[0] == "/" && !eq(name, vp->name))
+ || (memb[0] && !eq(memb, vp->member)))
+ continue;
- /* totally opaque! */
- io = bfd_cache_lookup(vp->bfd);
- if (!io)
- fatal("cannot find BFD's iostream for %s"
- , vp->name);
+ io = bfd_cache_lookup(vp->bfd); /* totally opaque! */
+ if (!io)
+ fatal("cannot find BFD's iostream for %s", vp->name);
- /* see if we are referring to the same file */
- if (fstat(fileno(io), &vi) < 0)
- fatal("cannot fstat BFD for %s", vp->name);
+ /* see if we are referring to the same file */
- if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
- continue;
+ if (fstat(fileno(io), &vi) < 0)
+ fatal("cannot fstat BFD for %s", vp->name);
- if (!retried)
- close(ldi->ldinfo_fd);
+ if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
+ continue;
- ++got_one;
+ if (!retried)
+ close(ldi->ldinfo_fd);
- /* found a corresponding VMAP. remap! */
- ostart = vp->tstart;
+ ++got_one;
- vp->tstart = ldi->ldinfo_textorg;
- vp->tend = vp->tstart + ldi->ldinfo_textsize;
- vp->dstart = ldi->ldinfo_dataorg;
- vp->dend = vp->dstart + ldi->ldinfo_datasize;
+ /* found a corresponding VMAP. remap! */
+ ostart = vp->tstart;
- if (vp->tadj) {
- vp->tstart += vp->tadj;
- vp->tend += vp->tadj;
- }
+ vp->tstart = ldi->ldinfo_textorg;
+ vp->tend = vp->tstart + ldi->ldinfo_textsize;
+ vp->dstart = ldi->ldinfo_dataorg;
+ vp->dend = vp->dstart + ldi->ldinfo_datasize;
- /* relocate symbol table(s). */
- vmap_symtab(vp, ostart, &vi);
+ if (vp->tadj) {
+ vp->tstart += vp->tadj;
+ vp->tend += vp->tadj;
+ }
+
+ /* relocate symbol table(s). */
+ vmap_symtab(vp, ostart, &vi);
- /* there may be more, so we don't break out of the loop. */
+ /* there may be more, so we don't break out of the loop. */
}
- /*
- * if there was no matching *vp, we must perforce create
- * the sucker(s)
- */
- if (!got_one && !retried) {
- add_vmap(ldi);
- ++retried;
- goto retry;
+ /* if there was no matching *vp, we must perforce create the sucker(s) */
+ if (!got_one && !retried) {
+ add_vmap(ldi);
+ ++retried;
+ goto retry;
}
} while (ldi->ldinfo_next
&& (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
if (!vp)
return;
- printf("\n\tMapping info for file `%s'.\n", vp->name);
- printf("\t %8.8s %8.8s %8.8s %s\n",
- "start", "end", "section", "file(member)");
+ printf("\tMapping info for file `%s'.\n", vp->name);
+
+ printf("\t %8.8s %8.8s %8.8s %8.8s %8.8s %s\n",
+ "tstart", "tend", "dstart", "dend", "section", "file(member)");
for (; vp; vp = vp->nxt)
- printf("\t0x%8.8x 0x%8.8x %s%s%s%s\n",
- vp->tstart,
- vp->tend,
- vp->name,
- vp->member ? "(" : "",
- vp->member,
- vp->member ? ")" : "");
+ printf("\t0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x %s%s%s%s\n",
+ vp->tstart,
+ vp->tend,
+ vp->dstart,
+ vp->dend,
+ vp->name,
+ *vp->member ? "(" : "",
+ vp->member,
+ *vp->member ? ")" : "");
}
#ifdef DAMON
#include "defs.h"
#include "bfd.h"
-#ifdef IBM6000
+#ifdef IBM6000_HOST
/* Native only: Need struct tbtable in <sys/debug.h>. */
/* AIX COFF names have a preceeding dot `.' */
#include <sys/file.h>
#endif
#include <sys/stat.h>
-/*#include <linenum.h>*/
#include <sys/debug.h>
#include "symtab.h"
#include "libcoff.h" /* FIXME, internal data from BFD */
#include "coff/rs6000.h" /* FIXME, raw file-format guts of xcoff */
+
+/* Define this if you want gdb use the old xcoff symbol processing. This
+ way it won't use common `define_symbol()' function and Sun dbx stab
+ string grammar. And likely it won't be able to do G++ debugging. */
+
+/* #define NO_DEFINE_SYMBOL 1 */
+
+/* Define this if you want gdb to ignore typdef stabs. This was needed for
+ one of Transarc, to reduce the size of the symbol table. Types won't be
+ recognized, but tag names will be. */
+
+/* #define NO_TYPES 1 */
+
/* Simplified internal version of coff symbol table information */
struct coff_symbol {
if (ALLOCED) \
namestr = (NAME) + 1; \
else { \
- namestr = obstack_copy0 (&objfile->symbol_obstack, (NAME) + 1, strlen ((NAME)+1)); \
+ (NAME) = namestr = \
+ obstack_copy0 (&objfile->symbol_obstack, (NAME) + 1, strlen ((NAME)+1)); \
(ALLOCED) = 1; \
} \
prim_record_minimal_symbol (namestr, (ADDR), (TYPE)); \
long fcn_line_offset;
size_t size;
+ struct coff_symbol fcn_stab_saved;
+
/* fcn_cs_saved is global because process_xcoff_symbol needs it. */
union internal_auxent fcn_aux_saved;
struct type *fcn_type_saved = NULL;
/* record trampoline code entries as mst_unknown symbol. When we
lookup mst symbols, we will choose mst_text over mst_unknown. */
+#if 1
+ /* After the implementation of incremental loading of shared
+ libraries, we don't want to access trampoline entries. This
+ approach has a consequence of the necessity to bring the whole
+ shared library at first, in order do anything with it (putting
+ breakpoints, using malloc, etc). On the other side, this is
+ consistient with gdb's behaviour on a SUN platform. */
+
+ /* Trying to prefer *real* function entry over its trampoline,
+ by assigning `mst_unknown' type to trampoline entries fails.
+ Gdb treats those entries as chars. FIXME. */
+
+ /* Recording this entry is necessary. Single stepping relies on
+ this vector to get an idea about function address boundaries. */
+
+ prim_record_minimal_symbol (0, cs->c_value, mst_unknown);
+#else
+
+ /* record trampoline code entries as mst_unknown symbol. When we
+ lookup mst symbols, we will choose mst_text over mst_unknown. */
+
RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_unknown,
symname_alloced);
+#endif
continue;
}
break;
case C_FUN:
+#ifdef NO_DEFINE_SYMBOL
/* For a function stab, just save its type in `fcn_type_saved', and leave
it for the `.bf' processing. */
{
fcn_type_saved = lookup_function_type (read_type (&pp, objfile));
}
+#else
+ fcn_stab_saved = *cs;
+#endif
break;
mark_first_line (fcn_line_offset, cs->c_symnum);
new = push_context (0, fcn_start_addr);
+
+#ifdef NO_DEFINE_SYMBOL
new->name = process_xcoff_symbol (&fcn_cs_saved, objfile);
/* Between a function symbol and `.bf', there always will be a function
SYMBOL_TYPE (new->name) = fcn_type_saved;
fcn_type_saved = NULL;
}
+#else
+ new->name = define_symbol
+ (fcn_cs_saved.c_value, fcn_stab_saved.c_name, 0, 0, objfile);
+#endif
}
else if (strcmp (cs->c_name, ".ef") == 0) {
#endif
case C_DECL: /* a type decleration?? */
+
+#if defined(NO_TYPEDEFS) || defined(NO_DEFINE_SYMBOL)
qq = (char*) strchr (name, ':');
if (!qq) /* skip if there is no ':' */
return NULL;
obsavestring (name, qq-name,
&objfile->symbol_obstack);
}
- ttype = SYMBOL_TYPE (sym) = read_type (&pp, objfile);
+ ttype = SYMBOL_TYPE (sym) = read_type (&pp);
+
+ /* if there is no name for this typedef, you don't have to keep its
+ symbol, since nobody could ask for it. Otherwise, build a symbol
+ and add it into symbol_list. */
+
+ if (nameless)
+ return;
+
+#ifdef NO_TYPEDEFS
+ /* Transarc wants to eliminate type definitions from the symbol table.
+ Limited debugging capabilities, but faster symbol table processing
+ and less memory usage. Note that tag definitions (starting with
+ 'T') will remain intact. */
+
+ if (qq[1] != 'T' && (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0')) {
+
+ if (SYMBOL_NAME (sym))
+ TYPE_NAME (ttype) = SYMBOL_NAME (sym);
+ else
+ TYPE_NAME (ttype) = obsavestring (name, qq-name);
+
+ return;
+ }
+
+#endif /* !NO_TYPEDEFS */
/* read_type() will return null if type (or tag) definition was
unnnecessarily duplicated. Also, if the symbol doesn't have a name,
symbol, since nobody could ask for it. Otherwise, build a symbol
and add it into symbol_list. */
- if (!nameless) {
- if (qq[1] == 'T')
+ if (qq[1] == 'T')
SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
- else if (qq[1] == 't')
+ else if (qq[1] == 't')
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
- else {
- printf ("ERROR: Unrecognized stab string.\n");
+ else {
+ warning ("Unrecognized stab string.\n");
return NULL;
- }
+ }
- SYMBOL_CLASS (sym) = LOC_TYPEDEF;
- if (!SYMBOL_NAME (sym))
- SYMBOL_NAME (sym) = obsavestring (name, qq-name,
- &objfile->symbol_obstack);
+ SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+ if (!SYMBOL_NAME (sym))
+ SYMBOL_NAME (sym) = obsavestring (name, qq-name);
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list
+ SYMBOL_DUP (sym, sym2);
+ add_symbol_to_list
(sym2, within_function ? &local_symbols : &file_symbols);
- /* For a combination of struct and type, add one more symbol
- for the type. */
+ /* For a combination of struct and type, add one more symbol
+ for the type. */
- if (struct_and_type_combined) {
+ if (struct_and_type_combined) {
SYMBOL_DUP (sym, sym2);
SYMBOL_NAMESPACE (sym2) = VAR_NAMESPACE;
add_symbol_to_list
(sym2, within_function ? &local_symbols : &file_symbols);
- }
- }
+ }
- /* assign a name to the type node. */
+ /* assign a name to the type node. */
- if (!nameless && (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0')) {
+ if (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0') {
if (struct_and_type_combined)
TYPE_NAME (ttype) = SYMBOL_NAME (sym);
-
-/* else if (SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE) */
else if (qq[1] == 'T') /* struct namespace */
TYPE_NAME (ttype) = concat (
TYPE_CODE (ttype) == TYPE_CODE_UNION ? "union " :
TYPE_CODE (ttype) == TYPE_CODE_STRUCT? "struct " : "enum ",
SYMBOL_NAME (sym), NULL);
}
-
break;
+#else /* !NO_DEFINE_SYMBOL */
+ return define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+#endif
+
case C_GSYM:
add_stab_to_list (name, &global_stabs);
break;
case C_PSYM:
case C_RPSYM:
+
+#ifdef NO_DEFINE_SYMBOL
if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL)
return NULL;
SYMBOL_NAME (sym) = obsavestring (name, pp-name, &objfile -> symbol_obstack);
SYMBOL_DUP (sym, sym2);
add_symbol_to_list (sym2, &local_symbols);
break;
+#else
+ sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+ SYMBOL_CLASS (sym) = (cs->c_sclass == C_PSYM) ? LOC_ARG : LOC_REGPARM;
+ return sym;
+#endif
case C_STSYM:
+
+#ifdef NO_DEFINE_SYMBOL
if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL)
return NULL;
SYMBOL_NAME (sym) = obsavestring (name, pp-name, &objfile -> symbol_obstack);
add_symbol_to_list
(sym2, within_function ? &local_symbols : &file_symbols);
break;
+#else
+ /* If we are going to use Sun dbx's define_symbol(), we need to
+ massage our stab string a little. Change 'V' type to 'S' to be
+ comparible with Sun. */
+
+ if (*name == ':' || (pp = (char *) index (name, ':')) == NULL)
+ return NULL;
+
+ ++pp;
+ if (*pp == 'V') *pp = 'S';
+ sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+ SYMBOL_VALUE (sym) += static_block_base;
+ return sym;
+#endif
case C_LSYM:
if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL)
break;
case C_RSYM:
+
+#ifdef NO_DEFINE_SYMBOL
pp = (char*) strchr (name, ':');
SYMBOL_CLASS (sym) = LOC_REGISTER;
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (cs->c_value);
SYMBOL_DUP (sym, sym2);
add_symbol_to_list (sym2, &local_symbols);
break;
+#else
+ if (pp) {
+ sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+ return sym;
+ }
+ else {
+ warning ("A non-stab C_RSYM needs special handling.");
+ return NULL;
+ }
+#endif
default :
- printf ("ERROR: Unexpected storage class: %d.\n", cs->c_sclass);
+ warning ("Unexpected storage class: %d.", cs->c_sclass);
return NULL;
}
}
read_xcoff_symtab(objfile, num_symbols);
- make_cleanup (free_debugsection, 0);
+ /* Free debug section. */
+ free_debugsection ();
/* Sort symbols alphabetically within each block. */
sort_syms ();
struct s *p;
};
*/
-#if 0
+
+
/* Smash TYPE to be a type of pointers to TO_TYPE.
If TO_TYPE is not permanent and has no pointer-type yet,
record TYPE as its pointer-type. */
smash_to_pointer_type (type, to_type)
struct type *type, *to_type;
{
- int type_permanent = (TYPE_FLAGS (type) & TYPE_FLAG_PERM);
+/* int type_permanent = (TYPE_FLAGS (type) & TYPE_FLAG_PERM); */
bzero (type, sizeof (struct type));
TYPE_TARGET_TYPE (type) = to_type;
/* ??? TYPE_TARGET_TYPE and TYPE_MAIN_VARIANT are the same. You can't do
this. It will break the target type!!!
TYPE_MAIN_VARIANT (type) = type;
-*/
if (type_permanent)
TYPE_FLAGS (type) |= TYPE_FLAG_PERM;
+*/
- if (TYPE_POINTER_TYPE (to_type) == 0
+ if (TYPE_POINTER_TYPE (to_type) == 0)
+#if 0
&& (!(TYPE_FLAGS (to_type) & TYPE_FLAG_PERM)
|| type_permanent))
+#endif /* 0 */
{
TYPE_POINTER_TYPE (to_type) = type;
}
}
-#endif
-#else /* IBM6000 */
+#else /* IBM6000_HOST */
struct type *
builtin_type (pp)
char **pp;
{
fatal ("internals eror: builtin_type called!");
}
-#endif /* IBM6000 */
+#endif /* IBM6000_HOST */
#define DEBUG 1
-#if defined (DEBUG) && defined (IBM6000) /* Needs both defined */
+#if defined (DEBUG) && defined (IBM6000_HOST) /* Needs both defined */
void
dump_strtbl ()
{
--- /dev/null
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/ldr.h>
+
+#include "defs.h"
+#include "bfd.h"
+/*#include "libbfd.h" /* BFD internals (sigh!) FIXME */
+#include "xcoffsolib.h"
+
+
+extern struct symtab *current_source_symtab;
+extern int current_source_line;
+
+
+/* The real work of adding a shared library file to the symtab and
+ the section list. */
+
+void
+solib_add (arg_string, from_tty, target)
+ char *arg_string;
+ int from_tty;
+ struct target_ops *target;
+{
+ char *val;
+ struct vmap *vp = vmap;
+ struct objfile *obj;
+ struct symtab *saved_symtab;
+ int saved_line;
+
+ int loaded = 0; /* true if any shared obj loaded */
+ int matched = 0; /* true if any shared obj matched */
+
+ if (arg_string == 0)
+ re_comp (".");
+ else if (val = (char *) re_comp (arg_string)) {
+ error ("Invalid regexp: %s", val);
+ }
+ if (!vp || !vp->nxt)
+ return;
+
+ /* save current symbol table and line number, in case they get changed
+ in symbol loading process. */
+
+ saved_symtab = current_source_symtab;
+ saved_line = current_source_line;
+
+ /* skip over the first vmap, it is the main program, always loaded. */
+ vp = vp->nxt;
+
+ for (; vp; vp = vp->nxt) {
+
+ if (re_exec (vp->name) || (*vp->member && re_exec (vp->member))) {
+
+ matched = 1;
+
+ /* if already loaded, continue with the next one. */
+ if (vp->loaded) {
+
+ printf ("%s%s%s%s: already loaded.\n",
+ *vp->member ? "(" : "",
+ vp->member,
+ *vp->member ? ") " : "",
+ vp->name);
+ continue;
+ }
+
+ printf ("Loading %s%s%s%s...",
+ *vp->member ? "(" : "",
+ vp->member,
+ *vp->member ? ") " : "",
+ vp->name);
+ fflush (stdout);
+
+ obj = lookup_objfile_bfd (vp->bfd);
+ if (!obj) {
+ warning ("\nObj structure for the shared object not found. Loading failed.");
+ continue;
+ }
+
+ syms_from_objfile (obj, 0, 0);
+ vmap_symtab (vp, 0, 0);
+ printf ("Done.\n");
+ loaded = vp->loaded = 1;
+ }
+ }
+ /* if any shared object is loaded, then misc_func_vector needs sorting. */
+ if (loaded) {
+#if 0
+ sort_misc_function_vector ();
+#endif
+ current_source_symtab = saved_symtab;
+ current_source_line = saved_line;
+
+ /* Getting new symbols might change our opinion about what is frameless.
+ Is this correct?? FIXME. */
+/* reinit_frame_cache(); */
+ }
+ else if (!matched)
+ printf ("No matching shared object found.\n");
+
+}
+
+
+/* Return the module name of a given text address. Note that returned buffer
+ is not persistent. */
+
+char *
+pc_load_segment_name (addr)
+CORE_ADDR addr;
+{
+ static char buffer [BUFSIZ];
+ struct vmap *vp = vmap;
+
+ buffer [0] = buffer [1] = '\0';
+ for (; vp; vp = vp->nxt)
+ if (vp->tstart <= addr && addr < vp->tend) {
+ if (*vp->member) {
+ buffer [0] = '(';
+ strcat (&buffer[1], vp->member);
+ strcat (buffer, ")");
+ }
+ strcat (buffer, vp->name);
+ return buffer;
+ }
+ return "(unknown load module)";
+}
+
+
+solib_info (ldi)
+register struct ld_info *ldi;
+{
+
+ struct vmap *vp = vmap;
+
+ if (!vp || !vp->nxt) {
+ printf("No shared libraries loaded at this time.\n");
+ return;
+ }
+
+ /* skip over the first vmap, it is the main program, always loaded. */
+ vp = vp->nxt;
+
+ printf ("\
+Text Range Data Range Syms Shared Object Library\n");
+
+ for (; vp; vp = vp->nxt) {
+
+ printf ("0x%08x-0x%08x 0x%08x-0x%08x %s %s%s%s%s\n",
+ vp->tstart, vp->tend,
+ vp->dstart, vp->dend,
+ vp->loaded ? "Yes" : "No ",
+ *vp->member ? "(" : "",
+ vp->member,
+ *vp->member ? ") " : "",
+ vp->name);
+ }
+}
+
+
+void
+sharedlibrary_command (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ dont_repeat();
+ solib_add (args, from_tty, (struct target_ops *)0);
+}
+
+void
+_initialize_solib()
+{
+
+ add_com("sharedlibrary", class_files, sharedlibrary_command,
+ "Load shared object library symbols for files matching REGEXP.");
+ add_info("sharedlibrary", solib_info,
+ "Status of loaded shared object libraries");
+}
--- /dev/null
+/*
+ the vmap struct is used to describe the virtual address space of
+ the target we are manipulating. The first entry is always the "exec"
+ file. Subsequent entries correspond to other objects that are
+ mapped into the address space of a process created from the "exec" file.
+ These are either in response to exec()ing the file, in which case all
+ shared libraries are loaded, or a "load" system call, followed by the
+ user's issuance of a "load" command. */
+
+struct vmap {
+ struct vmap *nxt; /* ^ to next in chain */
+ bfd *bfd; /* BFD for mappable object library */
+ char *name; /* ^ to object file name */
+ char *member; /* ^ to member name */
+ CORE_ADDR tstart; /* virtual addr where member is mapped */
+ CORE_ADDR tend; /* virtual upper bound of member */
+ CORE_ADDR tadj; /* heuristically derived adjustment */
+ CORE_ADDR dstart; /* virtual address of data start */
+ CORE_ADDR dend; /* vitrual address of data end */
+
+ CORE_ADDR ostart; /* objext start ??? */
+ unsigned loaded:1; /* True if symbols are loaded */
+ unsigned reloced:1; /* True, if symbols relocated */
+ unsigned padding:14;
+};
+
+
+struct vmap_and_bfd {
+ bfd *pbfd;
+ struct vmap *pvmap;
+};
+
+extern struct vmap *vmap;
#define CPLUS_MARKER '.'
/* Flag for machine-specific stuff in shared files. FIXME */
-#ifndef IBM6000
-#define IBM6000
-#endif
+#define IBM6000_HOST
/* /usr/include/stdlib.h always uses void* and void,
even when __STDC__ isn't defined. */
projects / deliverable / binutils-gdb.git / commitdiff
