1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
5 Free Software Foundation, Inc.
7 Contributed by the Center for Software Science at the
8 University of Utah (pa-gdb-bugs@cs.utah.edu).
10 This file is part of GDB.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>. */
29 #include "completer.h"
31 #include "gdb_assert.h"
32 #include "arch-utils.h"
33 /* For argument passing to the inferior */
36 #include "trad-frame.h"
37 #include "frame-unwind.h"
38 #include "frame-base.h"
44 #include "hppa-tdep.h"
46 static int hppa_debug = 0;
48 /* Some local constants. */
49 static const int hppa32_num_regs = 128;
50 static const int hppa64_num_regs = 96;
52 /* hppa-specific object data -- unwind and solib info.
53 TODO/maybe: think about splitting this into two parts; the unwind data is
54 common to all hppa targets, but is only used in this file; we can register
55 that separately and make this static. The solib data is probably hpux-
56 specific, so we can create a separate extern objfile_data that is registered
57 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
58 const struct objfile_data *hppa_objfile_priv_data = NULL;
60 /* Get at various relevent fields of an instruction word. */
63 #define MASK_14 0x3fff
64 #define MASK_21 0x1fffff
66 /* Sizes (in bytes) of the native unwind entries. */
67 #define UNWIND_ENTRY_SIZE 16
68 #define STUB_UNWIND_ENTRY_SIZE 8
70 /* Routines to extract various sized constants out of hppa
73 /* This assumes that no garbage lies outside of the lower bits of
77 hppa_sign_extend (unsigned val, unsigned bits)
79 return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
82 /* For many immediate values the sign bit is the low bit! */
85 hppa_low_hppa_sign_extend (unsigned val, unsigned bits)
87 return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
90 /* Extract the bits at positions between FROM and TO, using HP's numbering
94 hppa_get_field (unsigned word, int from, int to)
96 return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1));
99 /* extract the immediate field from a ld{bhw}s instruction */
102 hppa_extract_5_load (unsigned word)
104 return hppa_low_hppa_sign_extend (word >> 16 & MASK_5, 5);
107 /* extract the immediate field from a break instruction */
110 hppa_extract_5r_store (unsigned word)
112 return (word & MASK_5);
115 /* extract the immediate field from a {sr}sm instruction */
118 hppa_extract_5R_store (unsigned word)
120 return (word >> 16 & MASK_5);
123 /* extract a 14 bit immediate field */
126 hppa_extract_14 (unsigned word)
128 return hppa_low_hppa_sign_extend (word & MASK_14, 14);
131 /* extract a 21 bit constant */
134 hppa_extract_21 (unsigned word)
140 val = hppa_get_field (word, 20, 20);
142 val |= hppa_get_field (word, 9, 19);
144 val |= hppa_get_field (word, 5, 6);
146 val |= hppa_get_field (word, 0, 4);
148 val |= hppa_get_field (word, 7, 8);
149 return hppa_sign_extend (val, 21) << 11;
152 /* extract a 17 bit constant from branch instructions, returning the
153 19 bit signed value. */
156 hppa_extract_17 (unsigned word)
158 return hppa_sign_extend (hppa_get_field (word, 19, 28) |
159 hppa_get_field (word, 29, 29) << 10 |
160 hppa_get_field (word, 11, 15) << 11 |
161 (word & 0x1) << 16, 17) << 2;
165 hppa_symbol_address(const char *sym)
167 struct minimal_symbol *minsym;
169 minsym = lookup_minimal_symbol (sym, NULL, NULL);
171 return SYMBOL_VALUE_ADDRESS (minsym);
173 return (CORE_ADDR)-1;
176 struct hppa_objfile_private *
177 hppa_init_objfile_priv_data (struct objfile *objfile)
179 struct hppa_objfile_private *priv;
181 priv = (struct hppa_objfile_private *)
182 obstack_alloc (&objfile->objfile_obstack,
183 sizeof (struct hppa_objfile_private));
184 set_objfile_data (objfile, hppa_objfile_priv_data, priv);
185 memset (priv, 0, sizeof (*priv));
191 /* Compare the start address for two unwind entries returning 1 if
192 the first address is larger than the second, -1 if the second is
193 larger than the first, and zero if they are equal. */
196 compare_unwind_entries (const void *arg1, const void *arg2)
198 const struct unwind_table_entry *a = arg1;
199 const struct unwind_table_entry *b = arg2;
201 if (a->region_start > b->region_start)
203 else if (a->region_start < b->region_start)
210 record_text_segment_lowaddr (bfd *abfd, asection *section, void *data)
212 if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
213 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
215 bfd_vma value = section->vma - section->filepos;
216 CORE_ADDR *low_text_segment_address = (CORE_ADDR *)data;
218 if (value < *low_text_segment_address)
219 *low_text_segment_address = value;
224 internalize_unwinds (struct objfile *objfile, struct unwind_table_entry *table,
225 asection *section, unsigned int entries, unsigned int size,
226 CORE_ADDR text_offset)
228 /* We will read the unwind entries into temporary memory, then
229 fill in the actual unwind table. */
235 char *buf = alloca (size);
236 CORE_ADDR low_text_segment_address;
238 /* For ELF targets, then unwinds are supposed to
239 be segment relative offsets instead of absolute addresses.
241 Note that when loading a shared library (text_offset != 0) the
242 unwinds are already relative to the text_offset that will be
244 if (gdbarch_tdep (current_gdbarch)->is_elf && text_offset == 0)
246 low_text_segment_address = -1;
248 bfd_map_over_sections (objfile->obfd,
249 record_text_segment_lowaddr,
250 &low_text_segment_address);
252 text_offset = low_text_segment_address;
254 else if (gdbarch_tdep (current_gdbarch)->solib_get_text_base)
256 text_offset = gdbarch_tdep (current_gdbarch)->solib_get_text_base (objfile);
259 bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
261 /* Now internalize the information being careful to handle host/target
263 for (i = 0; i < entries; i++)
265 table[i].region_start = bfd_get_32 (objfile->obfd,
267 table[i].region_start += text_offset;
269 table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
270 table[i].region_end += text_offset;
272 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
274 table[i].Cannot_unwind = (tmp >> 31) & 0x1;
275 table[i].Millicode = (tmp >> 30) & 0x1;
276 table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
277 table[i].Region_description = (tmp >> 27) & 0x3;
278 table[i].reserved = (tmp >> 26) & 0x1;
279 table[i].Entry_SR = (tmp >> 25) & 0x1;
280 table[i].Entry_FR = (tmp >> 21) & 0xf;
281 table[i].Entry_GR = (tmp >> 16) & 0x1f;
282 table[i].Args_stored = (tmp >> 15) & 0x1;
283 table[i].Variable_Frame = (tmp >> 14) & 0x1;
284 table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
285 table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
286 table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
287 table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
288 table[i].sr4export = (tmp >> 9) & 0x1;
289 table[i].cxx_info = (tmp >> 8) & 0x1;
290 table[i].cxx_try_catch = (tmp >> 7) & 0x1;
291 table[i].sched_entry_seq = (tmp >> 6) & 0x1;
292 table[i].reserved1 = (tmp >> 5) & 0x1;
293 table[i].Save_SP = (tmp >> 4) & 0x1;
294 table[i].Save_RP = (tmp >> 3) & 0x1;
295 table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
296 table[i].save_r19 = (tmp >> 1) & 0x1;
297 table[i].Cleanup_defined = tmp & 0x1;
298 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
300 table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
301 table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
302 table[i].Large_frame = (tmp >> 29) & 0x1;
303 table[i].alloca_frame = (tmp >> 28) & 0x1;
304 table[i].reserved2 = (tmp >> 27) & 0x1;
305 table[i].Total_frame_size = tmp & 0x7ffffff;
307 /* Stub unwinds are handled elsewhere. */
308 table[i].stub_unwind.stub_type = 0;
309 table[i].stub_unwind.padding = 0;
314 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
315 the object file. This info is used mainly by find_unwind_entry() to find
316 out the stack frame size and frame pointer used by procedures. We put
317 everything on the psymbol obstack in the objfile so that it automatically
318 gets freed when the objfile is destroyed. */
321 read_unwind_info (struct objfile *objfile)
323 asection *unwind_sec, *stub_unwind_sec;
324 unsigned unwind_size, stub_unwind_size, total_size;
325 unsigned index, unwind_entries;
326 unsigned stub_entries, total_entries;
327 CORE_ADDR text_offset;
328 struct hppa_unwind_info *ui;
329 struct hppa_objfile_private *obj_private;
331 text_offset = ANOFFSET (objfile->section_offsets, 0);
332 ui = (struct hppa_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
333 sizeof (struct hppa_unwind_info));
339 /* For reasons unknown the HP PA64 tools generate multiple unwinder
340 sections in a single executable. So we just iterate over every
341 section in the BFD looking for unwinder sections intead of trying
342 to do a lookup with bfd_get_section_by_name.
344 First determine the total size of the unwind tables so that we
345 can allocate memory in a nice big hunk. */
347 for (unwind_sec = objfile->obfd->sections;
349 unwind_sec = unwind_sec->next)
351 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
352 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
354 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
355 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
357 total_entries += unwind_entries;
361 /* Now compute the size of the stub unwinds. Note the ELF tools do not
362 use stub unwinds at the current time. */
363 stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
367 stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
368 stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
372 stub_unwind_size = 0;
376 /* Compute total number of unwind entries and their total size. */
377 total_entries += stub_entries;
378 total_size = total_entries * sizeof (struct unwind_table_entry);
380 /* Allocate memory for the unwind table. */
381 ui->table = (struct unwind_table_entry *)
382 obstack_alloc (&objfile->objfile_obstack, total_size);
383 ui->last = total_entries - 1;
385 /* Now read in each unwind section and internalize the standard unwind
388 for (unwind_sec = objfile->obfd->sections;
390 unwind_sec = unwind_sec->next)
392 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
393 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
395 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
396 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
398 internalize_unwinds (objfile, &ui->table[index], unwind_sec,
399 unwind_entries, unwind_size, text_offset);
400 index += unwind_entries;
404 /* Now read in and internalize the stub unwind entries. */
405 if (stub_unwind_size > 0)
408 char *buf = alloca (stub_unwind_size);
410 /* Read in the stub unwind entries. */
411 bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
412 0, stub_unwind_size);
414 /* Now convert them into regular unwind entries. */
415 for (i = 0; i < stub_entries; i++, index++)
417 /* Clear out the next unwind entry. */
418 memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
420 /* Convert offset & size into region_start and region_end.
421 Stuff away the stub type into "reserved" fields. */
422 ui->table[index].region_start = bfd_get_32 (objfile->obfd,
424 ui->table[index].region_start += text_offset;
426 ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
429 ui->table[index].region_end
430 = ui->table[index].region_start + 4 *
431 (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
437 /* Unwind table needs to be kept sorted. */
438 qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
439 compare_unwind_entries);
441 /* Keep a pointer to the unwind information. */
442 obj_private = (struct hppa_objfile_private *)
443 objfile_data (objfile, hppa_objfile_priv_data);
444 if (obj_private == NULL)
445 obj_private = hppa_init_objfile_priv_data (objfile);
447 obj_private->unwind_info = ui;
450 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
451 of the objfiles seeking the unwind table entry for this PC. Each objfile
452 contains a sorted list of struct unwind_table_entry. Since we do a binary
453 search of the unwind tables, we depend upon them to be sorted. */
455 struct unwind_table_entry *
456 find_unwind_entry (CORE_ADDR pc)
458 int first, middle, last;
459 struct objfile *objfile;
460 struct hppa_objfile_private *priv;
463 fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry 0x%s -> ",
466 /* A function at address 0? Not in HP-UX! */
467 if (pc == (CORE_ADDR) 0)
470 fprintf_unfiltered (gdb_stdlog, "NULL }\n");
474 ALL_OBJFILES (objfile)
476 struct hppa_unwind_info *ui;
478 priv = objfile_data (objfile, hppa_objfile_priv_data);
480 ui = ((struct hppa_objfile_private *) priv)->unwind_info;
484 read_unwind_info (objfile);
485 priv = objfile_data (objfile, hppa_objfile_priv_data);
487 error (_("Internal error reading unwind information."));
488 ui = ((struct hppa_objfile_private *) priv)->unwind_info;
491 /* First, check the cache */
494 && pc >= ui->cache->region_start
495 && pc <= ui->cache->region_end)
498 fprintf_unfiltered (gdb_stdlog, "0x%s (cached) }\n",
499 paddr_nz ((uintptr_t) ui->cache));
503 /* Not in the cache, do a binary search */
508 while (first <= last)
510 middle = (first + last) / 2;
511 if (pc >= ui->table[middle].region_start
512 && pc <= ui->table[middle].region_end)
514 ui->cache = &ui->table[middle];
516 fprintf_unfiltered (gdb_stdlog, "0x%s }\n",
517 paddr_nz ((uintptr_t) ui->cache));
518 return &ui->table[middle];
521 if (pc < ui->table[middle].region_start)
526 } /* ALL_OBJFILES() */
529 fprintf_unfiltered (gdb_stdlog, "NULL (not found) }\n");
534 /* The epilogue is defined here as the area either on the `bv' instruction
535 itself or an instruction which destroys the function's stack frame.
537 We do not assume that the epilogue is at the end of a function as we can
538 also have return sequences in the middle of a function. */
540 hppa_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
542 unsigned long status;
547 status = target_read_memory (pc, buf, 4);
551 inst = extract_unsigned_integer (buf, 4);
553 /* The most common way to perform a stack adjustment ldo X(sp),sp
554 We are destroying a stack frame if the offset is negative. */
555 if ((inst & 0xffffc000) == 0x37de0000
556 && hppa_extract_14 (inst) < 0)
559 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
560 if (((inst & 0x0fc010e0) == 0x0fc010e0
561 || (inst & 0x0fc010e0) == 0x0fc010e0)
562 && hppa_extract_14 (inst) < 0)
565 /* bv %r0(%rp) or bv,n %r0(%rp) */
566 if (inst == 0xe840c000 || inst == 0xe840c002)
572 static const unsigned char *
573 hppa_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
575 static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
576 (*len) = sizeof (breakpoint);
580 /* Return the name of a register. */
583 hppa32_register_name (struct gdbarch *gdbarch, int i)
585 static char *names[] = {
586 "flags", "r1", "rp", "r3",
587 "r4", "r5", "r6", "r7",
588 "r8", "r9", "r10", "r11",
589 "r12", "r13", "r14", "r15",
590 "r16", "r17", "r18", "r19",
591 "r20", "r21", "r22", "r23",
592 "r24", "r25", "r26", "dp",
593 "ret0", "ret1", "sp", "r31",
594 "sar", "pcoqh", "pcsqh", "pcoqt",
595 "pcsqt", "eiem", "iir", "isr",
596 "ior", "ipsw", "goto", "sr4",
597 "sr0", "sr1", "sr2", "sr3",
598 "sr5", "sr6", "sr7", "cr0",
599 "cr8", "cr9", "ccr", "cr12",
600 "cr13", "cr24", "cr25", "cr26",
601 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
602 "fpsr", "fpe1", "fpe2", "fpe3",
603 "fpe4", "fpe5", "fpe6", "fpe7",
604 "fr4", "fr4R", "fr5", "fr5R",
605 "fr6", "fr6R", "fr7", "fr7R",
606 "fr8", "fr8R", "fr9", "fr9R",
607 "fr10", "fr10R", "fr11", "fr11R",
608 "fr12", "fr12R", "fr13", "fr13R",
609 "fr14", "fr14R", "fr15", "fr15R",
610 "fr16", "fr16R", "fr17", "fr17R",
611 "fr18", "fr18R", "fr19", "fr19R",
612 "fr20", "fr20R", "fr21", "fr21R",
613 "fr22", "fr22R", "fr23", "fr23R",
614 "fr24", "fr24R", "fr25", "fr25R",
615 "fr26", "fr26R", "fr27", "fr27R",
616 "fr28", "fr28R", "fr29", "fr29R",
617 "fr30", "fr30R", "fr31", "fr31R"
619 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
626 hppa64_register_name (struct gdbarch *gdbarch, int i)
628 static char *names[] = {
629 "flags", "r1", "rp", "r3",
630 "r4", "r5", "r6", "r7",
631 "r8", "r9", "r10", "r11",
632 "r12", "r13", "r14", "r15",
633 "r16", "r17", "r18", "r19",
634 "r20", "r21", "r22", "r23",
635 "r24", "r25", "r26", "dp",
636 "ret0", "ret1", "sp", "r31",
637 "sar", "pcoqh", "pcsqh", "pcoqt",
638 "pcsqt", "eiem", "iir", "isr",
639 "ior", "ipsw", "goto", "sr4",
640 "sr0", "sr1", "sr2", "sr3",
641 "sr5", "sr6", "sr7", "cr0",
642 "cr8", "cr9", "ccr", "cr12",
643 "cr13", "cr24", "cr25", "cr26",
644 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
645 "fpsr", "fpe1", "fpe2", "fpe3",
646 "fr4", "fr5", "fr6", "fr7",
647 "fr8", "fr9", "fr10", "fr11",
648 "fr12", "fr13", "fr14", "fr15",
649 "fr16", "fr17", "fr18", "fr19",
650 "fr20", "fr21", "fr22", "fr23",
651 "fr24", "fr25", "fr26", "fr27",
652 "fr28", "fr29", "fr30", "fr31"
654 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
661 hppa64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
663 /* r0-r31 and sar map one-to-one. */
667 /* fr4-fr31 are mapped from 72 in steps of 2. */
668 if (reg >= 72 || reg < 72 + 28 * 2)
669 return HPPA64_FP4_REGNUM + (reg - 72) / 2;
671 error ("Invalid DWARF register num %d.", reg);
675 /* This function pushes a stack frame with arguments as part of the
676 inferior function calling mechanism.
678 This is the version of the function for the 32-bit PA machines, in
679 which later arguments appear at lower addresses. (The stack always
680 grows towards higher addresses.)
682 We simply allocate the appropriate amount of stack space and put
683 arguments into their proper slots. */
686 hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
687 struct regcache *regcache, CORE_ADDR bp_addr,
688 int nargs, struct value **args, CORE_ADDR sp,
689 int struct_return, CORE_ADDR struct_addr)
691 /* Stack base address at which any pass-by-reference parameters are
693 CORE_ADDR struct_end = 0;
694 /* Stack base address at which the first parameter is stored. */
695 CORE_ADDR param_end = 0;
697 /* The inner most end of the stack after all the parameters have
699 CORE_ADDR new_sp = 0;
701 /* Two passes. First pass computes the location of everything,
702 second pass writes the bytes out. */
705 /* Global pointer (r19) of the function we are trying to call. */
708 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
710 for (write_pass = 0; write_pass < 2; write_pass++)
712 CORE_ADDR struct_ptr = 0;
713 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
714 struct_ptr is adjusted for each argument below, so the first
715 argument will end up at sp-36. */
716 CORE_ADDR param_ptr = 32;
718 int small_struct = 0;
720 for (i = 0; i < nargs; i++)
722 struct value *arg = args[i];
723 struct type *type = check_typedef (value_type (arg));
724 /* The corresponding parameter that is pushed onto the
725 stack, and [possibly] passed in a register. */
728 memset (param_val, 0, sizeof param_val);
729 if (TYPE_LENGTH (type) > 8)
731 /* Large parameter, pass by reference. Store the value
732 in "struct" area and then pass its address. */
734 struct_ptr += align_up (TYPE_LENGTH (type), 8);
736 write_memory (struct_end - struct_ptr, value_contents (arg),
738 store_unsigned_integer (param_val, 4, struct_end - struct_ptr);
740 else if (TYPE_CODE (type) == TYPE_CODE_INT
741 || TYPE_CODE (type) == TYPE_CODE_ENUM)
743 /* Integer value store, right aligned. "unpack_long"
744 takes care of any sign-extension problems. */
745 param_len = align_up (TYPE_LENGTH (type), 4);
746 store_unsigned_integer (param_val, param_len,
748 value_contents (arg)));
750 else if (TYPE_CODE (type) == TYPE_CODE_FLT)
752 /* Floating point value store, right aligned. */
753 param_len = align_up (TYPE_LENGTH (type), 4);
754 memcpy (param_val, value_contents (arg), param_len);
758 param_len = align_up (TYPE_LENGTH (type), 4);
760 /* Small struct value are stored right-aligned. */
761 memcpy (param_val + param_len - TYPE_LENGTH (type),
762 value_contents (arg), TYPE_LENGTH (type));
764 /* Structures of size 5, 6 and 7 bytes are special in that
765 the higher-ordered word is stored in the lower-ordered
766 argument, and even though it is a 8-byte quantity the
767 registers need not be 8-byte aligned. */
768 if (param_len > 4 && param_len < 8)
772 param_ptr += param_len;
773 if (param_len == 8 && !small_struct)
774 param_ptr = align_up (param_ptr, 8);
776 /* First 4 non-FP arguments are passed in gr26-gr23.
777 First 4 32-bit FP arguments are passed in fr4L-fr7L.
778 First 2 64-bit FP arguments are passed in fr5 and fr7.
780 The rest go on the stack, starting at sp-36, towards lower
781 addresses. 8-byte arguments must be aligned to a 8-byte
785 write_memory (param_end - param_ptr, param_val, param_len);
787 /* There are some cases when we don't know the type
788 expected by the callee (e.g. for variadic functions), so
789 pass the parameters in both general and fp regs. */
792 int grreg = 26 - (param_ptr - 36) / 4;
793 int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
794 int fpreg = 74 + (param_ptr - 32) / 8 * 4;
796 regcache_cooked_write (regcache, grreg, param_val);
797 regcache_cooked_write (regcache, fpLreg, param_val);
801 regcache_cooked_write (regcache, grreg + 1,
804 regcache_cooked_write (regcache, fpreg, param_val);
805 regcache_cooked_write (regcache, fpreg + 1,
812 /* Update the various stack pointers. */
815 struct_end = sp + align_up (struct_ptr, 64);
816 /* PARAM_PTR already accounts for all the arguments passed
817 by the user. However, the ABI mandates minimum stack
818 space allocations for outgoing arguments. The ABI also
819 mandates minimum stack alignments which we must
821 param_end = struct_end + align_up (param_ptr, 64);
825 /* If a structure has to be returned, set up register 28 to hold its
828 regcache_cooked_write_unsigned (regcache, 28, struct_addr);
830 gp = tdep->find_global_pointer (gdbarch, function);
833 regcache_cooked_write_unsigned (regcache, 19, gp);
835 /* Set the return address. */
836 if (!gdbarch_push_dummy_code_p (gdbarch))
837 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
839 /* Update the Stack Pointer. */
840 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end);
845 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
846 Runtime Architecture for PA-RISC 2.0", which is distributed as part
847 as of the HP-UX Software Transition Kit (STK). This implementation
848 is based on version 3.3, dated October 6, 1997. */
850 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
853 hppa64_integral_or_pointer_p (const struct type *type)
855 switch (TYPE_CODE (type))
861 case TYPE_CODE_RANGE:
863 int len = TYPE_LENGTH (type);
864 return (len == 1 || len == 2 || len == 4 || len == 8);
868 return (TYPE_LENGTH (type) == 8);
876 /* Check whether TYPE is a "Floating Scalar Type". */
879 hppa64_floating_p (const struct type *type)
881 switch (TYPE_CODE (type))
885 int len = TYPE_LENGTH (type);
886 return (len == 4 || len == 8 || len == 16);
895 /* If CODE points to a function entry address, try to look up the corresponding
896 function descriptor and return its address instead. If CODE is not a
897 function entry address, then just return it unchanged. */
899 hppa64_convert_code_addr_to_fptr (CORE_ADDR code)
901 struct obj_section *sec, *opd;
903 sec = find_pc_section (code);
908 /* If CODE is in a data section, assume it's already a fptr. */
909 if (!(sec->the_bfd_section->flags & SEC_CODE))
912 ALL_OBJFILE_OSECTIONS (sec->objfile, opd)
914 if (strcmp (opd->the_bfd_section->name, ".opd") == 0)
918 if (opd < sec->objfile->sections_end)
922 for (addr = obj_section_addr (opd);
923 addr < obj_section_endaddr (opd);
929 if (target_read_memory (addr, tmp, sizeof (tmp)))
931 opdaddr = extract_unsigned_integer (tmp, sizeof (tmp));
942 hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
943 struct regcache *regcache, CORE_ADDR bp_addr,
944 int nargs, struct value **args, CORE_ADDR sp,
945 int struct_return, CORE_ADDR struct_addr)
947 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
951 /* "The outgoing parameter area [...] must be aligned at a 16-byte
953 sp = align_up (sp, 16);
955 for (i = 0; i < nargs; i++)
957 struct value *arg = args[i];
958 struct type *type = value_type (arg);
959 int len = TYPE_LENGTH (type);
960 const bfd_byte *valbuf;
964 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
965 offset = align_up (offset, 8);
967 if (hppa64_integral_or_pointer_p (type))
969 /* "Integral scalar parameters smaller than 64 bits are
970 padded on the left (i.e., the value is in the
971 least-significant bits of the 64-bit storage unit, and
972 the high-order bits are undefined)." Therefore we can
973 safely sign-extend them. */
976 arg = value_cast (builtin_type_int64, arg);
980 else if (hppa64_floating_p (type))
984 /* "Quad-precision (128-bit) floating-point scalar
985 parameters are aligned on a 16-byte boundary." */
986 offset = align_up (offset, 16);
988 /* "Double-extended- and quad-precision floating-point
989 parameters within the first 64 bytes of the parameter
990 list are always passed in general registers." */
996 /* "Single-precision (32-bit) floating-point scalar
997 parameters are padded on the left with 32 bits of
998 garbage (i.e., the floating-point value is in the
999 least-significant 32 bits of a 64-bit storage
1004 /* "Single- and double-precision floating-point
1005 parameters in this area are passed according to the
1006 available formal parameter information in a function
1007 prototype. [...] If no prototype is in scope,
1008 floating-point parameters must be passed both in the
1009 corresponding general registers and in the
1010 corresponding floating-point registers." */
1011 regnum = HPPA64_FP4_REGNUM + offset / 8;
1013 if (regnum < HPPA64_FP4_REGNUM + 8)
1015 /* "Single-precision floating-point parameters, when
1016 passed in floating-point registers, are passed in
1017 the right halves of the floating point registers;
1018 the left halves are unused." */
1019 regcache_cooked_write_part (regcache, regnum, offset % 8,
1020 len, value_contents (arg));
1028 /* "Aggregates larger than 8 bytes are aligned on a
1029 16-byte boundary, possibly leaving an unused argument
1030 slot, which is filled with garbage. If necessary,
1031 they are padded on the right (with garbage), to a
1032 multiple of 8 bytes." */
1033 offset = align_up (offset, 16);
1037 /* If we are passing a function pointer, make sure we pass a function
1038 descriptor instead of the function entry address. */
1039 if (TYPE_CODE (type) == TYPE_CODE_PTR
1040 && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1042 ULONGEST codeptr, fptr;
1044 codeptr = unpack_long (type, value_contents (arg));
1045 fptr = hppa64_convert_code_addr_to_fptr (codeptr);
1046 store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), fptr);
1051 valbuf = value_contents (arg);
1054 /* Always store the argument in memory. */
1055 write_memory (sp + offset, valbuf, len);
1057 regnum = HPPA_ARG0_REGNUM - offset / 8;
1058 while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
1060 regcache_cooked_write_part (regcache, regnum,
1061 offset % 8, min (len, 8), valbuf);
1062 offset += min (len, 8);
1063 valbuf += min (len, 8);
1064 len -= min (len, 8);
1071 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1072 regcache_cooked_write_unsigned (regcache, HPPA_RET1_REGNUM, sp + 64);
1074 /* Allocate the outgoing parameter area. Make sure the outgoing
1075 parameter area is multiple of 16 bytes in length. */
1076 sp += max (align_up (offset, 16), 64);
1078 /* Allocate 32-bytes of scratch space. The documentation doesn't
1079 mention this, but it seems to be needed. */
1082 /* Allocate the frame marker area. */
1085 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1088 regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
1090 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1091 gp = tdep->find_global_pointer (gdbarch, function);
1093 regcache_cooked_write_unsigned (regcache, HPPA_DP_REGNUM, gp);
1095 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1096 if (!gdbarch_push_dummy_code_p (gdbarch))
1097 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
1099 /* Set up GR30 to hold the stack pointer (sp). */
1100 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, sp);
1106 /* Handle 32/64-bit struct return conventions. */
1108 static enum return_value_convention
1109 hppa32_return_value (struct gdbarch *gdbarch, struct type *func_type,
1110 struct type *type, struct regcache *regcache,
1111 gdb_byte *readbuf, const gdb_byte *writebuf)
1113 if (TYPE_LENGTH (type) <= 2 * 4)
1115 /* The value always lives in the right hand end of the register
1116 (or register pair)? */
1118 int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
1119 int part = TYPE_LENGTH (type) % 4;
1120 /* The left hand register contains only part of the value,
1121 transfer that first so that the rest can be xfered as entire
1122 4-byte registers. */
1125 if (readbuf != NULL)
1126 regcache_cooked_read_part (regcache, reg, 4 - part,
1128 if (writebuf != NULL)
1129 regcache_cooked_write_part (regcache, reg, 4 - part,
1133 /* Now transfer the remaining register values. */
1134 for (b = part; b < TYPE_LENGTH (type); b += 4)
1136 if (readbuf != NULL)
1137 regcache_cooked_read (regcache, reg, readbuf + b);
1138 if (writebuf != NULL)
1139 regcache_cooked_write (regcache, reg, writebuf + b);
1142 return RETURN_VALUE_REGISTER_CONVENTION;
1145 return RETURN_VALUE_STRUCT_CONVENTION;
1148 static enum return_value_convention
1149 hppa64_return_value (struct gdbarch *gdbarch, struct type *func_type,
1150 struct type *type, struct regcache *regcache,
1151 gdb_byte *readbuf, const gdb_byte *writebuf)
1153 int len = TYPE_LENGTH (type);
1158 /* All return values larget than 128 bits must be aggregate
1160 gdb_assert (!hppa64_integral_or_pointer_p (type));
1161 gdb_assert (!hppa64_floating_p (type));
1163 /* "Aggregate return values larger than 128 bits are returned in
1164 a buffer allocated by the caller. The address of the buffer
1165 must be passed in GR 28." */
1166 return RETURN_VALUE_STRUCT_CONVENTION;
1169 if (hppa64_integral_or_pointer_p (type))
1171 /* "Integral return values are returned in GR 28. Values
1172 smaller than 64 bits are padded on the left (with garbage)." */
1173 regnum = HPPA_RET0_REGNUM;
1176 else if (hppa64_floating_p (type))
1180 /* "Double-extended- and quad-precision floating-point
1181 values are returned in GRs 28 and 29. The sign,
1182 exponent, and most-significant bits of the mantissa are
1183 returned in GR 28; the least-significant bits of the
1184 mantissa are passed in GR 29. For double-extended
1185 precision values, GR 29 is padded on the right with 48
1186 bits of garbage." */
1187 regnum = HPPA_RET0_REGNUM;
1192 /* "Single-precision and double-precision floating-point
1193 return values are returned in FR 4R (single precision) or
1194 FR 4 (double-precision)." */
1195 regnum = HPPA64_FP4_REGNUM;
1201 /* "Aggregate return values up to 64 bits in size are returned
1202 in GR 28. Aggregates smaller than 64 bits are left aligned
1203 in the register; the pad bits on the right are undefined."
1205 "Aggregate return values between 65 and 128 bits are returned
1206 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1207 the remaining bits are placed, left aligned, in GR 29. The
1208 pad bits on the right of GR 29 (if any) are undefined." */
1209 regnum = HPPA_RET0_REGNUM;
1217 regcache_cooked_read_part (regcache, regnum, offset,
1218 min (len, 8), readbuf);
1219 readbuf += min (len, 8);
1220 len -= min (len, 8);
1229 regcache_cooked_write_part (regcache, regnum, offset,
1230 min (len, 8), writebuf);
1231 writebuf += min (len, 8);
1232 len -= min (len, 8);
1237 return RETURN_VALUE_REGISTER_CONVENTION;
1242 hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1243 struct target_ops *targ)
1247 CORE_ADDR plabel = addr & ~3;
1248 return read_memory_typed_address (plabel, builtin_type_void_func_ptr);
1255 hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1257 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1259 return align_up (addr, 64);
1262 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1265 hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1267 /* Just always 16-byte align. */
1268 return align_up (addr, 16);
1272 hppa_read_pc (struct regcache *regcache)
1277 regcache_cooked_read_unsigned (regcache, HPPA_IPSW_REGNUM, &ipsw);
1278 regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, &pc);
1280 /* If the current instruction is nullified, then we are effectively
1281 still executing the previous instruction. Pretend we are still
1282 there. This is needed when single stepping; if the nullified
1283 instruction is on a different line, we don't want GDB to think
1284 we've stepped onto that line. */
1285 if (ipsw & 0x00200000)
1292 hppa_write_pc (struct regcache *regcache, CORE_ADDR pc)
1294 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pc);
1295 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pc + 4);
1298 /* return the alignment of a type in bytes. Structures have the maximum
1299 alignment required by their fields. */
1302 hppa_alignof (struct type *type)
1304 int max_align, align, i;
1305 CHECK_TYPEDEF (type);
1306 switch (TYPE_CODE (type))
1311 return TYPE_LENGTH (type);
1312 case TYPE_CODE_ARRAY:
1313 return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
1314 case TYPE_CODE_STRUCT:
1315 case TYPE_CODE_UNION:
1317 for (i = 0; i < TYPE_NFIELDS (type); i++)
1319 /* Bit fields have no real alignment. */
1320 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1321 if (!TYPE_FIELD_BITSIZE (type, i)) /* elz: this should be bitsize */
1323 align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
1324 max_align = max (max_align, align);
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 it INST does not save a GR. */
1411 inst_saves_gr (unsigned long inst)
1413 /* Does it look like a stw? */
1414 if ((inst >> 26) == 0x1a || (inst >> 26) == 0x1b
1415 || (inst >> 26) == 0x1f
1416 || ((inst >> 26) == 0x1f
1417 && ((inst >> 6) == 0xa)))
1418 return hppa_extract_5R_store (inst);
1420 /* Does it look like a std? */
1421 if ((inst >> 26) == 0x1c
1422 || ((inst >> 26) == 0x03
1423 && ((inst >> 6) & 0xf) == 0xb))
1424 return hppa_extract_5R_store (inst);
1426 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1427 if ((inst >> 26) == 0x1b)
1428 return hppa_extract_5R_store (inst);
1430 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1432 if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18
1433 || ((inst >> 26) == 0x3
1434 && (((inst >> 6) & 0xf) == 0x8
1435 || (inst >> 6) & 0xf) == 0x9))
1436 return hppa_extract_5R_store (inst);
1441 /* Return the register number for a FR which is saved by INST or
1442 zero it INST does not save a FR.
1444 Note we only care about full 64bit register stores (that's the only
1445 kind of stores the prologue will use).
1447 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1450 inst_saves_fr (unsigned long inst)
1452 /* is this an FSTD ? */
1453 if ((inst & 0xfc00dfc0) == 0x2c001200)
1454 return hppa_extract_5r_store (inst);
1455 if ((inst & 0xfc000002) == 0x70000002)
1456 return hppa_extract_5R_store (inst);
1457 /* is this an FSTW ? */
1458 if ((inst & 0xfc00df80) == 0x24001200)
1459 return hppa_extract_5r_store (inst);
1460 if ((inst & 0xfc000002) == 0x7c000000)
1461 return hppa_extract_5R_store (inst);
1465 /* Advance PC across any function entry prologue instructions
1466 to reach some "real" code.
1468 Use information in the unwind table to determine what exactly should
1469 be in the prologue. */
1473 skip_prologue_hard_way (struct gdbarch *gdbarch, CORE_ADDR pc,
1474 int stop_before_branch)
1477 CORE_ADDR orig_pc = pc;
1478 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1479 unsigned long args_stored, status, i, restart_gr, restart_fr;
1480 struct unwind_table_entry *u;
1481 int final_iteration;
1487 u = find_unwind_entry (pc);
1491 /* If we are not at the beginning of a function, then return now. */
1492 if ((pc & ~0x3) != u->region_start)
1495 /* This is how much of a frame adjustment we need to account for. */
1496 stack_remaining = u->Total_frame_size << 3;
1498 /* Magic register saves we want to know about. */
1499 save_rp = u->Save_RP;
1500 save_sp = u->Save_SP;
1502 /* An indication that args may be stored into the stack. Unfortunately
1503 the HPUX compilers tend to set this in cases where no args were
1507 /* Turn the Entry_GR field into a bitmask. */
1509 for (i = 3; i < u->Entry_GR + 3; i++)
1511 /* Frame pointer gets saved into a special location. */
1512 if (u->Save_SP && i == HPPA_FP_REGNUM)
1515 save_gr |= (1 << i);
1517 save_gr &= ~restart_gr;
1519 /* Turn the Entry_FR field into a bitmask too. */
1521 for (i = 12; i < u->Entry_FR + 12; i++)
1522 save_fr |= (1 << i);
1523 save_fr &= ~restart_fr;
1525 final_iteration = 0;
1527 /* Loop until we find everything of interest or hit a branch.
1529 For unoptimized GCC code and for any HP CC code this will never ever
1530 examine any user instructions.
1532 For optimzied GCC code we're faced with problems. GCC will schedule
1533 its prologue and make prologue instructions available for delay slot
1534 filling. The end result is user code gets mixed in with the prologue
1535 and a prologue instruction may be in the delay slot of the first branch
1538 Some unexpected things are expected with debugging optimized code, so
1539 we allow this routine to walk past user instructions in optimized
1541 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1544 unsigned int reg_num;
1545 unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1546 unsigned long old_save_rp, old_save_sp, next_inst;
1548 /* Save copies of all the triggers so we can compare them later
1550 old_save_gr = save_gr;
1551 old_save_fr = save_fr;
1552 old_save_rp = save_rp;
1553 old_save_sp = save_sp;
1554 old_stack_remaining = stack_remaining;
1556 status = target_read_memory (pc, buf, 4);
1557 inst = extract_unsigned_integer (buf, 4);
1563 /* Note the interesting effects of this instruction. */
1564 stack_remaining -= prologue_inst_adjust_sp (inst);
1566 /* There are limited ways to store the return pointer into the
1568 if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1571 /* These are the only ways we save SP into the stack. At this time
1572 the HP compilers never bother to save SP into the stack. */
1573 if ((inst & 0xffffc000) == 0x6fc10000
1574 || (inst & 0xffffc00c) == 0x73c10008)
1577 /* Are we loading some register with an offset from the argument
1579 if ((inst & 0xffe00000) == 0x37a00000
1580 || (inst & 0xffffffe0) == 0x081d0240)
1586 /* Account for general and floating-point register saves. */
1587 reg_num = inst_saves_gr (inst);
1588 save_gr &= ~(1 << reg_num);
1590 /* Ugh. Also account for argument stores into the stack.
1591 Unfortunately args_stored only tells us that some arguments
1592 where stored into the stack. Not how many or what kind!
1594 This is a kludge as on the HP compiler sets this bit and it
1595 never does prologue scheduling. So once we see one, skip past
1596 all of them. We have similar code for the fp arg stores below.
1598 FIXME. Can still die if we have a mix of GR and FR argument
1600 if (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1603 while (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1607 status = target_read_memory (pc, buf, 4);
1608 inst = extract_unsigned_integer (buf, 4);
1611 reg_num = inst_saves_gr (inst);
1617 reg_num = inst_saves_fr (inst);
1618 save_fr &= ~(1 << reg_num);
1620 status = target_read_memory (pc + 4, buf, 4);
1621 next_inst = extract_unsigned_integer (buf, 4);
1627 /* We've got to be read to handle the ldo before the fp register
1629 if ((inst & 0xfc000000) == 0x34000000
1630 && inst_saves_fr (next_inst) >= 4
1631 && inst_saves_fr (next_inst)
1632 <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1634 /* So we drop into the code below in a reasonable state. */
1635 reg_num = inst_saves_fr (next_inst);
1639 /* Ugh. Also account for argument stores into the stack.
1640 This is a kludge as on the HP compiler sets this bit and it
1641 never does prologue scheduling. So once we see one, skip past
1644 && reg_num <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1648 <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1651 status = target_read_memory (pc, buf, 4);
1652 inst = extract_unsigned_integer (buf, 4);
1655 if ((inst & 0xfc000000) != 0x34000000)
1657 status = target_read_memory (pc + 4, buf, 4);
1658 next_inst = extract_unsigned_integer (buf, 4);
1661 reg_num = inst_saves_fr (next_inst);
1667 /* Quit if we hit any kind of branch. This can happen if a prologue
1668 instruction is in the delay slot of the first call/branch. */
1669 if (is_branch (inst) && stop_before_branch)
1672 /* What a crock. The HP compilers set args_stored even if no
1673 arguments were stored into the stack (boo hiss). This could
1674 cause this code to then skip a bunch of user insns (up to the
1677 To combat this we try to identify when args_stored was bogusly
1678 set and clear it. We only do this when args_stored is nonzero,
1679 all other resources are accounted for, and nothing changed on
1682 && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1683 && old_save_gr == save_gr && old_save_fr == save_fr
1684 && old_save_rp == save_rp && old_save_sp == save_sp
1685 && old_stack_remaining == stack_remaining)
1691 /* !stop_before_branch, so also look at the insn in the delay slot
1693 if (final_iteration)
1695 if (is_branch (inst))
1696 final_iteration = 1;
1699 /* We've got a tenative location for the end of the prologue. However
1700 because of limitations in the unwind descriptor mechanism we may
1701 have went too far into user code looking for the save of a register
1702 that does not exist. So, if there registers we expected to be saved
1703 but never were, mask them out and restart.
1705 This should only happen in optimized code, and should be very rare. */
1706 if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1709 restart_gr = save_gr;
1710 restart_fr = save_fr;
1718 /* Return the address of the PC after the last prologue instruction if
1719 we can determine it from the debug symbols. Else return zero. */
1722 after_prologue (CORE_ADDR pc)
1724 struct symtab_and_line sal;
1725 CORE_ADDR func_addr, func_end;
1728 /* If we can not find the symbol in the partial symbol table, then
1729 there is no hope we can determine the function's start address
1731 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1734 /* Get the line associated with FUNC_ADDR. */
1735 sal = find_pc_line (func_addr, 0);
1737 /* There are only two cases to consider. First, the end of the source line
1738 is within the function bounds. In that case we return the end of the
1739 source line. Second is the end of the source line extends beyond the
1740 bounds of the current function. We need to use the slow code to
1741 examine instructions in that case.
1743 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1744 the wrong thing to do. In fact, it should be entirely possible for this
1745 function to always return zero since the slow instruction scanning code
1746 is supposed to *always* work. If it does not, then it is a bug. */
1747 if (sal.end < func_end)
1753 /* To skip prologues, I use this predicate. Returns either PC itself
1754 if the code at PC does not look like a function prologue; otherwise
1755 returns an address that (if we're lucky) follows the prologue.
1757 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1758 It doesn't necessarily skips all the insns in the prologue. In fact
1759 we might not want to skip all the insns because a prologue insn may
1760 appear in the delay slot of the first branch, and we don't want to
1761 skip over the branch in that case. */
1764 hppa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1768 CORE_ADDR post_prologue_pc;
1771 /* See if we can determine the end of the prologue via the symbol table.
1772 If so, then return either PC, or the PC after the prologue, whichever
1775 post_prologue_pc = after_prologue (pc);
1777 /* If after_prologue returned a useful address, then use it. Else
1778 fall back on the instruction skipping code.
1780 Some folks have claimed this causes problems because the breakpoint
1781 may be the first instruction of the prologue. If that happens, then
1782 the instruction skipping code has a bug that needs to be fixed. */
1783 if (post_prologue_pc != 0)
1784 return max (pc, post_prologue_pc);
1786 return (skip_prologue_hard_way (gdbarch, pc, 1));
1789 /* Return an unwind entry that falls within the frame's code block. */
1791 static struct unwind_table_entry *
1792 hppa_find_unwind_entry_in_block (struct frame_info *this_frame)
1794 CORE_ADDR pc = get_frame_address_in_block (this_frame);
1796 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1797 result of get_frame_address_in_block implies a problem.
1798 The bits should have been removed earlier, before the return
1799 value of frame_pc_unwind. That might be happening already;
1800 if it isn't, it should be fixed. Then this call can be
1802 pc = gdbarch_addr_bits_remove (get_frame_arch (this_frame), pc);
1803 return find_unwind_entry (pc);
1806 struct hppa_frame_cache
1809 struct trad_frame_saved_reg *saved_regs;
1812 static struct hppa_frame_cache *
1813 hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
1815 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1816 struct hppa_frame_cache *cache;
1821 struct unwind_table_entry *u;
1822 CORE_ADDR prologue_end;
1827 fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
1828 frame_relative_level(this_frame));
1830 if ((*this_cache) != NULL)
1833 fprintf_unfiltered (gdb_stdlog, "base=0x%s (cached) }",
1834 paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
1835 return (*this_cache);
1837 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1838 (*this_cache) = cache;
1839 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1842 u = hppa_find_unwind_entry_in_block (this_frame);
1846 fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
1847 return (*this_cache);
1850 /* Turn the Entry_GR field into a bitmask. */
1852 for (i = 3; i < u->Entry_GR + 3; i++)
1854 /* Frame pointer gets saved into a special location. */
1855 if (u->Save_SP && i == HPPA_FP_REGNUM)
1858 saved_gr_mask |= (1 << i);
1861 /* Turn the Entry_FR field into a bitmask too. */
1863 for (i = 12; i < u->Entry_FR + 12; i++)
1864 saved_fr_mask |= (1 << i);
1866 /* Loop until we find everything of interest or hit a branch.
1868 For unoptimized GCC code and for any HP CC code this will never ever
1869 examine any user instructions.
1871 For optimized GCC code we're faced with problems. GCC will schedule
1872 its prologue and make prologue instructions available for delay slot
1873 filling. The end result is user code gets mixed in with the prologue
1874 and a prologue instruction may be in the delay slot of the first branch
1877 Some unexpected things are expected with debugging optimized code, so
1878 we allow this routine to walk past user instructions in optimized
1881 int final_iteration = 0;
1882 CORE_ADDR pc, start_pc, end_pc;
1883 int looking_for_sp = u->Save_SP;
1884 int looking_for_rp = u->Save_RP;
1887 /* We have to use skip_prologue_hard_way instead of just
1888 skip_prologue_using_sal, in case we stepped into a function without
1889 symbol information. hppa_skip_prologue also bounds the returned
1890 pc by the passed in pc, so it will not return a pc in the next
1893 We used to call hppa_skip_prologue to find the end of the prologue,
1894 but if some non-prologue instructions get scheduled into the prologue,
1895 and the program is compiled with debug information, the "easy" way
1896 in hppa_skip_prologue will return a prologue end that is too early
1897 for us to notice any potential frame adjustments. */
1899 /* We used to use get_frame_func to locate the beginning of the
1900 function to pass to skip_prologue. However, when objects are
1901 compiled without debug symbols, get_frame_func can return the wrong
1902 function (or 0). We can do better than that by using unwind records.
1903 This only works if the Region_description of the unwind record
1904 indicates that it includes the entry point of the function.
1905 HP compilers sometimes generate unwind records for regions that
1906 do not include the entry or exit point of a function. GNU tools
1909 if ((u->Region_description & 0x2) == 0)
1910 start_pc = u->region_start;
1912 start_pc = get_frame_func (this_frame);
1914 prologue_end = skip_prologue_hard_way (gdbarch, start_pc, 0);
1915 end_pc = get_frame_pc (this_frame);
1917 if (prologue_end != 0 && end_pc > prologue_end)
1918 end_pc = prologue_end;
1923 ((saved_gr_mask || saved_fr_mask
1924 || looking_for_sp || looking_for_rp
1925 || frame_size < (u->Total_frame_size << 3))
1933 if (!safe_frame_unwind_memory (this_frame, pc, buf4, sizeof buf4))
1935 error (_("Cannot read instruction at 0x%s."), paddr_nz (pc));
1936 return (*this_cache);
1939 inst = extract_unsigned_integer (buf4, sizeof buf4);
1941 /* Note the interesting effects of this instruction. */
1942 frame_size += prologue_inst_adjust_sp (inst);
1944 /* There are limited ways to store the return pointer into the
1946 if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1949 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
1951 else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1954 cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
1956 else if (inst == 0x0fc212c1
1957 || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1960 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
1963 /* Check to see if we saved SP into the stack. This also
1964 happens to indicate the location of the saved frame
1966 if ((inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1967 || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1970 cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
1972 else if (inst == 0x08030241) /* copy %r3, %r1 */
1977 /* Account for general and floating-point register saves. */
1978 reg = inst_saves_gr (inst);
1979 if (reg >= 3 && reg <= 18
1980 && (!u->Save_SP || reg != HPPA_FP_REGNUM))
1982 saved_gr_mask &= ~(1 << reg);
1983 if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
1984 /* stwm with a positive displacement is a _post_
1986 cache->saved_regs[reg].addr = 0;
1987 else if ((inst & 0xfc00000c) == 0x70000008)
1988 /* A std has explicit post_modify forms. */
1989 cache->saved_regs[reg].addr = 0;
1994 if ((inst >> 26) == 0x1c)
1995 offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
1996 else if ((inst >> 26) == 0x03)
1997 offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
1999 offset = hppa_extract_14 (inst);
2001 /* Handle code with and without frame pointers. */
2003 cache->saved_regs[reg].addr = offset;
2005 cache->saved_regs[reg].addr = (u->Total_frame_size << 3) + offset;
2009 /* GCC handles callee saved FP regs a little differently.
2011 It emits an instruction to put the value of the start of
2012 the FP store area into %r1. It then uses fstds,ma with a
2013 basereg of %r1 for the stores.
2015 HP CC emits them at the current stack pointer modifying the
2016 stack pointer as it stores each register. */
2018 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2019 if ((inst & 0xffffc000) == 0x34610000
2020 || (inst & 0xffffc000) == 0x37c10000)
2021 fp_loc = hppa_extract_14 (inst);
2023 reg = inst_saves_fr (inst);
2024 if (reg >= 12 && reg <= 21)
2026 /* Note +4 braindamage below is necessary because the FP
2027 status registers are internally 8 registers rather than
2028 the expected 4 registers. */
2029 saved_fr_mask &= ~(1 << reg);
2032 /* 1st HP CC FP register store. After this
2033 instruction we've set enough state that the GCC and
2034 HPCC code are both handled in the same manner. */
2035 cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
2040 cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
2045 /* Quit if we hit any kind of branch the previous iteration. */
2046 if (final_iteration)
2048 /* We want to look precisely one instruction beyond the branch
2049 if we have not found everything yet. */
2050 if (is_branch (inst))
2051 final_iteration = 1;
2056 /* The frame base always represents the value of %sp at entry to
2057 the current function (and is thus equivalent to the "saved"
2059 CORE_ADDR this_sp = get_frame_register_unsigned (this_frame,
2064 fprintf_unfiltered (gdb_stdlog, " (this_sp=0x%s, pc=0x%s, "
2065 "prologue_end=0x%s) ",
2067 paddr_nz (get_frame_pc (this_frame)),
2068 paddr_nz (prologue_end));
2070 /* Check to see if a frame pointer is available, and use it for
2071 frame unwinding if it is.
2073 There are some situations where we need to rely on the frame
2074 pointer to do stack unwinding. For example, if a function calls
2075 alloca (), the stack pointer can get adjusted inside the body of
2076 the function. In this case, the ABI requires that the compiler
2077 maintain a frame pointer for the function.
2079 The unwind record has a flag (alloca_frame) that indicates that
2080 a function has a variable frame; unfortunately, gcc/binutils
2081 does not set this flag. Instead, whenever a frame pointer is used
2082 and saved on the stack, the Save_SP flag is set. We use this to
2083 decide whether to use the frame pointer for unwinding.
2085 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2086 instead of Save_SP. */
2088 fp = get_frame_register_unsigned (this_frame, HPPA_FP_REGNUM);
2090 if (u->alloca_frame)
2091 fp -= u->Total_frame_size << 3;
2093 if (get_frame_pc (this_frame) >= prologue_end
2094 && (u->Save_SP || u->alloca_frame) && fp != 0)
2099 fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [frame pointer]",
2100 paddr_nz (cache->base));
2103 && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
2105 /* Both we're expecting the SP to be saved and the SP has been
2106 saved. The entry SP value is saved at this frame's SP
2108 cache->base = read_memory_integer
2109 (this_sp, gdbarch_ptr_bit (gdbarch) / 8);
2112 fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [saved]",
2113 paddr_nz (cache->base));
2117 /* The prologue has been slowly allocating stack space. Adjust
2119 cache->base = this_sp - frame_size;
2121 fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [unwind adjust]",
2122 paddr_nz (cache->base));
2125 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2128 /* The PC is found in the "return register", "Millicode" uses "r31"
2129 as the return register while normal code uses "rp". */
2132 if (trad_frame_addr_p (cache->saved_regs, 31))
2134 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
2136 fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
2140 ULONGEST r31 = get_frame_register_unsigned (this_frame, 31);
2141 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
2143 fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
2148 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2150 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2151 cache->saved_regs[HPPA_RP_REGNUM];
2153 fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
2157 ULONGEST rp = get_frame_register_unsigned (this_frame,
2159 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2161 fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
2165 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2166 frame. However, there is a one-insn window where we haven't saved it
2167 yet, but we've already clobbered it. Detect this case and fix it up.
2169 The prologue sequence for frame-pointer functions is:
2170 0: stw %rp, -20(%sp)
2173 c: stw,ma %r1, XX(%sp)
2175 So if we are at offset c, the r3 value that we want is not yet saved
2176 on the stack, but it's been overwritten. The prologue analyzer will
2177 set fp_in_r1 when it sees the copy insn so we know to get the value
2179 if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
2182 ULONGEST r1 = get_frame_register_unsigned (this_frame, 1);
2183 trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
2187 /* Convert all the offsets into addresses. */
2189 for (reg = 0; reg < gdbarch_num_regs (gdbarch); reg++)
2191 if (trad_frame_addr_p (cache->saved_regs, reg))
2192 cache->saved_regs[reg].addr += cache->base;
2197 struct gdbarch_tdep *tdep;
2199 tdep = gdbarch_tdep (gdbarch);
2201 if (tdep->unwind_adjust_stub)
2202 tdep->unwind_adjust_stub (this_frame, cache->base, cache->saved_regs);
2206 fprintf_unfiltered (gdb_stdlog, "base=0x%s }",
2207 paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
2208 return (*this_cache);
2212 hppa_frame_this_id (struct frame_info *this_frame, void **this_cache,
2213 struct frame_id *this_id)
2215 struct hppa_frame_cache *info;
2216 CORE_ADDR pc = get_frame_pc (this_frame);
2217 struct unwind_table_entry *u;
2219 info = hppa_frame_cache (this_frame, this_cache);
2220 u = hppa_find_unwind_entry_in_block (this_frame);
2222 (*this_id) = frame_id_build (info->base, u->region_start);
2225 static struct value *
2226 hppa_frame_prev_register (struct frame_info *this_frame,
2227 void **this_cache, int regnum)
2229 struct hppa_frame_cache *info = hppa_frame_cache (this_frame, this_cache);
2231 return hppa_frame_prev_register_helper (this_frame, info->saved_regs, regnum);
2235 hppa_frame_unwind_sniffer (const struct frame_unwind *self,
2236 struct frame_info *this_frame, void **this_cache)
2238 if (hppa_find_unwind_entry_in_block (this_frame))
2244 static const struct frame_unwind hppa_frame_unwind =
2248 hppa_frame_prev_register,
2250 hppa_frame_unwind_sniffer
2253 /* This is a generic fallback frame unwinder that kicks in if we fail all
2254 the other ones. Normally we would expect the stub and regular unwinder
2255 to work, but in some cases we might hit a function that just doesn't
2256 have any unwind information available. In this case we try to do
2257 unwinding solely based on code reading. This is obviously going to be
2258 slow, so only use this as a last resort. Currently this will only
2259 identify the stack and pc for the frame. */
2261 static struct hppa_frame_cache *
2262 hppa_fallback_frame_cache (struct frame_info *this_frame, void **this_cache)
2264 struct hppa_frame_cache *cache;
2265 unsigned int frame_size = 0;
2270 fprintf_unfiltered (gdb_stdlog,
2271 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2272 frame_relative_level (this_frame));
2274 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
2275 (*this_cache) = cache;
2276 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2278 start_pc = get_frame_func (this_frame);
2281 CORE_ADDR cur_pc = get_frame_pc (this_frame);
2284 for (pc = start_pc; pc < cur_pc; pc += 4)
2288 insn = read_memory_unsigned_integer (pc, 4);
2289 frame_size += prologue_inst_adjust_sp (insn);
2291 /* There are limited ways to store the return pointer into the
2293 if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2295 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2298 else if (insn == 0x0fc212c1
2299 || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2301 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2308 fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
2309 frame_size, found_rp);
2311 cache->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2312 cache->base -= frame_size;
2313 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2315 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2317 cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
2318 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2319 cache->saved_regs[HPPA_RP_REGNUM];
2324 rp = get_frame_register_unsigned (this_frame, HPPA_RP_REGNUM);
2325 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2332 hppa_fallback_frame_this_id (struct frame_info *this_frame, void **this_cache,
2333 struct frame_id *this_id)
2335 struct hppa_frame_cache *info =
2336 hppa_fallback_frame_cache (this_frame, this_cache);
2338 (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
2341 static struct value *
2342 hppa_fallback_frame_prev_register (struct frame_info *this_frame,
2343 void **this_cache, int regnum)
2345 struct hppa_frame_cache *info =
2346 hppa_fallback_frame_cache (this_frame, this_cache);
2348 return hppa_frame_prev_register_helper (this_frame, info->saved_regs, regnum);
2351 static const struct frame_unwind hppa_fallback_frame_unwind =
2354 hppa_fallback_frame_this_id,
2355 hppa_fallback_frame_prev_register,
2357 default_frame_sniffer
2360 /* Stub frames, used for all kinds of call stubs. */
2361 struct hppa_stub_unwind_cache
2364 struct trad_frame_saved_reg *saved_regs;
2367 static struct hppa_stub_unwind_cache *
2368 hppa_stub_frame_unwind_cache (struct frame_info *this_frame,
2371 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2372 struct hppa_stub_unwind_cache *info;
2373 struct unwind_table_entry *u;
2378 info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
2380 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2382 info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2384 if (gdbarch_osabi (gdbarch) == GDB_OSABI_HPUX_SOM)
2386 /* HPUX uses export stubs in function calls; the export stub clobbers
2387 the return value of the caller, and, later restores it from the
2389 u = find_unwind_entry (get_frame_pc (this_frame));
2391 if (u && u->stub_unwind.stub_type == EXPORT)
2393 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = info->base - 24;
2399 /* By default we assume that stubs do not change the rp. */
2400 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
2406 hppa_stub_frame_this_id (struct frame_info *this_frame,
2407 void **this_prologue_cache,
2408 struct frame_id *this_id)
2410 struct hppa_stub_unwind_cache *info
2411 = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2414 *this_id = frame_id_build (info->base, get_frame_func (this_frame));
2416 *this_id = null_frame_id;
2419 static struct value *
2420 hppa_stub_frame_prev_register (struct frame_info *this_frame,
2421 void **this_prologue_cache, int regnum)
2423 struct hppa_stub_unwind_cache *info
2424 = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2427 error (_("Requesting registers from null frame."));
2429 return hppa_frame_prev_register_helper (this_frame, info->saved_regs, regnum);
2433 hppa_stub_unwind_sniffer (const struct frame_unwind *self,
2434 struct frame_info *this_frame,
2437 CORE_ADDR pc = get_frame_address_in_block (this_frame);
2438 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2439 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2442 || (tdep->in_solib_call_trampoline != NULL
2443 && tdep->in_solib_call_trampoline (pc, NULL))
2444 || gdbarch_in_solib_return_trampoline (gdbarch, pc, NULL))
2449 static const struct frame_unwind hppa_stub_frame_unwind = {
2451 hppa_stub_frame_this_id,
2452 hppa_stub_frame_prev_register,
2454 hppa_stub_unwind_sniffer
2457 static struct frame_id
2458 hppa_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2460 return frame_id_build (get_frame_register_unsigned (this_frame,
2462 get_frame_pc (this_frame));
2466 hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2471 ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
2472 pc = frame_unwind_register_unsigned (next_frame, HPPA_PCOQ_HEAD_REGNUM);
2474 /* If the current instruction is nullified, then we are effectively
2475 still executing the previous instruction. Pretend we are still
2476 there. This is needed when single stepping; if the nullified
2477 instruction is on a different line, we don't want GDB to think
2478 we've stepped onto that line. */
2479 if (ipsw & 0x00200000)
2485 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2486 Return NULL if no such symbol was found. */
2488 struct minimal_symbol *
2489 hppa_lookup_stub_minimal_symbol (const char *name,
2490 enum unwind_stub_types stub_type)
2492 struct objfile *objfile;
2493 struct minimal_symbol *msym;
2495 ALL_MSYMBOLS (objfile, msym)
2497 if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
2499 struct unwind_table_entry *u;
2501 u = find_unwind_entry (SYMBOL_VALUE (msym));
2502 if (u != NULL && u->stub_unwind.stub_type == stub_type)
2511 unwind_command (char *exp, int from_tty)
2514 struct unwind_table_entry *u;
2516 /* If we have an expression, evaluate it and use it as the address. */
2518 if (exp != 0 && *exp != 0)
2519 address = parse_and_eval_address (exp);
2523 u = find_unwind_entry (address);
2527 printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2531 printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u);
2533 printf_unfiltered ("\tregion_start = ");
2534 print_address (u->region_start, gdb_stdout);
2535 gdb_flush (gdb_stdout);
2537 printf_unfiltered ("\n\tregion_end = ");
2538 print_address (u->region_end, gdb_stdout);
2539 gdb_flush (gdb_stdout);
2541 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2543 printf_unfiltered ("\n\tflags =");
2544 pif (Cannot_unwind);
2546 pif (Millicode_save_sr0);
2549 pif (Variable_Frame);
2550 pif (Separate_Package_Body);
2551 pif (Frame_Extension_Millicode);
2552 pif (Stack_Overflow_Check);
2553 pif (Two_Instruction_SP_Increment);
2556 pif (cxx_try_catch);
2557 pif (sched_entry_seq);
2560 pif (Save_MRP_in_frame);
2562 pif (Cleanup_defined);
2563 pif (MPE_XL_interrupt_marker);
2564 pif (HP_UX_interrupt_marker);
2568 putchar_unfiltered ('\n');
2570 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2572 pin (Region_description);
2575 pin (Total_frame_size);
2577 if (u->stub_unwind.stub_type)
2579 printf_unfiltered ("\tstub type = ");
2580 switch (u->stub_unwind.stub_type)
2583 printf_unfiltered ("long branch\n");
2585 case PARAMETER_RELOCATION:
2586 printf_unfiltered ("parameter relocation\n");
2589 printf_unfiltered ("export\n");
2592 printf_unfiltered ("import\n");
2595 printf_unfiltered ("import shlib\n");
2598 printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
2603 /* Return the GDB type object for the "standard" data type of data in
2606 static struct type *
2607 hppa32_register_type (struct gdbarch *gdbarch, int regnum)
2609 if (regnum < HPPA_FP4_REGNUM)
2610 return builtin_type_uint32;
2612 return builtin_type_ieee_single;
2615 static struct type *
2616 hppa64_register_type (struct gdbarch *gdbarch, int regnum)
2618 if (regnum < HPPA64_FP4_REGNUM)
2619 return builtin_type_uint64;
2621 return builtin_type_ieee_double;
2624 /* Return non-zero if REGNUM is not a register available to the user
2625 through ptrace/ttrace. */
2628 hppa32_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2631 || regnum == HPPA_PCSQ_HEAD_REGNUM
2632 || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2633 || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
2637 hppa32_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2639 /* cr26 and cr27 are readable (but not writable) from userspace. */
2640 if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2643 return hppa32_cannot_store_register (gdbarch, regnum);
2647 hppa64_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2650 || regnum == HPPA_PCSQ_HEAD_REGNUM
2651 || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2652 || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
2656 hppa64_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2658 /* cr26 and cr27 are readable (but not writable) from userspace. */
2659 if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2662 return hppa64_cannot_store_register (gdbarch, regnum);
2666 hppa_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
2668 /* The low two bits of the PC on the PA contain the privilege level.
2669 Some genius implementing a (non-GCC) compiler apparently decided
2670 this means that "addresses" in a text section therefore include a
2671 privilege level, and thus symbol tables should contain these bits.
2672 This seems like a bonehead thing to do--anyway, it seems to work
2673 for our purposes to just ignore those bits. */
2675 return (addr &= ~0x3);
2678 /* Get the ARGIth function argument for the current function. */
2681 hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
2684 return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
2688 hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2689 int regnum, gdb_byte *buf)
2693 regcache_raw_read_unsigned (regcache, regnum, &tmp);
2694 if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
2696 store_unsigned_integer (buf, sizeof tmp, tmp);
2700 hppa_find_global_pointer (struct gdbarch *gdbarch, struct value *function)
2706 hppa_frame_prev_register_helper (struct frame_info *this_frame,
2707 struct trad_frame_saved_reg saved_regs[],
2710 struct gdbarch *arch = get_frame_arch (this_frame);
2712 if (regnum == HPPA_PCOQ_TAIL_REGNUM)
2714 int size = register_size (arch, HPPA_PCOQ_HEAD_REGNUM);
2716 struct value *pcoq_val =
2717 trad_frame_get_prev_register (this_frame, saved_regs,
2718 HPPA_PCOQ_HEAD_REGNUM);
2720 pc = extract_unsigned_integer (value_contents_all (pcoq_val), size);
2721 return frame_unwind_got_constant (this_frame, regnum, pc + 4);
2724 /* Make sure the "flags" register is zero in all unwound frames.
2725 The "flags" registers is a HP-UX specific wart, and only the code
2726 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2727 with it here. This shouldn't affect other systems since those
2728 should provide zero for the "flags" register anyway. */
2729 if (regnum == HPPA_FLAGS_REGNUM)
2730 return frame_unwind_got_constant (this_frame, regnum, 0);
2732 return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
2736 /* An instruction to match. */
2739 unsigned int data; /* See if it matches this.... */
2740 unsigned int mask; /* ... with this mask. */
2743 /* See bfd/elf32-hppa.c */
2744 static struct insn_pattern hppa_long_branch_stub[] = {
2745 /* ldil LR'xxx,%r1 */
2746 { 0x20200000, 0xffe00000 },
2747 /* be,n RR'xxx(%sr4,%r1) */
2748 { 0xe0202002, 0xffe02002 },
2752 static struct insn_pattern hppa_long_branch_pic_stub[] = {
2754 { 0xe8200000, 0xffe00000 },
2755 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2756 { 0x28200000, 0xffe00000 },
2757 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2758 { 0xe0202002, 0xffe02002 },
2762 static struct insn_pattern hppa_import_stub[] = {
2763 /* addil LR'xxx, %dp */
2764 { 0x2b600000, 0xffe00000 },
2765 /* ldw RR'xxx(%r1), %r21 */
2766 { 0x48350000, 0xffffb000 },
2768 { 0xeaa0c000, 0xffffffff },
2769 /* ldw RR'xxx+4(%r1), %r19 */
2770 { 0x48330000, 0xffffb000 },
2774 static struct insn_pattern hppa_import_pic_stub[] = {
2775 /* addil LR'xxx,%r19 */
2776 { 0x2a600000, 0xffe00000 },
2777 /* ldw RR'xxx(%r1),%r21 */
2778 { 0x48350000, 0xffffb000 },
2780 { 0xeaa0c000, 0xffffffff },
2781 /* ldw RR'xxx+4(%r1),%r19 */
2782 { 0x48330000, 0xffffb000 },
2786 static struct insn_pattern hppa_plt_stub[] = {
2787 /* b,l 1b, %r20 - 1b is 3 insns before here */
2788 { 0xea9f1fdd, 0xffffffff },
2789 /* depi 0,31,2,%r20 */
2790 { 0xd6801c1e, 0xffffffff },
2794 static struct insn_pattern hppa_sigtramp[] = {
2795 /* ldi 0, %r25 or ldi 1, %r25 */
2796 { 0x34190000, 0xfffffffd },
2797 /* ldi __NR_rt_sigreturn, %r20 */
2798 { 0x3414015a, 0xffffffff },
2799 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
2800 { 0xe4008200, 0xffffffff },
2802 { 0x08000240, 0xffffffff },
2806 /* Maximum number of instructions on the patterns above. */
2807 #define HPPA_MAX_INSN_PATTERN_LEN 4
2809 /* Return non-zero if the instructions at PC match the series
2810 described in PATTERN, or zero otherwise. PATTERN is an array of
2811 'struct insn_pattern' objects, terminated by an entry whose mask is
2814 When the match is successful, fill INSN[i] with what PATTERN[i]
2818 hppa_match_insns (CORE_ADDR pc, struct insn_pattern *pattern,
2824 for (i = 0; pattern[i].mask; i++)
2826 gdb_byte buf[HPPA_INSN_SIZE];
2828 target_read_memory (npc, buf, HPPA_INSN_SIZE);
2829 insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE);
2830 if ((insn[i] & pattern[i].mask) == pattern[i].data)
2839 /* This relaxed version of the insstruction matcher allows us to match
2840 from somewhere inside the pattern, by looking backwards in the
2841 instruction scheme. */
2844 hppa_match_insns_relaxed (CORE_ADDR pc, struct insn_pattern *pattern,
2847 int offset, len = 0;
2849 while (pattern[len].mask)
2852 for (offset = 0; offset < len; offset++)
2853 if (hppa_match_insns (pc - offset * HPPA_INSN_SIZE, pattern, insn))
2860 hppa_in_dyncall (CORE_ADDR pc)
2862 struct unwind_table_entry *u;
2864 u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2868 return (pc >= u->region_start && pc <= u->region_end);
2872 hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name)
2874 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2875 struct unwind_table_entry *u;
2877 if (in_plt_section (pc, name) || hppa_in_dyncall (pc))
2880 /* The GNU toolchain produces linker stubs without unwind
2881 information. Since the pattern matching for linker stubs can be
2882 quite slow, so bail out if we do have an unwind entry. */
2884 u = find_unwind_entry (pc);
2888 return (hppa_match_insns_relaxed (pc, hppa_import_stub, insn)
2889 || hppa_match_insns_relaxed (pc, hppa_import_pic_stub, insn)
2890 || hppa_match_insns_relaxed (pc, hppa_long_branch_stub, insn)
2891 || hppa_match_insns_relaxed (pc, hppa_long_branch_pic_stub, insn));
2894 /* This code skips several kind of "trampolines" used on PA-RISC
2895 systems: $$dyncall, import stubs and PLT stubs. */
2898 hppa_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
2900 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2903 /* $$dyncall handles both PLABELs and direct addresses. */
2904 if (hppa_in_dyncall (pc))
2906 pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22);
2908 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2910 pc = read_memory_typed_address (pc & ~0x3, builtin_type_void_func_ptr);
2915 dp_rel = hppa_match_insns (pc, hppa_import_stub, insn);
2916 if (dp_rel || hppa_match_insns (pc, hppa_import_pic_stub, insn))
2918 /* Extract the target address from the addil/ldw sequence. */
2919 pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
2922 pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM);
2924 pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
2929 if (in_plt_section (pc, NULL))
2931 pc = read_memory_typed_address (pc, builtin_type_void_func_ptr);
2933 /* If the PLT slot has not yet been resolved, the target will be
2935 if (in_plt_section (pc, NULL))
2937 /* Sanity check: are we pointing to the PLT stub? */
2938 if (!hppa_match_insns (pc, hppa_plt_stub, insn))
2940 warning (_("Cannot resolve PLT stub at 0x%s."), paddr_nz (pc));
2944 /* This should point to the fixup routine. */
2945 pc = read_memory_typed_address (pc + 8, builtin_type_void_func_ptr);
2953 /* Here is a table of C type sizes on hppa with various compiles
2954 and options. I measured this on PA 9000/800 with HP-UX 11.11
2955 and these compilers:
2957 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2958 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2959 /opt/aCC/bin/aCC B3910B A.03.45
2960 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2962 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2963 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2964 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2965 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2966 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2967 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2968 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2969 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2973 compiler and options
2974 char, short, int, long, long long
2975 float, double, long double
2978 So all these compilers use either ILP32 or LP64 model.
2979 TODO: gcc has more options so it needs more investigation.
2981 For floating point types, see:
2983 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2984 HP-UX floating-point guide, hpux 11.00
2986 -- chastain 2003-12-18 */
2988 static struct gdbarch *
2989 hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2991 struct gdbarch_tdep *tdep;
2992 struct gdbarch *gdbarch;
2994 /* Try to determine the ABI of the object we are loading. */
2995 if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
2997 /* If it's a SOM file, assume it's HP/UX SOM. */
2998 if (bfd_get_flavour (info.abfd) == bfd_target_som_flavour)
2999 info.osabi = GDB_OSABI_HPUX_SOM;
3002 /* find a candidate among the list of pre-declared architectures. */
3003 arches = gdbarch_list_lookup_by_info (arches, &info);
3005 return (arches->gdbarch);
3007 /* If none found, then allocate and initialize one. */
3008 tdep = XZALLOC (struct gdbarch_tdep);
3009 gdbarch = gdbarch_alloc (&info, tdep);
3011 /* Determine from the bfd_arch_info structure if we are dealing with
3012 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3013 then default to a 32bit machine. */
3014 if (info.bfd_arch_info != NULL)
3015 tdep->bytes_per_address =
3016 info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
3018 tdep->bytes_per_address = 4;
3020 tdep->find_global_pointer = hppa_find_global_pointer;
3022 /* Some parts of the gdbarch vector depend on whether we are running
3023 on a 32 bits or 64 bits target. */
3024 switch (tdep->bytes_per_address)
3027 set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
3028 set_gdbarch_register_name (gdbarch, hppa32_register_name);
3029 set_gdbarch_register_type (gdbarch, hppa32_register_type);
3030 set_gdbarch_cannot_store_register (gdbarch,
3031 hppa32_cannot_store_register);
3032 set_gdbarch_cannot_fetch_register (gdbarch,
3033 hppa32_cannot_fetch_register);
3036 set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
3037 set_gdbarch_register_name (gdbarch, hppa64_register_name);
3038 set_gdbarch_register_type (gdbarch, hppa64_register_type);
3039 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa64_dwarf_reg_to_regnum);
3040 set_gdbarch_cannot_store_register (gdbarch,
3041 hppa64_cannot_store_register);
3042 set_gdbarch_cannot_fetch_register (gdbarch,
3043 hppa64_cannot_fetch_register);
3046 internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
3047 tdep->bytes_per_address);
3050 set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3051 set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
3053 /* The following gdbarch vector elements are the same in both ILP32
3054 and LP64, but might show differences some day. */
3055 set_gdbarch_long_long_bit (gdbarch, 64);
3056 set_gdbarch_long_double_bit (gdbarch, 128);
3057 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3059 /* The following gdbarch vector elements do not depend on the address
3060 size, or in any other gdbarch element previously set. */
3061 set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
3062 set_gdbarch_in_function_epilogue_p (gdbarch,
3063 hppa_in_function_epilogue_p);
3064 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
3065 set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM);
3066 set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM);
3067 set_gdbarch_addr_bits_remove (gdbarch, hppa_smash_text_address);
3068 set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
3069 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3070 set_gdbarch_read_pc (gdbarch, hppa_read_pc);
3071 set_gdbarch_write_pc (gdbarch, hppa_write_pc);
3073 /* Helper for function argument information. */
3074 set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
3076 set_gdbarch_print_insn (gdbarch, print_insn_hppa);
3078 /* When a hardware watchpoint triggers, we'll move the inferior past
3079 it by removing all eventpoints; stepping past the instruction
3080 that caused the trigger; reinserting eventpoints; and checking
3081 whether any watched location changed. */
3082 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
3084 /* Inferior function call methods. */
3085 switch (tdep->bytes_per_address)
3088 set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
3089 set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
3090 set_gdbarch_convert_from_func_ptr_addr
3091 (gdbarch, hppa32_convert_from_func_ptr_addr);
3094 set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
3095 set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
3098 internal_error (__FILE__, __LINE__, _("bad switch"));
3101 /* Struct return methods. */
3102 switch (tdep->bytes_per_address)
3105 set_gdbarch_return_value (gdbarch, hppa32_return_value);
3108 set_gdbarch_return_value (gdbarch, hppa64_return_value);
3111 internal_error (__FILE__, __LINE__, _("bad switch"));
3114 set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
3115 set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
3117 /* Frame unwind methods. */
3118 set_gdbarch_dummy_id (gdbarch, hppa_dummy_id);
3119 set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
3121 /* Hook in ABI-specific overrides, if they have been registered. */
3122 gdbarch_init_osabi (info, gdbarch);
3124 /* Hook in the default unwinders. */
3125 frame_unwind_append_unwinder (gdbarch, &hppa_stub_frame_unwind);
3126 frame_unwind_append_unwinder (gdbarch, &hppa_frame_unwind);
3127 frame_unwind_append_unwinder (gdbarch, &hppa_fallback_frame_unwind);
3133 hppa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3135 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3137 fprintf_unfiltered (file, "bytes_per_address = %d\n",
3138 tdep->bytes_per_address);
3139 fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
3143 _initialize_hppa_tdep (void)
3145 struct cmd_list_element *c;
3147 gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
3149 hppa_objfile_priv_data = register_objfile_data ();
3151 add_cmd ("unwind", class_maintenance, unwind_command,
3152 _("Print unwind table entry at given address."),
3153 &maintenanceprintlist);
3155 /* Debug this files internals. */
3156 add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
3157 Set whether hppa target specific debugging information should be displayed."),
3159 Show whether hppa target specific debugging information is displayed."), _("\
3160 This flag controls whether hppa target specific debugging information is\n\
3161 displayed. This information is particularly useful for debugging frame\n\
3162 unwinding problems."),
3164 NULL, /* FIXME: i18n: hppa debug flag is %s. */
3165 &setdebuglist, &showdebuglist);