gdb/hppa-tdep.c

   1 /* Target-dependent code for the HP PA-RISC architecture.
   2
   3    Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
   5    Free Software Foundation, Inc.
   6
   7    Contributed by the Center for Software Science at the
   8    University of Utah (pa-gdb-bugs@cs.utah.edu).
   9
  10    This file is part of GDB.
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 3 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  24
  25 #include "defs.h"
  26 #include "bfd.h"
  27 #include "inferior.h"
  28 #include "regcache.h"
  29 #include "completer.h"
  30 #include "osabi.h"
  31 #include "gdb_assert.h"
  32 #include "gdb_stdint.h"
  33 #include "arch-utils.h"
  34 /* For argument passing to the inferior */
  35 #include "symtab.h"
  36 #include "dis-asm.h"
  37 #include "trad-frame.h"
  38 #include "frame-unwind.h"
  39 #include "frame-base.h"
  40
  41 #include "gdbcore.h"
  42 #include "gdbcmd.h"
  43 #include "gdbtypes.h"
  44 #include "objfiles.h"
  45 #include "hppa-tdep.h"
  46
  47 static int hppa_debug = 0;
  48
  49 /* Some local constants.  */
  50 static const int hppa32_num_regs = 128;
  51 static const int hppa64_num_regs = 96;
  52
  53 /* hppa-specific object data -- unwind and solib info.
  54    TODO/maybe: think about splitting this into two parts; the unwind data is
  55    common to all hppa targets, but is only used in this file; we can register
  56    that separately and make this static. The solib data is probably hpux-
  57    specific, so we can create a separate extern objfile_data that is registered
  58    by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c.  */
  59 const struct objfile_data *hppa_objfile_priv_data = NULL;
  60
  61 /* Get at various relevent fields of an instruction word. */
  62 #define MASK_5 0x1f
  63 #define MASK_11 0x7ff
  64 #define MASK_14 0x3fff
  65 #define MASK_21 0x1fffff
  66
  67 /* Sizes (in bytes) of the native unwind entries.  */
  68 #define UNWIND_ENTRY_SIZE 16
  69 #define STUB_UNWIND_ENTRY_SIZE 8
  70
  71 /* Routines to extract various sized constants out of hppa
  72    instructions. */
  73
  74 /* This assumes that no garbage lies outside of the lower bits of
  75    value. */
  76
  77 int
  78 hppa_sign_extend (unsigned val, unsigned bits)
  79 {
  80   return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
  81 }
  82
  83 /* For many immediate values the sign bit is the low bit! */
  84
  85 int
  86 hppa_low_hppa_sign_extend (unsigned val, unsigned bits)
  87 {
  88   return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
  89 }
  90
  91 /* Extract the bits at positions between FROM and TO, using HP's numbering
  92    (MSB = 0). */
  93
  94 int
  95 hppa_get_field (unsigned word, int from, int to)
  96 {
  97   return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1));
  98 }
  99
 100 /* extract the immediate field from a ld{bhw}s instruction */
 101
 102 int
 103 hppa_extract_5_load (unsigned word)
 104 {
 105   return hppa_low_hppa_sign_extend (word >> 16 & MASK_5, 5);
 106 }
 107
 108 /* extract the immediate field from a break instruction */
 109
 110 unsigned
 111 hppa_extract_5r_store (unsigned word)
 112 {
 113   return (word & MASK_5);
 114 }
 115
 116 /* extract the immediate field from a {sr}sm instruction */
 117
 118 unsigned
 119 hppa_extract_5R_store (unsigned word)
 120 {
 121   return (word >> 16 & MASK_5);
 122 }
 123
 124 /* extract a 14 bit immediate field */
 125
 126 int
 127 hppa_extract_14 (unsigned word)
 128 {
 129   return hppa_low_hppa_sign_extend (word & MASK_14, 14);
 130 }
 131
 132 /* extract a 21 bit constant */
 133
 134 int
 135 hppa_extract_21 (unsigned word)
 136 {
 137   int val;
 138
 139   word &= MASK_21;
 140   word <<= 11;
 141   val = hppa_get_field (word, 20, 20);
 142   val <<= 11;
 143   val |= hppa_get_field (word, 9, 19);
 144   val <<= 2;
 145   val |= hppa_get_field (word, 5, 6);
 146   val <<= 5;
 147   val |= hppa_get_field (word, 0, 4);
 148   val <<= 2;
 149   val |= hppa_get_field (word, 7, 8);
 150   return hppa_sign_extend (val, 21) << 11;
 151 }
 152
 153 /* extract a 17 bit constant from branch instructions, returning the
 154    19 bit signed value. */
 155
 156 int
 157 hppa_extract_17 (unsigned word)
 158 {
 159   return hppa_sign_extend (hppa_get_field (word, 19, 28) |
 160                       hppa_get_field (word, 29, 29) << 10 |
 161                       hppa_get_field (word, 11, 15) << 11 |
 162                       (word & 0x1) << 16, 17) << 2;
 163 }
 164
 165 CORE_ADDR
 166 hppa_symbol_address(const char *sym)
 167 {
 168   struct minimal_symbol *minsym;
 169
 170   minsym = lookup_minimal_symbol (sym, NULL, NULL);
 171   if (minsym)
 172     return SYMBOL_VALUE_ADDRESS (minsym);
 173   else
 174     return (CORE_ADDR)-1;
 175 }
 176
 177 struct hppa_objfile_private *
 178 hppa_init_objfile_priv_data (struct objfile *objfile)
 179 {
 180   struct hppa_objfile_private *priv;
 181
 182   priv = (struct hppa_objfile_private *)
 183          obstack_alloc (&objfile->objfile_obstack,
 184                         sizeof (struct hppa_objfile_private));
 185   set_objfile_data (objfile, hppa_objfile_priv_data, priv);
 186   memset (priv, 0, sizeof (*priv));
 187
 188   return priv;
 189 }
 190 \f
 191
 192 /* Compare the start address for two unwind entries returning 1 if
 193    the first address is larger than the second, -1 if the second is
 194    larger than the first, and zero if they are equal.  */
 195
 196 static int
 197 compare_unwind_entries (const void *arg1, const void *arg2)
 198 {
 199   const struct unwind_table_entry *a = arg1;
 200   const struct unwind_table_entry *b = arg2;
 201
 202   if (a->region_start > b->region_start)
 203     return 1;
 204   else if (a->region_start < b->region_start)
 205     return -1;
 206   else
 207     return 0;
 208 }
 209
 210 static void
 211 record_text_segment_lowaddr (bfd *abfd, asection *section, void *data)
 212 {
 213   if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
 214        == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
 215     {
 216       bfd_vma value = section->vma - section->filepos;
 217       CORE_ADDR *low_text_segment_address = (CORE_ADDR *)data;
 218
 219       if (value < *low_text_segment_address)
 220           *low_text_segment_address = value;
 221     }
 222 }
 223
 224 static void
 225 internalize_unwinds (struct objfile *objfile, struct unwind_table_entry *table,
 226                      asection *section, unsigned int entries, unsigned int size,
 227                      CORE_ADDR text_offset)
 228 {
 229   /* We will read the unwind entries into temporary memory, then
 230      fill in the actual unwind table.  */
 231
 232   if (size > 0)
 233     {
 234       unsigned long tmp;
 235       unsigned i;
 236       char *buf = alloca (size);
 237       CORE_ADDR low_text_segment_address;
 238
 239       /* For ELF targets, then unwinds are supposed to
 240          be segment relative offsets instead of absolute addresses.
 241
 242          Note that when loading a shared library (text_offset != 0) the
 243          unwinds are already relative to the text_offset that will be
 244          passed in.  */
 245       if (gdbarch_tdep (current_gdbarch)->is_elf && text_offset == 0)
 246         {
 247           low_text_segment_address = -1;
 248
 249           bfd_map_over_sections (objfile->obfd,
 250                                  record_text_segment_lowaddr,
 251                                  &low_text_segment_address);
 252
 253           text_offset = low_text_segment_address;
 254         }
 255       else if (gdbarch_tdep (current_gdbarch)->solib_get_text_base)
 256         {
 257           text_offset = gdbarch_tdep (current_gdbarch)->solib_get_text_base (objfile);
 258         }
 259
 260       bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
 261
 262       /* Now internalize the information being careful to handle host/target
 263          endian issues.  */
 264       for (i = 0; i < entries; i++)
 265         {
 266           table[i].region_start = bfd_get_32 (objfile->obfd,
 267                                               (bfd_byte *) buf);
 268           table[i].region_start += text_offset;
 269           buf += 4;
 270           table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
 271           table[i].region_end += text_offset;
 272           buf += 4;
 273           tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
 274           buf += 4;
 275           table[i].Cannot_unwind = (tmp >> 31) & 0x1;
 276           table[i].Millicode = (tmp >> 30) & 0x1;
 277           table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
 278           table[i].Region_description = (tmp >> 27) & 0x3;
 279           table[i].reserved = (tmp >> 26) & 0x1;
 280           table[i].Entry_SR = (tmp >> 25) & 0x1;
 281           table[i].Entry_FR = (tmp >> 21) & 0xf;
 282           table[i].Entry_GR = (tmp >> 16) & 0x1f;
 283           table[i].Args_stored = (tmp >> 15) & 0x1;
 284           table[i].Variable_Frame = (tmp >> 14) & 0x1;
 285           table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
 286           table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
 287           table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
 288           table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
 289           table[i].sr4export = (tmp >> 9) & 0x1;
 290           table[i].cxx_info = (tmp >> 8) & 0x1;
 291           table[i].cxx_try_catch = (tmp >> 7) & 0x1;
 292           table[i].sched_entry_seq = (tmp >> 6) & 0x1;
 293           table[i].reserved1 = (tmp >> 5) & 0x1;
 294           table[i].Save_SP = (tmp >> 4) & 0x1;
 295           table[i].Save_RP = (tmp >> 3) & 0x1;
 296           table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
 297           table[i].save_r19 = (tmp >> 1) & 0x1;
 298           table[i].Cleanup_defined = tmp & 0x1;
 299           tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
 300           buf += 4;
 301           table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
 302           table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
 303           table[i].Large_frame = (tmp >> 29) & 0x1;
 304           table[i].alloca_frame = (tmp >> 28) & 0x1;
 305           table[i].reserved2 = (tmp >> 27) & 0x1;
 306           table[i].Total_frame_size = tmp & 0x7ffffff;
 307
 308           /* Stub unwinds are handled elsewhere. */
 309           table[i].stub_unwind.stub_type = 0;
 310           table[i].stub_unwind.padding = 0;
 311         }
 312     }
 313 }
 314
 315 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
 316    the object file.  This info is used mainly by find_unwind_entry() to find
 317    out the stack frame size and frame pointer used by procedures.  We put
 318    everything on the psymbol obstack in the objfile so that it automatically
 319    gets freed when the objfile is destroyed.  */
 320
 321 static void
 322 read_unwind_info (struct objfile *objfile)
 323 {
 324   asection *unwind_sec, *stub_unwind_sec;
 325   unsigned unwind_size, stub_unwind_size, total_size;
 326   unsigned index, unwind_entries;
 327   unsigned stub_entries, total_entries;
 328   CORE_ADDR text_offset;
 329   struct hppa_unwind_info *ui;
 330   struct hppa_objfile_private *obj_private;
 331
 332   text_offset = ANOFFSET (objfile->section_offsets, 0);
 333   ui = (struct hppa_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
 334                                            sizeof (struct hppa_unwind_info));
 335
 336   ui->table = NULL;
 337   ui->cache = NULL;
 338   ui->last = -1;
 339
 340   /* For reasons unknown the HP PA64 tools generate multiple unwinder
 341      sections in a single executable.  So we just iterate over every
 342      section in the BFD looking for unwinder sections intead of trying
 343      to do a lookup with bfd_get_section_by_name.
 344
 345      First determine the total size of the unwind tables so that we
 346      can allocate memory in a nice big hunk.  */
 347   total_entries = 0;
 348   for (unwind_sec = objfile->obfd->sections;
 349        unwind_sec;
 350        unwind_sec = unwind_sec->next)
 351     {
 352       if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
 353           || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
 354         {
 355           unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
 356           unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
 357
 358           total_entries += unwind_entries;
 359         }
 360     }
 361
 362   /* Now compute the size of the stub unwinds.  Note the ELF tools do not
 363      use stub unwinds at the current time.  */
 364   stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
 365
 366   if (stub_unwind_sec)
 367     {
 368       stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
 369       stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
 370     }
 371   else
 372     {
 373       stub_unwind_size = 0;
 374       stub_entries = 0;
 375     }
 376
 377   /* Compute total number of unwind entries and their total size.  */
 378   total_entries += stub_entries;
 379   total_size = total_entries * sizeof (struct unwind_table_entry);
 380
 381   /* Allocate memory for the unwind table.  */
 382   ui->table = (struct unwind_table_entry *)
 383     obstack_alloc (&objfile->objfile_obstack, total_size);
 384   ui->last = total_entries - 1;
 385
 386   /* Now read in each unwind section and internalize the standard unwind
 387      entries.  */
 388   index = 0;
 389   for (unwind_sec = objfile->obfd->sections;
 390        unwind_sec;
 391        unwind_sec = unwind_sec->next)
 392     {
 393       if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
 394           || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
 395         {
 396           unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
 397           unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
 398
 399           internalize_unwinds (objfile, &ui->table[index], unwind_sec,
 400                                unwind_entries, unwind_size, text_offset);
 401           index += unwind_entries;
 402         }
 403     }
 404
 405   /* Now read in and internalize the stub unwind entries.  */
 406   if (stub_unwind_size > 0)
 407     {
 408       unsigned int i;
 409       char *buf = alloca (stub_unwind_size);
 410
 411       /* Read in the stub unwind entries.  */
 412       bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
 413                                 0, stub_unwind_size);
 414
 415       /* Now convert them into regular unwind entries.  */
 416       for (i = 0; i < stub_entries; i++, index++)
 417         {
 418           /* Clear out the next unwind entry.  */
 419           memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
 420
 421           /* Convert offset & size into region_start and region_end.
 422              Stuff away the stub type into "reserved" fields.  */
 423           ui->table[index].region_start = bfd_get_32 (objfile->obfd,
 424                                                       (bfd_byte *) buf);
 425           ui->table[index].region_start += text_offset;
 426           buf += 4;
 427           ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
 428                                                           (bfd_byte *) buf);
 429           buf += 2;
 430           ui->table[index].region_end
 431             = ui->table[index].region_start + 4 *
 432             (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
 433           buf += 2;
 434         }
 435
 436     }
 437
 438   /* Unwind table needs to be kept sorted.  */
 439   qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
 440          compare_unwind_entries);
 441
 442   /* Keep a pointer to the unwind information.  */
 443   obj_private = (struct hppa_objfile_private *)
 444                 objfile_data (objfile, hppa_objfile_priv_data);
 445   if (obj_private == NULL)
 446     obj_private = hppa_init_objfile_priv_data (objfile);
 447
 448   obj_private->unwind_info = ui;
 449 }
 450
 451 /* Lookup the unwind (stack backtrace) info for the given PC.  We search all
 452    of the objfiles seeking the unwind table entry for this PC.  Each objfile
 453    contains a sorted list of struct unwind_table_entry.  Since we do a binary
 454    search of the unwind tables, we depend upon them to be sorted.  */
 455
 456 struct unwind_table_entry *
 457 find_unwind_entry (CORE_ADDR pc)
 458 {
 459   int first, middle, last;
 460   struct objfile *objfile;
 461   struct hppa_objfile_private *priv;
 462
 463   if (hppa_debug)
 464     fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry 0x%s -> ",
 465                         paddr_nz (pc));
 466
 467   /* A function at address 0?  Not in HP-UX! */
 468   if (pc == (CORE_ADDR) 0)
 469     {
 470       if (hppa_debug)
 471         fprintf_unfiltered (gdb_stdlog, "NULL }\n");
 472       return NULL;
 473     }
 474
 475   ALL_OBJFILES (objfile)
 476   {
 477     struct hppa_unwind_info *ui;
 478     ui = NULL;
 479     priv = objfile_data (objfile, hppa_objfile_priv_data);
 480     if (priv)
 481       ui = ((struct hppa_objfile_private *) priv)->unwind_info;
 482
 483     if (!ui)
 484       {
 485         read_unwind_info (objfile);
 486         priv = objfile_data (objfile, hppa_objfile_priv_data);
 487         if (priv == NULL)
 488           error (_("Internal error reading unwind information."));
 489         ui = ((struct hppa_objfile_private *) priv)->unwind_info;
 490       }
 491
 492     /* First, check the cache */
 493
 494     if (ui->cache
 495         && pc >= ui->cache->region_start
 496         && pc <= ui->cache->region_end)
 497       {
 498         if (hppa_debug)
 499           fprintf_unfiltered (gdb_stdlog, "0x%s (cached) }\n",
 500             paddr_nz ((uintptr_t) ui->cache));
 501         return ui->cache;
 502       }
 503
 504     /* Not in the cache, do a binary search */
 505
 506     first = 0;
 507     last = ui->last;
 508
 509     while (first <= last)
 510       {
 511         middle = (first + last) / 2;
 512         if (pc >= ui->table[middle].region_start
 513             && pc <= ui->table[middle].region_end)
 514           {
 515             ui->cache = &ui->table[middle];
 516             if (hppa_debug)
 517               fprintf_unfiltered (gdb_stdlog, "0x%s }\n",
 518                 paddr_nz ((uintptr_t) ui->cache));
 519             return &ui->table[middle];
 520           }
 521
 522         if (pc < ui->table[middle].region_start)
 523           last = middle - 1;
 524         else
 525           first = middle + 1;
 526       }
 527   }                             /* ALL_OBJFILES() */
 528
 529   if (hppa_debug)
 530     fprintf_unfiltered (gdb_stdlog, "NULL (not found) }\n");
 531
 532   return NULL;
 533 }
 534
 535 /* The epilogue is defined here as the area either on the `bv' instruction
 536    itself or an instruction which destroys the function's stack frame.
 537
 538    We do not assume that the epilogue is at the end of a function as we can
 539    also have return sequences in the middle of a function.  */
 540 static int
 541 hppa_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 542 {
 543   unsigned long status;
 544   unsigned int inst;
 545   char buf[4];
 546   int off;
 547
 548   status = read_memory_nobpt (pc, buf, 4);
 549   if (status != 0)
 550     return 0;
 551
 552   inst = extract_unsigned_integer (buf, 4);
 553
 554   /* The most common way to perform a stack adjustment ldo X(sp),sp
 555      We are destroying a stack frame if the offset is negative.  */
 556   if ((inst & 0xffffc000) == 0x37de0000
 557       && hppa_extract_14 (inst) < 0)
 558     return 1;
 559
 560   /* ldw,mb D(sp),X or ldd,mb D(sp),X */
 561   if (((inst & 0x0fc010e0) == 0x0fc010e0
 562        || (inst & 0x0fc010e0) == 0x0fc010e0)
 563       && hppa_extract_14 (inst) < 0)
 564     return 1;
 565
 566   /* bv %r0(%rp) or bv,n %r0(%rp) */
 567   if (inst == 0xe840c000 || inst == 0xe840c002)
 568     return 1;
 569
 570   return 0;
 571 }
 572
 573 static const unsigned char *
 574 hppa_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
 575 {
 576   static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
 577   (*len) = sizeof (breakpoint);
 578   return breakpoint;
 579 }
 580
 581 /* Return the name of a register.  */
 582
 583 static const char *
 584 hppa32_register_name (struct gdbarch *gdbarch, int i)
 585 {
 586   static char *names[] = {
 587     "flags",  "r1",      "rp",     "r3",
 588     "r4",     "r5",      "r6",     "r7",
 589     "r8",     "r9",      "r10",    "r11",
 590     "r12",    "r13",     "r14",    "r15",
 591     "r16",    "r17",     "r18",    "r19",
 592     "r20",    "r21",     "r22",    "r23",
 593     "r24",    "r25",     "r26",    "dp",
 594     "ret0",   "ret1",    "sp",     "r31",
 595     "sar",    "pcoqh",   "pcsqh",  "pcoqt",
 596     "pcsqt",  "eiem",    "iir",    "isr",
 597     "ior",    "ipsw",    "goto",   "sr4",
 598     "sr0",    "sr1",     "sr2",    "sr3",
 599     "sr5",    "sr6",     "sr7",    "cr0",
 600     "cr8",    "cr9",     "ccr",    "cr12",
 601     "cr13",   "cr24",    "cr25",   "cr26",
 602     "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
 603     "fpsr",    "fpe1",   "fpe2",   "fpe3",
 604     "fpe4",   "fpe5",    "fpe6",   "fpe7",
 605     "fr4",     "fr4R",   "fr5",    "fr5R",
 606     "fr6",    "fr6R",    "fr7",    "fr7R",
 607     "fr8",     "fr8R",   "fr9",    "fr9R",
 608     "fr10",   "fr10R",   "fr11",   "fr11R",
 609     "fr12",    "fr12R",  "fr13",   "fr13R",
 610     "fr14",   "fr14R",   "fr15",   "fr15R",
 611     "fr16",    "fr16R",  "fr17",   "fr17R",
 612     "fr18",   "fr18R",   "fr19",   "fr19R",
 613     "fr20",    "fr20R",  "fr21",   "fr21R",
 614     "fr22",   "fr22R",   "fr23",   "fr23R",
 615     "fr24",    "fr24R",  "fr25",   "fr25R",
 616     "fr26",   "fr26R",   "fr27",   "fr27R",
 617     "fr28",    "fr28R",  "fr29",   "fr29R",
 618     "fr30",   "fr30R",   "fr31",   "fr31R"
 619   };
 620   if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
 621     return NULL;
 622   else
 623     return names[i];
 624 }
 625
 626 static const char *
 627 hppa64_register_name (struct gdbarch *gdbarch, int i)
 628 {
 629   static char *names[] = {
 630     "flags",  "r1",      "rp",     "r3",
 631     "r4",     "r5",      "r6",     "r7",
 632     "r8",     "r9",      "r10",    "r11",
 633     "r12",    "r13",     "r14",    "r15",
 634     "r16",    "r17",     "r18",    "r19",
 635     "r20",    "r21",     "r22",    "r23",
 636     "r24",    "r25",     "r26",    "dp",
 637     "ret0",   "ret1",    "sp",     "r31",
 638     "sar",    "pcoqh",   "pcsqh",  "pcoqt",
 639     "pcsqt",  "eiem",    "iir",    "isr",
 640     "ior",    "ipsw",    "goto",   "sr4",
 641     "sr0",    "sr1",     "sr2",    "sr3",
 642     "sr5",    "sr6",     "sr7",    "cr0",
 643     "cr8",    "cr9",     "ccr",    "cr12",
 644     "cr13",   "cr24",    "cr25",   "cr26",
 645     "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
 646     "fpsr",    "fpe1",   "fpe2",   "fpe3",
 647     "fr4",    "fr5",     "fr6",    "fr7",
 648     "fr8",     "fr9",    "fr10",   "fr11",
 649     "fr12",   "fr13",    "fr14",   "fr15",
 650     "fr16",    "fr17",   "fr18",   "fr19",
 651     "fr20",   "fr21",    "fr22",   "fr23",
 652     "fr24",    "fr25",   "fr26",   "fr27",
 653     "fr28",  "fr29",    "fr30",   "fr31"
 654   };
 655   if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
 656     return NULL;
 657   else
 658     return names[i];
 659 }
 660
 661 static int
 662 hppa64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 663 {
 664   /* r0-r31 and sar map one-to-one.  */
 665   if (reg <= 32)
 666     return reg;
 667
 668   /* fr4-fr31 are mapped from 72 in steps of 2.  */
 669   if (reg >= 72 || reg < 72 + 28 * 2)
 670     return HPPA64_FP4_REGNUM + (reg - 72) / 2;
 671
 672   error ("Invalid DWARF register num %d.", reg);
 673   return -1;
 674 }
 675
 676 /* This function pushes a stack frame with arguments as part of the
 677    inferior function calling mechanism.
 678
 679    This is the version of the function for the 32-bit PA machines, in
 680    which later arguments appear at lower addresses.  (The stack always
 681    grows towards higher addresses.)
 682
 683    We simply allocate the appropriate amount of stack space and put
 684    arguments into their proper slots.  */
 685
 686 static CORE_ADDR
 687 hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 688                         struct regcache *regcache, CORE_ADDR bp_addr,
 689                         int nargs, struct value **args, CORE_ADDR sp,
 690                         int struct_return, CORE_ADDR struct_addr)
 691 {
 692   /* Stack base address at which any pass-by-reference parameters are
 693      stored.  */
 694   CORE_ADDR struct_end = 0;
 695   /* Stack base address at which the first parameter is stored.  */
 696   CORE_ADDR param_end = 0;
 697
 698   /* The inner most end of the stack after all the parameters have
 699      been pushed.  */
 700   CORE_ADDR new_sp = 0;
 701
 702   /* Two passes.  First pass computes the location of everything,
 703      second pass writes the bytes out.  */
 704   int write_pass;
 705
 706   /* Global pointer (r19) of the function we are trying to call.  */
 707   CORE_ADDR gp;
 708
 709   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 710
 711   for (write_pass = 0; write_pass < 2; write_pass++)
 712     {
 713       CORE_ADDR struct_ptr = 0;
 714       /* The first parameter goes into sp-36, each stack slot is 4-bytes.
 715          struct_ptr is adjusted for each argument below, so the first
 716          argument will end up at sp-36.  */
 717       CORE_ADDR param_ptr = 32;
 718       int i;
 719       int small_struct = 0;
 720
 721       for (i = 0; i < nargs; i++)
 722         {
 723           struct value *arg = args[i];
 724           struct type *type = check_typedef (value_type (arg));
 725           /* The corresponding parameter that is pushed onto the
 726              stack, and [possibly] passed in a register.  */
 727           char param_val[8];
 728           int param_len;
 729           memset (param_val, 0, sizeof param_val);
 730           if (TYPE_LENGTH (type) > 8)
 731             {
 732               /* Large parameter, pass by reference.  Store the value
 733                  in "struct" area and then pass its address.  */
 734               param_len = 4;
 735               struct_ptr += align_up (TYPE_LENGTH (type), 8);
 736               if (write_pass)
 737                 write_memory (struct_end - struct_ptr, value_contents (arg),
 738                               TYPE_LENGTH (type));
 739               store_unsigned_integer (param_val, 4, struct_end - struct_ptr);
 740             }
 741           else if (TYPE_CODE (type) == TYPE_CODE_INT
 742                    || TYPE_CODE (type) == TYPE_CODE_ENUM)
 743             {
 744               /* Integer value store, right aligned.  "unpack_long"
 745                  takes care of any sign-extension problems.  */
 746               param_len = align_up (TYPE_LENGTH (type), 4);
 747               store_unsigned_integer (param_val, param_len,
 748                                       unpack_long (type,
 749                                                    value_contents (arg)));
 750             }
 751           else if (TYPE_CODE (type) == TYPE_CODE_FLT)
 752             {
 753               /* Floating point value store, right aligned.  */
 754               param_len = align_up (TYPE_LENGTH (type), 4);
 755               memcpy (param_val, value_contents (arg), param_len);
 756             }
 757           else
 758             {
 759               param_len = align_up (TYPE_LENGTH (type), 4);
 760
 761               /* Small struct value are stored right-aligned.  */
 762               memcpy (param_val + param_len - TYPE_LENGTH (type),
 763                       value_contents (arg), TYPE_LENGTH (type));
 764
 765               /* Structures of size 5, 6 and 7 bytes are special in that
 766                  the higher-ordered word is stored in the lower-ordered
 767                  argument, and even though it is a 8-byte quantity the
 768                  registers need not be 8-byte aligned.  */
 769               if (param_len > 4 && param_len < 8)
 770                 small_struct = 1;
 771             }
 772
 773           param_ptr += param_len;
 774           if (param_len == 8 && !small_struct)
 775             param_ptr = align_up (param_ptr, 8);
 776
 777           /* First 4 non-FP arguments are passed in gr26-gr23.
 778              First 4 32-bit FP arguments are passed in fr4L-fr7L.
 779              First 2 64-bit FP arguments are passed in fr5 and fr7.
 780
 781              The rest go on the stack, starting at sp-36, towards lower
 782              addresses.  8-byte arguments must be aligned to a 8-byte
 783              stack boundary.  */
 784           if (write_pass)
 785             {
 786               write_memory (param_end - param_ptr, param_val, param_len);
 787
 788               /* There are some cases when we don't know the type
 789                  expected by the callee (e.g. for variadic functions), so
 790                  pass the parameters in both general and fp regs.  */
 791               if (param_ptr <= 48)
 792                 {
 793                   int grreg = 26 - (param_ptr - 36) / 4;
 794                   int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
 795                   int fpreg = 74 + (param_ptr - 32) / 8 * 4;
 796
 797                   regcache_cooked_write (regcache, grreg, param_val);
 798                   regcache_cooked_write (regcache, fpLreg, param_val);
 799
 800                   if (param_len > 4)
 801                     {
 802                       regcache_cooked_write (regcache, grreg + 1,
 803                                              param_val + 4);
 804
 805                       regcache_cooked_write (regcache, fpreg, param_val);
 806                       regcache_cooked_write (regcache, fpreg + 1,
 807                                              param_val + 4);
 808                     }
 809                 }
 810             }
 811         }
 812
 813       /* Update the various stack pointers.  */
 814       if (!write_pass)
 815         {
 816           struct_end = sp + align_up (struct_ptr, 64);
 817           /* PARAM_PTR already accounts for all the arguments passed
 818              by the user.  However, the ABI mandates minimum stack
 819              space allocations for outgoing arguments.  The ABI also
 820              mandates minimum stack alignments which we must
 821              preserve.  */
 822           param_end = struct_end + align_up (param_ptr, 64);
 823         }
 824     }
 825
 826   /* If a structure has to be returned, set up register 28 to hold its
 827      address */
 828   if (struct_return)
 829     regcache_cooked_write_unsigned (regcache, 28, struct_addr);
 830
 831   gp = tdep->find_global_pointer (function);
 832
 833   if (gp != 0)
 834     regcache_cooked_write_unsigned (regcache, 19, gp);
 835
 836   /* Set the return address.  */
 837   if (!gdbarch_push_dummy_code_p (gdbarch))
 838     regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
 839
 840   /* Update the Stack Pointer.  */
 841   regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end);
 842
 843   return param_end;
 844 }
 845
 846 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
 847    Runtime Architecture for PA-RISC 2.0", which is distributed as part
 848    as of the HP-UX Software Transition Kit (STK).  This implementation
 849    is based on version 3.3, dated October 6, 1997.  */
 850
 851 /* Check whether TYPE is an "Integral or Pointer Scalar Type".  */
 852
 853 static int
 854 hppa64_integral_or_pointer_p (const struct type *type)
 855 {
 856   switch (TYPE_CODE (type))
 857     {
 858     case TYPE_CODE_INT:
 859     case TYPE_CODE_BOOL:
 860     case TYPE_CODE_CHAR:
 861     case TYPE_CODE_ENUM:
 862     case TYPE_CODE_RANGE:
 863       {
 864         int len = TYPE_LENGTH (type);
 865         return (len == 1 || len == 2 || len == 4 || len == 8);
 866       }
 867     case TYPE_CODE_PTR:
 868     case TYPE_CODE_REF:
 869       return (TYPE_LENGTH (type) == 8);
 870     default:
 871       break;
 872     }
 873
 874   return 0;
 875 }
 876
 877 /* Check whether TYPE is a "Floating Scalar Type".  */
 878
 879 static int
 880 hppa64_floating_p (const struct type *type)
 881 {
 882   switch (TYPE_CODE (type))
 883     {
 884     case TYPE_CODE_FLT:
 885       {
 886         int len = TYPE_LENGTH (type);
 887         return (len == 4 || len == 8 || len == 16);
 888       }
 889     default:
 890       break;
 891     }
 892
 893   return 0;
 894 }
 895
 896 /* If CODE points to a function entry address, try to look up the corresponding
 897    function descriptor and return its address instead.  If CODE is not a
 898    function entry address, then just return it unchanged.  */
 899 static CORE_ADDR
 900 hppa64_convert_code_addr_to_fptr (CORE_ADDR code)
 901 {
 902   struct obj_section *sec, *opd;
 903
 904   sec = find_pc_section (code);
 905
 906   if (!sec)
 907     return code;
 908
 909   /* If CODE is in a data section, assume it's already a fptr.  */
 910   if (!(sec->the_bfd_section->flags & SEC_CODE))
 911     return code;
 912
 913   ALL_OBJFILE_OSECTIONS (sec->objfile, opd)
 914     {
 915       if (strcmp (opd->the_bfd_section->name, ".opd") == 0)
 916         break;
 917     }
 918
 919   if (opd < sec->objfile->sections_end)
 920     {
 921       CORE_ADDR addr;
 922
 923       for (addr = opd->addr; addr < opd->endaddr; addr += 2 * 8)
 924         {
 925           ULONGEST opdaddr;
 926           char tmp[8];
 927
 928           if (target_read_memory (addr, tmp, sizeof (tmp)))
 929               break;
 930           opdaddr = extract_unsigned_integer (tmp, sizeof (tmp));
 931
 932           if (opdaddr == code)
 933             return addr - 16;
 934         }
 935     }
 936
 937   return code;
 938 }
 939
 940 static CORE_ADDR
 941 hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 942                         struct regcache *regcache, CORE_ADDR bp_addr,
 943                         int nargs, struct value **args, CORE_ADDR sp,
 944                         int struct_return, CORE_ADDR struct_addr)
 945 {
 946   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 947   int i, offset = 0;
 948   CORE_ADDR gp;
 949
 950   /* "The outgoing parameter area [...] must be aligned at a 16-byte
 951      boundary."  */
 952   sp = align_up (sp, 16);
 953
 954   for (i = 0; i < nargs; i++)
 955     {
 956       struct value *arg = args[i];
 957       struct type *type = value_type (arg);
 958       int len = TYPE_LENGTH (type);
 959       const bfd_byte *valbuf;
 960       bfd_byte fptrbuf[8];
 961       int regnum;
 962
 963       /* "Each parameter begins on a 64-bit (8-byte) boundary."  */
 964       offset = align_up (offset, 8);
 965
 966       if (hppa64_integral_or_pointer_p (type))
 967         {
 968           /* "Integral scalar parameters smaller than 64 bits are
 969              padded on the left (i.e., the value is in the
 970              least-significant bits of the 64-bit storage unit, and
 971              the high-order bits are undefined)."  Therefore we can
 972              safely sign-extend them.  */
 973           if (len < 8)
 974             {
 975               arg = value_cast (builtin_type_int64, arg);
 976               len = 8;
 977             }
 978         }
 979       else if (hppa64_floating_p (type))
 980         {
 981           if (len > 8)
 982             {
 983               /* "Quad-precision (128-bit) floating-point scalar
 984                  parameters are aligned on a 16-byte boundary."  */
 985               offset = align_up (offset, 16);
 986
 987               /* "Double-extended- and quad-precision floating-point
 988                  parameters within the first 64 bytes of the parameter
 989                  list are always passed in general registers."  */
 990             }
 991           else
 992             {
 993               if (len == 4)
 994                 {
 995                   /* "Single-precision (32-bit) floating-point scalar
 996                      parameters are padded on the left with 32 bits of
 997                      garbage (i.e., the floating-point value is in the
 998                      least-significant 32 bits of a 64-bit storage
 999                      unit)."  */
1000                   offset += 4;
1001                 }
1002
1003               /* "Single- and double-precision floating-point
1004                  parameters in this area are passed according to the
1005                  available formal parameter information in a function
1006                  prototype.  [...]  If no prototype is in scope,
1007                  floating-point parameters must be passed both in the
1008                  corresponding general registers and in the
1009                  corresponding floating-point registers."  */
1010               regnum = HPPA64_FP4_REGNUM + offset / 8;
1011
1012               if (regnum < HPPA64_FP4_REGNUM + 8)
1013                 {
1014                   /* "Single-precision floating-point parameters, when
1015                      passed in floating-point registers, are passed in
1016                      the right halves of the floating point registers;
1017                      the left halves are unused."  */
1018                   regcache_cooked_write_part (regcache, regnum, offset % 8,
1019                                               len, value_contents (arg));
1020                 }
1021             }
1022         }
1023       else
1024         {
1025           if (len > 8)
1026             {
1027               /* "Aggregates larger than 8 bytes are aligned on a
1028                  16-byte boundary, possibly leaving an unused argument
1029                  slot, which is filled with garbage. If necessary,
1030                  they are padded on the right (with garbage), to a
1031                  multiple of 8 bytes."  */
1032               offset = align_up (offset, 16);
1033             }
1034         }
1035
1036       /* If we are passing a function pointer, make sure we pass a function
1037          descriptor instead of the function entry address.  */
1038       if (TYPE_CODE (type) == TYPE_CODE_PTR
1039           && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1040         {
1041           ULONGEST codeptr, fptr;
1042
1043           codeptr = unpack_long (type, value_contents (arg));
1044           fptr = hppa64_convert_code_addr_to_fptr (codeptr);
1045           store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), fptr);
1046           valbuf = fptrbuf;
1047         }
1048       else
1049         {
1050           valbuf = value_contents (arg);
1051         }
1052
1053       /* Always store the argument in memory.  */
1054       write_memory (sp + offset, valbuf, len);
1055
1056       regnum = HPPA_ARG0_REGNUM - offset / 8;
1057       while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
1058         {
1059           regcache_cooked_write_part (regcache, regnum,
1060                                       offset % 8, min (len, 8), valbuf);
1061           offset += min (len, 8);
1062           valbuf += min (len, 8);
1063           len -= min (len, 8);
1064           regnum--;
1065         }
1066
1067       offset += len;
1068     }
1069
1070   /* Set up GR29 (%ret1) to hold the argument pointer (ap).  */
1071   regcache_cooked_write_unsigned (regcache, HPPA_RET1_REGNUM, sp + 64);
1072
1073   /* Allocate the outgoing parameter area.  Make sure the outgoing
1074      parameter area is multiple of 16 bytes in length.  */
1075   sp += max (align_up (offset, 16), 64);
1076
1077   /* Allocate 32-bytes of scratch space.  The documentation doesn't
1078      mention this, but it seems to be needed.  */
1079   sp += 32;
1080
1081   /* Allocate the frame marker area.  */
1082   sp += 16;
1083
1084   /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1085      its address.  */
1086   if (struct_return)
1087     regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
1088
1089   /* Set up GR27 (%dp) to hold the global pointer (gp).  */
1090   gp = tdep->find_global_pointer (function);
1091   if (gp != 0)
1092     regcache_cooked_write_unsigned (regcache, HPPA_DP_REGNUM, gp);
1093
1094   /* Set up GR2 (%rp) to hold the return pointer (rp).  */
1095   if (!gdbarch_push_dummy_code_p (gdbarch))
1096     regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
1097
1098   /* Set up GR30 to hold the stack pointer (sp).  */
1099   regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, sp);
1100
1101   return sp;
1102 }
1103 \f
1104
1105 /* Handle 32/64-bit struct return conventions.  */
1106
1107 static enum return_value_convention
1108 hppa32_return_value (struct gdbarch *gdbarch,
1109                      struct type *type, struct regcache *regcache,
1110                      gdb_byte *readbuf, const gdb_byte *writebuf)
1111 {
1112   if (TYPE_LENGTH (type) <= 2 * 4)
1113     {
1114       /* The value always lives in the right hand end of the register
1115          (or register pair)?  */
1116       int b;
1117       int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
1118       int part = TYPE_LENGTH (type) % 4;
1119       /* The left hand register contains only part of the value,
1120          transfer that first so that the rest can be xfered as entire
1121          4-byte registers.  */
1122       if (part > 0)
1123         {
1124           if (readbuf != NULL)
1125             regcache_cooked_read_part (regcache, reg, 4 - part,
1126                                        part, readbuf);
1127           if (writebuf != NULL)
1128             regcache_cooked_write_part (regcache, reg, 4 - part,
1129                                         part, writebuf);
1130           reg++;
1131         }
1132       /* Now transfer the remaining register values.  */
1133       for (b = part; b < TYPE_LENGTH (type); b += 4)
1134         {
1135           if (readbuf != NULL)
1136             regcache_cooked_read (regcache, reg, readbuf + b);
1137           if (writebuf != NULL)
1138             regcache_cooked_write (regcache, reg, writebuf + b);
1139           reg++;
1140         }
1141       return RETURN_VALUE_REGISTER_CONVENTION;
1142     }
1143   else
1144     return RETURN_VALUE_STRUCT_CONVENTION;
1145 }
1146
1147 static enum return_value_convention
1148 hppa64_return_value (struct gdbarch *gdbarch,
1149                      struct type *type, struct regcache *regcache,
1150                      gdb_byte *readbuf, const gdb_byte *writebuf)
1151 {
1152   int len = TYPE_LENGTH (type);
1153   int regnum, offset;
1154
1155   if (len > 16)
1156     {
1157       /* All return values larget than 128 bits must be aggregate
1158          return values.  */
1159       gdb_assert (!hppa64_integral_or_pointer_p (type));
1160       gdb_assert (!hppa64_floating_p (type));
1161
1162       /* "Aggregate return values larger than 128 bits are returned in
1163          a buffer allocated by the caller.  The address of the buffer
1164          must be passed in GR 28."  */
1165       return RETURN_VALUE_STRUCT_CONVENTION;
1166     }
1167
1168   if (hppa64_integral_or_pointer_p (type))
1169     {
1170       /* "Integral return values are returned in GR 28.  Values
1171          smaller than 64 bits are padded on the left (with garbage)."  */
1172       regnum = HPPA_RET0_REGNUM;
1173       offset = 8 - len;
1174     }
1175   else if (hppa64_floating_p (type))
1176     {
1177       if (len > 8)
1178         {
1179           /* "Double-extended- and quad-precision floating-point
1180              values are returned in GRs 28 and 29.  The sign,
1181              exponent, and most-significant bits of the mantissa are
1182              returned in GR 28; the least-significant bits of the
1183              mantissa are passed in GR 29.  For double-extended
1184              precision values, GR 29 is padded on the right with 48
1185              bits of garbage."  */
1186           regnum = HPPA_RET0_REGNUM;
1187           offset = 0;
1188         }
1189       else
1190         {
1191           /* "Single-precision and double-precision floating-point
1192              return values are returned in FR 4R (single precision) or
1193              FR 4 (double-precision)."  */
1194           regnum = HPPA64_FP4_REGNUM;
1195           offset = 8 - len;
1196         }
1197     }
1198   else
1199     {
1200       /* "Aggregate return values up to 64 bits in size are returned
1201          in GR 28.  Aggregates smaller than 64 bits are left aligned
1202          in the register; the pad bits on the right are undefined."
1203
1204          "Aggregate return values between 65 and 128 bits are returned
1205          in GRs 28 and 29.  The first 64 bits are placed in GR 28, and
1206          the remaining bits are placed, left aligned, in GR 29.  The
1207          pad bits on the right of GR 29 (if any) are undefined."  */
1208       regnum = HPPA_RET0_REGNUM;
1209       offset = 0;
1210     }
1211
1212   if (readbuf)
1213     {
1214       while (len > 0)
1215         {
1216           regcache_cooked_read_part (regcache, regnum, offset,
1217                                      min (len, 8), readbuf);
1218           readbuf += min (len, 8);
1219           len -= min (len, 8);
1220           regnum++;
1221         }
1222     }
1223
1224   if (writebuf)
1225     {
1226       while (len > 0)
1227         {
1228           regcache_cooked_write_part (regcache, regnum, offset,
1229                                       min (len, 8), writebuf);
1230           writebuf += min (len, 8);
1231           len -= min (len, 8);
1232           regnum++;
1233         }
1234     }
1235
1236   return RETURN_VALUE_REGISTER_CONVENTION;
1237 }
1238 \f
1239
1240 static CORE_ADDR
1241 hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1242                                    struct target_ops *targ)
1243 {
1244   if (addr & 2)
1245     {
1246       CORE_ADDR plabel = addr & ~3;
1247       return read_memory_typed_address (plabel, builtin_type_void_func_ptr);
1248     }
1249
1250   return addr;
1251 }
1252
1253 static CORE_ADDR
1254 hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1255 {
1256   /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1257      and not _bit_)!  */
1258   return align_up (addr, 64);
1259 }
1260
1261 /* Force all frames to 16-byte alignment.  Better safe than sorry.  */
1262
1263 static CORE_ADDR
1264 hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1265 {
1266   /* Just always 16-byte align.  */
1267   return align_up (addr, 16);
1268 }
1269
1270 CORE_ADDR
1271 hppa_read_pc (struct regcache *regcache)
1272 {
1273   ULONGEST ipsw;
1274   ULONGEST pc;
1275
1276   regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
1277   regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
1278
1279   /* If the current instruction is nullified, then we are effectively
1280      still executing the previous instruction.  Pretend we are still
1281      there.  This is needed when single stepping; if the nullified
1282      instruction is on a different line, we don't want GDB to think
1283      we've stepped onto that line.  */
1284   if (ipsw & 0x00200000)
1285     pc -= 4;
1286
1287   return pc & ~0x3;
1288 }
1289
1290 void
1291 hppa_write_pc (struct regcache *regcache, CORE_ADDR pc)
1292 {
1293   regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pc);
1294   regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pc + 4);
1295 }
1296
1297 /* return the alignment of a type in bytes. Structures have the maximum
1298    alignment required by their fields. */
1299
1300 static int
1301 hppa_alignof (struct type *type)
1302 {
1303   int max_align, align, i;
1304   CHECK_TYPEDEF (type);
1305   switch (TYPE_CODE (type))
1306     {
1307     case TYPE_CODE_PTR:
1308     case TYPE_CODE_INT:
1309     case TYPE_CODE_FLT:
1310       return TYPE_LENGTH (type);
1311     case TYPE_CODE_ARRAY:
1312       return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
1313     case TYPE_CODE_STRUCT:
1314     case TYPE_CODE_UNION:
1315       max_align = 1;
1316       for (i = 0; i < TYPE_NFIELDS (type); i++)
1317         {
1318           /* Bit fields have no real alignment. */
1319           /* if (!TYPE_FIELD_BITPOS (type, i)) */
1320           if (!TYPE_FIELD_BITSIZE (type, i))    /* elz: this should be bitsize */
1321             {
1322               align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
1323               max_align = max (max_align, align);
1324             }
1325         }
1326       return max_align;
1327     default:
1328       return 4;
1329     }
1330 }
1331
1332 /* For the given instruction (INST), return any adjustment it makes
1333    to the stack pointer or zero for no adjustment.
1334
1335    This only handles instructions commonly found in prologues.  */
1336
1337 static int
1338 prologue_inst_adjust_sp (unsigned long inst)
1339 {
1340   /* This must persist across calls.  */
1341   static int save_high21;
1342
1343   /* The most common way to perform a stack adjustment ldo X(sp),sp */
1344   if ((inst & 0xffffc000) == 0x37de0000)
1345     return hppa_extract_14 (inst);
1346
1347   /* stwm X,D(sp) */
1348   if ((inst & 0xffe00000) == 0x6fc00000)
1349     return hppa_extract_14 (inst);
1350
1351   /* std,ma X,D(sp) */
1352   if ((inst & 0xffe00008) == 0x73c00008)
1353     return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
1354
1355   /* addil high21,%r30; ldo low11,(%r1),%r30)
1356      save high bits in save_high21 for later use.  */
1357   if ((inst & 0xffe00000) == 0x2bc00000)
1358     {
1359       save_high21 = hppa_extract_21 (inst);
1360       return 0;
1361     }
1362
1363   if ((inst & 0xffff0000) == 0x343e0000)
1364     return save_high21 + hppa_extract_14 (inst);
1365
1366   /* fstws as used by the HP compilers.  */
1367   if ((inst & 0xffffffe0) == 0x2fd01220)
1368     return hppa_extract_5_load (inst);
1369
1370   /* No adjustment.  */
1371   return 0;
1372 }
1373
1374 /* Return nonzero if INST is a branch of some kind, else return zero.  */
1375
1376 static int
1377 is_branch (unsigned long inst)
1378 {
1379   switch (inst >> 26)
1380     {
1381     case 0x20:
1382     case 0x21:
1383     case 0x22:
1384     case 0x23:
1385     case 0x27:
1386     case 0x28:
1387     case 0x29:
1388     case 0x2a:
1389     case 0x2b:
1390     case 0x2f:
1391     case 0x30:
1392     case 0x31:
1393     case 0x32:
1394     case 0x33:
1395     case 0x38:
1396     case 0x39:
1397     case 0x3a:
1398     case 0x3b:
1399       return 1;
1400
1401     default:
1402       return 0;
1403     }
1404 }
1405
1406 /* Return the register number for a GR which is saved by INST or
1407    zero it INST does not save a GR.  */
1408
1409 static int
1410 inst_saves_gr (unsigned long inst)
1411 {
1412   /* Does it look like a stw?  */
1413   if ((inst >> 26) == 0x1a || (inst >> 26) == 0x1b
1414       || (inst >> 26) == 0x1f
1415       || ((inst >> 26) == 0x1f
1416           && ((inst >> 6) == 0xa)))
1417     return hppa_extract_5R_store (inst);
1418
1419   /* Does it look like a std?  */
1420   if ((inst >> 26) == 0x1c
1421       || ((inst >> 26) == 0x03
1422           && ((inst >> 6) & 0xf) == 0xb))
1423     return hppa_extract_5R_store (inst);
1424
1425   /* Does it look like a stwm?  GCC & HPC may use this in prologues. */
1426   if ((inst >> 26) == 0x1b)
1427     return hppa_extract_5R_store (inst);
1428
1429   /* Does it look like sth or stb?  HPC versions 9.0 and later use these
1430      too.  */
1431   if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18
1432       || ((inst >> 26) == 0x3
1433           && (((inst >> 6) & 0xf) == 0x8
1434               || (inst >> 6) & 0xf) == 0x9))
1435     return hppa_extract_5R_store (inst);
1436
1437   return 0;
1438 }
1439
1440 /* Return the register number for a FR which is saved by INST or
1441    zero it INST does not save a FR.
1442
1443    Note we only care about full 64bit register stores (that's the only
1444    kind of stores the prologue will use).
1445
1446    FIXME: What about argument stores with the HP compiler in ANSI mode? */
1447
1448 static int
1449 inst_saves_fr (unsigned long inst)
1450 {
1451   /* is this an FSTD ? */
1452   if ((inst & 0xfc00dfc0) == 0x2c001200)
1453     return hppa_extract_5r_store (inst);
1454   if ((inst & 0xfc000002) == 0x70000002)
1455     return hppa_extract_5R_store (inst);
1456   /* is this an FSTW ? */
1457   if ((inst & 0xfc00df80) == 0x24001200)
1458     return hppa_extract_5r_store (inst);
1459   if ((inst & 0xfc000002) == 0x7c000000)
1460     return hppa_extract_5R_store (inst);
1461   return 0;
1462 }
1463
1464 /* Advance PC across any function entry prologue instructions
1465    to reach some "real" code.
1466
1467    Use information in the unwind table to determine what exactly should
1468    be in the prologue.  */
1469
1470
1471 static CORE_ADDR
1472 skip_prologue_hard_way (CORE_ADDR pc, int stop_before_branch)
1473 {
1474   char buf[4];
1475   CORE_ADDR orig_pc = pc;
1476   unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1477   unsigned long args_stored, status, i, restart_gr, restart_fr;
1478   struct unwind_table_entry *u;
1479   int final_iteration;
1480
1481   restart_gr = 0;
1482   restart_fr = 0;
1483
1484 restart:
1485   u = find_unwind_entry (pc);
1486   if (!u)
1487     return pc;
1488
1489   /* If we are not at the beginning of a function, then return now. */
1490   if ((pc & ~0x3) != u->region_start)
1491     return pc;
1492
1493   /* This is how much of a frame adjustment we need to account for.  */
1494   stack_remaining = u->Total_frame_size << 3;
1495
1496   /* Magic register saves we want to know about.  */
1497   save_rp = u->Save_RP;
1498   save_sp = u->Save_SP;
1499
1500   /* An indication that args may be stored into the stack.  Unfortunately
1501      the HPUX compilers tend to set this in cases where no args were
1502      stored too!.  */
1503   args_stored = 1;
1504
1505   /* Turn the Entry_GR field into a bitmask.  */
1506   save_gr = 0;
1507   for (i = 3; i < u->Entry_GR + 3; i++)
1508     {
1509       /* Frame pointer gets saved into a special location.  */
1510       if (u->Save_SP && i == HPPA_FP_REGNUM)
1511         continue;
1512
1513       save_gr |= (1 << i);
1514     }
1515   save_gr &= ~restart_gr;
1516
1517   /* Turn the Entry_FR field into a bitmask too.  */
1518   save_fr = 0;
1519   for (i = 12; i < u->Entry_FR + 12; i++)
1520     save_fr |= (1 << i);
1521   save_fr &= ~restart_fr;
1522
1523   final_iteration = 0;
1524
1525   /* Loop until we find everything of interest or hit a branch.
1526
1527      For unoptimized GCC code and for any HP CC code this will never ever
1528      examine any user instructions.
1529
1530      For optimzied GCC code we're faced with problems.  GCC will schedule
1531      its prologue and make prologue instructions available for delay slot
1532      filling.  The end result is user code gets mixed in with the prologue
1533      and a prologue instruction may be in the delay slot of the first branch
1534      or call.
1535
1536      Some unexpected things are expected with debugging optimized code, so
1537      we allow this routine to walk past user instructions in optimized
1538      GCC code.  */
1539   while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1540          || args_stored)
1541     {
1542       unsigned int reg_num;
1543       unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1544       unsigned long old_save_rp, old_save_sp, next_inst;
1545
1546       /* Save copies of all the triggers so we can compare them later
1547          (only for HPC).  */
1548       old_save_gr = save_gr;
1549       old_save_fr = save_fr;
1550       old_save_rp = save_rp;
1551       old_save_sp = save_sp;
1552       old_stack_remaining = stack_remaining;
1553
1554       status = read_memory_nobpt (pc, buf, 4);
1555       inst = extract_unsigned_integer (buf, 4);
1556
1557       /* Yow! */
1558       if (status != 0)
1559         return pc;
1560
1561       /* Note the interesting effects of this instruction.  */
1562       stack_remaining -= prologue_inst_adjust_sp (inst);
1563
1564       /* There are limited ways to store the return pointer into the
1565          stack.  */
1566       if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1567         save_rp = 0;
1568
1569       /* These are the only ways we save SP into the stack.  At this time
1570          the HP compilers never bother to save SP into the stack.  */
1571       if ((inst & 0xffffc000) == 0x6fc10000
1572           || (inst & 0xffffc00c) == 0x73c10008)
1573         save_sp = 0;
1574
1575       /* Are we loading some register with an offset from the argument
1576          pointer?  */
1577       if ((inst & 0xffe00000) == 0x37a00000
1578           || (inst & 0xffffffe0) == 0x081d0240)
1579         {
1580           pc += 4;
1581           continue;
1582         }
1583
1584       /* Account for general and floating-point register saves.  */
1585       reg_num = inst_saves_gr (inst);
1586       save_gr &= ~(1 << reg_num);
1587
1588       /* Ugh.  Also account for argument stores into the stack.
1589          Unfortunately args_stored only tells us that some arguments
1590          where stored into the stack.  Not how many or what kind!
1591
1592          This is a kludge as on the HP compiler sets this bit and it
1593          never does prologue scheduling.  So once we see one, skip past
1594          all of them.   We have similar code for the fp arg stores below.
1595
1596          FIXME.  Can still die if we have a mix of GR and FR argument
1597          stores!  */
1598       if (reg_num >= (gdbarch_ptr_bit (current_gdbarch) == 64 ? 19 : 23)
1599           && reg_num <= 26)
1600         {
1601           while (reg_num >= (gdbarch_ptr_bit (current_gdbarch) == 64 ? 19 : 23)
1602                  && reg_num <= 26)
1603             {
1604               pc += 4;
1605               status = read_memory_nobpt (pc, buf, 4);
1606               inst = extract_unsigned_integer (buf, 4);
1607               if (status != 0)
1608                 return pc;
1609               reg_num = inst_saves_gr (inst);
1610             }
1611           args_stored = 0;
1612           continue;
1613         }
1614
1615       reg_num = inst_saves_fr (inst);
1616       save_fr &= ~(1 << reg_num);
1617
1618       status = read_memory_nobpt (pc + 4, buf, 4);
1619       next_inst = extract_unsigned_integer (buf, 4);
1620
1621       /* Yow! */
1622       if (status != 0)
1623         return pc;
1624
1625       /* We've got to be read to handle the ldo before the fp register
1626          save.  */
1627       if ((inst & 0xfc000000) == 0x34000000
1628           && inst_saves_fr (next_inst) >= 4
1629           && inst_saves_fr (next_inst)
1630                <= (gdbarch_ptr_bit (current_gdbarch) == 64 ? 11 : 7))
1631         {
1632           /* So we drop into the code below in a reasonable state.  */
1633           reg_num = inst_saves_fr (next_inst);
1634           pc -= 4;
1635         }
1636
1637       /* Ugh.  Also account for argument stores into the stack.
1638          This is a kludge as on the HP compiler sets this bit and it
1639          never does prologue scheduling.  So once we see one, skip past
1640          all of them.  */
1641       if (reg_num >= 4
1642           && reg_num <= (gdbarch_ptr_bit (current_gdbarch) == 64 ? 11 : 7))
1643         {
1644           while (reg_num >= 4
1645                  && reg_num
1646                       <= (gdbarch_ptr_bit (current_gdbarch) == 64 ? 11 : 7))
1647             {
1648               pc += 8;
1649               status = read_memory_nobpt (pc, buf, 4);
1650               inst = extract_unsigned_integer (buf, 4);
1651               if (status != 0)
1652                 return pc;
1653               if ((inst & 0xfc000000) != 0x34000000)
1654                 break;
1655               status = read_memory_nobpt (pc + 4, buf, 4);
1656               next_inst = extract_unsigned_integer (buf, 4);
1657               if (status != 0)
1658                 return pc;
1659               reg_num = inst_saves_fr (next_inst);
1660             }
1661           args_stored = 0;
1662           continue;
1663         }
1664
1665       /* Quit if we hit any kind of branch.  This can happen if a prologue
1666          instruction is in the delay slot of the first call/branch.  */
1667       if (is_branch (inst) && stop_before_branch)
1668         break;
1669
1670       /* What a crock.  The HP compilers set args_stored even if no
1671          arguments were stored into the stack (boo hiss).  This could
1672          cause this code to then skip a bunch of user insns (up to the
1673          first branch).
1674
1675          To combat this we try to identify when args_stored was bogusly
1676          set and clear it.   We only do this when args_stored is nonzero,
1677          all other resources are accounted for, and nothing changed on
1678          this pass.  */
1679       if (args_stored
1680        && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1681           && old_save_gr == save_gr && old_save_fr == save_fr
1682           && old_save_rp == save_rp && old_save_sp == save_sp
1683           && old_stack_remaining == stack_remaining)
1684         break;
1685
1686       /* Bump the PC.  */
1687       pc += 4;
1688
1689       /* !stop_before_branch, so also look at the insn in the delay slot
1690          of the branch.  */
1691       if (final_iteration)
1692         break;
1693       if (is_branch (inst))
1694         final_iteration = 1;
1695     }
1696
1697   /* We've got a tenative location for the end of the prologue.  However
1698      because of limitations in the unwind descriptor mechanism we may
1699      have went too far into user code looking for the save of a register
1700      that does not exist.  So, if there registers we expected to be saved
1701      but never were, mask them out and restart.
1702
1703      This should only happen in optimized code, and should be very rare.  */
1704   if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1705     {
1706       pc = orig_pc;
1707       restart_gr = save_gr;
1708       restart_fr = save_fr;
1709       goto restart;
1710     }
1711
1712   return pc;
1713 }
1714
1715
1716 /* Return the address of the PC after the last prologue instruction if
1717    we can determine it from the debug symbols.  Else return zero.  */
1718
1719 static CORE_ADDR
1720 after_prologue (CORE_ADDR pc)
1721 {
1722   struct symtab_and_line sal;
1723   CORE_ADDR func_addr, func_end;
1724   struct symbol *f;
1725
1726   /* If we can not find the symbol in the partial symbol table, then
1727      there is no hope we can determine the function's start address
1728      with this code.  */
1729   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1730     return 0;
1731
1732   /* Get the line associated with FUNC_ADDR.  */
1733   sal = find_pc_line (func_addr, 0);
1734
1735   /* There are only two cases to consider.  First, the end of the source line
1736      is within the function bounds.  In that case we return the end of the
1737      source line.  Second is the end of the source line extends beyond the
1738      bounds of the current function.  We need to use the slow code to
1739      examine instructions in that case.
1740
1741      Anything else is simply a bug elsewhere.  Fixing it here is absolutely
1742      the wrong thing to do.  In fact, it should be entirely possible for this
1743      function to always return zero since the slow instruction scanning code
1744      is supposed to *always* work.  If it does not, then it is a bug.  */
1745   if (sal.end < func_end)
1746     return sal.end;
1747   else
1748     return 0;
1749 }
1750
1751 /* To skip prologues, I use this predicate.  Returns either PC itself
1752    if the code at PC does not look like a function prologue; otherwise
1753    returns an address that (if we're lucky) follows the prologue.
1754
1755    hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1756    It doesn't necessarily skips all the insns in the prologue. In fact
1757    we might not want to skip all the insns because a prologue insn may
1758    appear in the delay slot of the first branch, and we don't want to
1759    skip over the branch in that case.  */
1760
1761 static CORE_ADDR
1762 hppa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1763 {
1764   unsigned long inst;
1765   int offset;
1766   CORE_ADDR post_prologue_pc;
1767   char buf[4];
1768
1769   /* See if we can determine the end of the prologue via the symbol table.
1770      If so, then return either PC, or the PC after the prologue, whichever
1771      is greater.  */
1772
1773   post_prologue_pc = after_prologue (pc);
1774
1775   /* If after_prologue returned a useful address, then use it.  Else
1776      fall back on the instruction skipping code.
1777
1778      Some folks have claimed this causes problems because the breakpoint
1779      may be the first instruction of the prologue.  If that happens, then
1780      the instruction skipping code has a bug that needs to be fixed.  */
1781   if (post_prologue_pc != 0)
1782     return max (pc, post_prologue_pc);
1783   else
1784     return (skip_prologue_hard_way (pc, 1));
1785 }
1786
1787 /* Return an unwind entry that falls within the frame's code block.  */
1788 static struct unwind_table_entry *
1789 hppa_find_unwind_entry_in_block (struct frame_info *f)
1790 {
1791   CORE_ADDR pc = frame_unwind_address_in_block (f, NORMAL_FRAME);
1792
1793   /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1794      result of frame_unwind_address_in_block implies a problem.
1795      The bits should have been removed earlier, before the return
1796      value of frame_pc_unwind.  That might be happening already;
1797      if it isn't, it should be fixed.  Then this call can be
1798      removed.  */
1799   pc = gdbarch_addr_bits_remove (get_frame_arch (f), pc);
1800   return find_unwind_entry (pc);
1801 }
1802
1803 struct hppa_frame_cache
1804 {
1805   CORE_ADDR base;
1806   struct trad_frame_saved_reg *saved_regs;
1807 };
1808
1809 static struct hppa_frame_cache *
1810 hppa_frame_cache (struct frame_info *next_frame, void **this_cache)
1811 {
1812   struct gdbarch *gdbarch = get_frame_arch (next_frame);
1813   struct hppa_frame_cache *cache;
1814   long saved_gr_mask;
1815   long saved_fr_mask;
1816   CORE_ADDR this_sp;
1817   long frame_size;
1818   struct unwind_table_entry *u;
1819   CORE_ADDR prologue_end;
1820   int fp_in_r1 = 0;
1821   int i;
1822
1823   if (hppa_debug)
1824     fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
1825       frame_relative_level(next_frame));
1826
1827   if ((*this_cache) != NULL)
1828     {
1829       if (hppa_debug)
1830         fprintf_unfiltered (gdb_stdlog, "base=0x%s (cached) }",
1831           paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
1832       return (*this_cache);
1833     }
1834   cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1835   (*this_cache) = cache;
1836   cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1837
1838   /* Yow! */
1839   u = hppa_find_unwind_entry_in_block (next_frame);
1840   if (!u)
1841     {
1842       if (hppa_debug)
1843         fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
1844       return (*this_cache);
1845     }
1846
1847   /* Turn the Entry_GR field into a bitmask.  */
1848   saved_gr_mask = 0;
1849   for (i = 3; i < u->Entry_GR + 3; i++)
1850     {
1851       /* Frame pointer gets saved into a special location.  */
1852       if (u->Save_SP && i == HPPA_FP_REGNUM)
1853         continue;
1854
1855       saved_gr_mask |= (1 << i);
1856     }
1857
1858   /* Turn the Entry_FR field into a bitmask too.  */
1859   saved_fr_mask = 0;
1860   for (i = 12; i < u->Entry_FR + 12; i++)
1861     saved_fr_mask |= (1 << i);
1862
1863   /* Loop until we find everything of interest or hit a branch.
1864
1865      For unoptimized GCC code and for any HP CC code this will never ever
1866      examine any user instructions.
1867
1868      For optimized GCC code we're faced with problems.  GCC will schedule
1869      its prologue and make prologue instructions available for delay slot
1870      filling.  The end result is user code gets mixed in with the prologue
1871      and a prologue instruction may be in the delay slot of the first branch
1872      or call.
1873
1874      Some unexpected things are expected with debugging optimized code, so
1875      we allow this routine to walk past user instructions in optimized
1876      GCC code.  */
1877   {
1878     int final_iteration = 0;
1879     CORE_ADDR pc, start_pc, end_pc;
1880     int looking_for_sp = u->Save_SP;
1881     int looking_for_rp = u->Save_RP;
1882     int fp_loc = -1;
1883
1884     /* We have to use skip_prologue_hard_way instead of just
1885        skip_prologue_using_sal, in case we stepped into a function without
1886        symbol information.  hppa_skip_prologue also bounds the returned
1887        pc by the passed in pc, so it will not return a pc in the next
1888        function.
1889
1890        We used to call hppa_skip_prologue to find the end of the prologue,
1891        but if some non-prologue instructions get scheduled into the prologue,
1892        and the program is compiled with debug information, the "easy" way
1893        in hppa_skip_prologue will return a prologue end that is too early
1894        for us to notice any potential frame adjustments.  */
1895
1896     /* We used to use frame_func_unwind () to locate the beginning of the
1897        function to pass to skip_prologue ().  However, when objects are
1898        compiled without debug symbols, frame_func_unwind can return the wrong
1899        function (or 0).  We can do better than that by using unwind records.
1900        This only works if the Region_description of the unwind record
1901        indicates that it includes the entry point of the function.
1902        HP compilers sometimes generate unwind records for regions that
1903        do not include the entry or exit point of a function.  GNU tools
1904        do not do this.  */
1905
1906     if ((u->Region_description & 0x2) == 0)
1907       start_pc = u->region_start;
1908     else
1909       start_pc = frame_func_unwind (next_frame, NORMAL_FRAME);
1910
1911     prologue_end = skip_prologue_hard_way (start_pc, 0);
1912     end_pc = frame_pc_unwind (next_frame);
1913
1914     if (prologue_end != 0 && end_pc > prologue_end)
1915       end_pc = prologue_end;
1916
1917     frame_size = 0;
1918
1919     for (pc = start_pc;
1920          ((saved_gr_mask || saved_fr_mask
1921            || looking_for_sp || looking_for_rp
1922            || frame_size < (u->Total_frame_size << 3))
1923           && pc < end_pc);
1924          pc += 4)
1925       {
1926         int reg;
1927         char buf4[4];
1928         long inst;
1929
1930         if (!safe_frame_unwind_memory (next_frame, pc, buf4,
1931                                        sizeof buf4))
1932           {
1933             error (_("Cannot read instruction at 0x%s."), paddr_nz (pc));
1934             return (*this_cache);
1935           }
1936
1937         inst = extract_unsigned_integer (buf4, sizeof buf4);
1938
1939         /* Note the interesting effects of this instruction.  */
1940         frame_size += prologue_inst_adjust_sp (inst);
1941
1942         /* There are limited ways to store the return pointer into the
1943            stack.  */
1944         if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1945           {
1946             looking_for_rp = 0;
1947             cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
1948           }
1949         else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1950           {
1951             looking_for_rp = 0;
1952             cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
1953           }
1954         else if (inst == 0x0fc212c1
1955                  || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1956           {
1957             looking_for_rp = 0;
1958             cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
1959           }
1960
1961         /* Check to see if we saved SP into the stack.  This also
1962            happens to indicate the location of the saved frame
1963            pointer.  */
1964         if ((inst & 0xffffc000) == 0x6fc10000  /* stw,ma r1,N(sr0,sp) */
1965             || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1966           {
1967             looking_for_sp = 0;
1968             cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
1969           }
1970         else if (inst == 0x08030241) /* copy %r3, %r1 */
1971           {
1972             fp_in_r1 = 1;
1973           }
1974
1975         /* Account for general and floating-point register saves.  */
1976         reg = inst_saves_gr (inst);
1977         if (reg >= 3 && reg <= 18
1978             && (!u->Save_SP || reg != HPPA_FP_REGNUM))
1979           {
1980             saved_gr_mask &= ~(1 << reg);
1981             if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
1982               /* stwm with a positive displacement is a _post_
1983                  _modify_.  */
1984               cache->saved_regs[reg].addr = 0;
1985             else if ((inst & 0xfc00000c) == 0x70000008)
1986               /* A std has explicit post_modify forms.  */
1987               cache->saved_regs[reg].addr = 0;
1988             else
1989               {
1990                 CORE_ADDR offset;
1991
1992                 if ((inst >> 26) == 0x1c)
1993                   offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
1994                 else if ((inst >> 26) == 0x03)
1995                   offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
1996                 else
1997                   offset = hppa_extract_14 (inst);
1998
1999                 /* Handle code with and without frame pointers.  */
2000                 if (u->Save_SP)
2001                   cache->saved_regs[reg].addr = offset;
2002                 else
2003                   cache->saved_regs[reg].addr = (u->Total_frame_size << 3) + offset;
2004               }
2005           }
2006
2007         /* GCC handles callee saved FP regs a little differently.
2008
2009            It emits an instruction to put the value of the start of
2010            the FP store area into %r1.  It then uses fstds,ma with a
2011            basereg of %r1 for the stores.
2012
2013            HP CC emits them at the current stack pointer modifying the
2014            stack pointer as it stores each register.  */
2015
2016         /* ldo X(%r3),%r1 or ldo X(%r30),%r1.  */
2017         if ((inst & 0xffffc000) == 0x34610000
2018             || (inst & 0xffffc000) == 0x37c10000)
2019           fp_loc = hppa_extract_14 (inst);
2020
2021         reg = inst_saves_fr (inst);
2022         if (reg >= 12 && reg <= 21)
2023           {
2024             /* Note +4 braindamage below is necessary because the FP
2025                status registers are internally 8 registers rather than
2026                the expected 4 registers.  */
2027             saved_fr_mask &= ~(1 << reg);
2028             if (fp_loc == -1)
2029               {
2030                 /* 1st HP CC FP register store.  After this
2031                    instruction we've set enough state that the GCC and
2032                    HPCC code are both handled in the same manner.  */
2033                 cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
2034                 fp_loc = 8;
2035               }
2036             else
2037               {
2038                 cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
2039                 fp_loc += 8;
2040               }
2041           }
2042
2043         /* Quit if we hit any kind of branch the previous iteration. */
2044         if (final_iteration)
2045           break;
2046         /* We want to look precisely one instruction beyond the branch
2047            if we have not found everything yet.  */
2048         if (is_branch (inst))
2049           final_iteration = 1;
2050       }
2051   }
2052
2053   {
2054     /* The frame base always represents the value of %sp at entry to
2055        the current function (and is thus equivalent to the "saved"
2056        stack pointer.  */
2057     CORE_ADDR this_sp = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
2058     CORE_ADDR fp;
2059
2060     if (hppa_debug)
2061       fprintf_unfiltered (gdb_stdlog, " (this_sp=0x%s, pc=0x%s, "
2062                           "prologue_end=0x%s) ",
2063                           paddr_nz (this_sp),
2064                           paddr_nz (frame_pc_unwind (next_frame)),
2065                           paddr_nz (prologue_end));
2066
2067      /* Check to see if a frame pointer is available, and use it for
2068         frame unwinding if it is.
2069
2070         There are some situations where we need to rely on the frame
2071         pointer to do stack unwinding.  For example, if a function calls
2072         alloca (), the stack pointer can get adjusted inside the body of
2073         the function.  In this case, the ABI requires that the compiler
2074         maintain a frame pointer for the function.
2075
2076         The unwind record has a flag (alloca_frame) that indicates that
2077         a function has a variable frame; unfortunately, gcc/binutils
2078         does not set this flag.  Instead, whenever a frame pointer is used
2079         and saved on the stack, the Save_SP flag is set.  We use this to
2080         decide whether to use the frame pointer for unwinding.
2081
2082         TODO: For the HP compiler, maybe we should use the alloca_frame flag
2083         instead of Save_SP.  */
2084
2085      fp = frame_unwind_register_unsigned (next_frame, HPPA_FP_REGNUM);
2086
2087      if (u->alloca_frame)
2088        fp -= u->Total_frame_size << 3;
2089
2090      if (frame_pc_unwind (next_frame) >= prologue_end
2091          && (u->Save_SP || u->alloca_frame) && fp != 0)
2092       {
2093         cache->base = fp;
2094
2095         if (hppa_debug)
2096           fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [frame pointer]",
2097             paddr_nz (cache->base));
2098       }
2099      else if (u->Save_SP
2100               && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
2101       {
2102             /* Both we're expecting the SP to be saved and the SP has been
2103                saved.  The entry SP value is saved at this frame's SP
2104                address.  */
2105             cache->base = read_memory_integer
2106                             (this_sp, gdbarch_ptr_bit (gdbarch) / 8);
2107
2108             if (hppa_debug)
2109               fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [saved]",
2110                                   paddr_nz (cache->base));
2111       }
2112     else
2113       {
2114         /* The prologue has been slowly allocating stack space.  Adjust
2115            the SP back.  */
2116         cache->base = this_sp - frame_size;
2117         if (hppa_debug)
2118           fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [unwind adjust]",
2119                               paddr_nz (cache->base));
2120
2121       }
2122     trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2123   }
2124
2125   /* The PC is found in the "return register", "Millicode" uses "r31"
2126      as the return register while normal code uses "rp".  */
2127   if (u->Millicode)
2128     {
2129       if (trad_frame_addr_p (cache->saved_regs, 31))
2130         {
2131           cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
2132           if (hppa_debug)
2133             fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
2134         }
2135       else
2136         {
2137           ULONGEST r31 = frame_unwind_register_unsigned (next_frame, 31);
2138           trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
2139           if (hppa_debug)
2140             fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
2141         }
2142     }
2143   else
2144     {
2145       if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2146         {
2147           cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2148             cache->saved_regs[HPPA_RP_REGNUM];
2149           if (hppa_debug)
2150             fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
2151         }
2152       else
2153         {
2154           ULONGEST rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
2155           trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2156           if (hppa_debug)
2157             fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
2158         }
2159     }
2160
2161   /* If Save_SP is set, then we expect the frame pointer to be saved in the
2162      frame.  However, there is a one-insn window where we haven't saved it
2163      yet, but we've already clobbered it.  Detect this case and fix it up.
2164
2165      The prologue sequence for frame-pointer functions is:
2166         0: stw %rp, -20(%sp)
2167         4: copy %r3, %r1
2168         8: copy %sp, %r3
2169         c: stw,ma %r1, XX(%sp)
2170
2171      So if we are at offset c, the r3 value that we want is not yet saved
2172      on the stack, but it's been overwritten.  The prologue analyzer will
2173      set fp_in_r1 when it sees the copy insn so we know to get the value
2174      from r1 instead.  */
2175   if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
2176       && fp_in_r1)
2177     {
2178       ULONGEST r1 = frame_unwind_register_unsigned (next_frame, 1);
2179       trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
2180     }
2181
2182   {
2183     /* Convert all the offsets into addresses.  */
2184     int reg;
2185     for (reg = 0; reg < gdbarch_num_regs (gdbarch); reg++)
2186       {
2187         if (trad_frame_addr_p (cache->saved_regs, reg))
2188           cache->saved_regs[reg].addr += cache->base;
2189       }
2190   }
2191
2192   {
2193     struct gdbarch_tdep *tdep;
2194
2195     tdep = gdbarch_tdep (gdbarch);
2196
2197     if (tdep->unwind_adjust_stub)
2198       {
2199         tdep->unwind_adjust_stub (next_frame, cache->base, cache->saved_regs);
2200       }
2201   }
2202
2203   if (hppa_debug)
2204     fprintf_unfiltered (gdb_stdlog, "base=0x%s }",
2205       paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
2206   return (*this_cache);
2207 }
2208
2209 static void
2210 hppa_frame_this_id (struct frame_info *next_frame, void **this_cache,
2211                            struct frame_id *this_id)
2212 {
2213   struct hppa_frame_cache *info;
2214   CORE_ADDR pc = frame_pc_unwind (next_frame);
2215   struct unwind_table_entry *u;
2216
2217   info = hppa_frame_cache (next_frame, this_cache);
2218   u = hppa_find_unwind_entry_in_block (next_frame);
2219
2220   (*this_id) = frame_id_build (info->base, u->region_start);
2221 }
2222
2223 static void
2224 hppa_frame_prev_register (struct frame_info *next_frame,
2225                           void **this_cache,
2226                           int regnum, int *optimizedp,
2227                           enum lval_type *lvalp, CORE_ADDR *addrp,
2228                           int *realnump, gdb_byte *valuep)
2229 {
2230   struct hppa_frame_cache *info = hppa_frame_cache (next_frame, this_cache);
2231   hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
2232                                    optimizedp, lvalp, addrp, realnump, valuep);
2233 }
2234
2235 static const struct frame_unwind hppa_frame_unwind =
2236 {
2237   NORMAL_FRAME,
2238   hppa_frame_this_id,
2239   hppa_frame_prev_register
2240 };
2241
2242 static const struct frame_unwind *
2243 hppa_frame_unwind_sniffer (struct frame_info *next_frame)
2244 {
2245   if (hppa_find_unwind_entry_in_block (next_frame))
2246     return &hppa_frame_unwind;
2247
2248   return NULL;
2249 }
2250
2251 /* This is a generic fallback frame unwinder that kicks in if we fail all
2252    the other ones.  Normally we would expect the stub and regular unwinder
2253    to work, but in some cases we might hit a function that just doesn't
2254    have any unwind information available.  In this case we try to do
2255    unwinding solely based on code reading.  This is obviously going to be
2256    slow, so only use this as a last resort.  Currently this will only
2257    identify the stack and pc for the frame.  */
2258
2259 static struct hppa_frame_cache *
2260 hppa_fallback_frame_cache (struct frame_info *next_frame, void **this_cache)
2261 {
2262   struct hppa_frame_cache *cache;
2263   unsigned int frame_size = 0;
2264   int found_rp = 0;
2265   CORE_ADDR start_pc;
2266
2267   if (hppa_debug)
2268     fprintf_unfiltered (gdb_stdlog,
2269                         "{ hppa_fallback_frame_cache (frame=%d) -> ",
2270                         frame_relative_level (next_frame));
2271
2272   cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
2273   (*this_cache) = cache;
2274   cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
2275
2276   start_pc = frame_func_unwind (next_frame, NORMAL_FRAME);
2277   if (start_pc)
2278     {
2279       CORE_ADDR cur_pc = frame_pc_unwind (next_frame);
2280       CORE_ADDR pc;
2281
2282       for (pc = start_pc; pc < cur_pc; pc += 4)
2283         {
2284           unsigned int insn;
2285
2286           insn = read_memory_unsigned_integer (pc, 4);
2287           frame_size += prologue_inst_adjust_sp (insn);
2288
2289           /* There are limited ways to store the return pointer into the
2290              stack.  */
2291           if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2292             {
2293               cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2294               found_rp = 1;
2295             }
2296           else if (insn == 0x0fc212c1
2297                    || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2298             {
2299               cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2300               found_rp = 1;
2301             }
2302         }
2303     }
2304
2305   if (hppa_debug)
2306     fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
2307                         frame_size, found_rp);
2308
2309   cache->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
2310   cache->base -= frame_size;
2311   trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2312
2313   if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2314     {
2315       cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
2316       cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2317         cache->saved_regs[HPPA_RP_REGNUM];
2318     }
2319   else
2320     {
2321       ULONGEST rp;
2322       rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
2323       trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2324     }
2325
2326   return cache;
2327 }
2328
2329 static void
2330 hppa_fallback_frame_this_id (struct frame_info *next_frame, void **this_cache,
2331                              struct frame_id *this_id)
2332 {
2333   struct hppa_frame_cache *info =
2334     hppa_fallback_frame_cache (next_frame, this_cache);
2335   (*this_id) = frame_id_build (info->base,
2336                                frame_func_unwind (next_frame, NORMAL_FRAME));
2337 }
2338
2339 static void
2340 hppa_fallback_frame_prev_register (struct frame_info *next_frame,
2341                           void **this_cache,
2342                           int regnum, int *optimizedp,
2343                           enum lval_type *lvalp, CORE_ADDR *addrp,
2344                           int *realnump, gdb_byte *valuep)
2345 {
2346   struct hppa_frame_cache *info =
2347     hppa_fallback_frame_cache (next_frame, this_cache);
2348   hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
2349                                    optimizedp, lvalp, addrp, realnump, valuep);
2350 }
2351
2352 static const struct frame_unwind hppa_fallback_frame_unwind =
2353 {
2354   NORMAL_FRAME,
2355   hppa_fallback_frame_this_id,
2356   hppa_fallback_frame_prev_register
2357 };
2358
2359 static const struct frame_unwind *
2360 hppa_fallback_unwind_sniffer (struct frame_info *next_frame)
2361 {
2362   return &hppa_fallback_frame_unwind;
2363 }
2364
2365 /* Stub frames, used for all kinds of call stubs.  */
2366 struct hppa_stub_unwind_cache
2367 {
2368   CORE_ADDR base;
2369   struct trad_frame_saved_reg *saved_regs;
2370 };
2371
2372 static struct hppa_stub_unwind_cache *
2373 hppa_stub_frame_unwind_cache (struct frame_info *next_frame,
2374                               void **this_cache)
2375 {
2376   struct gdbarch *gdbarch = get_frame_arch (next_frame);
2377   struct hppa_stub_unwind_cache *info;
2378   struct unwind_table_entry *u;
2379
2380   if (*this_cache)
2381     return *this_cache;
2382
2383   info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
2384   *this_cache = info;
2385   info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
2386
2387   info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
2388
2389   if (gdbarch_osabi (gdbarch) == GDB_OSABI_HPUX_SOM)
2390     {
2391       /* HPUX uses export stubs in function calls; the export stub clobbers
2392          the return value of the caller, and, later restores it from the
2393          stack.  */
2394       u = find_unwind_entry (frame_pc_unwind (next_frame));
2395
2396       if (u && u->stub_unwind.stub_type == EXPORT)
2397         {
2398           info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = info->base - 24;
2399
2400           return info;
2401         }
2402     }
2403
2404   /* By default we assume that stubs do not change the rp.  */
2405   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
2406
2407   return info;
2408 }
2409
2410 static void
2411 hppa_stub_frame_this_id (struct frame_info *next_frame,
2412                          void **this_prologue_cache,
2413                          struct frame_id *this_id)
2414 {
2415   struct hppa_stub_unwind_cache *info
2416     = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
2417
2418   if (info)
2419     *this_id = frame_id_build (info->base,
2420                                frame_func_unwind (next_frame, NORMAL_FRAME));
2421   else
2422     *this_id = null_frame_id;
2423 }
2424
2425 static void
2426 hppa_stub_frame_prev_register (struct frame_info *next_frame,
2427                                void **this_prologue_cache,
2428                                int regnum, int *optimizedp,
2429                                enum lval_type *lvalp, CORE_ADDR *addrp,
2430                                int *realnump, gdb_byte *valuep)
2431 {
2432   struct hppa_stub_unwind_cache *info
2433     = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
2434
2435   if (info)
2436     hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
2437                                      optimizedp, lvalp, addrp, realnump,
2438                                      valuep);
2439   else
2440     error (_("Requesting registers from null frame."));
2441 }
2442
2443 static const struct frame_unwind hppa_stub_frame_unwind = {
2444   NORMAL_FRAME,
2445   hppa_stub_frame_this_id,
2446   hppa_stub_frame_prev_register
2447 };
2448
2449 static const struct frame_unwind *
2450 hppa_stub_unwind_sniffer (struct frame_info *next_frame)
2451 {
2452   CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
2453   struct gdbarch *gdbarch = get_frame_arch (next_frame);
2454   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2455
2456   if (pc == 0
2457       || (tdep->in_solib_call_trampoline != NULL
2458           && tdep->in_solib_call_trampoline (pc, NULL))
2459       || gdbarch_in_solib_return_trampoline (gdbarch, pc, NULL))
2460     return &hppa_stub_frame_unwind;
2461   return NULL;
2462 }
2463
2464 static struct frame_id
2465 hppa_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
2466 {
2467   return frame_id_build (frame_unwind_register_unsigned (next_frame,
2468                                                          HPPA_SP_REGNUM),
2469                          frame_pc_unwind (next_frame));
2470 }
2471
2472 CORE_ADDR
2473 hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2474 {
2475   ULONGEST ipsw;
2476   CORE_ADDR pc;
2477
2478   ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
2479   pc = frame_unwind_register_unsigned (next_frame, HPPA_PCOQ_HEAD_REGNUM);
2480
2481   /* If the current instruction is nullified, then we are effectively
2482      still executing the previous instruction.  Pretend we are still
2483      there.  This is needed when single stepping; if the nullified
2484      instruction is on a different line, we don't want GDB to think
2485      we've stepped onto that line.  */
2486   if (ipsw & 0x00200000)
2487     pc -= 4;
2488
2489   return pc & ~0x3;
2490 }
2491
2492 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2493    Return NULL if no such symbol was found.  */
2494
2495 struct minimal_symbol *
2496 hppa_lookup_stub_minimal_symbol (const char *name,
2497                                  enum unwind_stub_types stub_type)
2498 {
2499   struct objfile *objfile;
2500   struct minimal_symbol *msym;
2501
2502   ALL_MSYMBOLS (objfile, msym)
2503     {
2504       if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
2505         {
2506           struct unwind_table_entry *u;
2507
2508           u = find_unwind_entry (SYMBOL_VALUE (msym));
2509           if (u != NULL && u->stub_unwind.stub_type == stub_type)
2510             return msym;
2511         }
2512     }
2513
2514   return NULL;
2515 }
2516
2517 static void
2518 unwind_command (char *exp, int from_tty)
2519 {
2520   CORE_ADDR address;
2521   struct unwind_table_entry *u;
2522
2523   /* If we have an expression, evaluate it and use it as the address.  */
2524
2525   if (exp != 0 && *exp != 0)
2526     address = parse_and_eval_address (exp);
2527   else
2528     return;
2529
2530   u = find_unwind_entry (address);
2531
2532   if (!u)
2533     {
2534       printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2535       return;
2536     }
2537
2538   printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u);
2539
2540   printf_unfiltered ("\tregion_start = ");
2541   print_address (u->region_start, gdb_stdout);
2542   gdb_flush (gdb_stdout);
2543
2544   printf_unfiltered ("\n\tregion_end = ");
2545   print_address (u->region_end, gdb_stdout);
2546   gdb_flush (gdb_stdout);
2547
2548 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2549
2550   printf_unfiltered ("\n\tflags =");
2551   pif (Cannot_unwind);
2552   pif (Millicode);
2553   pif (Millicode_save_sr0);
2554   pif (Entry_SR);
2555   pif (Args_stored);
2556   pif (Variable_Frame);
2557   pif (Separate_Package_Body);
2558   pif (Frame_Extension_Millicode);
2559   pif (Stack_Overflow_Check);
2560   pif (Two_Instruction_SP_Increment);
2561   pif (sr4export);
2562   pif (cxx_info);
2563   pif (cxx_try_catch);
2564   pif (sched_entry_seq);
2565   pif (Save_SP);
2566   pif (Save_RP);
2567   pif (Save_MRP_in_frame);
2568   pif (save_r19);
2569   pif (Cleanup_defined);
2570   pif (MPE_XL_interrupt_marker);
2571   pif (HP_UX_interrupt_marker);
2572   pif (Large_frame);
2573   pif (alloca_frame);
2574
2575   putchar_unfiltered ('\n');
2576
2577 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2578
2579   pin (Region_description);
2580   pin (Entry_FR);
2581   pin (Entry_GR);
2582   pin (Total_frame_size);
2583
2584   if (u->stub_unwind.stub_type)
2585     {
2586       printf_unfiltered ("\tstub type = ");
2587       switch (u->stub_unwind.stub_type)
2588         {
2589           case LONG_BRANCH:
2590             printf_unfiltered ("long branch\n");
2591             break;
2592           case PARAMETER_RELOCATION:
2593             printf_unfiltered ("parameter relocation\n");
2594             break;
2595           case EXPORT:
2596             printf_unfiltered ("export\n");
2597             break;
2598           case IMPORT:
2599             printf_unfiltered ("import\n");
2600             break;
2601           case IMPORT_SHLIB:
2602             printf_unfiltered ("import shlib\n");
2603             break;
2604           default:
2605             printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
2606         }
2607     }
2608 }
2609
2610 /* Return the GDB type object for the "standard" data type of data in
2611    register REGNUM.  */
2612
2613 static struct type *
2614 hppa32_register_type (struct gdbarch *gdbarch, int regnum)
2615 {
2616    if (regnum < HPPA_FP4_REGNUM)
2617      return builtin_type_uint32;
2618    else
2619      return builtin_type_ieee_single;
2620 }
2621
2622 static struct type *
2623 hppa64_register_type (struct gdbarch *gdbarch, int regnum)
2624 {
2625    if (regnum < HPPA64_FP4_REGNUM)
2626      return builtin_type_uint64;
2627    else
2628      return builtin_type_ieee_double;
2629 }
2630
2631 /* Return non-zero if REGNUM is not a register available to the user
2632    through ptrace/ttrace.  */
2633
2634 static int
2635 hppa32_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2636 {
2637   return (regnum == 0
2638           || regnum == HPPA_PCSQ_HEAD_REGNUM
2639           || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2640           || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
2641 }
2642
2643 static int
2644 hppa32_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2645 {
2646   /* cr26 and cr27 are readable (but not writable) from userspace.  */
2647   if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2648     return 0;
2649   else
2650     return hppa32_cannot_store_register (gdbarch, regnum);
2651 }
2652
2653 static int
2654 hppa64_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2655 {
2656   return (regnum == 0
2657           || regnum == HPPA_PCSQ_HEAD_REGNUM
2658           || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2659           || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
2660 }
2661
2662 static int
2663 hppa64_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2664 {
2665   /* cr26 and cr27 are readable (but not writable) from userspace.  */
2666   if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2667     return 0;
2668   else
2669     return hppa64_cannot_store_register (gdbarch, regnum);
2670 }
2671
2672 static CORE_ADDR
2673 hppa_smash_text_address (CORE_ADDR addr)
2674 {
2675   /* The low two bits of the PC on the PA contain the privilege level.
2676      Some genius implementing a (non-GCC) compiler apparently decided
2677      this means that "addresses" in a text section therefore include a
2678      privilege level, and thus symbol tables should contain these bits.
2679      This seems like a bonehead thing to do--anyway, it seems to work
2680      for our purposes to just ignore those bits.  */
2681
2682   return (addr &= ~0x3);
2683 }
2684
2685 /* Get the ARGIth function argument for the current function.  */
2686
2687 static CORE_ADDR
2688 hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
2689                              struct type *type)
2690 {
2691   return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
2692 }
2693
2694 static void
2695 hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2696                            int regnum, gdb_byte *buf)
2697 {
2698     ULONGEST tmp;
2699
2700     regcache_raw_read_unsigned (regcache, regnum, &tmp);
2701     if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
2702       tmp &= ~0x3;
2703     store_unsigned_integer (buf, sizeof tmp, tmp);
2704 }
2705
2706 static CORE_ADDR
2707 hppa_find_global_pointer (struct value *function)
2708 {
2709   return 0;
2710 }
2711
2712 void
2713 hppa_frame_prev_register_helper (struct frame_info *next_frame,
2714                                  struct trad_frame_saved_reg saved_regs[],
2715                                  int regnum, int *optimizedp,
2716                                  enum lval_type *lvalp, CORE_ADDR *addrp,
2717                                  int *realnump, gdb_byte *valuep)
2718 {
2719   struct gdbarch *arch = get_frame_arch (next_frame);
2720
2721   if (regnum == HPPA_PCOQ_TAIL_REGNUM)
2722     {
2723       if (valuep)
2724         {
2725           int size = register_size (arch, HPPA_PCOQ_HEAD_REGNUM);
2726           CORE_ADDR pc;
2727
2728           trad_frame_get_prev_register (next_frame, saved_regs,
2729                                         HPPA_PCOQ_HEAD_REGNUM, optimizedp,
2730                                         lvalp, addrp, realnump, valuep);
2731
2732           pc = extract_unsigned_integer (valuep, size);
2733           store_unsigned_integer (valuep, size, pc + 4);
2734         }
2735
2736       /* It's a computed value.  */
2737       *optimizedp = 0;
2738       *lvalp = not_lval;
2739       *addrp = 0;
2740       *realnump = -1;
2741       return;
2742     }
2743
2744   /* Make sure the "flags" register is zero in all unwound frames.
2745      The "flags" registers is a HP-UX specific wart, and only the code
2746      in hppa-hpux-tdep.c depends on it.  However, it is easier to deal
2747      with it here.  This shouldn't affect other systems since those
2748      should provide zero for the "flags" register anyway.  */
2749   if (regnum == HPPA_FLAGS_REGNUM)
2750     {
2751       if (valuep)
2752         store_unsigned_integer (valuep, register_size (arch, regnum), 0);
2753
2754       /* It's a computed value.  */
2755       *optimizedp = 0;
2756       *lvalp = not_lval;
2757       *addrp = 0;
2758       *realnump = -1;
2759       return;
2760     }
2761
2762   trad_frame_get_prev_register (next_frame, saved_regs, regnum,
2763                                 optimizedp, lvalp, addrp, realnump, valuep);
2764 }
2765 \f
2766
2767 /* An instruction to match.  */
2768 struct insn_pattern
2769 {
2770   unsigned int data;            /* See if it matches this....  */
2771   unsigned int mask;            /* ... with this mask.  */
2772 };
2773
2774 /* See bfd/elf32-hppa.c */
2775 static struct insn_pattern hppa_long_branch_stub[] = {
2776   /* ldil LR'xxx,%r1 */
2777   { 0x20200000, 0xffe00000 },
2778   /* be,n RR'xxx(%sr4,%r1) */
2779   { 0xe0202002, 0xffe02002 },
2780   { 0, 0 }
2781 };
2782
2783 static struct insn_pattern hppa_long_branch_pic_stub[] = {
2784   /* b,l .+8, %r1 */
2785   { 0xe8200000, 0xffe00000 },
2786   /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2787   { 0x28200000, 0xffe00000 },
2788   /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2789   { 0xe0202002, 0xffe02002 },
2790   { 0, 0 }
2791 };
2792
2793 static struct insn_pattern hppa_import_stub[] = {
2794   /* addil LR'xxx, %dp */
2795   { 0x2b600000, 0xffe00000 },
2796   /* ldw RR'xxx(%r1), %r21 */
2797   { 0x48350000, 0xffffb000 },
2798   /* bv %r0(%r21) */
2799   { 0xeaa0c000, 0xffffffff },
2800   /* ldw RR'xxx+4(%r1), %r19 */
2801   { 0x48330000, 0xffffb000 },
2802   { 0, 0 }
2803 };
2804
2805 static struct insn_pattern hppa_import_pic_stub[] = {
2806   /* addil LR'xxx,%r19 */
2807   { 0x2a600000, 0xffe00000 },
2808   /* ldw RR'xxx(%r1),%r21 */
2809   { 0x48350000, 0xffffb000 },
2810   /* bv %r0(%r21) */
2811   { 0xeaa0c000, 0xffffffff },
2812   /* ldw RR'xxx+4(%r1),%r19 */
2813   { 0x48330000, 0xffffb000 },
2814   { 0, 0 },
2815 };
2816
2817 static struct insn_pattern hppa_plt_stub[] = {
2818   /* b,l 1b, %r20 - 1b is 3 insns before here */
2819   { 0xea9f1fdd, 0xffffffff },
2820   /* depi 0,31,2,%r20 */
2821   { 0xd6801c1e, 0xffffffff },
2822   { 0, 0 }
2823 };
2824
2825 static struct insn_pattern hppa_sigtramp[] = {
2826   /* ldi 0, %r25 or ldi 1, %r25 */
2827   { 0x34190000, 0xfffffffd },
2828   /* ldi __NR_rt_sigreturn, %r20 */
2829   { 0x3414015a, 0xffffffff },
2830   /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
2831   { 0xe4008200, 0xffffffff },
2832   /* nop */
2833   { 0x08000240, 0xffffffff },
2834   { 0, 0 }
2835 };
2836
2837 /* Maximum number of instructions on the patterns above.  */
2838 #define HPPA_MAX_INSN_PATTERN_LEN       4
2839
2840 /* Return non-zero if the instructions at PC match the series
2841    described in PATTERN, or zero otherwise.  PATTERN is an array of
2842    'struct insn_pattern' objects, terminated by an entry whose mask is
2843    zero.
2844
2845    When the match is successful, fill INSN[i] with what PATTERN[i]
2846    matched.  */
2847
2848 static int
2849 hppa_match_insns (CORE_ADDR pc, struct insn_pattern *pattern,
2850                   unsigned int *insn)
2851 {
2852   CORE_ADDR npc = pc;
2853   int i;
2854
2855   for (i = 0; pattern[i].mask; i++)
2856     {
2857       gdb_byte buf[HPPA_INSN_SIZE];
2858
2859       read_memory_nobpt (npc, buf, HPPA_INSN_SIZE);
2860       insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE);
2861       if ((insn[i] & pattern[i].mask) == pattern[i].data)
2862         npc += 4;
2863       else
2864         return 0;
2865     }
2866
2867   return 1;
2868 }
2869
2870 /* This relaxed version of the insstruction matcher allows us to match
2871    from somewhere inside the pattern, by looking backwards in the
2872    instruction scheme.  */
2873
2874 static int
2875 hppa_match_insns_relaxed (CORE_ADDR pc, struct insn_pattern *pattern,
2876                           unsigned int *insn)
2877 {
2878   int offset, len = 0;
2879
2880   while (pattern[len].mask)
2881     len++;
2882
2883   for (offset = 0; offset < len; offset++)
2884     if (hppa_match_insns (pc - offset * HPPA_INSN_SIZE, pattern, insn))
2885       return 1;
2886
2887   return 0;
2888 }
2889
2890 static int
2891 hppa_in_dyncall (CORE_ADDR pc)
2892 {
2893   struct unwind_table_entry *u;
2894
2895   u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2896   if (!u)
2897     return 0;
2898
2899   return (pc >= u->region_start && pc <= u->region_end);
2900 }
2901
2902 int
2903 hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name)
2904 {
2905   unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2906   struct unwind_table_entry *u;
2907
2908   if (in_plt_section (pc, name) || hppa_in_dyncall (pc))
2909     return 1;
2910
2911   /* The GNU toolchain produces linker stubs without unwind
2912      information.  Since the pattern matching for linker stubs can be
2913      quite slow, so bail out if we do have an unwind entry.  */
2914
2915   u = find_unwind_entry (pc);
2916   if (u != NULL)
2917     return 0;
2918
2919   return (hppa_match_insns_relaxed (pc, hppa_import_stub, insn)
2920           || hppa_match_insns_relaxed (pc, hppa_import_pic_stub, insn)
2921           || hppa_match_insns_relaxed (pc, hppa_long_branch_stub, insn)
2922           || hppa_match_insns_relaxed (pc, hppa_long_branch_pic_stub, insn));
2923 }
2924
2925 /* This code skips several kind of "trampolines" used on PA-RISC
2926    systems: $$dyncall, import stubs and PLT stubs.  */
2927
2928 CORE_ADDR
2929 hppa_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
2930 {
2931   unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2932   int dp_rel;
2933
2934   /* $$dyncall handles both PLABELs and direct addresses.  */
2935   if (hppa_in_dyncall (pc))
2936     {
2937       pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22);
2938
2939       /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it.  */
2940       if (pc & 0x2)
2941         pc = read_memory_typed_address (pc & ~0x3, builtin_type_void_func_ptr);
2942
2943       return pc;
2944     }
2945
2946   dp_rel = hppa_match_insns (pc, hppa_import_stub, insn);
2947   if (dp_rel || hppa_match_insns (pc, hppa_import_pic_stub, insn))
2948     {
2949       /* Extract the target address from the addil/ldw sequence.  */
2950       pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
2951
2952       if (dp_rel)
2953         pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
2954       else
2955         pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
2956
2957       /* fallthrough */
2958     }
2959
2960   if (in_plt_section (pc, NULL))
2961     {
2962       pc = read_memory_typed_address (pc, builtin_type_void_func_ptr);
2963
2964       /* If the PLT slot has not yet been resolved, the target will be
2965          the PLT stub.  */
2966       if (in_plt_section (pc, NULL))
2967         {
2968           /* Sanity check: are we pointing to the PLT stub?  */
2969           if (!hppa_match_insns (pc, hppa_plt_stub, insn))
2970             {
2971               warning (_("Cannot resolve PLT stub at 0x%s."), paddr_nz (pc));
2972               return 0;
2973             }
2974
2975           /* This should point to the fixup routine.  */
2976           pc = read_memory_typed_address (pc + 8, builtin_type_void_func_ptr);
2977         }
2978     }
2979
2980   return pc;
2981 }
2982 \f
2983
2984 /* Here is a table of C type sizes on hppa with various compiles
2985    and options.  I measured this on PA 9000/800 with HP-UX 11.11
2986    and these compilers:
2987
2988      /usr/ccs/bin/cc    HP92453-01 A.11.01.21
2989      /opt/ansic/bin/cc  HP92453-01 B.11.11.28706.GP
2990      /opt/aCC/bin/aCC   B3910B A.03.45
2991      gcc                gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2992
2993      cc            : 1 2 4 4 8 : 4 8 -- : 4 4
2994      ansic +DA1.1  : 1 2 4 4 8 : 4 8 16 : 4 4
2995      ansic +DA2.0  : 1 2 4 4 8 : 4 8 16 : 4 4
2996      ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2997      acc   +DA1.1  : 1 2 4 4 8 : 4 8 16 : 4 4
2998      acc   +DA2.0  : 1 2 4 4 8 : 4 8 16 : 4 4
2999      acc   +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3000      gcc           : 1 2 4 4 8 : 4 8 16 : 4 4
3001
3002    Each line is:
3003
3004      compiler and options
3005      char, short, int, long, long long
3006      float, double, long double
3007      char *, void (*)()
3008
3009    So all these compilers use either ILP32 or LP64 model.
3010    TODO: gcc has more options so it needs more investigation.
3011
3012    For floating point types, see:
3013
3014      http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3015      HP-UX floating-point guide, hpux 11.00
3016
3017    -- chastain 2003-12-18  */
3018
3019 static struct gdbarch *
3020 hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3021 {
3022   struct gdbarch_tdep *tdep;
3023   struct gdbarch *gdbarch;
3024
3025   /* Try to determine the ABI of the object we are loading.  */
3026   if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
3027     {
3028       /* If it's a SOM file, assume it's HP/UX SOM.  */
3029       if (bfd_get_flavour (info.abfd) == bfd_target_som_flavour)
3030         info.osabi = GDB_OSABI_HPUX_SOM;
3031     }
3032
3033   /* find a candidate among the list of pre-declared architectures.  */
3034   arches = gdbarch_list_lookup_by_info (arches, &info);
3035   if (arches != NULL)
3036     return (arches->gdbarch);
3037
3038   /* If none found, then allocate and initialize one.  */
3039   tdep = XZALLOC (struct gdbarch_tdep);
3040   gdbarch = gdbarch_alloc (&info, tdep);
3041
3042   /* Determine from the bfd_arch_info structure if we are dealing with
3043      a 32 or 64 bits architecture.  If the bfd_arch_info is not available,
3044      then default to a 32bit machine.  */
3045   if (info.bfd_arch_info != NULL)
3046     tdep->bytes_per_address =
3047       info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
3048   else
3049     tdep->bytes_per_address = 4;
3050
3051   tdep->find_global_pointer = hppa_find_global_pointer;
3052
3053   /* Some parts of the gdbarch vector depend on whether we are running
3054      on a 32 bits or 64 bits target.  */
3055   switch (tdep->bytes_per_address)
3056     {
3057       case 4:
3058         set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
3059         set_gdbarch_register_name (gdbarch, hppa32_register_name);
3060         set_gdbarch_register_type (gdbarch, hppa32_register_type);
3061         set_gdbarch_cannot_store_register (gdbarch,
3062                                            hppa32_cannot_store_register);
3063         set_gdbarch_cannot_fetch_register (gdbarch,
3064                                            hppa32_cannot_fetch_register);
3065         break;
3066       case 8:
3067         set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
3068         set_gdbarch_register_name (gdbarch, hppa64_register_name);
3069         set_gdbarch_register_type (gdbarch, hppa64_register_type);
3070         set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
3071         set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
3072         set_gdbarch_cannot_store_register (gdbarch,
3073                                            hppa64_cannot_store_register);
3074         set_gdbarch_cannot_fetch_register (gdbarch,
3075                                            hppa64_cannot_fetch_register);
3076         break;
3077       default:
3078         internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
3079                         tdep->bytes_per_address);
3080     }
3081
3082   set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3083   set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3084
3085   /* The following gdbarch vector elements are the same in both ILP32
3086      and LP64, but might show differences some day.  */
3087   set_gdbarch_long_long_bit (gdbarch, 64);
3088   set_gdbarch_long_double_bit (gdbarch, 128);
3089   set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3090
3091   /* The following gdbarch vector elements do not depend on the address
3092      size, or in any other gdbarch element previously set.  */
3093   set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
3094   set_gdbarch_in_function_epilogue_p (gdbarch,
3095                                       hppa_in_function_epilogue_p);
3096   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
3097   set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM);
3098   set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM);
3099   set_gdbarch_addr_bits_remove (gdbarch, hppa_smash_text_address);
3100   set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
3101   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3102   set_gdbarch_read_pc (gdbarch, hppa_read_pc);
3103   set_gdbarch_write_pc (gdbarch, hppa_write_pc);
3104
3105   /* Helper for function argument information.  */
3106   set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
3107
3108   set_gdbarch_print_insn (gdbarch, print_insn_hppa);
3109
3110   /* When a hardware watchpoint triggers, we'll move the inferior past
3111      it by removing all eventpoints; stepping past the instruction
3112      that caused the trigger; reinserting eventpoints; and checking
3113      whether any watched location changed.  */
3114   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
3115
3116   /* Inferior function call methods.  */
3117   switch (tdep->bytes_per_address)
3118     {
3119     case 4:
3120       set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
3121       set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
3122       set_gdbarch_convert_from_func_ptr_addr
3123         (gdbarch, hppa32_convert_from_func_ptr_addr);
3124       break;
3125     case 8:
3126       set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
3127       set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
3128       break;
3129     default:
3130       internal_error (__FILE__, __LINE__, _("bad switch"));
3131     }
3132
3133   /* Struct return methods.  */
3134   switch (tdep->bytes_per_address)
3135     {
3136     case 4:
3137       set_gdbarch_return_value (gdbarch, hppa32_return_value);
3138       break;
3139     case 8:
3140       set_gdbarch_return_value (gdbarch, hppa64_return_value);
3141       break;
3142     default:
3143       internal_error (__FILE__, __LINE__, _("bad switch"));
3144     }
3145
3146   set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
3147   set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
3148
3149   /* Frame unwind methods.  */
3150   set_gdbarch_unwind_dummy_id (gdbarch, hppa_unwind_dummy_id);
3151   set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
3152
3153   /* Hook in ABI-specific overrides, if they have been registered.  */
3154   gdbarch_init_osabi (info, gdbarch);
3155
3156   /* Hook in the default unwinders.  */
3157   frame_unwind_append_sniffer (gdbarch, hppa_stub_unwind_sniffer);
3158   frame_unwind_append_sniffer (gdbarch, hppa_frame_unwind_sniffer);
3159   frame_unwind_append_sniffer (gdbarch, hppa_fallback_unwind_sniffer);
3160
3161   return gdbarch;
3162 }
3163
3164 static void
3165 hppa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3166 {
3167   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3168
3169   fprintf_unfiltered (file, "bytes_per_address = %d\n",
3170                       tdep->bytes_per_address);
3171   fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
3172 }
3173
3174 void
3175 _initialize_hppa_tdep (void)
3176 {
3177   struct cmd_list_element *c;
3178
3179   gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
3180
3181   hppa_objfile_priv_data = register_objfile_data ();
3182
3183   add_cmd ("unwind", class_maintenance, unwind_command,
3184            _("Print unwind table entry at given address."),
3185            &maintenanceprintlist);
3186
3187   /* Debug this files internals. */
3188   add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
3189 Set whether hppa target specific debugging information should be displayed."),
3190                            _("\
3191 Show whether hppa target specific debugging information is displayed."), _("\
3192 This flag controls whether hppa target specific debugging information is\n\
3193 displayed.  This information is particularly useful for debugging frame\n\
3194 unwinding problems."),
3195                            NULL,
3196                            NULL, /* FIXME: i18n: hppa debug flag is %s.  */
3197                            &setdebuglist, &showdebuglist);
3198 }