PR binutils/1437
[deliverable/binutils-gdb.git] / gdb / hppa-tdep.c
index 8469bd6f6bc02ace91261f7e67410986bddaa470..a10437152640e057e85f346200eded4708596904 100644 (file)
@@ -1,8 +1,8 @@
-/* Target-dependent code for the HP PA architecture, for GDB.
+/* Target-dependent code for the HP PA-RISC architecture.
 
    Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software
-   Foundation, Inc.
+   1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+   Free Software Foundation, Inc.
 
    Contributed by the Center for Software Science at the
    University of Utah (pa-gdb-bugs@cs.utah.edu).
@@ -364,7 +364,7 @@ read_unwind_info (struct objfile *objfile)
     }
 
   /* Now compute the size of the stub unwinds.  Note the ELF tools do not
-     use stub unwinds at the curren time.  */
+     use stub unwinds at the current time.  */
   stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
 
   if (stub_unwind_sec)
@@ -489,7 +489,7 @@ find_unwind_entry (CORE_ADDR pc)
        read_unwind_info (objfile);
         priv = objfile_data (objfile, hppa_objfile_priv_data);
        if (priv == NULL)
-         error ("Internal error reading unwind information.");
+         error (_("Internal error reading unwind information."));
         ui = ((struct hppa_objfile_private *) priv)->unwind_info;
       }
 
@@ -1035,7 +1035,7 @@ hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 static enum return_value_convention
 hppa32_return_value (struct gdbarch *gdbarch,
                     struct type *type, struct regcache *regcache,
-                    void *readbuf, const void *writebuf)
+                    gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   if (TYPE_LENGTH (type) <= 2 * 4)
     {
@@ -1061,9 +1061,9 @@ hppa32_return_value (struct gdbarch *gdbarch,
       for (b = part; b < TYPE_LENGTH (type); b += 4)
        {
          if (readbuf != NULL)
-           regcache_cooked_read (regcache, reg, (char *) readbuf + b);
+           regcache_cooked_read (regcache, reg, readbuf + b);
          if (writebuf != NULL)
-           regcache_cooked_write (regcache, reg, (const char *) writebuf + b);
+           regcache_cooked_write (regcache, reg, writebuf + b);
          reg++;
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
@@ -1075,7 +1075,7 @@ hppa32_return_value (struct gdbarch *gdbarch,
 static enum return_value_convention
 hppa64_return_value (struct gdbarch *gdbarch,
                     struct type *type, struct regcache *regcache,
-                    void *readbuf, const void *writebuf)
+                    gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   int len = TYPE_LENGTH (type);
   int regnum, offset;
@@ -1139,12 +1139,11 @@ hppa64_return_value (struct gdbarch *gdbarch,
 
   if (readbuf)
     {
-      char *buf = readbuf;
       while (len > 0)
        {
          regcache_cooked_read_part (regcache, regnum, offset,
-                                    min (len, 8), buf);
-         buf += min (len, 8);
+                                    min (len, 8), readbuf);
+         readbuf += min (len, 8);
          len -= min (len, 8);
          regnum++;
        }
@@ -1152,12 +1151,11 @@ hppa64_return_value (struct gdbarch *gdbarch,
 
   if (writebuf)
     {
-      const char *buf = writebuf;
       while (len > 0)
        {
          regcache_cooked_write_part (regcache, regnum, offset,
-                                     min (len, 8), buf);
-         buf += min (len, 8);
+                                     min (len, 8), writebuf);
+         writebuf += min (len, 8);
          len -= min (len, 8);
          regnum++;
        }
@@ -1168,16 +1166,13 @@ hppa64_return_value (struct gdbarch *gdbarch,
 \f
 
 static CORE_ADDR
-hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
-                                  CORE_ADDR addr,
+hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
                                   struct target_ops *targ)
 {
   if (addr & 2)
     {
-      CORE_ADDR plabel;
-
-      plabel = addr & ~3;
-      target_read_memory(plabel, (char *)&addr, 4);
+      CORE_ADDR plabel = addr & ~3;
+      return read_memory_typed_address (plabel, builtin_type_void_func_ptr);
     }
 
   return addr;
@@ -1830,7 +1825,7 @@ hppa_frame_cache (struct frame_info *next_frame, void **this_cache)
        if (!safe_frame_unwind_memory (next_frame, pc, buf4, 
                                       sizeof buf4)) 
          {
-           error ("Cannot read instruction at 0x%s\n", paddr_nz (pc));
+           error (_("Cannot read instruction at 0x%s."), paddr_nz (pc));
            return (*this_cache);
          }
 
@@ -2109,7 +2104,7 @@ hppa_frame_prev_register (struct frame_info *next_frame,
                          void **this_cache,
                          int regnum, int *optimizedp,
                          enum lval_type *lvalp, CORE_ADDR *addrp,
-                         int *realnump, void *valuep)
+                         int *realnump, gdb_byte *valuep)
 {
   struct hppa_frame_cache *info = hppa_frame_cache (next_frame, this_cache);
   hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
@@ -2146,72 +2141,65 @@ static struct hppa_frame_cache *
 hppa_fallback_frame_cache (struct frame_info *next_frame, void **this_cache)
 {
   struct hppa_frame_cache *cache;
-  unsigned int frame_size;
-  int found_rp;
-  CORE_ADDR pc, start_pc, end_pc, cur_pc;
+  unsigned int frame_size = 0;
+  int found_rp = 0;
+  CORE_ADDR start_pc;
 
   if (hppa_debug)
-    fprintf_unfiltered (gdb_stdlog, "{ hppa_fallback_frame_cache (frame=%d)-> ",
-      frame_relative_level(next_frame));
+    fprintf_unfiltered (gdb_stdlog,
+                       "{ hppa_fallback_frame_cache (frame=%d) -> ",
+                       frame_relative_level (next_frame));
 
   cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
   (*this_cache) = cache;
   cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 
-  pc = frame_func_unwind (next_frame);
-  cur_pc = frame_pc_unwind (next_frame);
-  frame_size = 0;
-  found_rp = 0;
-
-  find_pc_partial_function (pc, NULL, &start_pc, &end_pc);
-
-  if (start_pc == 0 || end_pc == 0)
-    {
-      error ("Cannot find bounds of current function (@0x%s), unwinding will "
-            "fail.", paddr_nz (pc));
-      return cache;
-    }
-
-  if (end_pc > cur_pc)
-    end_pc = cur_pc;
-
-  for (pc = start_pc; pc < end_pc; pc += 4)
+  start_pc = frame_func_unwind (next_frame);
+  if (start_pc)
     {
-      unsigned int insn;
+      CORE_ADDR cur_pc = frame_pc_unwind (next_frame);
+      CORE_ADDR pc;
 
-      insn = read_memory_unsigned_integer (pc, 4);
+      for (pc = start_pc; pc < cur_pc; pc += 4)
+       {
+         unsigned int insn;
 
-      frame_size += prologue_inst_adjust_sp (insn);
+         insn = read_memory_unsigned_integer (pc, 4);
+         frame_size += prologue_inst_adjust_sp (insn);
 
-      /* There are limited ways to store the return pointer into the
-        stack.  */
-      if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
-        {
-          cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
-          found_rp = 1;
-        }
-      else if (insn == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
-        {
-          cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
-          found_rp = 1;
-        }
+         /* There are limited ways to store the return pointer into the
+            stack.  */
+         if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
+           {
+             cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
+             found_rp = 1;
+           }
+         else if (insn == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
+           {
+             cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
+             found_rp = 1;
+           }
+       }
     }
 
   if (hppa_debug)
-    fprintf_unfiltered (gdb_stdlog, " frame_size = %d, found_rp = %d }\n",
-      frame_size, found_rp);
+    fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
+                       frame_size, found_rp);
 
-  cache->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM) - frame_size;
+  cache->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
+  cache->base -= frame_size;
   trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
 
   if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
     {
       cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
-      cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[HPPA_RP_REGNUM];
+      cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = 
+       cache->saved_regs[HPPA_RP_REGNUM];
     }
   else
     {
-      ULONGEST rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
+      ULONGEST rp;
+      rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
       trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
     }
 
@@ -2232,7 +2220,7 @@ hppa_fallback_frame_prev_register (struct frame_info *next_frame,
                          void **this_cache,
                          int regnum, int *optimizedp,
                          enum lval_type *lvalp, CORE_ADDR *addrp,
-                         int *realnump, void *valuep)
+                         int *realnump, gdb_byte *valuep)
 {
   struct hppa_frame_cache *info = 
     hppa_fallback_frame_cache (next_frame, this_cache);
@@ -2317,7 +2305,7 @@ hppa_stub_frame_prev_register (struct frame_info *next_frame,
                               void **this_prologue_cache,
                               int regnum, int *optimizedp,
                               enum lval_type *lvalp, CORE_ADDR *addrp,
-                              int *realnump, void *valuep)
+                              int *realnump, gdb_byte *valuep)
 {
   struct hppa_stub_unwind_cache *info
     = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
@@ -2327,7 +2315,7 @@ hppa_stub_frame_prev_register (struct frame_info *next_frame,
                                     optimizedp, lvalp, addrp, realnump, 
                                     valuep);
   else
-    error ("Requesting registers from null frame.\n");
+    error (_("Requesting registers from null frame."));
 }
 
 static const struct frame_unwind hppa_stub_frame_unwind = {
@@ -2404,16 +2392,6 @@ hppa_lookup_stub_minimal_symbol (const char *name,
   return NULL;
 }
 
-/* Instead of this nasty cast, add a method pvoid() that prints out a
-   host VOID data type (remember %p isn't portable).  */
-
-static CORE_ADDR
-hppa_pointer_to_address_hack (void *ptr)
-{
-  gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr));
-  return POINTER_TO_ADDRESS (builtin_type_void_data_ptr, &ptr);
-}
-
 static void
 unwind_command (char *exp, int from_tty)
 {
@@ -2435,8 +2413,7 @@ unwind_command (char *exp, int from_tty)
       return;
     }
 
-  printf_unfiltered ("unwind_table_entry (0x%s):\n",
-                    paddr_nz (hppa_pointer_to_address_hack (u)));
+  printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u);
 
   printf_unfiltered ("\tregion_start = ");
   print_address (u->region_start, gdb_stdout);
@@ -2529,7 +2506,7 @@ hppa_pc_requires_run_before_use (CORE_ADDR pc)
      minimal symbols, I'm resorting to the gross hack of checking the
      top byte of the address for all 1's.  Sigh.  */
 
-  return (!target_has_stack && (pc & 0xFF000000));
+  return (!target_has_stack && (pc & 0xFF000000) == 0xFF000000);
 }
 
 /* Return the GDB type object for the "standard" data type of data in
@@ -2587,26 +2564,25 @@ hppa_smash_text_address (CORE_ADDR addr)
   return (addr &= ~0x3);
 }
 
-/* Get the ith function argument for the current function.  */
+/* Get the ARGIth function argument for the current function.  */
+
 static CORE_ADDR
 hppa_fetch_pointer_argument (struct frame_info *frame, int argi, 
                             struct type *type)
 {
-  CORE_ADDR addr;
-  get_frame_register (frame, HPPA_R0_REGNUM + 26 - argi, &addr);
-  return addr;
+  return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
 }
 
 static void
 hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
-                          int regnum, void *buf)
+                          int regnum, gdb_byte *buf)
 {
     ULONGEST tmp;
 
     regcache_raw_read_unsigned (regcache, regnum, &tmp);
     if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
       tmp &= ~0x3;
-    store_unsigned_integer (buf, sizeof(tmp), tmp);
+    store_unsigned_integer (buf, sizeof tmp, tmp);
 }
 
 static CORE_ADDR
@@ -2620,7 +2596,7 @@ hppa_frame_prev_register_helper (struct frame_info *next_frame,
                                 struct trad_frame_saved_reg saved_regs[],
                                 int regnum, int *optimizedp,
                                 enum lval_type *lvalp, CORE_ADDR *addrp,
-                                int *realnump, void *valuep)
+                                int *realnump, gdb_byte *valuep)
 {
   struct gdbarch *arch = get_frame_arch (next_frame);
 
@@ -2762,7 +2738,7 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
                                           hppa64_cannot_store_register);
         break;
       default:
-        internal_error (__FILE__, __LINE__, "Unsupported address size: %d",
+        internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
                         tdep->bytes_per_address);
     }
 
@@ -2814,7 +2790,7 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
       break;
     default:
-      internal_error (__FILE__, __LINE__, "bad switch");
+      internal_error (__FILE__, __LINE__, _("bad switch"));
     }
       
   /* Struct return methods.  */
@@ -2827,7 +2803,7 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       set_gdbarch_return_value (gdbarch, hppa64_return_value);
       break;
     default:
-      internal_error (__FILE__, __LINE__, "bad switch");
+      internal_error (__FILE__, __LINE__, _("bad switch"));
     }
       
   set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
@@ -2868,15 +2844,18 @@ _initialize_hppa_tdep (void)
   hppa_objfile_priv_data = register_objfile_data ();
 
   add_cmd ("unwind", class_maintenance, unwind_command,
-          "Print unwind table entry at given address.",
+          _("Print unwind table entry at given address."),
           &maintenanceprintlist);
 
   /* Debug this files internals. */
-  add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, "\
-Set whether hppa target specific debugging information should be displayed.", "\
-Show whether hppa target specific debugging information is displayed.", "\
+  add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
+Set whether hppa target specific debugging information should be displayed."),
+                          _("\
+Show whether hppa target specific debugging information is displayed."), _("\
 This flag controls whether hppa target specific debugging information is\n\
 displayed.  This information is particularly useful for debugging frame\n\
-unwinding problems.", "hppa debug flag is %s.",
-                          NULL, NULL, &setdebuglist, &showdebuglist);
+unwinding problems."),
+                          NULL,
+                          NULL, /* FIXME: i18n: hppa debug flag is %s.  */
+                          &setdebuglist, &showdebuglist);
 }
This page took 0.029048 seconds and 4 git commands to generate.