X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fm32c-tdep.c;h=b680fa07dbad6e0a6d66cc9b7ce7baccc5a35927;hb=1c658ad5fac2a221b589cbe26ec84c788b24a8d1;hp=10367b38b029f3b677d9225d549702e5d15a52b1;hpb=55f960e1d2e58215a0c274e8d30e6036c96a2959;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c index 10367b38b0..b680fa07db 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, 2008, 2009 Free Software Foundation, Inc. + Copyright 2004-2005, 2007-2012 Free Software Foundation, Inc. This file is part of GDB. @@ -53,9 +53,9 @@ struct m32c_reg; /* The type of a function that moves the value of REG between CACHE or BUF --- in either direction. */ -typedef void (m32c_move_reg_t) (struct m32c_reg *reg, - struct regcache *cache, - void *buf); +typedef enum register_status (m32c_move_reg_t) (struct m32c_reg *reg, + struct regcache *cache, + void *buf); struct m32c_reg { @@ -187,39 +187,41 @@ make_types (struct gdbarch *arch) break; default: - gdb_assert (0); + gdb_assert_not_reached ("unexpected mach"); } /* The builtin_type_mumble variables are sometimes uninitialized when this is called, so we avoid using them. */ - tdep->voyd = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL); - tdep->ptr_voyd = init_type (TYPE_CODE_PTR, gdbarch_ptr_bit (arch) / 8, - TYPE_FLAG_UNSIGNED, NULL, NULL); + tdep->voyd = arch_type (arch, TYPE_CODE_VOID, 1, "void"); + tdep->ptr_voyd + = arch_type (arch, TYPE_CODE_PTR, gdbarch_ptr_bit (arch) / TARGET_CHAR_BIT, + NULL); TYPE_TARGET_TYPE (tdep->ptr_voyd) = tdep->voyd; + TYPE_UNSIGNED (tdep->ptr_voyd) = 1; tdep->func_voyd = lookup_function_type (tdep->voyd); sprintf (type_name, "%s_data_addr_t", gdbarch_bfd_arch_info (arch)->printable_name); tdep->data_addr_reg_type - = init_type (TYPE_CODE_PTR, data_addr_reg_bits / 8, - TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL); + = arch_type (arch, TYPE_CODE_PTR, data_addr_reg_bits / TARGET_CHAR_BIT, + xstrdup (type_name)); TYPE_TARGET_TYPE (tdep->data_addr_reg_type) = tdep->voyd; + TYPE_UNSIGNED (tdep->data_addr_reg_type) = 1; sprintf (type_name, "%s_code_addr_t", gdbarch_bfd_arch_info (arch)->printable_name); tdep->code_addr_reg_type - = init_type (TYPE_CODE_PTR, code_addr_reg_bits / 8, - TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL); + = arch_type (arch, TYPE_CODE_PTR, code_addr_reg_bits / TARGET_CHAR_BIT, + xstrdup (type_name)); TYPE_TARGET_TYPE (tdep->code_addr_reg_type) = tdep->func_voyd; + TYPE_UNSIGNED (tdep->code_addr_reg_type) = 1; - tdep->uint8 = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, - "uint8_t", NULL); - tdep->uint16 = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, - "uint16_t", NULL); - tdep->int8 = init_type (TYPE_CODE_INT, 1, 0, "int8_t", NULL); - tdep->int16 = init_type (TYPE_CODE_INT, 2, 0, "int16_t", NULL); - tdep->int32 = init_type (TYPE_CODE_INT, 4, 0, "int32_t", NULL); - tdep->int64 = init_type (TYPE_CODE_INT, 8, 0, "int64_t", NULL); + tdep->uint8 = arch_integer_type (arch, 8, 1, "uint8_t"); + tdep->uint16 = arch_integer_type (arch, 16, 1, "uint16_t"); + tdep->int8 = arch_integer_type (arch, 8, 0, "int8_t"); + tdep->int16 = arch_integer_type (arch, 16, 0, "int16_t"); + tdep->int32 = arch_integer_type (arch, 32, 0, "int32_t"); + tdep->int64 = arch_integer_type (arch, 64, 0, "int64_t"); } @@ -312,18 +314,20 @@ static m32c_move_reg_t m32c_r3r2r1r0_read, m32c_r3r2r1r0_write; /* Copy the value of the raw register REG from CACHE to BUF. */ -static void +static enum register_status m32c_raw_read (struct m32c_reg *reg, struct regcache *cache, void *buf) { - regcache_raw_read (cache, reg->num, buf); + return regcache_raw_read (cache, reg->num, buf); } /* Copy the value of the raw register REG from BUF to CACHE. */ -static void +static enum register_status m32c_raw_write (struct m32c_reg *reg, struct regcache *cache, void *buf) { regcache_raw_write (cache, reg->num, (const void *) buf); + + return REG_VALID; } @@ -350,11 +354,11 @@ m32c_banked_register (struct m32c_reg *reg, struct regcache *cache) If the value of the 'flg' register in CACHE has any of the bits masked in REG->n set, then read REG->ry. Otherwise, read REG->rx. */ -static void +static enum register_status m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, void *buf) { struct m32c_reg *bank_reg = m32c_banked_register (reg, cache); - regcache_raw_read (cache, bank_reg->num, buf); + return regcache_raw_read (cache, bank_reg->num, buf); } @@ -362,35 +366,39 @@ m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, void *buf) If the value of the 'flg' register in CACHE has any of the bits masked in REG->n set, then write REG->ry. Otherwise, write REG->rx. */ -static void +static enum register_status m32c_banked_write (struct m32c_reg *reg, struct regcache *cache, void *buf) { struct m32c_reg *bank_reg = m32c_banked_register (reg, cache); regcache_raw_write (cache, bank_reg->num, (const void *) buf); + + return REG_VALID; } /* Move the value of SB from CACHE to BUF. On bfd_mach_m32c, SB is a banked register; on bfd_mach_m16c, it's not. */ -static void +static enum register_status m32c_sb_read (struct m32c_reg *reg, struct regcache *cache, void *buf) { if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c) - m32c_raw_read (reg->rx, cache, buf); + return m32c_raw_read (reg->rx, cache, buf); else - m32c_banked_read (reg, cache, buf); + return m32c_banked_read (reg, cache, buf); } /* Move the value of SB from BUF to CACHE. On bfd_mach_m32c, SB is a banked register; on bfd_mach_m16c, it's not. */ -static void +static enum register_status m32c_sb_write (struct m32c_reg *reg, struct regcache *cache, void *buf) { if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c) m32c_raw_write (reg->rx, cache, buf); else m32c_banked_write (reg, cache, buf); + + return REG_VALID; } @@ -435,13 +443,14 @@ m32c_find_part (struct m32c_reg *reg, int *offset_p, int *len_p) to BUF. Treating the value of the register REG->rx as an array of REG->type values, where higher indices refer to more significant bits, read the value of the REG->n'th element. */ -static void +static enum register_status m32c_part_read (struct m32c_reg *reg, struct regcache *cache, void *buf) { int offset, len; + memset (buf, 0, TYPE_LENGTH (reg->type)); m32c_find_part (reg, &offset, &len); - regcache_cooked_read_part (cache, reg->rx->num, offset, len, buf); + return regcache_cooked_read_part (cache, reg->rx->num, offset, len, buf); } @@ -449,45 +458,53 @@ m32c_part_read (struct m32c_reg *reg, struct regcache *cache, void *buf) Treating the value of the register REG->rx as an array of REG->type values, where higher indices refer to more significant bits, write the value of the REG->n'th element. */ -static void +static enum register_status m32c_part_write (struct m32c_reg *reg, struct regcache *cache, void *buf) { int offset, len; + m32c_find_part (reg, &offset, &len); regcache_cooked_write_part (cache, reg->rx->num, offset, len, buf); + + return REG_VALID; } /* Move the value of REG from CACHE to BUF. REG's value is the concatenation of the values of the registers REG->rx and REG->ry, with REG->rx contributing the more significant bits. */ -static void +static enum register_status m32c_cat_read (struct m32c_reg *reg, struct regcache *cache, void *buf) { int high_bytes = TYPE_LENGTH (reg->rx->type); int low_bytes = TYPE_LENGTH (reg->ry->type); /* For address arithmetic. */ unsigned char *cbuf = buf; + enum register_status status; gdb_assert (TYPE_LENGTH (reg->type) == high_bytes + low_bytes); if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG) { - regcache_cooked_read (cache, reg->rx->num, cbuf); - regcache_cooked_read (cache, reg->ry->num, cbuf + high_bytes); + status = regcache_cooked_read (cache, reg->rx->num, cbuf); + if (status == REG_VALID) + status = regcache_cooked_read (cache, reg->ry->num, cbuf + high_bytes); } else { - regcache_cooked_read (cache, reg->rx->num, cbuf + low_bytes); - regcache_cooked_read (cache, reg->ry->num, cbuf); + status = regcache_cooked_read (cache, reg->rx->num, cbuf + low_bytes); + if (status == REG_VALID) + status = regcache_cooked_read (cache, reg->ry->num, cbuf); } + + return status; } /* Move the value of REG from CACHE to BUF. REG's value is the concatenation of the values of the registers REG->rx and REG->ry, with REG->rx contributing the more significant bits. */ -static void +static enum register_status m32c_cat_write (struct m32c_reg *reg, struct regcache *cache, void *buf) { int high_bytes = TYPE_LENGTH (reg->rx->type); @@ -507,42 +524,53 @@ m32c_cat_write (struct m32c_reg *reg, struct regcache *cache, void *buf) regcache_cooked_write (cache, reg->rx->num, cbuf + low_bytes); regcache_cooked_write (cache, reg->ry->num, cbuf); } + + return REG_VALID; } /* Copy the value of the raw register REG from CACHE to BUF. REG is the concatenation (from most significant to least) of r3, r2, r1, and r0. */ -static void +static enum register_status m32c_r3r2r1r0_read (struct m32c_reg *reg, struct regcache *cache, void *buf) { struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch); int len = TYPE_LENGTH (tdep->r0->type); + enum register_status status; /* For address arithmetic. */ unsigned char *cbuf = buf; if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG) { - regcache_cooked_read (cache, tdep->r0->num, cbuf + len * 3); - regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 2); - regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 1); - regcache_cooked_read (cache, tdep->r3->num, cbuf); + status = regcache_cooked_read (cache, tdep->r0->num, cbuf + len * 3); + if (status == REG_VALID) + status = regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 2); + if (status == REG_VALID) + status = regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 1); + if (status == REG_VALID) + status = regcache_cooked_read (cache, tdep->r3->num, cbuf); } else { - regcache_cooked_read (cache, tdep->r0->num, cbuf); - regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 1); - regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 2); - regcache_cooked_read (cache, tdep->r3->num, cbuf + len * 3); + status = regcache_cooked_read (cache, tdep->r0->num, cbuf); + if (status == REG_VALID) + status = regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 1); + if (status == REG_VALID) + status = regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 2); + if (status == REG_VALID) + status = regcache_cooked_read (cache, tdep->r3->num, cbuf + len * 3); } + + return status; } /* Copy the value of the raw register REG from BUF to CACHE. REG is the concatenation (from most significant to least) of r3, r2, r1, and r0. */ -static void +static enum register_status m32c_r3r2r1r0_write (struct m32c_reg *reg, struct regcache *cache, void *buf) { struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch); @@ -565,10 +593,12 @@ m32c_r3r2r1r0_write (struct m32c_reg *reg, struct regcache *cache, void *buf) regcache_cooked_write (cache, tdep->r2->num, cbuf + len * 2); regcache_cooked_write (cache, tdep->r3->num, cbuf + len * 3); } + + return REG_VALID; } -static void +static enum register_status m32c_pseudo_register_read (struct gdbarch *arch, struct regcache *cache, int cookednum, @@ -582,7 +612,7 @@ m32c_pseudo_register_read (struct gdbarch *arch, gdb_assert (arch == tdep->regs[cookednum].arch); reg = &tdep->regs[cookednum]; - reg->read (reg, cache, buf); + return reg->read (reg, cache, buf); } @@ -1240,7 +1270,7 @@ m32c_decode_srcdest4 (struct m32c_pv_state *st, case 0xf: sd.addr = pv_constant (m32c_udisp16 (st)); break; default: - gdb_assert (0); + gdb_assert_not_reached ("unexpected srcdest4"); } return sd; @@ -1299,7 +1329,7 @@ m32c_decode_sd23 (struct m32c_pv_state *st, int code, int size, int ind) case 0x0f: sd.addr = pv_constant (m32c_udisp16 (st)); break; case 0x0e: sd.addr = pv_constant (m32c_udisp24 (st)); break; default: - gdb_assert (0); + gdb_assert_not_reached ("unexpected sd23"); } if (ind) @@ -1804,7 +1834,7 @@ m32c_analyze_prologue (struct gdbarch *arch, static CORE_ADDR m32c_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip) { - char *name; + const char *name; CORE_ADDR func_addr, func_end, sal_end; struct m32c_prologue p; @@ -1815,7 +1845,7 @@ m32c_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip) /* Find end by prologue analysis. */ m32c_analyze_prologue (gdbarch, ip, func_end, &p); /* Find end by line info. */ - sal_end = skip_prologue_using_sal (ip); + sal_end = skip_prologue_using_sal (gdbarch, ip); /* Return whichever is lower. */ if (sal_end != 0 && sal_end != ip && sal_end < p.prologue_end) return sal_end; @@ -1884,7 +1914,7 @@ m32c_frame_base (struct frame_info *this_frame, return 0; default: - gdb_assert (0); + gdb_assert_not_reached ("unexpected prologue kind"); } } @@ -1929,6 +1959,7 @@ m32c_prev_register (struct frame_info *this_frame, static const struct frame_unwind m32c_unwind = { NORMAL_FRAME, + default_frame_unwind_stop_reason, m32c_this_id, m32c_prev_register, NULL, @@ -2004,6 +2035,7 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function, CORE_ADDR struct_addr) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); unsigned long mach = gdbarch_bfd_arch_info (gdbarch)->mach; CORE_ADDR cfa; int i; @@ -2041,7 +2073,7 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { int ptr_len = TYPE_LENGTH (tdep->ptr_voyd); sp -= ptr_len; - write_memory_unsigned_integer (sp, ptr_len, struct_addr); + write_memory_unsigned_integer (sp, ptr_len, byte_order, struct_addr); } /* Push the arguments. */ @@ -2062,7 +2094,8 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function, sure it ends up in the least significant end of r1. (GDB should avoid assuming endianness, even on uni-endian processors.) */ - ULONGEST u = extract_unsigned_integer (arg_bits, arg_size); + ULONGEST u = extract_unsigned_integer (arg_bits, arg_size, + byte_order); struct m32c_reg *reg = (mach == bfd_mach_m16c) ? tdep->r1 : tdep->r0; regcache_cooked_write_unsigned (regcache, reg->num, u); } @@ -2093,7 +2126,8 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Push the return address. */ sp -= tdep->ret_addr_bytes; - write_memory_unsigned_integer (sp, tdep->ret_addr_bytes, bp_addr); + write_memory_unsigned_integer (sp, tdep->ret_addr_bytes, byte_order, + bp_addr); /* Update the stack pointer. */ regcache_cooked_write_unsigned (regcache, tdep->sp->num, sp); @@ -2172,13 +2206,14 @@ m32c_return_by_passed_buf (struct type *type) static enum return_value_convention m32c_return_value (struct gdbarch *gdbarch, - struct type *func_type, + struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); enum return_value_convention conv; ULONGEST valtype_len = TYPE_LENGTH (valtype); @@ -2201,7 +2236,7 @@ m32c_return_value (struct gdbarch *gdbarch, { ULONGEST u; regcache_cooked_read_unsigned (regcache, tdep->r0->num, &u); - store_unsigned_integer (readbuf, valtype_len, u); + store_unsigned_integer (readbuf, valtype_len, byte_order, u); } else { @@ -2212,9 +2247,9 @@ m32c_return_value (struct gdbarch *gdbarch, = lookup_minimal_symbol ("mem0", NULL, NULL); if (! mem0) - error ("The return value is stored in memory at 'mem0', " - "but GDB cannot find\n" - "its address."); + error (_("The return value is stored in memory at 'mem0', " + "but GDB cannot find\n" + "its address.")); read_memory (SYMBOL_VALUE_ADDRESS (mem0), readbuf, valtype_len); } } @@ -2231,7 +2266,8 @@ m32c_return_value (struct gdbarch *gdbarch, /* Anything that fits in r0 is returned there. */ if (valtype_len <= TYPE_LENGTH (tdep->r0->type)) { - ULONGEST u = extract_unsigned_integer (writebuf, valtype_len); + ULONGEST u = extract_unsigned_integer (writebuf, valtype_len, + byte_order); regcache_cooked_write_unsigned (regcache, tdep->r0->num, u); } else @@ -2243,9 +2279,9 @@ m32c_return_value (struct gdbarch *gdbarch, = lookup_minimal_symbol ("mem0", NULL, NULL); if (! mem0) - error ("The return value is stored in memory at 'mem0', " - "but GDB cannot find\n" - " its address."); + error (_("The return value is stored in memory at 'mem0', " + "but GDB cannot find\n" + " its address.")); write_memory (SYMBOL_VALUE_ADDRESS (mem0), (char *) writebuf, valtype_len); } @@ -2307,7 +2343,9 @@ 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 (get_frame_arch (frame)); + struct gdbarch *gdbarch = get_frame_arch (frame); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); /* It would be nicer to simply look up the addresses of known trampolines once, and then compare stop_pc with them. However, @@ -2315,7 +2353,7 @@ m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc) someone loaded a new executable, and I'm not quite sure of the best way to do that. find_pc_partial_function does do some caching, so we'll see how this goes. */ - char *name; + const char *name; CORE_ADDR start, end; if (find_pc_partial_function (stop_pc, &name, &start, &end)) @@ -2330,13 +2368,14 @@ m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc) m32c_jsri*16*. */ CORE_ADDR sp = get_frame_sp (get_current_frame ()); CORE_ADDR target - = read_memory_unsigned_integer (sp + tdep->ret_addr_bytes, 2); + = read_memory_unsigned_integer (sp + tdep->ret_addr_bytes, + 2, byte_order); /* What we have now is the address of a jump instruction. What we need is the destination of that jump. - The opcode is 1 byte, and the destination is the next 3 bytes. - */ - target = read_memory_unsigned_integer (target + 1, 3); + The opcode is 1 byte, and the destination is the next 3 bytes. */ + + target = read_memory_unsigned_integer (target + 1, 3, byte_order); return target; } } @@ -2401,8 +2440,10 @@ m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc) programmer! :) */ static void -m32c_m16c_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) +m32c_m16c_address_to_pointer (struct gdbarch *gdbarch, + struct type *type, gdb_byte *buf, CORE_ADDR addr) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); enum type_code target_code; gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF); @@ -2411,7 +2452,7 @@ m32c_m16c_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD) { - char *func_name; + const char *func_name; char *tramp_name; struct minimal_symbol *tramp_msym; @@ -2419,9 +2460,9 @@ m32c_m16c_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) struct minimal_symbol *func_msym = lookup_minimal_symbol_by_pc (addr); if (! func_msym) - error ("Cannot convert code address %s to function pointer:\n" - "couldn't find a symbol at that address, to find trampoline.", - paddr_nz (addr)); + error (_("Cannot convert code address %s to function pointer:\n" + "couldn't find a symbol at that address, to find trampoline."), + paddress (gdbarch, addr)); func_name = SYMBOL_LINKAGE_NAME (func_msym); tramp_name = xmalloc (strlen (func_name) + 5); @@ -2436,28 +2477,57 @@ m32c_m16c_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) xfree (tramp_name); if (! tramp_msym) - error ("Cannot convert code address %s to function pointer:\n" - "couldn't find trampoline named '%s.plt'.", - paddr_nz (addr), func_name); + { + CORE_ADDR ptrval; + + /* No PLT entry found. Mask off the upper bits of the address + to make a pointer. As noted in the warning to the user + below, this value might be useful if converted back into + an address by GDB, but will otherwise, almost certainly, + be garbage. + + Using this masked result does seem to be useful + in gdb.cp/cplusfuncs.exp in which ~40 FAILs turn into + PASSes. These results appear to be correct as well. + + We print a warning here so that the user can make a + determination about whether the result is useful or not. */ + ptrval = addr & 0xffff; + + warning (_("Cannot convert code address %s to function pointer:\n" + "couldn't find trampoline named '%s.plt'.\n" + "Returning pointer value %s instead; this may produce\n" + "a useful result if converted back into an address by GDB,\n" + "but will most likely not be useful otherwise.\n"), + paddress (gdbarch, addr), func_name, + paddress (gdbarch, ptrval)); + + addr = ptrval; - /* The trampoline's address is our pointer. */ - addr = SYMBOL_VALUE_ADDRESS (tramp_msym); + } + else + { + /* The trampoline's address is our pointer. */ + addr = SYMBOL_VALUE_ADDRESS (tramp_msym); + } } - store_unsigned_integer (buf, TYPE_LENGTH (type), addr); + store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr); } static CORE_ADDR -m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf) +m32c_m16c_pointer_to_address (struct gdbarch *gdbarch, + struct type *type, const gdb_byte *buf) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR ptr; enum type_code target_code; gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF); - ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type)); + ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order); target_code = TYPE_CODE (TYPE_TARGET_TYPE (type)); @@ -2469,7 +2539,7 @@ m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf) if (ptr_msym) { - char *ptr_msym_name = SYMBOL_LINKAGE_NAME (ptr_msym); + const char *ptr_msym_name = SYMBOL_LINKAGE_NAME (ptr_msym); int len = strlen (ptr_msym_name); if (len > 4 @@ -2494,6 +2564,18 @@ m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf) ptr = SYMBOL_VALUE_ADDRESS (func_msym); } } + else + { + int aspace; + + for (aspace = 1; aspace <= 15; aspace++) + { + ptr_msym = lookup_minimal_symbol_by_pc ((aspace << 16) | ptr); + + if (ptr_msym) + ptr |= aspace << 16; + } + } } return ptr; @@ -2504,15 +2586,16 @@ m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset) { - char *name; - CORE_ADDR func_addr, func_end, sal_end; + const char *name; + CORE_ADDR func_addr, func_end; struct m32c_prologue p; 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")); + internal_error (__FILE__, __LINE__, + _("No virtual frame pointer available")); m32c_analyze_prologue (gdbarch, func_addr, pc, &p); switch (p.kind) @@ -2532,7 +2615,8 @@ m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, } /* Sanity check */ if (*frame_regnum > gdbarch_num_regs (gdbarch)) - internal_error (__FILE__, __LINE__, _("No virtual frame pointer available")); + internal_error (__FILE__, __LINE__, + _("No virtual frame pointer available")); } @@ -2584,8 +2668,7 @@ m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) They may be in the dwarf2 cfi code in GDB, or they may be in the debug info emitted by the upstream toolchain. I don't know which, but I do know that the prologue analyzer works better. - MVS 04/13/06 - */ + MVS 04/13/06 */ dwarf2_append_sniffers (arch); #endif frame_unwind_append_unwinder (arch, &m32c_unwind); @@ -2603,7 +2686,7 @@ m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* 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. + 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