X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fia64-tdep.c;h=1d1fd2e5f0ee479edfccd2da05442e06d43a03a5;hb=a50264baf57716993e701096fa6e466fb63e0301;hp=e1d8075e2e083063484116f917b29e5ce8660695;hpb=3b2ca8248cae742c00cb4e94138edf1403d43d47;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c index e1d8075e2e..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-2017 Free Software Foundation, Inc. + Copyright (C) 1999-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -69,6 +69,7 @@ struct ia64_table_entry }; static struct ia64_table_entry *ktab = NULL; +static gdb::optional ktab_buf; #endif @@ -329,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; @@ -706,7 +707,7 @@ ia64_memory_insert_breakpoint (struct gdbarch *gdbarch, if (val != 0) 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. */ @@ -876,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); @@ -927,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); @@ -946,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; @@ -982,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; @@ -995,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; @@ -1013,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; @@ -1036,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; @@ -1054,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; @@ -1210,7 +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) == TYPE_CODE_FLT + && type->code () == TYPE_CODE_FLT && type != ia64_ext_type (gdbarch)); } @@ -1396,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 @@ -1406,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; @@ -1523,11 +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); - saved_sp = get_frame_register_unsigned (this_frame, - sp_regnum); - } + saved_sp = get_frame_register_unsigned (this_frame, + sp_regnum); spill_addr = saved_sp + (rM == 12 ? 0 : mem_stack_frame_size) + imm; @@ -2481,8 +2480,6 @@ ia64_access_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *val, 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; /* We never call any libunwind routines that need to write registers. */ gdb_assert (!write); @@ -2554,8 +2551,6 @@ ia64_access_rse_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t bsp, sof, cfm, psr, ip; struct regcache *regcache = (struct regcache *) arg; struct gdbarch *gdbarch = regcache->arch (); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - long new_sof, old_sof; /* We never call any libunwind routines that need to write registers. */ gdb_assert (!write); @@ -2614,7 +2609,7 @@ ia64_access_rse_fpreg (unw_addr_space_t as, unw_regnum_t uw_regnum, /* 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; } @@ -2645,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 @@ -2658,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. */ @@ -2672,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; @@ -2725,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) { @@ -2776,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; @@ -2857,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; @@ -2865,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; @@ -3036,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)) @@ -3163,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 @@ -3187,8 +3173,8 @@ 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 @@ -3208,7 +3194,7 @@ ia64_extract_return_value (struct type *type, struct regcache *regcache, while (n-- > 0) { - regcache_cooked_read (regcache, regnum, from); + regcache->cooked_read (regnum, from); target_float_convert (from, ia64_ext_type (gdbarch), valbuf + offset, float_elt_type); offset += TYPE_LENGTH (float_elt_type); @@ -3241,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++; } @@ -3275,14 +3261,13 @@ ia64_store_return_value (struct type *type, struct regcache *regcache, { target_float_convert (valbuf + offset, float_elt_type, to, ia64_ext_type (gdbarch)); - regcache_cooked_write (regcache, regnum, to); + 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)); @@ -3300,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); } @@ -3334,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) @@ -3354,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; @@ -3388,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: @@ -3403,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; @@ -3629,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); } @@ -3686,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); @@ -3712,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; @@ -3753,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), @@ -3832,7 +3819,7 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function, target_float_convert (value_contents (arg) + argoffset, float_elt_type, to, ia64_ext_type (gdbarch)); - regcache_cooked_write (regcache, floatreg, to); + regcache->cooked_write (floatreg, to); floatreg++; argoffset += TYPE_LENGTH (float_elt_type); len -= TYPE_LENGTH (float_elt_type); @@ -3841,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); @@ -4027,8 +4012,9 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) return gdbarch; } +void _initialize_ia64_tdep (); void -_initialize_ia64_tdep (void) +_initialize_ia64_tdep () { gdbarch_register (bfd_arch_ia64, ia64_gdbarch_init, NULL); }