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