X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fia64-tdep.c;h=5fa0fad2888a5321658966529aa7002372fd9a91;hb=b4991d292edd84c16bd2050bd071198ceae764fe;hp=af185a2963d0d583ffeb5f041a5df118fbe1049e;hpb=e2882c85786571175a0b0bfc3bcd2f14620b1ea3;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c index af185a2963..5fa0fad288 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-2018 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 @@ -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; @@ -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)) @@ -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); } @@ -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); @@ -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); }