/* Copyright (C) 1988, 1990 Free Software Foundation, Inc. This file is part of GDB. GDB is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. GDB is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GDB; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include "defs.h" #include "param.h" #include "frame.h" #include "inferior.h" #include "value.h" #ifdef USG #include #endif #include #include #include #include "gdbcore.h" #include #ifndef USER /* added to support BCS ptrace_user */ #define USER ptrace_user #endif #include #include #ifdef COFF_ENCAPSULATE #include "a.out.encap.h" #else #include #endif #include #include #include "symtab.h" #include "setjmp.h" #include "value.h" int stack_error; jmp_buf stack_jmp; void tdesc_error_function (environment, continuable, message) dc_word_t environment; dc_boolean_t continuable; char *message; { if (stack_error) longjmp (stack_jmp, 1); if (!continuable) { printf("%s\n",message); abort(); } } void tdesc_read_function (environment, memory, length, buffer) dc_word_t environment; dc_word_t memory; int length; char *buffer; { 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 else read_memory (memory, buffer, length); } /* 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 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; } dc_handle_t tdesc_handle; extern int debug_info; void init_tdesc () { 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 */ dc_dcontext_t init_dcontext() { 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); } dc_dcontext_t get_prev_context (context) dc_dcontext_t context; { return current_context = dc_previous_dcontext (context); } /* 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 */ CORE_ADDR get_frame_base(pc) CORE_ADDR pc; { 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. */ if (this_file) { 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); } return (CORE_ADDR) dc_frame_address (current_context); } #if TARGET_BYTE_ORDER != HOST_BYTE_ORDER you lose #else /* Host and target byte order the same. */ #define SINGLE_EXP_BITS 8 #define DOUBLE_EXP_BITS 11 int IEEE_isNAN(fp, len) int *fp, len; /* fp points to a single precision OR double precision * floating point value; len is the number of bytes, either 4 or 8. * Returns 1 iff fp points to a valid IEEE floating point number. * Returns 0 if fp points to a denormalized number or a NaN */ { int exponent; if (len == 4) { exponent = *fp; exponent = exponent << 1 >> (32 - SINGLE_EXP_BITS - 1); return ((exponent == -1) || (! exponent && *fp)); } else if (len == 8) { exponent = *(fp+1); exponent = exponent << 1 >> (32 - DOUBLE_EXP_BITS - 1); return ((exponent == -1) || (! exponent && *fp * *(fp+1))); } else return 1; } #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; struct value *v; { switch (TYPE_CODE (VALUE_TYPE (v))) { case TYPE_CODE_VOID: /* Void type (values zero length) */ return 0; /* That was easy! */ case TYPE_CODE_PTR: /* Pointer type */ case TYPE_CODE_ENUM: /* Enumeration type */ case TYPE_CODE_INT: /* Integer type */ case TYPE_CODE_REF: /* C++ Reference types */ case TYPE_CODE_ARRAY: /* Array type, lower bound zero */ return 1; case TYPE_CODE_FLT: /* Floating type */ if (TYPE_LENGTH (VALUE_TYPE (v)) == 4) return 1; else /* Assume that it must be a double. */ if (prev_words & 1) /* at an odd-word boundary */ return 3; /* round to 8-byte boundary */ else return 2; case TYPE_CODE_STRUCT: /* C struct or Pascal record */ case TYPE_CODE_UNION: /* C union or Pascal variant part */ return (((TYPE_LENGTH (VALUE_TYPE (v)) + 3) / 4) * 4); case TYPE_CODE_FUNC: /* Function type */ case TYPE_CODE_SET: /* Pascal sets */ case TYPE_CODE_RANGE: /* Range (integers within bounds) */ case TYPE_CODE_PASCAL_ARRAY: /* Array with explicit type of index */ case TYPE_CODE_MEMBER: /* Member type */ case TYPE_CODE_METHOD: /* Method type */ /* Don't know how to pass these yet. */ case TYPE_CODE_UNDEF: /* Not used; catches errors */ default: abort (); } } static void store_parm_word (address, val) CORE_ADDR address; int val; { write_memory (address, &val, 4); } static int store_parm (prev_words, left_parm_addr, v) unsigned int prev_words; CORE_ADDR left_parm_addr; struct value *v; { CORE_ADDR start = left_parm_addr + (prev_words * 4); int *val_addr = (int *)VALUE_CONTENTS(v); switch (TYPE_CODE (VALUE_TYPE (v))) { case TYPE_CODE_VOID: /* Void type (values zero length) */ return 0; case TYPE_CODE_PTR: /* Pointer type */ case TYPE_CODE_ENUM: /* Enumeration type */ case TYPE_CODE_INT: /* Integer type */ case TYPE_CODE_ARRAY: /* Array type, lower bound zero */ case TYPE_CODE_REF: /* C++ Reference types */ store_parm_word (start, *val_addr); return 1; case TYPE_CODE_FLT: /* Floating type */ if (TYPE_LENGTH (VALUE_TYPE (v)) == 4) { store_parm_word (start, *val_addr); return 1; } else { store_parm_word (start + ((prev_words & 1) * 4), val_addr[0]); store_parm_word (start + ((prev_words & 1) * 4) + 4, val_addr[1]); return 2 + (prev_words & 1); } case TYPE_CODE_STRUCT: /* C struct or Pascal record */ case TYPE_CODE_UNION: /* C union or Pascal variant part */ { unsigned int words = (((TYPE_LENGTH (VALUE_TYPE (v)) + 3) / 4) * 4); unsigned int word; for (word = 0; word < words; word++) store_parm_word (start + (word * 4), val_addr[word]); return words; } default: abort (); } } /* This routine sets up all of the parameter values needed to make a pseudo call. The name "push_parameters" is a misnomer on some archs, because (on the m88k) most parameters generally end up being passed in registers rather than on the stack. In this routine however, we do end up storing *all* parameter values onto the stack (even if we will realize later that some of these stores were unnecessary). */ 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; /* Start out by creating a space for the return value (if need be). We only need to do this if the return value is a struct or union. If we do make a space for a struct or union return value, then we must also arrange for the base address of that space to go into r12, which is the standard place to pass the address of the return value area to the callee. Note that only structs and unions are returned in this fashion. Ints, enums, pointers, and floats are returned into r2. Doubles are returned into the register pair {r2,r3}. Note also that the space reserved for a struct or union return value only has to be word aligned (not double-word) but it is double-word aligned here anyway (just in case that becomes important someday). */ switch (TYPE_CODE (return_type)) { case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: { int return_bytes = ((TYPE_LENGTH (return_type) + 7) / 8) * 8; CORE_ADDR rv_addr; rv_addr = read_register (SP_REGNUM) - return_bytes; write_register (SP_REGNUM, rv_addr); /* push space onto the stack */ write_register (SRA_REGNUM, rv_addr);/* set return value register */ } } /* Here we make a pre-pass on the whole parameter list to figure out exactly how many words worth of stuff we are going to pass. */ for (p_words = 0, parm_num = 0; parm_num < nargs; parm_num++) p_words += pushed_size (p_words, value_arg_coerce (args[parm_num])); /* Now, check to see if we have to round up the number of parameter words to get up to the next 8-bytes boundary. This may be necessary because of the software convention to always keep the stack aligned on an 8-byte boundary. */ if (p_words & 1) p_words++; /* round to 8-byte boundary */ /* Now figure out the absolute address of the leftmost parameter, and update the stack pointer to point at that address. */ left_parm_addr = read_register (SP_REGNUM) - (p_words * 4); write_register (SP_REGNUM, left_parm_addr); /* Now we can go through all of the parameters (in left-to-right order) and write them to their parameter stack slots. Note that we are not really "pushing" the parameter values. The stack space for these values was already allocated above. Now we are just filling it up. */ for (p_words = 0, parm_num = 0; parm_num < nargs; parm_num++) p_words += store_parm (p_words, left_parm_addr, value_arg_coerce (args[parm_num])); /* Now that we are all done storing the parameter values into the stack, we must go back and load up the parameter registers with the values from the corresponding stack slots. Note that in the two cases of (a) gaps in the parameter word sequence causes by (otherwise) misaligned doubles, and (b) slots correcponding to structs or unions, the work we do here in loading some parameter registers may be unnecessary, but who cares? */ for (p_words = 0; p_words < 8; p_words++) { write_register (FIRST_PARM_REGNUM + p_words, read_memory_integer (left_parm_addr + (p_words * 4), 4)); } } void pop_frame () { error ("Feature not implemented for the m88k yet."); 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. */ /* Stuff a breakpoint instruction onto the stack (or elsewhere if the stack 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! */ return text_end; } #endif /* 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); } /* 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; } } 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; } /* Well, the caller can't treat it as a register or memory... */ if (lvalp != NULL) *lvalp = not_lval; }