X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fm32c-tdep.c;h=b8cd1675c31f14cc406522b64edb204d1da0f70b;hb=e7c8859c2139c644b2d3506e75ad0c9e368ea2eb;hp=8ea84ac4a72b68f341a7119033be994728d2414b;hpb=7830cb4f50d1ba2edfb90b4bcbb34e7d32e38bef;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c index 8ea84ac4a7..b8cd1675c3 100644 --- a/gdb/m32c-tdep.c +++ b/gdb/m32c-tdep.c @@ -1,12 +1,12 @@ /* Renesas M32C target-dependent code for GDB, the GNU debugger. - Copyright 2004, 2005 Free Software Foundation, Inc. + Copyright 2004, 2005, 2007, 2008 Free Software Foundation, Inc. This file is part of GDB. This program 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 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -15,9 +15,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" @@ -229,9 +227,9 @@ make_types (struct gdbarch *arch) /* Register set. */ static const char * -m32c_register_name (int num) +m32c_register_name (struct gdbarch *gdbarch, int num) { - return gdbarch_tdep (current_gdbarch)->regs[num].name; + return gdbarch_tdep (gdbarch)->regs[num].name; } @@ -243,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; @@ -267,7 +265,7 @@ 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. */ @@ -782,6 +780,28 @@ make_regs (struct gdbarch *arch) { struct gdbarch_tdep *tdep = gdbarch_tdep (arch); int mach = gdbarch_bfd_arch_info (arch)->mach; + int num_raw_regs; + int num_cooked_regs; + + struct m32c_reg *r0; + struct m32c_reg *r1; + struct m32c_reg *r2; + struct m32c_reg *r3; + struct m32c_reg *a0; + struct m32c_reg *a1; + struct m32c_reg *fb; + struct m32c_reg *sb; + struct m32c_reg *sp; + struct m32c_reg *r0hl; + struct m32c_reg *r1hl; + struct m32c_reg *r2hl; + struct m32c_reg *r3hl; + struct m32c_reg *intbhl; + struct m32c_reg *r2r0; + struct m32c_reg *r3r1; + struct m32c_reg *r3r1r2r0; + struct m32c_reg *r3r2r1r0; + struct m32c_reg *a1a0; struct m32c_reg *raw_r0_pair = RBD (r0); struct m32c_reg *raw_r1_pair = RBD (r1); @@ -816,50 +836,48 @@ make_regs (struct gdbarch *arch) struct m32c_reg *dra01 = DMA (RP (dra, tdep->data_addr_reg_type)); } - int num_raw_regs = tdep->num_regs; + num_raw_regs = tdep->num_regs; - struct m32c_reg *r0 = G (CB (r0, raw_r0_pair)); - struct m32c_reg *r1 = G (CB (r1, raw_r1_pair)); - struct m32c_reg *r2 = G (CB (r2, raw_r2_pair)); - struct m32c_reg *r3 = G (CB (r3, raw_r3_pair)); - struct m32c_reg *a0 = G (CB (a0, raw_a0_pair)); - struct m32c_reg *a1 = G (CB (a1, raw_a1_pair)); - struct m32c_reg *fb = G (CB (fb, raw_fb_pair)); + r0 = G (CB (r0, raw_r0_pair)); + r1 = G (CB (r1, raw_r1_pair)); + r2 = G (CB (r2, raw_r2_pair)); + r3 = G (CB (r3, raw_r3_pair)); + a0 = G (CB (a0, raw_a0_pair)); + a1 = G (CB (a1, raw_a1_pair)); + fb = G (CB (fb, raw_fb_pair)); /* sb is banked on the bfd_mach_m32c, but not on bfd_mach_m16c. Specify custom read/write functions that do the right thing. */ - struct m32c_reg *sb - = G (add_reg (arch, "sb", raw_sb_pair->type, 0, - m32c_sb_read, m32c_sb_write, - raw_sb_pair, raw_sb_pair + 1, 0)); + sb = G (add_reg (arch, "sb", raw_sb_pair->type, 0, + m32c_sb_read, m32c_sb_write, + raw_sb_pair, raw_sb_pair + 1, 0)); /* The current sp is either usp or isp, depending on the value of the FLG register's U bit. */ - struct m32c_reg *sp - = G (add_reg (arch, "sp", usp->type, 0, - m32c_banked_read, m32c_banked_write, isp, usp, FLAGBIT_U)); + sp = G (add_reg (arch, "sp", usp->type, 0, + m32c_banked_read, m32c_banked_write, + isp, usp, FLAGBIT_U)); - struct m32c_reg *r0hl = CHL (r0, tdep->int8); - struct m32c_reg *r1hl = CHL (r1, tdep->int8); - struct m32c_reg *r2hl = CHL (r2, tdep->int8); - struct m32c_reg *r3hl = CHL (r3, tdep->int8); - struct m32c_reg *intbhl = CHL (intb, tdep->int16); + r0hl = CHL (r0, tdep->int8); + r1hl = CHL (r1, tdep->int8); + r2hl = CHL (r2, tdep->int8); + r3hl = CHL (r3, tdep->int8); + intbhl = CHL (intb, tdep->int16); - struct m32c_reg *r2r0 = CCAT (r2, r0, tdep->int32); - struct m32c_reg *r3r1 = CCAT (r3, r1, tdep->int32); - struct m32c_reg *r3r1r2r0 = CCAT (r3r1, r2r0, tdep->int64); + r2r0 = CCAT (r2, r0, tdep->int32); + r3r1 = CCAT (r3, r1, tdep->int32); + r3r1r2r0 = CCAT (r3r1, r2r0, tdep->int64); - struct m32c_reg *r3r2r1r0 + r3r2r1r0 = add_reg (arch, "r3r2r1r0", tdep->int64, 0, m32c_r3r2r1r0_read, m32c_r3r2r1r0_write, NULL, NULL, 0); - struct m32c_reg *a1a0; if (mach == bfd_mach_m16c) a1a0 = CCAT (a1, a0, tdep->int32); else a1a0 = NULL; - int num_cooked_regs = tdep->num_regs - num_raw_regs; + num_cooked_regs = tdep->num_regs - num_raw_regs; tdep->pc = pc; tdep->flg = flg; @@ -941,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); @@ -958,7 +975,7 @@ make_regs (struct gdbarch *arch) /* Breakpoints. */ static const unsigned char * -m32c_breakpoint_from_pc (CORE_ADDR *pc, int *len) +m32c_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len) { static unsigned char break_insn[] = { 0x00 }; /* brk */ @@ -1196,6 +1213,9 @@ m32c_decode_srcdest4 (struct m32c_pv_state *st, else sd.kind = srcdest_mem; + sd.addr = pv_unknown (); + sd.reg = 0; + switch (code) { case 0x0: sd.reg = (size == 1 ? &st->r0 : &st->r0); break; @@ -1232,6 +1252,9 @@ m32c_decode_sd23 (struct m32c_pv_state *st, int code, int size, int ind) { struct srcdest sd; + sd.addr = pv_unknown (); + sd.reg = 0; + switch (code) { case 0x12: @@ -1475,7 +1498,7 @@ check_for_saved (void *prologue_untyped, pv_t addr, CORE_ADDR size, pv_t value) if (value.reg == tdep->pc->num) saved_size = tdep->ret_addr_bytes; - else if (gdbarch_register_type (arch, value.reg) + else if (register_type (arch, value.reg) == tdep->data_addr_reg_type) saved_size = tdep->push_addr_bytes; @@ -1586,14 +1609,16 @@ m32c_analyze_prologue (struct gdbarch *arch, else if ((st.insn[0] & 0xfe) == 0x72) { int size = (st.insn[0] & 0x01) ? 2 : 1; - + struct srcdest src; + struct srcdest dest; + pv_t src_value; st.next_addr += 2; - struct srcdest src + src = m32c_decode_srcdest4 (&st, (st.insn[1] >> 4) & 0xf, size); - struct srcdest dest + dest = m32c_decode_srcdest4 (&st, st.insn[1] & 0xf, size); - pv_t src_value = m32c_srcdest_fetch (&st, src, size); + src_value = m32c_srcdest_fetch (&st, src, size); if (m32c_is_arg_spill (&st, dest, src_value)) after_last_frame_related_insn = st.next_addr; @@ -1671,18 +1696,20 @@ m32c_analyze_prologue (struct gdbarch *arch, && m32c_get_src23 (&st.insn[i]) < 20 && m32c_get_dest23 (&st.insn[i]) < 20) { + struct srcdest src; + struct srcdest dest; + pv_t src_value; int bw = st.insn[i] & 0x01; int size = bw ? 2 : 1; - st.next_addr += 2; - struct srcdest src + src = m32c_decode_sd23 (&st, m32c_get_src23 (&st.insn[i]), size, src_indirect); - struct srcdest dest + dest = m32c_decode_sd23 (&st, m32c_get_dest23 (&st.insn[i]), size, dest_indirect); - pv_t src_value = m32c_srcdest_fetch (&st, src, size); + src_value = m32c_srcdest_fetch (&st, src, size); if (m32c_is_arg_spill (&st, dest, src_value)) after_last_frame_related_insn = st.next_addr; @@ -1775,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; @@ -1786,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. */ @@ -1801,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); - 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. */ @@ -1815,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); } @@ -1824,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 @@ -1842,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; } @@ -1863,75 +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)); + *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 - frame_register_unwind (next_frame, regnum, - optimizedp, lvalp, addrp, 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) { @@ -2112,7 +2116,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 @@ -2120,8 +2124,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)); } @@ -2163,6 +2168,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, @@ -2282,10 +2288,10 @@ m32c_return_value (struct gdbarch *gdbarch, their program is calling, not in some trampoline code they've never seen before.) - The SKIP_TRAMPOLINE_CODE gdbarch method tells GDB how to step + The gdbarch_skip_trampoline_code method tells GDB how to step through such trampoline functions transparently to the user. When given the address of a trampoline function's first instruction, - SKIP_TRAMPOLINE_CODE should return the address of the first + gdbarch_skip_trampoline_code should return the address of the first instruction of the function really being called. If GDB decides it wants to step into that function, it will set a breakpoint there and silently continue to it. @@ -2295,9 +2301,9 @@ m32c_return_value (struct gdbarch *gdbarch, code sequence seems more fragile. */ static CORE_ADDR -m32c_skip_trampoline_code (CORE_ADDR stop_pc) +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, @@ -2393,13 +2399,18 @@ m32c_skip_trampoline_code (CORE_ADDR stop_pc) static void m32c_m16c_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) { + enum type_code target_code; gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF); - enum type_code target_code = TYPE_CODE (TYPE_TARGET_TYPE (type)); + target_code = TYPE_CODE (TYPE_TARGET_TYPE (type)); if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD) { + char *func_name; + char *tramp_name; + struct minimal_symbol *tramp_msym; + /* Try to find a linker symbol at this address. */ struct minimal_symbol *func_msym = lookup_minimal_symbol_by_pc (addr); @@ -2408,14 +2419,13 @@ m32c_m16c_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) "couldn't find a symbol at that address, to find trampoline.", paddr_nz (addr)); - char *func_name = SYMBOL_LINKAGE_NAME (func_msym); - char *tramp_name = xmalloc (strlen (func_name) + 5); + func_name = SYMBOL_LINKAGE_NAME (func_msym); + tramp_name = xmalloc (strlen (func_name) + 5); strcpy (tramp_name, func_name); strcat (tramp_name, ".plt"); /* Try to find a linker symbol for the trampoline. */ - struct minimal_symbol *tramp_msym - = lookup_minimal_symbol (tramp_name, NULL, NULL); + tramp_msym = lookup_minimal_symbol (tramp_name, NULL, NULL); /* We've either got another copy of the name now, or don't need the name any more. */ @@ -2437,12 +2447,15 @@ m32c_m16c_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) static CORE_ADDR m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf) { + CORE_ADDR ptr; + enum type_code target_code; + gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF); - CORE_ADDR ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type)); + ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type)); - enum type_code target_code = TYPE_CODE (TYPE_TARGET_TYPE (type)); + target_code = TYPE_CODE (TYPE_TARGET_TYPE (type)); if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD) { @@ -2458,6 +2471,7 @@ m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf) if (len > 4 && strcmp (ptr_msym_name + len - 4, ".plt") == 0) { + struct minimal_symbol *func_msym; /* We have a .plt symbol; try to find the symbol for the corresponding function. @@ -2467,7 +2481,7 @@ m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf) char *func_name = xmalloc (len - 4 + 1); memcpy (func_name, ptr_msym_name, len - 4); func_name[len - 4] = '\0'; - struct minimal_symbol *func_msym + func_msym = lookup_minimal_symbol (func_name, NULL, NULL); /* If we do have such a symbol, return its value as the @@ -2482,7 +2496,7 @@ m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf) } void -m32c_virtual_frame_pointer (CORE_ADDR pc, +m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset) { @@ -2490,29 +2504,30 @@ m32c_virtual_frame_pointer (CORE_ADDR pc, CORE_ADDR func_addr, func_end, sal_end; struct m32c_prologue p; - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct regcache *regcache = get_current_regcache (); + 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: - *frame_regnum = m32c_banked_register (tdep->fb, current_regcache)->num; + *frame_regnum = m32c_banked_register (tdep->fb, regcache)->num; *frame_offset = p.frame_ptr_offset; break; case prologue_sans_frame_ptr: - *frame_regnum = m32c_banked_register (tdep->sp, current_regcache)->num; + *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num; *frame_offset = p.frame_size; break; default: - *frame_regnum = m32c_banked_register (tdep->sp, current_regcache)->num; + *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num; *frame_offset = 0; break; } /* Sanity check */ - if (*frame_regnum > NUM_REGS) + if (*frame_regnum > gdbarch_num_regs (gdbarch)) internal_error (__FILE__, __LINE__, _("No virtual frame pointer available")); } @@ -2567,14 +2582,14 @@ 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);