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