diff options
| -rw-r--r-- | gdb/ChangeLog | 5 | ||||
| -rw-r--r-- | gdb/config/tic80/tm-tic80.h | 87 | ||||
| -rw-r--r-- | gdb/tic80-tdep.c | 463 |
3 files changed, 504 insertions, 51 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 11561e4..aa83c63 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,8 @@ +Mon May 12 11:35:04 1997 Mark Alexander <marka@cygnus.com> + + * tic80-tdep.c, config/tic80/tm-tic80.h: First cut at getting + basic C80 features working. + Thu May 8 08:42:47 1997 Andrew Cagney <cagney@b1.cygnus.com> * configure.in (AC_TYPE_SIGNAL): Add diff --git a/gdb/config/tic80/tm-tic80.h b/gdb/config/tic80/tm-tic80.h index cfaf1e1..6f670a0 100644 --- a/gdb/config/tic80/tm-tic80.h +++ b/gdb/config/tic80/tm-tic80.h @@ -51,7 +51,11 @@ struct frame_saved_regs; FIXME: Shadow updates in sim/tic80/sim-calls.c */ #define SP_REGNUM 1 /* Contains address of top of stack */ -#define FP_REGNUM 31 /* Contains address of executing stack frame */ +#define ARG0_REGNUM 2 /* Contains argument 1 (r3 has high word) */ +#define RET_REGNUM 2 /* Contains function return value */ +#define ARGLAST_REGNUM 12 /* Contains argument 6 (r13 has high word) */ +#define FP_REGNUM 30 /* Contains address of executing stack frame */ +#define LR_REGNUM 31 /* Contains address of caller (link register) */ #define PC_REGNUM 32 /* Contains program counter (FIXME?) */ #define NPC_REGNUM 33 /* Contains the next program counter (FIXME?) */ #define A0_REGNUM 34 /* Accumulator register 0 */ @@ -119,15 +123,10 @@ struct frame_saved_regs; #define DECR_PC_AFTER_BREAK 0 /* FIXME! */ -/* Push an empty stack frame, to record the current PC, etc. */ - -#define PUSH_DUMMY_FRAME tic80_push_dummy_frame() -extern void tic80_push_dummy_frame PARAMS ((void)); - /* Discard from the stack the innermost frame, restoring all registers. */ -#define POP_FRAME tic80_pop_frame() -extern void tic80_pop_frame PARAMS ((void)); +#define POP_FRAME tic80_pop_frame(get_current_frame ()) +extern struct frame_info *tic80_pop_frame PARAMS ((struct frame_info *frame)); /* Return number of bytes at start of arglist that are not really args. */ @@ -143,6 +142,22 @@ extern void tic80_pop_frame PARAMS ((void)); #define FRAME_ARGS_ADDRESS(fi) (fi)->frame #define FRAME_LOCALS_ADDRESS(fi) (fi)->frame +/* Define other aspects of the stack frame. + We keep the offsets of all saved registers, 'cause we need 'em a lot! + We also keep the current size of the stack frame, and the offset of + the frame pointer from the stack pointer (for frameless functions, and + when we're still in the prologue of a function with a frame) */ + +#define EXTRA_FRAME_INFO \ + struct frame_saved_regs fsr; \ + int framesize; \ + int frameoffset; \ + int framereg; + +extern void tic80_init_extra_frame_info PARAMS ((struct frame_info *fi)); +#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) tic80_init_extra_frame_info (fi) +#define INIT_FRAME_PC /* Not necessary */ + /* 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 @@ -164,8 +179,7 @@ extern CORE_ADDR tic80_skip_prologue PARAMS ((CORE_ADDR pc)); the new frame is not set up until the new function executes some instructions. */ -#define SAVED_PC_AFTER_CALL(frame) tic80_saved_pc_after_call(frame) -extern CORE_ADDR tic80_saved_pc_after_call PARAMS ((struct frame_info *)); +#define SAVED_PC_AFTER_CALL(frame) read_register (LR_REGNUM) /* Describe the pointer in each stack frame to the previous stack frame (its caller). */ @@ -179,19 +193,64 @@ extern CORE_ADDR tic80_frame_chain PARAMS ((struct frame_info *)); #define FRAME_SAVED_PC(FRAME) tic80_frame_saved_pc (FRAME) extern CORE_ADDR tic80_frame_saved_pc PARAMS ((struct frame_info *)); +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. + + We store structs through a pointer passed in R2 */ + +#define STORE_STRUCT_RETURN(STRUCT_ADDR, SP) \ + write_register (ARG0_REGNUM, STRUCT_ADDR) + /* Extract from an array REGBUF containing the (raw) register state a function return value of type TYPE, and copy that, in virtual format, into VALBUF. */ #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ - tic80_extract_return_value((TYPE), (REGBUF), (VALBUF)) -extern void tic80_extract_return_value PARAMS ((struct type *, char *, char *)); + memcpy ((VALBUF), \ + (char *)(REGBUF) + REGISTER_BYTE (RET_REGNUM) + \ + ((TYPE_LENGTH (TYPE) > 4 ? 8 : 4) - TYPE_LENGTH (TYPE)), \ + TYPE_LENGTH (TYPE)) /* Write into appropriate registers a function return value of type TYPE, given in virtual format. */ #define STORE_RETURN_VALUE(TYPE,VALBUF) \ - tic80_store_return_value((TYPE), (VALBUF)) -extern void tic80_store_return_value PARAMS ((struct type *, char *)); + write_register_bytes(REGISTER_BYTE (RET_REGNUM) + \ + ((TYPE_LENGTH (TYPE) > 4 ? 8:4) - TYPE_LENGTH (TYPE)),\ + (VALBUF), TYPE_LENGTH (TYPE)); + + + +/* PUSH_ARGUMENTS */ +extern CORE_ADDR tic80_push_arguments PARAMS ((int nargs, + struct value **args, + CORE_ADDR sp, + unsigned char struct_return, + CORE_ADDR struct_addr)); + +#define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \ + (SP) = tic80_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) + +/* PUSH_RETURN_ADDRESS */ +extern CORE_ADDR tic80_push_return_address PARAMS ((CORE_ADDR, CORE_ADDR)); +#define PUSH_RETURN_ADDRESS(PC, SP) tic80_push_return_address (PC, SP) + +/* override the standard get_saved_register function with + one that takes account of generic CALL_DUMMY frames */ +#define GET_SAVED_REGISTER + +#define USE_GENERIC_DUMMY_FRAMES +#define CALL_DUMMY {0} +#define CALL_DUMMY_LENGTH (0) +#define CALL_DUMMY_START_OFFSET (0) +#define CALL_DUMMY_BREAKPOINT_OFFSET (0) +#define FIX_CALL_DUMMY(DUMMY1, STARTADDR, FUNADDR, NARGS, ARGS, TYPE, GCCP) +#define CALL_DUMMY_LOCATION AT_ENTRY_POINT +#define CALL_DUMMY_ADDRESS() entry_point_address () + +/* generic dummy frame stuff */ + +#define PUSH_DUMMY_FRAME generic_push_dummy_frame () +#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP) #endif /* TM_TIC80_H */ diff --git a/gdb/tic80-tdep.c b/gdb/tic80-tdep.c index d43f25e..5d1cc64 100644 --- a/gdb/tic80-tdep.c +++ b/gdb/tic80-tdep.c @@ -1,6 +1,5 @@ -/* Target-dependent code for the TI TMS320C80 (MVP) architecture, - for GDB, the GNU Debugger. - Copyright 1997 Free Software Foundation, Inc. +/* Target-dependent code for the TI TMS320C80 (MVP) for GDB, the GNU debugger. + Copyright 1996, Free Software Foundation, Inc. This file is part of GDB. @@ -19,71 +18,461 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "defs.h" +#include "value.h" +#include "frame.h" +#include "inferior.h" +#include "obstack.h" +#include "target.h" +#include "bfd.h" +#include "gdb_string.h" +#include "gdbcore.h" +#include "symfile.h" + +/* Function: frame_find_saved_regs + Return the frame_saved_regs structure for the frame. + Doesn't really work for dummy frames, but it does pass back + an empty frame_saved_regs, so I guess that's better than total failure */ + +void +tic80_frame_find_saved_regs (fi, regaddr) + struct frame_info *fi; + struct frame_saved_regs *regaddr; +{ + memcpy (regaddr, &fi->fsr, sizeof (struct frame_saved_regs)); +} + +/* Function: skip_prologue + Find end of function prologue. */ CORE_ADDR tic80_skip_prologue (pc) CORE_ADDR pc; { - error ("tic80_skip_prologue not implemented"); + CORE_ADDR func_addr, func_end; + struct symtab_and_line sal; + + /* See what the symbol table says */ + + if (find_pc_partial_function (pc, NULL, &func_addr, &func_end)) + { + sal = find_pc_line (func_addr, 0); + + if (sal.line != 0 && sal.end < func_end) + return sal.end; + else + /* Either there's no line info, or the line after the prologue is after + the end of the function. In this case, there probably isn't a + prologue. */ + return pc; + } + + /* We can't find the start of this function, so there's nothing we can do. */ + return pc; +} + +/* Function: tic80_scan_prologue + This function decodes the target function prologue to determine: + 1) the size of the stack frame + 2) which registers are saved on it + 3) the offsets of saved regs + 4) the frame size + This information is stored in the "extra" fields of the frame_info. */ + +static void +tic80_scan_prologue (fi) + struct frame_info *fi; +{ + struct symtab_and_line sal; + CORE_ADDR prologue_start, prologue_end, current_pc; + + /* Assume there is no frame until proven otherwise. */ + fi->framereg = SP_REGNUM; + fi->framesize = 0; + fi->frameoffset = 0; + + /* this code essentially duplicates skip_prologue, + but we need the start address below. */ + + if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end)) + { + sal = find_pc_line (prologue_start, 0); + + if (sal.line == 0) /* no line info, use current PC */ + if (prologue_start != entry_point_address ()) + prologue_end = fi->pc; + else + return; /* _start has no frame or prologue */ + else if (sal.end < prologue_end) /* next line begins after fn end */ + prologue_end = sal.end; /* (probably means no prologue) */ + } + else +/* FIXME */ + prologue_end = prologue_start + 40; /* We're in the boondocks: allow for */ + /* 16 pushes, an add, and "mv fp,sp" */ + + prologue_end = min (prologue_end, fi->pc); + + /* Now search the prologue looking for instructions that set up the + frame pointer, adjust the stack pointer, and save registers. */ + + for (current_pc = prologue_start; current_pc < prologue_end; current_pc += 4) + { + unsigned int insn; + int regno; + int offset = 0; + + insn = read_memory_unsigned_integer (current_pc, 4); + + if ((insn & 0x301000) == 0x301000) /* Long immediate? */ +/* FIXME - set offset for long immediate instructions */ + current_pc += 4; + else + { + offset = insn & 0x7fff; /* extract 15-bit offset */ + if (offset & 0x4000) /* if negative, sign-extend */ + offset = -(0x8000 - offset); + } + + if ((insn & 0x7fd0000) == 0x590000) /* st.{w,d} reg, xx(r1) */ + { + regno = ((insn >> 27) & 0x1f); + fi->fsr.regs[regno] = offset; + if (insn & 0x8000) /* 64-bit store (st.d)? */ + fi->fsr.regs[regno+1] = offset+4; + } + else if ((insn & 0xffff8000) == 0x086c8000) /* addu xx, r1, r1 */ + fi->framesize = -offset; + else if ((insn & 0xffff8000) == 0xf06c8000) /* addu xx, r1, r30 */ + { + fi->framereg = FP_REGNUM; /* fp is now valid */ + fi->frameoffset = offset; + break; /* end of stack adjustments */ + } + else if (insn == 0xf03b2001) /* addu r1, r0, r30 */ + { + fi->framereg = FP_REGNUM; /* fp is now valid */ + fi->frameoffset = 0; + break; /* end of stack adjustments */ + } + else +/* FIXME - handle long immediate instructions */ + break; /* anything else isn't prologue */ + } +} + +/* Function: init_extra_frame_info + This function actually figures out the frame address for a given pc and + sp. This is tricky on the c80 because we sometimes don't use an explicit + frame pointer, and the previous stack pointer isn't necessarily recorded + on the stack. The only reliable way to get this info is to + examine the prologue. */ + +void +tic80_init_extra_frame_info (fi) + struct frame_info *fi; +{ + int reg; + + if (fi->next) + fi->pc = FRAME_SAVED_PC (fi->next); + + memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs); + + if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) + { + /* We need to setup fi->frame here because run_stack_dummy gets it wrong + by assuming it's always FP. */ + fi->frame = generic_read_register_dummy (fi->pc, fi->frame, SP_REGNUM); + fi->framesize = 0; + fi->frameoffset = 0; + return; + } + else + { + tic80_scan_prologue (fi); + + if (!fi->next) /* this is the innermost frame? */ + fi->frame = read_register (fi->framereg); + else /* not the innermost frame */ + if (fi->framereg == FP_REGNUM) /* we have an FP */ + if (fi->next->fsr.regs[FP_REGNUM] != 0) /* caller saved our FP */ + fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4); + for (reg = 0; reg < NUM_REGS; reg++) + if (fi->fsr.regs[reg] != 0) + fi->fsr.regs[reg] += fi->frame - fi->frameoffset; + } +} + +/* Function: find_callers_reg + Find REGNUM on the stack. Otherwise, it's in an active register. One thing + we might want to do here is to check REGNUM against the clobber mask, and + somehow flag it as invalid if it isn't saved on the stack somewhere. This + would provide a graceful failure mode when trying to get the value of + caller-saves registers for an inner frame. */ + +CORE_ADDR +tic80_find_callers_reg (fi, regnum) + struct frame_info *fi; + int regnum; +{ + for (; fi; fi = fi->next) + if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) + return generic_read_register_dummy (fi->pc, fi->frame, regnum); + else if (fi->fsr.regs[regnum] != 0) + return read_memory_integer (fi->fsr.regs[regnum], + REGISTER_RAW_SIZE(regnum)); + return read_register (regnum); } +/* Function: frame_chain + 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 c80, we save the frame size when we initialize the frame_info. */ + CORE_ADDR -tic80_frame_chain (finfo) - struct frame_info *finfo; +tic80_frame_chain (fi) + struct frame_info *fi; { - error ("tic80_frame_chain not implemented"); + CORE_ADDR fn_start, callers_pc, fp; + + /* is this a dummy frame? */ + if (PC_IN_CALL_DUMMY(fi->pc, fi->frame, fi->frame)) + return fi->frame; /* dummy frame same as caller's frame */ + + /* is caller-of-this a dummy frame? */ + callers_pc = FRAME_SAVED_PC(fi); /* find out who called us: */ + fp = tic80_find_callers_reg (fi, FP_REGNUM); + if (PC_IN_CALL_DUMMY(callers_pc, fp, fp)) + return fp; /* dummy frame's frame may bear no relation to ours */ + + if (find_pc_partial_function (fi->pc, 0, &fn_start, 0)) + if (fn_start == entry_point_address ()) + return 0; /* in _start fn, don't chain further */ + + if (fi->framereg == FP_REGNUM) + return tic80_find_callers_reg (fi, FP_REGNUM); + else + return fi->frame + fi->framesize; } +/* Function: pop_frame + Discard from the stack the innermost frame, + restoring all saved registers. */ + +struct frame_info * +tic80_pop_frame (frame) + struct frame_info *frame; +{ + int regnum; + + if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame)) + generic_pop_dummy_frame (); + else + { + for (regnum = 0; regnum < NUM_REGS; regnum++) + if (frame->fsr.regs[regnum] != 0) + write_register (regnum, + read_memory_integer (frame->fsr.regs[regnum], 4)); + + write_register (PC_REGNUM, FRAME_SAVED_PC (frame)); + write_register (SP_REGNUM, read_register (FP_REGNUM)); +#if 0 + if (read_register (PSW_REGNUM) & 0x80) + write_register (SPU_REGNUM, read_register (SP_REGNUM)); + else + write_register (SPI_REGNUM, read_register (SP_REGNUM)); +#endif + } + flush_cached_frames (); + return NULL; +} + +/* Function: frame_saved_pc + Find the caller of this frame. We do this by seeing if LR_REGNUM is saved + in the stack anywhere, otherwise we get it from the registers. */ + CORE_ADDR -tic80_frame_saved_pc (finfo) - struct frame_info *finfo; +tic80_frame_saved_pc (fi) + struct frame_info *fi; { - error ("tic80_frame_saved_pc not implemented"); + if (PC_IN_CALL_DUMMY(fi->pc, fi->frame, fi->frame)) + return generic_read_register_dummy(fi->pc, fi->frame, PC_REGNUM); + else + return tic80_find_callers_reg (fi, LR_REGNUM); } +/* Function: tic80_push_return_address (pc, sp) + Set up the return address for the inferior function call. + Necessary for targets that don't actually execute a JSR/BSR instruction + (ie. when using an empty CALL_DUMMY) */ + CORE_ADDR -tic80_saved_pc_after_call (finfo) - struct frame_info *finfo; +tic80_push_return_address (pc, sp) + CORE_ADDR pc; + CORE_ADDR sp; { - error ("tic80_saved_pc_after_call not implemented"); + write_register (LR_REGNUM, CALL_DUMMY_ADDRESS ()); + return sp; } -void -tic80_pop_frame () + +/* Function: push_arguments + Setup the function arguments for calling a function in the inferior. + + On the TI C80 architecture, there are six register pairs (R2/R3 to R12/13) + which are dedicated for passing function arguments. Up to the first six + arguments (depending on size) may go into these registers. + The rest go on the stack. + + Arguments that are smaller than 4 bytes will still take up a whole + register or a whole 32-bit word on the stack, and will be + right-justified in the register or the stack word. This includes + chars, shorts, and small aggregate types. + + Arguments that are four bytes or less in size are placed in the + even-numbered register of a register pair, and the odd-numbered + register is not used. + + Arguments of 8 bytes size (such as floating point doubles) are placed + in a register pair. The least significant 32-bit word is placed in + the even-numbered register, and the most significant word in the + odd-numbered register. + + Aggregate types with sizes between 4 and 8 bytes are passed + entirely on the stack, and are left-justified within the + double-word (as opposed to aggregates smaller than 4 bytes + which are right-justified). + + Aggregates of greater than 8 bytes are first copied onto the stack, + and then a pointer to the copy is passed in the place of the normal + argument (either in a register if available, or on the stack). + + Functions that must return an aggregate type can return it in the + normal return value registers (R2 and R3) if its size is 8 bytes or + less. For larger return values, the caller must allocate space for + the callee to copy the return value to. A pointer to this space is + passed as an implicit first argument, always in R0. */ + +CORE_ADDR +tic80_push_arguments (nargs, args, sp, struct_return, struct_addr) + int nargs; + value_ptr *args; + CORE_ADDR sp; + unsigned char struct_return; + CORE_ADDR struct_addr; { - error ("tic80_pop_frame not implemented"); + int stack_offset, stack_alloc; + int argreg; + int argnum; + struct type *type; + CORE_ADDR regval; + char *val; + char valbuf[4]; + int len; + int odd_sized_struct; + + /* first force sp to a 4-byte alignment */ + sp = sp & ~3; + + argreg = ARG0_REGNUM; + /* The "struct return pointer" pseudo-argument goes in R0 */ + if (struct_return) + write_register (argreg++, struct_addr); + + /* Now make sure there's space on the stack */ + for (argnum = 0, stack_alloc = 0; + argnum < nargs; argnum++) + stack_alloc += ((TYPE_LENGTH(VALUE_TYPE(args[argnum])) + 3) & ~3); + sp -= stack_alloc; /* make room on stack for args */ + + + /* Now load as many as possible of the first arguments into + registers, and push the rest onto the stack. There are 16 bytes + in four registers available. Loop thru args from first to last. */ + + argreg = ARG0_REGNUM; + for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++) + { + type = VALUE_TYPE (args[argnum]); + len = TYPE_LENGTH (type); + memset(valbuf, 0, sizeof(valbuf)); + val = (char *) VALUE_CONTENTS (args[argnum]); + if (len < 4) + { /* value gets right-justified in the register or stack word */ + memcpy(valbuf + (4 - len), val, len); + val = valbuf; + } + +/* FIXME -- tic80 can take doubleword arguments in register pairs */ + if (len > 4 && (len & 3) != 0) + odd_sized_struct = 1; /* such structs go entirely on stack */ + else + odd_sized_struct = 0; + while (len > 0) + { + if (argreg > ARGLAST_REGNUM || odd_sized_struct) + { /* must go on the stack */ + write_memory (sp + stack_offset, val, 4); + stack_offset += 4; + } + /* NOTE WELL!!!!! This is not an "else if" clause!!! + That's because some *&^%$ things get passed on the stack + AND in the registers! */ + if (argreg <= ARGLAST_REGNUM) + { /* there's room in a register */ + regval = extract_address (val, REGISTER_RAW_SIZE(argreg)); + write_register (argreg, regval); + argreg += 2; /* FIXME -- what about doubleword args? */ + } + /* Store the value 4 bytes at a time. This means that things + larger than 4 bytes may go partly in registers and partly + on the stack. */ + len -= REGISTER_RAW_SIZE(argreg); + val += REGISTER_RAW_SIZE(argreg); + } + } + return sp; } +/* Function: get_saved_register + Just call the generic_get_saved_register function. */ + void -tic80_store_return_value (valtype, valbuf) - struct type *valtype; - char *valbuf; +get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval) + char *raw_buffer; + int *optimized; + CORE_ADDR *addrp; + struct frame_info *frame; + int regnum; + enum lval_type *lval; { - error ("tic80_store_return_value not implemented"); + generic_get_saved_register (raw_buffer, optimized, addrp, + frame, regnum, lval); } -/* 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. */ +/* Function: tic80_write_sp + Because SP is really a read-only register that mirrors either SPU or SPI, + we must actually write one of those two as well, depending on PSW. */ void -tic80_frame_find_saved_regs (fi, fsr) - struct frame_info *fi; - struct frame_saved_regs *fsr; +tic80_write_sp (val) + CORE_ADDR val; { - error ("tic80_frame_find_saved_regs not implemented"); -} +#if 0 + unsigned long psw = read_register (PSW_REGNUM); -/* Given a return value in `regbuf' with a type `valtype', - extract and copy its value into `valbuf'. */ + if (psw & 0x80) /* stack mode: user or interrupt */ + write_register (SPU_REGNUM, val); + else + write_register (SPI_REGNUM, val); +#endif + write_register (SP_REGNUM, val); +} void -tic80_extract_return_value (valtype, regbuf, valbuf) - struct type *valtype; - char regbuf[REGISTER_BYTES]; - char *valbuf; +_initialize_tic80_tdep () { - error ("tic80_extract_return_value not implemented"); + tm_print_insn = print_insn_tic80; } + |