1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986-2015 Free Software Foundation, Inc.
5 Contributed by the Center for Software Science at the
6 University of Utah (pa-gdb-bugs@cs.utah.edu).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "completer.h"
29 #include "arch-utils.h"
30 /* For argument passing to the inferior. */
33 #include "trad-frame.h"
34 #include "frame-unwind.h"
35 #include "frame-base.h"
41 #include "hppa-tdep.h"
43 static int hppa_debug = 0;
45 /* Some local constants. */
46 static const int hppa32_num_regs = 128;
47 static const int hppa64_num_regs = 96;
49 /* We use the objfile->obj_private pointer for two things:
52 * 2. A pointer to any associated shared library object.
54 * #defines are used to help refer to these objects.
57 /* Info about the unwind table associated with an object file.
58 * This is hung off of the "objfile->obj_private" pointer, and
59 * is allocated in the objfile's psymbol obstack. This allows
60 * us to have unique unwind info for each executable and shared
61 * library that we are debugging.
63 struct hppa_unwind_info
65 struct unwind_table_entry *table; /* Pointer to unwind info */
66 struct unwind_table_entry *cache; /* Pointer to last entry we found */
67 int last; /* Index of last entry */
70 struct hppa_objfile_private
72 struct hppa_unwind_info *unwind_info; /* a pointer */
73 struct so_list *so_info; /* a pointer */
76 int dummy_call_sequence_reg;
77 CORE_ADDR dummy_call_sequence_addr;
80 /* hppa-specific object data -- unwind and solib info.
81 TODO/maybe: think about splitting this into two parts; the unwind data is
82 common to all hppa targets, but is only used in this file; we can register
83 that separately and make this static. The solib data is probably hpux-
84 specific, so we can create a separate extern objfile_data that is registered
85 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
86 static const struct objfile_data *hppa_objfile_priv_data = NULL;
88 /* Get at various relevent fields of an instruction word. */
91 #define MASK_14 0x3fff
92 #define MASK_21 0x1fffff
94 /* Sizes (in bytes) of the native unwind entries. */
95 #define UNWIND_ENTRY_SIZE 16
96 #define STUB_UNWIND_ENTRY_SIZE 8
98 /* Routines to extract various sized constants out of hppa
101 /* This assumes that no garbage lies outside of the lower bits of
105 hppa_sign_extend (unsigned val, unsigned bits)
107 return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
110 /* For many immediate values the sign bit is the low bit! */
113 hppa_low_hppa_sign_extend (unsigned val, unsigned bits)
115 return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
118 /* Extract the bits at positions between FROM and TO, using HP's numbering
122 hppa_get_field (unsigned word, int from, int to)
124 return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1));
127 /* Extract the immediate field from a ld{bhw}s instruction. */
130 hppa_extract_5_load (unsigned word)
132 return hppa_low_hppa_sign_extend (word >> 16 & MASK_5, 5);
135 /* Extract the immediate field from a break instruction. */
138 hppa_extract_5r_store (unsigned word)
140 return (word & MASK_5);
143 /* Extract the immediate field from a {sr}sm instruction. */
146 hppa_extract_5R_store (unsigned word)
148 return (word >> 16 & MASK_5);
151 /* Extract a 14 bit immediate field. */
154 hppa_extract_14 (unsigned word)
156 return hppa_low_hppa_sign_extend (word & MASK_14, 14);
159 /* Extract a 21 bit constant. */
162 hppa_extract_21 (unsigned word)
168 val = hppa_get_field (word, 20, 20);
170 val |= hppa_get_field (word, 9, 19);
172 val |= hppa_get_field (word, 5, 6);
174 val |= hppa_get_field (word, 0, 4);
176 val |= hppa_get_field (word, 7, 8);
177 return hppa_sign_extend (val, 21) << 11;
180 /* extract a 17 bit constant from branch instructions, returning the
181 19 bit signed value. */
184 hppa_extract_17 (unsigned word)
186 return hppa_sign_extend (hppa_get_field (word, 19, 28) |
187 hppa_get_field (word, 29, 29) << 10 |
188 hppa_get_field (word, 11, 15) << 11 |
189 (word & 0x1) << 16, 17) << 2;
193 hppa_symbol_address(const char *sym)
195 struct bound_minimal_symbol minsym;
197 minsym = lookup_minimal_symbol (sym, NULL, NULL);
199 return BMSYMBOL_VALUE_ADDRESS (minsym);
201 return (CORE_ADDR)-1;
204 static struct hppa_objfile_private *
205 hppa_init_objfile_priv_data (struct objfile *objfile)
207 struct hppa_objfile_private *priv;
209 priv = (struct hppa_objfile_private *)
210 obstack_alloc (&objfile->objfile_obstack,
211 sizeof (struct hppa_objfile_private));
212 set_objfile_data (objfile, hppa_objfile_priv_data, priv);
213 memset (priv, 0, sizeof (*priv));
219 /* Compare the start address for two unwind entries returning 1 if
220 the first address is larger than the second, -1 if the second is
221 larger than the first, and zero if they are equal. */
224 compare_unwind_entries (const void *arg1, const void *arg2)
226 const struct unwind_table_entry *a = (const struct unwind_table_entry *) arg1;
227 const struct unwind_table_entry *b = (const struct unwind_table_entry *) arg2;
229 if (a->region_start > b->region_start)
231 else if (a->region_start < b->region_start)
238 record_text_segment_lowaddr (bfd *abfd, asection *section, void *data)
240 if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
241 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
243 bfd_vma value = section->vma - section->filepos;
244 CORE_ADDR *low_text_segment_address = (CORE_ADDR *)data;
246 if (value < *low_text_segment_address)
247 *low_text_segment_address = value;
252 internalize_unwinds (struct objfile *objfile, struct unwind_table_entry *table,
253 asection *section, unsigned int entries,
254 size_t size, CORE_ADDR text_offset)
256 /* We will read the unwind entries into temporary memory, then
257 fill in the actual unwind table. */
261 struct gdbarch *gdbarch = get_objfile_arch (objfile);
264 char *buf = (char *) alloca (size);
265 CORE_ADDR low_text_segment_address;
267 /* For ELF targets, then unwinds are supposed to
268 be segment relative offsets instead of absolute addresses.
270 Note that when loading a shared library (text_offset != 0) the
271 unwinds are already relative to the text_offset that will be
273 if (gdbarch_tdep (gdbarch)->is_elf && text_offset == 0)
275 low_text_segment_address = -1;
277 bfd_map_over_sections (objfile->obfd,
278 record_text_segment_lowaddr,
279 &low_text_segment_address);
281 text_offset = low_text_segment_address;
283 else if (gdbarch_tdep (gdbarch)->solib_get_text_base)
285 text_offset = gdbarch_tdep (gdbarch)->solib_get_text_base (objfile);
288 bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
290 /* Now internalize the information being careful to handle host/target
292 for (i = 0; i < entries; i++)
294 table[i].region_start = bfd_get_32 (objfile->obfd,
296 table[i].region_start += text_offset;
298 table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
299 table[i].region_end += text_offset;
301 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
303 table[i].Cannot_unwind = (tmp >> 31) & 0x1;
304 table[i].Millicode = (tmp >> 30) & 0x1;
305 table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
306 table[i].Region_description = (tmp >> 27) & 0x3;
307 table[i].reserved = (tmp >> 26) & 0x1;
308 table[i].Entry_SR = (tmp >> 25) & 0x1;
309 table[i].Entry_FR = (tmp >> 21) & 0xf;
310 table[i].Entry_GR = (tmp >> 16) & 0x1f;
311 table[i].Args_stored = (tmp >> 15) & 0x1;
312 table[i].Variable_Frame = (tmp >> 14) & 0x1;
313 table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
314 table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
315 table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
316 table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
317 table[i].sr4export = (tmp >> 9) & 0x1;
318 table[i].cxx_info = (tmp >> 8) & 0x1;
319 table[i].cxx_try_catch = (tmp >> 7) & 0x1;
320 table[i].sched_entry_seq = (tmp >> 6) & 0x1;
321 table[i].reserved1 = (tmp >> 5) & 0x1;
322 table[i].Save_SP = (tmp >> 4) & 0x1;
323 table[i].Save_RP = (tmp >> 3) & 0x1;
324 table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
325 table[i].save_r19 = (tmp >> 1) & 0x1;
326 table[i].Cleanup_defined = tmp & 0x1;
327 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
329 table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
330 table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
331 table[i].Large_frame = (tmp >> 29) & 0x1;
332 table[i].alloca_frame = (tmp >> 28) & 0x1;
333 table[i].reserved2 = (tmp >> 27) & 0x1;
334 table[i].Total_frame_size = tmp & 0x7ffffff;
336 /* Stub unwinds are handled elsewhere. */
337 table[i].stub_unwind.stub_type = 0;
338 table[i].stub_unwind.padding = 0;
343 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
344 the object file. This info is used mainly by find_unwind_entry() to find
345 out the stack frame size and frame pointer used by procedures. We put
346 everything on the psymbol obstack in the objfile so that it automatically
347 gets freed when the objfile is destroyed. */
350 read_unwind_info (struct objfile *objfile)
352 asection *unwind_sec, *stub_unwind_sec;
353 size_t unwind_size, stub_unwind_size, total_size;
354 unsigned index, unwind_entries;
355 unsigned stub_entries, total_entries;
356 CORE_ADDR text_offset;
357 struct hppa_unwind_info *ui;
358 struct hppa_objfile_private *obj_private;
360 text_offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
361 ui = (struct hppa_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
362 sizeof (struct hppa_unwind_info));
368 /* For reasons unknown the HP PA64 tools generate multiple unwinder
369 sections in a single executable. So we just iterate over every
370 section in the BFD looking for unwinder sections intead of trying
371 to do a lookup with bfd_get_section_by_name.
373 First determine the total size of the unwind tables so that we
374 can allocate memory in a nice big hunk. */
376 for (unwind_sec = objfile->obfd->sections;
378 unwind_sec = unwind_sec->next)
380 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
381 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
383 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
384 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
386 total_entries += unwind_entries;
390 /* Now compute the size of the stub unwinds. Note the ELF tools do not
391 use stub unwinds at the current time. */
392 stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
396 stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
397 stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
401 stub_unwind_size = 0;
405 /* Compute total number of unwind entries and their total size. */
406 total_entries += stub_entries;
407 total_size = total_entries * sizeof (struct unwind_table_entry);
409 /* Allocate memory for the unwind table. */
410 ui->table = (struct unwind_table_entry *)
411 obstack_alloc (&objfile->objfile_obstack, total_size);
412 ui->last = total_entries - 1;
414 /* Now read in each unwind section and internalize the standard unwind
417 for (unwind_sec = objfile->obfd->sections;
419 unwind_sec = unwind_sec->next)
421 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
422 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
424 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
425 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
427 internalize_unwinds (objfile, &ui->table[index], unwind_sec,
428 unwind_entries, unwind_size, text_offset);
429 index += unwind_entries;
433 /* Now read in and internalize the stub unwind entries. */
434 if (stub_unwind_size > 0)
437 char *buf = (char *) alloca (stub_unwind_size);
439 /* Read in the stub unwind entries. */
440 bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
441 0, stub_unwind_size);
443 /* Now convert them into regular unwind entries. */
444 for (i = 0; i < stub_entries; i++, index++)
446 /* Clear out the next unwind entry. */
447 memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
449 /* Convert offset & size into region_start and region_end.
450 Stuff away the stub type into "reserved" fields. */
451 ui->table[index].region_start = bfd_get_32 (objfile->obfd,
453 ui->table[index].region_start += text_offset;
455 ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
458 ui->table[index].region_end
459 = ui->table[index].region_start + 4 *
460 (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
466 /* Unwind table needs to be kept sorted. */
467 qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
468 compare_unwind_entries);
470 /* Keep a pointer to the unwind information. */
471 obj_private = (struct hppa_objfile_private *)
472 objfile_data (objfile, hppa_objfile_priv_data);
473 if (obj_private == NULL)
474 obj_private = hppa_init_objfile_priv_data (objfile);
476 obj_private->unwind_info = ui;
479 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
480 of the objfiles seeking the unwind table entry for this PC. Each objfile
481 contains a sorted list of struct unwind_table_entry. Since we do a binary
482 search of the unwind tables, we depend upon them to be sorted. */
484 struct unwind_table_entry *
485 find_unwind_entry (CORE_ADDR pc)
487 int first, middle, last;
488 struct objfile *objfile;
489 struct hppa_objfile_private *priv;
492 fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry %s -> ",
495 /* A function at address 0? Not in HP-UX! */
496 if (pc == (CORE_ADDR) 0)
499 fprintf_unfiltered (gdb_stdlog, "NULL }\n");
503 ALL_OBJFILES (objfile)
505 struct hppa_unwind_info *ui;
507 priv = ((struct hppa_objfile_private *)
508 objfile_data (objfile, hppa_objfile_priv_data));
510 ui = ((struct hppa_objfile_private *) priv)->unwind_info;
514 read_unwind_info (objfile);
515 priv = ((struct hppa_objfile_private *)
516 objfile_data (objfile, hppa_objfile_priv_data));
518 error (_("Internal error reading unwind information."));
519 ui = ((struct hppa_objfile_private *) priv)->unwind_info;
522 /* First, check the cache. */
525 && pc >= ui->cache->region_start
526 && pc <= ui->cache->region_end)
529 fprintf_unfiltered (gdb_stdlog, "%s (cached) }\n",
530 hex_string ((uintptr_t) ui->cache));
534 /* Not in the cache, do a binary search. */
539 while (first <= last)
541 middle = (first + last) / 2;
542 if (pc >= ui->table[middle].region_start
543 && pc <= ui->table[middle].region_end)
545 ui->cache = &ui->table[middle];
547 fprintf_unfiltered (gdb_stdlog, "%s }\n",
548 hex_string ((uintptr_t) ui->cache));
549 return &ui->table[middle];
552 if (pc < ui->table[middle].region_start)
557 } /* ALL_OBJFILES() */
560 fprintf_unfiltered (gdb_stdlog, "NULL (not found) }\n");
565 /* Implement the stack_frame_destroyed_p gdbarch method.
567 The epilogue is defined here as the area either on the `bv' instruction
568 itself or an instruction which destroys the function's stack frame.
570 We do not assume that the epilogue is at the end of a function as we can
571 also have return sequences in the middle of a function. */
574 hppa_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
576 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
577 unsigned long status;
581 status = target_read_memory (pc, buf, 4);
585 inst = extract_unsigned_integer (buf, 4, byte_order);
587 /* The most common way to perform a stack adjustment ldo X(sp),sp
588 We are destroying a stack frame if the offset is negative. */
589 if ((inst & 0xffffc000) == 0x37de0000
590 && hppa_extract_14 (inst) < 0)
593 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
594 if (((inst & 0x0fc010e0) == 0x0fc010e0
595 || (inst & 0x0fc010e0) == 0x0fc010e0)
596 && hppa_extract_14 (inst) < 0)
599 /* bv %r0(%rp) or bv,n %r0(%rp) */
600 if (inst == 0xe840c000 || inst == 0xe840c002)
606 static const unsigned char *
607 hppa_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
609 static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
610 (*len) = sizeof (breakpoint);
614 /* Return the name of a register. */
617 hppa32_register_name (struct gdbarch *gdbarch, int i)
619 static char *names[] = {
620 "flags", "r1", "rp", "r3",
621 "r4", "r5", "r6", "r7",
622 "r8", "r9", "r10", "r11",
623 "r12", "r13", "r14", "r15",
624 "r16", "r17", "r18", "r19",
625 "r20", "r21", "r22", "r23",
626 "r24", "r25", "r26", "dp",
627 "ret0", "ret1", "sp", "r31",
628 "sar", "pcoqh", "pcsqh", "pcoqt",
629 "pcsqt", "eiem", "iir", "isr",
630 "ior", "ipsw", "goto", "sr4",
631 "sr0", "sr1", "sr2", "sr3",
632 "sr5", "sr6", "sr7", "cr0",
633 "cr8", "cr9", "ccr", "cr12",
634 "cr13", "cr24", "cr25", "cr26",
635 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
636 "fpsr", "fpe1", "fpe2", "fpe3",
637 "fpe4", "fpe5", "fpe6", "fpe7",
638 "fr4", "fr4R", "fr5", "fr5R",
639 "fr6", "fr6R", "fr7", "fr7R",
640 "fr8", "fr8R", "fr9", "fr9R",
641 "fr10", "fr10R", "fr11", "fr11R",
642 "fr12", "fr12R", "fr13", "fr13R",
643 "fr14", "fr14R", "fr15", "fr15R",
644 "fr16", "fr16R", "fr17", "fr17R",
645 "fr18", "fr18R", "fr19", "fr19R",
646 "fr20", "fr20R", "fr21", "fr21R",
647 "fr22", "fr22R", "fr23", "fr23R",
648 "fr24", "fr24R", "fr25", "fr25R",
649 "fr26", "fr26R", "fr27", "fr27R",
650 "fr28", "fr28R", "fr29", "fr29R",
651 "fr30", "fr30R", "fr31", "fr31R"
653 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
660 hppa64_register_name (struct gdbarch *gdbarch, int i)
662 static char *names[] = {
663 "flags", "r1", "rp", "r3",
664 "r4", "r5", "r6", "r7",
665 "r8", "r9", "r10", "r11",
666 "r12", "r13", "r14", "r15",
667 "r16", "r17", "r18", "r19",
668 "r20", "r21", "r22", "r23",
669 "r24", "r25", "r26", "dp",
670 "ret0", "ret1", "sp", "r31",
671 "sar", "pcoqh", "pcsqh", "pcoqt",
672 "pcsqt", "eiem", "iir", "isr",
673 "ior", "ipsw", "goto", "sr4",
674 "sr0", "sr1", "sr2", "sr3",
675 "sr5", "sr6", "sr7", "cr0",
676 "cr8", "cr9", "ccr", "cr12",
677 "cr13", "cr24", "cr25", "cr26",
678 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
679 "fpsr", "fpe1", "fpe2", "fpe3",
680 "fr4", "fr5", "fr6", "fr7",
681 "fr8", "fr9", "fr10", "fr11",
682 "fr12", "fr13", "fr14", "fr15",
683 "fr16", "fr17", "fr18", "fr19",
684 "fr20", "fr21", "fr22", "fr23",
685 "fr24", "fr25", "fr26", "fr27",
686 "fr28", "fr29", "fr30", "fr31"
688 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
694 /* Map dwarf DBX register numbers to GDB register numbers. */
696 hppa64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
698 /* The general registers and the sar are the same in both sets. */
702 /* fr4-fr31 are mapped from 72 in steps of 2. */
703 if (reg >= 72 && reg < 72 + 28 * 2 && !(reg & 1))
704 return HPPA64_FP4_REGNUM + (reg - 72) / 2;
706 warning (_("Unmapped DWARF DBX Register #%d encountered."), reg);
710 /* This function pushes a stack frame with arguments as part of the
711 inferior function calling mechanism.
713 This is the version of the function for the 32-bit PA machines, in
714 which later arguments appear at lower addresses. (The stack always
715 grows towards higher addresses.)
717 We simply allocate the appropriate amount of stack space and put
718 arguments into their proper slots. */
721 hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
722 struct regcache *regcache, CORE_ADDR bp_addr,
723 int nargs, struct value **args, CORE_ADDR sp,
724 int struct_return, CORE_ADDR struct_addr)
726 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
728 /* Stack base address at which any pass-by-reference parameters are
730 CORE_ADDR struct_end = 0;
731 /* Stack base address at which the first parameter is stored. */
732 CORE_ADDR param_end = 0;
734 /* The inner most end of the stack after all the parameters have
736 CORE_ADDR new_sp = 0;
738 /* Two passes. First pass computes the location of everything,
739 second pass writes the bytes out. */
742 /* Global pointer (r19) of the function we are trying to call. */
745 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
747 for (write_pass = 0; write_pass < 2; write_pass++)
749 CORE_ADDR struct_ptr = 0;
750 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
751 struct_ptr is adjusted for each argument below, so the first
752 argument will end up at sp-36. */
753 CORE_ADDR param_ptr = 32;
755 int small_struct = 0;
757 for (i = 0; i < nargs; i++)
759 struct value *arg = args[i];
760 struct type *type = check_typedef (value_type (arg));
761 /* The corresponding parameter that is pushed onto the
762 stack, and [possibly] passed in a register. */
763 gdb_byte param_val[8];
765 memset (param_val, 0, sizeof param_val);
766 if (TYPE_LENGTH (type) > 8)
768 /* Large parameter, pass by reference. Store the value
769 in "struct" area and then pass its address. */
771 struct_ptr += align_up (TYPE_LENGTH (type), 8);
773 write_memory (struct_end - struct_ptr, value_contents (arg),
775 store_unsigned_integer (param_val, 4, byte_order,
776 struct_end - struct_ptr);
778 else if (TYPE_CODE (type) == TYPE_CODE_INT
779 || TYPE_CODE (type) == TYPE_CODE_ENUM)
781 /* Integer value store, right aligned. "unpack_long"
782 takes care of any sign-extension problems. */
783 param_len = align_up (TYPE_LENGTH (type), 4);
784 store_unsigned_integer (param_val, param_len, byte_order,
786 value_contents (arg)));
788 else if (TYPE_CODE (type) == TYPE_CODE_FLT)
790 /* Floating point value store, right aligned. */
791 param_len = align_up (TYPE_LENGTH (type), 4);
792 memcpy (param_val, value_contents (arg), param_len);
796 param_len = align_up (TYPE_LENGTH (type), 4);
798 /* Small struct value are stored right-aligned. */
799 memcpy (param_val + param_len - TYPE_LENGTH (type),
800 value_contents (arg), TYPE_LENGTH (type));
802 /* Structures of size 5, 6 and 7 bytes are special in that
803 the higher-ordered word is stored in the lower-ordered
804 argument, and even though it is a 8-byte quantity the
805 registers need not be 8-byte aligned. */
806 if (param_len > 4 && param_len < 8)
810 param_ptr += param_len;
811 if (param_len == 8 && !small_struct)
812 param_ptr = align_up (param_ptr, 8);
814 /* First 4 non-FP arguments are passed in gr26-gr23.
815 First 4 32-bit FP arguments are passed in fr4L-fr7L.
816 First 2 64-bit FP arguments are passed in fr5 and fr7.
818 The rest go on the stack, starting at sp-36, towards lower
819 addresses. 8-byte arguments must be aligned to a 8-byte
823 write_memory (param_end - param_ptr, param_val, param_len);
825 /* There are some cases when we don't know the type
826 expected by the callee (e.g. for variadic functions), so
827 pass the parameters in both general and fp regs. */
830 int grreg = 26 - (param_ptr - 36) / 4;
831 int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
832 int fpreg = 74 + (param_ptr - 32) / 8 * 4;
834 regcache_cooked_write (regcache, grreg, param_val);
835 regcache_cooked_write (regcache, fpLreg, param_val);
839 regcache_cooked_write (regcache, grreg + 1,
842 regcache_cooked_write (regcache, fpreg, param_val);
843 regcache_cooked_write (regcache, fpreg + 1,
850 /* Update the various stack pointers. */
853 struct_end = sp + align_up (struct_ptr, 64);
854 /* PARAM_PTR already accounts for all the arguments passed
855 by the user. However, the ABI mandates minimum stack
856 space allocations for outgoing arguments. The ABI also
857 mandates minimum stack alignments which we must
859 param_end = struct_end + align_up (param_ptr, 64);
863 /* If a structure has to be returned, set up register 28 to hold its
866 regcache_cooked_write_unsigned (regcache, 28, struct_addr);
868 gp = tdep->find_global_pointer (gdbarch, function);
871 regcache_cooked_write_unsigned (regcache, 19, gp);
873 /* Set the return address. */
874 if (!gdbarch_push_dummy_code_p (gdbarch))
875 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
877 /* Update the Stack Pointer. */
878 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end);
883 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
884 Runtime Architecture for PA-RISC 2.0", which is distributed as part
885 as of the HP-UX Software Transition Kit (STK). This implementation
886 is based on version 3.3, dated October 6, 1997. */
888 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
891 hppa64_integral_or_pointer_p (const struct type *type)
893 switch (TYPE_CODE (type))
899 case TYPE_CODE_RANGE:
901 int len = TYPE_LENGTH (type);
902 return (len == 1 || len == 2 || len == 4 || len == 8);
906 return (TYPE_LENGTH (type) == 8);
914 /* Check whether TYPE is a "Floating Scalar Type". */
917 hppa64_floating_p (const struct type *type)
919 switch (TYPE_CODE (type))
923 int len = TYPE_LENGTH (type);
924 return (len == 4 || len == 8 || len == 16);
933 /* If CODE points to a function entry address, try to look up the corresponding
934 function descriptor and return its address instead. If CODE is not a
935 function entry address, then just return it unchanged. */
937 hppa64_convert_code_addr_to_fptr (struct gdbarch *gdbarch, CORE_ADDR code)
939 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
940 struct obj_section *sec, *opd;
942 sec = find_pc_section (code);
947 /* If CODE is in a data section, assume it's already a fptr. */
948 if (!(sec->the_bfd_section->flags & SEC_CODE))
951 ALL_OBJFILE_OSECTIONS (sec->objfile, opd)
953 if (strcmp (opd->the_bfd_section->name, ".opd") == 0)
957 if (opd < sec->objfile->sections_end)
961 for (addr = obj_section_addr (opd);
962 addr < obj_section_endaddr (opd);
968 if (target_read_memory (addr, tmp, sizeof (tmp)))
970 opdaddr = extract_unsigned_integer (tmp, sizeof (tmp), byte_order);
981 hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
982 struct regcache *regcache, CORE_ADDR bp_addr,
983 int nargs, struct value **args, CORE_ADDR sp,
984 int struct_return, CORE_ADDR struct_addr)
986 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
987 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
991 /* "The outgoing parameter area [...] must be aligned at a 16-byte
993 sp = align_up (sp, 16);
995 for (i = 0; i < nargs; i++)
997 struct value *arg = args[i];
998 struct type *type = value_type (arg);
999 int len = TYPE_LENGTH (type);
1000 const bfd_byte *valbuf;
1001 bfd_byte fptrbuf[8];
1004 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
1005 offset = align_up (offset, 8);
1007 if (hppa64_integral_or_pointer_p (type))
1009 /* "Integral scalar parameters smaller than 64 bits are
1010 padded on the left (i.e., the value is in the
1011 least-significant bits of the 64-bit storage unit, and
1012 the high-order bits are undefined)." Therefore we can
1013 safely sign-extend them. */
1016 arg = value_cast (builtin_type (gdbarch)->builtin_int64, arg);
1020 else if (hppa64_floating_p (type))
1024 /* "Quad-precision (128-bit) floating-point scalar
1025 parameters are aligned on a 16-byte boundary." */
1026 offset = align_up (offset, 16);
1028 /* "Double-extended- and quad-precision floating-point
1029 parameters within the first 64 bytes of the parameter
1030 list are always passed in general registers." */
1036 /* "Single-precision (32-bit) floating-point scalar
1037 parameters are padded on the left with 32 bits of
1038 garbage (i.e., the floating-point value is in the
1039 least-significant 32 bits of a 64-bit storage
1044 /* "Single- and double-precision floating-point
1045 parameters in this area are passed according to the
1046 available formal parameter information in a function
1047 prototype. [...] If no prototype is in scope,
1048 floating-point parameters must be passed both in the
1049 corresponding general registers and in the
1050 corresponding floating-point registers." */
1051 regnum = HPPA64_FP4_REGNUM + offset / 8;
1053 if (regnum < HPPA64_FP4_REGNUM + 8)
1055 /* "Single-precision floating-point parameters, when
1056 passed in floating-point registers, are passed in
1057 the right halves of the floating point registers;
1058 the left halves are unused." */
1059 regcache_cooked_write_part (regcache, regnum, offset % 8,
1060 len, value_contents (arg));
1068 /* "Aggregates larger than 8 bytes are aligned on a
1069 16-byte boundary, possibly leaving an unused argument
1070 slot, which is filled with garbage. If necessary,
1071 they are padded on the right (with garbage), to a
1072 multiple of 8 bytes." */
1073 offset = align_up (offset, 16);
1077 /* If we are passing a function pointer, make sure we pass a function
1078 descriptor instead of the function entry address. */
1079 if (TYPE_CODE (type) == TYPE_CODE_PTR
1080 && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1082 ULONGEST codeptr, fptr;
1084 codeptr = unpack_long (type, value_contents (arg));
1085 fptr = hppa64_convert_code_addr_to_fptr (gdbarch, codeptr);
1086 store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), byte_order,
1092 valbuf = value_contents (arg);
1095 /* Always store the argument in memory. */
1096 write_memory (sp + offset, valbuf, len);
1098 regnum = HPPA_ARG0_REGNUM - offset / 8;
1099 while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
1101 regcache_cooked_write_part (regcache, regnum,
1102 offset % 8, min (len, 8), valbuf);
1103 offset += min (len, 8);
1104 valbuf += min (len, 8);
1105 len -= min (len, 8);
1112 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1113 regcache_cooked_write_unsigned (regcache, HPPA_RET1_REGNUM, sp + 64);
1115 /* Allocate the outgoing parameter area. Make sure the outgoing
1116 parameter area is multiple of 16 bytes in length. */
1117 sp += max (align_up (offset, 16), 64);
1119 /* Allocate 32-bytes of scratch space. The documentation doesn't
1120 mention this, but it seems to be needed. */
1123 /* Allocate the frame marker area. */
1126 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1129 regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
1131 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1132 gp = tdep->find_global_pointer (gdbarch, function);
1134 regcache_cooked_write_unsigned (regcache, HPPA_DP_REGNUM, gp);
1136 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1137 if (!gdbarch_push_dummy_code_p (gdbarch))
1138 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
1140 /* Set up GR30 to hold the stack pointer (sp). */
1141 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, sp);
1147 /* Handle 32/64-bit struct return conventions. */
1149 static enum return_value_convention
1150 hppa32_return_value (struct gdbarch *gdbarch, struct value *function,
1151 struct type *type, struct regcache *regcache,
1152 gdb_byte *readbuf, const gdb_byte *writebuf)
1154 if (TYPE_LENGTH (type) <= 2 * 4)
1156 /* The value always lives in the right hand end of the register
1157 (or register pair)? */
1159 int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
1160 int part = TYPE_LENGTH (type) % 4;
1161 /* The left hand register contains only part of the value,
1162 transfer that first so that the rest can be xfered as entire
1163 4-byte registers. */
1166 if (readbuf != NULL)
1167 regcache_cooked_read_part (regcache, reg, 4 - part,
1169 if (writebuf != NULL)
1170 regcache_cooked_write_part (regcache, reg, 4 - part,
1174 /* Now transfer the remaining register values. */
1175 for (b = part; b < TYPE_LENGTH (type); b += 4)
1177 if (readbuf != NULL)
1178 regcache_cooked_read (regcache, reg, readbuf + b);
1179 if (writebuf != NULL)
1180 regcache_cooked_write (regcache, reg, writebuf + b);
1183 return RETURN_VALUE_REGISTER_CONVENTION;
1186 return RETURN_VALUE_STRUCT_CONVENTION;
1189 static enum return_value_convention
1190 hppa64_return_value (struct gdbarch *gdbarch, struct value *function,
1191 struct type *type, struct regcache *regcache,
1192 gdb_byte *readbuf, const gdb_byte *writebuf)
1194 int len = TYPE_LENGTH (type);
1199 /* All return values larget than 128 bits must be aggregate
1201 gdb_assert (!hppa64_integral_or_pointer_p (type));
1202 gdb_assert (!hppa64_floating_p (type));
1204 /* "Aggregate return values larger than 128 bits are returned in
1205 a buffer allocated by the caller. The address of the buffer
1206 must be passed in GR 28." */
1207 return RETURN_VALUE_STRUCT_CONVENTION;
1210 if (hppa64_integral_or_pointer_p (type))
1212 /* "Integral return values are returned in GR 28. Values
1213 smaller than 64 bits are padded on the left (with garbage)." */
1214 regnum = HPPA_RET0_REGNUM;
1217 else if (hppa64_floating_p (type))
1221 /* "Double-extended- and quad-precision floating-point
1222 values are returned in GRs 28 and 29. The sign,
1223 exponent, and most-significant bits of the mantissa are
1224 returned in GR 28; the least-significant bits of the
1225 mantissa are passed in GR 29. For double-extended
1226 precision values, GR 29 is padded on the right with 48
1227 bits of garbage." */
1228 regnum = HPPA_RET0_REGNUM;
1233 /* "Single-precision and double-precision floating-point
1234 return values are returned in FR 4R (single precision) or
1235 FR 4 (double-precision)." */
1236 regnum = HPPA64_FP4_REGNUM;
1242 /* "Aggregate return values up to 64 bits in size are returned
1243 in GR 28. Aggregates smaller than 64 bits are left aligned
1244 in the register; the pad bits on the right are undefined."
1246 "Aggregate return values between 65 and 128 bits are returned
1247 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1248 the remaining bits are placed, left aligned, in GR 29. The
1249 pad bits on the right of GR 29 (if any) are undefined." */
1250 regnum = HPPA_RET0_REGNUM;
1258 regcache_cooked_read_part (regcache, regnum, offset,
1259 min (len, 8), readbuf);
1260 readbuf += min (len, 8);
1261 len -= min (len, 8);
1270 regcache_cooked_write_part (regcache, regnum, offset,
1271 min (len, 8), writebuf);
1272 writebuf += min (len, 8);
1273 len -= min (len, 8);
1278 return RETURN_VALUE_REGISTER_CONVENTION;
1283 hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1284 struct target_ops *targ)
1288 struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1289 CORE_ADDR plabel = addr & ~3;
1290 return read_memory_typed_address (plabel, func_ptr_type);
1297 hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1299 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1301 return align_up (addr, 64);
1304 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1307 hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1309 /* Just always 16-byte align. */
1310 return align_up (addr, 16);
1314 hppa_read_pc (struct regcache *regcache)
1319 regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
1320 regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
1322 /* If the current instruction is nullified, then we are effectively
1323 still executing the previous instruction. Pretend we are still
1324 there. This is needed when single stepping; if the nullified
1325 instruction is on a different line, we don't want GDB to think
1326 we've stepped onto that line. */
1327 if (ipsw & 0x00200000)
1334 hppa_write_pc (struct regcache *regcache, CORE_ADDR pc)
1336 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pc);
1337 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pc + 4);
1340 /* For the given instruction (INST), return any adjustment it makes
1341 to the stack pointer or zero for no adjustment.
1343 This only handles instructions commonly found in prologues. */
1346 prologue_inst_adjust_sp (unsigned long inst)
1348 /* This must persist across calls. */
1349 static int save_high21;
1351 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1352 if ((inst & 0xffffc000) == 0x37de0000)
1353 return hppa_extract_14 (inst);
1356 if ((inst & 0xffe00000) == 0x6fc00000)
1357 return hppa_extract_14 (inst);
1359 /* std,ma X,D(sp) */
1360 if ((inst & 0xffe00008) == 0x73c00008)
1361 return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
1363 /* addil high21,%r30; ldo low11,(%r1),%r30)
1364 save high bits in save_high21 for later use. */
1365 if ((inst & 0xffe00000) == 0x2bc00000)
1367 save_high21 = hppa_extract_21 (inst);
1371 if ((inst & 0xffff0000) == 0x343e0000)
1372 return save_high21 + hppa_extract_14 (inst);
1374 /* fstws as used by the HP compilers. */
1375 if ((inst & 0xffffffe0) == 0x2fd01220)
1376 return hppa_extract_5_load (inst);
1378 /* No adjustment. */
1382 /* Return nonzero if INST is a branch of some kind, else return zero. */
1385 is_branch (unsigned long inst)
1414 /* Return the register number for a GR which is saved by INST or
1415 zero if INST does not save a GR.
1420 https://parisc.wiki.kernel.org/images-parisc/6/68/Pa11_acd.pdf
1423 https://parisc.wiki.kernel.org/images-parisc/7/73/Parisc2.0.pdf
1425 According to Table 6-5 of Chapter 6 (Memory Reference Instructions)
1426 on page 106 in parisc 2.0, all instructions for storing values from
1427 the general registers are:
1429 Store: stb, sth, stw, std (according to Chapter 7, they
1430 are only in both "inst >> 26" and "inst >> 6".
1431 Store Absolute: stwa, stda (according to Chapter 7, they are only
1433 Store Bytes: stby, stdby (according to Chapter 7, they are
1434 only in "inst >> 6").
1436 For (inst >> 26), according to Chapter 7:
1438 The effective memory reference address is formed by the addition
1439 of an immediate displacement to a base value.
1441 - stb: 0x18, store a byte from a general register.
1443 - sth: 0x19, store a halfword from a general register.
1445 - stw: 0x1a, store a word from a general register.
1447 - stwm: 0x1b, store a word from a general register and perform base
1448 register modification (2.0 will still treate it as stw).
1450 - std: 0x1c, store a doubleword from a general register (2.0 only).
1452 - stw: 0x1f, store a word from a general register (2.0 only).
1454 For (inst >> 6) when ((inst >> 26) == 0x03), according to Chapter 7:
1456 The effective memory reference address is formed by the addition
1457 of an index value to a base value specified in the instruction.
1459 - stb: 0x08, store a byte from a general register (1.1 calls stbs).
1461 - sth: 0x09, store a halfword from a general register (1.1 calls
1464 - stw: 0x0a, store a word from a general register (1.1 calls stws).
1466 - std: 0x0b: store a doubleword from a general register (2.0 only)
1468 Implement fast byte moves (stores) to unaligned word or doubleword
1471 - stby: 0x0c, for unaligned word (1.1 calls stbys).
1473 - stdby: 0x0d for unaligned doubleword (2.0 only).
1475 Store a word or doubleword using an absolute memory address formed
1476 using short or long displacement or indexed
1478 - stwa: 0x0e, store a word from a general register to an absolute
1479 address (1.0 calls stwas).
1481 - stda: 0x0f, store a doubleword from a general register to an
1482 absolute address (2.0 only). */
1485 inst_saves_gr (unsigned long inst)
1487 switch ((inst >> 26) & 0x0f)
1490 switch ((inst >> 6) & 0x0f)
1500 return hppa_extract_5R_store (inst);
1509 /* no 0x1d or 0x1e -- according to parisc 2.0 document */
1511 return hppa_extract_5R_store (inst);
1517 /* Return the register number for a FR which is saved by INST or
1518 zero it INST does not save a FR.
1520 Note we only care about full 64bit register stores (that's the only
1521 kind of stores the prologue will use).
1523 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1526 inst_saves_fr (unsigned long inst)
1528 /* Is this an FSTD? */
1529 if ((inst & 0xfc00dfc0) == 0x2c001200)
1530 return hppa_extract_5r_store (inst);
1531 if ((inst & 0xfc000002) == 0x70000002)
1532 return hppa_extract_5R_store (inst);
1533 /* Is this an FSTW? */
1534 if ((inst & 0xfc00df80) == 0x24001200)
1535 return hppa_extract_5r_store (inst);
1536 if ((inst & 0xfc000002) == 0x7c000000)
1537 return hppa_extract_5R_store (inst);
1541 /* Advance PC across any function entry prologue instructions
1542 to reach some "real" code.
1544 Use information in the unwind table to determine what exactly should
1545 be in the prologue. */
1549 skip_prologue_hard_way (struct gdbarch *gdbarch, CORE_ADDR pc,
1550 int stop_before_branch)
1552 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1554 CORE_ADDR orig_pc = pc;
1555 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1556 unsigned long args_stored, status, i, restart_gr, restart_fr;
1557 struct unwind_table_entry *u;
1558 int final_iteration;
1564 u = find_unwind_entry (pc);
1568 /* If we are not at the beginning of a function, then return now. */
1569 if ((pc & ~0x3) != u->region_start)
1572 /* This is how much of a frame adjustment we need to account for. */
1573 stack_remaining = u->Total_frame_size << 3;
1575 /* Magic register saves we want to know about. */
1576 save_rp = u->Save_RP;
1577 save_sp = u->Save_SP;
1579 /* An indication that args may be stored into the stack. Unfortunately
1580 the HPUX compilers tend to set this in cases where no args were
1584 /* Turn the Entry_GR field into a bitmask. */
1586 for (i = 3; i < u->Entry_GR + 3; i++)
1588 /* Frame pointer gets saved into a special location. */
1589 if (u->Save_SP && i == HPPA_FP_REGNUM)
1592 save_gr |= (1 << i);
1594 save_gr &= ~restart_gr;
1596 /* Turn the Entry_FR field into a bitmask too. */
1598 for (i = 12; i < u->Entry_FR + 12; i++)
1599 save_fr |= (1 << i);
1600 save_fr &= ~restart_fr;
1602 final_iteration = 0;
1604 /* Loop until we find everything of interest or hit a branch.
1606 For unoptimized GCC code and for any HP CC code this will never ever
1607 examine any user instructions.
1609 For optimzied GCC code we're faced with problems. GCC will schedule
1610 its prologue and make prologue instructions available for delay slot
1611 filling. The end result is user code gets mixed in with the prologue
1612 and a prologue instruction may be in the delay slot of the first branch
1615 Some unexpected things are expected with debugging optimized code, so
1616 we allow this routine to walk past user instructions in optimized
1618 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1621 unsigned int reg_num;
1622 unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1623 unsigned long old_save_rp, old_save_sp, next_inst;
1625 /* Save copies of all the triggers so we can compare them later
1627 old_save_gr = save_gr;
1628 old_save_fr = save_fr;
1629 old_save_rp = save_rp;
1630 old_save_sp = save_sp;
1631 old_stack_remaining = stack_remaining;
1633 status = target_read_memory (pc, buf, 4);
1634 inst = extract_unsigned_integer (buf, 4, byte_order);
1640 /* Note the interesting effects of this instruction. */
1641 stack_remaining -= prologue_inst_adjust_sp (inst);
1643 /* There are limited ways to store the return pointer into the
1645 if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1648 /* These are the only ways we save SP into the stack. At this time
1649 the HP compilers never bother to save SP into the stack. */
1650 if ((inst & 0xffffc000) == 0x6fc10000
1651 || (inst & 0xffffc00c) == 0x73c10008)
1654 /* Are we loading some register with an offset from the argument
1656 if ((inst & 0xffe00000) == 0x37a00000
1657 || (inst & 0xffffffe0) == 0x081d0240)
1663 /* Account for general and floating-point register saves. */
1664 reg_num = inst_saves_gr (inst);
1665 save_gr &= ~(1 << reg_num);
1667 /* Ugh. Also account for argument stores into the stack.
1668 Unfortunately args_stored only tells us that some arguments
1669 where stored into the stack. Not how many or what kind!
1671 This is a kludge as on the HP compiler sets this bit and it
1672 never does prologue scheduling. So once we see one, skip past
1673 all of them. We have similar code for the fp arg stores below.
1675 FIXME. Can still die if we have a mix of GR and FR argument
1677 if (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1680 while (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1684 status = target_read_memory (pc, buf, 4);
1685 inst = extract_unsigned_integer (buf, 4, byte_order);
1688 reg_num = inst_saves_gr (inst);
1694 reg_num = inst_saves_fr (inst);
1695 save_fr &= ~(1 << reg_num);
1697 status = target_read_memory (pc + 4, buf, 4);
1698 next_inst = extract_unsigned_integer (buf, 4, byte_order);
1704 /* We've got to be read to handle the ldo before the fp register
1706 if ((inst & 0xfc000000) == 0x34000000
1707 && inst_saves_fr (next_inst) >= 4
1708 && inst_saves_fr (next_inst)
1709 <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1711 /* So we drop into the code below in a reasonable state. */
1712 reg_num = inst_saves_fr (next_inst);
1716 /* Ugh. Also account for argument stores into the stack.
1717 This is a kludge as on the HP compiler sets this bit and it
1718 never does prologue scheduling. So once we see one, skip past
1721 && reg_num <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1725 <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1728 status = target_read_memory (pc, buf, 4);
1729 inst = extract_unsigned_integer (buf, 4, byte_order);
1732 if ((inst & 0xfc000000) != 0x34000000)
1734 status = target_read_memory (pc + 4, buf, 4);
1735 next_inst = extract_unsigned_integer (buf, 4, byte_order);
1738 reg_num = inst_saves_fr (next_inst);
1744 /* Quit if we hit any kind of branch. This can happen if a prologue
1745 instruction is in the delay slot of the first call/branch. */
1746 if (is_branch (inst) && stop_before_branch)
1749 /* What a crock. The HP compilers set args_stored even if no
1750 arguments were stored into the stack (boo hiss). This could
1751 cause this code to then skip a bunch of user insns (up to the
1754 To combat this we try to identify when args_stored was bogusly
1755 set and clear it. We only do this when args_stored is nonzero,
1756 all other resources are accounted for, and nothing changed on
1759 && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1760 && old_save_gr == save_gr && old_save_fr == save_fr
1761 && old_save_rp == save_rp && old_save_sp == save_sp
1762 && old_stack_remaining == stack_remaining)
1768 /* !stop_before_branch, so also look at the insn in the delay slot
1770 if (final_iteration)
1772 if (is_branch (inst))
1773 final_iteration = 1;
1776 /* We've got a tenative location for the end of the prologue. However
1777 because of limitations in the unwind descriptor mechanism we may
1778 have went too far into user code looking for the save of a register
1779 that does not exist. So, if there registers we expected to be saved
1780 but never were, mask them out and restart.
1782 This should only happen in optimized code, and should be very rare. */
1783 if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1786 restart_gr = save_gr;
1787 restart_fr = save_fr;
1795 /* Return the address of the PC after the last prologue instruction if
1796 we can determine it from the debug symbols. Else return zero. */
1799 after_prologue (CORE_ADDR pc)
1801 struct symtab_and_line sal;
1802 CORE_ADDR func_addr, func_end;
1804 /* If we can not find the symbol in the partial symbol table, then
1805 there is no hope we can determine the function's start address
1807 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1810 /* Get the line associated with FUNC_ADDR. */
1811 sal = find_pc_line (func_addr, 0);
1813 /* There are only two cases to consider. First, the end of the source line
1814 is within the function bounds. In that case we return the end of the
1815 source line. Second is the end of the source line extends beyond the
1816 bounds of the current function. We need to use the slow code to
1817 examine instructions in that case.
1819 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1820 the wrong thing to do. In fact, it should be entirely possible for this
1821 function to always return zero since the slow instruction scanning code
1822 is supposed to *always* work. If it does not, then it is a bug. */
1823 if (sal.end < func_end)
1829 /* To skip prologues, I use this predicate. Returns either PC itself
1830 if the code at PC does not look like a function prologue; otherwise
1831 returns an address that (if we're lucky) follows the prologue.
1833 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1834 It doesn't necessarily skips all the insns in the prologue. In fact
1835 we might not want to skip all the insns because a prologue insn may
1836 appear in the delay slot of the first branch, and we don't want to
1837 skip over the branch in that case. */
1840 hppa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1842 CORE_ADDR post_prologue_pc;
1844 /* See if we can determine the end of the prologue via the symbol table.
1845 If so, then return either PC, or the PC after the prologue, whichever
1848 post_prologue_pc = after_prologue (pc);
1850 /* If after_prologue returned a useful address, then use it. Else
1851 fall back on the instruction skipping code.
1853 Some folks have claimed this causes problems because the breakpoint
1854 may be the first instruction of the prologue. If that happens, then
1855 the instruction skipping code has a bug that needs to be fixed. */
1856 if (post_prologue_pc != 0)
1857 return max (pc, post_prologue_pc);
1859 return (skip_prologue_hard_way (gdbarch, pc, 1));
1862 /* Return an unwind entry that falls within the frame's code block. */
1864 static struct unwind_table_entry *
1865 hppa_find_unwind_entry_in_block (struct frame_info *this_frame)
1867 CORE_ADDR pc = get_frame_address_in_block (this_frame);
1869 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1870 result of get_frame_address_in_block implies a problem.
1871 The bits should have been removed earlier, before the return
1872 value of gdbarch_unwind_pc. That might be happening already;
1873 if it isn't, it should be fixed. Then this call can be
1875 pc = gdbarch_addr_bits_remove (get_frame_arch (this_frame), pc);
1876 return find_unwind_entry (pc);
1879 struct hppa_frame_cache
1882 struct trad_frame_saved_reg *saved_regs;
1885 static struct hppa_frame_cache *
1886 hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
1888 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1889 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1890 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1891 struct hppa_frame_cache *cache;
1895 struct unwind_table_entry *u;
1896 CORE_ADDR prologue_end;
1901 fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
1902 frame_relative_level(this_frame));
1904 if ((*this_cache) != NULL)
1907 fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
1908 paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
1909 return (struct hppa_frame_cache *) (*this_cache);
1911 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1912 (*this_cache) = cache;
1913 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1916 u = hppa_find_unwind_entry_in_block (this_frame);
1920 fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
1921 return (struct hppa_frame_cache *) (*this_cache);
1924 /* Turn the Entry_GR field into a bitmask. */
1926 for (i = 3; i < u->Entry_GR + 3; i++)
1928 /* Frame pointer gets saved into a special location. */
1929 if (u->Save_SP && i == HPPA_FP_REGNUM)
1932 saved_gr_mask |= (1 << i);
1935 /* Turn the Entry_FR field into a bitmask too. */
1937 for (i = 12; i < u->Entry_FR + 12; i++)
1938 saved_fr_mask |= (1 << i);
1940 /* Loop until we find everything of interest or hit a branch.
1942 For unoptimized GCC code and for any HP CC code this will never ever
1943 examine any user instructions.
1945 For optimized GCC code we're faced with problems. GCC will schedule
1946 its prologue and make prologue instructions available for delay slot
1947 filling. The end result is user code gets mixed in with the prologue
1948 and a prologue instruction may be in the delay slot of the first branch
1951 Some unexpected things are expected with debugging optimized code, so
1952 we allow this routine to walk past user instructions in optimized
1955 int final_iteration = 0;
1956 CORE_ADDR pc, start_pc, end_pc;
1957 int looking_for_sp = u->Save_SP;
1958 int looking_for_rp = u->Save_RP;
1961 /* We have to use skip_prologue_hard_way instead of just
1962 skip_prologue_using_sal, in case we stepped into a function without
1963 symbol information. hppa_skip_prologue also bounds the returned
1964 pc by the passed in pc, so it will not return a pc in the next
1967 We used to call hppa_skip_prologue to find the end of the prologue,
1968 but if some non-prologue instructions get scheduled into the prologue,
1969 and the program is compiled with debug information, the "easy" way
1970 in hppa_skip_prologue will return a prologue end that is too early
1971 for us to notice any potential frame adjustments. */
1973 /* We used to use get_frame_func to locate the beginning of the
1974 function to pass to skip_prologue. However, when objects are
1975 compiled without debug symbols, get_frame_func can return the wrong
1976 function (or 0). We can do better than that by using unwind records.
1977 This only works if the Region_description of the unwind record
1978 indicates that it includes the entry point of the function.
1979 HP compilers sometimes generate unwind records for regions that
1980 do not include the entry or exit point of a function. GNU tools
1983 if ((u->Region_description & 0x2) == 0)
1984 start_pc = u->region_start;
1986 start_pc = get_frame_func (this_frame);
1988 prologue_end = skip_prologue_hard_way (gdbarch, start_pc, 0);
1989 end_pc = get_frame_pc (this_frame);
1991 if (prologue_end != 0 && end_pc > prologue_end)
1992 end_pc = prologue_end;
1997 ((saved_gr_mask || saved_fr_mask
1998 || looking_for_sp || looking_for_rp
1999 || frame_size < (u->Total_frame_size << 3))
2007 if (!safe_frame_unwind_memory (this_frame, pc, buf4, sizeof buf4))
2009 error (_("Cannot read instruction at %s."),
2010 paddress (gdbarch, pc));
2011 return (struct hppa_frame_cache *) (*this_cache);
2014 inst = extract_unsigned_integer (buf4, sizeof buf4, byte_order);
2016 /* Note the interesting effects of this instruction. */
2017 frame_size += prologue_inst_adjust_sp (inst);
2019 /* There are limited ways to store the return pointer into the
2021 if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2024 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2026 else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
2029 cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
2031 else if (inst == 0x0fc212c1
2032 || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2035 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2038 /* Check to see if we saved SP into the stack. This also
2039 happens to indicate the location of the saved frame
2041 if ((inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
2042 || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2045 cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
2047 else if (inst == 0x08030241) /* copy %r3, %r1 */
2052 /* Account for general and floating-point register saves. */
2053 reg = inst_saves_gr (inst);
2054 if (reg >= 3 && reg <= 18
2055 && (!u->Save_SP || reg != HPPA_FP_REGNUM))
2057 saved_gr_mask &= ~(1 << reg);
2058 if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
2059 /* stwm with a positive displacement is a _post_
2061 cache->saved_regs[reg].addr = 0;
2062 else if ((inst & 0xfc00000c) == 0x70000008)
2063 /* A std has explicit post_modify forms. */
2064 cache->saved_regs[reg].addr = 0;
2069 if ((inst >> 26) == 0x1c)
2070 offset = (inst & 0x1 ? -1 << 13 : 0)
2071 | (((inst >> 4) & 0x3ff) << 3);
2072 else if ((inst >> 26) == 0x03)
2073 offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
2075 offset = hppa_extract_14 (inst);
2077 /* Handle code with and without frame pointers. */
2079 cache->saved_regs[reg].addr = offset;
2081 cache->saved_regs[reg].addr
2082 = (u->Total_frame_size << 3) + offset;
2086 /* GCC handles callee saved FP regs a little differently.
2088 It emits an instruction to put the value of the start of
2089 the FP store area into %r1. It then uses fstds,ma with a
2090 basereg of %r1 for the stores.
2092 HP CC emits them at the current stack pointer modifying the
2093 stack pointer as it stores each register. */
2095 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2096 if ((inst & 0xffffc000) == 0x34610000
2097 || (inst & 0xffffc000) == 0x37c10000)
2098 fp_loc = hppa_extract_14 (inst);
2100 reg = inst_saves_fr (inst);
2101 if (reg >= 12 && reg <= 21)
2103 /* Note +4 braindamage below is necessary because the FP
2104 status registers are internally 8 registers rather than
2105 the expected 4 registers. */
2106 saved_fr_mask &= ~(1 << reg);
2109 /* 1st HP CC FP register store. After this
2110 instruction we've set enough state that the GCC and
2111 HPCC code are both handled in the same manner. */
2112 cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
2117 cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
2122 /* Quit if we hit any kind of branch the previous iteration. */
2123 if (final_iteration)
2125 /* We want to look precisely one instruction beyond the branch
2126 if we have not found everything yet. */
2127 if (is_branch (inst))
2128 final_iteration = 1;
2133 /* The frame base always represents the value of %sp at entry to
2134 the current function (and is thus equivalent to the "saved"
2136 CORE_ADDR this_sp = get_frame_register_unsigned (this_frame,
2141 fprintf_unfiltered (gdb_stdlog, " (this_sp=%s, pc=%s, "
2142 "prologue_end=%s) ",
2143 paddress (gdbarch, this_sp),
2144 paddress (gdbarch, get_frame_pc (this_frame)),
2145 paddress (gdbarch, prologue_end));
2147 /* Check to see if a frame pointer is available, and use it for
2148 frame unwinding if it is.
2150 There are some situations where we need to rely on the frame
2151 pointer to do stack unwinding. For example, if a function calls
2152 alloca (), the stack pointer can get adjusted inside the body of
2153 the function. In this case, the ABI requires that the compiler
2154 maintain a frame pointer for the function.
2156 The unwind record has a flag (alloca_frame) that indicates that
2157 a function has a variable frame; unfortunately, gcc/binutils
2158 does not set this flag. Instead, whenever a frame pointer is used
2159 and saved on the stack, the Save_SP flag is set. We use this to
2160 decide whether to use the frame pointer for unwinding.
2162 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2163 instead of Save_SP. */
2165 fp = get_frame_register_unsigned (this_frame, HPPA_FP_REGNUM);
2167 if (u->alloca_frame)
2168 fp -= u->Total_frame_size << 3;
2170 if (get_frame_pc (this_frame) >= prologue_end
2171 && (u->Save_SP || u->alloca_frame) && fp != 0)
2176 fprintf_unfiltered (gdb_stdlog, " (base=%s) [frame pointer]",
2177 paddress (gdbarch, cache->base));
2180 && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
2182 /* Both we're expecting the SP to be saved and the SP has been
2183 saved. The entry SP value is saved at this frame's SP
2185 cache->base = read_memory_integer (this_sp, word_size, byte_order);
2188 fprintf_unfiltered (gdb_stdlog, " (base=%s) [saved]",
2189 paddress (gdbarch, cache->base));
2193 /* The prologue has been slowly allocating stack space. Adjust
2195 cache->base = this_sp - frame_size;
2197 fprintf_unfiltered (gdb_stdlog, " (base=%s) [unwind adjust]",
2198 paddress (gdbarch, cache->base));
2201 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2204 /* The PC is found in the "return register", "Millicode" uses "r31"
2205 as the return register while normal code uses "rp". */
2208 if (trad_frame_addr_p (cache->saved_regs, 31))
2210 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
2212 fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
2216 ULONGEST r31 = get_frame_register_unsigned (this_frame, 31);
2217 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
2219 fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
2224 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2226 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2227 cache->saved_regs[HPPA_RP_REGNUM];
2229 fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
2233 ULONGEST rp = get_frame_register_unsigned (this_frame,
2235 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2237 fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
2241 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2242 frame. However, there is a one-insn window where we haven't saved it
2243 yet, but we've already clobbered it. Detect this case and fix it up.
2245 The prologue sequence for frame-pointer functions is:
2246 0: stw %rp, -20(%sp)
2249 c: stw,ma %r1, XX(%sp)
2251 So if we are at offset c, the r3 value that we want is not yet saved
2252 on the stack, but it's been overwritten. The prologue analyzer will
2253 set fp_in_r1 when it sees the copy insn so we know to get the value
2255 if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
2258 ULONGEST r1 = get_frame_register_unsigned (this_frame, 1);
2259 trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
2263 /* Convert all the offsets into addresses. */
2265 for (reg = 0; reg < gdbarch_num_regs (gdbarch); reg++)
2267 if (trad_frame_addr_p (cache->saved_regs, reg))
2268 cache->saved_regs[reg].addr += cache->base;
2273 struct gdbarch_tdep *tdep;
2275 tdep = gdbarch_tdep (gdbarch);
2277 if (tdep->unwind_adjust_stub)
2278 tdep->unwind_adjust_stub (this_frame, cache->base, cache->saved_regs);
2282 fprintf_unfiltered (gdb_stdlog, "base=%s }",
2283 paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
2284 return (struct hppa_frame_cache *) (*this_cache);
2288 hppa_frame_this_id (struct frame_info *this_frame, void **this_cache,
2289 struct frame_id *this_id)
2291 struct hppa_frame_cache *info;
2292 CORE_ADDR pc = get_frame_pc (this_frame);
2293 struct unwind_table_entry *u;
2295 info = hppa_frame_cache (this_frame, this_cache);
2296 u = hppa_find_unwind_entry_in_block (this_frame);
2298 (*this_id) = frame_id_build (info->base, u->region_start);
2301 static struct value *
2302 hppa_frame_prev_register (struct frame_info *this_frame,
2303 void **this_cache, int regnum)
2305 struct hppa_frame_cache *info = hppa_frame_cache (this_frame, this_cache);
2307 return hppa_frame_prev_register_helper (this_frame,
2308 info->saved_regs, regnum);
2312 hppa_frame_unwind_sniffer (const struct frame_unwind *self,
2313 struct frame_info *this_frame, void **this_cache)
2315 if (hppa_find_unwind_entry_in_block (this_frame))
2321 static const struct frame_unwind hppa_frame_unwind =
2324 default_frame_unwind_stop_reason,
2326 hppa_frame_prev_register,
2328 hppa_frame_unwind_sniffer
2331 /* This is a generic fallback frame unwinder that kicks in if we fail all
2332 the other ones. Normally we would expect the stub and regular unwinder
2333 to work, but in some cases we might hit a function that just doesn't
2334 have any unwind information available. In this case we try to do
2335 unwinding solely based on code reading. This is obviously going to be
2336 slow, so only use this as a last resort. Currently this will only
2337 identify the stack and pc for the frame. */
2339 static struct hppa_frame_cache *
2340 hppa_fallback_frame_cache (struct frame_info *this_frame, void **this_cache)
2342 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2343 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2344 struct hppa_frame_cache *cache;
2345 unsigned int frame_size = 0;
2350 fprintf_unfiltered (gdb_stdlog,
2351 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2352 frame_relative_level (this_frame));
2354 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
2355 (*this_cache) = cache;
2356 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2358 start_pc = get_frame_func (this_frame);
2361 CORE_ADDR cur_pc = get_frame_pc (this_frame);
2364 for (pc = start_pc; pc < cur_pc; pc += 4)
2368 insn = read_memory_unsigned_integer (pc, 4, byte_order);
2369 frame_size += prologue_inst_adjust_sp (insn);
2371 /* There are limited ways to store the return pointer into the
2373 if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2375 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2378 else if (insn == 0x0fc212c1
2379 || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2381 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2388 fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
2389 frame_size, found_rp);
2391 cache->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2392 cache->base -= frame_size;
2393 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2395 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2397 cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
2398 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2399 cache->saved_regs[HPPA_RP_REGNUM];
2404 rp = get_frame_register_unsigned (this_frame, HPPA_RP_REGNUM);
2405 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2412 hppa_fallback_frame_this_id (struct frame_info *this_frame, void **this_cache,
2413 struct frame_id *this_id)
2415 struct hppa_frame_cache *info =
2416 hppa_fallback_frame_cache (this_frame, this_cache);
2418 (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
2421 static struct value *
2422 hppa_fallback_frame_prev_register (struct frame_info *this_frame,
2423 void **this_cache, int regnum)
2425 struct hppa_frame_cache *info
2426 = hppa_fallback_frame_cache (this_frame, this_cache);
2428 return hppa_frame_prev_register_helper (this_frame,
2429 info->saved_regs, regnum);
2432 static const struct frame_unwind hppa_fallback_frame_unwind =
2435 default_frame_unwind_stop_reason,
2436 hppa_fallback_frame_this_id,
2437 hppa_fallback_frame_prev_register,
2439 default_frame_sniffer
2442 /* Stub frames, used for all kinds of call stubs. */
2443 struct hppa_stub_unwind_cache
2446 struct trad_frame_saved_reg *saved_regs;
2449 static struct hppa_stub_unwind_cache *
2450 hppa_stub_frame_unwind_cache (struct frame_info *this_frame,
2453 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2454 struct hppa_stub_unwind_cache *info;
2455 struct unwind_table_entry *u;
2458 return (struct hppa_stub_unwind_cache *) *this_cache;
2460 info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
2462 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2464 info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2466 if (gdbarch_osabi (gdbarch) == GDB_OSABI_HPUX_SOM)
2468 /* HPUX uses export stubs in function calls; the export stub clobbers
2469 the return value of the caller, and, later restores it from the
2471 u = find_unwind_entry (get_frame_pc (this_frame));
2473 if (u && u->stub_unwind.stub_type == EXPORT)
2475 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = info->base - 24;
2481 /* By default we assume that stubs do not change the rp. */
2482 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
2488 hppa_stub_frame_this_id (struct frame_info *this_frame,
2489 void **this_prologue_cache,
2490 struct frame_id *this_id)
2492 struct hppa_stub_unwind_cache *info
2493 = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2496 *this_id = frame_id_build (info->base, get_frame_func (this_frame));
2499 static struct value *
2500 hppa_stub_frame_prev_register (struct frame_info *this_frame,
2501 void **this_prologue_cache, int regnum)
2503 struct hppa_stub_unwind_cache *info
2504 = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2507 error (_("Requesting registers from null frame."));
2509 return hppa_frame_prev_register_helper (this_frame,
2510 info->saved_regs, regnum);
2514 hppa_stub_unwind_sniffer (const struct frame_unwind *self,
2515 struct frame_info *this_frame,
2518 CORE_ADDR pc = get_frame_address_in_block (this_frame);
2519 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2520 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2523 || (tdep->in_solib_call_trampoline != NULL
2524 && tdep->in_solib_call_trampoline (gdbarch, pc))
2525 || gdbarch_in_solib_return_trampoline (gdbarch, pc, NULL))
2530 static const struct frame_unwind hppa_stub_frame_unwind = {
2532 default_frame_unwind_stop_reason,
2533 hppa_stub_frame_this_id,
2534 hppa_stub_frame_prev_register,
2536 hppa_stub_unwind_sniffer
2539 static struct frame_id
2540 hppa_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2542 return frame_id_build (get_frame_register_unsigned (this_frame,
2544 get_frame_pc (this_frame));
2548 hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2553 ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
2554 pc = frame_unwind_register_unsigned (next_frame, HPPA_PCOQ_HEAD_REGNUM);
2556 /* If the current instruction is nullified, then we are effectively
2557 still executing the previous instruction. Pretend we are still
2558 there. This is needed when single stepping; if the nullified
2559 instruction is on a different line, we don't want GDB to think
2560 we've stepped onto that line. */
2561 if (ipsw & 0x00200000)
2567 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2568 Return NULL if no such symbol was found. */
2570 struct bound_minimal_symbol
2571 hppa_lookup_stub_minimal_symbol (const char *name,
2572 enum unwind_stub_types stub_type)
2574 struct objfile *objfile;
2575 struct minimal_symbol *msym;
2576 struct bound_minimal_symbol result = { NULL, NULL };
2578 ALL_MSYMBOLS (objfile, msym)
2580 if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
2582 struct unwind_table_entry *u;
2584 u = find_unwind_entry (MSYMBOL_VALUE (msym));
2585 if (u != NULL && u->stub_unwind.stub_type == stub_type)
2587 result.objfile = objfile;
2588 result.minsym = msym;
2598 unwind_command (char *exp, int from_tty)
2601 struct unwind_table_entry *u;
2603 /* If we have an expression, evaluate it and use it as the address. */
2605 if (exp != 0 && *exp != 0)
2606 address = parse_and_eval_address (exp);
2610 u = find_unwind_entry (address);
2614 printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2618 printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u));
2620 printf_unfiltered ("\tregion_start = %s\n", hex_string (u->region_start));
2621 gdb_flush (gdb_stdout);
2623 printf_unfiltered ("\tregion_end = %s\n", hex_string (u->region_end));
2624 gdb_flush (gdb_stdout);
2626 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2628 printf_unfiltered ("\n\tflags =");
2629 pif (Cannot_unwind);
2631 pif (Millicode_save_sr0);
2634 pif (Variable_Frame);
2635 pif (Separate_Package_Body);
2636 pif (Frame_Extension_Millicode);
2637 pif (Stack_Overflow_Check);
2638 pif (Two_Instruction_SP_Increment);
2641 pif (cxx_try_catch);
2642 pif (sched_entry_seq);
2645 pif (Save_MRP_in_frame);
2647 pif (Cleanup_defined);
2648 pif (MPE_XL_interrupt_marker);
2649 pif (HP_UX_interrupt_marker);
2653 putchar_unfiltered ('\n');
2655 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2657 pin (Region_description);
2660 pin (Total_frame_size);
2662 if (u->stub_unwind.stub_type)
2664 printf_unfiltered ("\tstub type = ");
2665 switch (u->stub_unwind.stub_type)
2668 printf_unfiltered ("long branch\n");
2670 case PARAMETER_RELOCATION:
2671 printf_unfiltered ("parameter relocation\n");
2674 printf_unfiltered ("export\n");
2677 printf_unfiltered ("import\n");
2680 printf_unfiltered ("import shlib\n");
2683 printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
2688 /* Return the GDB type object for the "standard" data type of data in
2691 static struct type *
2692 hppa32_register_type (struct gdbarch *gdbarch, int regnum)
2694 if (regnum < HPPA_FP4_REGNUM)
2695 return builtin_type (gdbarch)->builtin_uint32;
2697 return builtin_type (gdbarch)->builtin_float;
2700 static struct type *
2701 hppa64_register_type (struct gdbarch *gdbarch, int regnum)
2703 if (regnum < HPPA64_FP4_REGNUM)
2704 return builtin_type (gdbarch)->builtin_uint64;
2706 return builtin_type (gdbarch)->builtin_double;
2709 /* Return non-zero if REGNUM is not a register available to the user
2710 through ptrace/ttrace. */
2713 hppa32_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2716 || regnum == HPPA_PCSQ_HEAD_REGNUM
2717 || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2718 || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
2722 hppa32_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2724 /* cr26 and cr27 are readable (but not writable) from userspace. */
2725 if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2728 return hppa32_cannot_store_register (gdbarch, regnum);
2732 hppa64_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2735 || regnum == HPPA_PCSQ_HEAD_REGNUM
2736 || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2737 || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
2741 hppa64_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2743 /* cr26 and cr27 are readable (but not writable) from userspace. */
2744 if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2747 return hppa64_cannot_store_register (gdbarch, regnum);
2751 hppa_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2753 /* The low two bits of the PC on the PA contain the privilege level.
2754 Some genius implementing a (non-GCC) compiler apparently decided
2755 this means that "addresses" in a text section therefore include a
2756 privilege level, and thus symbol tables should contain these bits.
2757 This seems like a bonehead thing to do--anyway, it seems to work
2758 for our purposes to just ignore those bits. */
2760 return (addr &= ~0x3);
2763 /* Get the ARGIth function argument for the current function. */
2766 hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
2769 return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
2772 static enum register_status
2773 hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2774 int regnum, gdb_byte *buf)
2776 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2778 enum register_status status;
2780 status = regcache_raw_read_unsigned (regcache, regnum, &tmp);
2781 if (status == REG_VALID)
2783 if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
2785 store_unsigned_integer (buf, sizeof tmp, byte_order, tmp);
2791 hppa_find_global_pointer (struct gdbarch *gdbarch, struct value *function)
2797 hppa_frame_prev_register_helper (struct frame_info *this_frame,
2798 struct trad_frame_saved_reg saved_regs[],
2801 struct gdbarch *arch = get_frame_arch (this_frame);
2802 enum bfd_endian byte_order = gdbarch_byte_order (arch);
2804 if (regnum == HPPA_PCOQ_TAIL_REGNUM)
2806 int size = register_size (arch, HPPA_PCOQ_HEAD_REGNUM);
2808 struct value *pcoq_val =
2809 trad_frame_get_prev_register (this_frame, saved_regs,
2810 HPPA_PCOQ_HEAD_REGNUM);
2812 pc = extract_unsigned_integer (value_contents_all (pcoq_val),
2814 return frame_unwind_got_constant (this_frame, regnum, pc + 4);
2817 return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
2821 /* An instruction to match. */
2824 unsigned int data; /* See if it matches this.... */
2825 unsigned int mask; /* ... with this mask. */
2828 /* See bfd/elf32-hppa.c */
2829 static struct insn_pattern hppa_long_branch_stub[] = {
2830 /* ldil LR'xxx,%r1 */
2831 { 0x20200000, 0xffe00000 },
2832 /* be,n RR'xxx(%sr4,%r1) */
2833 { 0xe0202002, 0xffe02002 },
2837 static struct insn_pattern hppa_long_branch_pic_stub[] = {
2839 { 0xe8200000, 0xffe00000 },
2840 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2841 { 0x28200000, 0xffe00000 },
2842 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2843 { 0xe0202002, 0xffe02002 },
2847 static struct insn_pattern hppa_import_stub[] = {
2848 /* addil LR'xxx, %dp */
2849 { 0x2b600000, 0xffe00000 },
2850 /* ldw RR'xxx(%r1), %r21 */
2851 { 0x48350000, 0xffffb000 },
2853 { 0xeaa0c000, 0xffffffff },
2854 /* ldw RR'xxx+4(%r1), %r19 */
2855 { 0x48330000, 0xffffb000 },
2859 static struct insn_pattern hppa_import_pic_stub[] = {
2860 /* addil LR'xxx,%r19 */
2861 { 0x2a600000, 0xffe00000 },
2862 /* ldw RR'xxx(%r1),%r21 */
2863 { 0x48350000, 0xffffb000 },
2865 { 0xeaa0c000, 0xffffffff },
2866 /* ldw RR'xxx+4(%r1),%r19 */
2867 { 0x48330000, 0xffffb000 },
2871 static struct insn_pattern hppa_plt_stub[] = {
2872 /* b,l 1b, %r20 - 1b is 3 insns before here */
2873 { 0xea9f1fdd, 0xffffffff },
2874 /* depi 0,31,2,%r20 */
2875 { 0xd6801c1e, 0xffffffff },
2879 /* Maximum number of instructions on the patterns above. */
2880 #define HPPA_MAX_INSN_PATTERN_LEN 4
2882 /* Return non-zero if the instructions at PC match the series
2883 described in PATTERN, or zero otherwise. PATTERN is an array of
2884 'struct insn_pattern' objects, terminated by an entry whose mask is
2887 When the match is successful, fill INSN[i] with what PATTERN[i]
2891 hppa_match_insns (struct gdbarch *gdbarch, CORE_ADDR pc,
2892 struct insn_pattern *pattern, unsigned int *insn)
2894 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2898 for (i = 0; pattern[i].mask; i++)
2900 gdb_byte buf[HPPA_INSN_SIZE];
2902 target_read_memory (npc, buf, HPPA_INSN_SIZE);
2903 insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE, byte_order);
2904 if ((insn[i] & pattern[i].mask) == pattern[i].data)
2913 /* This relaxed version of the insstruction matcher allows us to match
2914 from somewhere inside the pattern, by looking backwards in the
2915 instruction scheme. */
2918 hppa_match_insns_relaxed (struct gdbarch *gdbarch, CORE_ADDR pc,
2919 struct insn_pattern *pattern, unsigned int *insn)
2921 int offset, len = 0;
2923 while (pattern[len].mask)
2926 for (offset = 0; offset < len; offset++)
2927 if (hppa_match_insns (gdbarch, pc - offset * HPPA_INSN_SIZE,
2935 hppa_in_dyncall (CORE_ADDR pc)
2937 struct unwind_table_entry *u;
2939 u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2943 return (pc >= u->region_start && pc <= u->region_end);
2947 hppa_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc)
2949 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2950 struct unwind_table_entry *u;
2952 if (in_plt_section (pc) || hppa_in_dyncall (pc))
2955 /* The GNU toolchain produces linker stubs without unwind
2956 information. Since the pattern matching for linker stubs can be
2957 quite slow, so bail out if we do have an unwind entry. */
2959 u = find_unwind_entry (pc);
2964 (hppa_match_insns_relaxed (gdbarch, pc, hppa_import_stub, insn)
2965 || hppa_match_insns_relaxed (gdbarch, pc, hppa_import_pic_stub, insn)
2966 || hppa_match_insns_relaxed (gdbarch, pc, hppa_long_branch_stub, insn)
2967 || hppa_match_insns_relaxed (gdbarch, pc,
2968 hppa_long_branch_pic_stub, insn));
2971 /* This code skips several kind of "trampolines" used on PA-RISC
2972 systems: $$dyncall, import stubs and PLT stubs. */
2975 hppa_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
2977 struct gdbarch *gdbarch = get_frame_arch (frame);
2978 struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
2980 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2983 /* $$dyncall handles both PLABELs and direct addresses. */
2984 if (hppa_in_dyncall (pc))
2986 pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22);
2988 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2990 pc = read_memory_typed_address (pc & ~0x3, func_ptr_type);
2995 dp_rel = hppa_match_insns (gdbarch, pc, hppa_import_stub, insn);
2996 if (dp_rel || hppa_match_insns (gdbarch, pc, hppa_import_pic_stub, insn))
2998 /* Extract the target address from the addil/ldw sequence. */
2999 pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
3002 pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
3004 pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
3009 if (in_plt_section (pc))
3011 pc = read_memory_typed_address (pc, func_ptr_type);
3013 /* If the PLT slot has not yet been resolved, the target will be
3015 if (in_plt_section (pc))
3017 /* Sanity check: are we pointing to the PLT stub? */
3018 if (!hppa_match_insns (gdbarch, pc, hppa_plt_stub, insn))
3020 warning (_("Cannot resolve PLT stub at %s."),
3021 paddress (gdbarch, pc));
3025 /* This should point to the fixup routine. */
3026 pc = read_memory_typed_address (pc + 8, func_ptr_type);
3034 /* Here is a table of C type sizes on hppa with various compiles
3035 and options. I measured this on PA 9000/800 with HP-UX 11.11
3036 and these compilers:
3038 /usr/ccs/bin/cc HP92453-01 A.11.01.21
3039 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
3040 /opt/aCC/bin/aCC B3910B A.03.45
3041 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3043 cc : 1 2 4 4 8 : 4 8 -- : 4 4
3044 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3045 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3046 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3047 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3048 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3049 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3050 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3054 compiler and options
3055 char, short, int, long, long long
3056 float, double, long double
3059 So all these compilers use either ILP32 or LP64 model.
3060 TODO: gcc has more options so it needs more investigation.
3062 For floating point types, see:
3064 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3065 HP-UX floating-point guide, hpux 11.00
3067 -- chastain 2003-12-18 */
3069 static struct gdbarch *
3070 hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3072 struct gdbarch_tdep *tdep;
3073 struct gdbarch *gdbarch;
3075 /* Try to determine the ABI of the object we are loading. */
3076 if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
3078 /* If it's a SOM file, assume it's HP/UX SOM. */
3079 if (bfd_get_flavour (info.abfd) == bfd_target_som_flavour)
3080 info.osabi = GDB_OSABI_HPUX_SOM;
3083 /* find a candidate among the list of pre-declared architectures. */
3084 arches = gdbarch_list_lookup_by_info (arches, &info);
3086 return (arches->gdbarch);
3088 /* If none found, then allocate and initialize one. */
3089 tdep = XCNEW (struct gdbarch_tdep);
3090 gdbarch = gdbarch_alloc (&info, tdep);
3092 /* Determine from the bfd_arch_info structure if we are dealing with
3093 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3094 then default to a 32bit machine. */
3095 if (info.bfd_arch_info != NULL)
3096 tdep->bytes_per_address =
3097 info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
3099 tdep->bytes_per_address = 4;
3101 tdep->find_global_pointer = hppa_find_global_pointer;
3103 /* Some parts of the gdbarch vector depend on whether we are running
3104 on a 32 bits or 64 bits target. */
3105 switch (tdep->bytes_per_address)
3108 set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
3109 set_gdbarch_register_name (gdbarch, hppa32_register_name);
3110 set_gdbarch_register_type (gdbarch, hppa32_register_type);
3111 set_gdbarch_cannot_store_register (gdbarch,
3112 hppa32_cannot_store_register);
3113 set_gdbarch_cannot_fetch_register (gdbarch,
3114 hppa32_cannot_fetch_register);
3117 set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
3118 set_gdbarch_register_name (gdbarch, hppa64_register_name);
3119 set_gdbarch_register_type (gdbarch, hppa64_register_type);
3120 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
3121 set_gdbarch_cannot_store_register (gdbarch,
3122 hppa64_cannot_store_register);
3123 set_gdbarch_cannot_fetch_register (gdbarch,
3124 hppa64_cannot_fetch_register);
3127 internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
3128 tdep->bytes_per_address);
3131 set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3132 set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3134 /* The following gdbarch vector elements are the same in both ILP32
3135 and LP64, but might show differences some day. */
3136 set_gdbarch_long_long_bit (gdbarch, 64);
3137 set_gdbarch_long_double_bit (gdbarch, 128);
3138 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3140 /* The following gdbarch vector elements do not depend on the address
3141 size, or in any other gdbarch element previously set. */
3142 set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
3143 set_gdbarch_stack_frame_destroyed_p (gdbarch,
3144 hppa_stack_frame_destroyed_p);
3145 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
3146 set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM);
3147 set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM);
3148 set_gdbarch_addr_bits_remove (gdbarch, hppa_addr_bits_remove);
3149 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3150 set_gdbarch_read_pc (gdbarch, hppa_read_pc);
3151 set_gdbarch_write_pc (gdbarch, hppa_write_pc);
3153 /* Helper for function argument information. */
3154 set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
3156 set_gdbarch_print_insn (gdbarch, print_insn_hppa);
3158 /* When a hardware watchpoint triggers, we'll move the inferior past
3159 it by removing all eventpoints; stepping past the instruction
3160 that caused the trigger; reinserting eventpoints; and checking
3161 whether any watched location changed. */
3162 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
3164 /* Inferior function call methods. */
3165 switch (tdep->bytes_per_address)
3168 set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
3169 set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
3170 set_gdbarch_convert_from_func_ptr_addr
3171 (gdbarch, hppa32_convert_from_func_ptr_addr);
3174 set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
3175 set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
3178 internal_error (__FILE__, __LINE__, _("bad switch"));
3181 /* Struct return methods. */
3182 switch (tdep->bytes_per_address)
3185 set_gdbarch_return_value (gdbarch, hppa32_return_value);
3188 set_gdbarch_return_value (gdbarch, hppa64_return_value);
3191 internal_error (__FILE__, __LINE__, _("bad switch"));
3194 set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
3195 set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
3197 /* Frame unwind methods. */
3198 set_gdbarch_dummy_id (gdbarch, hppa_dummy_id);
3199 set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
3201 /* Hook in ABI-specific overrides, if they have been registered. */
3202 gdbarch_init_osabi (info, gdbarch);
3204 /* Hook in the default unwinders. */
3205 frame_unwind_append_unwinder (gdbarch, &hppa_stub_frame_unwind);
3206 frame_unwind_append_unwinder (gdbarch, &hppa_frame_unwind);
3207 frame_unwind_append_unwinder (gdbarch, &hppa_fallback_frame_unwind);
3213 hppa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3215 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3217 fprintf_unfiltered (file, "bytes_per_address = %d\n",
3218 tdep->bytes_per_address);
3219 fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
3222 /* Provide a prototype to silence -Wmissing-prototypes. */
3223 extern initialize_file_ftype _initialize_hppa_tdep;
3226 _initialize_hppa_tdep (void)
3228 struct cmd_list_element *c;
3230 gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
3232 hppa_objfile_priv_data = register_objfile_data ();
3234 add_cmd ("unwind", class_maintenance, unwind_command,
3235 _("Print unwind table entry at given address."),
3236 &maintenanceprintlist);
3238 /* Debug this files internals. */
3239 add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
3240 Set whether hppa target specific debugging information should be displayed."),
3242 Show whether hppa target specific debugging information is displayed."), _("\
3243 This flag controls whether hppa target specific debugging information is\n\
3244 displayed. This information is particularly useful for debugging frame\n\
3245 unwinding problems."),
3247 NULL, /* FIXME: i18n: hppa debug flag is %s. */
3248 &setdebuglist, &showdebuglist);