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