GDBARCH_BREAKPOINT_MANIPULATION and SET_GDBARCH_BREAKPOINT_MANIPULATION
[external/binutils.git] / gdb / hppa-tdep.c
1 /* Target-dependent code for the HP PA-RISC architecture.
2
3    Copyright (C) 1986-2016 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 static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
608
609 GDBARCH_BREAKPOINT_MANIPULATION (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 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 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       return (TYPE_LENGTH (type) == 8);
899     default:
900       break;
901     }
902
903   return 0;
904 }
905
906 /* Check whether TYPE is a "Floating Scalar Type".  */
907
908 static int
909 hppa64_floating_p (const struct type *type)
910 {
911   switch (TYPE_CODE (type))
912     {
913     case TYPE_CODE_FLT:
914       {
915         int len = TYPE_LENGTH (type);
916         return (len == 4 || len == 8 || len == 16);
917       }
918     default:
919       break;
920     }
921
922   return 0;
923 }
924
925 /* If CODE points to a function entry address, try to look up the corresponding
926    function descriptor and return its address instead.  If CODE is not a
927    function entry address, then just return it unchanged.  */
928 static CORE_ADDR
929 hppa64_convert_code_addr_to_fptr (struct gdbarch *gdbarch, CORE_ADDR code)
930 {
931   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
932   struct obj_section *sec, *opd;
933
934   sec = find_pc_section (code);
935
936   if (!sec)
937     return code;
938
939   /* If CODE is in a data section, assume it's already a fptr.  */
940   if (!(sec->the_bfd_section->flags & SEC_CODE))
941     return code;
942
943   ALL_OBJFILE_OSECTIONS (sec->objfile, opd)
944     {
945       if (strcmp (opd->the_bfd_section->name, ".opd") == 0)
946         break;
947     }
948
949   if (opd < sec->objfile->sections_end)
950     {
951       CORE_ADDR addr;
952
953       for (addr = obj_section_addr (opd);
954            addr < obj_section_endaddr (opd);
955            addr += 2 * 8)
956         {
957           ULONGEST opdaddr;
958           gdb_byte tmp[8];
959
960           if (target_read_memory (addr, tmp, sizeof (tmp)))
961               break;
962           opdaddr = extract_unsigned_integer (tmp, sizeof (tmp), byte_order);
963
964           if (opdaddr == code)
965             return addr - 16;
966         }
967     }
968
969   return code;
970 }
971
972 static CORE_ADDR
973 hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
974                         struct regcache *regcache, CORE_ADDR bp_addr,
975                         int nargs, struct value **args, CORE_ADDR sp,
976                         int struct_return, CORE_ADDR struct_addr)
977 {
978   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
979   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
980   int i, offset = 0;
981   CORE_ADDR gp;
982
983   /* "The outgoing parameter area [...] must be aligned at a 16-byte
984      boundary."  */
985   sp = align_up (sp, 16);
986
987   for (i = 0; i < nargs; i++)
988     {
989       struct value *arg = args[i];
990       struct type *type = value_type (arg);
991       int len = TYPE_LENGTH (type);
992       const bfd_byte *valbuf;
993       bfd_byte fptrbuf[8];
994       int regnum;
995
996       /* "Each parameter begins on a 64-bit (8-byte) boundary."  */
997       offset = align_up (offset, 8);
998
999       if (hppa64_integral_or_pointer_p (type))
1000         {
1001           /* "Integral scalar parameters smaller than 64 bits are
1002              padded on the left (i.e., the value is in the
1003              least-significant bits of the 64-bit storage unit, and
1004              the high-order bits are undefined)."  Therefore we can
1005              safely sign-extend them.  */
1006           if (len < 8)
1007             {
1008               arg = value_cast (builtin_type (gdbarch)->builtin_int64, arg);
1009               len = 8;
1010             }
1011         }
1012       else if (hppa64_floating_p (type))
1013         {
1014           if (len > 8)
1015             {
1016               /* "Quad-precision (128-bit) floating-point scalar
1017                  parameters are aligned on a 16-byte boundary."  */
1018               offset = align_up (offset, 16);
1019
1020               /* "Double-extended- and quad-precision floating-point
1021                  parameters within the first 64 bytes of the parameter
1022                  list are always passed in general registers."  */
1023             }
1024           else
1025             {
1026               if (len == 4)
1027                 {
1028                   /* "Single-precision (32-bit) floating-point scalar
1029                      parameters are padded on the left with 32 bits of
1030                      garbage (i.e., the floating-point value is in the
1031                      least-significant 32 bits of a 64-bit storage
1032                      unit)."  */
1033                   offset += 4;
1034                 }
1035
1036               /* "Single- and double-precision floating-point
1037                  parameters in this area are passed according to the
1038                  available formal parameter information in a function
1039                  prototype.  [...]  If no prototype is in scope,
1040                  floating-point parameters must be passed both in the
1041                  corresponding general registers and in the
1042                  corresponding floating-point registers."  */
1043               regnum = HPPA64_FP4_REGNUM + offset / 8;
1044
1045               if (regnum < HPPA64_FP4_REGNUM + 8)
1046                 {
1047                   /* "Single-precision floating-point parameters, when
1048                      passed in floating-point registers, are passed in
1049                      the right halves of the floating point registers;
1050                      the left halves are unused."  */
1051                   regcache_cooked_write_part (regcache, regnum, offset % 8,
1052                                               len, value_contents (arg));
1053                 }
1054             }
1055         }
1056       else
1057         {
1058           if (len > 8)
1059             {
1060               /* "Aggregates larger than 8 bytes are aligned on a
1061                  16-byte boundary, possibly leaving an unused argument
1062                  slot, which is filled with garbage.  If necessary,
1063                  they are padded on the right (with garbage), to a
1064                  multiple of 8 bytes."  */
1065               offset = align_up (offset, 16);
1066             }
1067         }
1068
1069       /* If we are passing a function pointer, make sure we pass a function
1070          descriptor instead of the function entry address.  */
1071       if (TYPE_CODE (type) == TYPE_CODE_PTR
1072           && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1073         {
1074           ULONGEST codeptr, fptr;
1075
1076           codeptr = unpack_long (type, value_contents (arg));
1077           fptr = hppa64_convert_code_addr_to_fptr (gdbarch, codeptr);
1078           store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), byte_order,
1079                                   fptr);
1080           valbuf = fptrbuf;
1081         }
1082       else
1083         {
1084           valbuf = value_contents (arg);
1085         }
1086
1087       /* Always store the argument in memory.  */
1088       write_memory (sp + offset, valbuf, len);
1089
1090       regnum = HPPA_ARG0_REGNUM - offset / 8;
1091       while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
1092         {
1093           regcache_cooked_write_part (regcache, regnum,
1094                                       offset % 8, std::min (len, 8), valbuf);
1095           offset += std::min (len, 8);
1096           valbuf += std::min (len, 8);
1097           len -= std::min (len, 8);
1098           regnum--;
1099         }
1100
1101       offset += len;
1102     }
1103
1104   /* Set up GR29 (%ret1) to hold the argument pointer (ap).  */
1105   regcache_cooked_write_unsigned (regcache, HPPA_RET1_REGNUM, sp + 64);
1106
1107   /* Allocate the outgoing parameter area.  Make sure the outgoing
1108      parameter area is multiple of 16 bytes in length.  */
1109   sp += std::max (align_up (offset, 16), (ULONGEST) 64);
1110
1111   /* Allocate 32-bytes of scratch space.  The documentation doesn't
1112      mention this, but it seems to be needed.  */
1113   sp += 32;
1114
1115   /* Allocate the frame marker area.  */
1116   sp += 16;
1117
1118   /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1119      its address.  */
1120   if (struct_return)
1121     regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
1122
1123   /* Set up GR27 (%dp) to hold the global pointer (gp).  */
1124   gp = tdep->find_global_pointer (gdbarch, function);
1125   if (gp != 0)
1126     regcache_cooked_write_unsigned (regcache, HPPA_DP_REGNUM, gp);
1127
1128   /* Set up GR2 (%rp) to hold the return pointer (rp).  */
1129   if (!gdbarch_push_dummy_code_p (gdbarch))
1130     regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
1131
1132   /* Set up GR30 to hold the stack pointer (sp).  */
1133   regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, sp);
1134
1135   return sp;
1136 }
1137 \f
1138
1139 /* Handle 32/64-bit struct return conventions.  */
1140
1141 static enum return_value_convention
1142 hppa32_return_value (struct gdbarch *gdbarch, struct value *function,
1143                      struct type *type, struct regcache *regcache,
1144                      gdb_byte *readbuf, const gdb_byte *writebuf)
1145 {
1146   if (TYPE_LENGTH (type) <= 2 * 4)
1147     {
1148       /* The value always lives in the right hand end of the register
1149          (or register pair)?  */
1150       int b;
1151       int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
1152       int part = TYPE_LENGTH (type) % 4;
1153       /* The left hand register contains only part of the value,
1154          transfer that first so that the rest can be xfered as entire
1155          4-byte registers.  */
1156       if (part > 0)
1157         {
1158           if (readbuf != NULL)
1159             regcache_cooked_read_part (regcache, reg, 4 - part,
1160                                        part, readbuf);
1161           if (writebuf != NULL)
1162             regcache_cooked_write_part (regcache, reg, 4 - part,
1163                                         part, writebuf);
1164           reg++;
1165         }
1166       /* Now transfer the remaining register values.  */
1167       for (b = part; b < TYPE_LENGTH (type); b += 4)
1168         {
1169           if (readbuf != NULL)
1170             regcache_cooked_read (regcache, reg, readbuf + b);
1171           if (writebuf != NULL)
1172             regcache_cooked_write (regcache, reg, writebuf + b);
1173           reg++;
1174         }
1175       return RETURN_VALUE_REGISTER_CONVENTION;
1176     }
1177   else
1178     return RETURN_VALUE_STRUCT_CONVENTION;
1179 }
1180
1181 static enum return_value_convention
1182 hppa64_return_value (struct gdbarch *gdbarch, struct value *function,
1183                      struct type *type, struct regcache *regcache,
1184                      gdb_byte *readbuf, const gdb_byte *writebuf)
1185 {
1186   int len = TYPE_LENGTH (type);
1187   int regnum, offset;
1188
1189   if (len > 16)
1190     {
1191       /* All return values larget than 128 bits must be aggregate
1192          return values.  */
1193       gdb_assert (!hppa64_integral_or_pointer_p (type));
1194       gdb_assert (!hppa64_floating_p (type));
1195
1196       /* "Aggregate return values larger than 128 bits are returned in
1197          a buffer allocated by the caller.  The address of the buffer
1198          must be passed in GR 28."  */
1199       return RETURN_VALUE_STRUCT_CONVENTION;
1200     }
1201
1202   if (hppa64_integral_or_pointer_p (type))
1203     {
1204       /* "Integral return values are returned in GR 28.  Values
1205          smaller than 64 bits are padded on the left (with garbage)."  */
1206       regnum = HPPA_RET0_REGNUM;
1207       offset = 8 - len;
1208     }
1209   else if (hppa64_floating_p (type))
1210     {
1211       if (len > 8)
1212         {
1213           /* "Double-extended- and quad-precision floating-point
1214              values are returned in GRs 28 and 29.  The sign,
1215              exponent, and most-significant bits of the mantissa are
1216              returned in GR 28; the least-significant bits of the
1217              mantissa are passed in GR 29.  For double-extended
1218              precision values, GR 29 is padded on the right with 48
1219              bits of garbage."  */
1220           regnum = HPPA_RET0_REGNUM;
1221           offset = 0;
1222         }
1223       else
1224         {
1225           /* "Single-precision and double-precision floating-point
1226              return values are returned in FR 4R (single precision) or
1227              FR 4 (double-precision)."  */
1228           regnum = HPPA64_FP4_REGNUM;
1229           offset = 8 - len;
1230         }
1231     }
1232   else
1233     {
1234       /* "Aggregate return values up to 64 bits in size are returned
1235          in GR 28.  Aggregates smaller than 64 bits are left aligned
1236          in the register; the pad bits on the right are undefined."
1237
1238          "Aggregate return values between 65 and 128 bits are returned
1239          in GRs 28 and 29.  The first 64 bits are placed in GR 28, and
1240          the remaining bits are placed, left aligned, in GR 29.  The
1241          pad bits on the right of GR 29 (if any) are undefined."  */
1242       regnum = HPPA_RET0_REGNUM;
1243       offset = 0;
1244     }
1245
1246   if (readbuf)
1247     {
1248       while (len > 0)
1249         {
1250           regcache_cooked_read_part (regcache, regnum, offset,
1251                                      std::min (len, 8), readbuf);
1252           readbuf += std::min (len, 8);
1253           len -= std::min (len, 8);
1254           regnum++;
1255         }
1256     }
1257
1258   if (writebuf)
1259     {
1260       while (len > 0)
1261         {
1262           regcache_cooked_write_part (regcache, regnum, offset,
1263                                       std::min (len, 8), writebuf);
1264           writebuf += std::min (len, 8);
1265           len -= std::min (len, 8);
1266           regnum++;
1267         }
1268     }
1269
1270   return RETURN_VALUE_REGISTER_CONVENTION;
1271 }
1272 \f
1273
1274 static CORE_ADDR
1275 hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1276                                    struct target_ops *targ)
1277 {
1278   if (addr & 2)
1279     {
1280       struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1281       CORE_ADDR plabel = addr & ~3;
1282       return read_memory_typed_address (plabel, func_ptr_type);
1283     }
1284
1285   return addr;
1286 }
1287
1288 static CORE_ADDR
1289 hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1290 {
1291   /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1292      and not _bit_)!  */
1293   return align_up (addr, 64);
1294 }
1295
1296 /* Force all frames to 16-byte alignment.  Better safe than sorry.  */
1297
1298 static CORE_ADDR
1299 hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1300 {
1301   /* Just always 16-byte align.  */
1302   return align_up (addr, 16);
1303 }
1304
1305 CORE_ADDR
1306 hppa_read_pc (struct regcache *regcache)
1307 {
1308   ULONGEST ipsw;
1309   ULONGEST pc;
1310
1311   regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
1312   regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
1313
1314   /* If the current instruction is nullified, then we are effectively
1315      still executing the previous instruction.  Pretend we are still
1316      there.  This is needed when single stepping; if the nullified
1317      instruction is on a different line, we don't want GDB to think
1318      we've stepped onto that line.  */
1319   if (ipsw & 0x00200000)
1320     pc -= 4;
1321
1322   return pc & ~0x3;
1323 }
1324
1325 void
1326 hppa_write_pc (struct regcache *regcache, CORE_ADDR pc)
1327 {
1328   regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pc);
1329   regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pc + 4);
1330 }
1331
1332 /* For the given instruction (INST), return any adjustment it makes
1333    to the stack pointer or zero for no adjustment.
1334
1335    This only handles instructions commonly found in prologues.  */
1336
1337 static int
1338 prologue_inst_adjust_sp (unsigned long inst)
1339 {
1340   /* This must persist across calls.  */
1341   static int save_high21;
1342
1343   /* The most common way to perform a stack adjustment ldo X(sp),sp */
1344   if ((inst & 0xffffc000) == 0x37de0000)
1345     return hppa_extract_14 (inst);
1346
1347   /* stwm X,D(sp) */
1348   if ((inst & 0xffe00000) == 0x6fc00000)
1349     return hppa_extract_14 (inst);
1350
1351   /* std,ma X,D(sp) */
1352   if ((inst & 0xffe00008) == 0x73c00008)
1353     return (inst & 0x1 ? -(1 << 13) : 0) | (((inst >> 4) & 0x3ff) << 3);
1354
1355   /* addil high21,%r30; ldo low11,(%r1),%r30)
1356      save high bits in save_high21 for later use.  */
1357   if ((inst & 0xffe00000) == 0x2bc00000)
1358     {
1359       save_high21 = hppa_extract_21 (inst);
1360       return 0;
1361     }
1362
1363   if ((inst & 0xffff0000) == 0x343e0000)
1364     return save_high21 + hppa_extract_14 (inst);
1365
1366   /* fstws as used by the HP compilers.  */
1367   if ((inst & 0xffffffe0) == 0x2fd01220)
1368     return hppa_extract_5_load (inst);
1369
1370   /* No adjustment.  */
1371   return 0;
1372 }
1373
1374 /* Return nonzero if INST is a branch of some kind, else return zero.  */
1375
1376 static int
1377 is_branch (unsigned long inst)
1378 {
1379   switch (inst >> 26)
1380     {
1381     case 0x20:
1382     case 0x21:
1383     case 0x22:
1384     case 0x23:
1385     case 0x27:
1386     case 0x28:
1387     case 0x29:
1388     case 0x2a:
1389     case 0x2b:
1390     case 0x2f:
1391     case 0x30:
1392     case 0x31:
1393     case 0x32:
1394     case 0x33:
1395     case 0x38:
1396     case 0x39:
1397     case 0x3a:
1398     case 0x3b:
1399       return 1;
1400
1401     default:
1402       return 0;
1403     }
1404 }
1405
1406 /* Return the register number for a GR which is saved by INST or
1407    zero if INST does not save a GR.
1408
1409    Referenced from:
1410
1411      parisc 1.1:
1412      https://parisc.wiki.kernel.org/images-parisc/6/68/Pa11_acd.pdf
1413
1414      parisc 2.0:
1415      https://parisc.wiki.kernel.org/images-parisc/7/73/Parisc2.0.pdf
1416
1417      According to Table 6-5 of Chapter 6 (Memory Reference Instructions)
1418      on page 106 in parisc 2.0, all instructions for storing values from
1419      the general registers are:
1420
1421        Store:          stb, sth, stw, std (according to Chapter 7, they
1422                        are only in both "inst >> 26" and "inst >> 6".
1423        Store Absolute: stwa, stda (according to Chapter 7, they are only
1424                        in "inst >> 6".
1425        Store Bytes:    stby, stdby (according to Chapter 7, they are
1426                        only in "inst >> 6").
1427
1428    For (inst >> 26), according to Chapter 7:
1429
1430      The effective memory reference address is formed by the addition
1431      of an immediate displacement to a base value.
1432
1433     - stb: 0x18, store a byte from a general register.
1434
1435     - sth: 0x19, store a halfword from a general register.
1436
1437     - stw: 0x1a, store a word from a general register.
1438
1439     - stwm: 0x1b, store a word from a general register and perform base
1440       register modification (2.0 will still treate it as stw).
1441
1442     - std: 0x1c, store a doubleword from a general register (2.0 only).
1443
1444     - stw: 0x1f, store a word from a general register (2.0 only).
1445
1446    For (inst >> 6) when ((inst >> 26) == 0x03), according to Chapter 7:
1447
1448      The effective memory reference address is formed by the addition
1449      of an index value to a base value specified in the instruction.
1450
1451     - stb: 0x08, store a byte from a general register (1.1 calls stbs).
1452
1453     - sth: 0x09, store a halfword from a general register (1.1 calls
1454       sths).
1455
1456     - stw: 0x0a, store a word from a general register (1.1 calls stws).
1457
1458     - std: 0x0b: store a doubleword from a general register (2.0 only)
1459
1460      Implement fast byte moves (stores) to unaligned word or doubleword
1461      destination.
1462
1463     - stby: 0x0c, for unaligned word (1.1 calls stbys).
1464
1465     - stdby: 0x0d for unaligned doubleword (2.0 only).
1466
1467      Store a word or doubleword using an absolute memory address formed
1468      using short or long displacement or indexed
1469
1470     - stwa: 0x0e, store a word from a general register to an absolute
1471       address (1.0 calls stwas).
1472
1473     - stda: 0x0f, store a doubleword from a general register to an
1474       absolute address (2.0 only).  */
1475
1476 static int
1477 inst_saves_gr (unsigned long inst)
1478 {
1479   switch ((inst >> 26) & 0x0f)
1480     {
1481       case 0x03:
1482         switch ((inst >> 6) & 0x0f)
1483           {
1484             case 0x08:
1485             case 0x09:
1486             case 0x0a:
1487             case 0x0b:
1488             case 0x0c:
1489             case 0x0d:
1490             case 0x0e:
1491             case 0x0f:
1492               return hppa_extract_5R_store (inst);
1493             default:
1494               return 0;
1495           }
1496       case 0x18:
1497       case 0x19:
1498       case 0x1a:
1499       case 0x1b:
1500       case 0x1c:
1501       /* no 0x1d or 0x1e -- according to parisc 2.0 document */
1502       case 0x1f:
1503         return hppa_extract_5R_store (inst);
1504       default:
1505         return 0;
1506     }
1507 }
1508
1509 /* Return the register number for a FR which is saved by INST or
1510    zero it INST does not save a FR.
1511
1512    Note we only care about full 64bit register stores (that's the only
1513    kind of stores the prologue will use).
1514
1515    FIXME: What about argument stores with the HP compiler in ANSI mode? */
1516
1517 static int
1518 inst_saves_fr (unsigned long inst)
1519 {
1520   /* Is this an FSTD?  */
1521   if ((inst & 0xfc00dfc0) == 0x2c001200)
1522     return hppa_extract_5r_store (inst);
1523   if ((inst & 0xfc000002) == 0x70000002)
1524     return hppa_extract_5R_store (inst);
1525   /* Is this an FSTW?  */
1526   if ((inst & 0xfc00df80) == 0x24001200)
1527     return hppa_extract_5r_store (inst);
1528   if ((inst & 0xfc000002) == 0x7c000000)
1529     return hppa_extract_5R_store (inst);
1530   return 0;
1531 }
1532
1533 /* Advance PC across any function entry prologue instructions
1534    to reach some "real" code.
1535
1536    Use information in the unwind table to determine what exactly should
1537    be in the prologue.  */
1538
1539
1540 static CORE_ADDR
1541 skip_prologue_hard_way (struct gdbarch *gdbarch, CORE_ADDR pc,
1542                         int stop_before_branch)
1543 {
1544   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1545   gdb_byte buf[4];
1546   CORE_ADDR orig_pc = pc;
1547   unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1548   unsigned long args_stored, status, i, restart_gr, restart_fr;
1549   struct unwind_table_entry *u;
1550   int final_iteration;
1551
1552   restart_gr = 0;
1553   restart_fr = 0;
1554
1555 restart:
1556   u = find_unwind_entry (pc);
1557   if (!u)
1558     return pc;
1559
1560   /* If we are not at the beginning of a function, then return now.  */
1561   if ((pc & ~0x3) != u->region_start)
1562     return pc;
1563
1564   /* This is how much of a frame adjustment we need to account for.  */
1565   stack_remaining = u->Total_frame_size << 3;
1566
1567   /* Magic register saves we want to know about.  */
1568   save_rp = u->Save_RP;
1569   save_sp = u->Save_SP;
1570
1571   /* An indication that args may be stored into the stack.  Unfortunately
1572      the HPUX compilers tend to set this in cases where no args were
1573      stored too!.  */
1574   args_stored = 1;
1575
1576   /* Turn the Entry_GR field into a bitmask.  */
1577   save_gr = 0;
1578   for (i = 3; i < u->Entry_GR + 3; i++)
1579     {
1580       /* Frame pointer gets saved into a special location.  */
1581       if (u->Save_SP && i == HPPA_FP_REGNUM)
1582         continue;
1583
1584       save_gr |= (1 << i);
1585     }
1586   save_gr &= ~restart_gr;
1587
1588   /* Turn the Entry_FR field into a bitmask too.  */
1589   save_fr = 0;
1590   for (i = 12; i < u->Entry_FR + 12; i++)
1591     save_fr |= (1 << i);
1592   save_fr &= ~restart_fr;
1593
1594   final_iteration = 0;
1595
1596   /* Loop until we find everything of interest or hit a branch.
1597
1598      For unoptimized GCC code and for any HP CC code this will never ever
1599      examine any user instructions.
1600
1601      For optimzied GCC code we're faced with problems.  GCC will schedule
1602      its prologue and make prologue instructions available for delay slot
1603      filling.  The end result is user code gets mixed in with the prologue
1604      and a prologue instruction may be in the delay slot of the first branch
1605      or call.
1606
1607      Some unexpected things are expected with debugging optimized code, so
1608      we allow this routine to walk past user instructions in optimized
1609      GCC code.  */
1610   while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1611          || args_stored)
1612     {
1613       unsigned int reg_num;
1614       unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1615       unsigned long old_save_rp, old_save_sp, next_inst;
1616
1617       /* Save copies of all the triggers so we can compare them later
1618          (only for HPC).  */
1619       old_save_gr = save_gr;
1620       old_save_fr = save_fr;
1621       old_save_rp = save_rp;
1622       old_save_sp = save_sp;
1623       old_stack_remaining = stack_remaining;
1624
1625       status = target_read_memory (pc, buf, 4);
1626       inst = extract_unsigned_integer (buf, 4, byte_order);
1627
1628       /* Yow! */
1629       if (status != 0)
1630         return pc;
1631
1632       /* Note the interesting effects of this instruction.  */
1633       stack_remaining -= prologue_inst_adjust_sp (inst);
1634
1635       /* There are limited ways to store the return pointer into the
1636          stack.  */
1637       if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1638         save_rp = 0;
1639
1640       /* These are the only ways we save SP into the stack.  At this time
1641          the HP compilers never bother to save SP into the stack.  */
1642       if ((inst & 0xffffc000) == 0x6fc10000
1643           || (inst & 0xffffc00c) == 0x73c10008)
1644         save_sp = 0;
1645
1646       /* Are we loading some register with an offset from the argument
1647          pointer?  */
1648       if ((inst & 0xffe00000) == 0x37a00000
1649           || (inst & 0xffffffe0) == 0x081d0240)
1650         {
1651           pc += 4;
1652           continue;
1653         }
1654
1655       /* Account for general and floating-point register saves.  */
1656       reg_num = inst_saves_gr (inst);
1657       save_gr &= ~(1 << reg_num);
1658
1659       /* Ugh.  Also account for argument stores into the stack.
1660          Unfortunately args_stored only tells us that some arguments
1661          where stored into the stack.  Not how many or what kind!
1662
1663          This is a kludge as on the HP compiler sets this bit and it
1664          never does prologue scheduling.  So once we see one, skip past
1665          all of them.   We have similar code for the fp arg stores below.
1666
1667          FIXME.  Can still die if we have a mix of GR and FR argument
1668          stores!  */
1669       if (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1670           && reg_num <= 26)
1671         {
1672           while (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1673                  && reg_num <= 26)
1674             {
1675               pc += 4;
1676               status = target_read_memory (pc, buf, 4);
1677               inst = extract_unsigned_integer (buf, 4, byte_order);
1678               if (status != 0)
1679                 return pc;
1680               reg_num = inst_saves_gr (inst);
1681             }
1682           args_stored = 0;
1683           continue;
1684         }
1685
1686       reg_num = inst_saves_fr (inst);
1687       save_fr &= ~(1 << reg_num);
1688
1689       status = target_read_memory (pc + 4, buf, 4);
1690       next_inst = extract_unsigned_integer (buf, 4, byte_order);
1691
1692       /* Yow! */
1693       if (status != 0)
1694         return pc;
1695
1696       /* We've got to be read to handle the ldo before the fp register
1697          save.  */
1698       if ((inst & 0xfc000000) == 0x34000000
1699           && inst_saves_fr (next_inst) >= 4
1700           && inst_saves_fr (next_inst)
1701                <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1702         {
1703           /* So we drop into the code below in a reasonable state.  */
1704           reg_num = inst_saves_fr (next_inst);
1705           pc -= 4;
1706         }
1707
1708       /* Ugh.  Also account for argument stores into the stack.
1709          This is a kludge as on the HP compiler sets this bit and it
1710          never does prologue scheduling.  So once we see one, skip past
1711          all of them.  */
1712       if (reg_num >= 4
1713           && reg_num <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1714         {
1715           while (reg_num >= 4
1716                  && reg_num
1717                       <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1718             {
1719               pc += 8;
1720               status = target_read_memory (pc, buf, 4);
1721               inst = extract_unsigned_integer (buf, 4, byte_order);
1722               if (status != 0)
1723                 return pc;
1724               if ((inst & 0xfc000000) != 0x34000000)
1725                 break;
1726               status = target_read_memory (pc + 4, buf, 4);
1727               next_inst = extract_unsigned_integer (buf, 4, byte_order);
1728               if (status != 0)
1729                 return pc;
1730               reg_num = inst_saves_fr (next_inst);
1731             }
1732           args_stored = 0;
1733           continue;
1734         }
1735
1736       /* Quit if we hit any kind of branch.  This can happen if a prologue
1737          instruction is in the delay slot of the first call/branch.  */
1738       if (is_branch (inst) && stop_before_branch)
1739         break;
1740
1741       /* What a crock.  The HP compilers set args_stored even if no
1742          arguments were stored into the stack (boo hiss).  This could
1743          cause this code to then skip a bunch of user insns (up to the
1744          first branch).
1745
1746          To combat this we try to identify when args_stored was bogusly
1747          set and clear it.   We only do this when args_stored is nonzero,
1748          all other resources are accounted for, and nothing changed on
1749          this pass.  */
1750       if (args_stored
1751        && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1752           && old_save_gr == save_gr && old_save_fr == save_fr
1753           && old_save_rp == save_rp && old_save_sp == save_sp
1754           && old_stack_remaining == stack_remaining)
1755         break;
1756
1757       /* Bump the PC.  */
1758       pc += 4;
1759
1760       /* !stop_before_branch, so also look at the insn in the delay slot 
1761          of the branch.  */
1762       if (final_iteration)
1763         break;
1764       if (is_branch (inst))
1765         final_iteration = 1;
1766     }
1767
1768   /* We've got a tenative location for the end of the prologue.  However
1769      because of limitations in the unwind descriptor mechanism we may
1770      have went too far into user code looking for the save of a register
1771      that does not exist.  So, if there registers we expected to be saved
1772      but never were, mask them out and restart.
1773
1774      This should only happen in optimized code, and should be very rare.  */
1775   if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1776     {
1777       pc = orig_pc;
1778       restart_gr = save_gr;
1779       restart_fr = save_fr;
1780       goto restart;
1781     }
1782
1783   return pc;
1784 }
1785
1786
1787 /* Return the address of the PC after the last prologue instruction if
1788    we can determine it from the debug symbols.  Else return zero.  */
1789
1790 static CORE_ADDR
1791 after_prologue (CORE_ADDR pc)
1792 {
1793   struct symtab_and_line sal;
1794   CORE_ADDR func_addr, func_end;
1795
1796   /* If we can not find the symbol in the partial symbol table, then
1797      there is no hope we can determine the function's start address
1798      with this code.  */
1799   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1800     return 0;
1801
1802   /* Get the line associated with FUNC_ADDR.  */
1803   sal = find_pc_line (func_addr, 0);
1804
1805   /* There are only two cases to consider.  First, the end of the source line
1806      is within the function bounds.  In that case we return the end of the
1807      source line.  Second is the end of the source line extends beyond the
1808      bounds of the current function.  We need to use the slow code to
1809      examine instructions in that case.
1810
1811      Anything else is simply a bug elsewhere.  Fixing it here is absolutely
1812      the wrong thing to do.  In fact, it should be entirely possible for this
1813      function to always return zero since the slow instruction scanning code
1814      is supposed to *always* work.  If it does not, then it is a bug.  */
1815   if (sal.end < func_end)
1816     return sal.end;
1817   else
1818     return 0;
1819 }
1820
1821 /* To skip prologues, I use this predicate.  Returns either PC itself
1822    if the code at PC does not look like a function prologue; otherwise
1823    returns an address that (if we're lucky) follows the prologue.
1824    
1825    hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1826    It doesn't necessarily skips all the insns in the prologue.  In fact
1827    we might not want to skip all the insns because a prologue insn may
1828    appear in the delay slot of the first branch, and we don't want to
1829    skip over the branch in that case.  */
1830
1831 static CORE_ADDR
1832 hppa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1833 {
1834   CORE_ADDR post_prologue_pc;
1835
1836   /* See if we can determine the end of the prologue via the symbol table.
1837      If so, then return either PC, or the PC after the prologue, whichever
1838      is greater.  */
1839
1840   post_prologue_pc = after_prologue (pc);
1841
1842   /* If after_prologue returned a useful address, then use it.  Else
1843      fall back on the instruction skipping code.
1844
1845      Some folks have claimed this causes problems because the breakpoint
1846      may be the first instruction of the prologue.  If that happens, then
1847      the instruction skipping code has a bug that needs to be fixed.  */
1848   if (post_prologue_pc != 0)
1849     return std::max (pc, post_prologue_pc);
1850   else
1851     return (skip_prologue_hard_way (gdbarch, pc, 1));
1852 }
1853
1854 /* Return an unwind entry that falls within the frame's code block.  */
1855
1856 static struct unwind_table_entry *
1857 hppa_find_unwind_entry_in_block (struct frame_info *this_frame)
1858 {
1859   CORE_ADDR pc = get_frame_address_in_block (this_frame);
1860
1861   /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1862      result of get_frame_address_in_block implies a problem.
1863      The bits should have been removed earlier, before the return
1864      value of gdbarch_unwind_pc.  That might be happening already;
1865      if it isn't, it should be fixed.  Then this call can be
1866      removed.  */
1867   pc = gdbarch_addr_bits_remove (get_frame_arch (this_frame), pc);
1868   return find_unwind_entry (pc);
1869 }
1870
1871 struct hppa_frame_cache
1872 {
1873   CORE_ADDR base;
1874   struct trad_frame_saved_reg *saved_regs;
1875 };
1876
1877 static struct hppa_frame_cache *
1878 hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
1879 {
1880   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1881   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1882   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1883   struct hppa_frame_cache *cache;
1884   long saved_gr_mask;
1885   long saved_fr_mask;
1886   long frame_size;
1887   struct unwind_table_entry *u;
1888   CORE_ADDR prologue_end;
1889   int fp_in_r1 = 0;
1890   int i;
1891
1892   if (hppa_debug)
1893     fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
1894       frame_relative_level(this_frame));
1895
1896   if ((*this_cache) != NULL)
1897     {
1898       if (hppa_debug)
1899         fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
1900           paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
1901       return (struct hppa_frame_cache *) (*this_cache);
1902     }
1903   cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1904   (*this_cache) = cache;
1905   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1906
1907   /* Yow! */
1908   u = hppa_find_unwind_entry_in_block (this_frame);
1909   if (!u)
1910     {
1911       if (hppa_debug)
1912         fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
1913       return (struct hppa_frame_cache *) (*this_cache);
1914     }
1915
1916   /* Turn the Entry_GR field into a bitmask.  */
1917   saved_gr_mask = 0;
1918   for (i = 3; i < u->Entry_GR + 3; i++)
1919     {
1920       /* Frame pointer gets saved into a special location.  */
1921       if (u->Save_SP && i == HPPA_FP_REGNUM)
1922         continue;
1923         
1924       saved_gr_mask |= (1 << i);
1925     }
1926
1927   /* Turn the Entry_FR field into a bitmask too.  */
1928   saved_fr_mask = 0;
1929   for (i = 12; i < u->Entry_FR + 12; i++)
1930     saved_fr_mask |= (1 << i);
1931
1932   /* Loop until we find everything of interest or hit a branch.
1933
1934      For unoptimized GCC code and for any HP CC code this will never ever
1935      examine any user instructions.
1936
1937      For optimized GCC code we're faced with problems.  GCC will schedule
1938      its prologue and make prologue instructions available for delay slot
1939      filling.  The end result is user code gets mixed in with the prologue
1940      and a prologue instruction may be in the delay slot of the first branch
1941      or call.
1942
1943      Some unexpected things are expected with debugging optimized code, so
1944      we allow this routine to walk past user instructions in optimized
1945      GCC code.  */
1946   {
1947     int final_iteration = 0;
1948     CORE_ADDR pc, start_pc, end_pc;
1949     int looking_for_sp = u->Save_SP;
1950     int looking_for_rp = u->Save_RP;
1951     int fp_loc = -1;
1952
1953     /* We have to use skip_prologue_hard_way instead of just 
1954        skip_prologue_using_sal, in case we stepped into a function without
1955        symbol information.  hppa_skip_prologue also bounds the returned
1956        pc by the passed in pc, so it will not return a pc in the next
1957        function.
1958        
1959        We used to call hppa_skip_prologue to find the end of the prologue,
1960        but if some non-prologue instructions get scheduled into the prologue,
1961        and the program is compiled with debug information, the "easy" way
1962        in hppa_skip_prologue will return a prologue end that is too early
1963        for us to notice any potential frame adjustments.  */
1964
1965     /* We used to use get_frame_func to locate the beginning of the
1966        function to pass to skip_prologue.  However, when objects are
1967        compiled without debug symbols, get_frame_func can return the wrong
1968        function (or 0).  We can do better than that by using unwind records.
1969        This only works if the Region_description of the unwind record
1970        indicates that it includes the entry point of the function.
1971        HP compilers sometimes generate unwind records for regions that
1972        do not include the entry or exit point of a function.  GNU tools
1973        do not do this.  */
1974
1975     if ((u->Region_description & 0x2) == 0)
1976       start_pc = u->region_start;
1977     else
1978       start_pc = get_frame_func (this_frame);
1979
1980     prologue_end = skip_prologue_hard_way (gdbarch, start_pc, 0);
1981     end_pc = get_frame_pc (this_frame);
1982
1983     if (prologue_end != 0 && end_pc > prologue_end)
1984       end_pc = prologue_end;
1985
1986     frame_size = 0;
1987
1988     for (pc = start_pc;
1989          ((saved_gr_mask || saved_fr_mask
1990            || looking_for_sp || looking_for_rp
1991            || frame_size < (u->Total_frame_size << 3))
1992           && pc < end_pc);
1993          pc += 4)
1994       {
1995         int reg;
1996         gdb_byte buf4[4];
1997         long inst;
1998
1999         if (!safe_frame_unwind_memory (this_frame, pc, buf4, sizeof buf4)) 
2000           {
2001             error (_("Cannot read instruction at %s."),
2002                    paddress (gdbarch, pc));
2003             return (struct hppa_frame_cache *) (*this_cache);
2004           }
2005
2006         inst = extract_unsigned_integer (buf4, sizeof buf4, byte_order);
2007
2008         /* Note the interesting effects of this instruction.  */
2009         frame_size += prologue_inst_adjust_sp (inst);
2010         
2011         /* There are limited ways to store the return pointer into the
2012            stack.  */
2013         if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2014           {
2015             looking_for_rp = 0;
2016             cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2017           }
2018         else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
2019           {
2020             looking_for_rp = 0;
2021             cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
2022           }
2023         else if (inst == 0x0fc212c1 
2024                  || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2025           {
2026             looking_for_rp = 0;
2027             cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2028           }
2029         
2030         /* Check to see if we saved SP into the stack.  This also
2031            happens to indicate the location of the saved frame
2032            pointer.  */
2033         if ((inst & 0xffffc000) == 0x6fc10000  /* stw,ma r1,N(sr0,sp) */
2034             || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2035           {
2036             looking_for_sp = 0;
2037             cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
2038           }
2039         else if (inst == 0x08030241) /* copy %r3, %r1 */
2040           {
2041             fp_in_r1 = 1;
2042           }
2043         
2044         /* Account for general and floating-point register saves.  */
2045         reg = inst_saves_gr (inst);
2046         if (reg >= 3 && reg <= 18
2047             && (!u->Save_SP || reg != HPPA_FP_REGNUM))
2048           {
2049             saved_gr_mask &= ~(1 << reg);
2050             if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
2051               /* stwm with a positive displacement is a _post_
2052                  _modify_.  */
2053               cache->saved_regs[reg].addr = 0;
2054             else if ((inst & 0xfc00000c) == 0x70000008)
2055               /* A std has explicit post_modify forms.  */
2056               cache->saved_regs[reg].addr = 0;
2057             else
2058               {
2059                 CORE_ADDR offset;
2060                 
2061                 if ((inst >> 26) == 0x1c)
2062                   offset = (inst & 0x1 ? -(1 << 13) : 0)
2063                     | (((inst >> 4) & 0x3ff) << 3);
2064                 else if ((inst >> 26) == 0x03)
2065                   offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
2066                 else
2067                   offset = hppa_extract_14 (inst);
2068                 
2069                 /* Handle code with and without frame pointers.  */
2070                 if (u->Save_SP)
2071                   cache->saved_regs[reg].addr = offset;
2072                 else
2073                   cache->saved_regs[reg].addr
2074                     = (u->Total_frame_size << 3) + offset;
2075               }
2076           }
2077
2078         /* GCC handles callee saved FP regs a little differently.  
2079            
2080            It emits an instruction to put the value of the start of
2081            the FP store area into %r1.  It then uses fstds,ma with a
2082            basereg of %r1 for the stores.
2083
2084            HP CC emits them at the current stack pointer modifying the
2085            stack pointer as it stores each register.  */
2086         
2087         /* ldo X(%r3),%r1 or ldo X(%r30),%r1.  */
2088         if ((inst & 0xffffc000) == 0x34610000
2089             || (inst & 0xffffc000) == 0x37c10000)
2090           fp_loc = hppa_extract_14 (inst);
2091         
2092         reg = inst_saves_fr (inst);
2093         if (reg >= 12 && reg <= 21)
2094           {
2095             /* Note +4 braindamage below is necessary because the FP
2096                status registers are internally 8 registers rather than
2097                the expected 4 registers.  */
2098             saved_fr_mask &= ~(1 << reg);
2099             if (fp_loc == -1)
2100               {
2101                 /* 1st HP CC FP register store.  After this
2102                    instruction we've set enough state that the GCC and
2103                    HPCC code are both handled in the same manner.  */
2104                 cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
2105                 fp_loc = 8;
2106               }
2107             else
2108               {
2109                 cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
2110                 fp_loc += 8;
2111               }
2112           }
2113         
2114         /* Quit if we hit any kind of branch the previous iteration.  */
2115         if (final_iteration)
2116           break;
2117         /* We want to look precisely one instruction beyond the branch
2118            if we have not found everything yet.  */
2119         if (is_branch (inst))
2120           final_iteration = 1;
2121       }
2122   }
2123
2124   {
2125     /* The frame base always represents the value of %sp at entry to
2126        the current function (and is thus equivalent to the "saved"
2127        stack pointer.  */
2128     CORE_ADDR this_sp = get_frame_register_unsigned (this_frame,
2129                                                      HPPA_SP_REGNUM);
2130     CORE_ADDR fp;
2131
2132     if (hppa_debug)
2133       fprintf_unfiltered (gdb_stdlog, " (this_sp=%s, pc=%s, "
2134                           "prologue_end=%s) ",
2135                           paddress (gdbarch, this_sp),
2136                           paddress (gdbarch, get_frame_pc (this_frame)),
2137                           paddress (gdbarch, prologue_end));
2138
2139      /* Check to see if a frame pointer is available, and use it for
2140         frame unwinding if it is.
2141  
2142         There are some situations where we need to rely on the frame
2143         pointer to do stack unwinding.  For example, if a function calls
2144         alloca (), the stack pointer can get adjusted inside the body of
2145         the function.  In this case, the ABI requires that the compiler
2146         maintain a frame pointer for the function.
2147  
2148         The unwind record has a flag (alloca_frame) that indicates that
2149         a function has a variable frame; unfortunately, gcc/binutils 
2150         does not set this flag.  Instead, whenever a frame pointer is used
2151         and saved on the stack, the Save_SP flag is set.  We use this to
2152         decide whether to use the frame pointer for unwinding.
2153         
2154         TODO: For the HP compiler, maybe we should use the alloca_frame flag 
2155         instead of Save_SP.  */
2156  
2157      fp = get_frame_register_unsigned (this_frame, HPPA_FP_REGNUM);
2158
2159      if (u->alloca_frame)
2160        fp -= u->Total_frame_size << 3;
2161  
2162      if (get_frame_pc (this_frame) >= prologue_end
2163          && (u->Save_SP || u->alloca_frame) && fp != 0)
2164       {
2165         cache->base = fp;
2166  
2167         if (hppa_debug)
2168           fprintf_unfiltered (gdb_stdlog, " (base=%s) [frame pointer]",
2169                               paddress (gdbarch, cache->base));
2170       }
2171      else if (u->Save_SP 
2172               && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
2173       {
2174             /* Both we're expecting the SP to be saved and the SP has been
2175                saved.  The entry SP value is saved at this frame's SP
2176                address.  */
2177             cache->base = read_memory_integer (this_sp, word_size, byte_order);
2178
2179             if (hppa_debug)
2180               fprintf_unfiltered (gdb_stdlog, " (base=%s) [saved]",
2181                                   paddress (gdbarch, cache->base));
2182       }
2183     else
2184       {
2185         /* The prologue has been slowly allocating stack space.  Adjust
2186            the SP back.  */
2187         cache->base = this_sp - frame_size;
2188         if (hppa_debug)
2189           fprintf_unfiltered (gdb_stdlog, " (base=%s) [unwind adjust]",
2190                               paddress (gdbarch, cache->base));
2191
2192       }
2193     trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2194   }
2195
2196   /* The PC is found in the "return register", "Millicode" uses "r31"
2197      as the return register while normal code uses "rp".  */
2198   if (u->Millicode)
2199     {
2200       if (trad_frame_addr_p (cache->saved_regs, 31))
2201         {
2202           cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
2203           if (hppa_debug)
2204             fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
2205         }
2206       else
2207         {
2208           ULONGEST r31 = get_frame_register_unsigned (this_frame, 31);
2209           trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
2210           if (hppa_debug)
2211             fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
2212         }
2213     }
2214   else
2215     {
2216       if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2217         {
2218           cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = 
2219             cache->saved_regs[HPPA_RP_REGNUM];
2220           if (hppa_debug)
2221             fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
2222         }
2223       else
2224         {
2225           ULONGEST rp = get_frame_register_unsigned (this_frame,
2226                                                      HPPA_RP_REGNUM);
2227           trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2228           if (hppa_debug)
2229             fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
2230         }
2231     }
2232
2233   /* If Save_SP is set, then we expect the frame pointer to be saved in the
2234      frame.  However, there is a one-insn window where we haven't saved it
2235      yet, but we've already clobbered it.  Detect this case and fix it up.
2236
2237      The prologue sequence for frame-pointer functions is:
2238         0: stw %rp, -20(%sp)
2239         4: copy %r3, %r1
2240         8: copy %sp, %r3
2241         c: stw,ma %r1, XX(%sp)
2242
2243      So if we are at offset c, the r3 value that we want is not yet saved
2244      on the stack, but it's been overwritten.  The prologue analyzer will
2245      set fp_in_r1 when it sees the copy insn so we know to get the value 
2246      from r1 instead.  */
2247   if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
2248       && fp_in_r1)
2249     {
2250       ULONGEST r1 = get_frame_register_unsigned (this_frame, 1);
2251       trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
2252     }
2253
2254   {
2255     /* Convert all the offsets into addresses.  */
2256     int reg;
2257     for (reg = 0; reg < gdbarch_num_regs (gdbarch); reg++)
2258       {
2259         if (trad_frame_addr_p (cache->saved_regs, reg))
2260           cache->saved_regs[reg].addr += cache->base;
2261       }
2262   }
2263
2264   {
2265     struct gdbarch_tdep *tdep;
2266
2267     tdep = gdbarch_tdep (gdbarch);
2268
2269     if (tdep->unwind_adjust_stub)
2270       tdep->unwind_adjust_stub (this_frame, cache->base, cache->saved_regs);
2271   }
2272
2273   if (hppa_debug)
2274     fprintf_unfiltered (gdb_stdlog, "base=%s }",
2275       paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
2276   return (struct hppa_frame_cache *) (*this_cache);
2277 }
2278
2279 static void
2280 hppa_frame_this_id (struct frame_info *this_frame, void **this_cache,
2281                     struct frame_id *this_id)
2282 {
2283   struct hppa_frame_cache *info;
2284   struct unwind_table_entry *u;
2285
2286   info = hppa_frame_cache (this_frame, this_cache);
2287   u = hppa_find_unwind_entry_in_block (this_frame);
2288
2289   (*this_id) = frame_id_build (info->base, u->region_start);
2290 }
2291
2292 static struct value *
2293 hppa_frame_prev_register (struct frame_info *this_frame,
2294                           void **this_cache, int regnum)
2295 {
2296   struct hppa_frame_cache *info = hppa_frame_cache (this_frame, this_cache);
2297
2298   return hppa_frame_prev_register_helper (this_frame,
2299                                           info->saved_regs, regnum);
2300 }
2301
2302 static int
2303 hppa_frame_unwind_sniffer (const struct frame_unwind *self,
2304                            struct frame_info *this_frame, void **this_cache)
2305 {
2306   if (hppa_find_unwind_entry_in_block (this_frame))
2307     return 1;
2308
2309   return 0;
2310 }
2311
2312 static const struct frame_unwind hppa_frame_unwind =
2313 {
2314   NORMAL_FRAME,
2315   default_frame_unwind_stop_reason,
2316   hppa_frame_this_id,
2317   hppa_frame_prev_register,
2318   NULL,
2319   hppa_frame_unwind_sniffer
2320 };
2321
2322 /* This is a generic fallback frame unwinder that kicks in if we fail all
2323    the other ones.  Normally we would expect the stub and regular unwinder
2324    to work, but in some cases we might hit a function that just doesn't
2325    have any unwind information available.  In this case we try to do
2326    unwinding solely based on code reading.  This is obviously going to be
2327    slow, so only use this as a last resort.  Currently this will only
2328    identify the stack and pc for the frame.  */
2329
2330 static struct hppa_frame_cache *
2331 hppa_fallback_frame_cache (struct frame_info *this_frame, void **this_cache)
2332 {
2333   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2334   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2335   struct hppa_frame_cache *cache;
2336   unsigned int frame_size = 0;
2337   int found_rp = 0;
2338   CORE_ADDR start_pc;
2339
2340   if (hppa_debug)
2341     fprintf_unfiltered (gdb_stdlog,
2342                         "{ hppa_fallback_frame_cache (frame=%d) -> ",
2343                         frame_relative_level (this_frame));
2344
2345   cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
2346   (*this_cache) = cache;
2347   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2348
2349   start_pc = get_frame_func (this_frame);
2350   if (start_pc)
2351     {
2352       CORE_ADDR cur_pc = get_frame_pc (this_frame);
2353       CORE_ADDR pc;
2354
2355       for (pc = start_pc; pc < cur_pc; pc += 4)
2356         {
2357           unsigned int insn;
2358
2359           insn = read_memory_unsigned_integer (pc, 4, byte_order);
2360           frame_size += prologue_inst_adjust_sp (insn);
2361
2362           /* There are limited ways to store the return pointer into the
2363              stack.  */
2364           if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2365             {
2366               cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2367               found_rp = 1;
2368             }
2369           else if (insn == 0x0fc212c1
2370                    || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2371             {
2372               cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2373               found_rp = 1;
2374             }
2375         }
2376     }
2377
2378   if (hppa_debug)
2379     fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
2380                         frame_size, found_rp);
2381
2382   cache->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2383   cache->base -= frame_size;
2384   trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2385
2386   if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2387     {
2388       cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
2389       cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = 
2390         cache->saved_regs[HPPA_RP_REGNUM];
2391     }
2392   else
2393     {
2394       ULONGEST rp;
2395       rp = get_frame_register_unsigned (this_frame, HPPA_RP_REGNUM);
2396       trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2397     }
2398
2399   return cache;
2400 }
2401
2402 static void
2403 hppa_fallback_frame_this_id (struct frame_info *this_frame, void **this_cache,
2404                              struct frame_id *this_id)
2405 {
2406   struct hppa_frame_cache *info = 
2407     hppa_fallback_frame_cache (this_frame, this_cache);
2408
2409   (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
2410 }
2411
2412 static struct value *
2413 hppa_fallback_frame_prev_register (struct frame_info *this_frame,
2414                                    void **this_cache, int regnum)
2415 {
2416   struct hppa_frame_cache *info
2417     = hppa_fallback_frame_cache (this_frame, this_cache);
2418
2419   return hppa_frame_prev_register_helper (this_frame,
2420                                           info->saved_regs, regnum);
2421 }
2422
2423 static const struct frame_unwind hppa_fallback_frame_unwind =
2424 {
2425   NORMAL_FRAME,
2426   default_frame_unwind_stop_reason,
2427   hppa_fallback_frame_this_id,
2428   hppa_fallback_frame_prev_register,
2429   NULL,
2430   default_frame_sniffer
2431 };
2432
2433 /* Stub frames, used for all kinds of call stubs.  */
2434 struct hppa_stub_unwind_cache
2435 {
2436   CORE_ADDR base;
2437   struct trad_frame_saved_reg *saved_regs;
2438 };
2439
2440 static struct hppa_stub_unwind_cache *
2441 hppa_stub_frame_unwind_cache (struct frame_info *this_frame,
2442                               void **this_cache)
2443 {
2444   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2445   struct hppa_stub_unwind_cache *info;
2446   struct unwind_table_entry *u;
2447
2448   if (*this_cache)
2449     return (struct hppa_stub_unwind_cache *) *this_cache;
2450
2451   info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
2452   *this_cache = info;
2453   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2454
2455   info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2456
2457   if (gdbarch_osabi (gdbarch) == GDB_OSABI_HPUX_SOM)
2458     {
2459       /* HPUX uses export stubs in function calls; the export stub clobbers
2460          the return value of the caller, and, later restores it from the
2461          stack.  */
2462       u = find_unwind_entry (get_frame_pc (this_frame));
2463
2464       if (u && u->stub_unwind.stub_type == EXPORT)
2465         {
2466           info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = info->base - 24;
2467
2468           return info;
2469         }
2470     }
2471
2472   /* By default we assume that stubs do not change the rp.  */
2473   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
2474
2475   return info;
2476 }
2477
2478 static void
2479 hppa_stub_frame_this_id (struct frame_info *this_frame,
2480                          void **this_prologue_cache,
2481                          struct frame_id *this_id)
2482 {
2483   struct hppa_stub_unwind_cache *info
2484     = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2485
2486   if (info)
2487     *this_id = frame_id_build (info->base, get_frame_func (this_frame));
2488 }
2489
2490 static struct value *
2491 hppa_stub_frame_prev_register (struct frame_info *this_frame,
2492                                void **this_prologue_cache, int regnum)
2493 {
2494   struct hppa_stub_unwind_cache *info
2495     = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2496
2497   if (info == NULL)
2498     error (_("Requesting registers from null frame."));
2499
2500   return hppa_frame_prev_register_helper (this_frame,
2501                                           info->saved_regs, regnum);
2502 }
2503
2504 static int
2505 hppa_stub_unwind_sniffer (const struct frame_unwind *self,
2506                           struct frame_info *this_frame,
2507                           void **this_cache)
2508 {
2509   CORE_ADDR pc = get_frame_address_in_block (this_frame);
2510   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2511   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2512
2513   if (pc == 0
2514       || (tdep->in_solib_call_trampoline != NULL
2515           && tdep->in_solib_call_trampoline (gdbarch, pc))
2516       || gdbarch_in_solib_return_trampoline (gdbarch, pc, NULL))
2517     return 1;
2518   return 0;
2519 }
2520
2521 static const struct frame_unwind hppa_stub_frame_unwind = {
2522   NORMAL_FRAME,
2523   default_frame_unwind_stop_reason,
2524   hppa_stub_frame_this_id,
2525   hppa_stub_frame_prev_register,
2526   NULL,
2527   hppa_stub_unwind_sniffer
2528 };
2529
2530 static struct frame_id
2531 hppa_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2532 {
2533   return frame_id_build (get_frame_register_unsigned (this_frame,
2534                                                       HPPA_SP_REGNUM),
2535                          get_frame_pc (this_frame));
2536 }
2537
2538 CORE_ADDR
2539 hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2540 {
2541   ULONGEST ipsw;
2542   CORE_ADDR pc;
2543
2544   ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
2545   pc = frame_unwind_register_unsigned (next_frame, HPPA_PCOQ_HEAD_REGNUM);
2546
2547   /* If the current instruction is nullified, then we are effectively
2548      still executing the previous instruction.  Pretend we are still
2549      there.  This is needed when single stepping; if the nullified
2550      instruction is on a different line, we don't want GDB to think
2551      we've stepped onto that line.  */
2552   if (ipsw & 0x00200000)
2553     pc -= 4;
2554
2555   return pc & ~0x3;
2556 }
2557
2558 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2559    Return NULL if no such symbol was found.  */
2560
2561 struct bound_minimal_symbol
2562 hppa_lookup_stub_minimal_symbol (const char *name,
2563                                  enum unwind_stub_types stub_type)
2564 {
2565   struct objfile *objfile;
2566   struct minimal_symbol *msym;
2567   struct bound_minimal_symbol result = { NULL, NULL };
2568
2569   ALL_MSYMBOLS (objfile, msym)
2570     {
2571       if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
2572         {
2573           struct unwind_table_entry *u;
2574
2575           u = find_unwind_entry (MSYMBOL_VALUE (msym));
2576           if (u != NULL && u->stub_unwind.stub_type == stub_type)
2577             {
2578               result.objfile = objfile;
2579               result.minsym = msym;
2580               return result;
2581             }
2582         }
2583     }
2584
2585   return result;
2586 }
2587
2588 static void
2589 unwind_command (char *exp, int from_tty)
2590 {
2591   CORE_ADDR address;
2592   struct unwind_table_entry *u;
2593
2594   /* If we have an expression, evaluate it and use it as the address.  */
2595
2596   if (exp != 0 && *exp != 0)
2597     address = parse_and_eval_address (exp);
2598   else
2599     return;
2600
2601   u = find_unwind_entry (address);
2602
2603   if (!u)
2604     {
2605       printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2606       return;
2607     }
2608
2609   printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u));
2610
2611   printf_unfiltered ("\tregion_start = %s\n", hex_string (u->region_start));
2612   gdb_flush (gdb_stdout);
2613
2614   printf_unfiltered ("\tregion_end = %s\n", hex_string (u->region_end));
2615   gdb_flush (gdb_stdout);
2616
2617 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2618
2619   printf_unfiltered ("\n\tflags =");
2620   pif (Cannot_unwind);
2621   pif (Millicode);
2622   pif (Millicode_save_sr0);
2623   pif (Entry_SR);
2624   pif (Args_stored);
2625   pif (Variable_Frame);
2626   pif (Separate_Package_Body);
2627   pif (Frame_Extension_Millicode);
2628   pif (Stack_Overflow_Check);
2629   pif (Two_Instruction_SP_Increment);
2630   pif (sr4export);
2631   pif (cxx_info);
2632   pif (cxx_try_catch);
2633   pif (sched_entry_seq);
2634   pif (Save_SP);
2635   pif (Save_RP);
2636   pif (Save_MRP_in_frame);
2637   pif (save_r19);
2638   pif (Cleanup_defined);
2639   pif (MPE_XL_interrupt_marker);
2640   pif (HP_UX_interrupt_marker);
2641   pif (Large_frame);
2642   pif (alloca_frame);
2643
2644   putchar_unfiltered ('\n');
2645
2646 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2647
2648   pin (Region_description);
2649   pin (Entry_FR);
2650   pin (Entry_GR);
2651   pin (Total_frame_size);
2652
2653   if (u->stub_unwind.stub_type)
2654     {
2655       printf_unfiltered ("\tstub type = ");
2656       switch (u->stub_unwind.stub_type)
2657         {
2658           case LONG_BRANCH:
2659             printf_unfiltered ("long branch\n");
2660             break;
2661           case PARAMETER_RELOCATION:
2662             printf_unfiltered ("parameter relocation\n");
2663             break;
2664           case EXPORT:
2665             printf_unfiltered ("export\n");
2666             break;
2667           case IMPORT:
2668             printf_unfiltered ("import\n");
2669             break;
2670           case IMPORT_SHLIB:
2671             printf_unfiltered ("import shlib\n");
2672             break;
2673           default:
2674             printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
2675         }
2676     }
2677 }
2678
2679 /* Return the GDB type object for the "standard" data type of data in
2680    register REGNUM.  */
2681
2682 static struct type *
2683 hppa32_register_type (struct gdbarch *gdbarch, int regnum)
2684 {
2685    if (regnum < HPPA_FP4_REGNUM)
2686      return builtin_type (gdbarch)->builtin_uint32;
2687    else
2688      return builtin_type (gdbarch)->builtin_float;
2689 }
2690
2691 static struct type *
2692 hppa64_register_type (struct gdbarch *gdbarch, int regnum)
2693 {
2694    if (regnum < HPPA64_FP4_REGNUM)
2695      return builtin_type (gdbarch)->builtin_uint64;
2696    else
2697      return builtin_type (gdbarch)->builtin_double;
2698 }
2699
2700 /* Return non-zero if REGNUM is not a register available to the user
2701    through ptrace/ttrace.  */
2702
2703 static int
2704 hppa32_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2705 {
2706   return (regnum == 0
2707           || regnum == HPPA_PCSQ_HEAD_REGNUM
2708           || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2709           || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
2710 }
2711
2712 static int
2713 hppa32_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2714 {
2715   /* cr26 and cr27 are readable (but not writable) from userspace.  */
2716   if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2717     return 0;
2718   else
2719     return hppa32_cannot_store_register (gdbarch, regnum);
2720 }
2721
2722 static int
2723 hppa64_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2724 {
2725   return (regnum == 0
2726           || regnum == HPPA_PCSQ_HEAD_REGNUM
2727           || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2728           || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
2729 }
2730
2731 static int
2732 hppa64_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2733 {
2734   /* cr26 and cr27 are readable (but not writable) from userspace.  */
2735   if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2736     return 0;
2737   else
2738     return hppa64_cannot_store_register (gdbarch, regnum);
2739 }
2740
2741 static CORE_ADDR
2742 hppa_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2743 {
2744   /* The low two bits of the PC on the PA contain the privilege level.
2745      Some genius implementing a (non-GCC) compiler apparently decided
2746      this means that "addresses" in a text section therefore include a
2747      privilege level, and thus symbol tables should contain these bits.
2748      This seems like a bonehead thing to do--anyway, it seems to work
2749      for our purposes to just ignore those bits.  */
2750
2751   return (addr &= ~0x3);
2752 }
2753
2754 /* Get the ARGIth function argument for the current function.  */
2755
2756 static CORE_ADDR
2757 hppa_fetch_pointer_argument (struct frame_info *frame, int argi, 
2758                              struct type *type)
2759 {
2760   return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
2761 }
2762
2763 static enum register_status
2764 hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2765                            int regnum, gdb_byte *buf)
2766 {
2767   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2768   ULONGEST tmp;
2769   enum register_status status;
2770
2771   status = regcache_raw_read_unsigned (regcache, regnum, &tmp);
2772   if (status == REG_VALID)
2773     {
2774       if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
2775         tmp &= ~0x3;
2776       store_unsigned_integer (buf, sizeof tmp, byte_order, tmp);
2777     }
2778   return status;
2779 }
2780
2781 static CORE_ADDR
2782 hppa_find_global_pointer (struct gdbarch *gdbarch, struct value *function)
2783 {
2784   return 0;
2785 }
2786
2787 struct value *
2788 hppa_frame_prev_register_helper (struct frame_info *this_frame,
2789                                  struct trad_frame_saved_reg saved_regs[],
2790                                  int regnum)
2791 {
2792   struct gdbarch *arch = get_frame_arch (this_frame);
2793   enum bfd_endian byte_order = gdbarch_byte_order (arch);
2794
2795   if (regnum == HPPA_PCOQ_TAIL_REGNUM)
2796     {
2797       int size = register_size (arch, HPPA_PCOQ_HEAD_REGNUM);
2798       CORE_ADDR pc;
2799       struct value *pcoq_val =
2800         trad_frame_get_prev_register (this_frame, saved_regs,
2801                                       HPPA_PCOQ_HEAD_REGNUM);
2802
2803       pc = extract_unsigned_integer (value_contents_all (pcoq_val),
2804                                      size, byte_order);
2805       return frame_unwind_got_constant (this_frame, regnum, pc + 4);
2806     }
2807
2808   return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
2809 }
2810 \f
2811
2812 /* An instruction to match.  */
2813 struct insn_pattern
2814 {
2815   unsigned int data;            /* See if it matches this....  */
2816   unsigned int mask;            /* ... with this mask.  */
2817 };
2818
2819 /* See bfd/elf32-hppa.c */
2820 static struct insn_pattern hppa_long_branch_stub[] = {
2821   /* ldil LR'xxx,%r1 */
2822   { 0x20200000, 0xffe00000 },
2823   /* be,n RR'xxx(%sr4,%r1) */
2824   { 0xe0202002, 0xffe02002 }, 
2825   { 0, 0 }
2826 };
2827
2828 static struct insn_pattern hppa_long_branch_pic_stub[] = {
2829   /* b,l .+8, %r1 */
2830   { 0xe8200000, 0xffe00000 },
2831   /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2832   { 0x28200000, 0xffe00000 },
2833   /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2834   { 0xe0202002, 0xffe02002 }, 
2835   { 0, 0 }
2836 };
2837
2838 static struct insn_pattern hppa_import_stub[] = {
2839   /* addil LR'xxx, %dp */
2840   { 0x2b600000, 0xffe00000 },
2841   /* ldw RR'xxx(%r1), %r21 */
2842   { 0x48350000, 0xffffb000 },
2843   /* bv %r0(%r21) */
2844   { 0xeaa0c000, 0xffffffff },
2845   /* ldw RR'xxx+4(%r1), %r19 */
2846   { 0x48330000, 0xffffb000 },
2847   { 0, 0 }
2848 };
2849
2850 static struct insn_pattern hppa_import_pic_stub[] = {
2851   /* addil LR'xxx,%r19 */
2852   { 0x2a600000, 0xffe00000 },
2853   /* ldw RR'xxx(%r1),%r21 */
2854   { 0x48350000, 0xffffb000 },
2855   /* bv %r0(%r21) */
2856   { 0xeaa0c000, 0xffffffff },
2857   /* ldw RR'xxx+4(%r1),%r19 */
2858   { 0x48330000, 0xffffb000 },
2859   { 0, 0 },
2860 };
2861
2862 static struct insn_pattern hppa_plt_stub[] = {
2863   /* b,l 1b, %r20 - 1b is 3 insns before here */
2864   { 0xea9f1fdd, 0xffffffff },
2865   /* depi 0,31,2,%r20 */
2866   { 0xd6801c1e, 0xffffffff },
2867   { 0, 0 }
2868 };
2869
2870 /* Maximum number of instructions on the patterns above.  */
2871 #define HPPA_MAX_INSN_PATTERN_LEN       4
2872
2873 /* Return non-zero if the instructions at PC match the series
2874    described in PATTERN, or zero otherwise.  PATTERN is an array of
2875    'struct insn_pattern' objects, terminated by an entry whose mask is
2876    zero.
2877
2878    When the match is successful, fill INSN[i] with what PATTERN[i]
2879    matched.  */
2880
2881 static int
2882 hppa_match_insns (struct gdbarch *gdbarch, CORE_ADDR pc,
2883                   struct insn_pattern *pattern, unsigned int *insn)
2884 {
2885   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2886   CORE_ADDR npc = pc;
2887   int i;
2888
2889   for (i = 0; pattern[i].mask; i++)
2890     {
2891       gdb_byte buf[HPPA_INSN_SIZE];
2892
2893       target_read_memory (npc, buf, HPPA_INSN_SIZE);
2894       insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE, byte_order);
2895       if ((insn[i] & pattern[i].mask) == pattern[i].data)
2896         npc += 4;
2897       else
2898         return 0;
2899     }
2900
2901   return 1;
2902 }
2903
2904 /* This relaxed version of the insstruction matcher allows us to match
2905    from somewhere inside the pattern, by looking backwards in the
2906    instruction scheme.  */
2907
2908 static int
2909 hppa_match_insns_relaxed (struct gdbarch *gdbarch, CORE_ADDR pc,
2910                           struct insn_pattern *pattern, unsigned int *insn)
2911 {
2912   int offset, len = 0;
2913
2914   while (pattern[len].mask)
2915     len++;
2916
2917   for (offset = 0; offset < len; offset++)
2918     if (hppa_match_insns (gdbarch, pc - offset * HPPA_INSN_SIZE,
2919                           pattern, insn))
2920       return 1;
2921
2922   return 0;
2923 }
2924
2925 static int
2926 hppa_in_dyncall (CORE_ADDR pc)
2927 {
2928   struct unwind_table_entry *u;
2929
2930   u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2931   if (!u)
2932     return 0;
2933
2934   return (pc >= u->region_start && pc <= u->region_end);
2935 }
2936
2937 int
2938 hppa_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc)
2939 {
2940   unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2941   struct unwind_table_entry *u;
2942
2943   if (in_plt_section (pc) || hppa_in_dyncall (pc))
2944     return 1;
2945
2946   /* The GNU toolchain produces linker stubs without unwind
2947      information.  Since the pattern matching for linker stubs can be
2948      quite slow, so bail out if we do have an unwind entry.  */
2949
2950   u = find_unwind_entry (pc);
2951   if (u != NULL)
2952     return 0;
2953
2954   return
2955     (hppa_match_insns_relaxed (gdbarch, pc, hppa_import_stub, insn)
2956      || hppa_match_insns_relaxed (gdbarch, pc, hppa_import_pic_stub, insn)
2957      || hppa_match_insns_relaxed (gdbarch, pc, hppa_long_branch_stub, insn)
2958      || hppa_match_insns_relaxed (gdbarch, pc,
2959                                   hppa_long_branch_pic_stub, insn));
2960 }
2961
2962 /* This code skips several kind of "trampolines" used on PA-RISC
2963    systems: $$dyncall, import stubs and PLT stubs.  */
2964
2965 CORE_ADDR
2966 hppa_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
2967 {
2968   struct gdbarch *gdbarch = get_frame_arch (frame);
2969   struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
2970
2971   unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2972   int dp_rel;
2973
2974   /* $$dyncall handles both PLABELs and direct addresses.  */
2975   if (hppa_in_dyncall (pc))
2976     {
2977       pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22);
2978
2979       /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it.  */
2980       if (pc & 0x2)
2981         pc = read_memory_typed_address (pc & ~0x3, func_ptr_type);
2982
2983       return pc;
2984     }
2985
2986   dp_rel = hppa_match_insns (gdbarch, pc, hppa_import_stub, insn);
2987   if (dp_rel || hppa_match_insns (gdbarch, pc, hppa_import_pic_stub, insn))
2988     {
2989       /* Extract the target address from the addil/ldw sequence.  */
2990       pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
2991
2992       if (dp_rel)
2993         pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
2994       else
2995         pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
2996
2997       /* fallthrough */
2998     }
2999
3000   if (in_plt_section (pc))
3001     {
3002       pc = read_memory_typed_address (pc, func_ptr_type);
3003
3004       /* If the PLT slot has not yet been resolved, the target will be
3005          the PLT stub.  */
3006       if (in_plt_section (pc))
3007         {
3008           /* Sanity check: are we pointing to the PLT stub?  */
3009           if (!hppa_match_insns (gdbarch, pc, hppa_plt_stub, insn))
3010             {
3011               warning (_("Cannot resolve PLT stub at %s."),
3012                        paddress (gdbarch, pc));
3013               return 0;
3014             }
3015
3016           /* This should point to the fixup routine.  */
3017           pc = read_memory_typed_address (pc + 8, func_ptr_type);
3018         }
3019     }
3020
3021   return pc;
3022 }
3023 \f
3024
3025 /* Here is a table of C type sizes on hppa with various compiles
3026    and options.  I measured this on PA 9000/800 with HP-UX 11.11
3027    and these compilers:
3028
3029      /usr/ccs/bin/cc    HP92453-01 A.11.01.21
3030      /opt/ansic/bin/cc  HP92453-01 B.11.11.28706.GP
3031      /opt/aCC/bin/aCC   B3910B A.03.45
3032      gcc                gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3033
3034      cc            : 1 2 4 4 8 : 4 8 -- : 4 4
3035      ansic +DA1.1  : 1 2 4 4 8 : 4 8 16 : 4 4
3036      ansic +DA2.0  : 1 2 4 4 8 : 4 8 16 : 4 4
3037      ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3038      acc   +DA1.1  : 1 2 4 4 8 : 4 8 16 : 4 4
3039      acc   +DA2.0  : 1 2 4 4 8 : 4 8 16 : 4 4
3040      acc   +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3041      gcc           : 1 2 4 4 8 : 4 8 16 : 4 4
3042
3043    Each line is:
3044
3045      compiler and options
3046      char, short, int, long, long long
3047      float, double, long double
3048      char *, void (*)()
3049
3050    So all these compilers use either ILP32 or LP64 model.
3051    TODO: gcc has more options so it needs more investigation.
3052
3053    For floating point types, see:
3054
3055      http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3056      HP-UX floating-point guide, hpux 11.00
3057
3058    -- chastain 2003-12-18  */
3059
3060 static struct gdbarch *
3061 hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3062 {
3063   struct gdbarch_tdep *tdep;
3064   struct gdbarch *gdbarch;
3065   
3066   /* Try to determine the ABI of the object we are loading.  */
3067   if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
3068     {
3069       /* If it's a SOM file, assume it's HP/UX SOM.  */
3070       if (bfd_get_flavour (info.abfd) == bfd_target_som_flavour)
3071         info.osabi = GDB_OSABI_HPUX_SOM;
3072     }
3073
3074   /* find a candidate among the list of pre-declared architectures.  */
3075   arches = gdbarch_list_lookup_by_info (arches, &info);
3076   if (arches != NULL)
3077     return (arches->gdbarch);
3078
3079   /* If none found, then allocate and initialize one.  */
3080   tdep = XCNEW (struct gdbarch_tdep);
3081   gdbarch = gdbarch_alloc (&info, tdep);
3082
3083   /* Determine from the bfd_arch_info structure if we are dealing with
3084      a 32 or 64 bits architecture.  If the bfd_arch_info is not available,
3085      then default to a 32bit machine.  */
3086   if (info.bfd_arch_info != NULL)
3087     tdep->bytes_per_address =
3088       info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
3089   else
3090     tdep->bytes_per_address = 4;
3091
3092   tdep->find_global_pointer = hppa_find_global_pointer;
3093
3094   /* Some parts of the gdbarch vector depend on whether we are running
3095      on a 32 bits or 64 bits target.  */
3096   switch (tdep->bytes_per_address)
3097     {
3098       case 4:
3099         set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
3100         set_gdbarch_register_name (gdbarch, hppa32_register_name);
3101         set_gdbarch_register_type (gdbarch, hppa32_register_type);
3102         set_gdbarch_cannot_store_register (gdbarch,
3103                                            hppa32_cannot_store_register);
3104         set_gdbarch_cannot_fetch_register (gdbarch,
3105                                            hppa32_cannot_fetch_register);
3106         break;
3107       case 8:
3108         set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
3109         set_gdbarch_register_name (gdbarch, hppa64_register_name);
3110         set_gdbarch_register_type (gdbarch, hppa64_register_type);
3111         set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
3112         set_gdbarch_cannot_store_register (gdbarch,
3113                                            hppa64_cannot_store_register);
3114         set_gdbarch_cannot_fetch_register (gdbarch,
3115                                            hppa64_cannot_fetch_register);
3116         break;
3117       default:
3118         internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
3119                         tdep->bytes_per_address);
3120     }
3121
3122   set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3123   set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3124
3125   /* The following gdbarch vector elements are the same in both ILP32
3126      and LP64, but might show differences some day.  */
3127   set_gdbarch_long_long_bit (gdbarch, 64);
3128   set_gdbarch_long_double_bit (gdbarch, 128);
3129   set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3130
3131   /* The following gdbarch vector elements do not depend on the address
3132      size, or in any other gdbarch element previously set.  */
3133   set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
3134   set_gdbarch_stack_frame_destroyed_p (gdbarch,
3135                                        hppa_stack_frame_destroyed_p);
3136   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
3137   set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM);
3138   set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM);
3139   set_gdbarch_addr_bits_remove (gdbarch, hppa_addr_bits_remove);
3140   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3141   set_gdbarch_read_pc (gdbarch, hppa_read_pc);
3142   set_gdbarch_write_pc (gdbarch, hppa_write_pc);
3143
3144   /* Helper for function argument information.  */
3145   set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
3146
3147   set_gdbarch_print_insn (gdbarch, print_insn_hppa);
3148
3149   /* When a hardware watchpoint triggers, we'll move the inferior past
3150      it by removing all eventpoints; stepping past the instruction
3151      that caused the trigger; reinserting eventpoints; and checking
3152      whether any watched location changed.  */
3153   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
3154
3155   /* Inferior function call methods.  */
3156   switch (tdep->bytes_per_address)
3157     {
3158     case 4:
3159       set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
3160       set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
3161       set_gdbarch_convert_from_func_ptr_addr
3162         (gdbarch, hppa32_convert_from_func_ptr_addr);
3163       break;
3164     case 8:
3165       set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
3166       set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
3167       break;
3168     default:
3169       internal_error (__FILE__, __LINE__, _("bad switch"));
3170     }
3171       
3172   /* Struct return methods.  */
3173   switch (tdep->bytes_per_address)
3174     {
3175     case 4:
3176       set_gdbarch_return_value (gdbarch, hppa32_return_value);
3177       break;
3178     case 8:
3179       set_gdbarch_return_value (gdbarch, hppa64_return_value);
3180       break;
3181     default:
3182       internal_error (__FILE__, __LINE__, _("bad switch"));
3183     }
3184       
3185   SET_GDBARCH_BREAKPOINT_MANIPULATION (hppa);
3186   set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
3187
3188   /* Frame unwind methods.  */
3189   set_gdbarch_dummy_id (gdbarch, hppa_dummy_id);
3190   set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
3191
3192   /* Hook in ABI-specific overrides, if they have been registered.  */
3193   gdbarch_init_osabi (info, gdbarch);
3194
3195   /* Hook in the default unwinders.  */
3196   frame_unwind_append_unwinder (gdbarch, &hppa_stub_frame_unwind);
3197   frame_unwind_append_unwinder (gdbarch, &hppa_frame_unwind);
3198   frame_unwind_append_unwinder (gdbarch, &hppa_fallback_frame_unwind);
3199
3200   return gdbarch;
3201 }
3202
3203 static void
3204 hppa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3205 {
3206   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3207
3208   fprintf_unfiltered (file, "bytes_per_address = %d\n", 
3209                       tdep->bytes_per_address);
3210   fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
3211 }
3212
3213 /* Provide a prototype to silence -Wmissing-prototypes.  */
3214 extern initialize_file_ftype _initialize_hppa_tdep;
3215
3216 void
3217 _initialize_hppa_tdep (void)
3218 {
3219   gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
3220
3221   hppa_objfile_priv_data = register_objfile_data ();
3222
3223   add_cmd ("unwind", class_maintenance, unwind_command,
3224            _("Print unwind table entry at given address."),
3225            &maintenanceprintlist);
3226
3227   /* Debug this files internals.  */
3228   add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
3229 Set whether hppa target specific debugging information should be displayed."),
3230                            _("\
3231 Show whether hppa target specific debugging information is displayed."), _("\
3232 This flag controls whether hppa target specific debugging information is\n\
3233 displayed.  This information is particularly useful for debugging frame\n\
3234 unwinding problems."),
3235                            NULL,
3236                            NULL, /* FIXME: i18n: hppa debug flag is %s.  */
3237                            &setdebuglist, &showdebuglist);
3238 }