1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986-2016 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"
44 static int hppa_debug = 0;
46 /* Some local constants. */
47 static const int hppa32_num_regs = 128;
48 static const int hppa64_num_regs = 96;
50 /* We use the objfile->obj_private pointer for two things:
53 * 2. A pointer to any associated shared library object.
55 * #defines are used to help refer to these objects.
58 /* Info about the unwind table associated with an object file.
59 * This is hung off of the "objfile->obj_private" pointer, and
60 * is allocated in the objfile's psymbol obstack. This allows
61 * us to have unique unwind info for each executable and shared
62 * library that we are debugging.
64 struct hppa_unwind_info
66 struct unwind_table_entry *table; /* Pointer to unwind info */
67 struct unwind_table_entry *cache; /* Pointer to last entry we found */
68 int last; /* Index of last entry */
71 struct hppa_objfile_private
73 struct hppa_unwind_info *unwind_info; /* a pointer */
74 struct so_list *so_info; /* a pointer */
77 int dummy_call_sequence_reg;
78 CORE_ADDR dummy_call_sequence_addr;
81 /* hppa-specific object data -- unwind and solib info.
82 TODO/maybe: think about splitting this into two parts; the unwind data is
83 common to all hppa targets, but is only used in this file; we can register
84 that separately and make this static. The solib data is probably hpux-
85 specific, so we can create a separate extern objfile_data that is registered
86 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
87 static const struct objfile_data *hppa_objfile_priv_data = NULL;
89 /* Get at various relevent fields of an instruction word. */
92 #define MASK_14 0x3fff
93 #define MASK_21 0x1fffff
95 /* Sizes (in bytes) of the native unwind entries. */
96 #define UNWIND_ENTRY_SIZE 16
97 #define STUB_UNWIND_ENTRY_SIZE 8
99 /* Routines to extract various sized constants out of hppa
102 /* This assumes that no garbage lies outside of the lower bits of
106 hppa_sign_extend (unsigned val, unsigned bits)
108 return (int) (val >> (bits - 1) ? (-(1 << bits)) | val : val);
111 /* For many immediate values the sign bit is the low bit! */
114 hppa_low_hppa_sign_extend (unsigned val, unsigned bits)
116 return (int) ((val & 0x1 ? (-(1 << (bits - 1))) : 0) | val >> 1);
119 /* Extract the bits at positions between FROM and TO, using HP's numbering
123 hppa_get_field (unsigned word, int from, int to)
125 return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1));
128 /* Extract the immediate field from a ld{bhw}s instruction. */
131 hppa_extract_5_load (unsigned word)
133 return hppa_low_hppa_sign_extend (word >> 16 & MASK_5, 5);
136 /* Extract the immediate field from a break instruction. */
139 hppa_extract_5r_store (unsigned word)
141 return (word & MASK_5);
144 /* Extract the immediate field from a {sr}sm instruction. */
147 hppa_extract_5R_store (unsigned word)
149 return (word >> 16 & MASK_5);
152 /* Extract a 14 bit immediate field. */
155 hppa_extract_14 (unsigned word)
157 return hppa_low_hppa_sign_extend (word & MASK_14, 14);
160 /* Extract a 21 bit constant. */
163 hppa_extract_21 (unsigned word)
169 val = hppa_get_field (word, 20, 20);
171 val |= hppa_get_field (word, 9, 19);
173 val |= hppa_get_field (word, 5, 6);
175 val |= hppa_get_field (word, 0, 4);
177 val |= hppa_get_field (word, 7, 8);
178 return hppa_sign_extend (val, 21) << 11;
181 /* extract a 17 bit constant from branch instructions, returning the
182 19 bit signed value. */
185 hppa_extract_17 (unsigned word)
187 return hppa_sign_extend (hppa_get_field (word, 19, 28) |
188 hppa_get_field (word, 29, 29) << 10 |
189 hppa_get_field (word, 11, 15) << 11 |
190 (word & 0x1) << 16, 17) << 2;
194 hppa_symbol_address(const char *sym)
196 struct bound_minimal_symbol minsym;
198 minsym = lookup_minimal_symbol (sym, NULL, NULL);
200 return BMSYMBOL_VALUE_ADDRESS (minsym);
202 return (CORE_ADDR)-1;
205 static struct hppa_objfile_private *
206 hppa_init_objfile_priv_data (struct objfile *objfile)
208 struct hppa_objfile_private *priv;
210 priv = (struct hppa_objfile_private *)
211 obstack_alloc (&objfile->objfile_obstack,
212 sizeof (struct hppa_objfile_private));
213 set_objfile_data (objfile, hppa_objfile_priv_data, priv);
214 memset (priv, 0, sizeof (*priv));
220 /* Compare the start address for two unwind entries returning 1 if
221 the first address is larger than the second, -1 if the second is
222 larger than the first, and zero if they are equal. */
225 compare_unwind_entries (const void *arg1, const void *arg2)
227 const struct unwind_table_entry *a = (const struct unwind_table_entry *) arg1;
228 const struct unwind_table_entry *b = (const struct unwind_table_entry *) arg2;
230 if (a->region_start > b->region_start)
232 else if (a->region_start < b->region_start)
239 record_text_segment_lowaddr (bfd *abfd, asection *section, void *data)
241 if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
242 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
244 bfd_vma value = section->vma - section->filepos;
245 CORE_ADDR *low_text_segment_address = (CORE_ADDR *)data;
247 if (value < *low_text_segment_address)
248 *low_text_segment_address = value;
253 internalize_unwinds (struct objfile *objfile, struct unwind_table_entry *table,
254 asection *section, unsigned int entries,
255 size_t size, CORE_ADDR text_offset)
257 /* We will read the unwind entries into temporary memory, then
258 fill in the actual unwind table. */
262 struct gdbarch *gdbarch = get_objfile_arch (objfile);
265 char *buf = (char *) alloca (size);
266 CORE_ADDR low_text_segment_address;
268 /* For ELF targets, then unwinds are supposed to
269 be segment relative offsets instead of absolute addresses.
271 Note that when loading a shared library (text_offset != 0) the
272 unwinds are already relative to the text_offset that will be
274 if (gdbarch_tdep (gdbarch)->is_elf && text_offset == 0)
276 low_text_segment_address = -1;
278 bfd_map_over_sections (objfile->obfd,
279 record_text_segment_lowaddr,
280 &low_text_segment_address);
282 text_offset = low_text_segment_address;
284 else if (gdbarch_tdep (gdbarch)->solib_get_text_base)
286 text_offset = gdbarch_tdep (gdbarch)->solib_get_text_base (objfile);
289 bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
291 /* Now internalize the information being careful to handle host/target
293 for (i = 0; i < entries; i++)
295 table[i].region_start = bfd_get_32 (objfile->obfd,
297 table[i].region_start += text_offset;
299 table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
300 table[i].region_end += text_offset;
302 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
304 table[i].Cannot_unwind = (tmp >> 31) & 0x1;
305 table[i].Millicode = (tmp >> 30) & 0x1;
306 table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
307 table[i].Region_description = (tmp >> 27) & 0x3;
308 table[i].reserved = (tmp >> 26) & 0x1;
309 table[i].Entry_SR = (tmp >> 25) & 0x1;
310 table[i].Entry_FR = (tmp >> 21) & 0xf;
311 table[i].Entry_GR = (tmp >> 16) & 0x1f;
312 table[i].Args_stored = (tmp >> 15) & 0x1;
313 table[i].Variable_Frame = (tmp >> 14) & 0x1;
314 table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
315 table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
316 table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
317 table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
318 table[i].sr4export = (tmp >> 9) & 0x1;
319 table[i].cxx_info = (tmp >> 8) & 0x1;
320 table[i].cxx_try_catch = (tmp >> 7) & 0x1;
321 table[i].sched_entry_seq = (tmp >> 6) & 0x1;
322 table[i].reserved1 = (tmp >> 5) & 0x1;
323 table[i].Save_SP = (tmp >> 4) & 0x1;
324 table[i].Save_RP = (tmp >> 3) & 0x1;
325 table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
326 table[i].save_r19 = (tmp >> 1) & 0x1;
327 table[i].Cleanup_defined = tmp & 0x1;
328 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
330 table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
331 table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
332 table[i].Large_frame = (tmp >> 29) & 0x1;
333 table[i].alloca_frame = (tmp >> 28) & 0x1;
334 table[i].reserved2 = (tmp >> 27) & 0x1;
335 table[i].Total_frame_size = tmp & 0x7ffffff;
337 /* Stub unwinds are handled elsewhere. */
338 table[i].stub_unwind.stub_type = 0;
339 table[i].stub_unwind.padding = 0;
344 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
345 the object file. This info is used mainly by find_unwind_entry() to find
346 out the stack frame size and frame pointer used by procedures. We put
347 everything on the psymbol obstack in the objfile so that it automatically
348 gets freed when the objfile is destroyed. */
351 read_unwind_info (struct objfile *objfile)
353 asection *unwind_sec, *stub_unwind_sec;
354 size_t unwind_size, stub_unwind_size, total_size;
355 unsigned index, unwind_entries;
356 unsigned stub_entries, total_entries;
357 CORE_ADDR text_offset;
358 struct hppa_unwind_info *ui;
359 struct hppa_objfile_private *obj_private;
361 text_offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
362 ui = (struct hppa_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
363 sizeof (struct hppa_unwind_info));
369 /* For reasons unknown the HP PA64 tools generate multiple unwinder
370 sections in a single executable. So we just iterate over every
371 section in the BFD looking for unwinder sections intead of trying
372 to do a lookup with bfd_get_section_by_name.
374 First determine the total size of the unwind tables so that we
375 can allocate memory in a nice big hunk. */
377 for (unwind_sec = objfile->obfd->sections;
379 unwind_sec = unwind_sec->next)
381 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
382 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
384 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
385 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
387 total_entries += unwind_entries;
391 /* Now compute the size of the stub unwinds. Note the ELF tools do not
392 use stub unwinds at the current time. */
393 stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
397 stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
398 stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
402 stub_unwind_size = 0;
406 /* Compute total number of unwind entries and their total size. */
407 total_entries += stub_entries;
408 total_size = total_entries * sizeof (struct unwind_table_entry);
410 /* Allocate memory for the unwind table. */
411 ui->table = (struct unwind_table_entry *)
412 obstack_alloc (&objfile->objfile_obstack, total_size);
413 ui->last = total_entries - 1;
415 /* Now read in each unwind section and internalize the standard unwind
418 for (unwind_sec = objfile->obfd->sections;
420 unwind_sec = unwind_sec->next)
422 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
423 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
425 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
426 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
428 internalize_unwinds (objfile, &ui->table[index], unwind_sec,
429 unwind_entries, unwind_size, text_offset);
430 index += unwind_entries;
434 /* Now read in and internalize the stub unwind entries. */
435 if (stub_unwind_size > 0)
438 char *buf = (char *) alloca (stub_unwind_size);
440 /* Read in the stub unwind entries. */
441 bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
442 0, stub_unwind_size);
444 /* Now convert them into regular unwind entries. */
445 for (i = 0; i < stub_entries; i++, index++)
447 /* Clear out the next unwind entry. */
448 memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
450 /* Convert offset & size into region_start and region_end.
451 Stuff away the stub type into "reserved" fields. */
452 ui->table[index].region_start = bfd_get_32 (objfile->obfd,
454 ui->table[index].region_start += text_offset;
456 ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
459 ui->table[index].region_end
460 = ui->table[index].region_start + 4 *
461 (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
467 /* Unwind table needs to be kept sorted. */
468 qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
469 compare_unwind_entries);
471 /* Keep a pointer to the unwind information. */
472 obj_private = (struct hppa_objfile_private *)
473 objfile_data (objfile, hppa_objfile_priv_data);
474 if (obj_private == NULL)
475 obj_private = hppa_init_objfile_priv_data (objfile);
477 obj_private->unwind_info = ui;
480 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
481 of the objfiles seeking the unwind table entry for this PC. Each objfile
482 contains a sorted list of struct unwind_table_entry. Since we do a binary
483 search of the unwind tables, we depend upon them to be sorted. */
485 struct unwind_table_entry *
486 find_unwind_entry (CORE_ADDR pc)
488 int first, middle, last;
489 struct objfile *objfile;
490 struct hppa_objfile_private *priv;
493 fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry %s -> ",
496 /* A function at address 0? Not in HP-UX! */
497 if (pc == (CORE_ADDR) 0)
500 fprintf_unfiltered (gdb_stdlog, "NULL }\n");
504 ALL_OBJFILES (objfile)
506 struct hppa_unwind_info *ui;
508 priv = ((struct hppa_objfile_private *)
509 objfile_data (objfile, hppa_objfile_priv_data));
511 ui = ((struct hppa_objfile_private *) priv)->unwind_info;
515 read_unwind_info (objfile);
516 priv = ((struct hppa_objfile_private *)
517 objfile_data (objfile, hppa_objfile_priv_data));
519 error (_("Internal error reading unwind information."));
520 ui = ((struct hppa_objfile_private *) priv)->unwind_info;
523 /* First, check the cache. */
526 && pc >= ui->cache->region_start
527 && pc <= ui->cache->region_end)
530 fprintf_unfiltered (gdb_stdlog, "%s (cached) }\n",
531 hex_string ((uintptr_t) ui->cache));
535 /* Not in the cache, do a binary search. */
540 while (first <= last)
542 middle = (first + last) / 2;
543 if (pc >= ui->table[middle].region_start
544 && pc <= ui->table[middle].region_end)
546 ui->cache = &ui->table[middle];
548 fprintf_unfiltered (gdb_stdlog, "%s }\n",
549 hex_string ((uintptr_t) ui->cache));
550 return &ui->table[middle];
553 if (pc < ui->table[middle].region_start)
558 } /* ALL_OBJFILES() */
561 fprintf_unfiltered (gdb_stdlog, "NULL (not found) }\n");
566 /* Implement the stack_frame_destroyed_p gdbarch method.
568 The epilogue is defined here as the area either on the `bv' instruction
569 itself or an instruction which destroys the function's stack frame.
571 We do not assume that the epilogue is at the end of a function as we can
572 also have return sequences in the middle of a function. */
575 hppa_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
577 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
578 unsigned long status;
582 status = target_read_memory (pc, buf, 4);
586 inst = extract_unsigned_integer (buf, 4, byte_order);
588 /* The most common way to perform a stack adjustment ldo X(sp),sp
589 We are destroying a stack frame if the offset is negative. */
590 if ((inst & 0xffffc000) == 0x37de0000
591 && hppa_extract_14 (inst) < 0)
594 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
595 if (((inst & 0x0fc010e0) == 0x0fc010e0
596 || (inst & 0x0fc010e0) == 0x0fc010e0)
597 && hppa_extract_14 (inst) < 0)
600 /* bv %r0(%rp) or bv,n %r0(%rp) */
601 if (inst == 0xe840c000 || inst == 0xe840c002)
607 static const unsigned char *
608 hppa_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
610 static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
611 (*len) = sizeof (breakpoint);
615 /* Return the name of a register. */
618 hppa32_register_name (struct gdbarch *gdbarch, int i)
620 static char *names[] = {
621 "flags", "r1", "rp", "r3",
622 "r4", "r5", "r6", "r7",
623 "r8", "r9", "r10", "r11",
624 "r12", "r13", "r14", "r15",
625 "r16", "r17", "r18", "r19",
626 "r20", "r21", "r22", "r23",
627 "r24", "r25", "r26", "dp",
628 "ret0", "ret1", "sp", "r31",
629 "sar", "pcoqh", "pcsqh", "pcoqt",
630 "pcsqt", "eiem", "iir", "isr",
631 "ior", "ipsw", "goto", "sr4",
632 "sr0", "sr1", "sr2", "sr3",
633 "sr5", "sr6", "sr7", "cr0",
634 "cr8", "cr9", "ccr", "cr12",
635 "cr13", "cr24", "cr25", "cr26",
636 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
637 "fpsr", "fpe1", "fpe2", "fpe3",
638 "fpe4", "fpe5", "fpe6", "fpe7",
639 "fr4", "fr4R", "fr5", "fr5R",
640 "fr6", "fr6R", "fr7", "fr7R",
641 "fr8", "fr8R", "fr9", "fr9R",
642 "fr10", "fr10R", "fr11", "fr11R",
643 "fr12", "fr12R", "fr13", "fr13R",
644 "fr14", "fr14R", "fr15", "fr15R",
645 "fr16", "fr16R", "fr17", "fr17R",
646 "fr18", "fr18R", "fr19", "fr19R",
647 "fr20", "fr20R", "fr21", "fr21R",
648 "fr22", "fr22R", "fr23", "fr23R",
649 "fr24", "fr24R", "fr25", "fr25R",
650 "fr26", "fr26R", "fr27", "fr27R",
651 "fr28", "fr28R", "fr29", "fr29R",
652 "fr30", "fr30R", "fr31", "fr31R"
654 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
661 hppa64_register_name (struct gdbarch *gdbarch, int i)
663 static char *names[] = {
664 "flags", "r1", "rp", "r3",
665 "r4", "r5", "r6", "r7",
666 "r8", "r9", "r10", "r11",
667 "r12", "r13", "r14", "r15",
668 "r16", "r17", "r18", "r19",
669 "r20", "r21", "r22", "r23",
670 "r24", "r25", "r26", "dp",
671 "ret0", "ret1", "sp", "r31",
672 "sar", "pcoqh", "pcsqh", "pcoqt",
673 "pcsqt", "eiem", "iir", "isr",
674 "ior", "ipsw", "goto", "sr4",
675 "sr0", "sr1", "sr2", "sr3",
676 "sr5", "sr6", "sr7", "cr0",
677 "cr8", "cr9", "ccr", "cr12",
678 "cr13", "cr24", "cr25", "cr26",
679 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
680 "fpsr", "fpe1", "fpe2", "fpe3",
681 "fr4", "fr5", "fr6", "fr7",
682 "fr8", "fr9", "fr10", "fr11",
683 "fr12", "fr13", "fr14", "fr15",
684 "fr16", "fr17", "fr18", "fr19",
685 "fr20", "fr21", "fr22", "fr23",
686 "fr24", "fr25", "fr26", "fr27",
687 "fr28", "fr29", "fr30", "fr31"
689 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
695 /* Map dwarf DBX register numbers to GDB register numbers. */
697 hppa64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
699 /* The general registers and the sar are the same in both sets. */
700 if (reg >= 0 && reg <= 32)
703 /* fr4-fr31 are mapped from 72 in steps of 2. */
704 if (reg >= 72 && reg < 72 + 28 * 2 && !(reg & 1))
705 return HPPA64_FP4_REGNUM + (reg - 72) / 2;
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 /* Two passes. First pass computes the location of everything,
735 second pass writes the bytes out. */
738 /* Global pointer (r19) of the function we are trying to call. */
741 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
743 for (write_pass = 0; write_pass < 2; write_pass++)
745 CORE_ADDR struct_ptr = 0;
746 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
747 struct_ptr is adjusted for each argument below, so the first
748 argument will end up at sp-36. */
749 CORE_ADDR param_ptr = 32;
751 int small_struct = 0;
753 for (i = 0; i < nargs; i++)
755 struct value *arg = args[i];
756 struct type *type = check_typedef (value_type (arg));
757 /* The corresponding parameter that is pushed onto the
758 stack, and [possibly] passed in a register. */
759 gdb_byte param_val[8];
761 memset (param_val, 0, sizeof param_val);
762 if (TYPE_LENGTH (type) > 8)
764 /* Large parameter, pass by reference. Store the value
765 in "struct" area and then pass its address. */
767 struct_ptr += align_up (TYPE_LENGTH (type), 8);
769 write_memory (struct_end - struct_ptr, value_contents (arg),
771 store_unsigned_integer (param_val, 4, byte_order,
772 struct_end - struct_ptr);
774 else if (TYPE_CODE (type) == TYPE_CODE_INT
775 || TYPE_CODE (type) == TYPE_CODE_ENUM)
777 /* Integer value store, right aligned. "unpack_long"
778 takes care of any sign-extension problems. */
779 param_len = align_up (TYPE_LENGTH (type), 4);
780 store_unsigned_integer (param_val, param_len, byte_order,
782 value_contents (arg)));
784 else if (TYPE_CODE (type) == TYPE_CODE_FLT)
786 /* Floating point value store, right aligned. */
787 param_len = align_up (TYPE_LENGTH (type), 4);
788 memcpy (param_val, value_contents (arg), param_len);
792 param_len = align_up (TYPE_LENGTH (type), 4);
794 /* Small struct value are stored right-aligned. */
795 memcpy (param_val + param_len - TYPE_LENGTH (type),
796 value_contents (arg), TYPE_LENGTH (type));
798 /* Structures of size 5, 6 and 7 bytes are special in that
799 the higher-ordered word is stored in the lower-ordered
800 argument, and even though it is a 8-byte quantity the
801 registers need not be 8-byte aligned. */
802 if (param_len > 4 && param_len < 8)
806 param_ptr += param_len;
807 if (param_len == 8 && !small_struct)
808 param_ptr = align_up (param_ptr, 8);
810 /* First 4 non-FP arguments are passed in gr26-gr23.
811 First 4 32-bit FP arguments are passed in fr4L-fr7L.
812 First 2 64-bit FP arguments are passed in fr5 and fr7.
814 The rest go on the stack, starting at sp-36, towards lower
815 addresses. 8-byte arguments must be aligned to a 8-byte
819 write_memory (param_end - param_ptr, param_val, param_len);
821 /* There are some cases when we don't know the type
822 expected by the callee (e.g. for variadic functions), so
823 pass the parameters in both general and fp regs. */
826 int grreg = 26 - (param_ptr - 36) / 4;
827 int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
828 int fpreg = 74 + (param_ptr - 32) / 8 * 4;
830 regcache_cooked_write (regcache, grreg, param_val);
831 regcache_cooked_write (regcache, fpLreg, param_val);
835 regcache_cooked_write (regcache, grreg + 1,
838 regcache_cooked_write (regcache, fpreg, param_val);
839 regcache_cooked_write (regcache, fpreg + 1,
846 /* Update the various stack pointers. */
849 struct_end = sp + align_up (struct_ptr, 64);
850 /* PARAM_PTR already accounts for all the arguments passed
851 by the user. However, the ABI mandates minimum stack
852 space allocations for outgoing arguments. The ABI also
853 mandates minimum stack alignments which we must
855 param_end = struct_end + align_up (param_ptr, 64);
859 /* If a structure has to be returned, set up register 28 to hold its
862 regcache_cooked_write_unsigned (regcache, 28, struct_addr);
864 gp = tdep->find_global_pointer (gdbarch, function);
867 regcache_cooked_write_unsigned (regcache, 19, gp);
869 /* Set the return address. */
870 if (!gdbarch_push_dummy_code_p (gdbarch))
871 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
873 /* Update the Stack Pointer. */
874 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end);
879 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
880 Runtime Architecture for PA-RISC 2.0", which is distributed as part
881 as of the HP-UX Software Transition Kit (STK). This implementation
882 is based on version 3.3, dated October 6, 1997. */
884 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
887 hppa64_integral_or_pointer_p (const struct type *type)
889 switch (TYPE_CODE (type))
895 case TYPE_CODE_RANGE:
897 int len = TYPE_LENGTH (type);
898 return (len == 1 || len == 2 || len == 4 || len == 8);
902 return (TYPE_LENGTH (type) == 8);
910 /* Check whether TYPE is a "Floating Scalar Type". */
913 hppa64_floating_p (const struct type *type)
915 switch (TYPE_CODE (type))
919 int len = TYPE_LENGTH (type);
920 return (len == 4 || len == 8 || len == 16);
929 /* If CODE points to a function entry address, try to look up the corresponding
930 function descriptor and return its address instead. If CODE is not a
931 function entry address, then just return it unchanged. */
933 hppa64_convert_code_addr_to_fptr (struct gdbarch *gdbarch, CORE_ADDR code)
935 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
936 struct obj_section *sec, *opd;
938 sec = find_pc_section (code);
943 /* If CODE is in a data section, assume it's already a fptr. */
944 if (!(sec->the_bfd_section->flags & SEC_CODE))
947 ALL_OBJFILE_OSECTIONS (sec->objfile, opd)
949 if (strcmp (opd->the_bfd_section->name, ".opd") == 0)
953 if (opd < sec->objfile->sections_end)
957 for (addr = obj_section_addr (opd);
958 addr < obj_section_endaddr (opd);
964 if (target_read_memory (addr, tmp, sizeof (tmp)))
966 opdaddr = extract_unsigned_integer (tmp, sizeof (tmp), byte_order);
977 hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
978 struct regcache *regcache, CORE_ADDR bp_addr,
979 int nargs, struct value **args, CORE_ADDR sp,
980 int struct_return, CORE_ADDR struct_addr)
982 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
983 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
987 /* "The outgoing parameter area [...] must be aligned at a 16-byte
989 sp = align_up (sp, 16);
991 for (i = 0; i < nargs; i++)
993 struct value *arg = args[i];
994 struct type *type = value_type (arg);
995 int len = TYPE_LENGTH (type);
996 const bfd_byte *valbuf;
1000 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
1001 offset = align_up (offset, 8);
1003 if (hppa64_integral_or_pointer_p (type))
1005 /* "Integral scalar parameters smaller than 64 bits are
1006 padded on the left (i.e., the value is in the
1007 least-significant bits of the 64-bit storage unit, and
1008 the high-order bits are undefined)." Therefore we can
1009 safely sign-extend them. */
1012 arg = value_cast (builtin_type (gdbarch)->builtin_int64, arg);
1016 else if (hppa64_floating_p (type))
1020 /* "Quad-precision (128-bit) floating-point scalar
1021 parameters are aligned on a 16-byte boundary." */
1022 offset = align_up (offset, 16);
1024 /* "Double-extended- and quad-precision floating-point
1025 parameters within the first 64 bytes of the parameter
1026 list are always passed in general registers." */
1032 /* "Single-precision (32-bit) floating-point scalar
1033 parameters are padded on the left with 32 bits of
1034 garbage (i.e., the floating-point value is in the
1035 least-significant 32 bits of a 64-bit storage
1040 /* "Single- and double-precision floating-point
1041 parameters in this area are passed according to the
1042 available formal parameter information in a function
1043 prototype. [...] If no prototype is in scope,
1044 floating-point parameters must be passed both in the
1045 corresponding general registers and in the
1046 corresponding floating-point registers." */
1047 regnum = HPPA64_FP4_REGNUM + offset / 8;
1049 if (regnum < HPPA64_FP4_REGNUM + 8)
1051 /* "Single-precision floating-point parameters, when
1052 passed in floating-point registers, are passed in
1053 the right halves of the floating point registers;
1054 the left halves are unused." */
1055 regcache_cooked_write_part (regcache, regnum, offset % 8,
1056 len, value_contents (arg));
1064 /* "Aggregates larger than 8 bytes are aligned on a
1065 16-byte boundary, possibly leaving an unused argument
1066 slot, which is filled with garbage. If necessary,
1067 they are padded on the right (with garbage), to a
1068 multiple of 8 bytes." */
1069 offset = align_up (offset, 16);
1073 /* If we are passing a function pointer, make sure we pass a function
1074 descriptor instead of the function entry address. */
1075 if (TYPE_CODE (type) == TYPE_CODE_PTR
1076 && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1078 ULONGEST codeptr, fptr;
1080 codeptr = unpack_long (type, value_contents (arg));
1081 fptr = hppa64_convert_code_addr_to_fptr (gdbarch, codeptr);
1082 store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), byte_order,
1088 valbuf = value_contents (arg);
1091 /* Always store the argument in memory. */
1092 write_memory (sp + offset, valbuf, len);
1094 regnum = HPPA_ARG0_REGNUM - offset / 8;
1095 while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
1097 regcache_cooked_write_part (regcache, regnum,
1098 offset % 8, std::min (len, 8), valbuf);
1099 offset += std::min (len, 8);
1100 valbuf += std::min (len, 8);
1101 len -= std::min (len, 8);
1108 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1109 regcache_cooked_write_unsigned (regcache, HPPA_RET1_REGNUM, sp + 64);
1111 /* Allocate the outgoing parameter area. Make sure the outgoing
1112 parameter area is multiple of 16 bytes in length. */
1113 sp += std::max (align_up (offset, 16), (ULONGEST) 64);
1115 /* Allocate 32-bytes of scratch space. The documentation doesn't
1116 mention this, but it seems to be needed. */
1119 /* Allocate the frame marker area. */
1122 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1125 regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
1127 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1128 gp = tdep->find_global_pointer (gdbarch, function);
1130 regcache_cooked_write_unsigned (regcache, HPPA_DP_REGNUM, gp);
1132 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1133 if (!gdbarch_push_dummy_code_p (gdbarch))
1134 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
1136 /* Set up GR30 to hold the stack pointer (sp). */
1137 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, sp);
1143 /* Handle 32/64-bit struct return conventions. */
1145 static enum return_value_convention
1146 hppa32_return_value (struct gdbarch *gdbarch, struct value *function,
1147 struct type *type, struct regcache *regcache,
1148 gdb_byte *readbuf, const gdb_byte *writebuf)
1150 if (TYPE_LENGTH (type) <= 2 * 4)
1152 /* The value always lives in the right hand end of the register
1153 (or register pair)? */
1155 int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
1156 int part = TYPE_LENGTH (type) % 4;
1157 /* The left hand register contains only part of the value,
1158 transfer that first so that the rest can be xfered as entire
1159 4-byte registers. */
1162 if (readbuf != NULL)
1163 regcache_cooked_read_part (regcache, reg, 4 - part,
1165 if (writebuf != NULL)
1166 regcache_cooked_write_part (regcache, reg, 4 - part,
1170 /* Now transfer the remaining register values. */
1171 for (b = part; b < TYPE_LENGTH (type); b += 4)
1173 if (readbuf != NULL)
1174 regcache_cooked_read (regcache, reg, readbuf + b);
1175 if (writebuf != NULL)
1176 regcache_cooked_write (regcache, reg, writebuf + b);
1179 return RETURN_VALUE_REGISTER_CONVENTION;
1182 return RETURN_VALUE_STRUCT_CONVENTION;
1185 static enum return_value_convention
1186 hppa64_return_value (struct gdbarch *gdbarch, struct value *function,
1187 struct type *type, struct regcache *regcache,
1188 gdb_byte *readbuf, const gdb_byte *writebuf)
1190 int len = TYPE_LENGTH (type);
1195 /* All return values larget than 128 bits must be aggregate
1197 gdb_assert (!hppa64_integral_or_pointer_p (type));
1198 gdb_assert (!hppa64_floating_p (type));
1200 /* "Aggregate return values larger than 128 bits are returned in
1201 a buffer allocated by the caller. The address of the buffer
1202 must be passed in GR 28." */
1203 return RETURN_VALUE_STRUCT_CONVENTION;
1206 if (hppa64_integral_or_pointer_p (type))
1208 /* "Integral return values are returned in GR 28. Values
1209 smaller than 64 bits are padded on the left (with garbage)." */
1210 regnum = HPPA_RET0_REGNUM;
1213 else if (hppa64_floating_p (type))
1217 /* "Double-extended- and quad-precision floating-point
1218 values are returned in GRs 28 and 29. The sign,
1219 exponent, and most-significant bits of the mantissa are
1220 returned in GR 28; the least-significant bits of the
1221 mantissa are passed in GR 29. For double-extended
1222 precision values, GR 29 is padded on the right with 48
1223 bits of garbage." */
1224 regnum = HPPA_RET0_REGNUM;
1229 /* "Single-precision and double-precision floating-point
1230 return values are returned in FR 4R (single precision) or
1231 FR 4 (double-precision)." */
1232 regnum = HPPA64_FP4_REGNUM;
1238 /* "Aggregate return values up to 64 bits in size are returned
1239 in GR 28. Aggregates smaller than 64 bits are left aligned
1240 in the register; the pad bits on the right are undefined."
1242 "Aggregate return values between 65 and 128 bits are returned
1243 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1244 the remaining bits are placed, left aligned, in GR 29. The
1245 pad bits on the right of GR 29 (if any) are undefined." */
1246 regnum = HPPA_RET0_REGNUM;
1254 regcache_cooked_read_part (regcache, regnum, offset,
1255 std::min (len, 8), readbuf);
1256 readbuf += std::min (len, 8);
1257 len -= std::min (len, 8);
1266 regcache_cooked_write_part (regcache, regnum, offset,
1267 std::min (len, 8), writebuf);
1268 writebuf += std::min (len, 8);
1269 len -= std::min (len, 8);
1274 return RETURN_VALUE_REGISTER_CONVENTION;
1279 hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1280 struct target_ops *targ)
1284 struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1285 CORE_ADDR plabel = addr & ~3;
1286 return read_memory_typed_address (plabel, func_ptr_type);
1293 hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1295 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1297 return align_up (addr, 64);
1300 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1303 hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1305 /* Just always 16-byte align. */
1306 return align_up (addr, 16);
1310 hppa_read_pc (struct regcache *regcache)
1315 regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
1316 regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
1318 /* If the current instruction is nullified, then we are effectively
1319 still executing the previous instruction. Pretend we are still
1320 there. This is needed when single stepping; if the nullified
1321 instruction is on a different line, we don't want GDB to think
1322 we've stepped onto that line. */
1323 if (ipsw & 0x00200000)
1330 hppa_write_pc (struct regcache *regcache, CORE_ADDR pc)
1332 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pc);
1333 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pc + 4);
1336 /* For the given instruction (INST), return any adjustment it makes
1337 to the stack pointer or zero for no adjustment.
1339 This only handles instructions commonly found in prologues. */
1342 prologue_inst_adjust_sp (unsigned long inst)
1344 /* This must persist across calls. */
1345 static int save_high21;
1347 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1348 if ((inst & 0xffffc000) == 0x37de0000)
1349 return hppa_extract_14 (inst);
1352 if ((inst & 0xffe00000) == 0x6fc00000)
1353 return hppa_extract_14 (inst);
1355 /* std,ma X,D(sp) */
1356 if ((inst & 0xffe00008) == 0x73c00008)
1357 return (inst & 0x1 ? -(1 << 13) : 0) | (((inst >> 4) & 0x3ff) << 3);
1359 /* addil high21,%r30; ldo low11,(%r1),%r30)
1360 save high bits in save_high21 for later use. */
1361 if ((inst & 0xffe00000) == 0x2bc00000)
1363 save_high21 = hppa_extract_21 (inst);
1367 if ((inst & 0xffff0000) == 0x343e0000)
1368 return save_high21 + hppa_extract_14 (inst);
1370 /* fstws as used by the HP compilers. */
1371 if ((inst & 0xffffffe0) == 0x2fd01220)
1372 return hppa_extract_5_load (inst);
1374 /* No adjustment. */
1378 /* Return nonzero if INST is a branch of some kind, else return zero. */
1381 is_branch (unsigned long inst)
1410 /* Return the register number for a GR which is saved by INST or
1411 zero if INST does not save a GR.
1416 https://parisc.wiki.kernel.org/images-parisc/6/68/Pa11_acd.pdf
1419 https://parisc.wiki.kernel.org/images-parisc/7/73/Parisc2.0.pdf
1421 According to Table 6-5 of Chapter 6 (Memory Reference Instructions)
1422 on page 106 in parisc 2.0, all instructions for storing values from
1423 the general registers are:
1425 Store: stb, sth, stw, std (according to Chapter 7, they
1426 are only in both "inst >> 26" and "inst >> 6".
1427 Store Absolute: stwa, stda (according to Chapter 7, they are only
1429 Store Bytes: stby, stdby (according to Chapter 7, they are
1430 only in "inst >> 6").
1432 For (inst >> 26), according to Chapter 7:
1434 The effective memory reference address is formed by the addition
1435 of an immediate displacement to a base value.
1437 - stb: 0x18, store a byte from a general register.
1439 - sth: 0x19, store a halfword from a general register.
1441 - stw: 0x1a, store a word from a general register.
1443 - stwm: 0x1b, store a word from a general register and perform base
1444 register modification (2.0 will still treate it as stw).
1446 - std: 0x1c, store a doubleword from a general register (2.0 only).
1448 - stw: 0x1f, store a word from a general register (2.0 only).
1450 For (inst >> 6) when ((inst >> 26) == 0x03), according to Chapter 7:
1452 The effective memory reference address is formed by the addition
1453 of an index value to a base value specified in the instruction.
1455 - stb: 0x08, store a byte from a general register (1.1 calls stbs).
1457 - sth: 0x09, store a halfword from a general register (1.1 calls
1460 - stw: 0x0a, store a word from a general register (1.1 calls stws).
1462 - std: 0x0b: store a doubleword from a general register (2.0 only)
1464 Implement fast byte moves (stores) to unaligned word or doubleword
1467 - stby: 0x0c, for unaligned word (1.1 calls stbys).
1469 - stdby: 0x0d for unaligned doubleword (2.0 only).
1471 Store a word or doubleword using an absolute memory address formed
1472 using short or long displacement or indexed
1474 - stwa: 0x0e, store a word from a general register to an absolute
1475 address (1.0 calls stwas).
1477 - stda: 0x0f, store a doubleword from a general register to an
1478 absolute address (2.0 only). */
1481 inst_saves_gr (unsigned long inst)
1483 switch ((inst >> 26) & 0x0f)
1486 switch ((inst >> 6) & 0x0f)
1496 return hppa_extract_5R_store (inst);
1505 /* no 0x1d or 0x1e -- according to parisc 2.0 document */
1507 return hppa_extract_5R_store (inst);
1513 /* Return the register number for a FR which is saved by INST or
1514 zero it INST does not save a FR.
1516 Note we only care about full 64bit register stores (that's the only
1517 kind of stores the prologue will use).
1519 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1522 inst_saves_fr (unsigned long inst)
1524 /* Is this an FSTD? */
1525 if ((inst & 0xfc00dfc0) == 0x2c001200)
1526 return hppa_extract_5r_store (inst);
1527 if ((inst & 0xfc000002) == 0x70000002)
1528 return hppa_extract_5R_store (inst);
1529 /* Is this an FSTW? */
1530 if ((inst & 0xfc00df80) == 0x24001200)
1531 return hppa_extract_5r_store (inst);
1532 if ((inst & 0xfc000002) == 0x7c000000)
1533 return hppa_extract_5R_store (inst);
1537 /* Advance PC across any function entry prologue instructions
1538 to reach some "real" code.
1540 Use information in the unwind table to determine what exactly should
1541 be in the prologue. */
1545 skip_prologue_hard_way (struct gdbarch *gdbarch, CORE_ADDR pc,
1546 int stop_before_branch)
1548 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1550 CORE_ADDR orig_pc = pc;
1551 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1552 unsigned long args_stored, status, i, restart_gr, restart_fr;
1553 struct unwind_table_entry *u;
1554 int final_iteration;
1560 u = find_unwind_entry (pc);
1564 /* If we are not at the beginning of a function, then return now. */
1565 if ((pc & ~0x3) != u->region_start)
1568 /* This is how much of a frame adjustment we need to account for. */
1569 stack_remaining = u->Total_frame_size << 3;
1571 /* Magic register saves we want to know about. */
1572 save_rp = u->Save_RP;
1573 save_sp = u->Save_SP;
1575 /* An indication that args may be stored into the stack. Unfortunately
1576 the HPUX compilers tend to set this in cases where no args were
1580 /* Turn the Entry_GR field into a bitmask. */
1582 for (i = 3; i < u->Entry_GR + 3; i++)
1584 /* Frame pointer gets saved into a special location. */
1585 if (u->Save_SP && i == HPPA_FP_REGNUM)
1588 save_gr |= (1 << i);
1590 save_gr &= ~restart_gr;
1592 /* Turn the Entry_FR field into a bitmask too. */
1594 for (i = 12; i < u->Entry_FR + 12; i++)
1595 save_fr |= (1 << i);
1596 save_fr &= ~restart_fr;
1598 final_iteration = 0;
1600 /* Loop until we find everything of interest or hit a branch.
1602 For unoptimized GCC code and for any HP CC code this will never ever
1603 examine any user instructions.
1605 For optimzied GCC code we're faced with problems. GCC will schedule
1606 its prologue and make prologue instructions available for delay slot
1607 filling. The end result is user code gets mixed in with the prologue
1608 and a prologue instruction may be in the delay slot of the first branch
1611 Some unexpected things are expected with debugging optimized code, so
1612 we allow this routine to walk past user instructions in optimized
1614 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1617 unsigned int reg_num;
1618 unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1619 unsigned long old_save_rp, old_save_sp, next_inst;
1621 /* Save copies of all the triggers so we can compare them later
1623 old_save_gr = save_gr;
1624 old_save_fr = save_fr;
1625 old_save_rp = save_rp;
1626 old_save_sp = save_sp;
1627 old_stack_remaining = stack_remaining;
1629 status = target_read_memory (pc, buf, 4);
1630 inst = extract_unsigned_integer (buf, 4, byte_order);
1636 /* Note the interesting effects of this instruction. */
1637 stack_remaining -= prologue_inst_adjust_sp (inst);
1639 /* There are limited ways to store the return pointer into the
1641 if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1644 /* These are the only ways we save SP into the stack. At this time
1645 the HP compilers never bother to save SP into the stack. */
1646 if ((inst & 0xffffc000) == 0x6fc10000
1647 || (inst & 0xffffc00c) == 0x73c10008)
1650 /* Are we loading some register with an offset from the argument
1652 if ((inst & 0xffe00000) == 0x37a00000
1653 || (inst & 0xffffffe0) == 0x081d0240)
1659 /* Account for general and floating-point register saves. */
1660 reg_num = inst_saves_gr (inst);
1661 save_gr &= ~(1 << reg_num);
1663 /* Ugh. Also account for argument stores into the stack.
1664 Unfortunately args_stored only tells us that some arguments
1665 where stored into the stack. Not how many or what kind!
1667 This is a kludge as on the HP compiler sets this bit and it
1668 never does prologue scheduling. So once we see one, skip past
1669 all of them. We have similar code for the fp arg stores below.
1671 FIXME. Can still die if we have a mix of GR and FR argument
1673 if (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1676 while (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1680 status = target_read_memory (pc, buf, 4);
1681 inst = extract_unsigned_integer (buf, 4, byte_order);
1684 reg_num = inst_saves_gr (inst);
1690 reg_num = inst_saves_fr (inst);
1691 save_fr &= ~(1 << reg_num);
1693 status = target_read_memory (pc + 4, buf, 4);
1694 next_inst = extract_unsigned_integer (buf, 4, byte_order);
1700 /* We've got to be read to handle the ldo before the fp register
1702 if ((inst & 0xfc000000) == 0x34000000
1703 && inst_saves_fr (next_inst) >= 4
1704 && inst_saves_fr (next_inst)
1705 <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1707 /* So we drop into the code below in a reasonable state. */
1708 reg_num = inst_saves_fr (next_inst);
1712 /* Ugh. Also account for argument stores into the stack.
1713 This is a kludge as on the HP compiler sets this bit and it
1714 never does prologue scheduling. So once we see one, skip past
1717 && reg_num <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1721 <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1724 status = target_read_memory (pc, buf, 4);
1725 inst = extract_unsigned_integer (buf, 4, byte_order);
1728 if ((inst & 0xfc000000) != 0x34000000)
1730 status = target_read_memory (pc + 4, buf, 4);
1731 next_inst = extract_unsigned_integer (buf, 4, byte_order);
1734 reg_num = inst_saves_fr (next_inst);
1740 /* Quit if we hit any kind of branch. This can happen if a prologue
1741 instruction is in the delay slot of the first call/branch. */
1742 if (is_branch (inst) && stop_before_branch)
1745 /* What a crock. The HP compilers set args_stored even if no
1746 arguments were stored into the stack (boo hiss). This could
1747 cause this code to then skip a bunch of user insns (up to the
1750 To combat this we try to identify when args_stored was bogusly
1751 set and clear it. We only do this when args_stored is nonzero,
1752 all other resources are accounted for, and nothing changed on
1755 && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1756 && old_save_gr == save_gr && old_save_fr == save_fr
1757 && old_save_rp == save_rp && old_save_sp == save_sp
1758 && old_stack_remaining == stack_remaining)
1764 /* !stop_before_branch, so also look at the insn in the delay slot
1766 if (final_iteration)
1768 if (is_branch (inst))
1769 final_iteration = 1;
1772 /* We've got a tenative location for the end of the prologue. However
1773 because of limitations in the unwind descriptor mechanism we may
1774 have went too far into user code looking for the save of a register
1775 that does not exist. So, if there registers we expected to be saved
1776 but never were, mask them out and restart.
1778 This should only happen in optimized code, and should be very rare. */
1779 if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1782 restart_gr = save_gr;
1783 restart_fr = save_fr;
1791 /* Return the address of the PC after the last prologue instruction if
1792 we can determine it from the debug symbols. Else return zero. */
1795 after_prologue (CORE_ADDR pc)
1797 struct symtab_and_line sal;
1798 CORE_ADDR func_addr, func_end;
1800 /* If we can not find the symbol in the partial symbol table, then
1801 there is no hope we can determine the function's start address
1803 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1806 /* Get the line associated with FUNC_ADDR. */
1807 sal = find_pc_line (func_addr, 0);
1809 /* There are only two cases to consider. First, the end of the source line
1810 is within the function bounds. In that case we return the end of the
1811 source line. Second is the end of the source line extends beyond the
1812 bounds of the current function. We need to use the slow code to
1813 examine instructions in that case.
1815 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1816 the wrong thing to do. In fact, it should be entirely possible for this
1817 function to always return zero since the slow instruction scanning code
1818 is supposed to *always* work. If it does not, then it is a bug. */
1819 if (sal.end < func_end)
1825 /* To skip prologues, I use this predicate. Returns either PC itself
1826 if the code at PC does not look like a function prologue; otherwise
1827 returns an address that (if we're lucky) follows the prologue.
1829 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1830 It doesn't necessarily skips all the insns in the prologue. In fact
1831 we might not want to skip all the insns because a prologue insn may
1832 appear in the delay slot of the first branch, and we don't want to
1833 skip over the branch in that case. */
1836 hppa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1838 CORE_ADDR post_prologue_pc;
1840 /* See if we can determine the end of the prologue via the symbol table.
1841 If so, then return either PC, or the PC after the prologue, whichever
1844 post_prologue_pc = after_prologue (pc);
1846 /* If after_prologue returned a useful address, then use it. Else
1847 fall back on the instruction skipping code.
1849 Some folks have claimed this causes problems because the breakpoint
1850 may be the first instruction of the prologue. If that happens, then
1851 the instruction skipping code has a bug that needs to be fixed. */
1852 if (post_prologue_pc != 0)
1853 return std::max (pc, post_prologue_pc);
1855 return (skip_prologue_hard_way (gdbarch, pc, 1));
1858 /* Return an unwind entry that falls within the frame's code block. */
1860 static struct unwind_table_entry *
1861 hppa_find_unwind_entry_in_block (struct frame_info *this_frame)
1863 CORE_ADDR pc = get_frame_address_in_block (this_frame);
1865 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1866 result of get_frame_address_in_block implies a problem.
1867 The bits should have been removed earlier, before the return
1868 value of gdbarch_unwind_pc. That might be happening already;
1869 if it isn't, it should be fixed. Then this call can be
1871 pc = gdbarch_addr_bits_remove (get_frame_arch (this_frame), pc);
1872 return find_unwind_entry (pc);
1875 struct hppa_frame_cache
1878 struct trad_frame_saved_reg *saved_regs;
1881 static struct hppa_frame_cache *
1882 hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
1884 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1885 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1886 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1887 struct hppa_frame_cache *cache;
1891 struct unwind_table_entry *u;
1892 CORE_ADDR prologue_end;
1897 fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
1898 frame_relative_level(this_frame));
1900 if ((*this_cache) != NULL)
1903 fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
1904 paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
1905 return (struct hppa_frame_cache *) (*this_cache);
1907 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1908 (*this_cache) = cache;
1909 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1912 u = hppa_find_unwind_entry_in_block (this_frame);
1916 fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
1917 return (struct hppa_frame_cache *) (*this_cache);
1920 /* Turn the Entry_GR field into a bitmask. */
1922 for (i = 3; i < u->Entry_GR + 3; i++)
1924 /* Frame pointer gets saved into a special location. */
1925 if (u->Save_SP && i == HPPA_FP_REGNUM)
1928 saved_gr_mask |= (1 << i);
1931 /* Turn the Entry_FR field into a bitmask too. */
1933 for (i = 12; i < u->Entry_FR + 12; i++)
1934 saved_fr_mask |= (1 << i);
1936 /* Loop until we find everything of interest or hit a branch.
1938 For unoptimized GCC code and for any HP CC code this will never ever
1939 examine any user instructions.
1941 For optimized GCC code we're faced with problems. GCC will schedule
1942 its prologue and make prologue instructions available for delay slot
1943 filling. The end result is user code gets mixed in with the prologue
1944 and a prologue instruction may be in the delay slot of the first branch
1947 Some unexpected things are expected with debugging optimized code, so
1948 we allow this routine to walk past user instructions in optimized
1951 int final_iteration = 0;
1952 CORE_ADDR pc, start_pc, end_pc;
1953 int looking_for_sp = u->Save_SP;
1954 int looking_for_rp = u->Save_RP;
1957 /* We have to use skip_prologue_hard_way instead of just
1958 skip_prologue_using_sal, in case we stepped into a function without
1959 symbol information. hppa_skip_prologue also bounds the returned
1960 pc by the passed in pc, so it will not return a pc in the next
1963 We used to call hppa_skip_prologue to find the end of the prologue,
1964 but if some non-prologue instructions get scheduled into the prologue,
1965 and the program is compiled with debug information, the "easy" way
1966 in hppa_skip_prologue will return a prologue end that is too early
1967 for us to notice any potential frame adjustments. */
1969 /* We used to use get_frame_func to locate the beginning of the
1970 function to pass to skip_prologue. However, when objects are
1971 compiled without debug symbols, get_frame_func can return the wrong
1972 function (or 0). We can do better than that by using unwind records.
1973 This only works if the Region_description of the unwind record
1974 indicates that it includes the entry point of the function.
1975 HP compilers sometimes generate unwind records for regions that
1976 do not include the entry or exit point of a function. GNU tools
1979 if ((u->Region_description & 0x2) == 0)
1980 start_pc = u->region_start;
1982 start_pc = get_frame_func (this_frame);
1984 prologue_end = skip_prologue_hard_way (gdbarch, start_pc, 0);
1985 end_pc = get_frame_pc (this_frame);
1987 if (prologue_end != 0 && end_pc > prologue_end)
1988 end_pc = prologue_end;
1993 ((saved_gr_mask || saved_fr_mask
1994 || looking_for_sp || looking_for_rp
1995 || frame_size < (u->Total_frame_size << 3))
2003 if (!safe_frame_unwind_memory (this_frame, pc, buf4, sizeof buf4))
2005 error (_("Cannot read instruction at %s."),
2006 paddress (gdbarch, pc));
2007 return (struct hppa_frame_cache *) (*this_cache);
2010 inst = extract_unsigned_integer (buf4, sizeof buf4, byte_order);
2012 /* Note the interesting effects of this instruction. */
2013 frame_size += prologue_inst_adjust_sp (inst);
2015 /* There are limited ways to store the return pointer into the
2017 if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2020 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2022 else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
2025 cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
2027 else if (inst == 0x0fc212c1
2028 || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2031 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2034 /* Check to see if we saved SP into the stack. This also
2035 happens to indicate the location of the saved frame
2037 if ((inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
2038 || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2041 cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
2043 else if (inst == 0x08030241) /* copy %r3, %r1 */
2048 /* Account for general and floating-point register saves. */
2049 reg = inst_saves_gr (inst);
2050 if (reg >= 3 && reg <= 18
2051 && (!u->Save_SP || reg != HPPA_FP_REGNUM))
2053 saved_gr_mask &= ~(1 << reg);
2054 if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
2055 /* stwm with a positive displacement is a _post_
2057 cache->saved_regs[reg].addr = 0;
2058 else if ((inst & 0xfc00000c) == 0x70000008)
2059 /* A std has explicit post_modify forms. */
2060 cache->saved_regs[reg].addr = 0;
2065 if ((inst >> 26) == 0x1c)
2066 offset = (inst & 0x1 ? -(1 << 13) : 0)
2067 | (((inst >> 4) & 0x3ff) << 3);
2068 else if ((inst >> 26) == 0x03)
2069 offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
2071 offset = hppa_extract_14 (inst);
2073 /* Handle code with and without frame pointers. */
2075 cache->saved_regs[reg].addr = offset;
2077 cache->saved_regs[reg].addr
2078 = (u->Total_frame_size << 3) + offset;
2082 /* GCC handles callee saved FP regs a little differently.
2084 It emits an instruction to put the value of the start of
2085 the FP store area into %r1. It then uses fstds,ma with a
2086 basereg of %r1 for the stores.
2088 HP CC emits them at the current stack pointer modifying the
2089 stack pointer as it stores each register. */
2091 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2092 if ((inst & 0xffffc000) == 0x34610000
2093 || (inst & 0xffffc000) == 0x37c10000)
2094 fp_loc = hppa_extract_14 (inst);
2096 reg = inst_saves_fr (inst);
2097 if (reg >= 12 && reg <= 21)
2099 /* Note +4 braindamage below is necessary because the FP
2100 status registers are internally 8 registers rather than
2101 the expected 4 registers. */
2102 saved_fr_mask &= ~(1 << reg);
2105 /* 1st HP CC FP register store. After this
2106 instruction we've set enough state that the GCC and
2107 HPCC code are both handled in the same manner. */
2108 cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
2113 cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
2118 /* Quit if we hit any kind of branch the previous iteration. */
2119 if (final_iteration)
2121 /* We want to look precisely one instruction beyond the branch
2122 if we have not found everything yet. */
2123 if (is_branch (inst))
2124 final_iteration = 1;
2129 /* The frame base always represents the value of %sp at entry to
2130 the current function (and is thus equivalent to the "saved"
2132 CORE_ADDR this_sp = get_frame_register_unsigned (this_frame,
2137 fprintf_unfiltered (gdb_stdlog, " (this_sp=%s, pc=%s, "
2138 "prologue_end=%s) ",
2139 paddress (gdbarch, this_sp),
2140 paddress (gdbarch, get_frame_pc (this_frame)),
2141 paddress (gdbarch, prologue_end));
2143 /* Check to see if a frame pointer is available, and use it for
2144 frame unwinding if it is.
2146 There are some situations where we need to rely on the frame
2147 pointer to do stack unwinding. For example, if a function calls
2148 alloca (), the stack pointer can get adjusted inside the body of
2149 the function. In this case, the ABI requires that the compiler
2150 maintain a frame pointer for the function.
2152 The unwind record has a flag (alloca_frame) that indicates that
2153 a function has a variable frame; unfortunately, gcc/binutils
2154 does not set this flag. Instead, whenever a frame pointer is used
2155 and saved on the stack, the Save_SP flag is set. We use this to
2156 decide whether to use the frame pointer for unwinding.
2158 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2159 instead of Save_SP. */
2161 fp = get_frame_register_unsigned (this_frame, HPPA_FP_REGNUM);
2163 if (u->alloca_frame)
2164 fp -= u->Total_frame_size << 3;
2166 if (get_frame_pc (this_frame) >= prologue_end
2167 && (u->Save_SP || u->alloca_frame) && fp != 0)
2172 fprintf_unfiltered (gdb_stdlog, " (base=%s) [frame pointer]",
2173 paddress (gdbarch, cache->base));
2176 && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
2178 /* Both we're expecting the SP to be saved and the SP has been
2179 saved. The entry SP value is saved at this frame's SP
2181 cache->base = read_memory_integer (this_sp, word_size, byte_order);
2184 fprintf_unfiltered (gdb_stdlog, " (base=%s) [saved]",
2185 paddress (gdbarch, cache->base));
2189 /* The prologue has been slowly allocating stack space. Adjust
2191 cache->base = this_sp - frame_size;
2193 fprintf_unfiltered (gdb_stdlog, " (base=%s) [unwind adjust]",
2194 paddress (gdbarch, cache->base));
2197 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2200 /* The PC is found in the "return register", "Millicode" uses "r31"
2201 as the return register while normal code uses "rp". */
2204 if (trad_frame_addr_p (cache->saved_regs, 31))
2206 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
2208 fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
2212 ULONGEST r31 = get_frame_register_unsigned (this_frame, 31);
2213 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
2215 fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
2220 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2222 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2223 cache->saved_regs[HPPA_RP_REGNUM];
2225 fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
2229 ULONGEST rp = get_frame_register_unsigned (this_frame,
2231 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2233 fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
2237 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2238 frame. However, there is a one-insn window where we haven't saved it
2239 yet, but we've already clobbered it. Detect this case and fix it up.
2241 The prologue sequence for frame-pointer functions is:
2242 0: stw %rp, -20(%sp)
2245 c: stw,ma %r1, XX(%sp)
2247 So if we are at offset c, the r3 value that we want is not yet saved
2248 on the stack, but it's been overwritten. The prologue analyzer will
2249 set fp_in_r1 when it sees the copy insn so we know to get the value
2251 if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
2254 ULONGEST r1 = get_frame_register_unsigned (this_frame, 1);
2255 trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
2259 /* Convert all the offsets into addresses. */
2261 for (reg = 0; reg < gdbarch_num_regs (gdbarch); reg++)
2263 if (trad_frame_addr_p (cache->saved_regs, reg))
2264 cache->saved_regs[reg].addr += cache->base;
2269 struct gdbarch_tdep *tdep;
2271 tdep = gdbarch_tdep (gdbarch);
2273 if (tdep->unwind_adjust_stub)
2274 tdep->unwind_adjust_stub (this_frame, cache->base, cache->saved_regs);
2278 fprintf_unfiltered (gdb_stdlog, "base=%s }",
2279 paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
2280 return (struct hppa_frame_cache *) (*this_cache);
2284 hppa_frame_this_id (struct frame_info *this_frame, void **this_cache,
2285 struct frame_id *this_id)
2287 struct hppa_frame_cache *info;
2288 struct unwind_table_entry *u;
2290 info = hppa_frame_cache (this_frame, this_cache);
2291 u = hppa_find_unwind_entry_in_block (this_frame);
2293 (*this_id) = frame_id_build (info->base, u->region_start);
2296 static struct value *
2297 hppa_frame_prev_register (struct frame_info *this_frame,
2298 void **this_cache, int regnum)
2300 struct hppa_frame_cache *info = hppa_frame_cache (this_frame, this_cache);
2302 return hppa_frame_prev_register_helper (this_frame,
2303 info->saved_regs, regnum);
2307 hppa_frame_unwind_sniffer (const struct frame_unwind *self,
2308 struct frame_info *this_frame, void **this_cache)
2310 if (hppa_find_unwind_entry_in_block (this_frame))
2316 static const struct frame_unwind hppa_frame_unwind =
2319 default_frame_unwind_stop_reason,
2321 hppa_frame_prev_register,
2323 hppa_frame_unwind_sniffer
2326 /* This is a generic fallback frame unwinder that kicks in if we fail all
2327 the other ones. Normally we would expect the stub and regular unwinder
2328 to work, but in some cases we might hit a function that just doesn't
2329 have any unwind information available. In this case we try to do
2330 unwinding solely based on code reading. This is obviously going to be
2331 slow, so only use this as a last resort. Currently this will only
2332 identify the stack and pc for the frame. */
2334 static struct hppa_frame_cache *
2335 hppa_fallback_frame_cache (struct frame_info *this_frame, void **this_cache)
2337 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2338 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2339 struct hppa_frame_cache *cache;
2340 unsigned int frame_size = 0;
2345 fprintf_unfiltered (gdb_stdlog,
2346 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2347 frame_relative_level (this_frame));
2349 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
2350 (*this_cache) = cache;
2351 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2353 start_pc = get_frame_func (this_frame);
2356 CORE_ADDR cur_pc = get_frame_pc (this_frame);
2359 for (pc = start_pc; pc < cur_pc; pc += 4)
2363 insn = read_memory_unsigned_integer (pc, 4, byte_order);
2364 frame_size += prologue_inst_adjust_sp (insn);
2366 /* There are limited ways to store the return pointer into the
2368 if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2370 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2373 else if (insn == 0x0fc212c1
2374 || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2376 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2383 fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
2384 frame_size, found_rp);
2386 cache->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2387 cache->base -= frame_size;
2388 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2390 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2392 cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
2393 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2394 cache->saved_regs[HPPA_RP_REGNUM];
2399 rp = get_frame_register_unsigned (this_frame, HPPA_RP_REGNUM);
2400 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2407 hppa_fallback_frame_this_id (struct frame_info *this_frame, void **this_cache,
2408 struct frame_id *this_id)
2410 struct hppa_frame_cache *info =
2411 hppa_fallback_frame_cache (this_frame, this_cache);
2413 (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
2416 static struct value *
2417 hppa_fallback_frame_prev_register (struct frame_info *this_frame,
2418 void **this_cache, int regnum)
2420 struct hppa_frame_cache *info
2421 = hppa_fallback_frame_cache (this_frame, this_cache);
2423 return hppa_frame_prev_register_helper (this_frame,
2424 info->saved_regs, regnum);
2427 static const struct frame_unwind hppa_fallback_frame_unwind =
2430 default_frame_unwind_stop_reason,
2431 hppa_fallback_frame_this_id,
2432 hppa_fallback_frame_prev_register,
2434 default_frame_sniffer
2437 /* Stub frames, used for all kinds of call stubs. */
2438 struct hppa_stub_unwind_cache
2441 struct trad_frame_saved_reg *saved_regs;
2444 static struct hppa_stub_unwind_cache *
2445 hppa_stub_frame_unwind_cache (struct frame_info *this_frame,
2448 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2449 struct hppa_stub_unwind_cache *info;
2450 struct unwind_table_entry *u;
2453 return (struct hppa_stub_unwind_cache *) *this_cache;
2455 info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
2457 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2459 info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2461 if (gdbarch_osabi (gdbarch) == GDB_OSABI_HPUX_SOM)
2463 /* HPUX uses export stubs in function calls; the export stub clobbers
2464 the return value of the caller, and, later restores it from the
2466 u = find_unwind_entry (get_frame_pc (this_frame));
2468 if (u && u->stub_unwind.stub_type == EXPORT)
2470 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = info->base - 24;
2476 /* By default we assume that stubs do not change the rp. */
2477 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
2483 hppa_stub_frame_this_id (struct frame_info *this_frame,
2484 void **this_prologue_cache,
2485 struct frame_id *this_id)
2487 struct hppa_stub_unwind_cache *info
2488 = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2491 *this_id = frame_id_build (info->base, get_frame_func (this_frame));
2494 static struct value *
2495 hppa_stub_frame_prev_register (struct frame_info *this_frame,
2496 void **this_prologue_cache, int regnum)
2498 struct hppa_stub_unwind_cache *info
2499 = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2502 error (_("Requesting registers from null frame."));
2504 return hppa_frame_prev_register_helper (this_frame,
2505 info->saved_regs, regnum);
2509 hppa_stub_unwind_sniffer (const struct frame_unwind *self,
2510 struct frame_info *this_frame,
2513 CORE_ADDR pc = get_frame_address_in_block (this_frame);
2514 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2515 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2518 || (tdep->in_solib_call_trampoline != NULL
2519 && tdep->in_solib_call_trampoline (gdbarch, pc))
2520 || gdbarch_in_solib_return_trampoline (gdbarch, pc, NULL))
2525 static const struct frame_unwind hppa_stub_frame_unwind = {
2527 default_frame_unwind_stop_reason,
2528 hppa_stub_frame_this_id,
2529 hppa_stub_frame_prev_register,
2531 hppa_stub_unwind_sniffer
2534 static struct frame_id
2535 hppa_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2537 return frame_id_build (get_frame_register_unsigned (this_frame,
2539 get_frame_pc (this_frame));
2543 hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2548 ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
2549 pc = frame_unwind_register_unsigned (next_frame, HPPA_PCOQ_HEAD_REGNUM);
2551 /* If the current instruction is nullified, then we are effectively
2552 still executing the previous instruction. Pretend we are still
2553 there. This is needed when single stepping; if the nullified
2554 instruction is on a different line, we don't want GDB to think
2555 we've stepped onto that line. */
2556 if (ipsw & 0x00200000)
2562 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2563 Return NULL if no such symbol was found. */
2565 struct bound_minimal_symbol
2566 hppa_lookup_stub_minimal_symbol (const char *name,
2567 enum unwind_stub_types stub_type)
2569 struct objfile *objfile;
2570 struct minimal_symbol *msym;
2571 struct bound_minimal_symbol result = { NULL, NULL };
2573 ALL_MSYMBOLS (objfile, msym)
2575 if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
2577 struct unwind_table_entry *u;
2579 u = find_unwind_entry (MSYMBOL_VALUE (msym));
2580 if (u != NULL && u->stub_unwind.stub_type == stub_type)
2582 result.objfile = objfile;
2583 result.minsym = msym;
2593 unwind_command (char *exp, int from_tty)
2596 struct unwind_table_entry *u;
2598 /* If we have an expression, evaluate it and use it as the address. */
2600 if (exp != 0 && *exp != 0)
2601 address = parse_and_eval_address (exp);
2605 u = find_unwind_entry (address);
2609 printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2613 printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u));
2615 printf_unfiltered ("\tregion_start = %s\n", hex_string (u->region_start));
2616 gdb_flush (gdb_stdout);
2618 printf_unfiltered ("\tregion_end = %s\n", hex_string (u->region_end));
2619 gdb_flush (gdb_stdout);
2621 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2623 printf_unfiltered ("\n\tflags =");
2624 pif (Cannot_unwind);
2626 pif (Millicode_save_sr0);
2629 pif (Variable_Frame);
2630 pif (Separate_Package_Body);
2631 pif (Frame_Extension_Millicode);
2632 pif (Stack_Overflow_Check);
2633 pif (Two_Instruction_SP_Increment);
2636 pif (cxx_try_catch);
2637 pif (sched_entry_seq);
2640 pif (Save_MRP_in_frame);
2642 pif (Cleanup_defined);
2643 pif (MPE_XL_interrupt_marker);
2644 pif (HP_UX_interrupt_marker);
2648 putchar_unfiltered ('\n');
2650 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2652 pin (Region_description);
2655 pin (Total_frame_size);
2657 if (u->stub_unwind.stub_type)
2659 printf_unfiltered ("\tstub type = ");
2660 switch (u->stub_unwind.stub_type)
2663 printf_unfiltered ("long branch\n");
2665 case PARAMETER_RELOCATION:
2666 printf_unfiltered ("parameter relocation\n");
2669 printf_unfiltered ("export\n");
2672 printf_unfiltered ("import\n");
2675 printf_unfiltered ("import shlib\n");
2678 printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
2683 /* Return the GDB type object for the "standard" data type of data in
2686 static struct type *
2687 hppa32_register_type (struct gdbarch *gdbarch, int regnum)
2689 if (regnum < HPPA_FP4_REGNUM)
2690 return builtin_type (gdbarch)->builtin_uint32;
2692 return builtin_type (gdbarch)->builtin_float;
2695 static struct type *
2696 hppa64_register_type (struct gdbarch *gdbarch, int regnum)
2698 if (regnum < HPPA64_FP4_REGNUM)
2699 return builtin_type (gdbarch)->builtin_uint64;
2701 return builtin_type (gdbarch)->builtin_double;
2704 /* Return non-zero if REGNUM is not a register available to the user
2705 through ptrace/ttrace. */
2708 hppa32_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2711 || regnum == HPPA_PCSQ_HEAD_REGNUM
2712 || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2713 || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
2717 hppa32_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2719 /* cr26 and cr27 are readable (but not writable) from userspace. */
2720 if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2723 return hppa32_cannot_store_register (gdbarch, regnum);
2727 hppa64_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2730 || regnum == HPPA_PCSQ_HEAD_REGNUM
2731 || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2732 || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
2736 hppa64_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2738 /* cr26 and cr27 are readable (but not writable) from userspace. */
2739 if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2742 return hppa64_cannot_store_register (gdbarch, regnum);
2746 hppa_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2748 /* The low two bits of the PC on the PA contain the privilege level.
2749 Some genius implementing a (non-GCC) compiler apparently decided
2750 this means that "addresses" in a text section therefore include a
2751 privilege level, and thus symbol tables should contain these bits.
2752 This seems like a bonehead thing to do--anyway, it seems to work
2753 for our purposes to just ignore those bits. */
2755 return (addr &= ~0x3);
2758 /* Get the ARGIth function argument for the current function. */
2761 hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
2764 return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
2767 static enum register_status
2768 hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2769 int regnum, gdb_byte *buf)
2771 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2773 enum register_status status;
2775 status = regcache_raw_read_unsigned (regcache, regnum, &tmp);
2776 if (status == REG_VALID)
2778 if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
2780 store_unsigned_integer (buf, sizeof tmp, byte_order, tmp);
2786 hppa_find_global_pointer (struct gdbarch *gdbarch, struct value *function)
2792 hppa_frame_prev_register_helper (struct frame_info *this_frame,
2793 struct trad_frame_saved_reg saved_regs[],
2796 struct gdbarch *arch = get_frame_arch (this_frame);
2797 enum bfd_endian byte_order = gdbarch_byte_order (arch);
2799 if (regnum == HPPA_PCOQ_TAIL_REGNUM)
2801 int size = register_size (arch, HPPA_PCOQ_HEAD_REGNUM);
2803 struct value *pcoq_val =
2804 trad_frame_get_prev_register (this_frame, saved_regs,
2805 HPPA_PCOQ_HEAD_REGNUM);
2807 pc = extract_unsigned_integer (value_contents_all (pcoq_val),
2809 return frame_unwind_got_constant (this_frame, regnum, pc + 4);
2812 return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
2816 /* An instruction to match. */
2819 unsigned int data; /* See if it matches this.... */
2820 unsigned int mask; /* ... with this mask. */
2823 /* See bfd/elf32-hppa.c */
2824 static struct insn_pattern hppa_long_branch_stub[] = {
2825 /* ldil LR'xxx,%r1 */
2826 { 0x20200000, 0xffe00000 },
2827 /* be,n RR'xxx(%sr4,%r1) */
2828 { 0xe0202002, 0xffe02002 },
2832 static struct insn_pattern hppa_long_branch_pic_stub[] = {
2834 { 0xe8200000, 0xffe00000 },
2835 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2836 { 0x28200000, 0xffe00000 },
2837 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2838 { 0xe0202002, 0xffe02002 },
2842 static struct insn_pattern hppa_import_stub[] = {
2843 /* addil LR'xxx, %dp */
2844 { 0x2b600000, 0xffe00000 },
2845 /* ldw RR'xxx(%r1), %r21 */
2846 { 0x48350000, 0xffffb000 },
2848 { 0xeaa0c000, 0xffffffff },
2849 /* ldw RR'xxx+4(%r1), %r19 */
2850 { 0x48330000, 0xffffb000 },
2854 static struct insn_pattern hppa_import_pic_stub[] = {
2855 /* addil LR'xxx,%r19 */
2856 { 0x2a600000, 0xffe00000 },
2857 /* ldw RR'xxx(%r1),%r21 */
2858 { 0x48350000, 0xffffb000 },
2860 { 0xeaa0c000, 0xffffffff },
2861 /* ldw RR'xxx+4(%r1),%r19 */
2862 { 0x48330000, 0xffffb000 },
2866 static struct insn_pattern hppa_plt_stub[] = {
2867 /* b,l 1b, %r20 - 1b is 3 insns before here */
2868 { 0xea9f1fdd, 0xffffffff },
2869 /* depi 0,31,2,%r20 */
2870 { 0xd6801c1e, 0xffffffff },
2874 /* Maximum number of instructions on the patterns above. */
2875 #define HPPA_MAX_INSN_PATTERN_LEN 4
2877 /* Return non-zero if the instructions at PC match the series
2878 described in PATTERN, or zero otherwise. PATTERN is an array of
2879 'struct insn_pattern' objects, terminated by an entry whose mask is
2882 When the match is successful, fill INSN[i] with what PATTERN[i]
2886 hppa_match_insns (struct gdbarch *gdbarch, CORE_ADDR pc,
2887 struct insn_pattern *pattern, unsigned int *insn)
2889 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2893 for (i = 0; pattern[i].mask; i++)
2895 gdb_byte buf[HPPA_INSN_SIZE];
2897 target_read_memory (npc, buf, HPPA_INSN_SIZE);
2898 insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE, byte_order);
2899 if ((insn[i] & pattern[i].mask) == pattern[i].data)
2908 /* This relaxed version of the insstruction matcher allows us to match
2909 from somewhere inside the pattern, by looking backwards in the
2910 instruction scheme. */
2913 hppa_match_insns_relaxed (struct gdbarch *gdbarch, CORE_ADDR pc,
2914 struct insn_pattern *pattern, unsigned int *insn)
2916 int offset, len = 0;
2918 while (pattern[len].mask)
2921 for (offset = 0; offset < len; offset++)
2922 if (hppa_match_insns (gdbarch, pc - offset * HPPA_INSN_SIZE,
2930 hppa_in_dyncall (CORE_ADDR pc)
2932 struct unwind_table_entry *u;
2934 u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2938 return (pc >= u->region_start && pc <= u->region_end);
2942 hppa_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc)
2944 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2945 struct unwind_table_entry *u;
2947 if (in_plt_section (pc) || hppa_in_dyncall (pc))
2950 /* The GNU toolchain produces linker stubs without unwind
2951 information. Since the pattern matching for linker stubs can be
2952 quite slow, so bail out if we do have an unwind entry. */
2954 u = find_unwind_entry (pc);
2959 (hppa_match_insns_relaxed (gdbarch, pc, hppa_import_stub, insn)
2960 || hppa_match_insns_relaxed (gdbarch, pc, hppa_import_pic_stub, insn)
2961 || hppa_match_insns_relaxed (gdbarch, pc, hppa_long_branch_stub, insn)
2962 || hppa_match_insns_relaxed (gdbarch, pc,
2963 hppa_long_branch_pic_stub, insn));
2966 /* This code skips several kind of "trampolines" used on PA-RISC
2967 systems: $$dyncall, import stubs and PLT stubs. */
2970 hppa_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
2972 struct gdbarch *gdbarch = get_frame_arch (frame);
2973 struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
2975 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2978 /* $$dyncall handles both PLABELs and direct addresses. */
2979 if (hppa_in_dyncall (pc))
2981 pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22);
2983 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2985 pc = read_memory_typed_address (pc & ~0x3, func_ptr_type);
2990 dp_rel = hppa_match_insns (gdbarch, pc, hppa_import_stub, insn);
2991 if (dp_rel || hppa_match_insns (gdbarch, pc, hppa_import_pic_stub, insn))
2993 /* Extract the target address from the addil/ldw sequence. */
2994 pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
2997 pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
2999 pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
3004 if (in_plt_section (pc))
3006 pc = read_memory_typed_address (pc, func_ptr_type);
3008 /* If the PLT slot has not yet been resolved, the target will be
3010 if (in_plt_section (pc))
3012 /* Sanity check: are we pointing to the PLT stub? */
3013 if (!hppa_match_insns (gdbarch, pc, hppa_plt_stub, insn))
3015 warning (_("Cannot resolve PLT stub at %s."),
3016 paddress (gdbarch, pc));
3020 /* This should point to the fixup routine. */
3021 pc = read_memory_typed_address (pc + 8, func_ptr_type);
3029 /* Here is a table of C type sizes on hppa with various compiles
3030 and options. I measured this on PA 9000/800 with HP-UX 11.11
3031 and these compilers:
3033 /usr/ccs/bin/cc HP92453-01 A.11.01.21
3034 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
3035 /opt/aCC/bin/aCC B3910B A.03.45
3036 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3038 cc : 1 2 4 4 8 : 4 8 -- : 4 4
3039 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3040 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3041 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3042 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3043 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3044 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3045 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3049 compiler and options
3050 char, short, int, long, long long
3051 float, double, long double
3054 So all these compilers use either ILP32 or LP64 model.
3055 TODO: gcc has more options so it needs more investigation.
3057 For floating point types, see:
3059 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3060 HP-UX floating-point guide, hpux 11.00
3062 -- chastain 2003-12-18 */
3064 static struct gdbarch *
3065 hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3067 struct gdbarch_tdep *tdep;
3068 struct gdbarch *gdbarch;
3070 /* Try to determine the ABI of the object we are loading. */
3071 if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
3073 /* If it's a SOM file, assume it's HP/UX SOM. */
3074 if (bfd_get_flavour (info.abfd) == bfd_target_som_flavour)
3075 info.osabi = GDB_OSABI_HPUX_SOM;
3078 /* find a candidate among the list of pre-declared architectures. */
3079 arches = gdbarch_list_lookup_by_info (arches, &info);
3081 return (arches->gdbarch);
3083 /* If none found, then allocate and initialize one. */
3084 tdep = XCNEW (struct gdbarch_tdep);
3085 gdbarch = gdbarch_alloc (&info, tdep);
3087 /* Determine from the bfd_arch_info structure if we are dealing with
3088 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3089 then default to a 32bit machine. */
3090 if (info.bfd_arch_info != NULL)
3091 tdep->bytes_per_address =
3092 info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
3094 tdep->bytes_per_address = 4;
3096 tdep->find_global_pointer = hppa_find_global_pointer;
3098 /* Some parts of the gdbarch vector depend on whether we are running
3099 on a 32 bits or 64 bits target. */
3100 switch (tdep->bytes_per_address)
3103 set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
3104 set_gdbarch_register_name (gdbarch, hppa32_register_name);
3105 set_gdbarch_register_type (gdbarch, hppa32_register_type);
3106 set_gdbarch_cannot_store_register (gdbarch,
3107 hppa32_cannot_store_register);
3108 set_gdbarch_cannot_fetch_register (gdbarch,
3109 hppa32_cannot_fetch_register);
3112 set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
3113 set_gdbarch_register_name (gdbarch, hppa64_register_name);
3114 set_gdbarch_register_type (gdbarch, hppa64_register_type);
3115 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
3116 set_gdbarch_cannot_store_register (gdbarch,
3117 hppa64_cannot_store_register);
3118 set_gdbarch_cannot_fetch_register (gdbarch,
3119 hppa64_cannot_fetch_register);
3122 internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
3123 tdep->bytes_per_address);
3126 set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3127 set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3129 /* The following gdbarch vector elements are the same in both ILP32
3130 and LP64, but might show differences some day. */
3131 set_gdbarch_long_long_bit (gdbarch, 64);
3132 set_gdbarch_long_double_bit (gdbarch, 128);
3133 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3135 /* The following gdbarch vector elements do not depend on the address
3136 size, or in any other gdbarch element previously set. */
3137 set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
3138 set_gdbarch_stack_frame_destroyed_p (gdbarch,
3139 hppa_stack_frame_destroyed_p);
3140 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
3141 set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM);
3142 set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM);
3143 set_gdbarch_addr_bits_remove (gdbarch, hppa_addr_bits_remove);
3144 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3145 set_gdbarch_read_pc (gdbarch, hppa_read_pc);
3146 set_gdbarch_write_pc (gdbarch, hppa_write_pc);
3148 /* Helper for function argument information. */
3149 set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
3151 set_gdbarch_print_insn (gdbarch, print_insn_hppa);
3153 /* When a hardware watchpoint triggers, we'll move the inferior past
3154 it by removing all eventpoints; stepping past the instruction
3155 that caused the trigger; reinserting eventpoints; and checking
3156 whether any watched location changed. */
3157 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
3159 /* Inferior function call methods. */
3160 switch (tdep->bytes_per_address)
3163 set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
3164 set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
3165 set_gdbarch_convert_from_func_ptr_addr
3166 (gdbarch, hppa32_convert_from_func_ptr_addr);
3169 set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
3170 set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
3173 internal_error (__FILE__, __LINE__, _("bad switch"));
3176 /* Struct return methods. */
3177 switch (tdep->bytes_per_address)
3180 set_gdbarch_return_value (gdbarch, hppa32_return_value);
3183 set_gdbarch_return_value (gdbarch, hppa64_return_value);
3186 internal_error (__FILE__, __LINE__, _("bad switch"));
3189 set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
3190 set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
3192 /* Frame unwind methods. */
3193 set_gdbarch_dummy_id (gdbarch, hppa_dummy_id);
3194 set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
3196 /* Hook in ABI-specific overrides, if they have been registered. */
3197 gdbarch_init_osabi (info, gdbarch);
3199 /* Hook in the default unwinders. */
3200 frame_unwind_append_unwinder (gdbarch, &hppa_stub_frame_unwind);
3201 frame_unwind_append_unwinder (gdbarch, &hppa_frame_unwind);
3202 frame_unwind_append_unwinder (gdbarch, &hppa_fallback_frame_unwind);
3208 hppa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3210 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3212 fprintf_unfiltered (file, "bytes_per_address = %d\n",
3213 tdep->bytes_per_address);
3214 fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
3217 /* Provide a prototype to silence -Wmissing-prototypes. */
3218 extern initialize_file_ftype _initialize_hppa_tdep;
3221 _initialize_hppa_tdep (void)
3223 gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
3225 hppa_objfile_priv_data = register_objfile_data ();
3227 add_cmd ("unwind", class_maintenance, unwind_command,
3228 _("Print unwind table entry at given address."),
3229 &maintenanceprintlist);
3231 /* Debug this files internals. */
3232 add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
3233 Set whether hppa target specific debugging information should be displayed."),
3235 Show whether hppa target specific debugging information is displayed."), _("\
3236 This flag controls whether hppa target specific debugging information is\n\
3237 displayed. This information is particularly useful for debugging frame\n\
3238 unwinding problems."),
3240 NULL, /* FIXME: i18n: hppa debug flag is %s. */
3241 &setdebuglist, &showdebuglist);