diff options
| -rw-r--r-- | gdb/ChangeLog | 32 | ||||
| -rw-r--r-- | gdb/alloca.c | 8 | ||||
| -rw-r--r-- | gdb/language.c | 12 | ||||
| -rw-r--r-- | gdb/m88k-tdep.c | 755 | ||||
| -rwxr-xr-x | gdb/tdesc.c | 4 | ||||
| -rw-r--r-- | gdb/tm-delta88.h | 147 | ||||
| -rw-r--r-- | gdb/xm-m88k.h | 52 |
7 files changed, 580 insertions, 430 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 96d9055..c236eb3 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,35 @@ +Wed Nov 13 16:45:13 1991 John Gilmore (gnu at cygnus.com) + + Motorola 88000 port without tears, I mean without tdescs. + + * m88k-tdep.c: Blow away all tdesc stuff. + Provide functions for all the frame-related macros in + tm-delta88.h. Adopt i960-style EXTRA_FRAME_INFO. + (examine_prologue, frame_find_saved_regs, skip_prologue): borrow + from i960-tdep.c and adapt to the function prologues on the 88k. + (read_next_frame_reg): Borrow from mips-tdep.c. + FIXME: frame_locals_address should go away. + + * tm-delta88.h: Dump all the tdesc stuff. + Macros for all frame-related stuff call fns of same name. + Remove duplicated definitions. FP_REGNUM becomes same as + SP_REGNUM. + + * xm-88k.h: Eliminate lots of library dependencies, now handled + in libiberty. Eliminate KDB nonsupport. + + * doc/gdbint.texinfo: Add rudiments on frames. FIXME, add more. + + + * stack.c (frame_info): Mark frameless functions. + Print locals address (FIXME, remove if same). + * blockframe.c: Comment changes, FIXME after. + * coffread.c: Even without TDESC, need to zap "@" symbols. + Don't register for wierd format names; change the names in BFD. + + * alloca.c, language.c, tdesc.c: Lint. + * tdesc.c, tdesc-lib: FIXME: remove these. + Tue Nov 12 19:30:22 1991 John Gilmore (gnu at cygnus.com) * Makefile.in: Add tdesc library support. Fixups to lint, diff --git a/gdb/alloca.c b/gdb/alloca.c index d5de3de..60f86e0 100644 --- a/gdb/alloca.c +++ b/gdb/alloca.c @@ -42,8 +42,8 @@ you lose -- must know STACK_DIRECTION at compile-time #endif /* STACK_DIRECTION undefined */ -#endif static -#endif emacs +#endif /* static */ +#endif /* emacs */ #ifdef __STDC__ typedef void *pointer; /* generic pointer type */ @@ -154,8 +154,8 @@ alloca (size) /* returns pointer to storage */ register header *hp; /* traverses linked list */ for (hp = last_alloca_header; hp != NULL;) - if (STACK_DIR > 0 && hp->h.deep > depth - || STACK_DIR < 0 && hp->h.deep < depth) + if ( (STACK_DIR > 0 && hp->h.deep > depth) + || (STACK_DIR < 0 && hp->h.deep < depth) ) { register header *np = hp->h.next; diff --git a/gdb/language.c b/gdb/language.c index 2ddad67..c584d4e 100644 --- a/gdb/language.c +++ b/gdb/language.c @@ -974,18 +974,6 @@ add_language (lang) languages_allocsize * sizeof (*languages)); } languages[languages_size++] = lang; - -#if FIXME - if (targetlist == NULL) - add_prefix_cmd ("target", class_run, target_command, - "Connect to a target machine or process.\n\ -The first argument is the type or protocol of the target machine.\n\ -Remaining arguments are interpreted by the target protocol. For more\n\ -information on the arguments for a particular protocol, type\n\ -`help target ' followed by the protocol name.", - &targetlist, "target ", 0, &cmdlist); - add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist); -#endif FIXME } /* Define the language that is no language. */ diff --git a/gdb/m88k-tdep.c b/gdb/m88k-tdep.c index 71407f3..6d0ca84 100644 --- a/gdb/m88k-tdep.c +++ b/gdb/m88k-tdep.c @@ -1,4 +1,5 @@ -/* Copyright (C) 1988, 1990 Free Software Foundation, Inc. +/* Target-machine dependent code for Motorola 88000 series, for GDB. + Copyright (C) 1988, 1990, 1991 Free Software Foundation, Inc. This file is part of GDB. @@ -46,139 +47,483 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "setjmp.h" #include "value.h" -int stack_error; -jmp_buf stack_jmp; +void frame_find_saved_regs (); -void -tdesc_error_function (environment, continuable, message) -dc_word_t environment; -dc_boolean_t continuable; -char *message; + +/* Given a GDB frame, determine the address of the calling function's frame. + This will be used to create a new GDB frame struct, and then + INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame. + + For us, the frame address is its stack pointer value, so we look up + the function prologue to determine the caller's sp value, and return it. */ + +FRAME_ADDR +frame_chain (thisframe) + FRAME thisframe; { - if (stack_error) longjmp (stack_jmp, 1); - if (!continuable) - { - printf("%s\n",message); - abort(); - } -} + frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0); + /* NOTE: this depends on frame_find_saved_regs returning the VALUE, not + the ADDRESS, of SP_REGNUM. It also depends on the cache of + frame_find_saved_regs results. */ + if (thisframe->fsr->regs[SP_REGNUM]) + return thisframe->fsr->regs[SP_REGNUM]; + else + return thisframe->frame; /* Leaf fn -- next frame up has same SP. */ +} -void -tdesc_read_function (environment, memory, length, buffer) -dc_word_t environment; -dc_word_t memory; -int length; -char *buffer; +int +frameless_function_invocation (frame) + FRAME frame; { - int ptrace_code; - errno = 0; - if (memory < 2048) -#if 0 - /* This is a no-op! It sets buffer, but doesn't do anything to - what buffer points to. What does this function do anyway? - And this is wrong for cross-debugging. */ - buffer = ptrace (3, inferior_pid, memory, 0); -#else - return; -#endif + + frame_find_saved_regs (frame, (struct frame_saved_regs *) 0); + /* NOTE: this depends on frame_find_saved_regs returning the VALUE, not + the ADDRESS, of SP_REGNUM. It also depends on the cache of + frame_find_saved_regs results. */ + if (frame->fsr->regs[SP_REGNUM]) + return 0; /* Frameful -- return addr saved somewhere */ else - read_memory (memory, buffer, length); + return 1; /* Frameless -- no saved return address */ } -/* Map function for tdesc */ -void -tdesc_map_function (map_env, loc, map_info_in, map_info_out) -dc_word_t map_env; -dc_word_t loc; -dc_map_info_in_t map_info_in; -dc_map_info_out_t *map_info_out; +int +frame_chain_valid (chain, thisframe) + CORE_ADDR chain; + struct frame_info *thisframe; { -int map_flags = DC_MIO_ENTRY_POINT | DC_MIO_IMPLICIT_PROLOGUE_END; -int entry_point = get_pc_function_start(loc); -map_info_out->flags = map_flags; -map_info_out->entry_point = entry_point; + return (chain != 0 + && outside_startup_file (FRAME_SAVED_PC (thisframe))); } -dc_handle_t tdesc_handle; +CORE_ADDR +frame_chain_combine (chain, thisframe) + CORE_ADDR chain; +{ + return chain; +} -extern int debug_info; +void +init_extra_frame_info (fromleaf, fi) + int fromleaf; + struct frame_info *fi; +{ + fi->fsr = 0; /* Not yet allocated */ + fi->args_pointer = 0; /* Unknown */ + fi->locals_pointer = 0; /* Unknown */ +} void -init_tdesc () +init_frame_pc (fromleaf, prev) + int fromleaf; + struct frame_info *prev; { - tdesc_handle = dc_initiate (debug_info, tdesc_error_function, - 0,tdesc_read_function,0,0,0,0,0,tdesc_map_function,0); -} -dc_dcontext_t current_context; - -/* setup current context, called from wait_for_inferior */ + /* FIXME, for now it's the default from blockframe.c. If it stays that + way, remove it entirely from here. */ + prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : + prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ()); + +} + +/* Examine an m88k function prologue, recording the addresses at which + registers are saved explicitly by the prologue code, and returning + the address of the first instruction after the prologue (but not + after the instruction at address LIMIT, as explained below). + + LIMIT places an upper bound on addresses of the instructions to be + examined. If the prologue code scan reaches LIMIT, the scan is + aborted and LIMIT is returned. This is used, when examining the + prologue for the current frame, to keep examine_prologue () from + claiming that a given register has been saved when in fact the + instruction that saves it has not yet been executed. LIMIT is used + at other times to stop the scan when we hit code after the true + function prologue (e.g. for the first source line) which might + otherwise be mistaken for function prologue. + + The format of the function prologue matched by this routine is + derived from examination of the source to gcc 1.95, particularly + the routine output_prologue () in config/out-m88k.c. + + subu r31,r31,n # stack pointer update + + (st rn,r31,offset)? # save incoming regs + (st.d rn,r31,offset)? + + (addu r30,r31,n)? # frame pointer update + + (pic sequence)? # PIC code prologue +*/ + +/* Macros for extracting fields from instructions. */ + +#define BITMASK(pos, width) (((0x1 << (width)) - 1) << (pos)) +#define EXTRACT_FIELD(val, pos, width) ((val) >> (pos) & BITMASK (0, width)) + +/* Prologue code that handles position-independent-code setup. */ + +struct pic_prologue_code { + unsigned long insn, mask; +}; + +static struct pic_prologue_code pic_prologue_code [] = { +/* FIXME -- until this is translated to hex, we won't match it... */ + 0xffffffff, 0, + /* or r10,r1,0 (if not saved) */ + /* bsr.n LabN */ + /* or.u r25,r0,const */ + /*LabN: or r25,r25,const2 */ + /* addu r25,r25,1 */ + /* or r1,r10,0 (if not saved) */ +}; + +/* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or + is not the address of a valid instruction, the address of the next + instruction beyond ADDR otherwise. *PWORD1 receives the first word + of the instruction. PWORD2 is ignored -- a remnant of the original + i960 version. */ + +#define NEXT_PROLOGUE_INSN(addr, lim, pword1, pword2) \ + (((addr) < (lim)) ? next_insn (addr, pword1) : 0) + +/* Read the m88k instruction at 'memaddr' and return the address of + the next instruction after that, or 0 if 'memaddr' is not the + address of a valid instruction. The instruction + is stored at 'pword1'. */ -dc_dcontext_t -init_dcontext() +CORE_ADDR +next_insn (memaddr, pword1) + unsigned long *pword1; + CORE_ADDR memaddr; { - dc_word_t reg_info[DC_NUM_REG]; - dc_word_t reg_flags[2] = {0,-1}; - dc_word_t aux_info[DC_NUM_AUX]; - dc_word_t aux_flags[2] = {0,-1}; - dc_exactness_t loc_exact = DC_NO; - dc_word_t psr_info; - dc_boolean_t psr_ind = 0; - dc_word_t psr_flags[2] = {0,-1}; - - bcopy (®isters, reg_info, DC_NUM_REG * 4); - aux_info[DC_AUX_LOC] = read_register(SXIP_REGNUM); - aux_info[DC_AUX_SXIP] = read_register(SXIP_REGNUM); - aux_info[DC_AUX_SNIP] = read_register(SNIP_REGNUM); - aux_info[DC_AUX_SFIP] = read_register(SFIP_REGNUM); - aux_info[DC_AUX_FPSR] = read_register(FPSR_REGNUM); - aux_info[DC_AUX_FPCR] = read_register(FPCR_REGNUM); - - psr_info = read_register(PSR_REGNUM); - - return dc_make_dcontext (tdesc_handle, reg_info, reg_flags, aux_info, - aux_flags, loc_exact, psr_info, psr_ind, psr_flags); + unsigned long buf[1]; + + read_memory (memaddr, buf, sizeof (buf)); + *pword1 = buf[0]; + SWAP_TARGET_AND_HOST (pword1, sizeof (long)); + + return memaddr + 4; } +/* Read a register from frames called by us (or from the hardware regs). */ -dc_dcontext_t -get_prev_context (context) - dc_dcontext_t context; +int +read_next_frame_reg(fi, regno) + FRAME fi; + int regno; { - return current_context = dc_previous_dcontext (context); + for (; fi; fi = fi->next) { + if (regno == SP_REGNUM) return fi->frame; + else if (fi->fsr->regs[regno]) + return read_memory_integer(fi->fsr->regs[regno], 4); + } + return read_register(regno); } - +/* Examine the prologue of a function. `ip' points to the first instruction. + `limit' is the limit of the prologue (e.g. the addr of the first + linenumber, or perhaps the program counter if we're stepping through). + `frame_sp' is the stack pointer value in use in this frame. + `fsr' is a pointer to a frame_saved_regs structure into which we put + info about the registers saved by this frame. + `fi' is a struct frame_info pointer; we fill in various fields in it + to reflect the offsets of the arg pointer and the locals pointer. */ + +static CORE_ADDR +examine_prologue (ip, limit, frame_sp, fsr, fi) + register CORE_ADDR ip; + register CORE_ADDR limit; + FRAME_ADDR frame_sp; + struct frame_saved_regs *fsr; + struct frame_info *fi; +{ + register CORE_ADDR next_ip; + register int src; + register struct pic_prologue_code *pcode; + unsigned int insn1, insn2; + int size, offset; + char must_adjust[32]; /* If set, must adjust offsets in fsr */ + int sp_offset = -1; /* -1 means not set (valid must be mult of 8) */ + int fp_offset = -1; /* -1 means not set */ + CORE_ADDR frame_fp; + + bzero (must_adjust, sizeof (must_adjust)); + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + + /* Accept an optional "subu sp,sp,n" to set up the stack pointer. */ + +#define SUBU_SP_INSN 0x67ff0000 +#define SUBU_SP_MASK 0xffff0007 /* Note offset must be mult. of 8 */ +#define SUBU_OFFSET(x) ((unsigned)(x & 0xFFFF)) + if (next_ip && + ((insn1 & SUBU_SP_MASK) == SUBU_SP_INSN)) /* subu r31, r31, N */ + { + sp_offset = -SUBU_OFFSET (insn1); + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + } + + /* The function must start with a stack-pointer adjustment, or + we don't know WHAT'S going on... */ + if (sp_offset == -1) + return ip; + + /* Accept zero or more instances of "st rx,sp,n" or "st.d rx,sp,n". + This may cause us to mistake the copying of a register + parameter to the frame for the saving of a callee-saved + register, but that can't be helped, since with the + "-fcall-saved" flag, any register can be made callee-saved. + This probably doesn't matter, since the ``saved'' caller's values of + non-callee-saved registers are not relevant anyway. */ + +#define STD_STACK_INSN 0x201f0000 +#define STD_STACK_MASK 0xfc1f0000 +#define ST_STACK_INSN 0x241f0000 +#define ST_STACK_MASK 0xfc1f0000 +#define ST_OFFSET(x) ((unsigned)((x) & 0xFFFF)) +#define ST_SRC(x) EXTRACT_FIELD ((x), 21, 5) + + while (next_ip) + { + if ((insn1 & ST_STACK_MASK) == ST_STACK_INSN) + size = 1; + else if ((insn1 & STD_STACK_MASK) == STD_STACK_INSN) + size = 2; + else + break; + + src = ST_SRC (insn1); + offset = ST_OFFSET (insn1); + while (size--) + { + must_adjust[src] = 1; + fsr->regs[src++] = offset; /* Will be adjusted later */ + offset += 4; + } + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + } + + /* Accept an optional "addu r30,r31,n" to set up the frame pointer. */ + +#define ADDU_FP_INSN 0x63df0000 +#define ADDU_FP_MASK 0xffff0000 +#define ADDU_OFFSET(x) ((unsigned)(x & 0xFFFF)) + if (next_ip && + ((insn1 & ADDU_FP_MASK) == ADDU_FP_INSN)) /* addu r30, r31, N */ + { + fp_offset = ADDU_OFFSET (insn1); + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + } + + /* Accept the PIC prologue code if present. */ + + pcode = pic_prologue_code; + size = sizeof (pic_prologue_code) / sizeof (*pic_prologue_code); + /* If return addr is saved, we don't use first or last insn of PICstuff. */ + if (fsr->regs[SRP_REGNUM]) { + pcode++; + size-=2; + } + + while (size-- && next_ip && (pcode->insn == (pcode->mask & insn1))) + { + pcode++; + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + } + + /* We're done with the prologue. If we don't care about the stack + frame itself, just return. (Note that fsr->regs has been trashed, + but the one caller who calls with fi==0 passes a dummy there.) */ + + if (fi == 0) + return ip; + + /* OK, now we have: + sp_offset original negative displacement of SP + fp_offset positive displacement between new SP and new FP, or -1 + fsr->regs[0..31] offset from original SP where reg is stored + must_adjust[0..31] set if corresp. offset was set + + The current SP (frame_sp) might not be the original new SP as set + by the function prologue, if alloca has been called. This can + only occur if fp_offset is set, though (the compiler allocates an + FP when it sees alloca). In that case, we have the FP, + and can calculate the original new SP from the FP. + + Then, we figure out where the arguments and locals are, and + relocate the offsets in fsr->regs to absolute addresses. */ + + if (fp_offset != -1) { + /* We have a frame pointer, so get it, and base our calc's on it. */ + frame_fp = (CORE_ADDR) read_next_frame_reg (fi->next, FP_REGNUM); + frame_sp = frame_fp - fp_offset; + } else { + /* We have no frame pointer, therefore frame_sp is still the same value + as set by prologue. But where is the frame itself? */ + if (must_adjust[SRP_REGNUM]) { + /* Function header saved SRP (r1), the return address. Frame starts + 4 bytes down from where it was saved. */ + frame_fp = frame_sp + fsr->regs[SRP_REGNUM] - 4; + fi->locals_pointer = frame_fp; + } else { + /* Function header didn't save SRP (r1), so we are in a leaf fn or + are otherwise confused. */ + frame_fp = -1; + } + } + + /* The locals are relative to the FP (whether it exists as an allocated + register, or just as an assumed offset from the SP) */ + fi->locals_pointer = frame_fp; + + /* The arguments are just above the SP as it was before we adjusted it + on entry. */ + fi->args_pointer = frame_sp - sp_offset; + + /* Now that we know the SP value used by the prologue, we know where + it saved all the registers. */ + for (src = 0; src < 32; src++) + if (must_adjust[src]) + fsr->regs[src] += frame_sp; + + /* The saved value of the SP is always known. */ + /* (we hope...) */ + if (fsr->regs[SP_REGNUM] != 0 + && fsr->regs[SP_REGNUM] != frame_sp - sp_offset) + fprintf(stderr, "Bad saved SP value %x != %x, offset %x!\n", + fsr->regs[SP_REGNUM], + frame_sp - sp_offset, sp_offset); + + fsr->regs[SP_REGNUM] = frame_sp - sp_offset; + return (ip); +} -/* Determine frame base for this file's frames. This will be either - the CFA or the old style FP_REGNUM; the symtab for the current pc's - file has the information */ +/* Given an ip value corresponding to the start of a function, + return the ip of the first instruction after the function + prologue. */ CORE_ADDR -get_frame_base(pc) -CORE_ADDR pc; +skip_prologue (ip) + CORE_ADDR (ip); { - struct symtab *this_file = find_pc_symtab(pc); - int coffsem_frame_position; - - /* If this_file is null, there's a good chance the file was compiled - without -g. If that's the case, use CFA (canonical frame addr) - as the default frame pointer. */ + struct frame_saved_regs saved_regs_dummy; + struct symtab_and_line sal; + CORE_ADDR limit; - if (this_file) + sal = find_pc_line (ip, 0); + limit = (sal.end) ? sal.end : 0xffffffff; + + return (examine_prologue (ip, limit, (FRAME_ADDR) 0, &saved_regs_dummy, + (struct frame_info *)0 )); +} + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. + + We cache the result of doing this in the frame_cache_obstack, since + it is fairly expensive. */ + +void +frame_find_saved_regs (fi, fsr) + struct frame_info *fi; + struct frame_saved_regs *fsr; +{ + register CORE_ADDR next_addr; + register CORE_ADDR *saved_regs; + register int regnum; + register struct frame_saved_regs *cache_fsr; + extern struct obstack frame_cache_obstack; + CORE_ADDR ip; + struct symtab_and_line sal; + CORE_ADDR limit; + + if (!fi->fsr) { - coffsem_frame_position = this_file->coffsem & 3; - if (coffsem_frame_position == 1) - return (CORE_ADDR) dc_general_register (current_context, FP_REGNUM); - else - /* default is CFA, as well as if coffsem==2 */ - return (CORE_ADDR) dc_frame_address (current_context); + cache_fsr = (struct frame_saved_regs *) + obstack_alloc (&frame_cache_obstack, + sizeof (struct frame_saved_regs)); + bzero (cache_fsr, sizeof (struct frame_saved_regs)); + fi->fsr = cache_fsr; + + /* Find the start and end of the function prologue. If the PC + is in the function prologue, we only consider the part that + has executed already. */ + + ip = get_pc_function_start (fi->pc); + sal = find_pc_line (ip, 0); + limit = (sal.end && sal.end < fi->pc) ? sal.end: fi->pc; + + /* This will fill in fields in *fi as well as in cache_fsr. */ + examine_prologue (ip, limit, fi->frame, cache_fsr, fi); } - return (CORE_ADDR) dc_frame_address (current_context); + if (fsr) + *fsr = *fi->fsr; +} + +/* Return the address of the locals block for the frame + described by FI. Returns 0 if the address is unknown. + NOTE! Frame locals are referred to by negative offsets from the + argument pointer, so this is the same as frame_args_address(). */ + +CORE_ADDR +frame_locals_address (fi) + struct frame_info *fi; +{ + register FRAME frame; + struct frame_saved_regs fsr; + CORE_ADDR ap; + + if (fi->args_pointer) /* Cached value is likely there. */ + return fi->args_pointer; + + /* Nope, generate it. */ + + get_frame_saved_regs (fi, &fsr); + + return fi->args_pointer; +} + +/* Return the address of the argument block for the frame + described by FI. Returns 0 if the address is unknown. */ + +CORE_ADDR +frame_args_address (fi) + struct frame_info *fi; +{ + register FRAME frame; + struct frame_saved_regs fsr; + CORE_ADDR ap; + + if (fi->args_pointer) /* Cached value is likely there. */ + return fi->args_pointer; + + /* Nope, generate it. */ + + get_frame_saved_regs (fi, &fsr); + + return fi->args_pointer; +} + +/* Return the saved PC from this frame. + + If the frame has a memory copy of SRP_REGNUM, use that. If not, + just use the register SRP_REGNUM itself. */ + +CORE_ADDR +frame_saved_pc (frame) + FRAME frame; +{ + return read_next_frame_reg(frame, SRP_REGNUM); } + #if TARGET_BYTE_ORDER != HOST_BYTE_ORDER you lose #else /* Host and target byte order the same. */ @@ -210,34 +555,6 @@ IEEE_isNAN(fp, len) } #endif /* Host and target byte order the same. */ -#define FIRST_PRESERVED_REGNUM 14 -#define LAST_PRESERVED_REGNUM 25 -#define FIRST_PARM_REGNUM 2 -#define LAST_PARM_REGNUM 9 - -#define MAX_REG_PARMS (LAST_PARM_REGNUM - FIRST_PARM_REGNUM + 1) - -void -frame_find_saved_regs (fi, fsr) - struct frame_info *fi; - struct frame_saved_regs *fsr; -{ - register int regnum; - - error ("Feature not implemented for the 88k yet."); - return; - -#if 0 - for (regnum = FIRST_PARM_REGNUM; regnum <= LAST_PARM_REGNUM; regnum++) - fsr->regs[regnum] - = (unsigned) fi->frame - ((regnum - FIRST_PARM_REGNUM) * 4); - - fsr->regs[SP_REGNUM] = 0; /* SP not saved in frames */ - fsr->regs[FP_REGNUM] = fi->frame; - fsr->regs[PC_REGNUM] = fi->frame + 4; -#endif -} - static int pushed_size (prev_words, v) int prev_words; @@ -357,13 +674,15 @@ store_parm (prev_words, left_parm_addr, v) end up storing *all* parameter values onto the stack (even if we will realize later that some of these stores were unnecessary). */ +#define FIRST_PARM_REGNUM 2 + void push_parameters (return_type, struct_conv, nargs, args) struct type *return_type; int struct_conv; int nargs; value *args; - { +{ int parm_num; unsigned int p_words = 0; CORE_ADDR left_parm_addr; @@ -445,20 +764,20 @@ pop_frame () return; } - void - collect_returned_value (rval, value_type, struct_return, nargs, args) - value *rval; - struct type *value_type; - int struct_return; - int nargs; - value *args; - { - char retbuf[REGISTER_BYTES]; - - bcopy (registers, retbuf, REGISTER_BYTES); - *rval = value_being_returned (value_type, retbuf, struct_return); - return; - } +void +collect_returned_value (rval, value_type, struct_return, nargs, args) + value *rval; + struct type *value_type; + int struct_return; + int nargs; + value *args; +{ + char retbuf[REGISTER_BYTES]; + + bcopy (registers, retbuf, REGISTER_BYTES); + *rval = value_being_returned (value_type, retbuf, struct_return); + return; +} #if 0 /* Now handled in a machine independent way with CALL_DUMMY_LOCATION. */ @@ -466,129 +785,39 @@ pop_frame () is not a good place for it). Return the address at which the instruction got stuffed, or zero if we were unable to stuff it anywhere. */ - CORE_ADDR - push_breakpoint () - { - static char breakpoint_insn[] = BREAKPOINT; - extern CORE_ADDR text_end; /* of inferior */ - static char readback_buffer[] = BREAKPOINT; - int i; - - /* With a little bit of luck, we can just stash the breakpoint instruction - in the word just beyond the end of normal text space. For systems on - which the hardware will not allow us to execute out of the stack segment, - we have to hope that we *are* at least allowed to effectively extend the - text segment by one word. If the actual end of user's the text segment - happens to fall right at a page boundary this trick may fail. Note that - we check for this by reading after writing, and comparing in order to - be sure that the write worked. */ - - write_memory (text_end, &breakpoint_insn, 4); - - /* Fill the readback buffer with some garbage which is certain to be - unequal to the breakpoint insn. That way we can tell if the - following read doesn't actually succeed. */ - - for (i = 0; i < sizeof (readback_buffer); i++) - readback_buffer[i] = ~ readback_buffer[i]; /* Invert the bits */ - - /* Now check that the breakpoint insn was successfully installed. */ - - read_memory (text_end, readback_buffer, sizeof (readback_buffer)); - for (i = 0; i < sizeof (readback_buffer); i++) - if (readback_buffer[i] != breakpoint_insn[i]) - return 0; /* Failed to install! */ +CORE_ADDR +push_breakpoint () +{ + static char breakpoint_insn[] = BREAKPOINT; + extern CORE_ADDR text_end; /* of inferior */ + static char readback_buffer[] = BREAKPOINT; + int i; - return text_end; - } -#endif + /* With a little bit of luck, we can just stash the breakpoint instruction + in the word just beyond the end of normal text space. For systems on + which the hardware will not allow us to execute out of the stack segment, + we have to hope that we *are* at least allowed to effectively extend the + text segment by one word. If the actual end of user's the text segment + happens to fall right at a page boundary this trick may fail. Note that + we check for this by reading after writing, and comparing in order to + be sure that the write worked. */ -/* Like dc_psr_register but takes an extra int arg. */ -static dc_word_t -psr_register (context, dummy) - dc_dcontext_t context; - int dummy; -{ - return dc_psr_register (context); -} + write_memory (text_end, &breakpoint_insn, 4); -/* Same functionality as get_saved_register in findvar.c, but implemented - to use tdesc. */ -void -get_saved_register (raw_buffer, optim, addrp, frame, regnum, lvalp) - char *raw_buffer; - int *optim; - CORE_ADDR *addrp; - FRAME frame; - int regnum; - enum lval_type *lvalp; -{ - struct frame_info *fi = get_frame_info (frame); - - /* Functions to say whether a register is optimized out, and - if not, to get the value. Take as args a context and the - value of get_reg_arg. */ - int (*get_reg_state) (); - dc_word_t (*get_reg) (); - int get_reg_arg; - - /* Because tdesc doesn't tell us whether it got it from a register - or memory, always say we don't have an address for it. */ - if (addrp != NULL) - *addrp = 0; - - if (regnum < DC_NUM_REG) - { - get_reg_state = dc_general_register_state; - get_reg = dc_general_register; - get_reg_arg = regnum; - } - else - { - get_reg_state = dc_auxiliary_register_state; - get_reg = dc_auxiliary_register; - switch (regnum) - { - case SXIP_REGNUM: - get_reg_arg = DC_AUX_SXIP; - break; - case SNIP_REGNUM: - get_reg_arg = DC_AUX_SNIP; - break; - case FPSR_REGNUM: - get_reg_arg = DC_AUX_FPSR; - break; - case FPCR_REGNUM: - get_reg_arg = DC_AUX_FPCR; - break; - case PSR_REGNUM: - get_reg_state = dc_psr_register_bit_state; - get_reg = psr_register; - get_reg_arg = 0; - break; - default: - if (optim != NULL) - *optim = 1; - return; - } - } + /* Fill the readback buffer with some garbage which is certain to be + unequal to the breakpoint insn. That way we can tell if the + following read doesn't actually succeed. */ - if ((*get_reg_state) (fi->frame_context, get_reg_arg)) - { - if (raw_buffer != NULL) - *(int *)raw_buffer = (*get_reg) (fi->frame_context, get_reg_arg); - if (optim != NULL) - *optim = 0; - return; - } - else - { - if (optim != NULL) - *optim = 1; - return; - } + for (i = 0; i < sizeof (readback_buffer); i++) + readback_buffer[i] = ~ readback_buffer[i]; /* Invert the bits */ + + /* Now check that the breakpoint insn was successfully installed. */ - /* Well, the caller can't treat it as a register or memory... */ - if (lvalp != NULL) - *lvalp = not_lval; + read_memory (text_end, readback_buffer, sizeof (readback_buffer)); + for (i = 0; i < sizeof (readback_buffer); i++) + if (readback_buffer[i] != breakpoint_insn[i]) + return 0; /* Failed to install! */ + + return text_end; } +#endif diff --git a/gdb/tdesc.c b/gdb/tdesc.c index 9a632e3..4a38649 100755 --- a/gdb/tdesc.c +++ b/gdb/tdesc.c @@ -235,11 +235,11 @@ int dc_compare_tdesc_elems (elem1, elem2) s1 = ((tdesc_elem_t *) elem1)->start_address; s2 = ((tdesc_elem_t *) elem2)->start_address; if (s1 < s2) return -1; - if (s1 > s2) return +1; + if (s1 > s2) return 1; e1 = ((tdesc_elem_t *) elem1)->end_address; e2 = ((tdesc_elem_t *) elem2)->end_address; if (e1 < e2) return -1; - if (e1 > e2) return +1; + if (e1 > e2) return 1; return 0; } diff --git a/gdb/tm-delta88.h b/gdb/tm-delta88.h index c0ffb4c..eacac69 100644 --- a/gdb/tm-delta88.h +++ b/gdb/tm-delta88.h @@ -18,81 +18,33 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* g++ support is not yet included. */ -#include "tdesc.h" +#define TARGET_BYTE_ORDER BIG_ENDIAN +/* We cache information about saved registers in the frame structure, + to save us from having to re-scan function prologues every time + a register in a non-current frame is accessed. */ -#define TARGET_BYTE_ORDER BIG_ENDIAN +#define EXTRA_FRAME_INFO \ + struct frame_saved_regs *fsr; \ + CORE_ADDR locals_pointer; \ + CORE_ADDR args_pointer; + +/* Zero the frame_saved_regs pointer when the frame is initialized, + so that FRAME_FIND_SAVED_REGS () will know to allocate and + initialize a frame_saved_regs struct the first time it is called. + Set the arg_pointer to -1, which is not valid; 0 and other values + indicate real, cached values. */ -#define EXTRA_SYMTAB_INFO int coffsem; - -/* This is not a CREATE_INFERIOR_HOOK because it also applies to - remote debugging. */ -#define START_INFERIOR_HOOK() \ - { \ - extern int safe_to_init_tdesc_context; \ - extern dc_handle_t tdesc_handle; \ - \ - safe_to_init_tdesc_context = 0; \ - if (tdesc_handle) \ - { \ - dc_terminate (tdesc_handle); \ - tdesc_handle = 0; \ - } \ - } - -dc_dcontext_t get_prev_context (); -extern int stack_error; - -#define EXTRA_FRAME_INFO dc_dcontext_t frame_context; -#define INIT_EXTRA_FRAME_INFO(fromleaf, fci) \ - { \ - if (fci->next_frame != NULL) \ - { \ - extern jmp_buf stack_jmp; \ - struct frame_info *next_frame = fci->next; \ - /* The call to get_prev_context */ \ - /* will update current_context for us. */ \ - stack_error = 1; \ - if (!setjmp (stack_jmp)) \ - { \ - fci->frame_context \ - = get_prev_context (next_frame->frame_context); \ - stack_error = 0; \ - } \ - else \ - { \ - stack_error = 0; \ - next_frame->prev = 0; \ - return 0; \ - } \ - if (!fci->frame_context) \ - { \ - next_frame->prev = 0; \ - return 0; \ - } \ - } \ - else \ - { \ - /* We are creating an arbitrary frame */ \ - /* (i.e. we are in create_new_frame). */ \ - extern dc_dcontext_t current_context; \ - \ - fci->frame_context = current_context; \ - } \ - } +#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \ + init_extra_frame_info (fromleaf, fi) +extern void init_extra_frame_info (); #define INIT_FRAME_PC(fromleaf, prev) \ - { \ - prev->pc = dc_location (prev->frame_context); \ - prev->frame = get_frame_base (prev->pc); \ - } + init_frame_pc (fromleaf, prev) +extern void init_frame_pc (); #define IEEE_FLOAT -/* Text Description (TDESC) is used by m88k to maintain stack & reg info */ - -#define TDESC - /* Define this if the C compiler puts an underscore at the front of external names before giving them to the linker. */ @@ -110,7 +62,9 @@ extern int stack_error; /* Advance PC across any function entry prologue instructions to reach some "real" code. */ -#define SKIP_PROLOGUE(frompc) 0 +#define SKIP_PROLOGUE(frompc) \ + skip_prologue (frompc) +extern CORE_ADDR skip_prologue (); /* The m88k kernel aligns all instructions on 4-byte boundaries. The kernel also uses the least significant two bits for its own hocus @@ -128,25 +82,9 @@ extern int stack_error; some instructions. */ #define SAVED_PC_AFTER_CALL(frame) \ - (read_register (SRP_REGNUM) & (~3)) - -/* Address of end of stack space. */ - -#define STACK_END_ADDR 0xF0000000 - -/* Stack grows downward. */ - -#define INNER_THAN < + (ADDR_BITS_REMOVE (read_register (SRP_REGNUM))) -/* Sequence of bytes for breakpoint instruction. */ - -/* instruction 0xF000D1FF is 'tb0 0,r0,511' - If Bit bit 0 of r0 is clear (always true), - initiate exception processing (trap). - */ -#define BREAKPOINT {0xF0, 0x00, 0xD1, 0xFF} - -/* Address of end of stack space. */ +/* Address of end of stack space (in core files). */ #define STACK_END_ADDR 0xF0000000 @@ -174,7 +112,7 @@ extern int stack_error; #define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0xF800) /* Return 1 if P points to an invalid floating point value. - LEN is the length in bytes -- not relevant on the 386. */ + LEN is the length in bytes. */ #define INVALID_FLOAT(p, len) IEEE_isNAN(p,len) @@ -266,7 +204,7 @@ extern int stack_error; #define SRP_REGNUM 1 /* Contains subroutine return pointer */ #define RV_REGNUM 2 /* Contains simple return values */ #define SRA_REGNUM 12 /* Contains address of struct return values */ -#define FP_REGNUM 30 /* Contains address of executing stack frame */ +#define FP_REGNUM 31 /* Reg fetched to locate frame when pgm stops */ #define SP_REGNUM 31 /* Contains address of top of stack */ #define SXIP_REGNUM 35 /* Contains Shadow Execute Instruction Pointer */ #define SNIP_REGNUM 36 /* Contains Shadow Next Instruction Pointer */ @@ -377,9 +315,6 @@ extern int stack_error; #define BELIEVE_PCC_PROMOTION 1 -/* We provide our own get_saved_register in m88k-tdep.c. */ -#define GET_SAVED_REGISTER - /* Describe the pointer in each stack frame to the previous stack frame (its caller). */ @@ -393,22 +328,36 @@ extern int stack_error; it means the given frame is the outermost one and has no caller. In that case, FRAME_CHAIN_COMBINE is not used. */ -/* These are just dummies for the 88k because INIT_FRAME_PC sets prev->frame - instead. */ +extern CORE_ADDR frame_chain (); +extern int frame_chain_valid (); +extern CORE_ADDR frame_chain_combine (); +extern int frameless_function_invocation (); + +#define FRAME_CHAIN(thisframe) \ + frame_chain (thisframe) -#define FRAME_CHAIN(thisframe) (0) +#define FRAME_CHAIN_VALID(chain, thisframe) \ + frame_chain_valid (chain, thisframe) -#define FRAME_CHAIN_VALID(chain, thisframe) (1) +#define FRAME_CHAIN_COMBINE(chain, thisframe) \ + frame_chain_combine (chain, thisframe) -#define FRAME_CHAIN_COMBINE(chain, thisframe) (0) +#define FRAMELESS_FUNCTION_INVOCATION(frame, fromleaf) \ + fromleaf = frameless_function_invocation (frame) /* Define other aspects of the stack frame. */ -#define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->frame+4, 4)) +#define FRAME_SAVED_PC(FRAME) \ + frame_saved_pc (FRAME) +extern CORE_ADDR frame_saved_pc (); -#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame) +#define FRAME_ARGS_ADDRESS(fi) \ + frame_args_address (fi) +extern CORE_ADDR frame_args_address (); -#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) +#define FRAME_LOCALS_ADDRESS(fi) \ + frame_locals_address (fi) +extern CORE_ADDR frame_locals_address (); /* Return number of args passed to a frame. Can return -1, meaning no way to tell. */ diff --git a/gdb/xm-m88k.h b/gdb/xm-m88k.h index ca89386..bcfc23e 100644 --- a/gdb/xm-m88k.h +++ b/gdb/xm-m88k.h @@ -1,4 +1,5 @@ -/* Copyright (C) 1986, 1987, 1988, 1989, 1990 Free Software Foundation, Inc. +/* Host-machine dependent parameters for Motorola 88000, for GDB. + Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc. This file is part of GDB. @@ -25,18 +26,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #if !defined (USG) #define USG 1 #endif -/* DGUX has bcopy(), etc. */ -#define USG_UTILS 0 #include <sys/param.h> -#define vfork() fork() -#define index strchr -#define rindex strrchr -#define getwd(BUF) getcwd(BUF,MAXPATHLEN); -#define bzero(ptr,count) (memset((ptr),0,(count))) -#define bcopy(src,dst,count) (memcpy((dst),(src),(count))) -#define bcmp(left,right,count) (memcmp((right),(left),(count))) #ifdef __GNUC__ #define memcpy __builtin_memcpy /* gcc doesn't have this, at least not gcc 1.92. */ @@ -86,43 +78,3 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #define HAVE_WAIT_STRUCT #define FETCH_INFERIOR_REGISTERS - -/* Interface definitions for kernel debugger KDB. */ - -/* Map machine fault codes into signal numbers. - First subtract 0, divide by 4, then index in a table. - Faults for which the entry in this table is 0 - are not handled by KDB; the program's own trap handler - gets to handle then. */ - -#define FAULT_CODE_ORIGIN 0 -#define FAULT_CODE_UNITS 4 -#define FAULT_TABLE \ -{ 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0} - -/* Start running with a stack stretching from BEG to END. - BEG and END should be symbols meaningful to the assembler. - This is used only for kdb. */ - -#define INIT_STACK(beg, end) {} - -/* Push the frame pointer register on the stack. */ -#define PUSH_FRAME_PTR {} - -/* Copy the top-of-stack to the frame pointer register. */ -#define POP_FRAME_PTR {} - -/* After KDB is entered by a fault, push all registers - that GDB thinks about (all NUM_REGS of them), - so that they appear in order of ascending GDB register number. - The fault code will be on the stack beyond the last register. */ - -#define PUSH_REGISTERS {} - -/* Assuming the registers (including processor status) have been - pushed on the stack in order of ascending GDB register number, - restore them and return to the address in the saved PC register. */ - -#define POP_REGISTERS {} |