Fix linking MSP430 files created by gcc's LTO optimizer.

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

diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 513f0e03914d5925c4d12da05a44eb48b85cb62c..d22b2cf5d28e641851c2e20838d2d72751ae1e1a 100644 (file)
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -205,13 +205,10 @@ hppa_symbol_address(const char *sym)
 static struct hppa_objfile_private *
 hppa_init_objfile_priv_data (struct objfile *objfile)
 {
-  struct hppa_objfile_private *priv;
+  hppa_objfile_private *priv
+    = OBSTACK_ZALLOC (&objfile->objfile_obstack, hppa_objfile_private);
 
-  priv = (struct hppa_objfile_private *)
-        obstack_alloc (&objfile->objfile_obstack,
-                       sizeof (struct hppa_objfile_private));
   set_objfile_data (objfile, hppa_objfile_priv_data, priv);
-  memset (priv, 0, sizeof (*priv));
 
   return priv;
 }
@@ -717,7 +714,8 @@ static CORE_ADDR
 hppa32_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)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 
@@ -823,17 +821,15 @@ hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                  int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
                  int fpreg = 74 + (param_ptr - 32) / 8 * 4;
 
-                 regcache_cooked_write (regcache, grreg, param_val);
-                 regcache_cooked_write (regcache, fpLreg, param_val);
+                 regcache->cooked_write (grreg, param_val);
+                 regcache->cooked_write (fpLreg, param_val);
 
                  if (param_len > 4)
                    {
-                     regcache_cooked_write (regcache, grreg + 1, 
-                                            param_val + 4);
+                     regcache->cooked_write (grreg + 1, param_val + 4);
 
-                     regcache_cooked_write (regcache, fpreg, param_val);
-                     regcache_cooked_write (regcache, fpreg + 1, 
-                                            param_val + 4);
+                     regcache->cooked_write (fpreg, param_val);
+                     regcache->cooked_write (fpreg + 1, param_val + 4);
                    }
                }
            }
@@ -854,7 +850,7 @@ hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* If a structure has to be returned, set up register 28 to hold its
      address.  */
-  if (struct_return)
+  if (return_method == return_method_struct)
     regcache_cooked_write_unsigned (regcache, 28, struct_addr);
 
   gp = tdep->find_global_pointer (gdbarch, function);
@@ -974,7 +970,8 @@ static CORE_ADDR
 hppa64_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);
@@ -1049,8 +1046,8 @@ hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                     passed in floating-point registers, are passed in
                     the right halves of the floating point registers;
                     the left halves are unused."  */
-                 regcache_cooked_write_part (regcache, regnum, offset % 8,
-                                             len, value_contents (arg));
+                 regcache->cooked_write_part (regnum, offset % 8, len,
+                                              value_contents (arg));
                }
            }
        }
@@ -1091,8 +1088,8 @@ hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       regnum = HPPA_ARG0_REGNUM - offset / 8;
       while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
        {
-         regcache_cooked_write_part (regcache, regnum,
-                                     offset % 8, std::min (len, 8), valbuf);
+         regcache->cooked_write_part (regnum, offset % 8, std::min (len, 8),
+                                      valbuf);
          offset += std::min (len, 8);
          valbuf += std::min (len, 8);
          len -= std::min (len, 8);
@@ -1118,7 +1115,7 @@ hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* If a structure has to be returned, set up GR 28 (%ret0) to hold
      its address.  */
-  if (struct_return)
+  if (return_method == return_method_struct)
     regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
 
   /* Set up GR27 (%dp) to hold the global pointer (gp).  */
@@ -1157,20 +1154,18 @@ hppa32_return_value (struct gdbarch *gdbarch, struct value *function,
       if (part > 0)
        {
          if (readbuf != NULL)
-           regcache_cooked_read_part (regcache, reg, 4 - part,
-                                      part, readbuf);
+           regcache->cooked_read_part (reg, 4 - part, part, readbuf);
          if (writebuf != NULL)
-           regcache_cooked_write_part (regcache, reg, 4 - part,
-                                       part, writebuf);
+           regcache->cooked_write_part (reg, 4 - part, part, writebuf);
          reg++;
        }
       /* Now transfer the remaining register values.  */
       for (b = part; b < TYPE_LENGTH (type); b += 4)
        {
          if (readbuf != NULL)
-           regcache_cooked_read (regcache, reg, readbuf + b);
+           regcache->cooked_read (reg, readbuf + b);
          if (writebuf != NULL)
-           regcache_cooked_write (regcache, reg, writebuf + b);
+           regcache->cooked_write (reg, writebuf + b);
          reg++;
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -1248,8 +1243,8 @@ hppa64_return_value (struct gdbarch *gdbarch, struct value *function,
     {
       while (len > 0)
        {
-         regcache_cooked_read_part (regcache, regnum, offset,
-                                    std::min (len, 8), readbuf);
+         regcache->cooked_read_part (regnum, offset, std::min (len, 8),
+                                     readbuf);
          readbuf += std::min (len, 8);
          len -= std::min (len, 8);
          regnum++;
@@ -1260,8 +1255,8 @@ hppa64_return_value (struct gdbarch *gdbarch, struct value *function,
     {
       while (len > 0)
        {
-         regcache_cooked_write_part (regcache, regnum, offset,
-                                     std::min (len, 8), writebuf);
+         regcache->cooked_write_part (regnum, offset, std::min (len, 8),
+                                      writebuf);
          writebuf += std::min (len, 8);
          len -= std::min (len, 8);
          regnum++;
@@ -1304,13 +1299,13 @@ hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
 }
 
 CORE_ADDR
-hppa_read_pc (struct regcache *regcache)
+hppa_read_pc (readable_regcache *regcache)
 {
   ULONGEST ipsw;
   ULONGEST pc;
 
-  regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
-  regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
+  regcache->cooked_read (HPPA_IPSW_REGNUM, &ipsw);
+  regcache->cooked_read (HPPA_PCOQ_HEAD_REGNUM, &pc);
 
   /* If the current instruction is nullified, then we are effectively
      still executing the previous instruction.  Pretend we are still
@@ -2442,9 +2437,7 @@ static struct hppa_stub_unwind_cache *
 hppa_stub_frame_unwind_cache (struct frame_info *this_frame,
                              void **this_cache)
 {
-  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct hppa_stub_unwind_cache *info;
-  struct unwind_table_entry *u;
 
   if (*this_cache)
     return (struct hppa_stub_unwind_cache *) *this_cache;
@@ -2747,14 +2740,14 @@ hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
 }
 
 static enum register_status
-hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
+hppa_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache,
                           int regnum, gdb_byte *buf)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   ULONGEST tmp;
   enum register_status status;
 
-  status = regcache_raw_read_unsigned (regcache, regnum, &tmp);
+  status = regcache->raw_read (regnum, &tmp);
   if (status == REG_VALID)
     {
       if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)