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