From: John Gilmore Date: Sat, 29 Aug 1992 00:28:56 +0000 (+0000) Subject: RS/6000 portability changes (for hosting cross-debuggers). X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=ecf4059f1cdbfdf685d5c02348090dc72c56c20e;p=binutils-gdb.git RS/6000 portability changes (for hosting cross-debuggers). * breakpoint.c (fixup_breakpoints): Re-kludge to IBM6000_TARGET. * buildsym.c, rs6000-xdep.c, rs6000-tdep.c, tm-rs6000.h, xcoffexec.c, xcoffread.c: Rename aixcoff to xcoff everywhere. * printcmd.c (print_frame_args): Remove an RS/6000 dependency. * stabsread.c (define_symbol): Remove RS/6000 dependencies. * tm-rs6000.h (ATTACH_DETACH): Remove: host-dependent. (PTRACE_ATTACH, PTRACE_DETACH): Remove: host-dep. (NO_SINGLE_STEP): Add, target-dependent. (loadinfotextindex): Lowercase, remove "aix_". * xm-rs6000.h: Add for infptrace.c. (NO_SINGLE_STEP): Remove, target-dependent. * xcoffexec.c (vmap_symtab): Cleanup #if 0'd code. * xcoffread.c: Only build file if RS/6000 native GDB. (build_function_symbol): Remove #if 0'd code. * rs6000-tdep.c: Cleanup. Add static fn protos. Use CORE_ADDR for addresses throughout. Make void fns void. (pop_dummy_frame): Add FIXME about bogosity of design here. (rs6000_struct_return_address): Ditto. (frameless_function_invocation, frame_get_cache_fsr, frame_initial_stack_address, xcoff_relocate_symtab, xcoff_init_loadinfo, free_loadinfo, xcoff_add_toc_to_loadinfo, add_text_to_loadinfo, find_toc_address): Move from xdep file. Use CORE_ADDRs. Change identifiers to lowercase. * rs6000-xdep.c: Make whole file conditional on native RS/6000, supplying dummy routines if non-native. Add prototype for static exec_one_dummy_insn. Move a mess of functions to rs6000-tdep.c (as above). Remove #if 0'd code. * config/rs6000.mh (XDEPFILES): Move xcoffexec.o to target side. (XM_CLIBS): Add -lm to circumvent AIX 3.2 libc ldexp bug. * config/rs6000.mt (TDEPFILES): Adopt xcoffexec.o. * gdbtypes.h (TYPE_ALLOC): Parenthesize result to avoid problems for callers. --- diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c index 290fb7747e7..5bee145831f 100644 --- a/gdb/rs6000-tdep.c +++ b/gdb/rs6000-tdep.c @@ -1,5 +1,5 @@ /* Target-dependent code for GDB, the GNU debugger. - Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc. + Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc. This file is part of GDB. @@ -37,9 +37,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include +#include extern int errno; -extern int attach_flag; /* Nonzero if we just simulated a single step break. */ int one_stepped; @@ -52,16 +52,33 @@ static struct sstep_breaks { int data; } stepBreaks[2]; +/* Static function prototypes */ + +static void +add_text_to_loadinfo PARAMS ((CORE_ADDR textaddr, CORE_ADDR dataaddr)); + +static CORE_ADDR +find_toc_address PARAMS ((CORE_ADDR pc)); + +static CORE_ADDR +branch_dest PARAMS ((int opcode, int instr, CORE_ADDR pc, CORE_ADDR safety)); + +static void +frame_get_cache_fsr PARAMS ((struct frame_info *fi, + struct aix_framedata *fdatap)); /* * Calculate the destination of a branch/jump. Return -1 if not a branch. */ -static int +static CORE_ADDR branch_dest (opcode, instr, pc, safety) - int opcode, instr, pc, safety; + int opcode; + int instr; + CORE_ADDR pc; + CORE_ADDR safety; { register long offset; - unsigned dest; + CORE_ADDR dest; int immediate; int absolute; int ext_op; @@ -70,7 +87,7 @@ branch_dest (opcode, instr, pc, safety) switch (opcode) { case 18 : - immediate = ((instr & ~3) << 6) >> 6; /* br unconditionl */ + immediate = ((instr & ~3) << 6) >> 6; /* br unconditional */ case 16 : if (opcode != 18) /* br conditional */ @@ -113,7 +130,6 @@ int signal; int breaks[2], opcode; if (!one_stepped) { - extern CORE_ADDR text_start; loc = read_pc (); ret = read_memory (loc, &insn, sizeof (int)); @@ -163,10 +179,10 @@ int signal; /* return pc value after skipping a function prologue. */ skip_prologue (pc) -int pc; +CORE_ADDR pc; { unsigned int tmp; - unsigned int op; + unsigned int op; /* FIXME, assumes instruction size matches host int!!! */ if (target_read_memory (pc, (char *)&op, sizeof (op))) return pc; /* Can't access it -- assume no prologue. */ @@ -269,12 +285,6 @@ int pc; } -/* text start and end addresses in virtual memory. */ - -CORE_ADDR text_start; -CORE_ADDR text_end; - - /************************************************************************* Support for creating pushind a dummy frame into the stack, and popping frames, etc. @@ -305,6 +315,7 @@ extern int stop_stack_dummy; /* push a dummy frame into stack, save all register. Currently we are saving only gpr's and fpr's, which is not good enough! FIXMEmgo */ +void push_dummy_frame () { int sp, pc; /* stack pointer and link register */ @@ -383,6 +394,12 @@ push_dummy_frame () 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). + +FIXME: This whole concept is broken. You should be able to detect +a dummy stack frame *on the user's stack itself*. When you do, +then you know the format of that stack frame -- including its +saved SP register! There should *not* be a separate stack in the +GDB process that keeps track of these dummy frames! -- gnu@cygnus.com Aug92 */ */ pop_dummy_frame () @@ -425,6 +442,7 @@ pop_dummy_frame () /* pop the innermost frame, go back to the caller. */ +void pop_frame () { int pc, lr, sp, prev_sp; /* %pc, %lr, %sp */ @@ -481,20 +499,20 @@ pop_frame () /* fixup the call sequence of a dummy function, with the real function address. its argumets will be passed by gdb. */ +void fix_call_dummy(dummyname, pc, fun, nargs, type) char *dummyname; - int pc; - int fun; + CORE_ADDR pc; + CORE_ADDR fun; int nargs; /* not used */ int type; /* not used */ - { #define TOC_ADDR_OFFSET 20 #define TARGET_ADDR_OFFSET 28 int ii; - unsigned long target_addr; - unsigned long tocvalue; + CORE_ADDR target_addr; + CORE_ADDR tocvalue; target_addr = fun; tocvalue = find_toc_address (target_addr); @@ -517,7 +535,6 @@ fix_call_dummy(dummyname, pc, fun, nargs, type) } - /* return information about a function frame. in struct aix_frameinfo fdata: - frameless is TRUE, if function does not save %pc value in its frame. @@ -527,6 +544,7 @@ fix_call_dummy(dummyname, pc, fun, nargs, type) - alloca_reg is the number of the register used for alloca() handling. Otherwise -1. */ +void function_frame_info (pc, fdata) int pc; struct aix_framedata *fdata; @@ -803,6 +821,7 @@ ran_out_of_registers_for_arguments: /* a given return value in `regbuf' with a type `valtype', extract and copy its value into `valbuf' */ +void extract_return_value (valtype, regbuf, valbuf) struct type *valtype; char regbuf[REGISTER_BYTES]; @@ -831,12 +850,16 @@ extract_return_value (valtype, regbuf, valbuf) } -/* keep keep structure return address in this variable. */ +/* keep structure return address in this variable. + FIXME: This is a horrid kludge which should not be allowed to continue + living. This only allows a single nested call to a structure-returning + function. Come on, guys! -- gnu@cygnus.com, Aug 92 */ CORE_ADDR rs6000_struct_return_address; /* Throw away this debugging code. FIXMEmgo. */ +void print_frame(fram) int fram; { @@ -858,8 +881,9 @@ int fram; Result is desired PC to step until, or NULL if we are not in trampoline code. */ +CORE_ADDR skip_trampoline_code (pc) -int pc; +CORE_ADDR pc; { register unsigned int ii, op; @@ -884,3 +908,283 @@ int pc; return pc; } + +/* Determines whether the function FI has a frame on the stack or not. + Called from the FRAMELESS_FUNCTION_INVOCATION macro in tm.h. */ + +int +frameless_function_invocation (fi) +struct frame_info *fi; +{ + CORE_ADDR func_start; + struct aix_framedata fdata; + + func_start = get_pc_function_start (fi->pc) + FUNCTION_START_OFFSET; + + /* 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, &fdata); + return fdata.frameless; +} + + +/* If saved registers of frame FI are not known yet, read and cache them. + &FDATAP contains aix_framedata; TDATAP can be NULL, + in which case the framedata are read. */ + +static void +frame_get_cache_fsr (fi, fdatap) + struct frame_info *fi; + struct aix_framedata *fdatap; +{ + int ii; + CORE_ADDR frame_addr; + struct aix_framedata work_fdata; + + if (fi->cache_fsr) + return; + + if (fdatap == NULL) { + fdatap = &work_fdata; + function_frame_info (get_pc_function_start (fi->pc), fdatap); + } + + fi->cache_fsr = (struct frame_saved_regs *) + obstack_alloc (&frame_cache_obstack, sizeof (struct frame_saved_regs)); + bzero (fi->cache_fsr, sizeof (struct frame_saved_regs)); + + if (fi->prev && fi->prev->frame) + frame_addr = fi->prev->frame; + else + frame_addr = read_memory_integer (fi->frame, 4); + + /* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr. + All fpr's from saved_fpr to fp31 are saved right underneath caller + stack pointer, starting from fp31 first. */ + + if (fdatap->saved_fpr >= 0) { + for (ii=31; ii >= fdatap->saved_fpr; --ii) + fi->cache_fsr->regs [FP0_REGNUM + ii] = frame_addr - ((32 - ii) * 8); + frame_addr -= (32 - fdatap->saved_fpr) * 8; + } + + /* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr. + All gpr's from saved_gpr to gpr31 are saved right under saved fprs, + starting from r31 first. */ + + if (fdatap->saved_gpr >= 0) + for (ii=31; ii >= fdatap->saved_gpr; --ii) + fi->cache_fsr->regs [ii] = frame_addr - ((32 - ii) * 4); +} + +/* Return the address of a frame. This is the inital %sp value when the frame + was first allocated. For functions calling alloca(), it might be saved in + an alloca register. */ + +CORE_ADDR +frame_initial_stack_address (fi) + struct frame_info *fi; +{ + CORE_ADDR tmpaddr; + struct aix_framedata fdata; + struct frame_info *callee_fi; + + /* if the initial stack pointer (frame address) of this frame is known, + just return it. */ + + if (fi->initial_sp) + return fi->initial_sp; + + /* find out if this function is using an alloca register.. */ + + function_frame_info (get_pc_function_start (fi->pc), &fdata); + + /* if saved registers of this frame are not known yet, read and cache them. */ + + if (!fi->cache_fsr) + frame_get_cache_fsr (fi, &fdata); + + /* If no alloca register used, then fi->frame is the value of the %sp for + this frame, and it is good enough. */ + + if (fdata.alloca_reg < 0) { + fi->initial_sp = fi->frame; + return fi->initial_sp; + } + + /* This function has an alloca register. If this is the top-most frame + (with the lowest address), the value in alloca register is good. */ + + if (!fi->next) + return fi->initial_sp = read_register (fdata.alloca_reg); + + /* Otherwise, this is a caller frame. Callee has usually already saved + registers, but there are exceptions (such as when the callee + has no parameters). Find the address in which caller's alloca + register is saved. */ + + for (callee_fi = fi->next; callee_fi; callee_fi = callee_fi->next) { + + if (!callee_fi->cache_fsr) + frame_get_cache_fsr (fi, NULL); + + /* this is the address in which alloca register is saved. */ + + tmpaddr = callee_fi->cache_fsr->regs [fdata.alloca_reg]; + if (tmpaddr) { + fi->initial_sp = read_memory_integer (tmpaddr, 4); + return fi->initial_sp; + } + + /* Go look into deeper levels of the frame chain to see if any one of + the callees has saved alloca register. */ + } + + /* If alloca register was not saved, by the callee (or any of its callees) + then the value in the register is still good. */ + + return fi->initial_sp = read_register (fdata.alloca_reg); +} + +/* xcoff_relocate_symtab - hook for symbol table relocation. + also reads shared libraries.. */ + +xcoff_relocate_symtab (pid) +unsigned int pid; +{ +#define MAX_LOAD_SEGS 64 /* maximum number of load segments */ + + struct ld_info *ldi; + int temp; + + ldi = (void *) alloca(MAX_LOAD_SEGS * sizeof (*ldi)); + + /* According to my humble theory, AIX has some timing problems and + when the user stack grows, kernel doesn't update stack info in time + and ptrace calls step on user stack. That is why we sleep here a little, + and give kernel to update its internals. */ + + usleep (36000); + + errno = 0; + ptrace(PT_LDINFO, pid, (PTRACE_ARG3_TYPE) ldi, + MAX_LOAD_SEGS * sizeof(*ldi), ldi); + if (errno) { + perror_with_name ("ptrace ldinfo"); + return 0; + } + + vmap_ldinfo(ldi); + + do { + add_text_to_loadinfo (ldi->ldinfo_textorg, ldi->ldinfo_dataorg); + } 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 (); +} + +/* Keep an array of load segment information and their TOC table addresses. + This info will be useful when calling a shared library function by hand. */ + +struct loadinfo { + CORE_ADDR textorg, dataorg; + unsigned long toc_offset; +}; + +#define LOADINFOLEN 10 + +/* FIXME Warning -- loadinfotextindex is used for a nefarious purpose by + tm-rs6000.h. */ + +static struct loadinfo *loadinfo = NULL; +static int loadinfolen = 0; +static int loadinfotocindex = 0; +int loadinfotextindex = 0; + + +void +xcoff_init_loadinfo () +{ + loadinfotocindex = 0; + loadinfotextindex = 0; + + if (loadinfolen == 0) { + loadinfo = (struct loadinfo *) + xmalloc (sizeof (struct loadinfo) * LOADINFOLEN); + loadinfolen = LOADINFOLEN; + } +} + + +/* FIXME -- this is never called! */ +void +free_loadinfo () +{ + if (loadinfo) + free (loadinfo); + loadinfo = NULL; + loadinfolen = 0; + loadinfotocindex = 0; + loadinfotextindex = 0; +} + +/* this is called from xcoffread.c */ + +void +xcoff_add_toc_to_loadinfo (unsigned long tocoff) +{ + while (loadinfotocindex >= loadinfolen) { + loadinfolen += LOADINFOLEN; + loadinfo = (struct loadinfo *) + xrealloc (loadinfo, sizeof(struct loadinfo) * loadinfolen); + } + loadinfo [loadinfotocindex++].toc_offset = tocoff; +} + + +static void +add_text_to_loadinfo (textaddr, dataaddr) + CORE_ADDR textaddr; + CORE_ADDR dataaddr; +{ + while (loadinfotextindex >= loadinfolen) { + loadinfolen += LOADINFOLEN; + loadinfo = (struct loadinfo *) + xrealloc (loadinfo, sizeof(struct loadinfo) * loadinfolen); + } + loadinfo [loadinfotextindex].textorg = textaddr; + loadinfo [loadinfotextindex].dataorg = dataaddr; + ++loadinfotextindex; +} + + +/* FIXME: This assumes that the "textorg" and "dataorg" elements + of a member of this array are correlated with the "toc_offset" + element of the same member. But they are sequentially assigned in wildly + different places, and probably there is no correlation. FIXME! */ + +static CORE_ADDR +find_toc_address (pc) + CORE_ADDR pc; +{ + int ii, toc_entry, tocbase = 0; + + for (ii=0; ii < 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; +}