X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fcris-tdep.c;h=5911318266875aebd91d8755048a66548f43cd58;hb=54c7009d04fc3da51b50cfbefe5f5894db2cad32;hp=860286eb48e96d8b49a0c7eccf70452777d7ab1e;hpb=4caf0990c1ff56195c12538598d1a2c2623328c4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c index 860286eb48..5911318266 100644 --- a/gdb/cris-tdep.c +++ b/gdb/cris-tdep.c @@ -1,5 +1,5 @@ /* Target dependent code for CRIS, for GDB, the GNU debugger. - Copyright 2001 Free Software Foundation, Inc. + Copyright 2001, 2002, 2003 Free Software Foundation, Inc. Contributed by Axis Communications AB. Written by Hendrik Ruijter, Stefan Andersson, and Orjan Friberg. @@ -392,7 +392,7 @@ static CORE_ADDR bfd_lookup_symbol (bfd *, const char *); CORE_ADDR frame CORE_ADDR pc - int signal_handler_caller + enum frame_type type; CORE_ADDR return_pc int leaf_function @@ -405,8 +405,9 @@ static CORE_ADDR bfd_lookup_symbol (bfd *, const char *); of the register PC. All other frames contain the content of the register PC in the next frame. - The variable signal_handler_caller is non-zero when the frame is - associated with the call of a signal handler. + The variable `type' indicates the frame's type: normal, SIGTRAMP + (associated with a signal handler), dummy (associated with a dummy + frame). The variable return_pc contains the address where execution should be resumed when the present frame has finished, the return address. @@ -487,7 +488,7 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, short source_register; /* This frame is with respect to a leaf until a push srp is found. */ - fi->extra_info->leaf_function = 1; + get_frame_extra_info (fi)->leaf_function = 1; /* This frame is without the FP until a push fp is found. */ have_fp = 0; @@ -500,10 +501,10 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, /* We only want to know the end of the prologue when fi->saved_regs == 0. When the saved registers are allocated full information is required. */ - if (fi->saved_regs) + if (get_frame_saved_regs (fi)) { for (regno = 0; regno < NUM_REGS; regno++) - fi->saved_regs[regno] = 0; + get_frame_saved_regs (fi)[regno] = 0; } /* Find the prologue instructions. */ @@ -526,7 +527,7 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, { return ip; } - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->leaf_function = 0; } else if (regno == FP_REGNUM) { @@ -675,34 +676,34 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, /* We only want to know the end of the prologue when fi->saved_regs == 0. */ - if (!fi->saved_regs) + if (!get_frame_saved_regs (fi)) return ip; if (have_fp) { - fi->saved_regs[FP_REGNUM] = FRAME_FP (fi); + get_frame_saved_regs (fi)[FP_REGNUM] = get_frame_base (fi); /* Calculate the addresses. */ for (regno = regsave; regno >= 0; regno--) { - fi->saved_regs[regno] = FRAME_FP (fi) - val; + get_frame_saved_regs (fi)[regno] = get_frame_base (fi) - val; val -= 4; } - if (fi->extra_info->leaf_function) + if (get_frame_extra_info (fi)->leaf_function) { /* Set the register SP to contain the stack pointer of the caller. */ - fi->saved_regs[SP_REGNUM] = FRAME_FP (fi) + 4; + get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 4; } else { /* Set the register SP to contain the stack pointer of the caller. */ - fi->saved_regs[SP_REGNUM] = FRAME_FP (fi) + 8; + get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 8; /* Set the register SRP to contain the return address of the caller. */ - fi->saved_regs[SRP_REGNUM] = FRAME_FP (fi) + 4; + get_frame_saved_regs (fi)[SRP_REGNUM] = get_frame_base (fi) + 4; } } return ip; @@ -733,17 +734,15 @@ cris_skip_prologue_frameless_p (CORE_ADDR pc) CORE_ADDR cris_skip_prologue_main (CORE_ADDR pc, int frameless_p) { - struct frame_info fi; - static struct frame_extra_info fei; + struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); + struct frame_info *fi; struct symtab_and_line sal = find_pc_line (pc, 0); int best_limit; CORE_ADDR pc_after_prologue; - /* frame_info now contains dynamic memory. Since fi is a dummy here, - I use static memory for extra_info, and don't bother allocating - memory for saved_regs. */ - fi.saved_regs = 0; - fi.extra_info = &fei; + /* frame_info now contains dynamic memory. Since fi is a dummy + here, I don't bother allocating memory for saved_regs. */ + fi = deprecated_frame_xmalloc_with_cleanup (0, sizeof (struct frame_extra_info)); /* If there is no symbol information then sal.end == 0, and we end up examining only the first instruction in the function prologue. @@ -753,7 +752,8 @@ cris_skip_prologue_main (CORE_ADDR pc, int frameless_p) else best_limit = pc + 100; - pc_after_prologue = cris_examine (pc, best_limit, &fi, frameless_p); + pc_after_prologue = cris_examine (pc, best_limit, fi, frameless_p); + do_cleanups (old_chain); return pc_after_prologue; } @@ -972,7 +972,7 @@ cris_abi_original_store_return_value (struct type *type, char *valbuf) int len = TYPE_LENGTH (type); if (len <= REGISTER_SIZE) - write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len); + deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len); else internal_error (__FILE__, __LINE__, "cris_abi_original_store_return_value: type length too large."); } @@ -987,7 +987,8 @@ cris_abi_v2_store_return_value (struct type *type, char *valbuf) if (len <= 2 * REGISTER_SIZE) { /* Note that this works since R10 and R11 are consecutive registers. */ - write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len); + deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, + len); } else internal_error (__FILE__, __LINE__, "cris_abi_v2_store_return_value: type length too large."); @@ -1139,7 +1140,7 @@ cris_abi_v2_reg_struct_has_addr (int gcc_p, struct type *type) int cris_frameless_function_invocation (struct frame_info *fi) { - if (fi->signal_handler_caller) + if ((get_frame_type (fi) == SIGTRAMP_FRAME)) return 0; else return frameless_look_for_prologue (fi); @@ -1147,8 +1148,7 @@ cris_frameless_function_invocation (struct frame_info *fi) /* See frame.h. Determines the address of all registers in the current stack frame storing each in frame->saved_regs. Space for frame->saved_regs shall - be allocated by FRAME_INIT_SAVED_REGS using either frame_saved_regs_zalloc - or frame_obstack_alloc. */ + be allocated by FRAME_INIT_SAVED_REGS using frame_saved_regs_zalloc. */ void cris_frame_init_saved_regs (struct frame_info *fi) @@ -1156,13 +1156,14 @@ cris_frame_init_saved_regs (struct frame_info *fi) CORE_ADDR ip; struct symtab_and_line sal; int best_limit; - char *dummy_regs = deprecated_generic_find_dummy_frame (fi->pc, fi->frame); + char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), + get_frame_base (fi)); /* Examine the entire prologue. */ register int frameless_p = 0; /* Has this frame's registers already been initialized? */ - if (fi->saved_regs) + if (get_frame_saved_regs (fi)) return; frame_saved_regs_zalloc (fi); @@ -1172,11 +1173,11 @@ cris_frame_init_saved_regs (struct frame_info *fi) /* I don't see this ever happening, considering the context in which cris_frame_init_saved_regs is called (always when we're not in a dummy frame). */ - memcpy (&fi->saved_regs, dummy_regs, sizeof (fi->saved_regs)); + memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS); } else { - ip = get_pc_function_start (fi->pc); + ip = get_pc_function_start (get_frame_pc (fi)); sal = find_pc_line (ip, 0); /* If there is no symbol information then sal.end == 0, and we end up @@ -1199,29 +1200,30 @@ cris_frame_init_saved_regs (struct frame_info *fi) void cris_init_extra_frame_info (int fromleaf, struct frame_info *fi) { - if (fi->next) + if (get_next_frame (fi)) { /* Called from get_prev_frame. */ - fi->pc = FRAME_SAVED_PC (fi->next); + deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (get_next_frame (fi))); } - fi->extra_info = (struct frame_extra_info *) - frame_obstack_alloc (sizeof (struct frame_extra_info)); + frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info)); - fi->extra_info->return_pc = 0; - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->return_pc = 0; + get_frame_extra_info (fi)->leaf_function = 0; - if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) + if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), + get_frame_base (fi), + get_frame_base (fi))) { /* We need to setup fi->frame here because run_stack_dummy gets it wrong by assuming it's always FP. */ - fi->frame = deprecated_read_register_dummy (fi->pc, fi->frame, - SP_REGNUM); - fi->extra_info->return_pc = - deprecated_read_register_dummy (fi->pc, fi->frame, PC_REGNUM); + deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM)); + get_frame_extra_info (fi)->return_pc = + deprecated_read_register_dummy (get_frame_pc (fi), + get_frame_base (fi), PC_REGNUM); /* FIXME: Is this necessarily true? */ - fi->extra_info->leaf_function = 0; + get_frame_extra_info (fi)->leaf_function = 0; } else { @@ -1229,19 +1231,19 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi) /* Check fromleaf/frameless_function_invocation. (FIXME) */ - if (fi->saved_regs[SRP_REGNUM] != 0) + if (get_frame_saved_regs (fi)[SRP_REGNUM] != 0) { /* SRP was saved on the stack; non-leaf function. */ - fi->extra_info->return_pc = - read_memory_integer (fi->saved_regs[SRP_REGNUM], + get_frame_extra_info (fi)->return_pc = + read_memory_integer (get_frame_saved_regs (fi)[SRP_REGNUM], REGISTER_RAW_SIZE (SRP_REGNUM)); } else { /* SRP is still in a register; leaf function. */ - fi->extra_info->return_pc = read_register (SRP_REGNUM); + get_frame_extra_info (fi)->return_pc = read_register (SRP_REGNUM); /* FIXME: Should leaf_function be set to 1 here? */ - fi->extra_info->leaf_function = 1; + get_frame_extra_info (fi)->leaf_function = 1; } } } @@ -1252,13 +1254,15 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi) CORE_ADDR cris_frame_chain (struct frame_info *fi) { - if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) + if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), + get_frame_base (fi), + get_frame_base (fi))) { - return fi->frame; + return get_frame_base (fi); } - else if (!inside_entry_file (fi->pc)) + else if (!inside_entry_file (get_frame_pc (fi))) { - return read_memory_unsigned_integer (FRAME_FP (fi), 4); + return read_memory_unsigned_integer (get_frame_base (fi), 4); } else { @@ -1271,25 +1275,7 @@ cris_frame_chain (struct frame_info *fi) CORE_ADDR cris_frame_saved_pc (struct frame_info *fi) { - return fi->extra_info->return_pc; -} - -/* Return the address of the argument block for the frame described - by struct frame_info. */ - -CORE_ADDR -cris_frame_args_address (struct frame_info *fi) -{ - return FRAME_FP (fi); -} - -/* Return the address of the locals block for the frame - described by struct frame_info. */ - -CORE_ADDR -cris_frame_locals_address (struct frame_info *fi) -{ - return FRAME_FP (fi); + return get_frame_extra_info (fi)->return_pc; } /* Setup the function arguments for calling a function in the inferior. */ @@ -1528,7 +1514,9 @@ cris_pop_frame (void) register int regno; register int stack_offset = 0; - if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) + if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), + get_frame_base (fi), + get_frame_base (fi))) { /* This happens when we hit a breakpoint set at the entry point, when returning from a dummy frame. */ @@ -1549,30 +1537,30 @@ cris_pop_frame (void) after SP was saved. */ for (regno = 0; regno < FP_REGNUM; regno++) { - if (fi->saved_regs[regno]) + if (get_frame_saved_regs (fi)[regno]) { write_register (regno, - read_memory_integer (fi->saved_regs[regno], 4)); + read_memory_integer (get_frame_saved_regs (fi)[regno], 4)); } } - if (fi->saved_regs[FP_REGNUM]) + if (get_frame_saved_regs (fi)[FP_REGNUM]) { /* Pop the frame pointer (R8). It was pushed before SP was saved. */ write_register (FP_REGNUM, - read_memory_integer (fi->saved_regs[FP_REGNUM], 4)); + read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4)); stack_offset += 4; /* Not a leaf function. */ - if (fi->saved_regs[SRP_REGNUM]) + if (get_frame_saved_regs (fi)[SRP_REGNUM]) { /* SRP was pushed before SP was saved. */ stack_offset += 4; } /* Restore the SP and adjust for R8 and (possibly) SRP. */ - write_register (SP_REGNUM, fi->saved_regs[FP_REGNUM] + stack_offset); + write_register (SP_REGNUM, get_frame_saved_regs (fi)[FP_REGNUM] + stack_offset); } else { @@ -1581,7 +1569,7 @@ cris_pop_frame (void) } /* Restore the PC. */ - write_register (PC_REGNUM, fi->extra_info->return_pc); + write_register (PC_REGNUM, get_frame_extra_info (fi)->return_pc); } flush_cached_frames (); } @@ -1880,8 +1868,7 @@ process_autoincrement (int size, unsigned short inst, inst_env_type *inst_env) /* Just a forward declaration. */ -unsigned long -get_data_from_address (unsigned short *inst, CORE_ADDR address); +unsigned long get_data_from_address (unsigned short *inst, CORE_ADDR address); /* Calculates the prefix value for the general case of offset addressing mode. */ @@ -4020,7 +4007,7 @@ bfd_lookup_symbol (bfd *abfd, const char *symname) if (storage_needed > 0) { symbol_table = (asymbol **) xmalloc (storage_needed); - back_to = make_cleanup (free, (PTR) symbol_table); + back_to = make_cleanup (free, symbol_table); number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); for (i = 0; i < number_of_symbols; i++) @@ -4139,6 +4126,10 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep)); gdbarch = gdbarch_alloc (&info, tdep); + /* NOTE: cagney/2002-12-06: This can be deleted when this arch is + ready to unwind the PC first (see frame.c:get_prev_frame()). */ + set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default); + tdep->cris_version = cris_version; tdep->cris_mode = cris_mode; tdep->cris_abi = cris_abi; @@ -4262,10 +4253,8 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_register_virtual_type (gdbarch, cris_register_virtual_type); /* Use generic dummy frames. */ - set_gdbarch_use_generic_dummy_frames (gdbarch, 1); /* Where to execute the call in the memory segments. */ - set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT); set_gdbarch_call_dummy_address (gdbarch, entry_point_address); /* Start execution at the beginning of dummy. */ @@ -4277,7 +4266,7 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Read all about dummy frames in blockframe.c. */ set_gdbarch_call_dummy_length (gdbarch, 0); - set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point); + set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point); /* Defined to 1 to indicate that the target supports inferior function calls. */ @@ -4326,11 +4315,8 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_frameless_function_invocation (gdbarch, cris_frameless_function_invocation); set_gdbarch_frame_chain (gdbarch, cris_frame_chain); - set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid); set_gdbarch_frame_saved_pc (gdbarch, cris_frame_saved_pc); - set_gdbarch_frame_args_address (gdbarch, cris_frame_args_address); - set_gdbarch_frame_locals_address (gdbarch, cris_frame_locals_address); set_gdbarch_saved_pc_after_call (gdbarch, cris_saved_pc_after_call); set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);