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