X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fia64-tdep.c;h=1d1fd2e5f0ee479edfccd2da05442e06d43a03a5;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=681c5605b8d5daf05f7efebf628b7c4d5b8b809e;hpb=870f88f7551b0f2d6aaaa36fb684b5ff8f468107;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c index 681c5605b8..1d1fd2e5f0 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-2016 Free Software Foundation, Inc. + Copyright (C) 1999-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -28,7 +28,7 @@ #include "frame.h" #include "frame-base.h" #include "frame-unwind.h" -#include "doublest.h" +#include "target-float.h" #include "value.h" #include "objfiles.h" #include "elf/common.h" /* for DT_PLTGOT value */ @@ -69,6 +69,7 @@ struct ia64_table_entry }; static struct ia64_table_entry *ktab = NULL; +static gdb::optional ktab_buf; #endif @@ -125,6 +126,9 @@ 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; /* NOTE: we treat the register stack registers r32-r127 as @@ -140,7 +144,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", @@ -326,7 +330,7 @@ ia64_register_reggroup_p (struct gdbarch *gdbarch, int regnum, if (group == all_reggroup) return 1; vector_p = TYPE_VECTOR (register_type (gdbarch, regnum)); - float_p = TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT; + float_p = register_type (gdbarch, regnum)->code () == TYPE_CODE_FLT; raw_p = regnum < NUM_IA64_RAW_REGS; if (group == float_reggroup) return float_p; @@ -641,7 +645,6 @@ ia64_memory_insert_breakpoint (struct gdbarch *gdbarch, long long instr_breakpoint; int val; int templ; - struct cleanup *cleanup; if (slotnum > 2) error (_("Can't insert breakpoint for slot numbers greater than 2.")); @@ -653,13 +656,11 @@ ia64_memory_insert_breakpoint (struct gdbarch *gdbarch, Otherwise, we could possibly store into the shadow parts of the adjacent placed breakpoints. It is due to our SHADOW_CONTENTS overlapping the real breakpoint instruction bits region. */ - cleanup = make_show_memory_breakpoints_cleanup (0); + scoped_restore restore_memory_0 + = make_scoped_restore_show_memory_breakpoints (0); val = target_read_memory (addr, bundle, BUNDLE_LEN); if (val != 0) - { - do_cleanups (cleanup); - return val; - } + return val; /* SHADOW_SLOTNUM saves the original slot number as expected by the caller for addressing the SHADOW_CONTENTS placement. */ @@ -700,15 +701,13 @@ ia64_memory_insert_breakpoint (struct gdbarch *gdbarch, restoration mechanism kicks in and we would possibly remove parts of the adjacent placed breakpoints. It is due to our SHADOW_CONTENTS overlapping the real breakpoint instruction bits region. */ - make_show_memory_breakpoints_cleanup (1); + scoped_restore restore_memory_1 + = make_scoped_restore_show_memory_breakpoints (1); val = target_read_memory (addr, bundle, BUNDLE_LEN); if (val != 0) - { - do_cleanups (cleanup); - return val; - } + return val; - /* Breakpoints already present in the code will get deteacted and not get + /* Breakpoints already present in the code will get detected and not get reinserted by bp_loc_is_permanent. Multiple breakpoints at the same location cannot induce the internal error as they are optimized into a single instance by update_global_location_list. */ @@ -719,12 +718,9 @@ 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); - do_cleanups (cleanup); return val; } @@ -738,7 +734,6 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, long long instr_breakpoint, instr_saved; int val; int templ; - struct cleanup *cleanup; addr &= ~0x0f; @@ -747,13 +742,11 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, mechanism kicks in and we would possibly remove parts of the adjacent placed breakpoints. It is due to our SHADOW_CONTENTS overlapping the real breakpoint instruction bits region. */ - cleanup = make_show_memory_breakpoints_cleanup (1); + scoped_restore restore_memory_1 + = make_scoped_restore_show_memory_breakpoints (1); val = target_read_memory (addr, bundle_mem, BUNDLE_LEN); if (val != 0) - { - do_cleanups (cleanup); - return val; - } + return val; /* SHADOW_SLOTNUM saves the original slot number as expected by the caller for addressing the SHADOW_CONTENTS placement. */ @@ -771,7 +764,6 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, warning (_("Cannot remove breakpoint at address %s from non-existing " "X-type slot, memory has changed underneath"), paddress (gdbarch, bp_tgt->placed_address)); - do_cleanups (cleanup); return -1; } if (template_encoding_table[templ][slotnum] == L) @@ -783,8 +775,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) @@ -792,7 +783,6 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, warning (_("Cannot remove breakpoint at address %s, " "no break instruction at such address."), paddress (gdbarch, bp_tgt->placed_address)); - do_cleanups (cleanup); return -1; } @@ -808,10 +798,18 @@ ia64_memory_remove_breakpoint (struct gdbarch *gdbarch, replace_slotN_contents (bundle_mem, instr_saved, slotnum); val = target_write_raw_memory (addr, bundle_mem, BUNDLE_LEN); - do_cleanups (cleanup); 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 @@ -828,7 +826,6 @@ ia64_breakpoint_from_pc (struct gdbarch *gdbarch, long long instr_fetched; int val; int templ; - struct cleanup *cleanup; if (slotnum > 2) error (_("Can't insert breakpoint for slot numbers greater than 2.")); @@ -837,9 +834,11 @@ ia64_breakpoint_from_pc (struct gdbarch *gdbarch, /* Enable the automatic memory restoration from breakpoints while we read our instruction bundle to match bp_loc_is_permanent. */ - cleanup = make_show_memory_breakpoints_cleanup (0); - val = target_read_memory (addr, bundle, BUNDLE_LEN); - do_cleanups (cleanup); + { + scoped_restore restore_memory_0 + = make_scoped_restore_show_memory_breakpoints (0); + val = target_read_memory (addr, bundle, BUNDLE_LEN); + } /* The memory might be unreachable. This can happen, for instance, when the user inserts a breakpoint at an invalid address. */ @@ -878,13 +877,13 @@ ia64_breakpoint_from_pc (struct gdbarch *gdbarch, } static CORE_ADDR -ia64_read_pc (struct regcache *regcache) +ia64_read_pc (readable_regcache *regcache) { ULONGEST psr_value, pc_value; int slot_num; - regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr_value); - regcache_cooked_read_unsigned (regcache, IA64_IP_REGNUM, &pc_value); + regcache->cooked_read (IA64_PSR_REGNUM, &psr_value); + regcache->cooked_read (IA64_IP_REGNUM, &pc_value); slot_num = (psr_value >> 41) & 3; return pc_value | (slot_num * SLOT_MULTIPLIER); @@ -929,7 +928,7 @@ rse_address_add(CORE_ADDR addr, int nslots) } static enum register_status -ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, +ia64_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, gdb_byte *buf) { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); @@ -948,18 +947,15 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, found sequentially in memory starting at $bof. This isn't always true, but without libunwind, this is the best we can do. */ - enum register_status status; ULONGEST cfm; ULONGEST bsp; CORE_ADDR reg; - status = regcache_cooked_read_unsigned (regcache, - IA64_BSP_REGNUM, &bsp); + status = regcache->cooked_read (IA64_BSP_REGNUM, &bsp); if (status != REG_VALID) return status; - status = regcache_cooked_read_unsigned (regcache, - IA64_CFM_REGNUM, &cfm); + status = regcache->cooked_read (IA64_CFM_REGNUM, &cfm); if (status != REG_VALID) return status; @@ -984,7 +980,8 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, { ULONGEST unatN_val; ULONGEST unat; - status = regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat); + + status = regcache->cooked_read (IA64_UNAT_REGNUM, &unat); if (status != REG_VALID) return status; unatN_val = (unat & (1LL << (regnum - IA64_NAT0_REGNUM))) != 0; @@ -997,10 +994,12 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, ULONGEST bsp; ULONGEST cfm; CORE_ADDR gr_addr = 0; - status = regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp); + + status = regcache->cooked_read (IA64_BSP_REGNUM, &bsp); if (status != REG_VALID) return status; - status = regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm); + + status = regcache->cooked_read (IA64_CFM_REGNUM, &cfm); if (status != REG_VALID) return status; @@ -1015,14 +1014,13 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, { /* Compute address of nat collection bits. */ CORE_ADDR nat_addr = gr_addr | 0x1f8; - CORE_ADDR nat_collection; + ULONGEST nat_collection; int nat_bit; /* If our nat collection address is bigger than bsp, we have to get the nat collection from rnat. Otherwise, we fetch the nat collection from the computed address. */ if (nat_addr >= bsp) - regcache_cooked_read_unsigned (regcache, IA64_RNAT_REGNUM, - &nat_collection); + regcache->cooked_read (IA64_RNAT_REGNUM, &nat_collection); else nat_collection = read_memory_integer (nat_addr, 8, byte_order); nat_bit = (gr_addr >> 3) & 0x3f; @@ -1038,10 +1036,11 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, It can be calculated as the bsp - sof (sizeof frame). */ ULONGEST bsp, vbsp; ULONGEST cfm; - status = regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp); + + status = regcache->cooked_read (IA64_BSP_REGNUM, &bsp); if (status != REG_VALID) return status; - status = regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm); + status = regcache->cooked_read (IA64_CFM_REGNUM, &cfm); if (status != REG_VALID) return status; @@ -1056,10 +1055,11 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, ULONGEST pr; ULONGEST cfm; ULONGEST prN_val; - status = regcache_cooked_read_unsigned (regcache, IA64_PR_REGNUM, &pr); + + status = regcache->cooked_read (IA64_PR_REGNUM, &pr); if (status != REG_VALID) return status; - status = regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm); + status = regcache->cooked_read (IA64_CFM_REGNUM, &cfm); if (status != REG_VALID) return status; @@ -1212,6 +1212,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_CODE_FLT && type != ia64_ext_type (gdbarch)); } @@ -1221,7 +1222,7 @@ ia64_register_to_value (struct frame_info *frame, int regnum, int *optimizedp, int *unavailablep) { struct gdbarch *gdbarch = get_frame_arch (frame); - gdb_byte in[MAX_REGISTER_SIZE]; + gdb_byte in[IA64_FP_REGISTER_SIZE]; /* Convert to TYPE. */ if (!get_frame_register_bytes (frame, regnum, 0, @@ -1229,7 +1230,7 @@ ia64_register_to_value (struct frame_info *frame, int regnum, in, optimizedp, unavailablep)) return 0; - convert_typed_floating (in, ia64_ext_type (gdbarch), out, valtype); + target_float_convert (in, ia64_ext_type (gdbarch), out, valtype); *optimizedp = *unavailablep = 0; return 1; } @@ -1239,8 +1240,8 @@ ia64_value_to_register (struct frame_info *frame, int regnum, struct type *valtype, const gdb_byte *in) { struct gdbarch *gdbarch = get_frame_arch (frame); - gdb_byte out[MAX_REGISTER_SIZE]; - convert_typed_floating (in, valtype, out, ia64_ext_type (gdbarch)); + gdb_byte out[IA64_FP_REGISTER_SIZE]; + target_float_convert (in, valtype, out, ia64_ext_type (gdbarch)); put_frame_register (frame, regnum, out); } @@ -1397,8 +1398,8 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, && it == M && ((instr & 0x1ee0000003fLL) == 0x02c00000000LL)) { /* alloc - start of a regular function. */ - int sol = (int) ((instr & 0x00007f00000LL) >> 20); - int sof = (int) ((instr & 0x000000fe000LL) >> 13); + int sol_bits = (int) ((instr & 0x00007f00000LL) >> 20); + int sof_bits = (int) ((instr & 0x000000fe000LL) >> 13); int rN = (int) ((instr & 0x00000001fc0LL) >> 6); /* Verify that the current cfm matches what we think is the @@ -1407,8 +1408,8 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, addresses of various registers such as the return address. We will instead treat the frame as frameless. */ if (!this_frame || - (sof == (cache->cfm & 0x7f) && - sol == ((cache->cfm >> 7) & 0x7f))) + (sof_bits == (cache->cfm & 0x7f) && + sol_bits == ((cache->cfm >> 7) & 0x7f))) frameless = 0; cfm_reg = rN; @@ -1510,7 +1511,6 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, else if (qp == 0 && rN == 2 && ((rM == fp_reg && fp_reg != 0) || rM == 12)) { - gdb_byte buf[MAX_REGISTER_SIZE]; CORE_ADDR saved_sp = 0; /* adds r2, spilloffset, rFramePointer or @@ -1525,12 +1525,8 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, where the pc is. If it's still early in the prologue this'll be wrong. FIXME */ 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) + imm; @@ -2283,10 +2279,6 @@ static struct value * ia64_sigtramp_frame_prev_register (struct frame_info *this_frame, void **this_cache, int regnum) { - gdb_byte 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); @@ -2302,8 +2294,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); @@ -2484,12 +2477,9 @@ 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; - gdb_byte buf[MAX_REGISTER_SIZE]; /* We never call any libunwind routines that need to write registers. */ gdb_assert (!write); @@ -2499,10 +2489,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; @@ -2511,10 +2499,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; @@ -2522,14 +2508,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; } @@ -2548,7 +2532,7 @@ 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); @@ -2564,12 +2548,9 @@ 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; - struct gdbarch *gdbarch = get_regcache_arch (regcache); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - long new_sof, old_sof; - gdb_byte buf[MAX_REGISTER_SIZE]; + unw_word_t bsp, sof, cfm, psr, ip; + struct regcache *regcache = (struct regcache *) arg; + struct gdbarch *gdbarch = regcache->arch (); /* We never call any libunwind routines that need to write registers. */ gdb_assert (!write); @@ -2579,10 +2560,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; @@ -2591,10 +2570,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; @@ -2602,14 +2579,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; } @@ -2629,12 +2604,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, (gdb_byte *) val); + regcache->cooked_read (regnum, (gdb_byte *) val); return 0; } @@ -2665,11 +2640,9 @@ ia64_access_mem (unw_addr_space_t as, } /* Call low-level function to access the kernel unwind table. */ -static LONGEST -getunwind_table (gdb_byte **buf_p) +static gdb::optional +getunwind_table () { - LONGEST x; - /* FIXME drow/2005-09-10: This code used to call ia64_linux_xfer_unwind_table directly to fetch the unwind table for the currently running ia64-linux kernel. That data should @@ -2678,10 +2651,8 @@ getunwind_table (gdb_byte **buf_p) we should find a way to override the corefile layer's xfer_partial method. */ - x = target_read_alloc (¤t_target, TARGET_OBJECT_UNWIND_TABLE, - NULL, buf_p); - - return x; + return target_read_alloc (current_top_target (), TARGET_OBJECT_UNWIND_TABLE, + NULL); } /* Get the kernel unwind table. */ @@ -2692,15 +2663,12 @@ get_kernel_table (unw_word_t ip, unw_dyn_info_t *di) if (!ktab) { - gdb_byte *ktab_buf; - LONGEST size; - - size = getunwind_table (&ktab_buf); - if (size <= 0) + ktab_buf = getunwind_table (); + if (!ktab_buf) return -UNW_ENOINFO; - ktab = (struct ia64_table_entry *) ktab_buf; - ktab_size = size; + ktab = (struct ia64_table_entry *) ktab_buf->data (); + ktab_size = ktab_buf->size (); for (etab = ktab; etab->start_offset; ++etab) etab->info_offset += KERNEL_START; @@ -2745,7 +2713,7 @@ ia64_find_unwind_table (struct objfile *objfile, unw_word_t ip, ehdr = elf_tdata (bfd)->elf_header; phdr = elf_tdata (bfd)->phdr; - load_base = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); + load_base = objfile->text_section_offset (); for (i = 0; i < ehdr->e_phnum; ++i) { @@ -2796,7 +2764,7 @@ ia64_find_unwind_table (struct objfile *objfile, unw_word_t ip, dip->start_ip = p_text->p_vaddr + load_base; dip->end_ip = dip->start_ip + p_text->p_memsz; - dip->gp = ia64_find_global_pointer (get_objfile_arch (objfile), ip); + dip->gp = ia64_find_global_pointer (objfile->arch (), ip); dip->format = UNW_INFO_FORMAT_REMOTE_TABLE; dip->u.rti.name_ptr = (unw_word_t) bfd_get_filename (bfd); dip->u.rti.segbase = segbase; @@ -2877,7 +2845,6 @@ ia64_get_dyn_info_list (unw_addr_space_t as, unw_word_t *dilap, void *arg) { struct obj_section *text_sec; - struct objfile *objfile; unw_word_t ip, addr; unw_dyn_info_t di; int ret; @@ -2885,7 +2852,7 @@ ia64_get_dyn_info_list (unw_addr_space_t as, if (!libunwind_is_initialized ()) return -UNW_ENOINFO; - for (objfile = object_files; objfile; objfile = objfile->next) + for (objfile *objfile : current_program_space->objfiles ()) { void *buf = NULL; @@ -2976,12 +2943,10 @@ ia64_libunwind_frame_prev_register (struct frame_info *this_frame, { int rrb_pr = 0; ULONGEST cfm; - gdb_byte 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. */ @@ -3058,7 +3023,6 @@ ia64_libunwind_sigtramp_frame_this_id (struct frame_info *this_frame, gdb_byte buf[8]; CORE_ADDR bsp; struct frame_id id = outer_frame_id; - CORE_ADDR prev_ip; libunwind_frame_this_id (this_frame, this_cache, &id); if (frame_id_eq (id, outer_frame_id)) @@ -3185,9 +3149,9 @@ ia64_use_struct_convention (struct type *type) /* Don't use the struct convention for anything but structure, union, or array types. */ - if (!(TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION - || TYPE_CODE (type) == TYPE_CODE_ARRAY)) + if (!(type->code () == TYPE_CODE_STRUCT + || type->code () == TYPE_CODE_UNION + || type->code () == TYPE_CODE_ARRAY)) return 0; /* HFAs are structures (or arrays) consisting entirely of floating @@ -3209,30 +3173,30 @@ ia64_use_struct_convention (struct type *type) static int ia64_struct_type_p (const struct type *type) { - return (TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION); + return (type->code () == TYPE_CODE_STRUCT + || type->code () == TYPE_CODE_UNION); } static void ia64_extract_return_value (struct type *type, struct regcache *regcache, gdb_byte *valbuf) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct type *float_elt_type; float_elt_type = is_float_or_hfa_type (type); if (float_elt_type != NULL) { - gdb_byte 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); while (n-- > 0) { - regcache_cooked_read (regcache, regnum, from); - convert_typed_floating (from, ia64_ext_type (gdbarch), - (char *)valbuf + offset, float_elt_type); + regcache->cooked_read (regnum, from); + target_float_convert (from, ia64_ext_type (gdbarch), + valbuf + offset, float_elt_type); offset += TYPE_LENGTH (float_elt_type); regnum++; } @@ -3263,9 +3227,9 @@ ia64_extract_return_value (struct type *type, struct regcache *regcache, while (n-- > 0) { - ULONGEST val; - regcache_cooked_read_unsigned (regcache, regnum, &val); - memcpy ((char *)valbuf + offset, &val, reglen); + ULONGEST regval; + regcache_cooked_read_unsigned (regcache, regnum, ®val); + memcpy ((char *)valbuf + offset, ®val, reglen); offset += reglen; regnum++; } @@ -3282,29 +3246,28 @@ static void ia64_store_return_value (struct type *type, struct regcache *regcache, const gdb_byte *valbuf) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct type *float_elt_type; float_elt_type = is_float_or_hfa_type (type); if (float_elt_type != NULL) { - gdb_byte 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); while (n-- > 0) { - convert_typed_floating ((char *)valbuf + offset, float_elt_type, - to, ia64_ext_type (gdbarch)); - regcache_cooked_write (regcache, regnum, to); + target_float_convert (valbuf + offset, float_elt_type, + to, ia64_ext_type (gdbarch)); + regcache->cooked_write (regnum, to); offset += TYPE_LENGTH (float_elt_type); regnum++; } } else { - ULONGEST val; int offset = 0; int regnum = IA64_GR8_REGNUM; int reglen = TYPE_LENGTH (register_type (gdbarch, IA64_GR8_REGNUM)); @@ -3322,6 +3285,7 @@ ia64_store_return_value (struct type *type, struct regcache *regcache, if (m) { + ULONGEST val; memcpy (&val, (char *)valbuf + offset, m); regcache_cooked_write_unsigned (regcache, regnum, val); } @@ -3356,7 +3320,7 @@ ia64_return_value (struct gdbarch *gdbarch, struct value *function, static int is_float_or_hfa_type_recurse (struct type *t, struct type **etp) { - switch (TYPE_CODE (t)) + switch (t->code ()) { case TYPE_CODE_FLT: if (*etp) @@ -3376,7 +3340,7 @@ is_float_or_hfa_type_recurse (struct type *t, struct type **etp) { int i; - for (i = 0; i < TYPE_NFIELDS (t); i++) + for (i = 0; i < t->num_fields (); i++) if (!is_float_or_hfa_type_recurse (check_typedef (TYPE_FIELD_TYPE (t, i)), etp)) return 0; @@ -3410,7 +3374,7 @@ is_float_or_hfa_type (struct type *t) static int slot_alignment_is_next_even (struct type *t) { - switch (TYPE_CODE (t)) + switch (t->code ()) { case TYPE_CODE_INT: case TYPE_CODE_FLT: @@ -3425,7 +3389,7 @@ slot_alignment_is_next_even (struct type *t) { int i; - for (i = 0; i < TYPE_NFIELDS (t); i++) + for (i = 0; i < t->num_fields (); i++) if (slot_alignment_is_next_even (check_typedef (TYPE_FIELD_TYPE (t, i)))) return 1; @@ -3582,7 +3546,7 @@ find_extant_func_descr (struct gdbarch *gdbarch, CORE_ADDR faddr) static CORE_ADDR find_func_descr (struct regcache *regcache, CORE_ADDR faddr, CORE_ADDR *fdaptr) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR fdesc; @@ -3651,7 +3615,7 @@ ia64_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, minsym = lookup_minimal_symbol_by_pc (addr); if (minsym.minsym - && is_vtable_name (MSYMBOL_LINKAGE_NAME (minsym.minsym))) + && is_vtable_name (minsym.minsym->linkage_name ())) return read_memory_unsigned_integer (addr, 8, byte_order); } @@ -3708,7 +3672,8 @@ static CORE_ADDR ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, - int struct_return, CORE_ADDR struct_addr) + function_call_return_method return_method, + CORE_ADDR struct_addr) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); @@ -3734,7 +3699,7 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if ((nslots & 1) && slot_alignment_is_next_even (type)) nslots++; - if (TYPE_CODE (type) == TYPE_CODE_FUNC) + if (type->code () == TYPE_CODE_FUNC) nfuncargs++; nslots += (len + 7) / 8; @@ -3775,9 +3740,9 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, len = TYPE_LENGTH (type); /* Special handling for function parameters. */ - if (len == 8 - && TYPE_CODE (type) == TYPE_CODE_PTR - && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC) + if (len == 8 + && type->code () == TYPE_CODE_PTR + && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC) { gdb_byte val_buf[8]; ULONGEST faddr = extract_unsigned_integer (value_contents (arg), @@ -3850,11 +3815,11 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, len = TYPE_LENGTH (type); while (len > 0 && floatreg < IA64_FR16_REGNUM) { - gdb_byte to[MAX_REGISTER_SIZE]; - convert_typed_floating (value_contents (arg) + argoffset, - float_elt_type, to, - ia64_ext_type (gdbarch)); - regcache_cooked_write (regcache, floatreg, to); + gdb_byte to[IA64_FP_REGISTER_SIZE]; + target_float_convert (value_contents (arg) + argoffset, + float_elt_type, to, + ia64_ext_type (gdbarch)); + regcache->cooked_write (floatreg, to); floatreg++; argoffset += TYPE_LENGTH (float_elt_type); len -= TYPE_LENGTH (float_elt_type); @@ -3863,11 +3828,9 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, } /* Store the struct return value in r8 if necessary. */ - if (struct_return) - { - regcache_cooked_write_unsigned (regcache, IA64_GR8_REGNUM, - (ULONGEST) struct_addr); - } + if (return_method == return_method_struct) + regcache_cooked_write_unsigned (regcache, IA64_GR8_REGNUM, + (ULONGEST) struct_addr); global_pointer = ia64_find_global_pointer (gdbarch, func_addr); @@ -3937,7 +3900,7 @@ static int ia64_print_insn (bfd_vma memaddr, struct disassemble_info *info) { info->bytes_per_line = SLOT_MULTIPLIER; - return print_insn_ia64 (memaddr, info); + return default_print_insn (memaddr, info); } /* The default "size_of_register_frame" gdbarch_tdep routine for ia64. */ @@ -4009,6 +3972,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); @@ -4048,10 +4012,9 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) return gdbarch; } -extern initialize_file_ftype _initialize_ia64_tdep; /* -Wmissing-prototypes */ - +void _initialize_ia64_tdep (); void -_initialize_ia64_tdep (void) +_initialize_ia64_tdep () { gdbarch_register (bfd_arch_ia64, ia64_gdbarch_init, NULL); }