gdb/hppa-tdep.c

   1 /* Target-dependent code for the HP PA architecture, for GDB.
   2    Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995
   3    Free Software Foundation, Inc.
   4
   5    Contributed by the Center for Software Science at the
   6    University of Utah (pa-gdb-bugs@cs.utah.edu).
   7
   8 This file is part of GDB.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program; if not, write to the Free Software
  22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23
  24 #include "defs.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "value.h"
  28
  29 /* For argument passing to the inferior */
  30 #include "symtab.h"
  31
  32 #ifdef USG
  33 #include <sys/types.h>
  34 #endif
  35
  36 #include <sys/param.h>
  37 #include <signal.h>
  38
  39 #ifdef COFF_ENCAPSULATE
  40 #include "a.out.encap.h"
  41 #else
  42 #endif
  43 #ifndef N_SET_MAGIC
  44 #define N_SET_MAGIC(exec, val) ((exec).a_magic = (val))
  45 #endif
  46
  47 /*#include <sys/user.h>         After a.out.h  */
  48 #include <sys/file.h>
  49 #include <sys/stat.h>
  50 #include "wait.h"
  51
  52 #include "gdbcore.h"
  53 #include "gdbcmd.h"
  54 #include "target.h"
  55 #include "symfile.h"
  56 #include "objfiles.h"
  57
  58 static int restore_pc_queue PARAMS ((struct frame_saved_regs *));
  59
  60 static int hppa_alignof PARAMS ((struct type *));
  61
  62 CORE_ADDR frame_saved_pc PARAMS ((struct frame_info *));
  63
  64 static int prologue_inst_adjust_sp PARAMS ((unsigned long));
  65
  66 static int is_branch PARAMS ((unsigned long));
  67
  68 static int inst_saves_gr PARAMS ((unsigned long));
  69
  70 static int inst_saves_fr PARAMS ((unsigned long));
  71
  72 static int pc_in_interrupt_handler PARAMS ((CORE_ADDR));
  73
  74 static int pc_in_linker_stub PARAMS ((CORE_ADDR));
  75
  76 static int compare_unwind_entries PARAMS ((const struct unwind_table_entry *,
  77                                            const struct unwind_table_entry *));
  78
  79 static void read_unwind_info PARAMS ((struct objfile *));
  80
  81 static void internalize_unwinds PARAMS ((struct objfile *,
  82                                          struct unwind_table_entry *,
  83                                          asection *, unsigned int,
  84                                          unsigned int, CORE_ADDR));
  85 static void pa_print_registers PARAMS ((char *, int, int));
  86 static void pa_print_fp_reg PARAMS ((int));
  87
  88 \f
  89 /* Routines to extract various sized constants out of hppa
  90    instructions. */
  91
  92 /* This assumes that no garbage lies outside of the lower bits of
  93    value. */
  94
  95 int
  96 sign_extend (val, bits)
  97      unsigned val, bits;
  98 {
  99   return (int)(val >> bits - 1 ? (-1 << bits) | val : val);
 100 }
 101
 102 /* For many immediate values the sign bit is the low bit! */
 103
 104 int
 105 low_sign_extend (val, bits)
 106      unsigned val, bits;
 107 {
 108   return (int)((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
 109 }
 110 /* extract the immediate field from a ld{bhw}s instruction */
 111
 112 unsigned
 113 get_field (val, from, to)
 114      unsigned val, from, to;
 115 {
 116   val = val >> 31 - to;
 117   return val & ((1 << 32 - from) - 1);
 118 }
 119
 120 unsigned
 121 set_field (val, from, to, new_val)
 122      unsigned *val, from, to;
 123 {
 124   unsigned mask = ~((1 << (to - from + 1)) << (31 - from));
 125   return *val = *val & mask | (new_val << (31 - from));
 126 }
 127
 128 /* extract a 3-bit space register number from a be, ble, mtsp or mfsp */
 129
 130 extract_3 (word)
 131      unsigned word;
 132 {
 133   return GET_FIELD (word, 18, 18) << 2 | GET_FIELD (word, 16, 17);
 134 }
 135
 136 extract_5_load (word)
 137      unsigned word;
 138 {
 139   return low_sign_extend (word >> 16 & MASK_5, 5);
 140 }
 141
 142 /* extract the immediate field from a st{bhw}s instruction */
 143
 144 int
 145 extract_5_store (word)
 146      unsigned word;
 147 {
 148   return low_sign_extend (word & MASK_5, 5);
 149 }
 150
 151 /* extract the immediate field from a break instruction */
 152
 153 unsigned
 154 extract_5r_store (word)
 155      unsigned word;
 156 {
 157   return (word & MASK_5);
 158 }
 159
 160 /* extract the immediate field from a {sr}sm instruction */
 161
 162 unsigned
 163 extract_5R_store (word)
 164      unsigned word;
 165 {
 166   return (word >> 16 & MASK_5);
 167 }
 168
 169 /* extract an 11 bit immediate field */
 170
 171 int
 172 extract_11 (word)
 173      unsigned word;
 174 {
 175   return low_sign_extend (word & MASK_11, 11);
 176 }
 177
 178 /* extract a 14 bit immediate field */
 179
 180 int
 181 extract_14 (word)
 182      unsigned word;
 183 {
 184   return low_sign_extend (word & MASK_14, 14);
 185 }
 186
 187 /* deposit a 14 bit constant in a word */
 188
 189 unsigned
 190 deposit_14 (opnd, word)
 191      int opnd;
 192      unsigned word;
 193 {
 194   unsigned sign = (opnd < 0 ? 1 : 0);
 195
 196   return word | ((unsigned)opnd << 1 & MASK_14)  | sign;
 197 }
 198
 199 /* extract a 21 bit constant */
 200
 201 int
 202 extract_21 (word)
 203      unsigned word;
 204 {
 205   int val;
 206
 207   word &= MASK_21;
 208   word <<= 11;
 209   val = GET_FIELD (word, 20, 20);
 210   val <<= 11;
 211   val |= GET_FIELD (word, 9, 19);
 212   val <<= 2;
 213   val |= GET_FIELD (word, 5, 6);
 214   val <<= 5;
 215   val |= GET_FIELD (word, 0, 4);
 216   val <<= 2;
 217   val |= GET_FIELD (word, 7, 8);
 218   return sign_extend (val, 21) << 11;
 219 }
 220
 221 /* deposit a 21 bit constant in a word. Although 21 bit constants are
 222    usually the top 21 bits of a 32 bit constant, we assume that only
 223    the low 21 bits of opnd are relevant */
 224
 225 unsigned
 226 deposit_21 (opnd, word)
 227      unsigned opnd, word;
 228 {
 229   unsigned val = 0;
 230
 231   val |= GET_FIELD (opnd, 11 + 14, 11 + 18);
 232   val <<= 2;
 233   val |= GET_FIELD (opnd, 11 + 12, 11 + 13);
 234   val <<= 2;
 235   val |= GET_FIELD (opnd, 11 + 19, 11 + 20);
 236   val <<= 11;
 237   val |= GET_FIELD (opnd, 11 + 1, 11 + 11);
 238   val <<= 1;
 239   val |= GET_FIELD (opnd, 11 + 0, 11 + 0);
 240   return word | val;
 241 }
 242
 243 /* extract a 12 bit constant from branch instructions */
 244
 245 int
 246 extract_12 (word)
 247      unsigned word;
 248 {
 249   return sign_extend (GET_FIELD (word, 19, 28) |
 250                       GET_FIELD (word, 29, 29) << 10 |
 251                       (word & 0x1) << 11, 12) << 2;
 252 }
 253
 254 /* Deposit a 17 bit constant in an instruction (like bl). */
 255
 256 unsigned int
 257 deposit_17 (opnd, word)
 258      unsigned opnd, word;
 259 {
 260   word |= GET_FIELD (opnd, 15 + 0, 15 + 0); /* w */
 261   word |= GET_FIELD (opnd, 15 + 1, 15 + 5) << 16; /* w1 */
 262   word |= GET_FIELD (opnd, 15 + 6, 15 + 6) << 2; /* w2[10] */
 263   word |= GET_FIELD (opnd, 15 + 7, 15 + 16) << 3; /* w2[0..9] */
 264
 265   return word;
 266 }
 267
 268 /* extract a 17 bit constant from branch instructions, returning the
 269    19 bit signed value. */
 270
 271 int
 272 extract_17 (word)
 273      unsigned word;
 274 {
 275   return sign_extend (GET_FIELD (word, 19, 28) |
 276                       GET_FIELD (word, 29, 29) << 10 |
 277                       GET_FIELD (word, 11, 15) << 11 |
 278                       (word & 0x1) << 16, 17) << 2;
 279 }
 280 \f
 281
 282 /* Compare the start address for two unwind entries returning 1 if
 283    the first address is larger than the second, -1 if the second is
 284    larger than the first, and zero if they are equal.  */
 285
 286 static int
 287 compare_unwind_entries (a, b)
 288      const struct unwind_table_entry *a;
 289      const struct unwind_table_entry *b;
 290 {
 291   if (a->region_start > b->region_start)
 292     return 1;
 293   else if (a->region_start < b->region_start)
 294     return -1;
 295   else
 296     return 0;
 297 }
 298
 299 static void
 300 internalize_unwinds (objfile, table, section, entries, size, text_offset)
 301      struct objfile *objfile;
 302      struct unwind_table_entry *table;
 303      asection *section;
 304      unsigned int entries, size;
 305      CORE_ADDR text_offset;
 306 {
 307   /* We will read the unwind entries into temporary memory, then
 308      fill in the actual unwind table.  */
 309   if (size > 0)
 310     {
 311       unsigned long tmp;
 312       unsigned i;
 313       char *buf = alloca (size);
 314
 315       bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
 316
 317       /* Now internalize the information being careful to handle host/target
 318          endian issues.  */
 319       for (i = 0; i < entries; i++)
 320         {
 321           table[i].region_start = bfd_get_32 (objfile->obfd,
 322                                                   (bfd_byte *)buf);
 323           table[i].region_start += text_offset;
 324           buf += 4;
 325           table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *)buf);
 326           table[i].region_end += text_offset;
 327           buf += 4;
 328           tmp = bfd_get_32 (objfile->obfd, (bfd_byte *)buf);
 329           buf += 4;
 330           table[i].Cannot_unwind = (tmp >> 31) & 0x1;
 331           table[i].Millicode = (tmp >> 30) & 0x1;
 332           table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
 333           table[i].Region_description = (tmp >> 27) & 0x3;
 334           table[i].reserved1 = (tmp >> 26) & 0x1;
 335           table[i].Entry_SR = (tmp >> 25) & 0x1;
 336           table[i].Entry_FR = (tmp >> 21) & 0xf;
 337           table[i].Entry_GR = (tmp >> 16) & 0x1f;
 338           table[i].Args_stored = (tmp >> 15) & 0x1;
 339           table[i].Variable_Frame = (tmp >> 14) & 0x1;
 340           table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
 341           table[i].Frame_Extension_Millicode = (tmp >> 12 ) & 0x1;
 342           table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
 343           table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
 344           table[i].Ada_Region = (tmp >> 9) & 0x1;
 345           table[i].reserved2 = (tmp >> 5) & 0xf;
 346           table[i].Save_SP = (tmp >> 4) & 0x1;
 347           table[i].Save_RP = (tmp >> 3) & 0x1;
 348           table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
 349           table[i].extn_ptr_defined = (tmp >> 1) & 0x1;
 350           table[i].Cleanup_defined = tmp & 0x1;
 351           tmp = bfd_get_32 (objfile->obfd, (bfd_byte *)buf);
 352           buf += 4;
 353           table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
 354           table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
 355           table[i].Large_frame = (tmp >> 29) & 0x1;
 356           table[i].reserved4 = (tmp >> 27) & 0x3;
 357           table[i].Total_frame_size = tmp & 0x7ffffff;
 358         }
 359     }
 360 }
 361
 362 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
 363    the object file.  This info is used mainly by find_unwind_entry() to find
 364    out the stack frame size and frame pointer used by procedures.  We put
 365    everything on the psymbol obstack in the objfile so that it automatically
 366    gets freed when the objfile is destroyed.  */
 367
 368 static void
 369 read_unwind_info (objfile)
 370      struct objfile *objfile;
 371 {
 372   asection *unwind_sec, *elf_unwind_sec, *stub_unwind_sec;
 373   unsigned unwind_size, elf_unwind_size, stub_unwind_size, total_size;
 374   unsigned index, unwind_entries, elf_unwind_entries;
 375   unsigned stub_entries, total_entries;
 376   CORE_ADDR text_offset;
 377   struct obj_unwind_info *ui;
 378
 379   text_offset = ANOFFSET (objfile->section_offsets, 0);
 380   ui = (struct obj_unwind_info *)obstack_alloc (&objfile->psymbol_obstack,
 381                                                 sizeof (struct obj_unwind_info));
 382
 383   ui->table = NULL;
 384   ui->cache = NULL;
 385   ui->last = -1;
 386
 387   /* Get hooks to all unwind sections.   Note there is no linker-stub unwind
 388      section in ELF at the moment.  */
 389   unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_START$");
 390   elf_unwind_sec = bfd_get_section_by_name (objfile->obfd, ".PARISC.unwind");
 391   stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
 392
 393   /* Get sizes and unwind counts for all sections.  */
 394   if (unwind_sec)
 395     {
 396       unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
 397       unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
 398     }
 399   else
 400     {
 401       unwind_size = 0;
 402       unwind_entries = 0;
 403     }
 404
 405   if (elf_unwind_sec)
 406     {
 407       elf_unwind_size = bfd_section_size (objfile->obfd, elf_unwind_sec);
 408       elf_unwind_entries = elf_unwind_size / UNWIND_ENTRY_SIZE;
 409     }
 410   else
 411     {
 412       elf_unwind_size = 0;
 413       elf_unwind_entries = 0;
 414     }
 415
 416   if (stub_unwind_sec)
 417     {
 418       stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
 419       stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
 420     }
 421   else
 422     {
 423       stub_unwind_size = 0;
 424       stub_entries = 0;
 425     }
 426
 427   /* Compute total number of unwind entries and their total size.  */
 428   total_entries = unwind_entries + elf_unwind_entries + stub_entries;
 429   total_size = total_entries * sizeof (struct unwind_table_entry);
 430
 431   /* Allocate memory for the unwind table.  */
 432   ui->table = obstack_alloc (&objfile->psymbol_obstack, total_size);
 433   ui->last = total_entries - 1;
 434
 435   /* Internalize the standard unwind entries.  */
 436   index = 0;
 437   internalize_unwinds (objfile, &ui->table[index], unwind_sec,
 438                        unwind_entries, unwind_size, text_offset);
 439   index += unwind_entries;
 440   internalize_unwinds (objfile, &ui->table[index], elf_unwind_sec,
 441                        elf_unwind_entries, elf_unwind_size, text_offset);
 442   index += elf_unwind_entries;
 443
 444   /* Now internalize the stub unwind entries.  */
 445   if (stub_unwind_size > 0)
 446     {
 447       unsigned int i;
 448       char *buf = alloca (stub_unwind_size);
 449
 450       /* Read in the stub unwind entries.  */
 451       bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
 452                                 0, stub_unwind_size);
 453
 454       /* Now convert them into regular unwind entries.  */
 455       for (i = 0; i < stub_entries; i++, index++)
 456         {
 457           /* Clear out the next unwind entry.  */
 458           memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
 459
 460           /* Convert offset & size into region_start and region_end.
 461              Stuff away the stub type into "reserved" fields.  */
 462           ui->table[index].region_start = bfd_get_32 (objfile->obfd,
 463                                                       (bfd_byte *) buf);
 464           ui->table[index].region_start += text_offset;
 465           buf += 4;
 466           ui->table[index].stub_type = bfd_get_8 (objfile->obfd,
 467                                                   (bfd_byte *) buf);
 468           buf += 2;
 469           ui->table[index].region_end
 470             = ui->table[index].region_start + 4 *
 471               (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
 472           buf += 2;
 473         }
 474
 475     }
 476
 477   /* Unwind table needs to be kept sorted.  */
 478   qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
 479          compare_unwind_entries);
 480
 481   /* Keep a pointer to the unwind information.  */
 482   objfile->obj_private = (PTR) ui;
 483 }
 484
 485 /* Lookup the unwind (stack backtrace) info for the given PC.  We search all
 486    of the objfiles seeking the unwind table entry for this PC.  Each objfile
 487    contains a sorted list of struct unwind_table_entry.  Since we do a binary
 488    search of the unwind tables, we depend upon them to be sorted.  */
 489
 490 static struct unwind_table_entry *
 491 find_unwind_entry(pc)
 492      CORE_ADDR pc;
 493 {
 494   int first, middle, last;
 495   struct objfile *objfile;
 496
 497   ALL_OBJFILES (objfile)
 498     {
 499       struct obj_unwind_info *ui;
 500
 501       ui = OBJ_UNWIND_INFO (objfile);
 502
 503       if (!ui)
 504         {
 505           read_unwind_info (objfile);
 506           ui = OBJ_UNWIND_INFO (objfile);
 507         }
 508
 509       /* First, check the cache */
 510
 511       if (ui->cache
 512           && pc >= ui->cache->region_start
 513           && pc <= ui->cache->region_end)
 514         return ui->cache;
 515
 516       /* Not in the cache, do a binary search */
 517
 518       first = 0;
 519       last = ui->last;
 520
 521       while (first <= last)
 522         {
 523           middle = (first + last) / 2;
 524           if (pc >= ui->table[middle].region_start
 525               && pc <= ui->table[middle].region_end)
 526             {
 527               ui->cache = &ui->table[middle];
 528               return &ui->table[middle];
 529             }
 530
 531           if (pc < ui->table[middle].region_start)
 532             last = middle - 1;
 533           else
 534             first = middle + 1;
 535         }
 536     }                           /* ALL_OBJFILES() */
 537   return NULL;
 538 }
 539
 540 /* Return the adjustment necessary to make for addresses on the stack
 541    as presented by hpread.c.
 542
 543    This is necessary because of the stack direction on the PA and the
 544    bizarre way in which someone (?) decided they wanted to handle
 545    frame pointerless code in GDB.  */
 546 int
 547 hpread_adjust_stack_address (func_addr)
 548      CORE_ADDR func_addr;
 549 {
 550   struct unwind_table_entry *u;
 551
 552   u = find_unwind_entry (func_addr);
 553   if (!u)
 554     return 0;
 555   else
 556     return u->Total_frame_size << 3;
 557 }
 558
 559 /* Called to determine if PC is in an interrupt handler of some
 560    kind.  */
 561
 562 static int
 563 pc_in_interrupt_handler (pc)
 564      CORE_ADDR pc;
 565 {
 566   struct unwind_table_entry *u;
 567   struct minimal_symbol *msym_us;
 568
 569   u = find_unwind_entry (pc);
 570   if (!u)
 571     return 0;
 572
 573   /* Oh joys.  HPUX sets the interrupt bit for _sigreturn even though
 574      its frame isn't a pure interrupt frame.  Deal with this.  */
 575   msym_us = lookup_minimal_symbol_by_pc (pc);
 576
 577   return u->HP_UX_interrupt_marker && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us));
 578 }
 579
 580 /* Called when no unwind descriptor was found for PC.  Returns 1 if it
 581    appears that PC is in a linker stub.  */
 582
 583 static int
 584 pc_in_linker_stub (pc)
 585      CORE_ADDR pc;
 586 {
 587   int found_magic_instruction = 0;
 588   int i;
 589   char buf[4];
 590
 591   /* If unable to read memory, assume pc is not in a linker stub.  */
 592   if (target_read_memory (pc, buf, 4) != 0)
 593     return 0;
 594
 595   /* We are looking for something like
 596
 597      ; $$dyncall jams RP into this special spot in the frame (RP')
 598      ; before calling the "call stub"
 599      ldw     -18(sp),rp
 600
 601      ldsid   (rp),r1         ; Get space associated with RP into r1
 602      mtsp    r1,sp           ; Move it into space register 0
 603      be,n    0(sr0),rp)      ; back to your regularly scheduled program
 604      */
 605
 606   /* Maximum known linker stub size is 4 instructions.  Search forward
 607      from the given PC, then backward.  */
 608   for (i = 0; i < 4; i++)
 609     {
 610       /* If we hit something with an unwind, stop searching this direction.  */
 611
 612       if (find_unwind_entry (pc + i * 4) != 0)
 613         break;
 614
 615       /* Check for ldsid (rp),r1 which is the magic instruction for a
 616          return from a cross-space function call.  */
 617       if (read_memory_integer (pc + i * 4, 4) == 0x004010a1)
 618         {
 619           found_magic_instruction = 1;
 620           break;
 621         }
 622       /* Add code to handle long call/branch and argument relocation stubs
 623          here.  */
 624     }
 625
 626   if (found_magic_instruction != 0)
 627     return 1;
 628
 629   /* Now look backward.  */
 630   for (i = 0; i < 4; i++)
 631     {
 632       /* If we hit something with an unwind, stop searching this direction.  */
 633
 634       if (find_unwind_entry (pc - i * 4) != 0)
 635         break;
 636
 637       /* Check for ldsid (rp),r1 which is the magic instruction for a
 638          return from a cross-space function call.  */
 639       if (read_memory_integer (pc - i * 4, 4) == 0x004010a1)
 640         {
 641           found_magic_instruction = 1;
 642           break;
 643         }
 644       /* Add code to handle long call/branch and argument relocation stubs
 645          here.  */
 646     }
 647   return found_magic_instruction;
 648 }
 649
 650 static int
 651 find_return_regnum(pc)
 652      CORE_ADDR pc;
 653 {
 654   struct unwind_table_entry *u;
 655
 656   u = find_unwind_entry (pc);
 657
 658   if (!u)
 659     return RP_REGNUM;
 660
 661   if (u->Millicode)
 662     return 31;
 663
 664   return RP_REGNUM;
 665 }
 666
 667 /* Return size of frame, or -1 if we should use a frame pointer.  */
 668 int
 669 find_proc_framesize (pc)
 670      CORE_ADDR pc;
 671 {
 672   struct unwind_table_entry *u;
 673   struct minimal_symbol *msym_us;
 674
 675   u = find_unwind_entry (pc);
 676
 677   if (!u)
 678     {
 679       if (pc_in_linker_stub (pc))
 680         /* Linker stubs have a zero size frame.  */
 681         return 0;
 682       else
 683         return -1;
 684     }
 685
 686   msym_us = lookup_minimal_symbol_by_pc (pc);
 687
 688   /* If Save_SP is set, and we're not in an interrupt or signal caller,
 689      then we have a frame pointer.  Use it.  */
 690   if (u->Save_SP && !pc_in_interrupt_handler (pc)
 691       && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us)))
 692     return -1;
 693
 694   return u->Total_frame_size << 3;
 695 }
 696
 697 /* Return offset from sp at which rp is saved, or 0 if not saved.  */
 698 static int rp_saved PARAMS ((CORE_ADDR));
 699
 700 static int
 701 rp_saved (pc)
 702      CORE_ADDR pc;
 703 {
 704   struct unwind_table_entry *u;
 705
 706   u = find_unwind_entry (pc);
 707
 708   if (!u)
 709     {
 710       if (pc_in_linker_stub (pc))
 711         /* This is the so-called RP'.  */
 712         return -24;
 713       else
 714         return 0;
 715     }
 716
 717   if (u->Save_RP)
 718     return -20;
 719   else if (u->stub_type != 0)
 720     {
 721       switch (u->stub_type)
 722         {
 723         case EXPORT:
 724         case IMPORT:
 725           return -24;
 726         case PARAMETER_RELOCATION:
 727           return -8;
 728         default:
 729           return 0;
 730         }
 731     }
 732   else
 733     return 0;
 734 }
 735 \f
 736 int
 737 frameless_function_invocation (frame)
 738      struct frame_info *frame;
 739 {
 740   struct unwind_table_entry *u;
 741
 742   u = find_unwind_entry (frame->pc);
 743
 744   if (u == 0)
 745     return 0;
 746
 747   return (u->Total_frame_size == 0 && u->stub_type == 0);
 748 }
 749
 750 CORE_ADDR
 751 saved_pc_after_call (frame)
 752      struct frame_info *frame;
 753 {
 754   int ret_regnum;
 755   CORE_ADDR pc;
 756   struct unwind_table_entry *u;
 757
 758   ret_regnum = find_return_regnum (get_frame_pc (frame));
 759   pc = read_register (ret_regnum) & ~0x3;
 760
 761   /* If PC is in a linker stub, then we need to dig the address
 762      the stub will return to out of the stack.  */
 763   u = find_unwind_entry (pc);
 764   if (u && u->stub_type != 0)
 765     return frame_saved_pc (frame);
 766   else
 767     return pc;
 768 }
 769 \f
 770 CORE_ADDR
 771 frame_saved_pc (frame)
 772      struct frame_info *frame;
 773 {
 774   CORE_ADDR pc = get_frame_pc (frame);
 775   struct unwind_table_entry *u;
 776
 777   /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
 778      at the base of the frame in an interrupt handler.  Registers within
 779      are saved in the exact same order as GDB numbers registers.  How
 780      convienent.  */
 781   if (pc_in_interrupt_handler (pc))
 782     return read_memory_integer (frame->frame + PC_REGNUM * 4, 4) & ~0x3;
 783
 784 #ifdef FRAME_SAVED_PC_IN_SIGTRAMP
 785   /* Deal with signal handler caller frames too.  */
 786   if (frame->signal_handler_caller)
 787     {
 788       CORE_ADDR rp;
 789       FRAME_SAVED_PC_IN_SIGTRAMP (frame, &rp);
 790       return rp & ~0x3;
 791     }
 792 #endif
 793
 794   if (frameless_function_invocation (frame))
 795     {
 796       int ret_regnum;
 797
 798       ret_regnum = find_return_regnum (pc);
 799
 800       /* If the next frame is an interrupt frame or a signal
 801          handler caller, then we need to look in the saved
 802          register area to get the return pointer (the values
 803          in the registers may not correspond to anything useful).  */
 804       if (frame->next
 805           && (frame->next->signal_handler_caller
 806               || pc_in_interrupt_handler (frame->next->pc)))
 807         {
 808           struct frame_saved_regs saved_regs;
 809
 810           get_frame_saved_regs (frame->next, &saved_regs);
 811           if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4) & 0x2)
 812             {
 813               pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
 814
 815               /* Syscalls are really two frames.  The syscall stub itself
 816                  with a return pointer in %rp and the kernel call with
 817                  a return pointer in %r31.  We return the %rp variant
 818                  if %r31 is the same as frame->pc.  */
 819               if (pc == frame->pc)
 820                 pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
 821             }
 822           else
 823             pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
 824         }
 825       else
 826         pc = read_register (ret_regnum) & ~0x3;
 827     }
 828   else
 829     {
 830       int rp_offset;
 831
 832 restart:
 833       rp_offset = rp_saved (pc);
 834       /* Similar to code in frameless function case.  If the next
 835          frame is a signal or interrupt handler, then dig the right
 836          information out of the saved register info.  */
 837       if (rp_offset == 0
 838           && frame->next
 839           && (frame->next->signal_handler_caller
 840               || pc_in_interrupt_handler (frame->next->pc)))
 841         {
 842           struct frame_saved_regs saved_regs;
 843
 844           get_frame_saved_regs (frame->next, &saved_regs);
 845           if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4) & 0x2)
 846             {
 847               pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
 848
 849               /* Syscalls are really two frames.  The syscall stub itself
 850                  with a return pointer in %rp and the kernel call with
 851                  a return pointer in %r31.  We return the %rp variant
 852                  if %r31 is the same as frame->pc.  */
 853               if (pc == frame->pc)
 854                 pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
 855             }
 856           else
 857             pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
 858         }
 859       else if (rp_offset == 0)
 860         pc = read_register (RP_REGNUM) & ~0x3;
 861       else
 862         pc = read_memory_integer (frame->frame + rp_offset, 4) & ~0x3;
 863     }
 864
 865   /* If PC is inside a linker stub, then dig out the address the stub
 866      will return to.  */
 867   u = find_unwind_entry (pc);
 868   if (u && u->stub_type != 0)
 869     goto restart;
 870
 871   return pc;
 872 }
 873 \f
 874 /* We need to correct the PC and the FP for the outermost frame when we are
 875    in a system call.  */
 876
 877 void
 878 init_extra_frame_info (fromleaf, frame)
 879      int fromleaf;
 880      struct frame_info *frame;
 881 {
 882   int flags;
 883   int framesize;
 884
 885   if (frame->next && !fromleaf)
 886     return;
 887
 888   /* If the next frame represents a frameless function invocation
 889      then we have to do some adjustments that are normally done by
 890      FRAME_CHAIN.  (FRAME_CHAIN is not called in this case.)  */
 891   if (fromleaf)
 892     {
 893       /* Find the framesize of *this* frame without peeking at the PC
 894          in the current frame structure (it isn't set yet).  */
 895       framesize = find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame)));
 896
 897       /* Now adjust our base frame accordingly.  If we have a frame pointer
 898          use it, else subtract the size of this frame from the current
 899          frame.  (we always want frame->frame to point at the lowest address
 900          in the frame).  */
 901       if (framesize == -1)
 902         frame->frame = read_register (FP_REGNUM);
 903       else
 904         frame->frame -= framesize;
 905       return;
 906     }
 907
 908   flags = read_register (FLAGS_REGNUM);
 909   if (flags & 2)        /* In system call? */
 910     frame->pc = read_register (31) & ~0x3;
 911
 912   /* The outermost frame is always derived from PC-framesize
 913
 914      One might think frameless innermost frames should have
 915      a frame->frame that is the same as the parent's frame->frame.
 916      That is wrong; frame->frame in that case should be the *high*
 917      address of the parent's frame.  It's complicated as hell to
 918      explain, but the parent *always* creates some stack space for
 919      the child.  So the child actually does have a frame of some
 920      sorts, and its base is the high address in its parent's frame.  */
 921   framesize = find_proc_framesize(frame->pc);
 922   if (framesize == -1)
 923     frame->frame = read_register (FP_REGNUM);
 924   else
 925     frame->frame = read_register (SP_REGNUM) - framesize;
 926 }
 927 \f
 928 /* Given a GDB frame, determine the address of the calling function's frame.
 929    This will be used to create a new GDB frame struct, and then
 930    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
 931
 932    This may involve searching through prologues for several functions
 933    at boundaries where GCC calls HP C code, or where code which has
 934    a frame pointer calls code without a frame pointer.  */
 935
 936 CORE_ADDR
 937 frame_chain (frame)
 938      struct frame_info *frame;
 939 {
 940   int my_framesize, caller_framesize;
 941   struct unwind_table_entry *u;
 942   CORE_ADDR frame_base;
 943
 944   /* Handle HPUX, BSD, and OSF1 style interrupt frames first.  These
 945      are easy; at *sp we have a full save state strucutre which we can
 946      pull the old stack pointer from.  Also see frame_saved_pc for
 947      code to dig a saved PC out of the save state structure.  */
 948   if (pc_in_interrupt_handler (frame->pc))
 949     frame_base = read_memory_integer (frame->frame + SP_REGNUM * 4, 4);
 950 #ifdef FRAME_BASE_BEFORE_SIGTRAMP
 951   else if (frame->signal_handler_caller)
 952     {
 953       FRAME_BASE_BEFORE_SIGTRAMP (frame, &frame_base);
 954     }
 955 #endif
 956   else
 957     frame_base = frame->frame;
 958
 959   /* Get frame sizes for the current frame and the frame of the
 960      caller.  */
 961   my_framesize = find_proc_framesize (frame->pc);
 962   caller_framesize = find_proc_framesize (FRAME_SAVED_PC(frame));
 963
 964   /* If caller does not have a frame pointer, then its frame
 965      can be found at current_frame - caller_framesize.  */
 966   if (caller_framesize != -1)
 967     return frame_base - caller_framesize;
 968
 969   /* Both caller and callee have frame pointers and are GCC compiled
 970      (SAVE_SP bit in unwind descriptor is on for both functions.
 971      The previous frame pointer is found at the top of the current frame.  */
 972   if (caller_framesize == -1 && my_framesize == -1)
 973     return read_memory_integer (frame_base, 4);
 974
 975   /* Caller has a frame pointer, but callee does not.  This is a little
 976      more difficult as GCC and HP C lay out locals and callee register save
 977      areas very differently.
 978
 979      The previous frame pointer could be in a register, or in one of
 980      several areas on the stack.
 981
 982      Walk from the current frame to the innermost frame examining
 983      unwind descriptors to determine if %r3 ever gets saved into the
 984      stack.  If so return whatever value got saved into the stack.
 985      If it was never saved in the stack, then the value in %r3 is still
 986      valid, so use it.
 987
 988      We use information from unwind descriptors to determine if %r3
 989      is saved into the stack (Entry_GR field has this information).  */
 990
 991   while (frame)
 992     {
 993       u = find_unwind_entry (frame->pc);
 994
 995       if (!u)
 996         {
 997           /* We could find this information by examining prologues.  I don't
 998              think anyone has actually written any tools (not even "strip")
 999              which leave them out of an executable, so maybe this is a moot
1000              point.  */
1001           warning ("Unable to find unwind for PC 0x%x -- Help!", frame->pc);
1002           return 0;
1003         }
1004
1005       /* Entry_GR specifies the number of callee-saved general registers
1006          saved in the stack.  It starts at %r3, so %r3 would be 1.  */
1007       if (u->Entry_GR >= 1 || u->Save_SP
1008           || frame->signal_handler_caller
1009           || pc_in_interrupt_handler (frame->pc))
1010         break;
1011       else
1012         frame = frame->next;
1013     }
1014
1015   if (frame)
1016     {
1017       /* We may have walked down the chain into a function with a frame
1018          pointer.  */
1019       if (u->Save_SP
1020           && !frame->signal_handler_caller
1021           && !pc_in_interrupt_handler (frame->pc))
1022         return read_memory_integer (frame->frame, 4);
1023       /* %r3 was saved somewhere in the stack.  Dig it out.  */
1024       else
1025         {
1026           struct frame_saved_regs saved_regs;
1027
1028           get_frame_saved_regs (frame, &saved_regs);
1029           return read_memory_integer (saved_regs.regs[FP_REGNUM], 4);
1030         }
1031     }
1032   else
1033     {
1034       /* The value in %r3 was never saved into the stack (thus %r3 still
1035          holds the value of the previous frame pointer).  */
1036       return read_register (FP_REGNUM);
1037     }
1038 }
1039
1040 \f
1041 /* To see if a frame chain is valid, see if the caller looks like it
1042    was compiled with gcc. */
1043
1044 int
1045 frame_chain_valid (chain, thisframe)
1046      CORE_ADDR chain;
1047      struct frame_info *thisframe;
1048 {
1049   struct minimal_symbol *msym_us;
1050   struct minimal_symbol *msym_start;
1051   struct unwind_table_entry *u, *next_u = NULL;
1052   struct frame_info *next;
1053
1054   if (!chain)
1055     return 0;
1056
1057   u = find_unwind_entry (thisframe->pc);
1058
1059   if (u == NULL)
1060     return 1;
1061
1062   /* We can't just check that the same of msym_us is "_start", because
1063      someone idiotically decided that they were going to make a Ltext_end
1064      symbol with the same address.  This Ltext_end symbol is totally
1065      indistinguishable (as nearly as I can tell) from the symbol for a function
1066      which is (legitimately, since it is in the user's namespace)
1067      named Ltext_end, so we can't just ignore it.  */
1068   msym_us = lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe));
1069   msym_start = lookup_minimal_symbol ("_start", NULL, NULL);
1070   if (msym_us
1071       && msym_start
1072       && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
1073     return 0;
1074
1075   next = get_next_frame (thisframe);
1076   if (next)
1077     next_u = find_unwind_entry (next->pc);
1078
1079   /* If this frame does not save SP, has no stack, isn't a stub,
1080      and doesn't "call" an interrupt routine or signal handler caller,
1081      then its not valid.  */
1082   if (u->Save_SP || u->Total_frame_size || u->stub_type != 0
1083       || (thisframe->next && thisframe->next->signal_handler_caller)
1084       || (next_u && next_u->HP_UX_interrupt_marker))
1085     return 1;
1086
1087   if (pc_in_linker_stub (thisframe->pc))
1088     return 1;
1089
1090   return 0;
1091 }
1092
1093 /*
1094  * These functions deal with saving and restoring register state
1095  * around a function call in the inferior. They keep the stack
1096  * double-word aligned; eventually, on an hp700, the stack will have
1097  * to be aligned to a 64-byte boundary.
1098  */
1099
1100 void
1101 push_dummy_frame (inf_status)
1102      struct inferior_status *inf_status;
1103 {
1104   CORE_ADDR sp, pc, pcspace;
1105   register int regnum;
1106   int int_buffer;
1107   double freg_buffer;
1108
1109   /* Oh, what a hack.  If we're trying to perform an inferior call
1110      while the inferior is asleep, we have to make sure to clear
1111      the "in system call" bit in the flag register (the call will
1112      start after the syscall returns, so we're no longer in the system
1113      call!)  This state is kept in "inf_status", change it there.
1114
1115      We also need a number of horrid hacks to deal with lossage in the
1116      PC queue registers (apparently they're not valid when the in syscall
1117      bit is set).  */
1118   pc = target_read_pc (inferior_pid);
1119   int_buffer = read_register (FLAGS_REGNUM);
1120   if (int_buffer & 0x2)
1121     {
1122       unsigned int sid;
1123       int_buffer &= ~0x2;
1124       memcpy (inf_status->registers, &int_buffer, 4);
1125       memcpy (inf_status->registers + REGISTER_BYTE (PCOQ_HEAD_REGNUM), &pc, 4);
1126       pc += 4;
1127       memcpy (inf_status->registers + REGISTER_BYTE (PCOQ_TAIL_REGNUM), &pc, 4);
1128       pc -= 4;
1129       sid = (pc >> 30) & 0x3;
1130       if (sid == 0)
1131         pcspace = read_register (SR4_REGNUM);
1132       else
1133         pcspace = read_register (SR4_REGNUM + 4 + sid);
1134       memcpy (inf_status->registers + REGISTER_BYTE (PCSQ_HEAD_REGNUM),
1135               &pcspace, 4);
1136       memcpy (inf_status->registers + REGISTER_BYTE (PCSQ_TAIL_REGNUM),
1137               &pcspace, 4);
1138     }
1139   else
1140     pcspace = read_register (PCSQ_HEAD_REGNUM);
1141
1142   /* Space for "arguments"; the RP goes in here. */
1143   sp = read_register (SP_REGNUM) + 48;
1144   int_buffer = read_register (RP_REGNUM) | 0x3;
1145   write_memory (sp - 20, (char *)&int_buffer, 4);
1146
1147   int_buffer = read_register (FP_REGNUM);
1148   write_memory (sp, (char *)&int_buffer, 4);
1149
1150   write_register (FP_REGNUM, sp);
1151
1152   sp += 8;
1153
1154   for (regnum = 1; regnum < 32; regnum++)
1155     if (regnum != RP_REGNUM && regnum != FP_REGNUM)
1156       sp = push_word (sp, read_register (regnum));
1157
1158   sp += 4;
1159
1160   for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
1161     {
1162       read_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
1163       sp = push_bytes (sp, (char *)&freg_buffer, 8);
1164     }
1165   sp = push_word (sp, read_register (IPSW_REGNUM));
1166   sp = push_word (sp, read_register (SAR_REGNUM));
1167   sp = push_word (sp, pc);
1168   sp = push_word (sp, pcspace);
1169   sp = push_word (sp, pc + 4);
1170   sp = push_word (sp, pcspace);
1171   write_register (SP_REGNUM, sp);
1172 }
1173
1174 void
1175 find_dummy_frame_regs (frame, frame_saved_regs)
1176      struct frame_info *frame;
1177      struct frame_saved_regs *frame_saved_regs;
1178 {
1179   CORE_ADDR fp = frame->frame;
1180   int i;
1181
1182   frame_saved_regs->regs[RP_REGNUM] = fp - 20 & ~0x3;
1183   frame_saved_regs->regs[FP_REGNUM] = fp;
1184   frame_saved_regs->regs[1] = fp + 8;
1185
1186   for (fp += 12, i = 3; i < 32; i++)
1187     {
1188       if (i != FP_REGNUM)
1189         {
1190           frame_saved_regs->regs[i] = fp;
1191           fp += 4;
1192         }
1193     }
1194
1195   fp += 4;
1196   for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
1197     frame_saved_regs->regs[i] = fp;
1198
1199   frame_saved_regs->regs[IPSW_REGNUM] = fp;
1200   frame_saved_regs->regs[SAR_REGNUM] = fp + 4;
1201   frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 8;
1202   frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 12;
1203   frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 16;
1204   frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 20;
1205 }
1206
1207 void
1208 hppa_pop_frame ()
1209 {
1210   register struct frame_info *frame = get_current_frame ();
1211   register CORE_ADDR fp, npc, target_pc;
1212   register int regnum;
1213   struct frame_saved_regs fsr;
1214   double freg_buffer;
1215
1216   fp = FRAME_FP (frame);
1217   get_frame_saved_regs (frame, &fsr);
1218
1219 #ifndef NO_PC_SPACE_QUEUE_RESTORE
1220   if (fsr.regs[IPSW_REGNUM])    /* Restoring a call dummy frame */
1221     restore_pc_queue (&fsr);
1222 #endif
1223
1224   for (regnum = 31; regnum > 0; regnum--)
1225     if (fsr.regs[regnum])
1226       write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
1227
1228   for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM ; regnum--)
1229     if (fsr.regs[regnum])
1230       {
1231         read_memory (fsr.regs[regnum], (char *)&freg_buffer, 8);
1232         write_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
1233       }
1234
1235   if (fsr.regs[IPSW_REGNUM])
1236     write_register (IPSW_REGNUM,
1237                     read_memory_integer (fsr.regs[IPSW_REGNUM], 4));
1238
1239   if (fsr.regs[SAR_REGNUM])
1240     write_register (SAR_REGNUM,
1241                     read_memory_integer (fsr.regs[SAR_REGNUM], 4));
1242
1243   /* If the PC was explicitly saved, then just restore it.  */
1244   if (fsr.regs[PCOQ_TAIL_REGNUM])
1245     {
1246       npc = read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM], 4);
1247       write_register (PCOQ_TAIL_REGNUM, npc);
1248     }
1249   /* Else use the value in %rp to set the new PC.  */
1250   else
1251     {
1252       npc = read_register (RP_REGNUM);
1253       target_write_pc (npc, 0);
1254     }
1255
1256   write_register (FP_REGNUM, read_memory_integer (fp, 4));
1257
1258   if (fsr.regs[IPSW_REGNUM])    /* call dummy */
1259     write_register (SP_REGNUM, fp - 48);
1260   else
1261     write_register (SP_REGNUM, fp);
1262
1263   /* The PC we just restored may be inside a return trampoline.  If so
1264      we want to restart the inferior and run it through the trampoline.
1265
1266      Do this by setting a momentary breakpoint at the location the
1267      trampoline returns to.
1268
1269      Don't skip through the trampoline if we're popping a dummy frame.  */
1270   target_pc = SKIP_TRAMPOLINE_CODE (npc & ~0x3) & ~0x3;
1271   if (target_pc && !fsr.regs[IPSW_REGNUM])
1272     {
1273       struct symtab_and_line sal;
1274       struct breakpoint *breakpoint;
1275       struct cleanup *old_chain;
1276
1277       /* Set up our breakpoint.   Set it to be silent as the MI code
1278          for "return_command" will print the frame we returned to.  */
1279       sal = find_pc_line (target_pc, 0);
1280       sal.pc = target_pc;
1281       breakpoint = set_momentary_breakpoint (sal, NULL, bp_finish);
1282       breakpoint->silent = 1;
1283
1284       /* So we can clean things up.  */
1285       old_chain = make_cleanup (delete_breakpoint, breakpoint);
1286
1287       /* Start up the inferior.  */
1288       proceed_to_finish = 1;
1289       proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
1290
1291       /* Perform our cleanups.  */
1292       do_cleanups (old_chain);
1293     }
1294   flush_cached_frames ();
1295 }
1296
1297 /*
1298  * After returning to a dummy on the stack, restore the instruction
1299  * queue space registers. */
1300
1301 static int
1302 restore_pc_queue (fsr)
1303      struct frame_saved_regs *fsr;
1304 {
1305   CORE_ADDR pc = read_pc ();
1306   CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM], 4);
1307   struct target_waitstatus w;
1308   int insn_count;
1309
1310   /* Advance past break instruction in the call dummy. */
1311   write_register (PCOQ_HEAD_REGNUM, pc + 4);
1312   write_register (PCOQ_TAIL_REGNUM, pc + 8);
1313
1314   /*
1315    * HPUX doesn't let us set the space registers or the space
1316    * registers of the PC queue through ptrace. Boo, hiss.
1317    * Conveniently, the call dummy has this sequence of instructions
1318    * after the break:
1319    *    mtsp r21, sr0
1320    *    ble,n 0(sr0, r22)
1321    *
1322    * So, load up the registers and single step until we are in the
1323    * right place.
1324    */
1325
1326   write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM], 4));
1327   write_register (22, new_pc);
1328
1329   for (insn_count = 0; insn_count < 3; insn_count++)
1330     {
1331       /* FIXME: What if the inferior gets a signal right now?  Want to
1332          merge this into wait_for_inferior (as a special kind of
1333          watchpoint?  By setting a breakpoint at the end?  Is there
1334          any other choice?  Is there *any* way to do this stuff with
1335          ptrace() or some equivalent?).  */
1336       resume (1, 0);
1337       target_wait (inferior_pid, &w);
1338
1339       if (w.kind == TARGET_WAITKIND_SIGNALLED)
1340         {
1341           stop_signal = w.value.sig;
1342           terminal_ours_for_output ();
1343           printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
1344                              target_signal_to_name (stop_signal),
1345                              target_signal_to_string (stop_signal));
1346           gdb_flush (gdb_stdout);
1347           return 0;
1348         }
1349     }
1350   target_terminal_ours ();
1351   target_fetch_registers (-1);
1352   return 1;
1353 }
1354
1355 CORE_ADDR
1356 hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
1357      int nargs;
1358      value_ptr *args;
1359      CORE_ADDR sp;
1360      int struct_return;
1361      CORE_ADDR struct_addr;
1362 {
1363   /* array of arguments' offsets */
1364   int *offset = (int *)alloca(nargs * sizeof (int));
1365   int cum = 0;
1366   int i, alignment;
1367
1368   for (i = 0; i < nargs; i++)
1369     {
1370       cum += TYPE_LENGTH (VALUE_TYPE (args[i]));
1371
1372     /* value must go at proper alignment. Assume alignment is a
1373          power of two.*/
1374       alignment = hppa_alignof (VALUE_TYPE (args[i]));
1375       if (cum % alignment)
1376         cum = (cum + alignment) & -alignment;
1377       offset[i] = -cum;
1378     }
1379   sp += max ((cum + 7) & -8, 16);
1380
1381   for (i = 0; i < nargs; i++)
1382     write_memory (sp + offset[i], VALUE_CONTENTS (args[i]),
1383                   TYPE_LENGTH (VALUE_TYPE (args[i])));
1384
1385   if (struct_return)
1386     write_register (28, struct_addr);
1387   return sp + 32;
1388 }
1389
1390 /*
1391  * Insert the specified number of args and function address
1392  * into a call sequence of the above form stored at DUMMYNAME.
1393  *
1394  * On the hppa we need to call the stack dummy through $$dyncall.
1395  * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
1396  * real_pc, which is the location where gdb should start up the
1397  * inferior to do the function call.
1398  */
1399
1400 CORE_ADDR
1401 hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
1402      char *dummy;
1403      CORE_ADDR pc;
1404      CORE_ADDR fun;
1405      int nargs;
1406      value_ptr *args;
1407      struct type *type;
1408      int gcc_p;
1409 {
1410   CORE_ADDR dyncall_addr;
1411   struct minimal_symbol *msymbol;
1412   int flags = read_register (FLAGS_REGNUM);
1413   struct unwind_table_entry *u;
1414
1415   msymbol = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
1416   if (msymbol == NULL)
1417     error ("Can't find an address for $$dyncall trampoline");
1418
1419   dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1420
1421   /* FUN could be a procedure label, in which case we have to get
1422      its real address and the value of its GOT/DP.  */
1423   if (fun & 0x2)
1424     {
1425       /* Get the GOT/DP value for the target function.  It's
1426          at *(fun+4).  Note the call dummy is *NOT* allowed to
1427          trash %r19 before calling the target function.  */
1428       write_register (19, read_memory_integer ((fun & ~0x3) + 4, 4));
1429
1430       /* Now get the real address for the function we are calling, it's
1431          at *fun.  */
1432       fun = (CORE_ADDR) read_memory_integer (fun & ~0x3, 4);
1433     }
1434   else
1435     {
1436
1437 #ifndef GDB_TARGET_IS_PA_ELF
1438       /* FUN could be either an export stub, or the real address of a
1439          function in a shared library.  We must call an import stub
1440          rather than the export stub or real function for lazy binding
1441          to work correctly.  */
1442       if (som_solib_get_got_by_pc (fun))
1443         {
1444           struct objfile *objfile;
1445           struct minimal_symbol *funsymbol, *stub_symbol;
1446           CORE_ADDR newfun = 0;
1447
1448           funsymbol = lookup_minimal_symbol_by_pc (fun);
1449           if (!funsymbol)
1450             error ("Unable to find minimal symbol for target fucntion.\n");
1451
1452           /* Search all the object files for an import symbol with the
1453              right name. */
1454           ALL_OBJFILES (objfile)
1455             {
1456               stub_symbol = lookup_minimal_symbol (SYMBOL_NAME (funsymbol),
1457                                                    NULL, objfile);
1458               /* Found a symbol with the right name.  */
1459               if (stub_symbol)
1460                 {
1461                   struct unwind_table_entry *u;
1462                   /* It must be a shared library trampoline.  */
1463                   if (SYMBOL_TYPE (stub_symbol) != mst_solib_trampoline)
1464                     continue;
1465
1466                   /* It must also be an import stub.  */
1467                   u = find_unwind_entry (SYMBOL_VALUE (stub_symbol));
1468                   if (!u || u->stub_type != IMPORT)
1469                     continue;
1470
1471                   /* OK.  Looks like the correct import stub.  */
1472                   newfun = SYMBOL_VALUE (stub_symbol);
1473                   fun = newfun;
1474                 }
1475             }
1476           if (newfun == 0)
1477             write_register (19, som_solib_get_got_by_pc (fun));
1478         }
1479 #endif
1480     }
1481
1482   /* If we are calling an import stub (eg calling into a dynamic library)
1483      then have sr4export call the magic __d_plt_call routine which is linked
1484      in from end.o.  (You can't use _sr4export to call the import stub as
1485      the value in sp-24 will get fried and you end up returning to the
1486      wrong location.  You can't call the import stub directly as the code
1487      to bind the PLT entry to a function can't return to a stack address.)  */
1488   u = find_unwind_entry (fun);
1489   if (u && u->stub_type == IMPORT)
1490     {
1491       CORE_ADDR new_fun;
1492       msymbol = lookup_minimal_symbol ("__d_plt_call", NULL, NULL);
1493       if (msymbol == NULL)
1494         msymbol = lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL);
1495
1496       if (msymbol == NULL)
1497         error ("Can't find an address for __d_plt_call or __gcc_plt_call trampoline");
1498
1499       /* This is where sr4export will jump to.  */
1500       new_fun = SYMBOL_VALUE_ADDRESS (msymbol);
1501
1502       if (strcmp (SYMBOL_NAME (msymbol), "__d_plt_call"))
1503         write_register (22, fun);
1504       else
1505         {
1506           /* We have to store the address of the stub in __shlib_funcptr.  */
1507           msymbol = lookup_minimal_symbol ("__shlib_funcptr", NULL,
1508                                            (struct objfile *)NULL);
1509           if (msymbol == NULL)
1510             error ("Can't find an address for __shlib_funcptr");
1511
1512           target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol), (char *)&fun, 4);
1513         }
1514       fun = new_fun;
1515     }
1516
1517 /* Store upper 21 bits of function address into ldil */
1518
1519   store_unsigned_integer
1520     (&dummy[FUNC_LDIL_OFFSET],
1521      INSTRUCTION_SIZE,
1522      deposit_21 (fun >> 11,
1523                  extract_unsigned_integer (&dummy[FUNC_LDIL_OFFSET],
1524                                            INSTRUCTION_SIZE)));
1525
1526 /* Store lower 11 bits of function address into ldo */
1527
1528   store_unsigned_integer
1529     (&dummy[FUNC_LDO_OFFSET],
1530      INSTRUCTION_SIZE,
1531      deposit_14 (fun & MASK_11,
1532                  extract_unsigned_integer (&dummy[FUNC_LDO_OFFSET],
1533                                            INSTRUCTION_SIZE)));
1534 #ifdef SR4EXPORT_LDIL_OFFSET
1535
1536   {
1537     CORE_ADDR sr4export_addr;
1538
1539     /* We still need sr4export's address too.  */
1540
1541     msymbol = lookup_minimal_symbol ("_sr4export", NULL, NULL);
1542     if (msymbol == NULL)
1543       error ("Can't find an address for _sr4export trampoline");
1544
1545     sr4export_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1546
1547 /* Store upper 21 bits of sr4export's address into ldil */
1548
1549     store_unsigned_integer
1550       (&dummy[SR4EXPORT_LDIL_OFFSET],
1551        INSTRUCTION_SIZE,
1552        deposit_21 (sr4export_addr >> 11,
1553                    extract_unsigned_integer (&dummy[SR4EXPORT_LDIL_OFFSET],
1554                                              INSTRUCTION_SIZE)));
1555 /* Store lower 11 bits of sr4export's address into ldo */
1556
1557     store_unsigned_integer
1558       (&dummy[SR4EXPORT_LDO_OFFSET],
1559        INSTRUCTION_SIZE,
1560        deposit_14 (sr4export_addr & MASK_11,
1561                    extract_unsigned_integer (&dummy[SR4EXPORT_LDO_OFFSET],
1562                                              INSTRUCTION_SIZE)));
1563   }
1564 #endif
1565
1566   write_register (22, pc);
1567
1568   /* If we are in a syscall, then we should call the stack dummy
1569      directly.  $$dyncall is not needed as the kernel sets up the
1570      space id registers properly based on the value in %r31.  In
1571      fact calling $$dyncall will not work because the value in %r22
1572      will be clobbered on the syscall exit path.
1573
1574      Similarly if the current PC is in a shared library.  Note however,
1575      this scheme won't work if the shared library isn't mapped into
1576      the same space as the stack.  */
1577   if (flags & 2)
1578     return pc;
1579 #ifndef GDB_TARGET_IS_PA_ELF
1580   else if (som_solib_get_got_by_pc (target_read_pc (inferior_pid)))
1581     return pc;
1582 #endif
1583   else
1584     return dyncall_addr;
1585
1586 }
1587
1588 /* Get the PC from %r31 if currently in a syscall.  Also mask out privilege
1589    bits.  */
1590
1591 CORE_ADDR
1592 target_read_pc (pid)
1593      int pid;
1594 {
1595   int flags = read_register (FLAGS_REGNUM);
1596
1597   if (flags & 2) {
1598     return read_register (31) & ~0x3;
1599   }
1600   return read_register (PC_REGNUM) & ~0x3;
1601 }
1602
1603 /* Write out the PC.  If currently in a syscall, then also write the new
1604    PC value into %r31.  */
1605
1606 void
1607 target_write_pc (v, pid)
1608      CORE_ADDR v;
1609      int pid;
1610 {
1611   int flags = read_register (FLAGS_REGNUM);
1612
1613   /* If in a syscall, then set %r31.  Also make sure to get the
1614      privilege bits set correctly.  */
1615   if (flags & 2)
1616     write_register (31, (long) (v | 0x3));
1617
1618   write_register (PC_REGNUM, (long) v);
1619   write_register (NPC_REGNUM, (long) v + 4);
1620 }
1621
1622 /* return the alignment of a type in bytes. Structures have the maximum
1623    alignment required by their fields. */
1624
1625 static int
1626 hppa_alignof (arg)
1627      struct type *arg;
1628 {
1629   int max_align, align, i;
1630   switch (TYPE_CODE (arg))
1631     {
1632     case TYPE_CODE_PTR:
1633     case TYPE_CODE_INT:
1634     case TYPE_CODE_FLT:
1635       return TYPE_LENGTH (arg);
1636     case TYPE_CODE_ARRAY:
1637       return hppa_alignof (TYPE_FIELD_TYPE (arg, 0));
1638     case TYPE_CODE_STRUCT:
1639     case TYPE_CODE_UNION:
1640       max_align = 2;
1641       for (i = 0; i < TYPE_NFIELDS (arg); i++)
1642         {
1643           /* Bit fields have no real alignment. */
1644           if (!TYPE_FIELD_BITPOS (arg, i))
1645             {
1646               align = hppa_alignof (TYPE_FIELD_TYPE (arg, i));
1647               max_align = max (max_align, align);
1648             }
1649         }
1650       return max_align;
1651     default:
1652       return 4;
1653     }
1654 }
1655
1656 /* Print the register regnum, or all registers if regnum is -1 */
1657
1658 void
1659 pa_do_registers_info (regnum, fpregs)
1660      int regnum;
1661      int fpregs;
1662 {
1663   char raw_regs [REGISTER_BYTES];
1664   int i;
1665
1666   for (i = 0; i < NUM_REGS; i++)
1667     read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
1668   if (regnum == -1)
1669     pa_print_registers (raw_regs, regnum, fpregs);
1670   else if (regnum < FP0_REGNUM)
1671     printf_unfiltered ("%s %x\n", reg_names[regnum], *(long *)(raw_regs +
1672                                                     REGISTER_BYTE (regnum)));
1673   else
1674     pa_print_fp_reg (regnum);
1675 }
1676
1677 static void
1678 pa_print_registers (raw_regs, regnum, fpregs)
1679      char *raw_regs;
1680      int regnum;
1681      int fpregs;
1682 {
1683   int i,j;
1684   long val;
1685
1686   for (i = 0; i < 18; i++)
1687     {
1688       for (j = 0; j < 4; j++)
1689         {
1690           val =
1691             extract_signed_integer (raw_regs + REGISTER_BYTE (i+(j*18)), 4);
1692           printf_unfiltered ("%8.8s: %8x  ", reg_names[i+(j*18)], val);
1693         }
1694       printf_unfiltered ("\n");
1695     }
1696
1697   if (fpregs)
1698     for (i = 72; i < NUM_REGS; i++)
1699       pa_print_fp_reg (i);
1700 }
1701
1702 static void
1703 pa_print_fp_reg (i)
1704      int i;
1705 {
1706   unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
1707   unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
1708
1709   /* Get 32bits of data.  */
1710   read_relative_register_raw_bytes (i, raw_buffer);
1711
1712   /* Put it in the buffer.  No conversions are ever necessary.  */
1713   memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i));
1714
1715   fputs_filtered (reg_names[i], gdb_stdout);
1716   print_spaces_filtered (8 - strlen (reg_names[i]), gdb_stdout);
1717   fputs_filtered ("(single precision)     ", gdb_stdout);
1718
1719   val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, gdb_stdout, 0,
1720              1, 0, Val_pretty_default);
1721   printf_filtered ("\n");
1722
1723   /* If "i" is even, then this register can also be a double-precision
1724      FP register.  Dump it out as such.  */
1725   if ((i % 2) == 0)
1726     {
1727       /* Get the data in raw format for the 2nd half.  */
1728       read_relative_register_raw_bytes (i + 1, raw_buffer);
1729
1730       /* Copy it into the appropriate part of the virtual buffer.  */
1731       memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buffer,
1732               REGISTER_RAW_SIZE (i));
1733
1734       /* Dump it as a double.  */
1735       fputs_filtered (reg_names[i], gdb_stdout);
1736       print_spaces_filtered (8 - strlen (reg_names[i]), gdb_stdout);
1737       fputs_filtered ("(double precision)     ", gdb_stdout);
1738
1739       val_print (builtin_type_double, virtual_buffer, 0, gdb_stdout, 0,
1740                  1, 0, Val_pretty_default);
1741       printf_filtered ("\n");
1742     }
1743 }
1744
1745 /* Return one if PC is in the call path of a trampoline, else return zero.
1746
1747    Note we return one for *any* call trampoline (long-call, arg-reloc), not
1748    just shared library trampolines (import, export).  */
1749
1750 int
1751 in_solib_call_trampoline (pc, name)
1752      CORE_ADDR pc;
1753      char *name;
1754 {
1755   struct minimal_symbol *minsym;
1756   struct unwind_table_entry *u;
1757   static CORE_ADDR dyncall = 0;
1758   static CORE_ADDR sr4export = 0;
1759
1760 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
1761    new exec file */
1762
1763   /* First see if PC is in one of the two C-library trampolines.  */
1764   if (!dyncall)
1765     {
1766       minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
1767       if (minsym)
1768         dyncall = SYMBOL_VALUE_ADDRESS (minsym);
1769       else
1770         dyncall = -1;
1771     }
1772
1773   if (!sr4export)
1774     {
1775       minsym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
1776       if (minsym)
1777         sr4export = SYMBOL_VALUE_ADDRESS (minsym);
1778       else
1779         sr4export = -1;
1780     }
1781
1782   if (pc == dyncall || pc == sr4export)
1783     return 1;
1784
1785   /* Get the unwind descriptor corresponding to PC, return zero
1786      if no unwind was found.  */
1787   u = find_unwind_entry (pc);
1788   if (!u)
1789     return 0;
1790
1791   /* If this isn't a linker stub, then return now.  */
1792   if (u->stub_type == 0)
1793     return 0;
1794
1795   /* By definition a long-branch stub is a call stub.  */
1796   if (u->stub_type == LONG_BRANCH)
1797     return 1;
1798
1799   /* The call and return path execute the same instructions within
1800      an IMPORT stub!  So an IMPORT stub is both a call and return
1801      trampoline.  */
1802   if (u->stub_type == IMPORT)
1803     return 1;
1804
1805   /* Parameter relocation stubs always have a call path and may have a
1806      return path.  */
1807   if (u->stub_type == PARAMETER_RELOCATION
1808       || u->stub_type == EXPORT)
1809     {
1810       CORE_ADDR addr;
1811
1812       /* Search forward from the current PC until we hit a branch
1813          or the end of the stub.  */
1814       for (addr = pc; addr <= u->region_end; addr += 4)
1815         {
1816           unsigned long insn;
1817
1818           insn = read_memory_integer (addr, 4);
1819
1820           /* Does it look like a bl?  If so then it's the call path, if
1821              we find a bv or be first, then we're on the return path.  */
1822           if ((insn & 0xfc00e000) == 0xe8000000)
1823             return 1;
1824           else if ((insn & 0xfc00e001) == 0xe800c000
1825                    || (insn & 0xfc000000) == 0xe0000000)
1826             return 0;
1827         }
1828
1829       /* Should never happen.  */
1830       warning ("Unable to find branch in parameter relocation stub.\n");
1831       return 0;
1832     }
1833
1834   /* Unknown stub type.  For now, just return zero.  */
1835   return 0;
1836 }
1837
1838 /* Return one if PC is in the return path of a trampoline, else return zero.
1839
1840    Note we return one for *any* call trampoline (long-call, arg-reloc), not
1841    just shared library trampolines (import, export).  */
1842
1843 int
1844 in_solib_return_trampoline (pc, name)
1845      CORE_ADDR pc;
1846      char *name;
1847 {
1848   struct unwind_table_entry *u;
1849
1850   /* Get the unwind descriptor corresponding to PC, return zero
1851      if no unwind was found.  */
1852   u = find_unwind_entry (pc);
1853   if (!u)
1854     return 0;
1855
1856   /* If this isn't a linker stub or it's just a long branch stub, then
1857      return zero.  */
1858   if (u->stub_type == 0 || u->stub_type == LONG_BRANCH)
1859     return 0;
1860
1861   /* The call and return path execute the same instructions within
1862      an IMPORT stub!  So an IMPORT stub is both a call and return
1863      trampoline.  */
1864   if (u->stub_type == IMPORT)
1865     return 1;
1866
1867   /* Parameter relocation stubs always have a call path and may have a
1868      return path.  */
1869   if (u->stub_type == PARAMETER_RELOCATION
1870       || u->stub_type == EXPORT)
1871     {
1872       CORE_ADDR addr;
1873
1874       /* Search forward from the current PC until we hit a branch
1875          or the end of the stub.  */
1876       for (addr = pc; addr <= u->region_end; addr += 4)
1877         {
1878           unsigned long insn;
1879
1880           insn = read_memory_integer (addr, 4);
1881
1882           /* Does it look like a bl?  If so then it's the call path, if
1883              we find a bv or be first, then we're on the return path.  */
1884           if ((insn & 0xfc00e000) == 0xe8000000)
1885             return 0;
1886           else if ((insn & 0xfc00e001) == 0xe800c000
1887                    || (insn & 0xfc000000) == 0xe0000000)
1888             return 1;
1889         }
1890
1891       /* Should never happen.  */
1892       warning ("Unable to find branch in parameter relocation stub.\n");
1893       return 0;
1894     }
1895
1896   /* Unknown stub type.  For now, just return zero.  */
1897   return 0;
1898
1899 }
1900
1901 /* Figure out if PC is in a trampoline, and if so find out where
1902    the trampoline will jump to.  If not in a trampoline, return zero.
1903
1904    Simple code examination probably is not a good idea since the code
1905    sequences in trampolines can also appear in user code.
1906
1907    We use unwinds and information from the minimal symbol table to
1908    determine when we're in a trampoline.  This won't work for ELF
1909    (yet) since it doesn't create stub unwind entries.  Whether or
1910    not ELF will create stub unwinds or normal unwinds for linker
1911    stubs is still being debated.
1912
1913    This should handle simple calls through dyncall or sr4export,
1914    long calls, argument relocation stubs, and dyncall/sr4export
1915    calling an argument relocation stub.  It even handles some stubs
1916    used in dynamic executables.  */
1917
1918 CORE_ADDR
1919 skip_trampoline_code (pc, name)
1920      CORE_ADDR pc;
1921      char *name;
1922 {
1923   long orig_pc = pc;
1924   long prev_inst, curr_inst, loc;
1925   static CORE_ADDR dyncall = 0;
1926   static CORE_ADDR sr4export = 0;
1927   struct minimal_symbol *msym;
1928   struct unwind_table_entry *u;
1929
1930 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
1931    new exec file */
1932
1933   if (!dyncall)
1934     {
1935       msym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
1936       if (msym)
1937         dyncall = SYMBOL_VALUE_ADDRESS (msym);
1938       else
1939         dyncall = -1;
1940     }
1941
1942   if (!sr4export)
1943     {
1944       msym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
1945       if (msym)
1946         sr4export = SYMBOL_VALUE_ADDRESS (msym);
1947       else
1948         sr4export = -1;
1949     }
1950
1951   /* Addresses passed to dyncall may *NOT* be the actual address
1952      of the function.  So we may have to do something special.  */
1953   if (pc == dyncall)
1954     {
1955       pc = (CORE_ADDR) read_register (22);
1956
1957       /* If bit 30 (counting from the left) is on, then pc is the address of
1958          the PLT entry for this function, not the address of the function
1959          itself.  Bit 31 has meaning too, but only for MPE.  */
1960       if (pc & 0x2)
1961         pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, 4);
1962     }
1963   else if (pc == sr4export)
1964     pc = (CORE_ADDR) (read_register (22));
1965
1966   /* Get the unwind descriptor corresponding to PC, return zero
1967      if no unwind was found.  */
1968   u = find_unwind_entry (pc);
1969   if (!u)
1970     return 0;
1971
1972   /* If this isn't a linker stub, then return now.  */
1973   if (u->stub_type == 0)
1974     return orig_pc == pc ? 0 : pc & ~0x3;
1975
1976   /* It's a stub.  Search for a branch and figure out where it goes.
1977      Note we have to handle multi insn branch sequences like ldil;ble.
1978      Most (all?) other branches can be determined by examining the contents
1979      of certain registers and the stack.  */
1980   loc = pc;
1981   curr_inst = 0;
1982   prev_inst = 0;
1983   while (1)
1984     {
1985       /* Make sure we haven't walked outside the range of this stub.  */
1986       if (u != find_unwind_entry (loc))
1987         {
1988           warning ("Unable to find branch in linker stub");
1989           return orig_pc == pc ? 0 : pc & ~0x3;
1990         }
1991
1992       prev_inst = curr_inst;
1993       curr_inst = read_memory_integer (loc, 4);
1994
1995       /* Does it look like a branch external using %r1?  Then it's the
1996          branch from the stub to the actual function.  */
1997       if ((curr_inst & 0xffe0e000) == 0xe0202000)
1998         {
1999           /* Yup.  See if the previous instruction loaded
2000              a value into %r1.  If so compute and return the jump address.  */
2001           if ((prev_inst & 0xffe00000) == 0x20200000)
2002             return (extract_21 (prev_inst) + extract_17 (curr_inst)) & ~0x3;
2003           else
2004             {
2005               warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
2006               return orig_pc == pc ? 0 : pc & ~0x3;
2007             }
2008         }
2009
2010       /* Does it look like a be 0(sr0,%r21)?  That's the branch from an
2011          import stub to an export stub.
2012
2013          It is impossible to determine the target of the branch via
2014          simple examination of instructions and/or data (consider
2015          that the address in the plabel may be the address of the
2016          bind-on-reference routine in the dynamic loader).
2017
2018          So we have try an alternative approach.
2019
2020          Get the name of the symbol at our current location; it should
2021          be a stub symbol with the same name as the symbol in the
2022          shared library.
2023
2024          Then lookup a minimal symbol with the same name; we should
2025          get the minimal symbol for the target routine in the shared
2026          library as those take precedence of import/export stubs.  */
2027       if (curr_inst == 0xe2a00000)
2028         {
2029           struct minimal_symbol *stubsym, *libsym;
2030
2031           stubsym = lookup_minimal_symbol_by_pc (loc);
2032           if (stubsym == NULL)
2033             {
2034               warning ("Unable to find symbol for 0x%x", loc);
2035               return orig_pc == pc ? 0 : pc & ~0x3;
2036             }
2037
2038           libsym = lookup_minimal_symbol (SYMBOL_NAME (stubsym), NULL, NULL);
2039           if (libsym == NULL)
2040             {
2041               warning ("Unable to find library symbol for %s\n",
2042                        SYMBOL_NAME (stubsym));
2043               return orig_pc == pc ? 0 : pc & ~0x3;
2044             }
2045
2046           return SYMBOL_VALUE (libsym);
2047         }
2048
2049       /* Does it look like bl X,%rp or bl X,%r0?  Another way to do a
2050          branch from the stub to the actual function.  */
2051       else if ((curr_inst & 0xffe0e000) == 0xe8400000
2052                || (curr_inst & 0xffe0e000) == 0xe8000000)
2053         return (loc + extract_17 (curr_inst) + 8) & ~0x3;
2054
2055       /* Does it look like bv (rp)?   Note this depends on the
2056          current stack pointer being the same as the stack
2057          pointer in the stub itself!  This is a branch on from the
2058          stub back to the original caller.  */
2059       else if ((curr_inst & 0xffe0e000) == 0xe840c000)
2060         {
2061           /* Yup.  See if the previous instruction loaded
2062              rp from sp - 8.  */
2063           if (prev_inst == 0x4bc23ff1)
2064             return (read_memory_integer
2065                     (read_register (SP_REGNUM) - 8, 4)) & ~0x3;
2066           else
2067             {
2068               warning ("Unable to find restore of %%rp before bv (%%rp).");
2069               return orig_pc == pc ? 0 : pc & ~0x3;
2070             }
2071         }
2072
2073       /* What about be,n 0(sr0,%rp)?  It's just another way we return to
2074          the original caller from the stub.  Used in dynamic executables.  */
2075       else if (curr_inst == 0xe0400002)
2076         {
2077           /* The value we jump to is sitting in sp - 24.  But that's
2078              loaded several instructions before the be instruction.
2079              I guess we could check for the previous instruction being
2080              mtsp %r1,%sr0 if we want to do sanity checking.  */
2081           return (read_memory_integer
2082                   (read_register (SP_REGNUM) - 24, 4)) & ~0x3;
2083         }
2084
2085       /* Haven't found the branch yet, but we're still in the stub.
2086          Keep looking.  */
2087       loc += 4;
2088     }
2089 }
2090
2091 /* For the given instruction (INST), return any adjustment it makes
2092    to the stack pointer or zero for no adjustment.
2093
2094    This only handles instructions commonly found in prologues.  */
2095
2096 static int
2097 prologue_inst_adjust_sp (inst)
2098      unsigned long inst;
2099 {
2100   /* This must persist across calls.  */
2101   static int save_high21;
2102
2103   /* The most common way to perform a stack adjustment ldo X(sp),sp */
2104   if ((inst & 0xffffc000) == 0x37de0000)
2105     return extract_14 (inst);
2106
2107   /* stwm X,D(sp) */
2108   if ((inst & 0xffe00000) == 0x6fc00000)
2109     return extract_14 (inst);
2110
2111   /* addil high21,%r1; ldo low11,(%r1),%r30)
2112      save high bits in save_high21 for later use.  */
2113   if ((inst & 0xffe00000) == 0x28200000)
2114     {
2115       save_high21 = extract_21 (inst);
2116       return 0;
2117     }
2118
2119   if ((inst & 0xffff0000) == 0x343e0000)
2120     return save_high21 + extract_14 (inst);
2121
2122   /* fstws as used by the HP compilers.  */
2123   if ((inst & 0xffffffe0) == 0x2fd01220)
2124     return extract_5_load (inst);
2125
2126   /* No adjustment.  */
2127   return 0;
2128 }
2129
2130 /* Return nonzero if INST is a branch of some kind, else return zero.  */
2131
2132 static int
2133 is_branch (inst)
2134      unsigned long inst;
2135 {
2136   switch (inst >> 26)
2137     {
2138     case 0x20:
2139     case 0x21:
2140     case 0x22:
2141     case 0x23:
2142     case 0x28:
2143     case 0x29:
2144     case 0x2a:
2145     case 0x2b:
2146     case 0x30:
2147     case 0x31:
2148     case 0x32:
2149     case 0x33:
2150     case 0x38:
2151     case 0x39:
2152     case 0x3a:
2153       return 1;
2154
2155     default:
2156       return 0;
2157     }
2158 }
2159
2160 /* Return the register number for a GR which is saved by INST or
2161    zero it INST does not save a GR.  */
2162
2163 static int
2164 inst_saves_gr (inst)
2165      unsigned long inst;
2166 {
2167   /* Does it look like a stw?  */
2168   if ((inst >> 26) == 0x1a)
2169     return extract_5R_store (inst);
2170
2171   /* Does it look like a stwm?  GCC & HPC may use this in prologues. */
2172   if ((inst >> 26) == 0x1b)
2173     return extract_5R_store (inst);
2174
2175   /* Does it look like sth or stb?  HPC versions 9.0 and later use these
2176      too.  */
2177   if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18)
2178     return extract_5R_store (inst);
2179
2180   return 0;
2181 }
2182
2183 /* Return the register number for a FR which is saved by INST or
2184    zero it INST does not save a FR.
2185
2186    Note we only care about full 64bit register stores (that's the only
2187    kind of stores the prologue will use).
2188
2189    FIXME: What about argument stores with the HP compiler in ANSI mode? */
2190
2191 static int
2192 inst_saves_fr (inst)
2193      unsigned long inst;
2194 {
2195   if ((inst & 0xfc00dfc0) == 0x2c001200)
2196     return extract_5r_store (inst);
2197   return 0;
2198 }
2199
2200 /* Advance PC across any function entry prologue instructions
2201    to reach some "real" code.
2202
2203    Use information in the unwind table to determine what exactly should
2204    be in the prologue.  */
2205
2206 CORE_ADDR
2207 skip_prologue (pc)
2208      CORE_ADDR pc;
2209 {
2210   char buf[4];
2211   unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
2212   unsigned long args_stored, status, i;
2213   struct unwind_table_entry *u;
2214
2215   u = find_unwind_entry (pc);
2216   if (!u)
2217     return pc;
2218
2219   /* If we are not at the beginning of a function, then return now.  */
2220   if ((pc & ~0x3) != u->region_start)
2221     return pc;
2222
2223   /* This is how much of a frame adjustment we need to account for.  */
2224   stack_remaining = u->Total_frame_size << 3;
2225
2226   /* Magic register saves we want to know about.  */
2227   save_rp = u->Save_RP;
2228   save_sp = u->Save_SP;
2229
2230   /* An indication that args may be stored into the stack.  Unfortunately
2231      the HPUX compilers tend to set this in cases where no args were
2232      stored too!.  */
2233   args_stored = u->Args_stored;
2234
2235   /* Turn the Entry_GR field into a bitmask.  */
2236   save_gr = 0;
2237   for (i = 3; i < u->Entry_GR + 3; i++)
2238     {
2239       /* Frame pointer gets saved into a special location.  */
2240       if (u->Save_SP && i == FP_REGNUM)
2241         continue;
2242
2243       save_gr |= (1 << i);
2244     }
2245
2246   /* Turn the Entry_FR field into a bitmask too.  */
2247   save_fr = 0;
2248   for (i = 12; i < u->Entry_FR + 12; i++)
2249     save_fr |= (1 << i);
2250
2251   /* Loop until we find everything of interest or hit a branch.
2252
2253      For unoptimized GCC code and for any HP CC code this will never ever
2254      examine any user instructions.
2255
2256      For optimzied GCC code we're faced with problems.  GCC will schedule
2257      its prologue and make prologue instructions available for delay slot
2258      filling.  The end result is user code gets mixed in with the prologue
2259      and a prologue instruction may be in the delay slot of the first branch
2260      or call.
2261
2262      Some unexpected things are expected with debugging optimized code, so
2263      we allow this routine to walk past user instructions in optimized
2264      GCC code.  */
2265   while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
2266          || args_stored)
2267     {
2268       unsigned int reg_num;
2269       unsigned long old_stack_remaining, old_save_gr, old_save_fr;
2270       unsigned long old_save_rp, old_save_sp, next_inst;
2271
2272       /* Save copies of all the triggers so we can compare them later
2273          (only for HPC).  */
2274       old_save_gr = save_gr;
2275       old_save_fr = save_fr;
2276       old_save_rp = save_rp;
2277       old_save_sp = save_sp;
2278       old_stack_remaining = stack_remaining;
2279
2280       status = target_read_memory (pc, buf, 4);
2281       inst = extract_unsigned_integer (buf, 4);
2282
2283       /* Yow! */
2284       if (status != 0)
2285         return pc;
2286
2287       /* Note the interesting effects of this instruction.  */
2288       stack_remaining -= prologue_inst_adjust_sp (inst);
2289
2290       /* There is only one instruction used for saving RP into the stack.  */
2291       if (inst == 0x6bc23fd9)
2292         save_rp = 0;
2293
2294       /* This is the only way we save SP into the stack.  At this time
2295          the HP compilers never bother to save SP into the stack.  */
2296       if ((inst & 0xffffc000) == 0x6fc10000)
2297         save_sp = 0;
2298
2299       /* Account for general and floating-point register saves.  */
2300       reg_num = inst_saves_gr (inst);
2301       save_gr &= ~(1 << reg_num);
2302
2303       /* Ugh.  Also account for argument stores into the stack.
2304          Unfortunately args_stored only tells us that some arguments
2305          where stored into the stack.  Not how many or what kind!
2306
2307          This is a kludge as on the HP compiler sets this bit and it
2308          never does prologue scheduling.  So once we see one, skip past
2309          all of them.   We have similar code for the fp arg stores below.
2310
2311          FIXME.  Can still die if we have a mix of GR and FR argument
2312          stores!  */
2313       if (reg_num >= 23 && reg_num <= 26)
2314         {
2315           while (reg_num >= 23 && reg_num <= 26)
2316             {
2317               pc += 4;
2318               status = target_read_memory (pc, buf, 4);
2319               inst = extract_unsigned_integer (buf, 4);
2320               if (status != 0)
2321                 return pc;
2322               reg_num = inst_saves_gr (inst);
2323             }
2324           args_stored = 0;
2325           continue;
2326         }
2327
2328       reg_num = inst_saves_fr (inst);
2329       save_fr &= ~(1 << reg_num);
2330
2331       status = target_read_memory (pc + 4, buf, 4);
2332       next_inst = extract_unsigned_integer (buf, 4);
2333
2334       /* Yow! */
2335       if (status != 0)
2336         return pc;
2337
2338       /* We've got to be read to handle the ldo before the fp register
2339          save.  */
2340       if ((inst & 0xfc000000) == 0x34000000
2341           && inst_saves_fr (next_inst) >= 4
2342           && inst_saves_fr (next_inst) <= 7)
2343         {
2344           /* So we drop into the code below in a reasonable state.  */
2345           reg_num = inst_saves_fr (next_inst);
2346           pc -= 4;
2347         }
2348
2349       /* Ugh.  Also account for argument stores into the stack.
2350          This is a kludge as on the HP compiler sets this bit and it
2351          never does prologue scheduling.  So once we see one, skip past
2352          all of them.  */
2353       if (reg_num >= 4 && reg_num <= 7)
2354         {
2355           while (reg_num >= 4 && reg_num <= 7)
2356             {
2357               pc += 8;
2358               status = target_read_memory (pc, buf, 4);
2359               inst = extract_unsigned_integer (buf, 4);
2360               if (status != 0)
2361                 return pc;
2362               if ((inst & 0xfc000000) != 0x34000000)
2363                 break;
2364               status = target_read_memory (pc + 4, buf, 4);
2365               next_inst = extract_unsigned_integer (buf, 4);
2366               if (status != 0)
2367                 return pc;
2368               reg_num = inst_saves_fr (next_inst);
2369             }
2370           args_stored = 0;
2371           continue;
2372         }
2373
2374       /* Quit if we hit any kind of branch.  This can happen if a prologue
2375          instruction is in the delay slot of the first call/branch.  */
2376       if (is_branch (inst))
2377         break;
2378
2379       /* What a crock.  The HP compilers set args_stored even if no
2380          arguments were stored into the stack (boo hiss).  This could
2381          cause this code to then skip a bunch of user insns (up to the
2382          first branch).
2383
2384          To combat this we try to identify when args_stored was bogusly
2385          set and clear it.   We only do this when args_stored is nonzero,
2386          all other resources are accounted for, and nothing changed on
2387          this pass.  */
2388       if (args_stored
2389           && ! (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
2390           && old_save_gr == save_gr && old_save_fr == save_fr
2391           && old_save_rp == save_rp && old_save_sp == save_sp
2392           && old_stack_remaining == stack_remaining)
2393         break;
2394
2395       /* Bump the PC.  */
2396       pc += 4;
2397     }
2398
2399   return pc;
2400 }
2401
2402 /* Put here the code to store, into a struct frame_saved_regs,
2403    the addresses of the saved registers of frame described by FRAME_INFO.
2404    This includes special registers such as pc and fp saved in special
2405    ways in the stack frame.  sp is even more special:
2406    the address we return for it IS the sp for the next frame.  */
2407
2408 void
2409 hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
2410      struct frame_info *frame_info;
2411      struct frame_saved_regs *frame_saved_regs;
2412 {
2413   CORE_ADDR pc;
2414   struct unwind_table_entry *u;
2415   unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
2416   int status, i, reg;
2417   char buf[4];
2418   int fp_loc = -1;
2419
2420   /* Zero out everything.  */
2421   memset (frame_saved_regs, '\0', sizeof (struct frame_saved_regs));
2422
2423   /* Call dummy frames always look the same, so there's no need to
2424      examine the dummy code to determine locations of saved registers;
2425      instead, let find_dummy_frame_regs fill in the correct offsets
2426      for the saved registers.  */
2427   if ((frame_info->pc >= frame_info->frame
2428        && frame_info->pc <= (frame_info->frame + CALL_DUMMY_LENGTH
2429                              + 32 * 4 +  (NUM_REGS - FP0_REGNUM) * 8
2430                              + 6 * 4)))
2431     find_dummy_frame_regs (frame_info, frame_saved_regs);
2432
2433   /* Interrupt handlers are special too.  They lay out the register
2434      state in the exact same order as the register numbers in GDB.  */
2435   if (pc_in_interrupt_handler (frame_info->pc))
2436     {
2437       for (i = 0; i < NUM_REGS; i++)
2438         {
2439           /* SP is a little special.  */
2440           if (i == SP_REGNUM)
2441             frame_saved_regs->regs[SP_REGNUM]
2442               = read_memory_integer (frame_info->frame + SP_REGNUM * 4, 4);
2443           else
2444             frame_saved_regs->regs[i] = frame_info->frame + i * 4;
2445         }
2446       return;
2447     }
2448
2449 #ifdef FRAME_FIND_SAVED_REGS_IN_SIGTRAMP
2450   /* Handle signal handler callers.  */
2451   if (frame_info->signal_handler_caller)
2452     {
2453       FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info, frame_saved_regs);
2454       return;
2455     }
2456 #endif
2457
2458   /* Get the starting address of the function referred to by the PC
2459      saved in frame.  */
2460   pc = get_pc_function_start (frame_info->pc);
2461
2462   /* Yow! */
2463   u = find_unwind_entry (pc);
2464   if (!u)
2465     return;
2466
2467   /* This is how much of a frame adjustment we need to account for.  */
2468   stack_remaining = u->Total_frame_size << 3;
2469
2470   /* Magic register saves we want to know about.  */
2471   save_rp = u->Save_RP;
2472   save_sp = u->Save_SP;
2473
2474   /* Turn the Entry_GR field into a bitmask.  */
2475   save_gr = 0;
2476   for (i = 3; i < u->Entry_GR + 3; i++)
2477     {
2478       /* Frame pointer gets saved into a special location.  */
2479       if (u->Save_SP && i == FP_REGNUM)
2480         continue;
2481
2482       save_gr |= (1 << i);
2483     }
2484
2485   /* Turn the Entry_FR field into a bitmask too.  */
2486   save_fr = 0;
2487   for (i = 12; i < u->Entry_FR + 12; i++)
2488     save_fr |= (1 << i);
2489
2490   /* The frame always represents the value of %sp at entry to the
2491      current function (and is thus equivalent to the "saved" stack
2492      pointer.  */
2493   frame_saved_regs->regs[SP_REGNUM] = frame_info->frame;
2494
2495   /* Loop until we find everything of interest or hit a branch.
2496
2497      For unoptimized GCC code and for any HP CC code this will never ever
2498      examine any user instructions.
2499
2500      For optimzied GCC code we're faced with problems.  GCC will schedule
2501      its prologue and make prologue instructions available for delay slot
2502      filling.  The end result is user code gets mixed in with the prologue
2503      and a prologue instruction may be in the delay slot of the first branch
2504      or call.
2505
2506      Some unexpected things are expected with debugging optimized code, so
2507      we allow this routine to walk past user instructions in optimized
2508      GCC code.  */
2509   while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
2510     {
2511       status = target_read_memory (pc, buf, 4);
2512       inst = extract_unsigned_integer (buf, 4);
2513
2514       /* Yow! */
2515       if (status != 0)
2516         return;
2517
2518       /* Note the interesting effects of this instruction.  */
2519       stack_remaining -= prologue_inst_adjust_sp (inst);
2520
2521       /* There is only one instruction used for saving RP into the stack.  */
2522       if (inst == 0x6bc23fd9)
2523         {
2524           save_rp = 0;
2525           frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 20;
2526         }
2527
2528       /* Just note that we found the save of SP into the stack.  The
2529          value for frame_saved_regs was computed above.  */
2530       if ((inst & 0xffffc000) == 0x6fc10000)
2531         save_sp = 0;
2532
2533       /* Account for general and floating-point register saves.  */
2534       reg = inst_saves_gr (inst);
2535       if (reg >= 3 && reg <= 18
2536           && (!u->Save_SP || reg != FP_REGNUM))
2537         {
2538           save_gr &= ~(1 << reg);
2539
2540           /* stwm with a positive displacement is a *post modify*.  */
2541           if ((inst >> 26) == 0x1b
2542               && extract_14 (inst) >= 0)
2543             frame_saved_regs->regs[reg] = frame_info->frame;
2544           else
2545             {
2546               /* Handle code with and without frame pointers.  */
2547               if (u->Save_SP)
2548                 frame_saved_regs->regs[reg]
2549                   = frame_info->frame + extract_14 (inst);
2550               else
2551                 frame_saved_regs->regs[reg]
2552                   = frame_info->frame + (u->Total_frame_size << 3)
2553                     + extract_14 (inst);
2554             }
2555         }
2556
2557
2558       /* GCC handles callee saved FP regs a little differently.
2559
2560          It emits an instruction to put the value of the start of
2561          the FP store area into %r1.  It then uses fstds,ma with
2562          a basereg of %r1 for the stores.
2563
2564          HP CC emits them at the current stack pointer modifying
2565          the stack pointer as it stores each register.  */
2566
2567       /* ldo X(%r3),%r1 or ldo X(%r30),%r1.  */
2568       if ((inst & 0xffffc000) == 0x34610000
2569           || (inst & 0xffffc000) == 0x37c10000)
2570         fp_loc = extract_14 (inst);
2571
2572       reg = inst_saves_fr (inst);
2573       if (reg >= 12 && reg <= 21)
2574         {
2575           /* Note +4 braindamage below is necessary because the FP status
2576              registers are internally 8 registers rather than the expected
2577              4 registers.  */
2578           save_fr &= ~(1 << reg);
2579           if (fp_loc == -1)
2580             {
2581               /* 1st HP CC FP register store.  After this instruction
2582                  we've set enough state that the GCC and HPCC code are
2583                  both handled in the same manner.  */
2584               frame_saved_regs->regs[reg + FP4_REGNUM + 4] = frame_info->frame;
2585               fp_loc = 8;
2586             }
2587           else
2588             {
2589               frame_saved_regs->regs[reg + FP0_REGNUM + 4]
2590                 = frame_info->frame + fp_loc;
2591               fp_loc += 8;
2592             }
2593         }
2594
2595       /* Quit if we hit any kind of branch.  This can happen if a prologue
2596          instruction is in the delay slot of the first call/branch.  */
2597       if (is_branch (inst))
2598         break;
2599
2600       /* Bump the PC.  */
2601       pc += 4;
2602     }
2603 }
2604
2605 #ifdef MAINTENANCE_CMDS
2606
2607 static void
2608 unwind_command (exp, from_tty)
2609      char *exp;
2610      int from_tty;
2611 {
2612   CORE_ADDR address;
2613   struct unwind_table_entry *u;
2614
2615   /* If we have an expression, evaluate it and use it as the address.  */
2616
2617   if (exp != 0 && *exp != 0)
2618     address = parse_and_eval_address (exp);
2619   else
2620     return;
2621
2622   u = find_unwind_entry (address);
2623
2624   if (!u)
2625     {
2626       printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2627       return;
2628     }
2629
2630   printf_unfiltered ("unwind_table_entry (0x%x):\n", u);
2631
2632   printf_unfiltered ("\tregion_start = ");
2633   print_address (u->region_start, gdb_stdout);
2634
2635   printf_unfiltered ("\n\tregion_end = ");
2636   print_address (u->region_end, gdb_stdout);
2637
2638 #ifdef __STDC__
2639 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2640 #else
2641 #define pif(FLD) if (u->FLD) printf_unfiltered (" FLD");
2642 #endif
2643
2644   printf_unfiltered ("\n\tflags =");
2645   pif (Cannot_unwind);
2646   pif (Millicode);
2647   pif (Millicode_save_sr0);
2648   pif (Entry_SR);
2649   pif (Args_stored);
2650   pif (Variable_Frame);
2651   pif (Separate_Package_Body);
2652   pif (Frame_Extension_Millicode);
2653   pif (Stack_Overflow_Check);
2654   pif (Two_Instruction_SP_Increment);
2655   pif (Ada_Region);
2656   pif (Save_SP);
2657   pif (Save_RP);
2658   pif (Save_MRP_in_frame);
2659   pif (extn_ptr_defined);
2660   pif (Cleanup_defined);
2661   pif (MPE_XL_interrupt_marker);
2662   pif (HP_UX_interrupt_marker);
2663   pif (Large_frame);
2664
2665   putchar_unfiltered ('\n');
2666
2667 #ifdef __STDC__
2668 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2669 #else
2670 #define pin(FLD) printf_unfiltered ("\tFLD = 0x%x\n", u->FLD);
2671 #endif
2672
2673   pin (Region_description);
2674   pin (Entry_FR);
2675   pin (Entry_GR);
2676   pin (Total_frame_size);
2677 }
2678 #endif /* MAINTENANCE_CMDS */
2679
2680 void
2681 _initialize_hppa_tdep ()
2682 {
2683   tm_print_insn = print_insn_hppa;
2684
2685 #ifdef MAINTENANCE_CMDS
2686   add_cmd ("unwind", class_maintenance, unwind_command,
2687            "Print unwind table entry at given address.",
2688            &maintenanceprintlist);
2689 #endif /* MAINTENANCE_CMDS */
2690 }