Some get_last_target_status tweaks

[deliverable/binutils-gdb.git] / gdb / ia64-tdep.c

diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index 2fab60c1d01e45708e0f71d12c236d1517297f40..40d4fd3c19d3c80147008b5ffcbf64bdd8c28537 100644 (file)
--- 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.
 
@@ -707,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.  */
@@ -947,7 +947,6 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, readable_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;
@@ -1399,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
@@ -1409,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;
@@ -1526,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;
@@ -2484,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);
@@ -2557,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);
@@ -2721,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->section_offsets[SECT_OFF_TEXT (objfile)];
 
   for (i = 0; i < ehdr->e_phnum; ++i)
     {
@@ -2853,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;
@@ -2861,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;
 
@@ -3032,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))
@@ -3237,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, &regval);
+         memcpy ((char *)valbuf + offset, &regval, reglen);
          offset += reglen;
          regnum++;
        }
@@ -3278,7 +3268,6 @@ ia64_store_return_value (struct type *type, struct regcache *regcache,
     }
   else
     {
-      ULONGEST val;
       int offset = 0;
       int regnum = IA64_GR8_REGNUM;
       int reglen = TYPE_LENGTH (register_type (gdbarch, IA64_GR8_REGNUM));
@@ -3296,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);
        }
@@ -3625,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);
     }
 
@@ -3682,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);
@@ -3837,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);