X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fm32c-tdep.c;h=9fa672bffa4a825a4514d931ff798e82f1404011;hb=727fc41e077139570ea8b8ddfd6c546b2a55627c;hp=db25f6c86e3cc805735e52581531b5f4bc094e5d;hpb=67d57894593345f23efe728f00b0a8c72216b962;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c index db25f6c86e..9fa672bffa 100644 --- a/gdb/m32c-tdep.c +++ b/gdb/m32c-tdep.c @@ -1,6 +1,6 @@ /* Renesas M32C target-dependent code for GDB, the GNU debugger. - Copyright 2004, 2005, 2007 Free Software Foundation, Inc. + Copyright 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. This file is part of GDB. @@ -241,16 +241,16 @@ m32c_register_type (struct gdbarch *arch, int reg_nr) static int -m32c_register_sim_regno (int reg_nr) +m32c_register_sim_regno (struct gdbarch *gdbarch, int reg_nr) { - return gdbarch_tdep (current_gdbarch)->regs[reg_nr].sim_num; + return gdbarch_tdep (gdbarch)->regs[reg_nr].sim_num; } static int -m32c_debug_info_reg_to_regnum (int reg_nr) +m32c_debug_info_reg_to_regnum (struct gdbarch *gdbarch, int reg_nr) { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (0 <= reg_nr && reg_nr <= M32C_MAX_DWARF_REGNUM && tdep->dwarf_regs[reg_nr]) return tdep->dwarf_regs[reg_nr]->num; @@ -261,11 +261,11 @@ m32c_debug_info_reg_to_regnum (int reg_nr) } -int +static int m32c_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *group) { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct m32c_reg *reg = &tdep->regs[regnum]; /* The anonymous raw registers aren't in any groups. */ @@ -959,7 +959,6 @@ make_regs (struct gdbarch *arch) set_gdbarch_pseudo_register_write (arch, m32c_pseudo_register_write); set_gdbarch_register_sim_regno (arch, m32c_register_sim_regno); set_gdbarch_stab_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum); - set_gdbarch_dwarf_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum); set_gdbarch_dwarf2_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum); set_gdbarch_register_reggroup_p (arch, m32c_register_reggroup_p); @@ -1520,7 +1519,7 @@ check_for_saved (void *prologue_untyped, pv_t addr, CORE_ADDR size, pv_t value) /* Analyze the function prologue for ARCH at START, going no further than LIMIT, and place a description of what we found in PROLOGUE. */ -void +static void m32c_analyze_prologue (struct gdbarch *arch, CORE_ADDR start, CORE_ADDR limit, struct m32c_prologue *prologue) @@ -1803,7 +1802,7 @@ m32c_analyze_prologue (struct gdbarch *arch, static CORE_ADDR -m32c_skip_prologue (CORE_ADDR ip) +m32c_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip) { char *name; CORE_ADDR func_addr, func_end, sal_end; @@ -1814,7 +1813,7 @@ m32c_skip_prologue (CORE_ADDR ip) return ip; /* Find end by prologue analysis. */ - m32c_analyze_prologue (current_gdbarch, ip, func_end, &p); + m32c_analyze_prologue (gdbarch, ip, func_end, &p); /* Find end by line info. */ sal_end = skip_prologue_using_sal (ip); /* Return whichever is lower. */ @@ -1829,13 +1828,13 @@ m32c_skip_prologue (CORE_ADDR ip) /* Stack unwinding. */ static struct m32c_prologue * -m32c_analyze_frame_prologue (struct frame_info *next_frame, +m32c_analyze_frame_prologue (struct frame_info *this_frame, void **this_prologue_cache) { if (! *this_prologue_cache) { - CORE_ADDR func_start = frame_func_unwind (next_frame, NORMAL_FRAME); - CORE_ADDR stop_addr = frame_pc_unwind (next_frame); + CORE_ADDR func_start = get_frame_func (this_frame); + CORE_ADDR stop_addr = get_frame_pc (this_frame); /* If we couldn't find any function containing the PC, then just initialize the prologue cache, but don't do anything. */ @@ -1843,7 +1842,7 @@ m32c_analyze_frame_prologue (struct frame_info *next_frame, stop_addr = func_start; *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct m32c_prologue); - m32c_analyze_prologue (get_frame_arch (next_frame), + m32c_analyze_prologue (get_frame_arch (this_frame), func_start, stop_addr, *this_prologue_cache); } @@ -1852,12 +1851,12 @@ m32c_analyze_frame_prologue (struct frame_info *next_frame, static CORE_ADDR -m32c_frame_base (struct frame_info *next_frame, +m32c_frame_base (struct frame_info *this_frame, void **this_prologue_cache) { struct m32c_prologue *p - = m32c_analyze_frame_prologue (next_frame, this_prologue_cache); - struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (next_frame)); + = m32c_analyze_frame_prologue (this_frame, this_prologue_cache); + struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame)); /* In functions that use alloca, the distance between the stack pointer and the frame base varies dynamically, so we can't use @@ -1870,14 +1869,14 @@ m32c_frame_base (struct frame_info *next_frame, case prologue_with_frame_ptr: { CORE_ADDR fb - = frame_unwind_register_unsigned (next_frame, tdep->fb->num); + = get_frame_register_unsigned (this_frame, tdep->fb->num); return fb - p->frame_ptr_offset; } case prologue_sans_frame_ptr: { CORE_ADDR sp - = frame_unwind_register_unsigned (next_frame, tdep->sp->num); + = get_frame_register_unsigned (this_frame, tdep->sp->num); return sp - p->frame_size; } @@ -1891,82 +1890,52 @@ m32c_frame_base (struct frame_info *next_frame, static void -m32c_this_id (struct frame_info *next_frame, +m32c_this_id (struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id) { - CORE_ADDR base = m32c_frame_base (next_frame, this_prologue_cache); + CORE_ADDR base = m32c_frame_base (this_frame, this_prologue_cache); if (base) - *this_id = frame_id_build (base, - frame_func_unwind (next_frame, NORMAL_FRAME)); + *this_id = frame_id_build (base, get_frame_func (this_frame)); /* Otherwise, leave it unset, and that will terminate the backtrace. */ } -static void -m32c_prev_register (struct frame_info *next_frame, - void **this_prologue_cache, - int regnum, int *optimizedp, - enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnump, gdb_byte *bufferp) +static struct value * +m32c_prev_register (struct frame_info *this_frame, + void **this_prologue_cache, int regnum) { - struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (next_frame)); + struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame)); struct m32c_prologue *p - = m32c_analyze_frame_prologue (next_frame, this_prologue_cache); - CORE_ADDR frame_base = m32c_frame_base (next_frame, this_prologue_cache); - int reg_size = register_size (get_frame_arch (next_frame), regnum); + = m32c_analyze_frame_prologue (this_frame, this_prologue_cache); + CORE_ADDR frame_base = m32c_frame_base (this_frame, this_prologue_cache); + int reg_size = register_size (get_frame_arch (this_frame), regnum); if (regnum == tdep->sp->num) - { - *optimizedp = 0; - *lvalp = not_lval; - *addrp = 0; - *realnump = -1; - if (bufferp) - store_unsigned_integer (bufferp, reg_size, frame_base); - } + return frame_unwind_got_constant (this_frame, regnum, frame_base); /* If prologue analysis says we saved this register somewhere, return a description of the stack slot holding it. */ - else if (p->reg_offset[regnum] != 1) - { - *optimizedp = 0; - *lvalp = lval_memory; - *addrp = frame_base + p->reg_offset[regnum]; - *realnump = -1; - if (bufferp) - get_frame_memory (next_frame, *addrp, bufferp, reg_size); - } + if (p->reg_offset[regnum] != 1) + return frame_unwind_got_memory (this_frame, regnum, + frame_base + p->reg_offset[regnum]); /* Otherwise, presume we haven't changed the value of this register, and get it from the next frame. */ - else - { - *optimizedp = 0; - *lvalp = lval_register; - *addrp = 0; - *realnump = regnum; - if (bufferp) - frame_unwind_register (next_frame, *realnump, bufferp); - } + return frame_unwind_got_register (this_frame, regnum, regnum); } static const struct frame_unwind m32c_unwind = { NORMAL_FRAME, m32c_this_id, - m32c_prev_register + m32c_prev_register, + NULL, + default_frame_sniffer }; -static const struct frame_unwind * -m32c_frame_sniffer (struct frame_info *next_frame) -{ - return &m32c_unwind; -} - - static CORE_ADDR m32c_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame) { @@ -2049,6 +2018,10 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { struct type *func_type = value_type (function); + /* Dereference function pointer types. */ + if (TYPE_CODE (func_type) == TYPE_CODE_PTR) + func_type = TYPE_TARGET_TYPE (func_type); + gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC || TYPE_CODE (func_type) == TYPE_CODE_METHOD); @@ -2147,7 +2120,7 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function, static struct frame_id -m32c_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) +m32c_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) { /* This needs to return a frame ID whose PC is the return address passed to m32c_push_dummy_call, and whose stack_addr is the SP @@ -2155,8 +2128,9 @@ m32c_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) m32c_unwind_sp gives us the CFA, which is the value the SP had before the return address was pushed. */ - return frame_id_build (m32c_unwind_sp (gdbarch, next_frame), - frame_pc_unwind (next_frame)); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + CORE_ADDR sp = get_frame_register_unsigned (this_frame, tdep->sp->num); + return frame_id_build (sp, get_frame_pc (this_frame)); } @@ -2198,6 +2172,7 @@ m32c_return_by_passed_buf (struct type *type) static enum return_value_convention m32c_return_value (struct gdbarch *gdbarch, + struct type *func_type, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, @@ -2332,7 +2307,7 @@ m32c_return_value (struct gdbarch *gdbarch, static CORE_ADDR m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc) { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame)); /* It would be nicer to simply look up the addresses of known trampolines once, and then compare stop_pc with them. However, @@ -2524,8 +2499,8 @@ m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf) return ptr; } -void -m32c_virtual_frame_pointer (CORE_ADDR pc, +static void +m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset) { @@ -2534,12 +2509,12 @@ m32c_virtual_frame_pointer (CORE_ADDR pc, struct m32c_prologue p; struct regcache *regcache = get_current_regcache (); - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (!find_pc_partial_function (pc, &name, &func_addr, &func_end)) internal_error (__FILE__, __LINE__, _("No virtual frame pointer available")); - m32c_analyze_prologue (current_gdbarch, func_addr, pc, &p); + m32c_analyze_prologue (gdbarch, func_addr, pc, &p); switch (p.kind) { case prologue_with_frame_ptr: @@ -2556,7 +2531,7 @@ m32c_virtual_frame_pointer (CORE_ADDR pc, break; } /* Sanity check */ - if (*frame_regnum > gdbarch_num_regs (current_gdbarch)) + if (*frame_regnum > gdbarch_num_regs (gdbarch)) internal_error (__FILE__, __LINE__, _("No virtual frame pointer available")); } @@ -2611,23 +2586,35 @@ m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) know which, but I do know that the prologue analyzer works better. MVS 04/13/06 */ - frame_unwind_append_sniffer (arch, dwarf2_frame_sniffer); + dwarf2_append_sniffers (arch); #endif - frame_unwind_append_sniffer (arch, m32c_frame_sniffer); + frame_unwind_append_unwinder (arch, &m32c_unwind); /* Inferior calls. */ set_gdbarch_push_dummy_call (arch, m32c_push_dummy_call); set_gdbarch_return_value (arch, m32c_return_value); - set_gdbarch_unwind_dummy_id (arch, m32c_unwind_dummy_id); + set_gdbarch_dummy_id (arch, m32c_dummy_id); /* Trampolines. */ set_gdbarch_skip_trampoline_code (arch, m32c_skip_trampoline_code); set_gdbarch_virtual_frame_pointer (arch, m32c_virtual_frame_pointer); + /* m32c function boundary addresses are not necessarily even. + Therefore, the `vbit', which indicates a pointer to a virtual + member function, is stored in the delta field, rather than as + the low bit of a function pointer address. + + In order to verify this, see the definition of + TARGET_PTRMEMFUNC_VBIT_LOCATION in gcc/defaults.h along with the + definition of FUNCTION_BOUNDARY in gcc/config/m32c/m32c.h. */ + set_gdbarch_vbit_in_delta (arch, 1); + return arch; } +/* Provide a prototype to silence -Wmissing-prototypes. */ +extern initialize_file_ftype _initialize_m32c_tdep; void _initialize_m32c_tdep (void)