X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fm32r-tdep.c;h=e22ca9dd779d3d5a3dc21c73b3498cc429b3c5e1;hb=d903301282bd777b82a395fc21dda695dc67f84d;hp=3766c1407393ac421422513cc050b62e14428744;hpb=f57d151a994d668d681871f04cfd6e32a1c5ac33;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m32r-tdep.c b/gdb/m32r-tdep.c index 3766c14073..e22ca9dd77 100644 --- a/gdb/m32r-tdep.c +++ b/gdb/m32r-tdep.c @@ -1,13 +1,13 @@ /* Target-dependent code for Renesas M32R, for GDB. - Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007 - Free Software Foundation, Inc. + Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, + 2008, 2009, 2010 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, @@ -16,9 +16,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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "frame.h" @@ -81,7 +79,8 @@ m32r_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp) The following functions take care of this behavior. */ static int -m32r_memory_insert_breakpoint (struct bp_target_info *bp_tgt) +m32r_memory_insert_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { CORE_ADDR addr = bp_tgt->placed_address; int val; @@ -97,7 +96,7 @@ m32r_memory_insert_breakpoint (struct bp_target_info *bp_tgt) bp_tgt->placed_size = bp_tgt->shadow_len = 4; /* Determine appropriate breakpoint contents and size for this address. */ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) { if ((addr & 3) == 0) { @@ -138,7 +137,8 @@ m32r_memory_insert_breakpoint (struct bp_target_info *bp_tgt) } static int -m32r_memory_remove_breakpoint (struct bp_target_info *bp_tgt) +m32r_memory_remove_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { CORE_ADDR addr = bp_tgt->placed_address; int val; @@ -151,7 +151,7 @@ m32r_memory_remove_breakpoint (struct bp_target_info *bp_tgt) buf[3] = contents_cache[3]; /* Remove parallel bit. */ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) { if ((buf[0] & 0x80) == 0 && (buf[2] & 0x80) != 0) buf[2] &= 0x7f; @@ -168,14 +168,14 @@ m32r_memory_remove_breakpoint (struct bp_target_info *bp_tgt) } static const gdb_byte * -m32r_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) +m32r_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr) { static gdb_byte be_bp_entry[] = { 0x10, 0xf1, 0x70, 0x00 }; /* dpt -> nop */ static gdb_byte le_bp_entry[] = { 0x00, 0x70, 0xf1, 0x10 }; /* dpt -> nop */ gdb_byte *bp; /* Determine appropriate breakpoint. */ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) { if ((*pcptr & 3) == 0) { @@ -214,7 +214,7 @@ char *m32r_register_names[] = { }; static const char * -m32r_register_name (int reg_nr) +m32r_register_name (struct gdbarch *gdbarch, int reg_nr) { if (reg_nr < 0) return NULL; @@ -231,11 +231,11 @@ static struct type * m32r_register_type (struct gdbarch *gdbarch, int reg_nr) { if (reg_nr == M32R_PC_REGNUM) - return builtin_type_void_func_ptr; + return builtin_type (gdbarch)->builtin_func_ptr; else if (reg_nr == M32R_SP_REGNUM || reg_nr == M32R_FP_REGNUM) - return builtin_type_void_data_ptr; + return builtin_type (gdbarch)->builtin_data_ptr; else - return builtin_type_int32; + return builtin_type (gdbarch)->builtin_int32; } @@ -248,15 +248,18 @@ static void m32r_store_return_value (struct type *type, struct regcache *regcache, const void *valbuf) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR regval; int len = TYPE_LENGTH (type); - regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len); + regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len, byte_order); regcache_cooked_write_unsigned (regcache, RET1_REGNUM, regval); if (len > 4) { - regval = extract_unsigned_integer ((gdb_byte *) valbuf + 4, len - 4); + regval = extract_unsigned_integer ((gdb_byte *) valbuf + 4, + len - 4, byte_order); regcache_cooked_write_unsigned (regcache, RET1_REGNUM + 1, regval); } } @@ -265,9 +268,11 @@ m32r_store_return_value (struct type *type, struct regcache *regcache, should be cached because this thrashing is getting nuts. */ static int -decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, +decode_prologue (struct gdbarch *gdbarch, + CORE_ADDR start_pc, CORE_ADDR scan_limit, CORE_ADDR *pl_endptr, unsigned long *framelength) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); unsigned long framesize; int insn; int op1; @@ -283,10 +288,10 @@ decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2) { /* Check if current pc's location is readable. */ - if (!safe_read_memory_integer (current_pc, 2, &return_value)) + if (!safe_read_memory_integer (current_pc, 2, byte_order, &return_value)) return -1; - insn = read_memory_unsigned_integer (current_pc, 2); + insn = read_memory_unsigned_integer (current_pc, 2, byte_order); if (insn == 0x0000) break; @@ -308,25 +313,30 @@ decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, current_pc += 2; /* skip the immediate data */ /* Check if current pc's location is readable. */ - if (!safe_read_memory_integer (current_pc, 2, &return_value)) + if (!safe_read_memory_integer (current_pc, 2, byte_order, + &return_value)) return -1; if (insn == 0x8faf) /* add3 sp, sp, xxxx */ /* add 16 bit sign-extended offset */ { framesize += - -((short) read_memory_unsigned_integer (current_pc, 2)); + -((short) read_memory_unsigned_integer (current_pc, + 2, byte_order)); } else { if (((insn >> 8) == 0xe4) /* ld24 r4, xxxxxx; sub sp, r4 */ - && safe_read_memory_integer (current_pc + 2, 2, + && safe_read_memory_integer (current_pc + 2, + 2, byte_order, &return_value) && read_memory_unsigned_integer (current_pc + 2, - 2) == 0x0f24) + 2, byte_order) + == 0x0f24) /* subtract 24 bit sign-extended negative-offset */ { - insn = read_memory_unsigned_integer (current_pc - 2, 4); + insn = read_memory_unsigned_integer (current_pc - 2, + 4, byte_order); if (insn & 0x00800000) /* sign extend */ insn |= 0xff000000; /* negative */ else @@ -351,7 +361,7 @@ decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, if ((insn >> 8) == 0x4f) /* addi sp, xx */ /* add 8 bit sign-extended offset */ { - int stack_adjust = (gdb_byte) (insn & 0xff); + int stack_adjust = (signed char) (insn & 0xff); /* there are probably two of these stack adjustments: 1) A negative one in the prologue, and @@ -449,9 +459,10 @@ decode_prologue (CORE_ADDR start_pc, CORE_ADDR scan_limit, #define DEFAULT_SEARCH_LIMIT 128 -CORE_ADDR -m32r_skip_prologue (CORE_ADDR pc) +static CORE_ADDR +m32r_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR func_addr, func_end; struct symtab_and_line sal; LONGEST return_value; @@ -478,11 +489,11 @@ m32r_skip_prologue (CORE_ADDR pc) func_end = pc + DEFAULT_SEARCH_LIMIT; /* If pc's location is not readable, just quit. */ - if (!safe_read_memory_integer (pc, 4, &return_value)) + if (!safe_read_memory_integer (pc, 4, byte_order, &return_value)) return pc; /* Find the end of prologue. */ - if (decode_prologue (pc, func_end, &sal.end, NULL) < 0) + if (decode_prologue (gdbarch, pc, func_end, &sal.end, NULL) < 0) return pc; return sal.end; @@ -513,7 +524,7 @@ struct m32r_unwind_cache for it IS the sp for the next frame. */ static struct m32r_unwind_cache * -m32r_frame_unwind_cache (struct frame_info *next_frame, +m32r_frame_unwind_cache (struct frame_info *this_frame, void **this_prologue_cache) { CORE_ADDR pc, scan_limit; @@ -529,19 +540,19 @@ m32r_frame_unwind_cache (struct frame_info *next_frame, info = FRAME_OBSTACK_ZALLOC (struct m32r_unwind_cache); (*this_prologue_cache) = info; - info->saved_regs = trad_frame_alloc_saved_regs (next_frame); + info->saved_regs = trad_frame_alloc_saved_regs (this_frame); info->size = 0; info->sp_offset = 0; info->uses_frame = 0; - scan_limit = frame_pc_unwind (next_frame); - for (pc = frame_func_unwind (next_frame, NORMAL_FRAME); + scan_limit = get_frame_pc (this_frame); + for (pc = get_frame_func (this_frame); pc > 0 && pc < scan_limit; pc += 2) { if ((pc & 2) == 0) { - op = get_frame_memory_unsigned (next_frame, pc, 4); + op = get_frame_memory_unsigned (this_frame, pc, 4); if ((op & 0x80000000) == 0x80000000) { /* 32-bit instruction */ @@ -552,7 +563,7 @@ m32r_frame_unwind_cache (struct frame_info *next_frame, info->sp_offset += n; } else if (((op >> 8) == 0xe4) - && get_frame_memory_unsigned (next_frame, pc + 2, + && get_frame_memory_unsigned (this_frame, pc + 2, 2) == 0x0f24) { /* ld24 r4, xxxxxx; sub sp, r4 */ @@ -569,7 +580,7 @@ m32r_frame_unwind_cache (struct frame_info *next_frame, } /* 16-bit instructions */ - op = get_frame_memory_unsigned (next_frame, pc, 2) & 0x7fff; + op = get_frame_memory_unsigned (this_frame, pc, 2) & 0x7fff; if ((op & 0xf0ff) == 0x207f) { /* st rn, @-sp */ @@ -580,7 +591,7 @@ m32r_frame_unwind_cache (struct frame_info *next_frame, else if ((op & 0xff00) == 0x4f00) { /* addi sp, xx */ - int n = (gdb_byte) (op & 0xff); + int n = (signed char) (op & 0xff); info->sp_offset += n; } else if (op == 0x1d8f) @@ -606,7 +617,7 @@ m32r_frame_unwind_cache (struct frame_info *next_frame, /* The SP was moved to the FP. This indicates that a new frame was created. Get THIS frame's FP value by unwinding it from the next frame. */ - this_base = frame_unwind_register_unsigned (next_frame, M32R_FP_REGNUM); + this_base = get_frame_register_unsigned (this_frame, M32R_FP_REGNUM); /* The FP points at the last saved register. Adjust the FP back to before the first saved register giving the SP. */ prev_sp = this_base + info->size; @@ -615,7 +626,7 @@ m32r_frame_unwind_cache (struct frame_info *next_frame, { /* Assume that the FP is this frame's SP but with that pushed stack space added back. */ - this_base = frame_unwind_register_unsigned (next_frame, M32R_SP_REGNUM); + this_base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM); prev_sp = this_base + info->size; } @@ -625,7 +636,7 @@ m32r_frame_unwind_cache (struct frame_info *next_frame, /* Adjust all the saved registers so that they contain addresses and not offsets. */ - for (i = 0; i < gdbarch_num_regs (current_gdbarch) - 1; i++) + for (i = 0; i < gdbarch_num_regs (get_frame_arch (this_frame)) - 1; i++) if (trad_frame_addr_p (info->saved_regs, i)) info->saved_regs[i].addr = (info->prev_sp + info->saved_regs[i].addr); @@ -643,27 +654,17 @@ m32r_frame_unwind_cache (struct frame_info *next_frame, } static CORE_ADDR -m32r_read_pc (ptid_t ptid) +m32r_read_pc (struct regcache *regcache) { - ptid_t save_ptid; ULONGEST pc; - - save_ptid = inferior_ptid; - inferior_ptid = ptid; - regcache_cooked_read_unsigned (current_regcache, M32R_PC_REGNUM, &pc); - inferior_ptid = save_ptid; + regcache_cooked_read_unsigned (regcache, M32R_PC_REGNUM, &pc); return pc; } static void -m32r_write_pc (CORE_ADDR val, ptid_t ptid) +m32r_write_pc (struct regcache *regcache, CORE_ADDR val) { - ptid_t save_ptid; - - save_ptid = inferior_ptid; - inferior_ptid = ptid; - write_register (M32R_PC_REGNUM, val); - inferior_ptid = save_ptid; + regcache_cooked_write_unsigned (regcache, M32R_PC_REGNUM, val); } static CORE_ADDR @@ -679,6 +680,7 @@ m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int stack_offset, stack_alloc; int argreg = ARG1_REGNUM; int argnum; @@ -723,7 +725,8 @@ m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (len > 8 && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)) { - store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (args[argnum])); + store_unsigned_integer (valbuf, 4, byte_order, + value_address (args[argnum])); typecode = TYPE_CODE_PTR; len = 4; val = valbuf; @@ -751,7 +754,8 @@ m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* there's room in a register */ regval = extract_unsigned_integer (val, - register_size (gdbarch, argreg)); + register_size (gdbarch, argreg), + byte_order); regcache_cooked_write_unsigned (regcache, argreg++, regval); } @@ -777,6 +781,8 @@ static void m32r_extract_return_value (struct type *type, struct regcache *regcache, void *dst) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); bfd_byte *valbuf = dst; int len = TYPE_LENGTH (type); ULONGEST tmp; @@ -784,21 +790,21 @@ m32r_extract_return_value (struct type *type, struct regcache *regcache, /* By using store_unsigned_integer we avoid having to do anything special for small big-endian values. */ regcache_cooked_read_unsigned (regcache, RET1_REGNUM, &tmp); - store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), tmp); + store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), byte_order, tmp); /* Ignore return values more than 8 bytes in size because the m32r returns anything more than 8 bytes in the stack. */ if (len > 4) { regcache_cooked_read_unsigned (regcache, RET1_REGNUM + 1, &tmp); - store_unsigned_integer (valbuf + len - 4, 4, tmp); + store_unsigned_integer (valbuf + len - 4, 4, byte_order, tmp); } } -enum return_value_convention -m32r_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, gdb_byte *readbuf, - const gdb_byte *writebuf) +static enum return_value_convention +m32r_return_value (struct gdbarch *gdbarch, struct type *func_type, + struct type *valtype, struct regcache *regcache, + gdb_byte *readbuf, const gdb_byte *writebuf) { if (TYPE_LENGTH (valtype) > 8) return RETURN_VALUE_STRUCT_CONVENTION; @@ -824,18 +830,18 @@ m32r_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) frame. This will be used to create a new GDB frame struct. */ static void -m32r_frame_this_id (struct frame_info *next_frame, +m32r_frame_this_id (struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id) { struct m32r_unwind_cache *info - = m32r_frame_unwind_cache (next_frame, this_prologue_cache); + = m32r_frame_unwind_cache (this_frame, this_prologue_cache); CORE_ADDR base; CORE_ADDR func; struct minimal_symbol *msym_stack; struct frame_id id; /* The FUNC is easy. */ - func = frame_func_unwind (next_frame, NORMAL_FRAME); + func = get_frame_func (this_frame); /* Check if the stack is empty. */ msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL); @@ -853,36 +859,28 @@ m32r_frame_this_id (struct frame_info *next_frame, (*this_id) = id; } -static void -m32r_frame_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 * +m32r_frame_prev_register (struct frame_info *this_frame, + void **this_prologue_cache, int regnum) { struct m32r_unwind_cache *info - = m32r_frame_unwind_cache (next_frame, this_prologue_cache); - trad_frame_get_prev_register (next_frame, info->saved_regs, regnum, - optimizedp, lvalp, addrp, realnump, bufferp); + = m32r_frame_unwind_cache (this_frame, this_prologue_cache); + return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum); } static const struct frame_unwind m32r_frame_unwind = { NORMAL_FRAME, m32r_frame_this_id, - m32r_frame_prev_register + m32r_frame_prev_register, + NULL, + default_frame_sniffer }; -static const struct frame_unwind * -m32r_frame_sniffer (struct frame_info *next_frame) -{ - return &m32r_frame_unwind; -} - static CORE_ADDR -m32r_frame_base_address (struct frame_info *next_frame, void **this_cache) +m32r_frame_base_address (struct frame_info *this_frame, void **this_cache) { struct m32r_unwind_cache *info - = m32r_frame_unwind_cache (next_frame, this_cache); + = m32r_frame_unwind_cache (this_frame, this_cache); return info->base; } @@ -893,16 +891,15 @@ static const struct frame_base m32r_frame_base = { m32r_frame_base_address }; -/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that - dummy frame. The frame ID's base needs to match the TOS value - saved by save_dummy_frame_tos(), and the PC match the dummy frame's - breakpoint. */ +/* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy + frame. The frame ID's base needs to match the TOS value saved by + save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */ static struct frame_id -m32r_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) +m32r_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) { - return frame_id_build (m32r_unwind_sp (gdbarch, next_frame), - frame_pc_unwind (next_frame)); + CORE_ADDR sp = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM); + return frame_id_build (sp, get_frame_pc (this_frame)); } @@ -950,7 +947,7 @@ m32r_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Methods for saving / extracting a dummy frame's ID. The ID's stack address must match the SP value returned by PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ - set_gdbarch_unwind_dummy_id (gdbarch, m32r_unwind_dummy_id); + set_gdbarch_dummy_id (gdbarch, m32r_dummy_id); /* Return the unwound PC value. */ set_gdbarch_unwind_pc (gdbarch, m32r_unwind_pc); @@ -961,7 +958,7 @@ m32r_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) gdbarch_init_osabi (info, gdbarch); /* Hook in the default unwinders. */ - frame_unwind_append_sniffer (gdbarch, m32r_frame_sniffer); + frame_unwind_append_unwinder (gdbarch, &m32r_frame_unwind); /* Support simple overlay manager. */ set_gdbarch_overlay_update (gdbarch, simple_overlay_update);