diff options
| -rw-r--r-- | gdb/ChangeLog | 27 | ||||
| -rw-r--r-- | gdb/buildsym.c | 4 | ||||
| -rw-r--r-- | gdb/infrun.c | 10 | ||||
| -rwxr-xr-x | gdb/munch | 6 | ||||
| -rw-r--r-- | gdb/rs6000-tdep.c | 277 | ||||
| -rw-r--r-- | gdb/rs6000-xdep.c | 87 | ||||
| -rwxr-xr-x | gdb/rs6k-opcode.h | 4 | ||||
| -rw-r--r-- | gdb/symtab.c | 11 | ||||
| -rw-r--r-- | gdb/tm-rs6000.h | 88 | ||||
| -rw-r--r-- | gdb/xcoffexec.c | 131 | ||||
| -rw-r--r-- | gdb/xcoffread.c | 971 | ||||
| -rw-r--r-- | gdb/xm-rs6000.h | 12 |
12 files changed, 1222 insertions, 406 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 26bce5f..821d3c0 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,30 @@ +Thu Feb 27 22:57:19 1992 Per Bothner (bothner@cygnus.com) + + * rs6k-opcode.h, tm-rs6000.h, xm-rs6000.h, rs6000-tdep.c, + rs6000-xdep.c, xcoffexec.c, xcoffread.c: + Merge in changes (mostly from IBM) for RS6000. + * breakpoint.c, buildsym.c, infptrace.c, stack.c, symtab.c: + More changes from IBM for RS6000. These are in machine- + independent code, and probably could do with some cleaning + up. The most questionable of these are #ifdef IBM6000. + * infrun.c, sparc-tdep.c: Pass a parameter (signal number) + to single_step() (for consistency with rs6000 and i860). + * utils.c: Allow the 1st arg to xrealloc to be NULL + (in which case do malloc). This removes the need for + some tests in xcoff code (and perhaps other places?). + * coffread.c: Removed variables last_source_file, + type_vector, and type_vector_length as these are now + defined by buildsym.[ch]. + * defs.h: Remove prototypes for malloc and realloc, since + these should only be used to implement xmalloc and xrealloc, + and they conflict with <stdlib.h> in AIX - where they + return void* even when __STDC__ isn't defined. Sigh. + * munch: Recognize *initialize* in data as well as text + (AIX uses data). Also, incorporate a patch from Garrett + Wollman <wollman@uvm-gen.uvm.edu> to make the sed script + much more sensible, by only trying to match the name of + the initialize_foo function, and not the junk before it. + Thu Feb 27 20:07:43 1992 Stu Grossman (grossman at cygnus.com) * breakpoint.c (breakpoint_re_set_one): Don't reset breakpoint diff --git a/gdb/buildsym.c b/gdb/buildsym.c index 11d5091..d71bdd0 100644 --- a/gdb/buildsym.c +++ b/gdb/buildsym.c @@ -842,6 +842,10 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile) blockvector = make_blockvector (objfile); } +#ifdef PROCESS_LINENUMBER_HOOK + PROCESS_LINENUMBER_HOOK (); /* Needed for aixcoff. */ +#endif + /* Now create the symtab objects proper, one for each subfile. */ /* (The main file is the last one on the chain.) */ diff --git a/gdb/infrun.c b/gdb/infrun.c index 3be0bb9..f8bc976 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -307,7 +307,7 @@ resume (step, sig) #ifdef NO_SINGLE_STEP if (step) { - single_step(); /* Do it the hard way, w/temp breakpoints */ + single_step(sig); /* Do it the hard way, w/temp breakpoints */ step = 0; /* ...and don't ask hardware to do it. */ } #endif @@ -555,7 +555,7 @@ child_create_inferior (exec_file, allargs, env) #ifdef NEED_POSIX_SETPGID debug_setpgrp = setpgid (0, 0); #else -#ifdef USG +#if defined(USG) && !defined(SETPGRP_ARGS) debug_setpgrp = setpgrp (); #else debug_setpgrp = setpgrp (getpid (), getpid ()); @@ -916,7 +916,7 @@ wait_for_inferior () will be set and we should check whether we've hit the step breakpoint. */ if (stop_signal == SIGTRAP && trap_expected - && step_resume_break_address == NULL) + && step_resume_break_address == 0) bpstat_clear (&stop_bpstat); else { @@ -1046,7 +1046,7 @@ wait_for_inferior () /* Need to blow away step-resume breakpoint, as it interferes with us */ remove_step_breakpoint (); - step_resume_break_address = NULL; + step_resume_break_address = 0; stop_step_resume_break = 0; #if 0 /* FIXME - Need to implement nested temporary breakpoints */ @@ -1409,7 +1409,7 @@ wait_for_inferior () breakpoints_inserted = 0; } else if (!breakpoints_inserted && - (step_resume_break_address != NULL || !another_trap)) + (step_resume_break_address != 0 || !another_trap)) { insert_step_breakpoint (); breakpoints_failed = insert_breakpoints (); @@ -20,7 +20,7 @@ if test "`$MUNCH_NM main.o | egrep main | egrep FUNC | egrep GLOB`" != "" ; then # System V Release 4 style nm $MUNCH_NM $* | egrep '|__?initialize_' | egrep FUNC | \ sed -e 's/^.*\(_initialize_[a-zA-Z0-9_]*\).*$/ {extern void \1 (); \1 ();}/' -elif test "`$MUNCH_NM main.o | egrep 'T _?main$'`" = "" ; then +elif test "`$MUNCH_NM main.o | egrep '[TD] _?main$'`" = "" ; then # System V style nm shift; $MUNCH_NM $* | egrep '^(.*[^a-zA-Z_]_|_)_?initialize_.*\.text' | \ @@ -28,8 +28,8 @@ elif test "`$MUNCH_NM main.o | egrep 'T _?main$'`" = "" ; then else # BSD style nm # We now accept either text or data symbols, since the RT/PC uses data. - $MUNCH_NM -p $* | egrep '[TD] *_?_initialize_' | \ - sed -e 's/^.*[TD] *_*\(.*\)/ {extern void _\1 (); _\1 ();}/' + $MUNCH_NM -p $* | egrep '[TD] *_?[_.]initialize_' | \ + sed -e 's/^.*\(initialize_.*\)/ {extern void _\1 (); _\1 ();}/' fi echo '}' diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c index eb203b2..e90222f 100644 --- a/gdb/rs6000-tdep.c +++ b/gdb/rs6000-tdep.c @@ -46,190 +46,6 @@ extern int attach_flag; /* Nonzero if we just simulated a single step break. */ int one_stepped; -#if 0 - -/* This is Damon's implementation of single step simulation. It suffers the - following program: - - 1 main () { - 2 char buf[10]; - 3 puts ("test"); - 4 strcmp (buf, "test"); puts ("test"); - 5 exit (0); - 6 } - - You cannot `next' on line 4 in the above program. gdb puts a breakpoint - to the return address of `strcmp', and when execution arrives that point, - it is still in the line range and gdb attemps to resume it with single - steps. At that point the breakpoint at step_resume_break_address (return - address of strcmp) and single step's breakpoint mixes up and we end up - with a breakpoint which its shadow and itself are identical. - - Fix that problem and use this version. FIXMEmgo. -*/ - - -static struct sstep_breaks { - int address; - int data; -} tbreak[2]; - - -/* - * branch_dest - calculate all places the current instruction may go - */ -static -branch_dest(tb) - register struct sstep_breaks *tb; -{ - register ulong opcode, iar; - long instr; - int immediate, absolute;; - - iar = read_pc(); /* current IAR */ - target_read_memory(iar, &instr, sizeof (instr)); /* current inst */ - - opcode = instr >> 26; - absolute = instr & 2; - - tb[1].address = -1; - - switch (opcode) { - case 0x10: /* branch conditional */ - immediate = ((instr & ~3) << 16) >> 16; - - /* - * two possible locations for next instruction - */ - tb[0].address = iar + 4; - tb[1].address = immediate + (absolute ? 0 : iar); - - break; - - case 0x12: /* branch unconditional */ - immediate = ((instr & ~3) << 6) >> 6; - - /* - * only one possible location for next instr - */ - tb[0].address = immediate + (absolute ? 0 : iar); - - break; - - case 0x13: /* branch conditional register */ - /* - * WE NEED TO CHECK THE CR HERE, TO SEE IF THIS IS - * REALLY UNCONDITIONAL. - */ - tb++->address = iar + 4; - - switch ((instr >> 1) & 0x3ff) { - case 0x10: /* branch conditional register */ - tb->address = read_register(LR_REGNUM) & ~3; - sigtramp_chk(tb); /* return from sig handler? */ - break; - - case 0x210: /* branch cond to CTR */ - tb->address = read_register(CTR_REGNUM) & ~3; - sigtramp_chk(tb); /* return from sig handler? */ - break; - - default: - /* - * not a branch. - */ - tb->address = iar + 4; - break; - } - break; - - default: - /* - * not a branch, flow proceeds normally - */ - tb->address = iar + 4; - break; - } -} - -/* - * sigtramp_chk - heuristic check to see if we think we are returning - * from a signal handler. - * - * Input: - * tb - ^ to a single step branch location - * - * Note: - * When we are at the "br" instruction returning to a signal handler, - * we return in user mode to an address in the kernel. If the - * segment of the branch target is 0, we may very well be in a - * signal handler. From scrounging through this code, we note that - * register 29 has the signal context pointer, from which we can - * determine where we will end up next. - */ -sigtramp_chk(tb) -register struct sstep_breaks *tb; { - struct sigcontext sc; - - if (tb->address & 0xf0000000) - return; /* can't have been sigtramp */ - - if (target_read_memory(read_register(GPR29), &sc, sizeof (sc))) - return; /* read fails, heuristic fails */ - - if ((sc.sc_jmpbuf.jmp_context.iar & 0xf0000000) == 0x10000000) { - /* - * looks like it might be ok..... - */ - tb->address = sc.sc_jmpbuf.jmp_context.iar; - } -} - - -/* - * single_step - no trace mode harware support, or software support. - * sigh. - */ -single_step(signal) { - register i; - - if (!one_stepped) { - /* - * need to set breakpoints for single step. - * figure out all places the current instruction could go. - */ - branch_dest(&tbreak[0]); - - /* - * always at least one place to go to - */ - target_insert_breakpoint(tbreak[0].address, &tbreak[0].data); - - /* - * if there is another possible location, set a breakpoint there - * as well. - */ - if (tbreak[1].address != -1) - target_insert_breakpoint(tbreak[1].address, &tbreak[1].data); - - one_stepped = 1; - ptrace(PT_CONTINUE, inferior_pid, 1, signal, 0); - } else { - /* - * need to clear the breakpoints. - */ - for (i = 0; i < 2; ++i) - if (tbreak[i].address != -1) - target_remove_breakpoint(tbreak[i].address, &tbreak[i].data); - - one_stepped = 0; - } - - return 1; -} - -#else /* !DAMON'S VERSION */ - /* Breakpoint shadows for the single step instructions will be kept here. */ static struct sstep_breaks { @@ -280,7 +96,7 @@ branch_dest (opcode, instr, pc, safety) default: return -1; } - return (dest < 0x10000000) ? safety : dest; + return (dest < TEXT_SEGMENT_BASE) ? safety : dest; } @@ -309,6 +125,10 @@ int signal; opcode = insn >> 26; breaks[1] = branch_dest (opcode, insn, loc, breaks[0]); + /* Don't put two breakpoints on the same address. */ + if (breaks[1] == breaks[0]) + breaks[1] = -1; + stepBreaks[1].address = -1; for (ii=0; ii < 2; ++ii) { @@ -324,7 +144,7 @@ int signal; } one_stepped = 1; - ptrace (PT_CONTINUE, inferior_pid, 1, signal); + ptrace (PT_CONTINUE, inferior_pid, 1, signal, 0); } else { @@ -336,10 +156,9 @@ int signal; one_stepped = 0; } + errno = 0; return 1; } -#endif /* !DAMON's version of single step. */ - /* return pc value after skipping a function prologue. */ @@ -360,8 +179,6 @@ int pc; pc += 4; op = read_memory_integer (pc, 4); } - else /* else, this is a frameless invocation */ - return pc; if ((op & 0xfc00003e) == 0x7c000026) { /* mfcr Rx */ pc += 4; @@ -373,10 +190,12 @@ int pc; op = read_memory_integer (pc, 4); } +#if 0 if ((op & 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */ pc += 4; /* store floating register double */ op = read_memory_integer (pc, 4); } +#endif if ((op & 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */ pc += 4; @@ -396,23 +215,32 @@ int pc; op = read_memory_integer (pc, 4); } - while ((op & 0xfc1f0000) == 0x90010000) { /* st r?, NUM(r1) */ - pc += 4; - op = read_memory_integer (pc, 4); - } + /* store parameters into stack */ + while( + (op & 0xfc1f0000) == 0xd8010000 || /* stfd Rx,NUM(r1) */ + (op & 0xfc1f0000) == 0x90010000 || /* st r?, NUM(r1) */ + (op & 0xfc000000) == 0xfc000000 || /* frsp, fp?, .. */ + (op & 0xd0000000) == 0xd0000000) /* stfs, fp?, .. */ + { + pc += 4; /* store fpr double */ + op = read_memory_integer (pc, 4); + } if (op == 0x603f0000) { /* oril r31, r1, 0x0 */ pc += 4; /* this happens if r31 is used as */ op = read_memory_integer (pc, 4); /* frame ptr. (gcc does that) */ - if ((op >> 16) == 0x907f) { /* st r3, NUM(r31) */ - pc += 4; + tmp = 0; + while ((op >> 16) == (0x907f + tmp)) { /* st r3, NUM(r31) */ + pc += 4; /* st r4, NUM(r31), ... */ op = read_memory_integer (pc, 4); + tmp += 0x20; } } return pc; } + /* text start and end addresses in virtual memory. */ CORE_ADDR text_start; @@ -424,10 +252,21 @@ CORE_ADDR text_end; frames, etc. *************************************************************************/ +/* The total size of dummy frame is 436, which is; + + 32 gpr's - 128 bytes + 32 fpr's - 256 " + 7 the rest - 28 " + and 24 extra bytes for the callee's link area. The last 24 bytes + for the link area might not be necessary, since it will be taken + care of by push_arguments(). */ + +#define DUMMY_FRAME_SIZE 436 + #define DUMMY_FRAME_ADDR_SIZE 10 /* Make sure you initialize these in somewhere, in case gdb gives up what it - was debugging and starts debugging something else. FIXMEmgo */ + was debugging and starts debugging something else. FIXMEibm */ static int dummy_frame_count = 0; static int dummy_frame_size = 0; @@ -464,15 +303,13 @@ push_dummy_frame () before writing register values into the new frame, decrement and update %sp first in order to secure your frame. */ - write_register (SP_REGNUM, sp-408); + write_register (SP_REGNUM, sp-DUMMY_FRAME_SIZE); -#if 1 /* gdb relies on the state of current_frame. We'd better update it, otherwise things like do_registers_info() wouldn't work properly! */ flush_cached_frames (); - set_current_frame (create_new_frame (sp-408, pc)); -#endif /* 0 */ + set_current_frame (create_new_frame (sp-DUMMY_FRAME_SIZE, pc)); /* save program counter in link register's space. */ write_memory (sp+8, &pc, 4); @@ -488,12 +325,17 @@ push_dummy_frame () for (ii=1; ii <=32; ++ii) write_memory (sp-256-(ii*4), ®isters[REGISTER_BYTE (32-ii)], 4); - /* so far, 32*2 + 32 words = 384 bytes have been written. We need 6 words - (24 bytes) for the rest of the registers. It brings the total to 408 - bytes. - save sp or so call back chain right here. */ - write_memory (sp-408, &sp, 4); - sp -= 408; + /* so far, 32*2 + 32 words = 384 bytes have been written. + 7 extra registers in our register set: pc, ps, cnd, lr, cnt, xer, mq */ + + for (ii=1; ii <= (LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii) { + write_memory (sp-384-(ii*4), + ®isters[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4); + } + + /* Save sp or so called back chain right here. */ + write_memory (sp-DUMMY_FRAME_SIZE, &sp, 4); + sp -= DUMMY_FRAME_SIZE; /* And finally, this is the back chain. */ write_memory (sp+8, &pc, 4); @@ -505,12 +347,13 @@ push_dummy_frame () In rs6000 when we push a dummy frame, we save all of the registers. This is usually done before user calls a function explicitly. - After a dummy frame is pushed, some instructions are copied into stack, and - stack pointer is decremented even more. Since we don't have a frame pointer to - get back to the parent frame of the dummy, we start having trouble poping it. - Therefore, we keep a dummy frame stack, keeping addresses of dummy frames as - such. When poping happens and when we detect that was a dummy frame, we pop - it back to its parent by using dummy frame stack (`dummy_frame_addr' array). + After a dummy frame is pushed, some instructions are copied into stack, + and stack pointer is decremented even more. Since we don't have a frame + pointer to get back to the parent frame of the dummy, we start having + trouble poping it. Therefore, we keep a dummy frame stack, keeping + addresses of dummy frames as such. When poping happens and when we + detect that was a dummy frame, we pop it back to its parent by using + dummy frame stack (`dummy_frame_addr' array). */ pop_dummy_frame () @@ -528,7 +371,13 @@ pop_dummy_frame () read_memory (sp-256-(ii*4), ®isters[REGISTER_BYTE (32-ii)], 4); } - read_memory (sp-400, ®isters [REGISTER_BYTE(PC_REGNUM)], 4); + /* restore the rest of the registers. */ + for (ii=1; ii <=(LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii) + read_memory (sp-384-(ii*4), + ®isters[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4); + + read_memory (sp-(DUMMY_FRAME_SIZE-8), + ®isters [REGISTER_BYTE(PC_REGNUM)], 4); /* when a dummy frame was being pushed, we had to decrement %sp first, in order to secure astack space. Thus, saved %sp (or %r1) value, is not the diff --git a/gdb/rs6000-xdep.c b/gdb/rs6000-xdep.c index 557ecb1..6a5543a 100644 --- a/gdb/rs6000-xdep.c +++ b/gdb/rs6000-xdep.c @@ -39,6 +39,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <sys/stat.h> #include <sys/core.h> #include <sys/ldr.h> +#include <sys/utsname.h> extern int errno; extern int attach_flag; @@ -60,6 +61,7 @@ static int special_regs[] = { extern int one_stepped; +void fetch_inferior_registers (regno) int regno; { @@ -196,30 +198,19 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr) frameless_function_invocation (fi) struct frame_info *fi; { - int ret; - CORE_ADDR func_start, after_prologue; + CORE_ADDR func_start; + int frameless, dummy; -#if 0 - func_start = (LOAD_ADDR (get_pc_function_start (fi->pc)) + - FUNCTION_START_OFFSET); -#else func_start = get_pc_function_start (fi->pc) + FUNCTION_START_OFFSET; -#endif - if (func_start) - { - after_prologue = func_start; - SKIP_PROLOGUE (after_prologue); - ret = (after_prologue == func_start); - } - else - /* If we can't find the start of the function, we don't really */ - /* know whether the function is frameless, but we should be */ - /* able to get a reasonable (i.e. best we can do under the */ - /* circumstances) backtrace by saying that it isn't. */ - ret = 0; - - return ret; + /* If we failed to find the start of the function, it is a mistake + to inspect the instructions. */ + + if (!func_start) + return 0; + + function_frame_info (func_start, &frameless, &dummy, &dummy, &dummy); + return frameless; } @@ -245,8 +236,10 @@ unsigned int pid; errno = 0; ptrace(PT_LDINFO, pid, ldi, MAX_LOAD_SEGS * sizeof(*ldi), ldi); - if (errno) + if (errno) { perror_with_name ("ptrace ldinfo"); + return 0; + } vmap_ldinfo(ldi); @@ -255,8 +248,10 @@ unsigned int pid; } while (ldi->ldinfo_next && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi))); +#if 0 /* Now that we've jumbled things around, re-sort them. */ sort_minimal_symbols (); +#endif /* relocate the exec and core sections as well. */ vmap_exec (); @@ -275,13 +270,13 @@ typedef struct { static LoadInfo *loadInfo = NULL; static int loadInfoLen = 0; static int loadInfoTocIndex = 0; -static int loadInfoTextIndex = 0; +int aix_loadInfoTextIndex = 0; xcoff_init_loadinfo () { loadInfoTocIndex = 0; - loadInfoTextIndex = 0; + aix_loadInfoTextIndex = 0; if (loadInfoLen == 0) { loadInfo = (void*) xmalloc (sizeof (LoadInfo) * LOADINFOLEN); @@ -297,7 +292,7 @@ free_loadinfo () loadInfo = NULL; loadInfoLen = 0; loadInfoTocIndex = 0; - loadInfoTextIndex = 0; + aix_loadInfoTextIndex = 0; } @@ -313,24 +308,26 @@ xcoff_add_toc_to_loadinfo (unsigned long tocaddr) add_text_to_loadinfo (unsigned long textaddr, unsigned long dataaddr) { - while (loadInfoTextIndex >= loadInfoLen) { + while (aix_loadInfoTextIndex >= loadInfoLen) { loadInfoLen += LOADINFOLEN; loadInfo = (void*) xrealloc (loadInfo, sizeof(LoadInfo) * loadInfoLen); } - loadInfo [loadInfoTextIndex].textorg = textaddr; - loadInfo [loadInfoTextIndex].dataorg = dataaddr; - ++loadInfoTextIndex; + loadInfo [aix_loadInfoTextIndex].textorg = textaddr; + loadInfo [aix_loadInfoTextIndex].dataorg = dataaddr; + ++aix_loadInfoTextIndex; } unsigned long find_toc_address (unsigned long pc) { - int ii, toc_entry; + int ii, toc_entry, tocbase = 0; - for (ii=0; ii < loadInfoTextIndex; ++ii) - if (pc > loadInfo [ii].textorg) + for (ii=0; ii < aix_loadInfoTextIndex; ++ii) + if (pc > loadInfo [ii].textorg && loadInfo [ii].textorg > tocbase) { toc_entry = ii; + tocbase = loadInfo [ii].textorg; + } return loadInfo [toc_entry].dataorg + loadInfo [toc_entry].toc_offset; } @@ -342,11 +339,14 @@ find_toc_address (unsigned long pc) exec_one_dummy_insn () { -#define DUMMY_INSN_ADDR 0x10000200 +#define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200 unsigned long shadow; unsigned int status, pid; + /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We assume that + this address will never be executed again by the real code. */ + target_insert_breakpoint (DUMMY_INSN_ADDR, &shadow); errno = 0; @@ -361,3 +361,24 @@ exec_one_dummy_insn () target_remove_breakpoint (DUMMY_INSN_ADDR, &shadow); } + +/* 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 */ + +int +aix_starting_inferior_traps () +{ + struct utsname unamebuf; + + if (uname (&unamebuf) == -1) + fatal ("uname(3) failed."); + + /* Assume the future versions will behave like 3.2 and return '3' for + anything other than 3.1x. The extra trap in 3.2 is the "trap after the + program is loaded" signal. */ + + if (unamebuf.version[0] == '3' && unamebuf.release[0] == '1') + return 2; + else + return 3; +} diff --git a/gdb/rs6k-opcode.h b/gdb/rs6k-opcode.h index ec2832a..7f616b5 100755 --- a/gdb/rs6k-opcode.h +++ b/gdb/rs6k-opcode.h @@ -1,13 +1,13 @@ /* IBM RS/6000 instruction set definitions, for GNU software. */ -struct rs6000_insn { +typedef struct rs6000_insn { char *operator; /* opcode name */ char *opr_ext; /* opcode name extension */ char *format; /* opcode format */ char p_opcode; /* primary opcode */ int e_opcode; /* extended opcode */ char oprnd_format[6]; /* operand format */ -}; +} OPCODE; /* operand format specifiers */ diff --git a/gdb/symtab.c b/gdb/symtab.c index 9d1bf3f..407a608 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -517,6 +517,17 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab) bv = BLOCKVECTOR (s); block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); sym = lookup_block_symbol (block, msymbol -> name, namespace); +#if 0 /* defined(IBM6000) */ + /* we kept static functions in misc_function_vector as well as + in static scope. We want to find them in the symbol table. */ + + if (!sym) { + block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); + sym = lookup_block_symbol (block, misc_function_vector[ind].name, + namespace); + } +#endif + /* sym == 0 if symbol was found in the minimal symbol table but not in the symtab. Return 0 to use the msymbol definition of "foo_". diff --git a/gdb/tm-rs6000.h b/gdb/tm-rs6000.h index 3b90fe3..07ec07b 100644 --- a/gdb/tm-rs6000.h +++ b/gdb/tm-rs6000.h @@ -18,14 +18,32 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* A successful ptrace(continue) might return errno != 0 in this particular port + of rs6000. I am not sure why. We will use this kludge and ignore it until + we figure out the real problem. */ + +#define AIX_BUGGY_PTRACE_CONTINUE \ +{ \ + int ret = ptrace (PT_CONTINUE, inferior_pid, (int *)1, signal, 0); \ + if (errno) { \ +/* printf ("ret: %d, errno: %d, signal: %d\n", ret, errno, signal); */ \ + errno = 0; } \ +} + extern int symtab_relocated; +/* Minimum possible text address in AIX */ + +#define TEXT_SEGMENT_BASE 0x10000000 + + /* text addresses in a core file does not necessarily match to symbol table, if symbol table relocation wasn't done yet. */ #define CORE_NEEDS_RELOCATION(PC) \ - if (!symtab_relocated && !inferior_pid && (PC) > 0x10000000) \ - (PC) -= (0x10000000 + text_adjustment (exec_bfd)); + if (!symtab_relocated && !inferior_pid && (PC) > TEXT_SEGMENT_BASE) \ + (PC) -= ( TEXT_SEGMENT_BASE + text_adjustment (exec_bfd)); /* Conversion between a register number in stab string to actual register num. */ @@ -89,14 +107,40 @@ struct fp_status { /* When a child process is just starting, we sneak in and relocate the symbol table (and other stuff) after the dynamic linker has - figured out where they go. */ + figured out where they go. But we want to do this relocation just + once. */ + +extern int aix_loadInfoTextIndex; + +#define SOLIB_CREATE_INFERIOR_HOOK() \ + do { \ + if (aix_loadInfoTextIndex == 0) \ + aixcoff_relocate_symtab (pid); \ + } while (0) + + +/* 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 SOLIB_CREATE_INFERIOR_HOOK(PID) aixcoff_relocate_symtab (PID) +#define START_INFERIOR_TRAPS_EXPECTED aix_starting_inferior_traps () +/* 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, + we postpone that, and then enter and sort(?) the whole line table at + once, when we are closing the current symbol table in end_symtab(). */ + +#define PROCESS_LINENUMBER_HOOK() aix_process_linenos () + + /* When a target process or core-file has been attached, we sneak in - and figure out where the shared libraries have got to. */ + and figure out where the shared libraries have got to. In case there + is no inferior_process exists (e.g. bringing up a core file), we can't + attemtp to relocate symbol table, since we don't have information about + load segments. */ -#define SOLIB_ADD(a, b, c) aixcoff_relocate_symtab (inferior_pid) +#define SOLIB_ADD(a, b, c) \ + if (inferior_pid) aixcoff_relocate_symtab (inferior_pid) /* Immediately after a function call, return the saved pc. Can't go through the frames for this because on some machines @@ -173,7 +217,7 @@ extern char registers[]; There should be NUM_REGS strings in this initializer. */ #define REGISTER_NAMES \ - {"r0", "sp", "toc", "r3", "r4", "r5", "r6", "r7", \ + {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ "r8", "r9", "r10","r11","r12","r13","r14","r15", \ "r16","r17","r18","r19","r20","r21","r22","r23", \ "r24","r25","r26","r27","r28","r29","r30","r31", \ @@ -194,6 +238,8 @@ extern char registers[]; #define SP_REGNUM 1 /* Contains address of top of stack */ #define TOC_REGNUM 2 /* TOC register */ #define FP0_REGNUM 32 /* Floating point register 0 */ +#define GP0_REGNUM 0 /* GPR register 0 */ +#define FP0_REGNUM 32 /* FPR (Floating point) register 0 */ #define FPLAST_REGNUM 63 /* Last floating point register */ /* Special purpose registers... */ @@ -307,7 +353,21 @@ extern unsigned int rs6000_struct_return_address; of type TYPE, given in virtual format. */ #define STORE_RETURN_VALUE(TYPE,VALBUF) \ - printf ("FIXMEmgo! STORE_RETURN_VALUE not implemented yet!\n") + { \ + if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ + \ + /* Floating point values are returned starting from FPR1 and up. \ + Say a double_double_double type could be returned in \ + FPR1/FPR2/FPR3 triple. */ \ + \ + write_register_bytes (REGISTER_BYTE (FP0_REGNUM+1), (VALBUF), \ + TYPE_LENGTH (TYPE)); \ + else \ + /* Everything else is returned in GPR3 and up. */ \ + write_register_bytes (REGISTER_BYTE (GP0_REGNUM+3), (VALBUF), \ + TYPE_LENGTH (TYPE)); \ + } + /* Extract from an array REGBUF containing the (raw) register state the address in which a function should return its structure value, @@ -318,7 +378,12 @@ extern unsigned int rs6000_struct_return_address; /* Do implement the attach and detach commands. */ -#define ATTACH_DETACH /* FIXMEmgo! Not implemented yet! */ +#define ATTACH_DETACH + +/* infptrace.c requires those. */ + +#define PTRACE_ATTACH 30 +#define PTRACE_DETACH 31 /* Describe the pointer in each stack frame to the previous stack frame @@ -453,3 +518,8 @@ extern unsigned int rs6000_struct_return_address; #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, using_gcc) \ fix_call_dummy(dummyname, pc, fun, nargs, type) + +/* Flag for machine-specific stuff in shared files. FIXME */ +#ifndef IBM6000 +#define IBM6000 +#endif diff --git a/gdb/xcoffexec.c b/gdb/xcoffexec.c index fa65151..7259b21 100644 --- a/gdb/xcoffexec.c +++ b/gdb/xcoffexec.c @@ -43,9 +43,6 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Prototypes for local functions */ static void -add_to_section_table PARAMS ((bfd *, sec_ptr, PTR)); - -static void file_command PARAMS ((char *, int)); static void @@ -59,6 +56,8 @@ struct section_table *exec_sections, *exec_sections_end; int write_files = 0; +extern int info_verbose; + bfd *exec_bfd; /* needed by core.c */ extern char *getenv(); @@ -66,6 +65,7 @@ extern void child_create_inferior (), child_attach (); extern void add_syms_addr_command (); extern void symbol_file_command (); static void exec_files_info(); +extern struct objfile *lookup_objfile_bfd (); /* * the vmap struct is used to describe the virtual address space of @@ -102,18 +102,29 @@ extern struct target_ops exec_ops; /* exec_close - done with exec file, clean up all resources. */ static void -exec_close(quitting) { - register struct vmap *vp, *nxt; - - for (nxt = vmap; vp = nxt; ) { - nxt = vp->nxt; - bfd_close(vp->bfd); - free_named_symtabs(vp->name, vp->member); /* XXX */ - free(vp); - } - - vmap = 0; - exec_bfd = 0; +exec_close(quitting) +{ + register struct vmap *vp, *nxt; + struct objfile *obj; + + for (nxt = vmap; vp = nxt; ) + { + nxt = vp->nxt; + + /* if there is an objfile associated with this bfd, + free_objfile() will do proper cleanup of objfile *and* bfd. */ + + if (obj = lookup_objfile_bfd (vp->bfd)) + free_objfile (obj); + else + bfd_close(vp->bfd); + + free_named_symtabs(vp->name); + free(vp); + } + + vmap = 0; + exec_bfd = 0; } /* @@ -327,7 +338,8 @@ relocate_minimal_symbol (objfile, msymbol, arg1, arg2, arg3) PTR arg2; PTR arg3; { - msymbol -> address += (int) arg1; + if (msymbol->address < TEXT_SEGMENT_BASE) + msymbol -> address += (int) arg1; } /* true, if symbol table and minimal symbol table are relocated. */ @@ -391,24 +403,18 @@ struct stat *vip; vmap_symtab_1(s, vp, old_start); } } - if (vp->tstart != old_start) + if (vp->tstart != old_start) { iterate_over_msymbols (relocate_minimal_symbol, (PTR) (vp->tstart - old_start), (PTR) NULL, (PTR) NULL); + + /* breakpoints need to be relocated as well. */ + fixup_breakpoints (0, TEXT_SEGMENT_BASE, vp->tstart - old_start); + } symtab_relocated = 1; } - -fixup_misc_vector (int disp) -{ - int ii; - for (ii=0; ii < misc_function_count; ++ii) - if (misc_function_vector[ii].address < 0x10000000) - misc_function_vector[ii].address += disp; -} - - vmap_symtab_1(s, vp, old_start) register struct symtab *s; register struct vmap *vp; @@ -429,12 +435,14 @@ CORE_ADDR old_start; /* * The line table must be relocated. This is only present for - * b.text sections, so only vp->text type maps need be considered. + * .text sections, so only vp->text type maps need be considered. */ l = LINETABLE (s); - len = l->nitems; - for (i = 0; i < len; i++) + if (l) { + len = l->nitems; + for (i = 0; i < len; i++) l->item[i].pc += reloc; + } /* if this symbol table is not relocatable, only line table should be relocated and the rest ignored. */ @@ -693,7 +701,6 @@ retry: } while (ldi->ldinfo_next && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi))); - breakpoint_re_set(); } /* @@ -728,18 +735,17 @@ vmap_inferior() { we just tail-call it with more arguments to select between them. */ int -xfer_memory (memaddr, myaddr, len, write, abfd, sections, sections_end) +xfer_memory (memaddr, myaddr, len, write, target) CORE_ADDR memaddr; char *myaddr; int len; int write; - bfd *abfd; - struct section_table *sections, *sections_end; + struct target_ops *target; { boolean res; struct section_table *p; CORE_ADDR nextsectaddr, memend; - boolean (*xfer_fn) (); + boolean (*xfer_fn) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type)); if (len <= 0) abort(); @@ -748,13 +754,13 @@ xfer_memory (memaddr, myaddr, len, write, abfd, sections, sections_end) xfer_fn = write? bfd_set_section_contents: bfd_get_section_contents; nextsectaddr = memend; - for (p = sections; p < sections_end; p++) + for (p = target->to_sections; p < target->to_sections_end; p++) { if (p->addr <= memaddr) if (p->endaddr >= memend) { /* Entire transfer is within this section. */ - res = xfer_fn (abfd, p->sec_ptr, myaddr, memaddr - p->addr, len); + res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len); return (res != false)? len: 0; } else if (p->endaddr <= memaddr) @@ -766,7 +772,7 @@ xfer_memory (memaddr, myaddr, len, write, abfd, sections, sections_end) { /* This section overlaps the transfer. Just do half. */ len = p->endaddr - memaddr; - res = xfer_fn (abfd, p->sec_ptr, myaddr, memaddr - p->addr, len); + res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len); return (res != false)? len: 0; } else if (p->addr < nextsectaddr) @@ -779,24 +785,31 @@ xfer_memory (memaddr, myaddr, len, write, abfd, sections, sections_end) return - (nextsectaddr - memaddr); /* Next boundary where we can help */ } -/* The function called by target_xfer_memory via our target_ops */ - -int -exec_xfer_memory (memaddr, myaddr, len, write) - CORE_ADDR memaddr; - char *myaddr; - int len; - int write; +void +print_section_info (t, abfd) + struct target_ops *t; + bfd *abfd; { - return xfer_memory (memaddr, myaddr, len, write, - exec_bfd, exec_sections, exec_sections_end); -} +#if 1 + struct section_table *p; -/* - * exec_files_info - "info files" command processor - */ -static void -exec_files_info() { + printf_filtered ("\t`%s', ", bfd_get_filename(abfd)); + wrap_here (" "); + printf_filtered ("file type %s.\n", bfd_get_target(abfd)); + + for (p = t->to_sections; p < t->to_sections_end; p++) { + printf_filtered ("\t%s", local_hex_string_custom (p->addr, "08")); + printf_filtered (" - %s", local_hex_string_custom (p->endaddr, "08")); + if (info_verbose) + printf_filtered (" @ %s", + local_hex_string_custom (p->sec_ptr->filepos, "08")); + printf_filtered (" is %s", bfd_section_name (p->bfd, p->sec_ptr)); + if (p->bfd != abfd) { + printf_filtered (" in %s", bfd_get_filename (p->bfd)); + } + printf_filtered ("\n"); + } +#else register struct vmap *vp = vmap; if (!vp) @@ -814,6 +827,14 @@ exec_files_info() { , *vp->member ? "(" : "" , vp->member , *vp->member ? ")" : ""); +#endif +} + +static void +exec_files_info (t) + struct target_ops *t; +{ + print_section_info (t, exec_bfd); } #ifdef DAMON @@ -914,7 +935,7 @@ Specify the filename of the executable file.", child_attach, 0, 0, 0, /* attach, detach, resume, wait, */ 0, 0, /* fetch_registers, store_registers, */ 0, 0, 0, /* prepare_to_store, conv_to, conv_from, */ - exec_xfer_memory, exec_files_info, + xfer_memory, exec_files_info, 0, 0, /* insert_breakpoint, remove_breakpoint, */ 0, 0, 0, 0, 0, /* terminal stuff */ 0, 0, /* kill, load */ diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c index 13c0e17..4d66f51 100644 --- a/gdb/xcoffread.c +++ b/gdb/xcoffread.c @@ -23,6 +23,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "defs.h" #include "bfd.h" +#ifdef IBM6000 +/* Native only: Need struct tbtable in <sys/debug.h>. */ + /* AIX COFF names have a preceeding dot `.' */ #define NAMES_HAVE_DOT 1 @@ -36,6 +39,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <sys/file.h> #endif #include <sys/stat.h> +/*#include <linenum.h>*/ +#include <sys/debug.h> #include "symtab.h" #include "gdbtypes.h" @@ -73,7 +78,7 @@ static bfd *symfile_bfd; This is calculated from the first function seen after a C_FILE symbol. */ -static CORE_ADDR cur_src_start_addr; + static CORE_ADDR cur_src_end_addr; /* Core address of the end of the first object file. */ @@ -97,7 +102,7 @@ static char *symtbl; #define INITIAL_STABVECTOR_LENGTH 40 struct pending_stabs *global_stabs; -struct pending_stabs *file_stabs; + /* Nonzero if within a function (so symbols should be local, if nothing says specifically). */ @@ -125,6 +130,7 @@ static unsigned local_n_tmask; static unsigned local_symesz; + /* coff_symfile_init() is the coff-specific initialization routine for reading symbols. It is passed a struct sym_fns which contains, among other things, @@ -145,8 +151,8 @@ struct coff_symfile_info { static void -enter_line_range PARAMS ((struct subfile *, unsigned, unsigned, CORE_ADDR, - unsigned *)); +enter_line_range PARAMS ((struct subfile *, unsigned, unsigned, + CORE_ADDR, CORE_ADDR, unsigned *)); static void aixcoff_symfile_read PARAMS ((struct sym_fns *, CORE_ADDR, int)); @@ -185,10 +191,6 @@ static void read_xcoff_symtab PARAMS ((struct objfile *, int)); static void -enter_line_range PARAMS ((struct subfile *, unsigned, unsigned, CORE_ADDR, - unsigned *)); - -static void add_stab_to_list PARAMS ((char *, struct pending_stabs **)); static void @@ -273,22 +275,412 @@ struct pending_stabs **stabvector; } +#if 0 +/* for all the stabs in a given stab vector, build appropriate types + and fix their symbols in given symbol vector. */ + +void +patch_block_stabs (symbols, stabs) +struct pending *symbols; +struct pending_stabs *stabs; +{ + int ii; + + if (!stabs) + return; + + /* for all the stab entries, find their corresponding symbols and + patch their types! */ + + for (ii=0; ii < stabs->count; ++ii) { + char *name = stabs->stab[ii]; + char *pp = (char*) index (name, ':'); + struct symbol *sym = find_symbol_in_list (symbols, name, pp-name); + if (!sym) { + ; + /* printf ("ERROR! stab symbol not found!\n"); /* FIXME */ + /* The above is a false alarm. There are cases the we can have + a stab, without its symbol. xlc generates this for the extern + definitions in inner blocks. */ + } + else { + pp += 2; + + if (*(pp-1) == 'F' || *(pp-1) == 'f') + SYMBOL_TYPE (sym) = lookup_function_type (read_type (&pp)); + else + SYMBOL_TYPE (sym) = read_type (&pp, objfile); + } + } +} +#endif + + +/* compare line table entry addresses. */ + + static int +compare_lte (lte1, lte2) + struct linetable_entry *lte1, *lte2; +{ + return lte1->pc - lte2->pc; +} + +/* Give a line table with function entries are marked, arrange its functions + in assending order and strip off function entry markers and return it in + a newly created table. If the old one is good enough, return the old one. */ + +static struct linetable * +arrange_linetable (oldLineTb) + struct linetable *oldLineTb; /* old linetable */ +{ + int ii, jj, + newline, /* new line count */ + function_count; /* # of functions */ + + struct linetable_entry *fentry; /* function entry vector */ + int fentry_size; /* # of function entries */ + struct linetable *newLineTb; /* new line table */ + +#define NUM_OF_FUNCTIONS 20 + + fentry_size = NUM_OF_FUNCTIONS; + fentry = (struct linetable_entry*) + malloc (fentry_size * sizeof (struct linetable_entry)); + + for (function_count=0, ii=0; ii <oldLineTb->nitems; ++ii) { + + if (oldLineTb->item[ii].line == 0) { /* function entry found. */ + + if (function_count >= fentry_size) { /* make sure you have room. */ + fentry_size *= 2; + fentry = (struct linetable_entry*) + realloc (fentry, fentry_size * sizeof (struct linetable_entry)); + } + fentry[function_count].line = ii; + fentry[function_count].pc = oldLineTb->item[ii].pc; + ++function_count; + } + } + + if (function_count == 0) { + free (fentry); + return oldLineTb; + } + else if (function_count > 1) + qsort (fentry, function_count, sizeof(struct linetable_entry), compare_lte); + + /* allocate a new line table. */ + newLineTb = (struct linetable*) malloc (sizeof (struct linetable) + + (oldLineTb->nitems - function_count) * sizeof (struct linetable_entry)); + + /* if line table does not start with a function beginning, copy up until + a function begin. */ + + newline = 0; + if (oldLineTb->item[0].line != 0) + for (newline=0; + newline < oldLineTb->nitems && oldLineTb->item[newline].line; ++newline) + newLineTb->item[newline] = oldLineTb->item[newline]; + + /* Now copy function lines one by one. */ + + for (ii=0; ii < function_count; ++ii) { + for (jj = fentry[ii].line + 1; + jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0; + ++jj, ++newline) + newLineTb->item[newline] = oldLineTb->item[jj]; + } + free (fentry); + newLineTb->nitems = oldLineTb->nitems - function_count; + return newLineTb; +} + + + +/* We try to detect the beginning of a compilation unit. That info will + be used as an entry in line number recording routines (enter_line_range) */ + +static unsigned first_fun_line_offset; +static unsigned first_fun_bf; + +#define mark_first_line(OFFSET, SYMNUM) \ + if (!first_fun_line_offset) { \ + first_fun_line_offset = OFFSET; \ + first_fun_bf = SYMNUM; \ + } + + +/* include file support: C_BINCL/C_EINCL pairs will be kept in the + following `IncludeChain'. At the end of each symtab (end_symtab), + we will determine if we should create additional symtab's to + represent if (the include files. */ + + +typedef struct _inclTable { + char *name; /* include filename */ + int begin, end; /* offsets to the line table */ + struct subfile *subfile; + unsigned funStartLine; /* start line # of its function */ +} InclTable; + +#define INITIAL_INCLUDE_TABLE_LENGTH 20 +static InclTable *inclTable; /* global include table */ +static int inclIndx; /* last entry to table */ +static int inclLength; /* table length */ +static int inclDepth; /* nested include depth */ + + +static void +record_include_begin (cs) +struct coff_symbol *cs; +{ + /* In aixcoff, we assume include files cannot be nested (not in .c file + of course, but in corresponding .s files.) */ + + if (inclDepth) + fatal ("aix internal: pending include file exists."); + + ++inclDepth; + + /* allocate an include file, or make room for the new entry */ + if (inclLength == 0) { + inclTable = (InclTable*) + xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH); + bzero (inclTable, sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH); + inclLength = INITIAL_INCLUDE_TABLE_LENGTH; + inclIndx = 0; + } + else if (inclIndx >= inclLength) { + inclLength += INITIAL_INCLUDE_TABLE_LENGTH; + inclTable = (InclTable*) + xrealloc (inclTable, sizeof (InclTable) * inclLength); + bzero (inclTable+inclLength-INITIAL_INCLUDE_TABLE_LENGTH, + sizeof (InclTable)*INITIAL_INCLUDE_TABLE_LENGTH); + } + + inclTable [inclIndx].name = cs->c_name; + inclTable [inclIndx].begin = cs->c_value; +} + + +static void +record_include_end (cs) +struct coff_symbol *cs; +{ + InclTable *pTbl; + + if (inclDepth == 0) + fatal ("aix internal: Mismatch C_BINCL/C_EINCL pair found."); + + pTbl = &inclTable [inclIndx]; + pTbl->end = cs->c_value; + + --inclDepth; + ++inclIndx; +} + + +static void +dumpIncludeChain () +{ + int ii; + if (inclTable && inclLength) + for (ii=0; ii < inclIndx; ++ii) + printf ("name: %s, begin: 0x%x, end: 0x%x\n", + inclTable[ii].name, inclTable[ii].begin, inclTable[ii].end); +} + + +/* given the start and end addresses of a compilation unit (or a csect, at times) + process its lines and create appropriate line vectors. */ + +static void +process_linenos (start, end) + CORE_ADDR start, end; +{ + char *pp; + int offset, ii; + + struct subfile main_subfile; /* subfile structure for the main + compilation unit. */ + + /* in the main source file, any time we see a function entry, we reset + this variable to function's absolute starting line number. All the + following line numbers in the function are relative to this, and + we record absolute line numbers in record_line(). */ + + int main_source_baseline = 0; + + + unsigned *firstLine; + CORE_ADDR addr; + + if (!(offset = first_fun_line_offset)) + goto return_after_cleanup; + + bzero (&main_subfile, sizeof (main_subfile)); + first_fun_line_offset = 0; + + if (inclIndx == 0) + enter_line_range (&main_subfile, offset, 0, start, end, + &main_source_baseline); + + /* else, there was source with line numbers in include files */ + else { + + main_source_baseline = 0; + for (ii=0; ii < inclIndx; ++ii) { + + struct subfile *tmpSubfile; + + /* if there is main file source before include file, enter it. */ + if (offset < inclTable[ii].begin) { + enter_line_range + (&main_subfile, offset, inclTable[ii].begin - LINESZ, start, 0, + &main_source_baseline); + } + + /* Have a new subfile for the include file */ + + tmpSubfile = inclTable[ii].subfile = (struct subfile*) + xmalloc (sizeof (struct subfile)); + + bzero (tmpSubfile, sizeof (struct subfile)); + firstLine = &(inclTable[ii].funStartLine); + + /* enter include file's lines now. */ + enter_line_range (tmpSubfile, inclTable[ii].begin, + inclTable[ii].end, start, 0, firstLine); + + offset = inclTable[ii].end + LINESZ; + } + + /* all the include files' line have been processed at this point. Now, + enter remaining lines of the main file, if any left. */ + if (offset < (linetab_offset + linetab_size + 1 - LINESZ)) { + enter_line_range (&main_subfile, offset, 0, start, end, + &main_source_baseline); + } + } + + /* Process main file's line numbers. */ + if (main_subfile.line_vector) { + struct linetable *lineTb, *lv; + + lv = main_subfile.line_vector; + + /* Line numbers are not necessarily ordered. xlc compilation will + put static function to the end. */ + + lineTb = arrange_linetable (lv); + if (lv == lineTb) { + current_subfile->line_vector = (struct linetable *) + xrealloc (lv, (sizeof (struct linetable) + + lv->nitems * sizeof (struct linetable_entry))); + + } + else { + free (lv); + current_subfile->line_vector = lineTb; + } + + current_subfile->line_vector_length = + current_subfile->line_vector->nitems; + + + /* Now, process included files' line numbers. */ + + for (ii=0; ii < inclIndx; ++ii) { + + if ( (inclTable[ii].subfile)->line_vector) { /* Useless if!!! FIXMEmgo */ + struct linetable *lineTb, *lv; + + lv = (inclTable[ii].subfile)->line_vector; + + /* Line numbers are not necessarily ordered. xlc compilation will + put static function to the end. */ + + lineTb = arrange_linetable (lv); + + push_subfile (); + + /* For the same include file, we might want to have more than one subfile. + This happens if we have something like: + + ...... + #include "foo.h" + ...... + #include "foo.h" + ...... + + while foo.h including code in it. (stupid but possible) + Since start_subfile() looks at the name and uses an existing one if finds, + we need to provide a fake name and fool it. */ + +/* start_subfile (inclTable[ii].name, (char*)0); */ + start_subfile (" ?", (char*)0); + current_subfile->name = + obsavestring (inclTable[ii].name, strlen (inclTable[ii].name), + ¤t_objfile->symbol_obstack); + + if (lv == lineTb) { + current_subfile->line_vector = (struct linetable *) + xrealloc (lv, (sizeof (struct linetable) + + lv->nitems * sizeof (struct linetable_entry))); + + } + else { + free (lv); + current_subfile->line_vector = lineTb; + } + + current_subfile->line_vector_length = + current_subfile->line_vector->nitems; + start_subfile (pop_subfile (), (char*)0); + } + } + } + else + /* I am not sure this logic is correct. There might be no lines in the + main file, whereas there are some in included ones. FIXMEibm */ + current_subfile->line_vector = NULL; + +return_after_cleanup: + + /* We don't want to keep alloc/free'ing the global include file table. */ + inclIndx = 0; + + /* start with a fresh subfile structure for the next file. */ + bzero (&main_subfile, sizeof (struct subfile)); +} + +void +aix_process_linenos () +{ + /* process line numbers and enter them into line vector */ + process_linenos (last_source_start_addr, cur_src_end_addr); +} + + /* Enter a given range of lines into the line vector. can be called in the following two ways: - enter_line_range (subfile, beginoffset, endoffset, 0, firstLine) or - enter_line_range (subfile, beginoffset, 0, endaddr, firstLine) */ + enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or + enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine) */ static void -enter_line_range (subfile, beginoffset, endoffset, endaddr, firstLine) - struct subfile *subfile; /* which sub-file to put line#s in */ +enter_line_range (subfile, beginoffset, endoffset, startaddr, endaddr, firstLine) + struct subfile *subfile; unsigned beginoffset, endoffset; /* offsets to line table */ - CORE_ADDR endaddr; + CORE_ADDR startaddr, endaddr; unsigned *firstLine; { char *pp, *limit; CORE_ADDR addr; - struct internal_lineno lptr; - unsigned local_linesz = coff_data (symfile_bfd)->local_linesz; + +/* Do Byte swapping, if needed. FIXME! */ +#define P_LINENO(PP) (*(unsigned short*)((struct external_lineno*)(PP))->l_lnno) +#define P_LINEADDR(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_paddr) +#define P_LINESYM(PP) (*(long*)((struct external_lineno*)(PP))->l_addr.l_symndx) pp = &linetab [beginoffset - linetab_offset]; limit = endoffset ? &linetab [endoffset - linetab_offset] @@ -296,26 +688,230 @@ enter_line_range (subfile, beginoffset, endoffset, endaddr, firstLine) while (pp <= limit) { - /* Swap and align this lineno entry into lptr. */ - bfd_coff_swap_lineno_in (symfile_bfd, pp, &lptr); - /* find the address this line represents */ - addr = lptr.l_lnno ? - lptr.l_addr.l_paddr : read_symbol_nvalue (symtbl, lptr.l_addr.l_symndx); + addr = P_LINENO(pp) ? + P_LINEADDR(pp) : read_symbol_nvalue (symtbl, P_LINESYM(pp)); - if (endaddr && addr >= endaddr) + if (addr < startaddr || (endaddr && addr > endaddr)) return; - if (lptr.l_lnno == 0) { - *firstLine = read_symbol_lineno (symtbl, lptr.l_addr.l_symndx); + if (P_LINENO(pp) == 0) { + *firstLine = read_symbol_lineno (symtbl, P_LINESYM(pp)); + record_line (subfile, 0, addr); --(*firstLine); } else - record_line (subfile, *firstLine + lptr.l_lnno, addr); + record_line (subfile, *firstLine + P_LINENO(pp), addr); + + pp += LINESZ; + } +} + +typedef struct { + int fsize; /* file size */ + int fixedparms; /* number of fixed parms */ + int floatparms; /* number of float parms */ + unsigned int parminfo; /* parameter info. + See /usr/include/sys/debug.h + tbtable_ext.parminfo */ + int framesize; /* function frame size */ +} TracebackInfo; + + +/* Given a function symbol, return its traceback information. */ + + TracebackInfo * +retrieve_tracebackinfo (abfd, textsec, cs) + bfd *abfd; + sec_ptr textsec; + struct coff_symbol *cs; +{ +#define TBTABLE_BUFSIZ 2000 +#define MIN_TBTABSIZ 50 /* minimum buffer size to hold a + traceback table. */ + + static TracebackInfo tbInfo; + struct tbtable *ptb; + + static char buffer [TBTABLE_BUFSIZ]; + + int *pinsn; + int bytesread=0; /* total # of bytes read so far */ + int bufferbytes; /* number of bytes in the buffer */ + + int functionstart = cs->c_value - textsec->vma; + + bzero (&tbInfo, sizeof (tbInfo)); + + /* keep reading blocks of data from the text section, until finding a zero + word and a traceback table. */ + + while (bfd_get_section_contents (abfd, textsec, buffer, + (file_ptr)(functionstart + bytesread), + bufferbytes = ( + (TBTABLE_BUFSIZ < (textsec->_raw_size - functionstart - bytesread)) ? + TBTABLE_BUFSIZ : (textsec->_raw_size - functionstart - bytesread)))) + { + bytesread += bufferbytes; + pinsn = (int*) buffer; + + /* if this is the first time we filled the buffer, retrieve function + framesize info. */ + + if (bytesread == bufferbytes) { + + /* skip over unrelated instructions */ + + if (*pinsn == 0x7c0802a6) /* mflr r0 */ + ++pinsn; + if ((*pinsn & 0xfc00003e) == 0x7c000026) /* mfcr Rx */ + ++pinsn; + if ((*pinsn & 0xfc000000) == 0x48000000) /* bl foo, save fprs */ + ++pinsn; + if ((*pinsn & 0xfc1f0000) == 0xbc010000) /* stm Rx, NUM(r1) */ + ++pinsn; + + do { + int tmp = (*pinsn >> 16) & 0xffff; + + if (tmp == 0x9421) { /* stu r1, NUM(r1) */ + tbInfo.framesize = 0x10000 - (*pinsn & 0xffff); + break; + } + else if ((*pinsn == 0x93e1fffc) || /* st r31,-4(r1) */ + (tmp == 0x9001)) /* st r0, NUM(r1) */ + ; + /* else, could not find a frame size. */ + else + return NULL; + + } while (++pinsn && *pinsn); + + if (!tbInfo.framesize) + return NULL; + } + + /* look for a zero word. */ + + while (*pinsn && (pinsn < (int*)(buffer + bufferbytes - sizeof(int)))) + ++pinsn; + + if (pinsn >= (int*)(buffer + bufferbytes)) + continue; - pp += local_linesz; + if (*pinsn == 0) { + + /* function size is the amount of bytes we have skipped so far. */ + tbInfo.fsize = bytesread - (buffer + bufferbytes - (char*)pinsn); + + ++pinsn; + + /* if we don't have the whole traceback table in the buffer, re-read + the whole thing. */ + + if ((char*)pinsn > (buffer + bufferbytes - MIN_TBTABSIZ)) { + + /* In case if we are *very* close to the end of the text section + and cannot read properly from that point on, abort by returning + NULL. + Handle this case more graciously -- FIXME */ + + if (!bfd_get_section_contents ( + abfd, textsec, buffer, + (file_ptr)(functionstart + + bytesread - (buffer + bufferbytes - (char*)pinsn)),MIN_TBTABSIZ)) + { printf ("Abnormal return!..\n"); return NULL; } + + ptb = (struct tbtable *)buffer; + } + else + ptb = (struct tbtable *)pinsn; + + tbInfo.fixedparms = ptb->tb.fixedparms; + tbInfo.floatparms = ptb->tb.floatparms; + tbInfo.parminfo = ptb->tb_ext.parminfo; + return &tbInfo; + } + } + return NULL; +} + +#if 0 +/* Given a function symbol, return a pointer to its traceback table. */ + + struct tbtable * +retrieve_traceback (abfd, textsec, cs, size) + bfd *abfd; + sec_ptr textsec; + struct coff_symbol *cs; + int *size; /* return function size */ +{ +#define TBTABLE_BUFSIZ 2000 +#define MIN_TBTABSIZ 50 /* minimum buffer size to hold a + traceback table. */ + + static char buffer [TBTABLE_BUFSIZ]; + + int *pinsn; + int bytesread=0; /* total # of bytes read so far */ + int bufferbytes; /* number of bytes in the buffer */ + + int functionstart = cs->c_value - textsec->filepos + textsec->vma; + *size = 0; + + /* keep reading blocks of data from the text section, until finding a zero + word and a traceback table. */ + + while (bfd_get_section_contents (abfd, textsec, buffer, + (file_ptr)(functionstart + bytesread), + bufferbytes = ( + (TBTABLE_BUFSIZ < (textsec->size - functionstart - bytesread)) ? + TBTABLE_BUFSIZ : (textsec->size - functionstart - bytesread)))) + { + bytesread += bufferbytes; + pinsn = (int*) buffer; + + /* look for a zero word. */ + + while (*pinsn && (pinsn < (int*)(buffer + bufferbytes - sizeof(int)))) + ++pinsn; + + if (pinsn >= (int*)(buffer + bufferbytes)) + continue; + + if (*pinsn == 0) { + + /* function size is the amount of bytes we have skipped so far. */ + *size = bytesread - (buffer + bufferbytes - pinsn); + + ++pinsn; + + /* if we don't have the whole traceback table in the buffer, re-read + the whole thing. */ + + if ((char*)pinsn > (buffer + bufferbytes - MIN_TBTABSIZ)) { + + /* In case if we are *very* close to the end of the text section + and cannot read properly from that point on, abort for now. + Handle this case more graciously -- FIXME */ + + if (!bfd_get_section_contents ( + abfd, textsec, buffer, + (file_ptr)(functionstart + + bytesread - (buffer + bufferbytes - pinsn)),MIN_TBTABSIZ)) + /* abort (); */ { printf ("abort!!!\n"); return NULL; } + + return (struct tbtable *)buffer; + } + else + return (struct tbtable *)pinsn; + } } + return NULL; } +#endif /* 0 */ + + /* Save the vital information for use when closing off the current file. @@ -324,7 +920,7 @@ enter_line_range (subfile, beginoffset, endoffset, endaddr, firstLine) #define complete_symtab(name, start_addr) { \ last_source_file = savestring (name, strlen (name)); \ - cur_src_start_addr = start_addr; \ + last_source_start_addr = start_addr; \ } @@ -347,10 +943,33 @@ enter_line_range (subfile, beginoffset, endoffset, endaddr, firstLine) (ALLOCED) = 1; \ } \ prim_record_minimal_symbol (namestr, (ADDR), (TYPE)); \ - last_recorded_fun = (ADDR); \ + misc_func_recorded = 1; \ } +/* A parameter template, used by ADD_PARM_TO_PENDING. */ + +static struct symbol parmsym = { /* default parameter symbol */ + "", /* name */ + VAR_NAMESPACE, /* namespace */ + LOC_ARG, /* class */ + NULL, /* type */ + 0, /* line number */ + 0, /* value */ +}; + +/* Add a parameter to a given pending symbol list. */ + +#define ADD_PARM_TO_PENDING(PARM, VALUE, PTYPE, PENDING_SYMBOLS) \ +{ \ + PARM = (struct symbol *) \ + obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \ + *(PARM) = parmsym; \ + SYMBOL_TYPE (PARM) = PTYPE; \ + SYMBOL_VALUE (PARM) = VALUE; \ + add_symbol_to_list (PARM, &PENDING_SYMBOLS); \ +} + /* aixcoff has static blocks marked in `.bs', `.es' pairs. They cannot be nested. At any given time, a symbol can only be in one static block. @@ -370,9 +989,11 @@ read_xcoff_symtab (objfile, nsyms) int nsyms; /* # of symbols */ { bfd *abfd = objfile->obfd; - /* char *symtbl; */ /* Raw symbol table base */ char *raw_symbol; /* Pointer into raw seething symbol table */ char *raw_auxptr; /* Pointer to first raw aux entry for sym */ + sec_ptr textsec; /* Pointer to text section */ + TracebackInfo *ptb; /* Pointer to traceback table */ + struct internal_syment symbol[1]; union internal_auxent main_aux[1]; struct coff_symbol cs[1]; @@ -383,7 +1004,6 @@ read_xcoff_symtab (objfile, nsyms) int just_started = 1; int depth = 0; int val; - int fcn_first_line; int fcn_last_line; int fcn_start_addr; long fcn_line_offset; @@ -391,11 +1011,14 @@ read_xcoff_symtab (objfile, nsyms) /* fcn_cs_saved is global because process_xcoff_symbol needs it. */ union internal_auxent fcn_aux_saved; + struct type *fcn_type_saved = NULL; struct context_stack *new; char *filestring = " _start_ "; /* Name of the current file. */ - char *last_seen_csect; - int last_recorded_fun = 0; /* last recorded fun. value */ + + char *last_csect_name; /* last seen csect's name and value */ + CORE_ADDR last_csect_val; + int misc_func_recorded; /* true if any misc. function */ current_objfile = objfile; @@ -405,8 +1028,9 @@ read_xcoff_symtab (objfile, nsyms) local_symesz = coff_data (abfd)->local_symesz; last_source_file = 0; - last_seen_csect = 0; - last_recorded_fun = 0; + last_csect_name = 0; + last_csect_val = 0; + misc_func_recorded = 0; start_symtab (filestring, (char *)NULL, file_start_addr); symnum = 0; @@ -425,6 +1049,11 @@ read_xcoff_symtab (objfile, nsyms) raw_symbol = symtbl; + textsec = bfd_get_section_by_name (abfd, ".text"); + if (!textsec) { + printf ("Unable to locate text section!\n"); + } + while (symnum < nsyms) { QUIT; /* make this command interruptable. */ @@ -478,7 +1107,7 @@ read_xcoff_symtab (objfile, nsyms) if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE) { if (last_source_file) - end_symtab (cur_src_end_addr, 1, 1, objfile); + end_symtab (cur_src_end_addr, 1, 0, objfile); start_symtab ("_globals_", (char *)NULL, (CORE_ADDR)0); cur_src_end_addr = first_object_file_end; @@ -527,10 +1156,22 @@ read_xcoff_symtab (objfile, nsyms) CU might get fragmented in the memory and gdb's file start and end address approach does not work! */ - if (last_seen_csect) { + if (last_csect_name) { + + /* if no misc. function recorded in the last seen csect, enter + it as a function. This will take care of functions like + strcmp() compiled by xlc. */ + + if (!misc_func_recorded) { + int alloced = 0; + RECORD_MINIMAL_SYMBOL (last_csect_name, last_csect_val, + mst_text, alloced); + } + + complete_symtab (filestring, file_start_addr); cur_src_end_addr = file_end_addr; - end_symtab (file_end_addr, 1, 1, objfile); + end_symtab (file_end_addr, 1, 0, objfile); start_symtab ((char *)NULL, (char *)NULL, (CORE_ADDR)0); } @@ -544,10 +1185,11 @@ read_xcoff_symtab (objfile, nsyms) file_end_addr = cs->c_value + CSECT_LEN (main_aux); if (cs->c_name && cs->c_name[0] == '.') { - last_seen_csect = cs->c_name; - RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text, symname_alloced); + last_csect_name = cs->c_name; + last_csect_val = cs->c_value; } } + misc_func_recorded = 0; continue; case XMC_RW : @@ -575,9 +1217,8 @@ read_xcoff_symtab (objfile, nsyms) if (CSECT_SCLAS (main_aux) == XMC_PR) { function_entry_point: - if (cs->c_value != last_recorded_fun) - RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text, - symname_alloced); + RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text, + symname_alloced); fcn_line_offset = main_aux->x_sym.x_fcnary.x_fcn.x_lnnoptr; fcn_start_addr = cs->c_value; @@ -586,27 +1227,91 @@ function_entry_point: when `.bf' is seen. */ fcn_cs_saved = *cs; fcn_aux_saved = *main_aux; + + + ptb = NULL; + + /* If function has two auxent, then debugging information is + already available for it. Process traceback table for + functions with only one auxent. */ + + if (cs->c_nsyms == 1) + ptb = retrieve_tracebackinfo (abfd, textsec, cs); + + else if (cs->c_nsyms != 2) + abort (); + + /* If there is traceback info, create and add parameters for it. */ + + if (ptb && (ptb->fixedparms || ptb->floatparms)) { + + int parmcnt = ptb->fixedparms + ptb->floatparms; + char *parmcode = (char*) &ptb->parminfo; + int parmvalue = ptb->framesize + 0x18; /* sizeof(LINK AREA) == 0x18 */ + unsigned int ii, mask; + + for (ii=0, mask = 0x80000000; ii <parmcnt; ++ii) { + struct symbol *parm; + + if (ptb->parminfo & mask) { /* float or double */ + mask = mask >> 1; + if (ptb->parminfo & mask) { /* double parm */ + ADD_PARM_TO_PENDING + (parm, parmvalue, builtin_type_double, local_symbols); + parmvalue += sizeof (double); + } + else { /* float parm */ + ADD_PARM_TO_PENDING + (parm, parmvalue, builtin_type_float, local_symbols); + parmvalue += sizeof (float); + } + } + else { /* fixed parm */ + ADD_PARM_TO_PENDING + (parm, parmvalue, builtin_type_int, local_symbols); + parmvalue += sizeof (int); + } + mask = mask >> 1; + } + + /* Fake this as a function. Needed in process_xcoff_symbol() */ + cs->c_type = 32; + + finish_block(process_xcoff_symbol (cs, objfile), &local_symbols, + pending_blocks, cs->c_value, + cs->c_value + ptb->fsize, objfile); + } continue; } - - /* shared library function entry point. */ + /* shared library function trampoline code entry point. */ else if (CSECT_SCLAS (main_aux) == XMC_GL) { - if (last_recorded_fun != cs->c_value) - RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text, - symname_alloced); + RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text, + symname_alloced); continue; } break; default : /* all other XTY_XXXs */ break; - } /* switch CSECT_SMTYP() */ - } + } /* switch CSECT_SMTYP() */ } switch (cs->c_sclass) { case C_FILE: + /* see if the last csect needs to be recorded. */ + + if (last_csect_name && !misc_func_recorded) { + + /* if no misc. function recorded in the last seen csect, enter + it as a function. This will take care of functions like + strcmp() compiled by xlc. */ + + int alloced = 0; + RECORD_MINIMAL_SYMBOL (last_csect_name, last_csect_val, + mst_text, alloced); + } + /* c_value field contains symnum of next .file entry in table or symnum of first global after last .file. */ @@ -618,11 +1323,12 @@ function_entry_point: /* Whether or not there was a csect in the previous file, we have to call `end_symtab' and `start_symtab' to reset type_vector, line_vector, etc. structures. */ + complete_symtab (filestring, file_start_addr); cur_src_end_addr = file_end_addr; - end_symtab (file_end_addr, 1, 1, objfile); + end_symtab (file_end_addr, 1, 0, objfile); start_symtab (cs->c_name, (char *)NULL, (CORE_ADDR)0); - last_seen_csect = 0; + last_csect_name = 0; /* reset file start and end addresses. A compilation unit with no text (only data) should have zero file boundaries. */ @@ -632,6 +1338,25 @@ function_entry_point: break; + case C_FUN: + + /* For a function stab, just save its type in `fcn_type_saved', and leave + it for the `.bf' processing. */ + { + char *pp = (char*) index (cs->c_name, ':'); + + if (!pp || ( *(pp+1) != 'F' && *(pp+1) != 'f')) + fatal ("Unrecognized stab"); + pp += 2; + + if (fcn_type_saved) + fatal ("Unprocessed function type"); + + fcn_type_saved = lookup_function_type (read_type (&pp, objfile)); + } + break; + + case C_FCN: if (strcmp (cs->c_name, ".bf") == 0) { @@ -640,17 +1365,73 @@ function_entry_point: within_function = 1; - /* value contains address of first non-init type code */ - /* main_aux.x_sym.x_misc.x_lnsz.x_lnno - contains line number of '{' } */ - fcn_first_line = main_aux->x_sym.x_misc.x_lnsz.x_lnno; - /* Linenos are now processed on a file-by-file, not fn-by-fn, basis. Metin did it, I'm not sure why. FIXME. -- gnu@cygnus.com */ - /* mark_first_line (fcn_line_offset, cs->c_symnum); */ + + /* Two reasons: + + 1) xlc (IBM's native c compiler) postpones static function code + emission to the end of a compilation unit. This way it can + determine if those functions (statics) are needed or not, and + can do some garbage collection (I think). This makes line + numbers and corresponding addresses unordered, and we end up + with a line table like: + + + lineno addr + foo() 10 0x100 + 20 0x200 + 30 0x300 + + foo3() 70 0x400 + 80 0x500 + 90 0x600 + + static foo2() + 40 0x700 + 50 0x800 + 60 0x900 + + and that breaks gdb's binary search on line numbers, if the + above table is not sorted on line numbers. And that sort + should be on function based, since gcc can emit line numbers + like: + + 10 0x100 - for the init/test part of a for stmt. + 20 0x200 + 30 0x300 + 10 0x400 - for the increment part of a for stmt. + + arrange_linenos() will do this sorting. + + + 2) aix symbol table might look like: + + c_file // beginning of a new file + .bi // beginning of include file + .ei // end of include file + .bi + .ei + + basically, .bi/.ei pairs do not necessarily encapsulate + their scope. They need to be recorded, and processed later + on when we come the end of the compilation unit. + Include table (inclTable) and process_linenos() handle + that. + */ + mark_first_line (fcn_line_offset, cs->c_symnum); new = push_context (0, fcn_start_addr); new->name = process_xcoff_symbol (&fcn_cs_saved, objfile); + + /* Between a function symbol and `.bf', there always will be a function + stab. We save function type when processing that stab. */ + + if (fcn_type_saved == NULL) + fatal ("Unknown function type"); + + SYMBOL_TYPE (new->name) = fcn_type_saved; + fcn_type_saved = NULL; } else if (strcmp (cs->c_name, ".ef") == 0) { @@ -663,11 +1444,6 @@ function_entry_point: contains number of lines to '}' */ fcn_last_line = main_aux->x_sym.x_misc.x_lnsz.x_lnno; -#if 0 - enter_linenos (fcn_line_offset, fcn_first_line, - fcn_first_line + fcn_last_line); -#endif - new = pop_context (); if (context_stack_depth != 0) error ("invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.", @@ -704,18 +1480,18 @@ function_entry_point: break; case C_BINCL : /* beginning of include file */ - push_subfile (); - start_subfile (cs->c_name, (char *)0); - fcn_first_line = cs->c_value; /* Offset to first lineno of file */ + + /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted + order. Thus, when wee see them, we might not know enough info + to process them. Thus, we'll be saving them into a table + (inclTable) and postpone their processing. */ + + record_include_begin (cs); break; case C_EINCL : /* end of include file */ - fcn_last_line = cs->c_value; /* Offset to last line number */ - { long dummy = 0; - enter_line_range (current_subfile, fcn_first_line, cs->c_value, 0, - (unsigned *) &dummy); - } - start_subfile (pop_subfile (), (char *)0); + /* see the comment after case C_BINCL. */ + record_include_end (cs); break; case C_BLOCK : @@ -747,7 +1523,7 @@ function_entry_point: } /* while */ if (last_source_file) - end_symtab (cur_src_end_addr, 1, 1, objfile); + end_symtab (cur_src_end_addr, 1, 0, objfile); free (symtbl); current_objfile = NULL; @@ -763,7 +1539,6 @@ function_entry_point: (ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME)); - /* process one xcoff symbol. */ static struct symbol * @@ -776,6 +1551,7 @@ process_xcoff_symbol (cs, objfile) struct symbol *sym2 = NULL; struct type *ttype; char *name, *pp, *qq; + int struct_and_type_combined; name = cs->c_name; if (name[0] == '.') @@ -794,7 +1570,7 @@ process_xcoff_symbol (cs, objfile) on in patch_block_stabs () */ SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced); - SYMBOL_TYPE (sym) = lookup_function_type (lookup_fundamental_type (current_objfile, FT_INTEGER)); + SYMBOL_TYPE (sym) = lookup_function_type (lookup_fundamental_type (objfile, FT_INTEGER)); SYMBOL_CLASS (sym) = LOC_BLOCK; SYMBOL_DUP (sym, sym2); @@ -808,23 +1584,26 @@ process_xcoff_symbol (cs, objfile) else { /* in case we can't figure out the type, default is `int'. */ - SYMBOL_TYPE (sym) = lookup_fundamental_type (current_objfile, FT_INTEGER); + SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile, FT_INTEGER); switch (cs->c_sclass) { +#if 0 case C_FUN: if (fcn_cs_saved.c_sclass == C_EXT) add_stab_to_list (name, &global_stabs); else add_stab_to_list (name, &file_stabs); break; +#endif case C_DECL: /* a type decleration?? */ qq = (char*) strchr (name, ':'); if (!qq) /* skip if there is no ':' */ return NULL; - pp = qq + 2; + struct_and_type_combined = (qq[1] == 'T' && qq[2] == 't'); + pp = qq + (struct_and_type_combined ? 3 : 2); ttype = SYMBOL_TYPE (sym) = read_type (&pp, objfile); /* read_type() will return null if type (or tag) definition was @@ -846,18 +1625,26 @@ process_xcoff_symbol (cs, objfile) SYMBOL_CLASS (sym) = LOC_TYPEDEF; SYMBOL_NAME (sym) = obsavestring (name, qq-name, &objfile->symbol_obstack); - if (SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE) + if (struct_and_type_combined) + TYPE_NAME (ttype) = SYMBOL_NAME (sym); + + else if (SYMBOL_NAMESPACE (sym) == 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); - else if (!TYPE_NAME (ttype)) /* else, regular typedef. */ - TYPE_NAME (ttype) = SYMBOL_NAME (sym); - 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. */ + 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); + } break; case C_GSYM: @@ -865,10 +1652,11 @@ process_xcoff_symbol (cs, objfile) break; case C_PSYM: + case C_RPSYM: if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL) return NULL; SYMBOL_NAME (sym) = obsavestring (name, pp-name, &objfile -> symbol_obstack); - SYMBOL_CLASS (sym) = LOC_ARG; + SYMBOL_CLASS (sym) = (cs->c_sclass == C_PSYM) ? LOC_ARG : LOC_REGPARM; pp += 2; SYMBOL_TYPE (sym) = read_type (&pp, objfile); SYMBOL_DUP (sym, sym2); @@ -944,8 +1732,8 @@ process_xcoff_symbol (cs, objfile) `int' or `float', depending on the register class. */ SYMBOL_TYPE (sym) = (SYMBOL_VALUE (sym) < 32) - ? lookup_fundamental_type (current_objfile, FT_INTEGER) - : lookup_fundamental_type (current_objfile, FT_FLOAT); + ? lookup_fundamental_type (objfile, FT_INTEGER) + : lookup_fundamental_type (objfile, FT_FLOAT); SYMBOL_DUP (sym, sym2); add_symbol_to_list (sym2, &local_symbols); @@ -1020,7 +1808,7 @@ PTR vpinfo; count = asect->lineno_count; - if (count == 0) + if (strcmp (asect->name, ".text") || count == 0) return; size = count * coff_data (symfile_bfd)->local_linesz; @@ -1169,7 +1957,14 @@ build_function_symbol (ind, objfile) static void aixcoff_new_init () { - /* Nothin' to do. */ + /* This routine is executed once per executable. We should start with a + fresh include table per executable. */ + + if (inclTable) { + free (inclTable); + inclTable = NULL; + } + inclIndx = inclLength = inclDepth = NULL; } static void @@ -1375,3 +2170,11 @@ _initialize_xcoffread () { add_symtab_fns(&aixcoff_sym_fns); } +#else /* IBM6000 */ +struct type * +builtin_type (pp) +char **pp; +{ + fatal ("internals eror: builtin_type called!"); +} +#endif /* IBM6000 */ diff --git a/gdb/xm-rs6000.h b/gdb/xm-rs6000.h index 2c0c101..deef444 100644 --- a/gdb/xm-rs6000.h +++ b/gdb/xm-rs6000.h @@ -54,7 +54,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Setpgrp() takes arguments, unlike ordinary Sys V's. */ -#define SETPGRP_ARGS +#define SETPGRP_ARGS 1 /* RS6000/AIXCOFF does not support PT_STEP. Has to be simulated. */ @@ -65,3 +65,13 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #define XCOFF_INIT_LOADINFO() xcoff_init_loadinfo() #define XCOFF_ADD_TOC_TO_LOADINFO(x) xcoff_add_toc_to_loadinfo (x) + +/* AIX's assembler doesn't grok dollar signs in identifiers. + So we use dots instead. This item must be coordinated with G++. */ +#undef CPLUS_MARKER +#define CPLUS_MARKER '.' + +/* Flag for machine-specific stuff in shared files. FIXME */ +#ifndef IBM6000 +#define IBM6000 +#endif |