X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fia64-tdep.c;h=d396fb81a62b0c2522900fd9cb0980aa2a5fb767;hb=2f91880f3afb3cc521111dfcc99b214c77aa97a1;hp=a7a802ab8a6797d3417cf032a6c9e3f73d9805f2;hpb=22e048c9ddfdfd4e4580998f543f80e70f9770f7;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c index a7a802ab8a..d396fb81a6 100644 --- a/gdb/ia64-tdep.c +++ b/gdb/ia64-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for the IA-64 for GDB, the GNU debugger. - Copyright (C) 1999-2012 Free Software Foundation, Inc. + Copyright (C) 1999-2017 Free Software Foundation, Inc. This file is part of GDB. @@ -30,7 +30,6 @@ #include "frame-unwind.h" #include "doublest.h" #include "value.h" -#include "gdb_assert.h" #include "objfiles.h" #include "elf/common.h" /* for DT_PLTGOT value */ #include "elf-bfd.h" @@ -126,9 +125,10 @@ static CORE_ADDR ia64_find_global_pointer (struct gdbarch *gdbarch, #define NUM_IA64_RAW_REGS 462 +/* Big enough to hold a FP register in bytes. */ +#define IA64_FP_REGISTER_SIZE 16 + static int sp_regnum = IA64_GR12_REGNUM; -static int fp_regnum = IA64_VFP_REGNUM; -static int lr_regnum = IA64_VRAP_REGNUM; /* NOTE: we treat the register stack registers r32-r127 as pseudo-registers because they may not be accessible via the ptrace @@ -143,7 +143,7 @@ enum pseudo_regs { FIRST_PSEUDO_REGNUM = NUM_IA64_RAW_REGS, /* Array of register names; There should be ia64_num_regs strings in the initializer. */ -static char *ia64_register_names[] = +static const char *ia64_register_names[] = { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", @@ -370,7 +370,7 @@ ia64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg) bit ``from''. */ static long long -extract_bit_field (const char *bundle, int from, int len) +extract_bit_field (const gdb_byte *bundle, int from, int len) { long long result = 0LL; int to = from + len; @@ -406,7 +406,7 @@ extract_bit_field (const char *bundle, int from, int len) /* Replace the specified bits in an instruction bundle. */ static void -replace_bit_field (char *bundle, long long val, int from, int len) +replace_bit_field (gdb_byte *bundle, long long val, int from, int len) { int to = from + len; int from_byte = from / 8; @@ -456,7 +456,7 @@ replace_bit_field (char *bundle, long long val, int from, int len) and instruction bundle. */ static long long -slotN_contents (char *bundle, int slotnum) +slotN_contents (gdb_byte *bundle, int slotnum) { return extract_bit_field (bundle, 5+41*slotnum, 41); } @@ -464,7 +464,7 @@ slotN_contents (char *bundle, int slotnum) /* Store an instruction in an instruction bundle. */ static void -replace_slotN_contents (char *bundle, long long instr, int slotnum) +replace_slotN_contents (gdb_byte *bundle, long long instr, int slotnum) { replace_bit_field (bundle, instr, 5+41*slotnum, 41); } @@ -511,9 +511,9 @@ static const enum instruction_type template_encoding_table[32][3] = static CORE_ADDR fetch_instruction (CORE_ADDR addr, instruction_type *it, long long *instr) { - char bundle[BUNDLE_LEN]; + gdb_byte bundle[BUNDLE_LEN]; int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER; - long long template; + long long templ; int val; /* Warn about slot numbers greater than 2. We used to generate @@ -544,8 +544,8 @@ fetch_instruction (CORE_ADDR addr, instruction_type *it, long long *instr) return 0; *instr = slotN_contents (bundle, slotnum); - template = extract_bit_field (bundle, 0, 5); - *it = template_encoding_table[(int)template][slotnum]; + templ = extract_bit_field (bundle, 0, 5); + *it = template_encoding_table[(int)templ][slotnum]; if (slotnum == 2 || (slotnum == 1 && *it == L)) addr += 16; @@ -638,12 +638,12 @@ static int ia64_memory_insert_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) { - CORE_ADDR addr = bp_tgt->placed_address; + CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address; gdb_byte bundle[BUNDLE_LEN]; int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER, shadow_slotnum; long long instr_breakpoint; int val; - int template; + int templ; struct cleanup *cleanup; if (slotnum > 2) @@ -672,8 +672,8 @@ ia64_memory_insert_breakpoint (struct gdbarch *gdbarch, a breakpoint on an L-X instruction. */ bp_tgt->shadow_len = BUNDLE_LEN - shadow_slotnum; - template = extract_bit_field (bundle, 0, 5); - if (template_encoding_table[template][slotnum] == X) + templ = extract_bit_field (bundle, 0, 5); + if (template_encoding_table[templ][slotnum] == X) { /* X unit types can only be used in slot 2, and are actually part of a 2-slot L-X instruction. We cannot break at this @@ -682,7 +682,7 @@ ia64_memory_insert_breakpoint (struct gdbarch *gdbarch, gdb_assert (slotnum == 2); error (_("Can't insert breakpoint for non-existing slot X")); } - if (template_encoding_table[template][slotnum] == L) + if (template_encoding_table[templ][slotnum] == L) { /* L unit types can only be used in slot 1. But the associated opcode for that instruction is in slot 2, so bump the slot number @@ -722,8 +722,6 @@ ia64_memory_insert_breakpoint (struct gdbarch *gdbarch, paddress (gdbarch, bp_tgt->placed_address)); replace_slotN_contents (bundle, IA64_BREAKPOINT, slotnum); - bp_tgt->placed_size = bp_tgt->shadow_len; - val = target_write_memory (addr + shadow_slotnum, bundle + shadow_slotnum, bp_tgt->shadow_len); @@ -740,7 +738,7 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, int slotnum = (addr & 0x0f) / SLOT_MULTIPLIER, shadow_slotnum; long long instr_breakpoint, instr_saved; int val; - int template; + int templ; struct cleanup *cleanup; addr &= ~0x0f; @@ -762,8 +760,8 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, for addressing the SHADOW_CONTENTS placement. */ shadow_slotnum = slotnum; - template = extract_bit_field (bundle_mem, 0, 5); - if (template_encoding_table[template][slotnum] == X) + templ = extract_bit_field (bundle_mem, 0, 5); + if (template_encoding_table[templ][slotnum] == X) { /* X unit types can only be used in slot 2, and are actually part of a 2-slot L-X instruction. We refuse to insert @@ -777,7 +775,7 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, do_cleanups (cleanup); return -1; } - if (template_encoding_table[template][slotnum] == L) + if (template_encoding_table[templ][slotnum] == L) { /* L unit types can only be used in slot 1. But the breakpoint was actually saved using slot 2, so update the slot number @@ -786,8 +784,7 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, slotnum = 2; } - gdb_assert (bp_tgt->placed_size == BUNDLE_LEN - shadow_slotnum); - gdb_assert (bp_tgt->placed_size == bp_tgt->shadow_len); + gdb_assert (bp_tgt->shadow_len == BUNDLE_LEN - shadow_slotnum); instr_breakpoint = slotN_contents (bundle_mem, slotnum); if (instr_breakpoint != IA64_BREAKPOINT) @@ -815,6 +812,15 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, return val; } +/* Implement the breakpoint_kind_from_pc gdbarch method. */ + +static int +ia64_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr) +{ + /* A place holder of gdbarch method breakpoint_kind_from_pc. */ + return 0; +} + /* As gdbarch_breakpoint_from_pc ranges have byte granularity and ia64 instruction slots ranges are bit-granular (41 bits) we have to provide an extended range as described for ia64_memory_insert_breakpoint. We also take @@ -830,7 +836,7 @@ ia64_breakpoint_from_pc (struct gdbarch *gdbarch, int slotnum = (int) (*pcptr & 0x0f) / SLOT_MULTIPLIER, shadow_slotnum; long long instr_fetched; int val; - int template; + int templ; struct cleanup *cleanup; if (slotnum > 2) @@ -858,13 +864,13 @@ ia64_breakpoint_from_pc (struct gdbarch *gdbarch, /* Check for L type instruction in slot 1, if present then bump up the slot number to the slot 2. */ - template = extract_bit_field (bundle, 0, 5); - if (template_encoding_table[template][slotnum] == X) + templ = extract_bit_field (bundle, 0, 5); + if (template_encoding_table[templ][slotnum] == X) { gdb_assert (slotnum == 2); error (_("Can't insert breakpoint for non-existing slot X")); } - if (template_encoding_table[template][slotnum] == L) + if (template_encoding_table[templ][slotnum] == L) { gdb_assert (slotnum == 1); slotnum = 2; @@ -1104,7 +1110,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, if ((cfm & 0x7f) > regnum - V32_REGNUM) { ULONGEST reg_addr = rse_address_add (bsp, (regnum - V32_REGNUM)); - write_memory (reg_addr, (void *) buf, 8); + write_memory (reg_addr, buf, 8); } } else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM) @@ -1165,7 +1171,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, } else { - char nat_buf[8]; + gdb_byte nat_buf[8]; nat_collection = read_memory_integer (nat_addr, 8, byte_order); if (natN_val) nat_collection |= natN_mask; @@ -1215,6 +1221,7 @@ static int ia64_convert_register_p (struct gdbarch *gdbarch, int regno, struct type *type) { return (regno >= IA64_FR0_REGNUM && regno <= IA64_FR127_REGNUM + && TYPE_CODE (type) == TYPE_CODE_FLT && type != ia64_ext_type (gdbarch)); } @@ -1224,7 +1231,7 @@ ia64_register_to_value (struct frame_info *frame, int regnum, int *optimizedp, int *unavailablep) { struct gdbarch *gdbarch = get_frame_arch (frame); - char in[MAX_REGISTER_SIZE]; + gdb_byte in[IA64_FP_REGISTER_SIZE]; /* Convert to TYPE. */ if (!get_frame_register_bytes (frame, regnum, 0, @@ -1242,7 +1249,7 @@ ia64_value_to_register (struct frame_info *frame, int regnum, struct type *valtype, const gdb_byte *in) { struct gdbarch *gdbarch = get_frame_arch (frame); - char out[MAX_REGISTER_SIZE]; + gdb_byte out[IA64_FP_REGISTER_SIZE]; convert_typed_floating (in, valtype, out, ia64_ext_type (gdbarch)); put_frame_register (frame, regnum, out); } @@ -1380,7 +1387,7 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, int frameless = 1; int i; CORE_ADDR addr; - char buf[8]; + gdb_byte buf[8]; CORE_ADDR bof, sor, sol, sof, cfm, rrb_gr; memset (instores, 0, sizeof instores); @@ -1400,7 +1407,6 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, && it == M && ((instr & 0x1ee0000003fLL) == 0x02c00000000LL)) { /* alloc - start of a regular function. */ - int sor = (int) ((instr & 0x00078000000LL) >> 27); int sol = (int) ((instr & 0x00007f00000LL) >> 20); int sof = (int) ((instr & 0x000000fe000LL) >> 13); int rN = (int) ((instr & 0x00000001fc0LL) >> 6); @@ -1514,7 +1520,6 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, else if (qp == 0 && rN == 2 && ((rM == fp_reg && fp_reg != 0) || rM == 12)) { - char buf[MAX_REGISTER_SIZE]; CORE_ADDR saved_sp = 0; /* adds r2, spilloffset, rFramePointer or @@ -1531,9 +1536,8 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, if (this_frame) { struct gdbarch *gdbarch = get_frame_arch (this_frame); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - get_frame_register (this_frame, sp_regnum, buf); - saved_sp = extract_unsigned_integer (buf, 8, byte_order); + saved_sp = get_frame_register_unsigned (this_frame, + sp_regnum); } spill_addr = saved_sp + (rM == 12 ? 0 : mem_stack_frame_size) @@ -1850,11 +1854,11 @@ ia64_frame_cache (struct frame_info *this_frame, void **this_cache) struct gdbarch *gdbarch = get_frame_arch (this_frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct ia64_frame_cache *cache; - char buf[8]; - CORE_ADDR cfm, psr; + gdb_byte buf[8]; + CORE_ADDR cfm; if (*this_cache) - return *this_cache; + return (struct ia64_frame_cache *) *this_cache; cache = ia64_alloc_frame_cache (); *this_cache = cache; @@ -1869,7 +1873,6 @@ ia64_frame_cache (struct frame_info *this_frame, void **this_cache) cache->bsp = extract_unsigned_integer (buf, 8, byte_order); get_frame_register (this_frame, IA64_PSR_REGNUM, buf); - psr = extract_unsigned_integer (buf, 8, byte_order); get_frame_register (this_frame, IA64_CFM_REGNUM, buf); cfm = extract_unsigned_integer (buf, 8, byte_order); @@ -1918,7 +1921,7 @@ ia64_frame_prev_register (struct frame_info *this_frame, void **this_cache, struct gdbarch *gdbarch = get_frame_arch (this_frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct ia64_frame_cache *cache = ia64_frame_cache (this_frame, this_cache); - char buf[8]; + gdb_byte buf[8]; gdb_assert (regnum >= 0); @@ -2238,10 +2241,10 @@ ia64_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache) struct gdbarch *gdbarch = get_frame_arch (this_frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct ia64_frame_cache *cache; - char buf[8]; + gdb_byte buf[8]; if (*this_cache) - return *this_cache; + return (struct ia64_frame_cache *) *this_cache; cache = ia64_alloc_frame_cache (); @@ -2288,10 +2291,6 @@ static struct value * ia64_sigtramp_frame_prev_register (struct frame_info *this_frame, void **this_cache, int regnum) { - char buf[MAX_REGISTER_SIZE]; - - struct gdbarch *gdbarch = get_frame_arch (this_frame); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct ia64_frame_cache *cache = ia64_sigtramp_frame_cache (this_frame, this_cache); @@ -2307,8 +2306,9 @@ ia64_sigtramp_frame_prev_register (struct frame_info *this_frame, if (addr != 0) { - read_memory (addr, buf, register_size (gdbarch, IA64_IP_REGNUM)); - pc = extract_unsigned_integer (buf, 8, byte_order); + struct gdbarch *gdbarch = get_frame_arch (this_frame); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + pc = read_memory_unsigned_integer (addr, 8, byte_order); } pc &= ~0xf; return frame_unwind_got_constant (this_frame, regnum, pc); @@ -2489,12 +2489,11 @@ ia64_access_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *val, int write, void *arg) { int regnum = ia64_uw2gdb_regnum (uw_regnum); - unw_word_t bsp, sof, sol, cfm, psr, ip; - struct frame_info *this_frame = arg; + unw_word_t bsp, sof, cfm, psr, ip; + struct frame_info *this_frame = (struct frame_info *) arg; struct gdbarch *gdbarch = get_frame_arch (this_frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); long new_sof, old_sof; - char buf[MAX_REGISTER_SIZE]; /* We never call any libunwind routines that need to write registers. */ gdb_assert (!write); @@ -2504,10 +2503,8 @@ ia64_access_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *val, case UNW_REG_IP: /* Libunwind expects to see the pc value which means the slot number from the psr must be merged with the ip word address. */ - get_frame_register (this_frame, IA64_IP_REGNUM, buf); - ip = extract_unsigned_integer (buf, 8, byte_order); - get_frame_register (this_frame, IA64_PSR_REGNUM, buf); - psr = extract_unsigned_integer (buf, 8, byte_order); + ip = get_frame_register_unsigned (this_frame, IA64_IP_REGNUM); + psr = get_frame_register_unsigned (this_frame, IA64_PSR_REGNUM); *val = ip | ((psr >> 41) & 0x3); break; @@ -2516,10 +2513,8 @@ ia64_access_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *val, register frame so we must account for the fact that ptrace() will return a value for bsp that points *after* the current register frame. */ - get_frame_register (this_frame, IA64_BSP_REGNUM, buf); - bsp = extract_unsigned_integer (buf, 8, byte_order); - get_frame_register (this_frame, IA64_CFM_REGNUM, buf); - cfm = extract_unsigned_integer (buf, 8, byte_order); + bsp = get_frame_register_unsigned (this_frame, IA64_BSP_REGNUM); + cfm = get_frame_register_unsigned (this_frame, IA64_CFM_REGNUM); sof = gdbarch_tdep (gdbarch)->size_of_register_frame (this_frame, cfm); *val = ia64_rse_skip_regs (bsp, -sof); break; @@ -2527,14 +2522,12 @@ ia64_access_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *val, case UNW_IA64_AR_BSPSTORE: /* Libunwind wants bspstore to be after the current register frame. This is what ptrace() and gdb treats as the regular bsp value. */ - get_frame_register (this_frame, IA64_BSP_REGNUM, buf); - *val = extract_unsigned_integer (buf, 8, byte_order); + *val = get_frame_register_unsigned (this_frame, IA64_BSP_REGNUM); break; default: /* For all other registers, just unwind the value directly. */ - get_frame_register (this_frame, regnum, buf); - *val = extract_unsigned_integer (buf, 8, byte_order); + *val = get_frame_register_unsigned (this_frame, regnum); break; } @@ -2553,12 +2546,12 @@ ia64_access_fpreg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_fpreg_t *val, int write, void *arg) { int regnum = ia64_uw2gdb_regnum (uw_regnum); - struct frame_info *this_frame = arg; + struct frame_info *this_frame = (struct frame_info *) arg; /* We never call any libunwind routines that need to write registers. */ gdb_assert (!write); - get_frame_register (this_frame, regnum, (char *) val); + get_frame_register (this_frame, regnum, (gdb_byte *) val); return 0; } @@ -2569,12 +2562,11 @@ ia64_access_rse_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *val, int write, void *arg) { int regnum = ia64_uw2gdb_regnum (uw_regnum); - unw_word_t bsp, sof, sol, cfm, psr, ip; - struct regcache *regcache = arg; + unw_word_t bsp, sof, cfm, psr, ip; + struct regcache *regcache = (struct regcache *) arg; struct gdbarch *gdbarch = get_regcache_arch (regcache); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); long new_sof, old_sof; - char buf[MAX_REGISTER_SIZE]; /* We never call any libunwind routines that need to write registers. */ gdb_assert (!write); @@ -2584,10 +2576,8 @@ ia64_access_rse_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, case UNW_REG_IP: /* Libunwind expects to see the pc value which means the slot number from the psr must be merged with the ip word address. */ - regcache_cooked_read (regcache, IA64_IP_REGNUM, buf); - ip = extract_unsigned_integer (buf, 8, byte_order); - regcache_cooked_read (regcache, IA64_PSR_REGNUM, buf); - psr = extract_unsigned_integer (buf, 8, byte_order); + regcache_cooked_read_unsigned (regcache, IA64_IP_REGNUM, &ip); + regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr); *val = ip | ((psr >> 41) & 0x3); break; @@ -2596,10 +2586,8 @@ ia64_access_rse_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, register frame so we must account for the fact that ptrace() will return a value for bsp that points *after* the current register frame. */ - regcache_cooked_read (regcache, IA64_BSP_REGNUM, buf); - bsp = extract_unsigned_integer (buf, 8, byte_order); - regcache_cooked_read (regcache, IA64_CFM_REGNUM, buf); - cfm = extract_unsigned_integer (buf, 8, byte_order); + regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp); + regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm); sof = (cfm & 0x7f); *val = ia64_rse_skip_regs (bsp, -sof); break; @@ -2607,14 +2595,12 @@ ia64_access_rse_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, case UNW_IA64_AR_BSPSTORE: /* Libunwind wants bspstore to be after the current register frame. This is what ptrace() and gdb treats as the regular bsp value. */ - regcache_cooked_read (regcache, IA64_BSP_REGNUM, buf); - *val = extract_unsigned_integer (buf, 8, byte_order); + regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, val); break; default: /* For all other registers, just unwind the value directly. */ - regcache_cooked_read (regcache, regnum, buf); - *val = extract_unsigned_integer (buf, 8, byte_order); + regcache_cooked_read_unsigned (regcache, regnum, val); break; } @@ -2634,12 +2620,12 @@ ia64_access_rse_fpreg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_fpreg_t *val, int write, void *arg) { int regnum = ia64_uw2gdb_regnum (uw_regnum); - struct regcache *regcache = arg; + struct regcache *regcache = (struct regcache *) arg; /* We never call any libunwind routines that need to write registers. */ gdb_assert (!write); - regcache_cooked_read (regcache, regnum, (char *) val); + regcache_cooked_read (regcache, regnum, (gdb_byte *) val); return 0; } @@ -2664,9 +2650,9 @@ ia64_access_mem (unw_addr_space_t as, /* XXX do we need to normalize byte-order here? */ if (write) - return target_write_memory (addr, (char *) val, sizeof (unw_word_t)); + return target_write_memory (addr, (gdb_byte *) val, sizeof (unw_word_t)); else - return target_read_memory (addr, (char *) val, sizeof (unw_word_t)); + return target_read_memory (addr, (gdb_byte *) val, sizeof (unw_word_t)); } /* Call low-level function to access the kernel unwind table. */ @@ -2929,7 +2915,7 @@ ia64_libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache, struct gdbarch *gdbarch = get_frame_arch (this_frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct frame_id id = outer_frame_id; - char buf[8]; + gdb_byte buf[8]; CORE_ADDR bsp; libunwind_frame_this_id (this_frame, this_cache, &id); @@ -2981,12 +2967,10 @@ ia64_libunwind_frame_prev_register (struct frame_info *this_frame, { int rrb_pr = 0; ULONGEST cfm; - unsigned char buf[MAX_REGISTER_SIZE]; /* Fetch predicate register rename base from current frame marker for this frame. */ - get_frame_register (this_frame, IA64_CFM_REGNUM, buf); - cfm = extract_unsigned_integer (buf, 8, byte_order); + cfm = get_frame_register_unsigned (this_frame, IA64_CFM_REGNUM); rrb_pr = (cfm >> 32) & 0x3f; /* Adjust the register number to account for register rotation. */ @@ -3060,7 +3044,7 @@ ia64_libunwind_sigtramp_frame_this_id (struct frame_info *this_frame, { struct gdbarch *gdbarch = get_frame_arch (this_frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - char buf[8]; + gdb_byte buf[8]; CORE_ADDR bsp; struct frame_id id = outer_frame_id; CORE_ADDR prev_ip; @@ -3228,7 +3212,7 @@ ia64_extract_return_value (struct type *type, struct regcache *regcache, float_elt_type = is_float_or_hfa_type (type); if (float_elt_type != NULL) { - char from[MAX_REGISTER_SIZE]; + gdb_byte from[IA64_FP_REGISTER_SIZE]; int offset = 0; int regnum = IA64_FR8_REGNUM; int n = TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type); @@ -3293,7 +3277,7 @@ ia64_store_return_value (struct type *type, struct regcache *regcache, float_elt_type = is_float_or_hfa_type (type); if (float_elt_type != NULL) { - char to[MAX_REGISTER_SIZE]; + gdb_byte to[IA64_FP_REGISTER_SIZE]; int offset = 0; int regnum = IA64_FR8_REGNUM; int n = TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type); @@ -3480,7 +3464,7 @@ ia64_find_global_pointer_from_dynamic_section (struct gdbarch *gdbarch, { int status; LONGEST tag; - char buf[8]; + gdb_byte buf[8]; status = target_read_memory (addr, buf, sizeof (buf)); if (status != 0) @@ -3563,7 +3547,7 @@ find_extant_func_descr (struct gdbarch *gdbarch, CORE_ADDR faddr) { int status; LONGEST faddr2; - char buf[8]; + gdb_byte buf[8]; status = target_read_memory (addr, buf, sizeof (buf)); if (status != 0) @@ -3596,7 +3580,7 @@ find_func_descr (struct regcache *regcache, CORE_ADDR faddr, CORE_ADDR *fdaptr) if (fdesc == 0) { ULONGEST global_pointer; - char buf[16]; + gdb_byte buf[16]; fdesc = *fdaptr; *fdaptr += 16; @@ -3651,11 +3635,12 @@ ia64_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, /* There are also descriptors embedded in vtables. */ if (s) { - struct minimal_symbol *minsym; + struct bound_minimal_symbol minsym; minsym = lookup_minimal_symbol_by_pc (addr); - if (minsym && is_vtable_name (SYMBOL_LINKAGE_NAME (minsym))) + if (minsym.minsym + && is_vtable_name (MSYMBOL_LINKAGE_NAME (minsym.minsym))) return read_memory_unsigned_integer (addr, 8, byte_order); } @@ -3723,7 +3708,7 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, int nslots, rseslots, memslots, slotnum, nfuncargs; int floatreg; ULONGEST bsp; - CORE_ADDR funcdescaddr, pc, global_pointer; + CORE_ADDR funcdescaddr, global_pointer; CORE_ADDR func_addr = find_function_addr (function, NULL); nslots = 0; @@ -3783,7 +3768,7 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, && TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC) { - char val_buf[8]; + gdb_byte val_buf[8]; ULONGEST faddr = extract_unsigned_integer (value_contents (arg), 8, byte_order); store_unsigned_integer (val_buf, 8, byte_order, @@ -3807,7 +3792,7 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, argoffset = 0; while (len > 0) { - char val_buf[8]; + gdb_byte val_buf[8]; memset (val_buf, 0, 8); if (!ia64_struct_type_p (type) && len < 8) @@ -3854,11 +3839,11 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, len = TYPE_LENGTH (type); while (len > 0 && floatreg < IA64_FR16_REGNUM) { - char to[MAX_REGISTER_SIZE]; + gdb_byte to[IA64_FP_REGISTER_SIZE]; convert_typed_floating (value_contents (arg) + argoffset, float_elt_type, to, ia64_ext_type (gdbarch)); - regcache_cooked_write (regcache, floatreg, (void *)to); + regcache_cooked_write (regcache, floatreg, to); floatreg++; argoffset += TYPE_LENGTH (float_elt_type); len -= TYPE_LENGTH (float_elt_type); @@ -3903,7 +3888,7 @@ static struct frame_id ia64_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - char buf[8]; + gdb_byte buf[8]; CORE_ADDR sp, bsp; get_frame_register (this_frame, sp_regnum, buf); @@ -3925,7 +3910,7 @@ static CORE_ADDR ia64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - char buf[8]; + gdb_byte buf[8]; CORE_ADDR ip, psr, pc; frame_unwind_register (next_frame, IA64_IP_REGNUM, buf); @@ -3963,7 +3948,7 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) if (arches != NULL) return arches->gdbarch; - tdep = xzalloc (sizeof (struct gdbarch_tdep)); + tdep = XCNEW (struct gdbarch_tdep); gdbarch = gdbarch_alloc (&info, tdep); tdep->size_of_register_frame = ia64_size_of_register_frame; @@ -4013,6 +3998,7 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint); set_gdbarch_breakpoint_from_pc (gdbarch, ia64_breakpoint_from_pc); + set_gdbarch_breakpoint_kind_from_pc (gdbarch, ia64_breakpoint_kind_from_pc); set_gdbarch_read_pc (gdbarch, ia64_read_pc); set_gdbarch_write_pc (gdbarch, ia64_write_pc);