/* Renesas M32C target-dependent code for GDB, the GNU debugger.
- Copyright 2004, 2005, 2007 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,
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 <http://www.gnu.org/licenses/>. */
#include "defs.h"
/* 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;
}
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;
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. */
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);
/* 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 */
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;
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. */
/* 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. */
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);
}
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
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;
}
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)
{
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
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));
}
static enum return_value_convention
m32c_return_value (struct gdbarch *gdbarch,
+ struct type *func_type,
struct type *valtype,
struct regcache *regcache,
gdb_byte *readbuf,
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,
}
void
-m32c_virtual_frame_pointer (CORE_ADDR pc,
+m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc,
int *frame_regnum,
LONGEST *frame_offset)
{
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 > gdbarch_num_regs (current_gdbarch))
+ if (*frame_regnum > gdbarch_num_regs (gdbarch))
internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
}
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);