1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986-2017 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 constexpr gdb_byte hppa_break_insn[] = {0x00, 0x01, 0x00, 0x04};
609 typedef BP_MANIPULATION (hppa_break_insn) hppa_breakpoint;
611 /* Return the name of a register. */
614 hppa32_register_name (struct gdbarch *gdbarch, int i)
616 static const char *names[] = {
617 "flags", "r1", "rp", "r3",
618 "r4", "r5", "r6", "r7",
619 "r8", "r9", "r10", "r11",
620 "r12", "r13", "r14", "r15",
621 "r16", "r17", "r18", "r19",
622 "r20", "r21", "r22", "r23",
623 "r24", "r25", "r26", "dp",
624 "ret0", "ret1", "sp", "r31",
625 "sar", "pcoqh", "pcsqh", "pcoqt",
626 "pcsqt", "eiem", "iir", "isr",
627 "ior", "ipsw", "goto", "sr4",
628 "sr0", "sr1", "sr2", "sr3",
629 "sr5", "sr6", "sr7", "cr0",
630 "cr8", "cr9", "ccr", "cr12",
631 "cr13", "cr24", "cr25", "cr26",
632 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
633 "fpsr", "fpe1", "fpe2", "fpe3",
634 "fpe4", "fpe5", "fpe6", "fpe7",
635 "fr4", "fr4R", "fr5", "fr5R",
636 "fr6", "fr6R", "fr7", "fr7R",
637 "fr8", "fr8R", "fr9", "fr9R",
638 "fr10", "fr10R", "fr11", "fr11R",
639 "fr12", "fr12R", "fr13", "fr13R",
640 "fr14", "fr14R", "fr15", "fr15R",
641 "fr16", "fr16R", "fr17", "fr17R",
642 "fr18", "fr18R", "fr19", "fr19R",
643 "fr20", "fr20R", "fr21", "fr21R",
644 "fr22", "fr22R", "fr23", "fr23R",
645 "fr24", "fr24R", "fr25", "fr25R",
646 "fr26", "fr26R", "fr27", "fr27R",
647 "fr28", "fr28R", "fr29", "fr29R",
648 "fr30", "fr30R", "fr31", "fr31R"
650 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
657 hppa64_register_name (struct gdbarch *gdbarch, int i)
659 static const char *names[] = {
660 "flags", "r1", "rp", "r3",
661 "r4", "r5", "r6", "r7",
662 "r8", "r9", "r10", "r11",
663 "r12", "r13", "r14", "r15",
664 "r16", "r17", "r18", "r19",
665 "r20", "r21", "r22", "r23",
666 "r24", "r25", "r26", "dp",
667 "ret0", "ret1", "sp", "r31",
668 "sar", "pcoqh", "pcsqh", "pcoqt",
669 "pcsqt", "eiem", "iir", "isr",
670 "ior", "ipsw", "goto", "sr4",
671 "sr0", "sr1", "sr2", "sr3",
672 "sr5", "sr6", "sr7", "cr0",
673 "cr8", "cr9", "ccr", "cr12",
674 "cr13", "cr24", "cr25", "cr26",
675 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
676 "fpsr", "fpe1", "fpe2", "fpe3",
677 "fr4", "fr5", "fr6", "fr7",
678 "fr8", "fr9", "fr10", "fr11",
679 "fr12", "fr13", "fr14", "fr15",
680 "fr16", "fr17", "fr18", "fr19",
681 "fr20", "fr21", "fr22", "fr23",
682 "fr24", "fr25", "fr26", "fr27",
683 "fr28", "fr29", "fr30", "fr31"
685 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
691 /* Map dwarf DBX register numbers to GDB register numbers. */
693 hppa64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
695 /* The general registers and the sar are the same in both sets. */
696 if (reg >= 0 && reg <= 32)
699 /* fr4-fr31 are mapped from 72 in steps of 2. */
700 if (reg >= 72 && reg < 72 + 28 * 2 && !(reg & 1))
701 return HPPA64_FP4_REGNUM + (reg - 72) / 2;
706 /* This function pushes a stack frame with arguments as part of the
707 inferior function calling mechanism.
709 This is the version of the function for the 32-bit PA machines, in
710 which later arguments appear at lower addresses. (The stack always
711 grows towards higher addresses.)
713 We simply allocate the appropriate amount of stack space and put
714 arguments into their proper slots. */
717 hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
718 struct regcache *regcache, CORE_ADDR bp_addr,
719 int nargs, struct value **args, CORE_ADDR sp,
720 int struct_return, CORE_ADDR struct_addr)
722 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
724 /* Stack base address at which any pass-by-reference parameters are
726 CORE_ADDR struct_end = 0;
727 /* Stack base address at which the first parameter is stored. */
728 CORE_ADDR param_end = 0;
730 /* Two passes. First pass computes the location of everything,
731 second pass writes the bytes out. */
734 /* Global pointer (r19) of the function we are trying to call. */
737 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
739 for (write_pass = 0; write_pass < 2; write_pass++)
741 CORE_ADDR struct_ptr = 0;
742 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
743 struct_ptr is adjusted for each argument below, so the first
744 argument will end up at sp-36. */
745 CORE_ADDR param_ptr = 32;
747 int small_struct = 0;
749 for (i = 0; i < nargs; i++)
751 struct value *arg = args[i];
752 struct type *type = check_typedef (value_type (arg));
753 /* The corresponding parameter that is pushed onto the
754 stack, and [possibly] passed in a register. */
755 gdb_byte param_val[8];
757 memset (param_val, 0, sizeof param_val);
758 if (TYPE_LENGTH (type) > 8)
760 /* Large parameter, pass by reference. Store the value
761 in "struct" area and then pass its address. */
763 struct_ptr += align_up (TYPE_LENGTH (type), 8);
765 write_memory (struct_end - struct_ptr, value_contents (arg),
767 store_unsigned_integer (param_val, 4, byte_order,
768 struct_end - struct_ptr);
770 else if (TYPE_CODE (type) == TYPE_CODE_INT
771 || TYPE_CODE (type) == TYPE_CODE_ENUM)
773 /* Integer value store, right aligned. "unpack_long"
774 takes care of any sign-extension problems. */
775 param_len = align_up (TYPE_LENGTH (type), 4);
776 store_unsigned_integer (param_val, param_len, byte_order,
778 value_contents (arg)));
780 else if (TYPE_CODE (type) == TYPE_CODE_FLT)
782 /* Floating point value store, right aligned. */
783 param_len = align_up (TYPE_LENGTH (type), 4);
784 memcpy (param_val, value_contents (arg), param_len);
788 param_len = align_up (TYPE_LENGTH (type), 4);
790 /* Small struct value are stored right-aligned. */
791 memcpy (param_val + param_len - TYPE_LENGTH (type),
792 value_contents (arg), TYPE_LENGTH (type));
794 /* Structures of size 5, 6 and 7 bytes are special in that
795 the higher-ordered word is stored in the lower-ordered
796 argument, and even though it is a 8-byte quantity the
797 registers need not be 8-byte aligned. */
798 if (param_len > 4 && param_len < 8)
802 param_ptr += param_len;
803 if (param_len == 8 && !small_struct)
804 param_ptr = align_up (param_ptr, 8);
806 /* First 4 non-FP arguments are passed in gr26-gr23.
807 First 4 32-bit FP arguments are passed in fr4L-fr7L.
808 First 2 64-bit FP arguments are passed in fr5 and fr7.
810 The rest go on the stack, starting at sp-36, towards lower
811 addresses. 8-byte arguments must be aligned to a 8-byte
815 write_memory (param_end - param_ptr, param_val, param_len);
817 /* There are some cases when we don't know the type
818 expected by the callee (e.g. for variadic functions), so
819 pass the parameters in both general and fp regs. */
822 int grreg = 26 - (param_ptr - 36) / 4;
823 int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
824 int fpreg = 74 + (param_ptr - 32) / 8 * 4;
826 regcache_cooked_write (regcache, grreg, param_val);
827 regcache_cooked_write (regcache, fpLreg, param_val);
831 regcache_cooked_write (regcache, grreg + 1,
834 regcache_cooked_write (regcache, fpreg, param_val);
835 regcache_cooked_write (regcache, fpreg + 1,
842 /* Update the various stack pointers. */
845 struct_end = sp + align_up (struct_ptr, 64);
846 /* PARAM_PTR already accounts for all the arguments passed
847 by the user. However, the ABI mandates minimum stack
848 space allocations for outgoing arguments. The ABI also
849 mandates minimum stack alignments which we must
851 param_end = struct_end + align_up (param_ptr, 64);
855 /* If a structure has to be returned, set up register 28 to hold its
858 regcache_cooked_write_unsigned (regcache, 28, struct_addr);
860 gp = tdep->find_global_pointer (gdbarch, function);
863 regcache_cooked_write_unsigned (regcache, 19, gp);
865 /* Set the return address. */
866 if (!gdbarch_push_dummy_code_p (gdbarch))
867 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
869 /* Update the Stack Pointer. */
870 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end);
875 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
876 Runtime Architecture for PA-RISC 2.0", which is distributed as part
877 as of the HP-UX Software Transition Kit (STK). This implementation
878 is based on version 3.3, dated October 6, 1997. */
880 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
883 hppa64_integral_or_pointer_p (const struct type *type)
885 switch (TYPE_CODE (type))
891 case TYPE_CODE_RANGE:
893 int len = TYPE_LENGTH (type);
894 return (len == 1 || len == 2 || len == 4 || len == 8);
898 case TYPE_CODE_RVALUE_REF:
899 return (TYPE_LENGTH (type) == 8);
907 /* Check whether TYPE is a "Floating Scalar Type". */
910 hppa64_floating_p (const struct type *type)
912 switch (TYPE_CODE (type))
916 int len = TYPE_LENGTH (type);
917 return (len == 4 || len == 8 || len == 16);
926 /* If CODE points to a function entry address, try to look up the corresponding
927 function descriptor and return its address instead. If CODE is not a
928 function entry address, then just return it unchanged. */
930 hppa64_convert_code_addr_to_fptr (struct gdbarch *gdbarch, CORE_ADDR code)
932 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
933 struct obj_section *sec, *opd;
935 sec = find_pc_section (code);
940 /* If CODE is in a data section, assume it's already a fptr. */
941 if (!(sec->the_bfd_section->flags & SEC_CODE))
944 ALL_OBJFILE_OSECTIONS (sec->objfile, opd)
946 if (strcmp (opd->the_bfd_section->name, ".opd") == 0)
950 if (opd < sec->objfile->sections_end)
954 for (addr = obj_section_addr (opd);
955 addr < obj_section_endaddr (opd);
961 if (target_read_memory (addr, tmp, sizeof (tmp)))
963 opdaddr = extract_unsigned_integer (tmp, sizeof (tmp), byte_order);
974 hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
975 struct regcache *regcache, CORE_ADDR bp_addr,
976 int nargs, struct value **args, CORE_ADDR sp,
977 int struct_return, CORE_ADDR struct_addr)
979 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
980 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
984 /* "The outgoing parameter area [...] must be aligned at a 16-byte
986 sp = align_up (sp, 16);
988 for (i = 0; i < nargs; i++)
990 struct value *arg = args[i];
991 struct type *type = value_type (arg);
992 int len = TYPE_LENGTH (type);
993 const bfd_byte *valbuf;
997 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
998 offset = align_up (offset, 8);
1000 if (hppa64_integral_or_pointer_p (type))
1002 /* "Integral scalar parameters smaller than 64 bits are
1003 padded on the left (i.e., the value is in the
1004 least-significant bits of the 64-bit storage unit, and
1005 the high-order bits are undefined)." Therefore we can
1006 safely sign-extend them. */
1009 arg = value_cast (builtin_type (gdbarch)->builtin_int64, arg);
1013 else if (hppa64_floating_p (type))
1017 /* "Quad-precision (128-bit) floating-point scalar
1018 parameters are aligned on a 16-byte boundary." */
1019 offset = align_up (offset, 16);
1021 /* "Double-extended- and quad-precision floating-point
1022 parameters within the first 64 bytes of the parameter
1023 list are always passed in general registers." */
1029 /* "Single-precision (32-bit) floating-point scalar
1030 parameters are padded on the left with 32 bits of
1031 garbage (i.e., the floating-point value is in the
1032 least-significant 32 bits of a 64-bit storage
1037 /* "Single- and double-precision floating-point
1038 parameters in this area are passed according to the
1039 available formal parameter information in a function
1040 prototype. [...] If no prototype is in scope,
1041 floating-point parameters must be passed both in the
1042 corresponding general registers and in the
1043 corresponding floating-point registers." */
1044 regnum = HPPA64_FP4_REGNUM + offset / 8;
1046 if (regnum < HPPA64_FP4_REGNUM + 8)
1048 /* "Single-precision floating-point parameters, when
1049 passed in floating-point registers, are passed in
1050 the right halves of the floating point registers;
1051 the left halves are unused." */
1052 regcache_cooked_write_part (regcache, regnum, offset % 8,
1053 len, value_contents (arg));
1061 /* "Aggregates larger than 8 bytes are aligned on a
1062 16-byte boundary, possibly leaving an unused argument
1063 slot, which is filled with garbage. If necessary,
1064 they are padded on the right (with garbage), to a
1065 multiple of 8 bytes." */
1066 offset = align_up (offset, 16);
1070 /* If we are passing a function pointer, make sure we pass a function
1071 descriptor instead of the function entry address. */
1072 if (TYPE_CODE (type) == TYPE_CODE_PTR
1073 && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1075 ULONGEST codeptr, fptr;
1077 codeptr = unpack_long (type, value_contents (arg));
1078 fptr = hppa64_convert_code_addr_to_fptr (gdbarch, codeptr);
1079 store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), byte_order,
1085 valbuf = value_contents (arg);
1088 /* Always store the argument in memory. */
1089 write_memory (sp + offset, valbuf, len);
1091 regnum = HPPA_ARG0_REGNUM - offset / 8;
1092 while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
1094 regcache_cooked_write_part (regcache, regnum,
1095 offset % 8, std::min (len, 8), valbuf);
1096 offset += std::min (len, 8);
1097 valbuf += std::min (len, 8);
1098 len -= std::min (len, 8);
1105 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1106 regcache_cooked_write_unsigned (regcache, HPPA_RET1_REGNUM, sp + 64);
1108 /* Allocate the outgoing parameter area. Make sure the outgoing
1109 parameter area is multiple of 16 bytes in length. */
1110 sp += std::max (align_up (offset, 16), (ULONGEST) 64);
1112 /* Allocate 32-bytes of scratch space. The documentation doesn't
1113 mention this, but it seems to be needed. */
1116 /* Allocate the frame marker area. */
1119 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1122 regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
1124 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1125 gp = tdep->find_global_pointer (gdbarch, function);
1127 regcache_cooked_write_unsigned (regcache, HPPA_DP_REGNUM, gp);
1129 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1130 if (!gdbarch_push_dummy_code_p (gdbarch))
1131 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
1133 /* Set up GR30 to hold the stack pointer (sp). */
1134 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, sp);
1140 /* Handle 32/64-bit struct return conventions. */
1142 static enum return_value_convention
1143 hppa32_return_value (struct gdbarch *gdbarch, struct value *function,
1144 struct type *type, struct regcache *regcache,
1145 gdb_byte *readbuf, const gdb_byte *writebuf)
1147 if (TYPE_LENGTH (type) <= 2 * 4)
1149 /* The value always lives in the right hand end of the register
1150 (or register pair)? */
1152 int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
1153 int part = TYPE_LENGTH (type) % 4;
1154 /* The left hand register contains only part of the value,
1155 transfer that first so that the rest can be xfered as entire
1156 4-byte registers. */
1159 if (readbuf != NULL)
1160 regcache_cooked_read_part (regcache, reg, 4 - part,
1162 if (writebuf != NULL)
1163 regcache_cooked_write_part (regcache, reg, 4 - part,
1167 /* Now transfer the remaining register values. */
1168 for (b = part; b < TYPE_LENGTH (type); b += 4)
1170 if (readbuf != NULL)
1171 regcache_cooked_read (regcache, reg, readbuf + b);
1172 if (writebuf != NULL)
1173 regcache_cooked_write (regcache, reg, writebuf + b);
1176 return RETURN_VALUE_REGISTER_CONVENTION;
1179 return RETURN_VALUE_STRUCT_CONVENTION;
1182 static enum return_value_convention
1183 hppa64_return_value (struct gdbarch *gdbarch, struct value *function,
1184 struct type *type, struct regcache *regcache,
1185 gdb_byte *readbuf, const gdb_byte *writebuf)
1187 int len = TYPE_LENGTH (type);
1192 /* All return values larget than 128 bits must be aggregate
1194 gdb_assert (!hppa64_integral_or_pointer_p (type));
1195 gdb_assert (!hppa64_floating_p (type));
1197 /* "Aggregate return values larger than 128 bits are returned in
1198 a buffer allocated by the caller. The address of the buffer
1199 must be passed in GR 28." */
1200 return RETURN_VALUE_STRUCT_CONVENTION;
1203 if (hppa64_integral_or_pointer_p (type))
1205 /* "Integral return values are returned in GR 28. Values
1206 smaller than 64 bits are padded on the left (with garbage)." */
1207 regnum = HPPA_RET0_REGNUM;
1210 else if (hppa64_floating_p (type))
1214 /* "Double-extended- and quad-precision floating-point
1215 values are returned in GRs 28 and 29. The sign,
1216 exponent, and most-significant bits of the mantissa are
1217 returned in GR 28; the least-significant bits of the
1218 mantissa are passed in GR 29. For double-extended
1219 precision values, GR 29 is padded on the right with 48
1220 bits of garbage." */
1221 regnum = HPPA_RET0_REGNUM;
1226 /* "Single-precision and double-precision floating-point
1227 return values are returned in FR 4R (single precision) or
1228 FR 4 (double-precision)." */
1229 regnum = HPPA64_FP4_REGNUM;
1235 /* "Aggregate return values up to 64 bits in size are returned
1236 in GR 28. Aggregates smaller than 64 bits are left aligned
1237 in the register; the pad bits on the right are undefined."
1239 "Aggregate return values between 65 and 128 bits are returned
1240 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1241 the remaining bits are placed, left aligned, in GR 29. The
1242 pad bits on the right of GR 29 (if any) are undefined." */
1243 regnum = HPPA_RET0_REGNUM;
1251 regcache_cooked_read_part (regcache, regnum, offset,
1252 std::min (len, 8), readbuf);
1253 readbuf += std::min (len, 8);
1254 len -= std::min (len, 8);
1263 regcache_cooked_write_part (regcache, regnum, offset,
1264 std::min (len, 8), writebuf);
1265 writebuf += std::min (len, 8);
1266 len -= std::min (len, 8);
1271 return RETURN_VALUE_REGISTER_CONVENTION;
1276 hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1277 struct target_ops *targ)
1281 struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1282 CORE_ADDR plabel = addr & ~3;
1283 return read_memory_typed_address (plabel, func_ptr_type);
1290 hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1292 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1294 return align_up (addr, 64);
1297 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1300 hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1302 /* Just always 16-byte align. */
1303 return align_up (addr, 16);
1307 hppa_read_pc (struct regcache *regcache)
1312 regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
1313 regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
1315 /* If the current instruction is nullified, then we are effectively
1316 still executing the previous instruction. Pretend we are still
1317 there. This is needed when single stepping; if the nullified
1318 instruction is on a different line, we don't want GDB to think
1319 we've stepped onto that line. */
1320 if (ipsw & 0x00200000)
1327 hppa_write_pc (struct regcache *regcache, CORE_ADDR pc)
1329 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pc);
1330 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pc + 4);
1333 /* For the given instruction (INST), return any adjustment it makes
1334 to the stack pointer or zero for no adjustment.
1336 This only handles instructions commonly found in prologues. */
1339 prologue_inst_adjust_sp (unsigned long inst)
1341 /* This must persist across calls. */
1342 static int save_high21;
1344 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1345 if ((inst & 0xffffc000) == 0x37de0000)
1346 return hppa_extract_14 (inst);
1349 if ((inst & 0xffe00000) == 0x6fc00000)
1350 return hppa_extract_14 (inst);
1352 /* std,ma X,D(sp) */
1353 if ((inst & 0xffe00008) == 0x73c00008)
1354 return (inst & 0x1 ? -(1 << 13) : 0) | (((inst >> 4) & 0x3ff) << 3);
1356 /* addil high21,%r30; ldo low11,(%r1),%r30)
1357 save high bits in save_high21 for later use. */
1358 if ((inst & 0xffe00000) == 0x2bc00000)
1360 save_high21 = hppa_extract_21 (inst);
1364 if ((inst & 0xffff0000) == 0x343e0000)
1365 return save_high21 + hppa_extract_14 (inst);
1367 /* fstws as used by the HP compilers. */
1368 if ((inst & 0xffffffe0) == 0x2fd01220)
1369 return hppa_extract_5_load (inst);
1371 /* No adjustment. */
1375 /* Return nonzero if INST is a branch of some kind, else return zero. */
1378 is_branch (unsigned long inst)
1407 /* Return the register number for a GR which is saved by INST or
1408 zero if INST does not save a GR.
1413 https://parisc.wiki.kernel.org/images-parisc/6/68/Pa11_acd.pdf
1416 https://parisc.wiki.kernel.org/images-parisc/7/73/Parisc2.0.pdf
1418 According to Table 6-5 of Chapter 6 (Memory Reference Instructions)
1419 on page 106 in parisc 2.0, all instructions for storing values from
1420 the general registers are:
1422 Store: stb, sth, stw, std (according to Chapter 7, they
1423 are only in both "inst >> 26" and "inst >> 6".
1424 Store Absolute: stwa, stda (according to Chapter 7, they are only
1426 Store Bytes: stby, stdby (according to Chapter 7, they are
1427 only in "inst >> 6").
1429 For (inst >> 26), according to Chapter 7:
1431 The effective memory reference address is formed by the addition
1432 of an immediate displacement to a base value.
1434 - stb: 0x18, store a byte from a general register.
1436 - sth: 0x19, store a halfword from a general register.
1438 - stw: 0x1a, store a word from a general register.
1440 - stwm: 0x1b, store a word from a general register and perform base
1441 register modification (2.0 will still treate it as stw).
1443 - std: 0x1c, store a doubleword from a general register (2.0 only).
1445 - stw: 0x1f, store a word from a general register (2.0 only).
1447 For (inst >> 6) when ((inst >> 26) == 0x03), according to Chapter 7:
1449 The effective memory reference address is formed by the addition
1450 of an index value to a base value specified in the instruction.
1452 - stb: 0x08, store a byte from a general register (1.1 calls stbs).
1454 - sth: 0x09, store a halfword from a general register (1.1 calls
1457 - stw: 0x0a, store a word from a general register (1.1 calls stws).
1459 - std: 0x0b: store a doubleword from a general register (2.0 only)
1461 Implement fast byte moves (stores) to unaligned word or doubleword
1464 - stby: 0x0c, for unaligned word (1.1 calls stbys).
1466 - stdby: 0x0d for unaligned doubleword (2.0 only).
1468 Store a word or doubleword using an absolute memory address formed
1469 using short or long displacement or indexed
1471 - stwa: 0x0e, store a word from a general register to an absolute
1472 address (1.0 calls stwas).
1474 - stda: 0x0f, store a doubleword from a general register to an
1475 absolute address (2.0 only). */
1478 inst_saves_gr (unsigned long inst)
1480 switch ((inst >> 26) & 0x0f)
1483 switch ((inst >> 6) & 0x0f)
1493 return hppa_extract_5R_store (inst);
1502 /* no 0x1d or 0x1e -- according to parisc 2.0 document */
1504 return hppa_extract_5R_store (inst);
1510 /* Return the register number for a FR which is saved by INST or
1511 zero it INST does not save a FR.
1513 Note we only care about full 64bit register stores (that's the only
1514 kind of stores the prologue will use).
1516 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1519 inst_saves_fr (unsigned long inst)
1521 /* Is this an FSTD? */
1522 if ((inst & 0xfc00dfc0) == 0x2c001200)
1523 return hppa_extract_5r_store (inst);
1524 if ((inst & 0xfc000002) == 0x70000002)
1525 return hppa_extract_5R_store (inst);
1526 /* Is this an FSTW? */
1527 if ((inst & 0xfc00df80) == 0x24001200)
1528 return hppa_extract_5r_store (inst);
1529 if ((inst & 0xfc000002) == 0x7c000000)
1530 return hppa_extract_5R_store (inst);
1534 /* Advance PC across any function entry prologue instructions
1535 to reach some "real" code.
1537 Use information in the unwind table to determine what exactly should
1538 be in the prologue. */
1542 skip_prologue_hard_way (struct gdbarch *gdbarch, CORE_ADDR pc,
1543 int stop_before_branch)
1545 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1547 CORE_ADDR orig_pc = pc;
1548 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1549 unsigned long args_stored, status, i, restart_gr, restart_fr;
1550 struct unwind_table_entry *u;
1551 int final_iteration;
1557 u = find_unwind_entry (pc);
1561 /* If we are not at the beginning of a function, then return now. */
1562 if ((pc & ~0x3) != u->region_start)
1565 /* This is how much of a frame adjustment we need to account for. */
1566 stack_remaining = u->Total_frame_size << 3;
1568 /* Magic register saves we want to know about. */
1569 save_rp = u->Save_RP;
1570 save_sp = u->Save_SP;
1572 /* An indication that args may be stored into the stack. Unfortunately
1573 the HPUX compilers tend to set this in cases where no args were
1577 /* Turn the Entry_GR field into a bitmask. */
1579 for (i = 3; i < u->Entry_GR + 3; i++)
1581 /* Frame pointer gets saved into a special location. */
1582 if (u->Save_SP && i == HPPA_FP_REGNUM)
1585 save_gr |= (1 << i);
1587 save_gr &= ~restart_gr;
1589 /* Turn the Entry_FR field into a bitmask too. */
1591 for (i = 12; i < u->Entry_FR + 12; i++)
1592 save_fr |= (1 << i);
1593 save_fr &= ~restart_fr;
1595 final_iteration = 0;
1597 /* Loop until we find everything of interest or hit a branch.
1599 For unoptimized GCC code and for any HP CC code this will never ever
1600 examine any user instructions.
1602 For optimzied GCC code we're faced with problems. GCC will schedule
1603 its prologue and make prologue instructions available for delay slot
1604 filling. The end result is user code gets mixed in with the prologue
1605 and a prologue instruction may be in the delay slot of the first branch
1608 Some unexpected things are expected with debugging optimized code, so
1609 we allow this routine to walk past user instructions in optimized
1611 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1614 unsigned int reg_num;
1615 unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1616 unsigned long old_save_rp, old_save_sp, next_inst;
1618 /* Save copies of all the triggers so we can compare them later
1620 old_save_gr = save_gr;
1621 old_save_fr = save_fr;
1622 old_save_rp = save_rp;
1623 old_save_sp = save_sp;
1624 old_stack_remaining = stack_remaining;
1626 status = target_read_memory (pc, buf, 4);
1627 inst = extract_unsigned_integer (buf, 4, byte_order);
1633 /* Note the interesting effects of this instruction. */
1634 stack_remaining -= prologue_inst_adjust_sp (inst);
1636 /* There are limited ways to store the return pointer into the
1638 if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1641 /* These are the only ways we save SP into the stack. At this time
1642 the HP compilers never bother to save SP into the stack. */
1643 if ((inst & 0xffffc000) == 0x6fc10000
1644 || (inst & 0xffffc00c) == 0x73c10008)
1647 /* Are we loading some register with an offset from the argument
1649 if ((inst & 0xffe00000) == 0x37a00000
1650 || (inst & 0xffffffe0) == 0x081d0240)
1656 /* Account for general and floating-point register saves. */
1657 reg_num = inst_saves_gr (inst);
1658 save_gr &= ~(1 << reg_num);
1660 /* Ugh. Also account for argument stores into the stack.
1661 Unfortunately args_stored only tells us that some arguments
1662 where stored into the stack. Not how many or what kind!
1664 This is a kludge as on the HP compiler sets this bit and it
1665 never does prologue scheduling. So once we see one, skip past
1666 all of them. We have similar code for the fp arg stores below.
1668 FIXME. Can still die if we have a mix of GR and FR argument
1670 if (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1673 while (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1677 status = target_read_memory (pc, buf, 4);
1678 inst = extract_unsigned_integer (buf, 4, byte_order);
1681 reg_num = inst_saves_gr (inst);
1687 reg_num = inst_saves_fr (inst);
1688 save_fr &= ~(1 << reg_num);
1690 status = target_read_memory (pc + 4, buf, 4);
1691 next_inst = extract_unsigned_integer (buf, 4, byte_order);
1697 /* We've got to be read to handle the ldo before the fp register
1699 if ((inst & 0xfc000000) == 0x34000000
1700 && inst_saves_fr (next_inst) >= 4
1701 && inst_saves_fr (next_inst)
1702 <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1704 /* So we drop into the code below in a reasonable state. */
1705 reg_num = inst_saves_fr (next_inst);
1709 /* Ugh. Also account for argument stores into the stack.
1710 This is a kludge as on the HP compiler sets this bit and it
1711 never does prologue scheduling. So once we see one, skip past
1714 && reg_num <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1718 <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1721 status = target_read_memory (pc, buf, 4);
1722 inst = extract_unsigned_integer (buf, 4, byte_order);
1725 if ((inst & 0xfc000000) != 0x34000000)
1727 status = target_read_memory (pc + 4, buf, 4);
1728 next_inst = extract_unsigned_integer (buf, 4, byte_order);
1731 reg_num = inst_saves_fr (next_inst);
1737 /* Quit if we hit any kind of branch. This can happen if a prologue
1738 instruction is in the delay slot of the first call/branch. */
1739 if (is_branch (inst) && stop_before_branch)
1742 /* What a crock. The HP compilers set args_stored even if no
1743 arguments were stored into the stack (boo hiss). This could
1744 cause this code to then skip a bunch of user insns (up to the
1747 To combat this we try to identify when args_stored was bogusly
1748 set and clear it. We only do this when args_stored is nonzero,
1749 all other resources are accounted for, and nothing changed on
1752 && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1753 && old_save_gr == save_gr && old_save_fr == save_fr
1754 && old_save_rp == save_rp && old_save_sp == save_sp
1755 && old_stack_remaining == stack_remaining)
1761 /* !stop_before_branch, so also look at the insn in the delay slot
1763 if (final_iteration)
1765 if (is_branch (inst))
1766 final_iteration = 1;
1769 /* We've got a tenative location for the end of the prologue. However
1770 because of limitations in the unwind descriptor mechanism we may
1771 have went too far into user code looking for the save of a register
1772 that does not exist. So, if there registers we expected to be saved
1773 but never were, mask them out and restart.
1775 This should only happen in optimized code, and should be very rare. */
1776 if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1779 restart_gr = save_gr;
1780 restart_fr = save_fr;
1788 /* Return the address of the PC after the last prologue instruction if
1789 we can determine it from the debug symbols. Else return zero. */
1792 after_prologue (CORE_ADDR pc)
1794 struct symtab_and_line sal;
1795 CORE_ADDR func_addr, func_end;
1797 /* If we can not find the symbol in the partial symbol table, then
1798 there is no hope we can determine the function's start address
1800 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1803 /* Get the line associated with FUNC_ADDR. */
1804 sal = find_pc_line (func_addr, 0);
1806 /* There are only two cases to consider. First, the end of the source line
1807 is within the function bounds. In that case we return the end of the
1808 source line. Second is the end of the source line extends beyond the
1809 bounds of the current function. We need to use the slow code to
1810 examine instructions in that case.
1812 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1813 the wrong thing to do. In fact, it should be entirely possible for this
1814 function to always return zero since the slow instruction scanning code
1815 is supposed to *always* work. If it does not, then it is a bug. */
1816 if (sal.end < func_end)
1822 /* To skip prologues, I use this predicate. Returns either PC itself
1823 if the code at PC does not look like a function prologue; otherwise
1824 returns an address that (if we're lucky) follows the prologue.
1826 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1827 It doesn't necessarily skips all the insns in the prologue. In fact
1828 we might not want to skip all the insns because a prologue insn may
1829 appear in the delay slot of the first branch, and we don't want to
1830 skip over the branch in that case. */
1833 hppa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1835 CORE_ADDR post_prologue_pc;
1837 /* See if we can determine the end of the prologue via the symbol table.
1838 If so, then return either PC, or the PC after the prologue, whichever
1841 post_prologue_pc = after_prologue (pc);
1843 /* If after_prologue returned a useful address, then use it. Else
1844 fall back on the instruction skipping code.
1846 Some folks have claimed this causes problems because the breakpoint
1847 may be the first instruction of the prologue. If that happens, then
1848 the instruction skipping code has a bug that needs to be fixed. */
1849 if (post_prologue_pc != 0)
1850 return std::max (pc, post_prologue_pc);
1852 return (skip_prologue_hard_way (gdbarch, pc, 1));
1855 /* Return an unwind entry that falls within the frame's code block. */
1857 static struct unwind_table_entry *
1858 hppa_find_unwind_entry_in_block (struct frame_info *this_frame)
1860 CORE_ADDR pc = get_frame_address_in_block (this_frame);
1862 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1863 result of get_frame_address_in_block implies a problem.
1864 The bits should have been removed earlier, before the return
1865 value of gdbarch_unwind_pc. That might be happening already;
1866 if it isn't, it should be fixed. Then this call can be
1868 pc = gdbarch_addr_bits_remove (get_frame_arch (this_frame), pc);
1869 return find_unwind_entry (pc);
1872 struct hppa_frame_cache
1875 struct trad_frame_saved_reg *saved_regs;
1878 static struct hppa_frame_cache *
1879 hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
1881 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1882 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1883 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1884 struct hppa_frame_cache *cache;
1888 struct unwind_table_entry *u;
1889 CORE_ADDR prologue_end;
1894 fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
1895 frame_relative_level(this_frame));
1897 if ((*this_cache) != NULL)
1900 fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
1901 paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
1902 return (struct hppa_frame_cache *) (*this_cache);
1904 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1905 (*this_cache) = cache;
1906 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1909 u = hppa_find_unwind_entry_in_block (this_frame);
1913 fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
1914 return (struct hppa_frame_cache *) (*this_cache);
1917 /* Turn the Entry_GR field into a bitmask. */
1919 for (i = 3; i < u->Entry_GR + 3; i++)
1921 /* Frame pointer gets saved into a special location. */
1922 if (u->Save_SP && i == HPPA_FP_REGNUM)
1925 saved_gr_mask |= (1 << i);
1928 /* Turn the Entry_FR field into a bitmask too. */
1930 for (i = 12; i < u->Entry_FR + 12; i++)
1931 saved_fr_mask |= (1 << i);
1933 /* Loop until we find everything of interest or hit a branch.
1935 For unoptimized GCC code and for any HP CC code this will never ever
1936 examine any user instructions.
1938 For optimized GCC code we're faced with problems. GCC will schedule
1939 its prologue and make prologue instructions available for delay slot
1940 filling. The end result is user code gets mixed in with the prologue
1941 and a prologue instruction may be in the delay slot of the first branch
1944 Some unexpected things are expected with debugging optimized code, so
1945 we allow this routine to walk past user instructions in optimized
1948 int final_iteration = 0;
1949 CORE_ADDR pc, start_pc, end_pc;
1950 int looking_for_sp = u->Save_SP;
1951 int looking_for_rp = u->Save_RP;
1954 /* We have to use skip_prologue_hard_way instead of just
1955 skip_prologue_using_sal, in case we stepped into a function without
1956 symbol information. hppa_skip_prologue also bounds the returned
1957 pc by the passed in pc, so it will not return a pc in the next
1960 We used to call hppa_skip_prologue to find the end of the prologue,
1961 but if some non-prologue instructions get scheduled into the prologue,
1962 and the program is compiled with debug information, the "easy" way
1963 in hppa_skip_prologue will return a prologue end that is too early
1964 for us to notice any potential frame adjustments. */
1966 /* We used to use get_frame_func to locate the beginning of the
1967 function to pass to skip_prologue. However, when objects are
1968 compiled without debug symbols, get_frame_func can return the wrong
1969 function (or 0). We can do better than that by using unwind records.
1970 This only works if the Region_description of the unwind record
1971 indicates that it includes the entry point of the function.
1972 HP compilers sometimes generate unwind records for regions that
1973 do not include the entry or exit point of a function. GNU tools
1976 if ((u->Region_description & 0x2) == 0)
1977 start_pc = u->region_start;
1979 start_pc = get_frame_func (this_frame);
1981 prologue_end = skip_prologue_hard_way (gdbarch, start_pc, 0);
1982 end_pc = get_frame_pc (this_frame);
1984 if (prologue_end != 0 && end_pc > prologue_end)
1985 end_pc = prologue_end;
1990 ((saved_gr_mask || saved_fr_mask
1991 || looking_for_sp || looking_for_rp
1992 || frame_size < (u->Total_frame_size << 3))
2000 if (!safe_frame_unwind_memory (this_frame, pc, buf4, sizeof buf4))
2002 error (_("Cannot read instruction at %s."),
2003 paddress (gdbarch, pc));
2004 return (struct hppa_frame_cache *) (*this_cache);
2007 inst = extract_unsigned_integer (buf4, sizeof buf4, byte_order);
2009 /* Note the interesting effects of this instruction. */
2010 frame_size += prologue_inst_adjust_sp (inst);
2012 /* There are limited ways to store the return pointer into the
2014 if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2017 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2019 else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
2022 cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
2024 else if (inst == 0x0fc212c1
2025 || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2028 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2031 /* Check to see if we saved SP into the stack. This also
2032 happens to indicate the location of the saved frame
2034 if ((inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
2035 || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2038 cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
2040 else if (inst == 0x08030241) /* copy %r3, %r1 */
2045 /* Account for general and floating-point register saves. */
2046 reg = inst_saves_gr (inst);
2047 if (reg >= 3 && reg <= 18
2048 && (!u->Save_SP || reg != HPPA_FP_REGNUM))
2050 saved_gr_mask &= ~(1 << reg);
2051 if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
2052 /* stwm with a positive displacement is a _post_
2054 cache->saved_regs[reg].addr = 0;
2055 else if ((inst & 0xfc00000c) == 0x70000008)
2056 /* A std has explicit post_modify forms. */
2057 cache->saved_regs[reg].addr = 0;
2062 if ((inst >> 26) == 0x1c)
2063 offset = (inst & 0x1 ? -(1 << 13) : 0)
2064 | (((inst >> 4) & 0x3ff) << 3);
2065 else if ((inst >> 26) == 0x03)
2066 offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
2068 offset = hppa_extract_14 (inst);
2070 /* Handle code with and without frame pointers. */
2072 cache->saved_regs[reg].addr = offset;
2074 cache->saved_regs[reg].addr
2075 = (u->Total_frame_size << 3) + offset;
2079 /* GCC handles callee saved FP regs a little differently.
2081 It emits an instruction to put the value of the start of
2082 the FP store area into %r1. It then uses fstds,ma with a
2083 basereg of %r1 for the stores.
2085 HP CC emits them at the current stack pointer modifying the
2086 stack pointer as it stores each register. */
2088 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2089 if ((inst & 0xffffc000) == 0x34610000
2090 || (inst & 0xffffc000) == 0x37c10000)
2091 fp_loc = hppa_extract_14 (inst);
2093 reg = inst_saves_fr (inst);
2094 if (reg >= 12 && reg <= 21)
2096 /* Note +4 braindamage below is necessary because the FP
2097 status registers are internally 8 registers rather than
2098 the expected 4 registers. */
2099 saved_fr_mask &= ~(1 << reg);
2102 /* 1st HP CC FP register store. After this
2103 instruction we've set enough state that the GCC and
2104 HPCC code are both handled in the same manner. */
2105 cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
2110 cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
2115 /* Quit if we hit any kind of branch the previous iteration. */
2116 if (final_iteration)
2118 /* We want to look precisely one instruction beyond the branch
2119 if we have not found everything yet. */
2120 if (is_branch (inst))
2121 final_iteration = 1;
2126 /* The frame base always represents the value of %sp at entry to
2127 the current function (and is thus equivalent to the "saved"
2129 CORE_ADDR this_sp = get_frame_register_unsigned (this_frame,
2134 fprintf_unfiltered (gdb_stdlog, " (this_sp=%s, pc=%s, "
2135 "prologue_end=%s) ",
2136 paddress (gdbarch, this_sp),
2137 paddress (gdbarch, get_frame_pc (this_frame)),
2138 paddress (gdbarch, prologue_end));
2140 /* Check to see if a frame pointer is available, and use it for
2141 frame unwinding if it is.
2143 There are some situations where we need to rely on the frame
2144 pointer to do stack unwinding. For example, if a function calls
2145 alloca (), the stack pointer can get adjusted inside the body of
2146 the function. In this case, the ABI requires that the compiler
2147 maintain a frame pointer for the function.
2149 The unwind record has a flag (alloca_frame) that indicates that
2150 a function has a variable frame; unfortunately, gcc/binutils
2151 does not set this flag. Instead, whenever a frame pointer is used
2152 and saved on the stack, the Save_SP flag is set. We use this to
2153 decide whether to use the frame pointer for unwinding.
2155 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2156 instead of Save_SP. */
2158 fp = get_frame_register_unsigned (this_frame, HPPA_FP_REGNUM);
2160 if (u->alloca_frame)
2161 fp -= u->Total_frame_size << 3;
2163 if (get_frame_pc (this_frame) >= prologue_end
2164 && (u->Save_SP || u->alloca_frame) && fp != 0)
2169 fprintf_unfiltered (gdb_stdlog, " (base=%s) [frame pointer]",
2170 paddress (gdbarch, cache->base));
2173 && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
2175 /* Both we're expecting the SP to be saved and the SP has been
2176 saved. The entry SP value is saved at this frame's SP
2178 cache->base = read_memory_integer (this_sp, word_size, byte_order);
2181 fprintf_unfiltered (gdb_stdlog, " (base=%s) [saved]",
2182 paddress (gdbarch, cache->base));
2186 /* The prologue has been slowly allocating stack space. Adjust
2188 cache->base = this_sp - frame_size;
2190 fprintf_unfiltered (gdb_stdlog, " (base=%s) [unwind adjust]",
2191 paddress (gdbarch, cache->base));
2194 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2197 /* The PC is found in the "return register", "Millicode" uses "r31"
2198 as the return register while normal code uses "rp". */
2201 if (trad_frame_addr_p (cache->saved_regs, 31))
2203 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
2205 fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
2209 ULONGEST r31 = get_frame_register_unsigned (this_frame, 31);
2210 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
2212 fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
2217 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2219 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2220 cache->saved_regs[HPPA_RP_REGNUM];
2222 fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
2226 ULONGEST rp = get_frame_register_unsigned (this_frame,
2228 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2230 fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
2234 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2235 frame. However, there is a one-insn window where we haven't saved it
2236 yet, but we've already clobbered it. Detect this case and fix it up.
2238 The prologue sequence for frame-pointer functions is:
2239 0: stw %rp, -20(%sp)
2242 c: stw,ma %r1, XX(%sp)
2244 So if we are at offset c, the r3 value that we want is not yet saved
2245 on the stack, but it's been overwritten. The prologue analyzer will
2246 set fp_in_r1 when it sees the copy insn so we know to get the value
2248 if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
2251 ULONGEST r1 = get_frame_register_unsigned (this_frame, 1);
2252 trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
2256 /* Convert all the offsets into addresses. */
2258 for (reg = 0; reg < gdbarch_num_regs (gdbarch); reg++)
2260 if (trad_frame_addr_p (cache->saved_regs, reg))
2261 cache->saved_regs[reg].addr += cache->base;
2266 struct gdbarch_tdep *tdep;
2268 tdep = gdbarch_tdep (gdbarch);
2270 if (tdep->unwind_adjust_stub)
2271 tdep->unwind_adjust_stub (this_frame, cache->base, cache->saved_regs);
2275 fprintf_unfiltered (gdb_stdlog, "base=%s }",
2276 paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
2277 return (struct hppa_frame_cache *) (*this_cache);
2281 hppa_frame_this_id (struct frame_info *this_frame, void **this_cache,
2282 struct frame_id *this_id)
2284 struct hppa_frame_cache *info;
2285 struct unwind_table_entry *u;
2287 info = hppa_frame_cache (this_frame, this_cache);
2288 u = hppa_find_unwind_entry_in_block (this_frame);
2290 (*this_id) = frame_id_build (info->base, u->region_start);
2293 static struct value *
2294 hppa_frame_prev_register (struct frame_info *this_frame,
2295 void **this_cache, int regnum)
2297 struct hppa_frame_cache *info = hppa_frame_cache (this_frame, this_cache);
2299 return hppa_frame_prev_register_helper (this_frame,
2300 info->saved_regs, regnum);
2304 hppa_frame_unwind_sniffer (const struct frame_unwind *self,
2305 struct frame_info *this_frame, void **this_cache)
2307 if (hppa_find_unwind_entry_in_block (this_frame))
2313 static const struct frame_unwind hppa_frame_unwind =
2316 default_frame_unwind_stop_reason,
2318 hppa_frame_prev_register,
2320 hppa_frame_unwind_sniffer
2323 /* This is a generic fallback frame unwinder that kicks in if we fail all
2324 the other ones. Normally we would expect the stub and regular unwinder
2325 to work, but in some cases we might hit a function that just doesn't
2326 have any unwind information available. In this case we try to do
2327 unwinding solely based on code reading. This is obviously going to be
2328 slow, so only use this as a last resort. Currently this will only
2329 identify the stack and pc for the frame. */
2331 static struct hppa_frame_cache *
2332 hppa_fallback_frame_cache (struct frame_info *this_frame, void **this_cache)
2334 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2335 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2336 struct hppa_frame_cache *cache;
2337 unsigned int frame_size = 0;
2342 fprintf_unfiltered (gdb_stdlog,
2343 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2344 frame_relative_level (this_frame));
2346 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
2347 (*this_cache) = cache;
2348 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2350 start_pc = get_frame_func (this_frame);
2353 CORE_ADDR cur_pc = get_frame_pc (this_frame);
2356 for (pc = start_pc; pc < cur_pc; pc += 4)
2360 insn = read_memory_unsigned_integer (pc, 4, byte_order);
2361 frame_size += prologue_inst_adjust_sp (insn);
2363 /* There are limited ways to store the return pointer into the
2365 if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2367 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2370 else if (insn == 0x0fc212c1
2371 || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2373 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2380 fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
2381 frame_size, found_rp);
2383 cache->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2384 cache->base -= frame_size;
2385 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2387 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2389 cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
2390 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2391 cache->saved_regs[HPPA_RP_REGNUM];
2396 rp = get_frame_register_unsigned (this_frame, HPPA_RP_REGNUM);
2397 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2404 hppa_fallback_frame_this_id (struct frame_info *this_frame, void **this_cache,
2405 struct frame_id *this_id)
2407 struct hppa_frame_cache *info =
2408 hppa_fallback_frame_cache (this_frame, this_cache);
2410 (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
2413 static struct value *
2414 hppa_fallback_frame_prev_register (struct frame_info *this_frame,
2415 void **this_cache, int regnum)
2417 struct hppa_frame_cache *info
2418 = hppa_fallback_frame_cache (this_frame, this_cache);
2420 return hppa_frame_prev_register_helper (this_frame,
2421 info->saved_regs, regnum);
2424 static const struct frame_unwind hppa_fallback_frame_unwind =
2427 default_frame_unwind_stop_reason,
2428 hppa_fallback_frame_this_id,
2429 hppa_fallback_frame_prev_register,
2431 default_frame_sniffer
2434 /* Stub frames, used for all kinds of call stubs. */
2435 struct hppa_stub_unwind_cache
2438 struct trad_frame_saved_reg *saved_regs;
2441 static struct hppa_stub_unwind_cache *
2442 hppa_stub_frame_unwind_cache (struct frame_info *this_frame,
2445 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2446 struct hppa_stub_unwind_cache *info;
2447 struct unwind_table_entry *u;
2450 return (struct hppa_stub_unwind_cache *) *this_cache;
2452 info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
2454 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2456 info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2458 /* By default we assume that stubs do not change the rp. */
2459 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
2465 hppa_stub_frame_this_id (struct frame_info *this_frame,
2466 void **this_prologue_cache,
2467 struct frame_id *this_id)
2469 struct hppa_stub_unwind_cache *info
2470 = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2473 *this_id = frame_id_build (info->base, get_frame_func (this_frame));
2476 static struct value *
2477 hppa_stub_frame_prev_register (struct frame_info *this_frame,
2478 void **this_prologue_cache, int regnum)
2480 struct hppa_stub_unwind_cache *info
2481 = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2484 error (_("Requesting registers from null frame."));
2486 return hppa_frame_prev_register_helper (this_frame,
2487 info->saved_regs, regnum);
2491 hppa_stub_unwind_sniffer (const struct frame_unwind *self,
2492 struct frame_info *this_frame,
2495 CORE_ADDR pc = get_frame_address_in_block (this_frame);
2496 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2497 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2500 || (tdep->in_solib_call_trampoline != NULL
2501 && tdep->in_solib_call_trampoline (gdbarch, pc))
2502 || gdbarch_in_solib_return_trampoline (gdbarch, pc, NULL))
2507 static const struct frame_unwind hppa_stub_frame_unwind = {
2509 default_frame_unwind_stop_reason,
2510 hppa_stub_frame_this_id,
2511 hppa_stub_frame_prev_register,
2513 hppa_stub_unwind_sniffer
2516 static struct frame_id
2517 hppa_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2519 return frame_id_build (get_frame_register_unsigned (this_frame,
2521 get_frame_pc (this_frame));
2525 hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2530 ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
2531 pc = frame_unwind_register_unsigned (next_frame, HPPA_PCOQ_HEAD_REGNUM);
2533 /* If the current instruction is nullified, then we are effectively
2534 still executing the previous instruction. Pretend we are still
2535 there. This is needed when single stepping; if the nullified
2536 instruction is on a different line, we don't want GDB to think
2537 we've stepped onto that line. */
2538 if (ipsw & 0x00200000)
2544 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2545 Return NULL if no such symbol was found. */
2547 struct bound_minimal_symbol
2548 hppa_lookup_stub_minimal_symbol (const char *name,
2549 enum unwind_stub_types stub_type)
2551 struct objfile *objfile;
2552 struct minimal_symbol *msym;
2553 struct bound_minimal_symbol result = { NULL, NULL };
2555 ALL_MSYMBOLS (objfile, msym)
2557 if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
2559 struct unwind_table_entry *u;
2561 u = find_unwind_entry (MSYMBOL_VALUE (msym));
2562 if (u != NULL && u->stub_unwind.stub_type == stub_type)
2564 result.objfile = objfile;
2565 result.minsym = msym;
2575 unwind_command (char *exp, int from_tty)
2578 struct unwind_table_entry *u;
2580 /* If we have an expression, evaluate it and use it as the address. */
2582 if (exp != 0 && *exp != 0)
2583 address = parse_and_eval_address (exp);
2587 u = find_unwind_entry (address);
2591 printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2595 printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u));
2597 printf_unfiltered ("\tregion_start = %s\n", hex_string (u->region_start));
2598 gdb_flush (gdb_stdout);
2600 printf_unfiltered ("\tregion_end = %s\n", hex_string (u->region_end));
2601 gdb_flush (gdb_stdout);
2603 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2605 printf_unfiltered ("\n\tflags =");
2606 pif (Cannot_unwind);
2608 pif (Millicode_save_sr0);
2611 pif (Variable_Frame);
2612 pif (Separate_Package_Body);
2613 pif (Frame_Extension_Millicode);
2614 pif (Stack_Overflow_Check);
2615 pif (Two_Instruction_SP_Increment);
2618 pif (cxx_try_catch);
2619 pif (sched_entry_seq);
2622 pif (Save_MRP_in_frame);
2624 pif (Cleanup_defined);
2625 pif (MPE_XL_interrupt_marker);
2626 pif (HP_UX_interrupt_marker);
2630 putchar_unfiltered ('\n');
2632 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2634 pin (Region_description);
2637 pin (Total_frame_size);
2639 if (u->stub_unwind.stub_type)
2641 printf_unfiltered ("\tstub type = ");
2642 switch (u->stub_unwind.stub_type)
2645 printf_unfiltered ("long branch\n");
2647 case PARAMETER_RELOCATION:
2648 printf_unfiltered ("parameter relocation\n");
2651 printf_unfiltered ("export\n");
2654 printf_unfiltered ("import\n");
2657 printf_unfiltered ("import shlib\n");
2660 printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
2665 /* Return the GDB type object for the "standard" data type of data in
2668 static struct type *
2669 hppa32_register_type (struct gdbarch *gdbarch, int regnum)
2671 if (regnum < HPPA_FP4_REGNUM)
2672 return builtin_type (gdbarch)->builtin_uint32;
2674 return builtin_type (gdbarch)->builtin_float;
2677 static struct type *
2678 hppa64_register_type (struct gdbarch *gdbarch, int regnum)
2680 if (regnum < HPPA64_FP4_REGNUM)
2681 return builtin_type (gdbarch)->builtin_uint64;
2683 return builtin_type (gdbarch)->builtin_double;
2686 /* Return non-zero if REGNUM is not a register available to the user
2687 through ptrace/ttrace. */
2690 hppa32_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2693 || regnum == HPPA_PCSQ_HEAD_REGNUM
2694 || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2695 || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
2699 hppa32_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2701 /* cr26 and cr27 are readable (but not writable) from userspace. */
2702 if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2705 return hppa32_cannot_store_register (gdbarch, regnum);
2709 hppa64_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2712 || regnum == HPPA_PCSQ_HEAD_REGNUM
2713 || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2714 || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
2718 hppa64_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2720 /* cr26 and cr27 are readable (but not writable) from userspace. */
2721 if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2724 return hppa64_cannot_store_register (gdbarch, regnum);
2728 hppa_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2730 /* The low two bits of the PC on the PA contain the privilege level.
2731 Some genius implementing a (non-GCC) compiler apparently decided
2732 this means that "addresses" in a text section therefore include a
2733 privilege level, and thus symbol tables should contain these bits.
2734 This seems like a bonehead thing to do--anyway, it seems to work
2735 for our purposes to just ignore those bits. */
2737 return (addr &= ~0x3);
2740 /* Get the ARGIth function argument for the current function. */
2743 hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
2746 return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
2749 static enum register_status
2750 hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2751 int regnum, gdb_byte *buf)
2753 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2755 enum register_status status;
2757 status = regcache_raw_read_unsigned (regcache, regnum, &tmp);
2758 if (status == REG_VALID)
2760 if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
2762 store_unsigned_integer (buf, sizeof tmp, byte_order, tmp);
2768 hppa_find_global_pointer (struct gdbarch *gdbarch, struct value *function)
2774 hppa_frame_prev_register_helper (struct frame_info *this_frame,
2775 struct trad_frame_saved_reg saved_regs[],
2778 struct gdbarch *arch = get_frame_arch (this_frame);
2779 enum bfd_endian byte_order = gdbarch_byte_order (arch);
2781 if (regnum == HPPA_PCOQ_TAIL_REGNUM)
2783 int size = register_size (arch, HPPA_PCOQ_HEAD_REGNUM);
2785 struct value *pcoq_val =
2786 trad_frame_get_prev_register (this_frame, saved_regs,
2787 HPPA_PCOQ_HEAD_REGNUM);
2789 pc = extract_unsigned_integer (value_contents_all (pcoq_val),
2791 return frame_unwind_got_constant (this_frame, regnum, pc + 4);
2794 return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
2798 /* An instruction to match. */
2801 unsigned int data; /* See if it matches this.... */
2802 unsigned int mask; /* ... with this mask. */
2805 /* See bfd/elf32-hppa.c */
2806 static struct insn_pattern hppa_long_branch_stub[] = {
2807 /* ldil LR'xxx,%r1 */
2808 { 0x20200000, 0xffe00000 },
2809 /* be,n RR'xxx(%sr4,%r1) */
2810 { 0xe0202002, 0xffe02002 },
2814 static struct insn_pattern hppa_long_branch_pic_stub[] = {
2816 { 0xe8200000, 0xffe00000 },
2817 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2818 { 0x28200000, 0xffe00000 },
2819 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2820 { 0xe0202002, 0xffe02002 },
2824 static struct insn_pattern hppa_import_stub[] = {
2825 /* addil LR'xxx, %dp */
2826 { 0x2b600000, 0xffe00000 },
2827 /* ldw RR'xxx(%r1), %r21 */
2828 { 0x48350000, 0xffffb000 },
2830 { 0xeaa0c000, 0xffffffff },
2831 /* ldw RR'xxx+4(%r1), %r19 */
2832 { 0x48330000, 0xffffb000 },
2836 static struct insn_pattern hppa_import_pic_stub[] = {
2837 /* addil LR'xxx,%r19 */
2838 { 0x2a600000, 0xffe00000 },
2839 /* ldw RR'xxx(%r1),%r21 */
2840 { 0x48350000, 0xffffb000 },
2842 { 0xeaa0c000, 0xffffffff },
2843 /* ldw RR'xxx+4(%r1),%r19 */
2844 { 0x48330000, 0xffffb000 },
2848 static struct insn_pattern hppa_plt_stub[] = {
2849 /* b,l 1b, %r20 - 1b is 3 insns before here */
2850 { 0xea9f1fdd, 0xffffffff },
2851 /* depi 0,31,2,%r20 */
2852 { 0xd6801c1e, 0xffffffff },
2856 /* Maximum number of instructions on the patterns above. */
2857 #define HPPA_MAX_INSN_PATTERN_LEN 4
2859 /* Return non-zero if the instructions at PC match the series
2860 described in PATTERN, or zero otherwise. PATTERN is an array of
2861 'struct insn_pattern' objects, terminated by an entry whose mask is
2864 When the match is successful, fill INSN[i] with what PATTERN[i]
2868 hppa_match_insns (struct gdbarch *gdbarch, CORE_ADDR pc,
2869 struct insn_pattern *pattern, unsigned int *insn)
2871 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2875 for (i = 0; pattern[i].mask; i++)
2877 gdb_byte buf[HPPA_INSN_SIZE];
2879 target_read_memory (npc, buf, HPPA_INSN_SIZE);
2880 insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE, byte_order);
2881 if ((insn[i] & pattern[i].mask) == pattern[i].data)
2890 /* This relaxed version of the insstruction matcher allows us to match
2891 from somewhere inside the pattern, by looking backwards in the
2892 instruction scheme. */
2895 hppa_match_insns_relaxed (struct gdbarch *gdbarch, CORE_ADDR pc,
2896 struct insn_pattern *pattern, unsigned int *insn)
2898 int offset, len = 0;
2900 while (pattern[len].mask)
2903 for (offset = 0; offset < len; offset++)
2904 if (hppa_match_insns (gdbarch, pc - offset * HPPA_INSN_SIZE,
2912 hppa_in_dyncall (CORE_ADDR pc)
2914 struct unwind_table_entry *u;
2916 u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2920 return (pc >= u->region_start && pc <= u->region_end);
2924 hppa_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc)
2926 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2927 struct unwind_table_entry *u;
2929 if (in_plt_section (pc) || hppa_in_dyncall (pc))
2932 /* The GNU toolchain produces linker stubs without unwind
2933 information. Since the pattern matching for linker stubs can be
2934 quite slow, so bail out if we do have an unwind entry. */
2936 u = find_unwind_entry (pc);
2941 (hppa_match_insns_relaxed (gdbarch, pc, hppa_import_stub, insn)
2942 || hppa_match_insns_relaxed (gdbarch, pc, hppa_import_pic_stub, insn)
2943 || hppa_match_insns_relaxed (gdbarch, pc, hppa_long_branch_stub, insn)
2944 || hppa_match_insns_relaxed (gdbarch, pc,
2945 hppa_long_branch_pic_stub, insn));
2948 /* This code skips several kind of "trampolines" used on PA-RISC
2949 systems: $$dyncall, import stubs and PLT stubs. */
2952 hppa_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
2954 struct gdbarch *gdbarch = get_frame_arch (frame);
2955 struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
2957 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2960 /* $$dyncall handles both PLABELs and direct addresses. */
2961 if (hppa_in_dyncall (pc))
2963 pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22);
2965 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2967 pc = read_memory_typed_address (pc & ~0x3, func_ptr_type);
2972 dp_rel = hppa_match_insns (gdbarch, pc, hppa_import_stub, insn);
2973 if (dp_rel || hppa_match_insns (gdbarch, pc, hppa_import_pic_stub, insn))
2975 /* Extract the target address from the addil/ldw sequence. */
2976 pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
2979 pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
2981 pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
2986 if (in_plt_section (pc))
2988 pc = read_memory_typed_address (pc, func_ptr_type);
2990 /* If the PLT slot has not yet been resolved, the target will be
2992 if (in_plt_section (pc))
2994 /* Sanity check: are we pointing to the PLT stub? */
2995 if (!hppa_match_insns (gdbarch, pc, hppa_plt_stub, insn))
2997 warning (_("Cannot resolve PLT stub at %s."),
2998 paddress (gdbarch, pc));
3002 /* This should point to the fixup routine. */
3003 pc = read_memory_typed_address (pc + 8, func_ptr_type);
3011 /* Here is a table of C type sizes on hppa with various compiles
3012 and options. I measured this on PA 9000/800 with HP-UX 11.11
3013 and these compilers:
3015 /usr/ccs/bin/cc HP92453-01 A.11.01.21
3016 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
3017 /opt/aCC/bin/aCC B3910B A.03.45
3018 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3020 cc : 1 2 4 4 8 : 4 8 -- : 4 4
3021 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3022 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3023 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3024 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3025 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3026 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3027 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3031 compiler and options
3032 char, short, int, long, long long
3033 float, double, long double
3036 So all these compilers use either ILP32 or LP64 model.
3037 TODO: gcc has more options so it needs more investigation.
3039 For floating point types, see:
3041 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3042 HP-UX floating-point guide, hpux 11.00
3044 -- chastain 2003-12-18 */
3046 static struct gdbarch *
3047 hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3049 struct gdbarch_tdep *tdep;
3050 struct gdbarch *gdbarch;
3052 /* find a candidate among the list of pre-declared architectures. */
3053 arches = gdbarch_list_lookup_by_info (arches, &info);
3055 return (arches->gdbarch);
3057 /* If none found, then allocate and initialize one. */
3058 tdep = XCNEW (struct gdbarch_tdep);
3059 gdbarch = gdbarch_alloc (&info, tdep);
3061 /* Determine from the bfd_arch_info structure if we are dealing with
3062 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3063 then default to a 32bit machine. */
3064 if (info.bfd_arch_info != NULL)
3065 tdep->bytes_per_address =
3066 info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
3068 tdep->bytes_per_address = 4;
3070 tdep->find_global_pointer = hppa_find_global_pointer;
3072 /* Some parts of the gdbarch vector depend on whether we are running
3073 on a 32 bits or 64 bits target. */
3074 switch (tdep->bytes_per_address)
3077 set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
3078 set_gdbarch_register_name (gdbarch, hppa32_register_name);
3079 set_gdbarch_register_type (gdbarch, hppa32_register_type);
3080 set_gdbarch_cannot_store_register (gdbarch,
3081 hppa32_cannot_store_register);
3082 set_gdbarch_cannot_fetch_register (gdbarch,
3083 hppa32_cannot_fetch_register);
3086 set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
3087 set_gdbarch_register_name (gdbarch, hppa64_register_name);
3088 set_gdbarch_register_type (gdbarch, hppa64_register_type);
3089 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
3090 set_gdbarch_cannot_store_register (gdbarch,
3091 hppa64_cannot_store_register);
3092 set_gdbarch_cannot_fetch_register (gdbarch,
3093 hppa64_cannot_fetch_register);
3096 internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
3097 tdep->bytes_per_address);
3100 set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3101 set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3103 /* The following gdbarch vector elements are the same in both ILP32
3104 and LP64, but might show differences some day. */
3105 set_gdbarch_long_long_bit (gdbarch, 64);
3106 set_gdbarch_long_double_bit (gdbarch, 128);
3107 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3109 /* The following gdbarch vector elements do not depend on the address
3110 size, or in any other gdbarch element previously set. */
3111 set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
3112 set_gdbarch_stack_frame_destroyed_p (gdbarch,
3113 hppa_stack_frame_destroyed_p);
3114 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
3115 set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM);
3116 set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM);
3117 set_gdbarch_addr_bits_remove (gdbarch, hppa_addr_bits_remove);
3118 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3119 set_gdbarch_read_pc (gdbarch, hppa_read_pc);
3120 set_gdbarch_write_pc (gdbarch, hppa_write_pc);
3122 /* Helper for function argument information. */
3123 set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
3125 set_gdbarch_print_insn (gdbarch, print_insn_hppa);
3127 /* When a hardware watchpoint triggers, we'll move the inferior past
3128 it by removing all eventpoints; stepping past the instruction
3129 that caused the trigger; reinserting eventpoints; and checking
3130 whether any watched location changed. */
3131 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
3133 /* Inferior function call methods. */
3134 switch (tdep->bytes_per_address)
3137 set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
3138 set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
3139 set_gdbarch_convert_from_func_ptr_addr
3140 (gdbarch, hppa32_convert_from_func_ptr_addr);
3143 set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
3144 set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
3147 internal_error (__FILE__, __LINE__, _("bad switch"));
3150 /* Struct return methods. */
3151 switch (tdep->bytes_per_address)
3154 set_gdbarch_return_value (gdbarch, hppa32_return_value);
3157 set_gdbarch_return_value (gdbarch, hppa64_return_value);
3160 internal_error (__FILE__, __LINE__, _("bad switch"));
3163 set_gdbarch_breakpoint_kind_from_pc (gdbarch, hppa_breakpoint::kind_from_pc);
3164 set_gdbarch_sw_breakpoint_from_kind (gdbarch, hppa_breakpoint::bp_from_kind);
3165 set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
3167 /* Frame unwind methods. */
3168 set_gdbarch_dummy_id (gdbarch, hppa_dummy_id);
3169 set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
3171 /* Hook in ABI-specific overrides, if they have been registered. */
3172 gdbarch_init_osabi (info, gdbarch);
3174 /* Hook in the default unwinders. */
3175 frame_unwind_append_unwinder (gdbarch, &hppa_stub_frame_unwind);
3176 frame_unwind_append_unwinder (gdbarch, &hppa_frame_unwind);
3177 frame_unwind_append_unwinder (gdbarch, &hppa_fallback_frame_unwind);
3183 hppa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3185 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3187 fprintf_unfiltered (file, "bytes_per_address = %d\n",
3188 tdep->bytes_per_address);
3189 fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
3192 /* Provide a prototype to silence -Wmissing-prototypes. */
3193 extern initialize_file_ftype _initialize_hppa_tdep;
3196 _initialize_hppa_tdep (void)
3198 gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
3200 hppa_objfile_priv_data = register_objfile_data ();
3202 add_cmd ("unwind", class_maintenance, unwind_command,
3203 _("Print unwind table entry at given address."),
3204 &maintenanceprintlist);
3206 /* Debug this files internals. */
3207 add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
3208 Set whether hppa target specific debugging information should be displayed."),
3210 Show whether hppa target specific debugging information is displayed."), _("\
3211 This flag controls whether hppa target specific debugging information is\n\
3212 displayed. This information is particularly useful for debugging frame\n\
3213 unwinding problems."),
3215 NULL, /* FIXME: i18n: hppa debug flag is %s. */
3216 &setdebuglist, &showdebuglist);