1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986-2018 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 hppa_objfile_private
*priv
209 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, hppa_objfile_private
);
211 set_objfile_data (objfile
, hppa_objfile_priv_data
, priv
);
217 /* Compare the start address for two unwind entries returning 1 if
218 the first address is larger than the second, -1 if the second is
219 larger than the first, and zero if they are equal. */
222 compare_unwind_entries (const void *arg1
, const void *arg2
)
224 const struct unwind_table_entry
*a
= (const struct unwind_table_entry
*) arg1
;
225 const struct unwind_table_entry
*b
= (const struct unwind_table_entry
*) arg2
;
227 if (a
->region_start
> b
->region_start
)
229 else if (a
->region_start
< b
->region_start
)
236 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
238 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
239 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
241 bfd_vma value
= section
->vma
- section
->filepos
;
242 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
244 if (value
< *low_text_segment_address
)
245 *low_text_segment_address
= value
;
250 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
251 asection
*section
, unsigned int entries
,
252 size_t size
, CORE_ADDR text_offset
)
254 /* We will read the unwind entries into temporary memory, then
255 fill in the actual unwind table. */
259 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
262 char *buf
= (char *) alloca (size
);
263 CORE_ADDR low_text_segment_address
;
265 /* For ELF targets, then unwinds are supposed to
266 be segment relative offsets instead of absolute addresses.
268 Note that when loading a shared library (text_offset != 0) the
269 unwinds are already relative to the text_offset that will be
271 if (gdbarch_tdep (gdbarch
)->is_elf
&& text_offset
== 0)
273 low_text_segment_address
= -1;
275 bfd_map_over_sections (objfile
->obfd
,
276 record_text_segment_lowaddr
,
277 &low_text_segment_address
);
279 text_offset
= low_text_segment_address
;
281 else if (gdbarch_tdep (gdbarch
)->solib_get_text_base
)
283 text_offset
= gdbarch_tdep (gdbarch
)->solib_get_text_base (objfile
);
286 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
288 /* Now internalize the information being careful to handle host/target
290 for (i
= 0; i
< entries
; i
++)
292 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
294 table
[i
].region_start
+= text_offset
;
296 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
297 table
[i
].region_end
+= text_offset
;
299 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
301 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
302 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
303 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
304 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
305 table
[i
].reserved
= (tmp
>> 26) & 0x1;
306 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
307 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
308 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
309 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
310 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
311 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
312 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
313 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
314 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
315 table
[i
].sr4export
= (tmp
>> 9) & 0x1;
316 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
317 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
318 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
319 table
[i
].reserved1
= (tmp
>> 5) & 0x1;
320 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
321 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
322 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
323 table
[i
].save_r19
= (tmp
>> 1) & 0x1;
324 table
[i
].Cleanup_defined
= tmp
& 0x1;
325 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
327 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
328 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
329 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
330 table
[i
].alloca_frame
= (tmp
>> 28) & 0x1;
331 table
[i
].reserved2
= (tmp
>> 27) & 0x1;
332 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
334 /* Stub unwinds are handled elsewhere. */
335 table
[i
].stub_unwind
.stub_type
= 0;
336 table
[i
].stub_unwind
.padding
= 0;
341 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
342 the object file. This info is used mainly by find_unwind_entry() to find
343 out the stack frame size and frame pointer used by procedures. We put
344 everything on the psymbol obstack in the objfile so that it automatically
345 gets freed when the objfile is destroyed. */
348 read_unwind_info (struct objfile
*objfile
)
350 asection
*unwind_sec
, *stub_unwind_sec
;
351 size_t unwind_size
, stub_unwind_size
, total_size
;
352 unsigned index
, unwind_entries
;
353 unsigned stub_entries
, total_entries
;
354 CORE_ADDR text_offset
;
355 struct hppa_unwind_info
*ui
;
356 struct hppa_objfile_private
*obj_private
;
358 text_offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
359 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
360 sizeof (struct hppa_unwind_info
));
366 /* For reasons unknown the HP PA64 tools generate multiple unwinder
367 sections in a single executable. So we just iterate over every
368 section in the BFD looking for unwinder sections intead of trying
369 to do a lookup with bfd_get_section_by_name.
371 First determine the total size of the unwind tables so that we
372 can allocate memory in a nice big hunk. */
374 for (unwind_sec
= objfile
->obfd
->sections
;
376 unwind_sec
= unwind_sec
->next
)
378 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
379 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
381 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
382 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
384 total_entries
+= unwind_entries
;
388 /* Now compute the size of the stub unwinds. Note the ELF tools do not
389 use stub unwinds at the current time. */
390 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
394 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
395 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
399 stub_unwind_size
= 0;
403 /* Compute total number of unwind entries and their total size. */
404 total_entries
+= stub_entries
;
405 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
407 /* Allocate memory for the unwind table. */
408 ui
->table
= (struct unwind_table_entry
*)
409 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
410 ui
->last
= total_entries
- 1;
412 /* Now read in each unwind section and internalize the standard unwind
415 for (unwind_sec
= objfile
->obfd
->sections
;
417 unwind_sec
= unwind_sec
->next
)
419 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
420 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
422 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
423 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
425 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
426 unwind_entries
, unwind_size
, text_offset
);
427 index
+= unwind_entries
;
431 /* Now read in and internalize the stub unwind entries. */
432 if (stub_unwind_size
> 0)
435 char *buf
= (char *) alloca (stub_unwind_size
);
437 /* Read in the stub unwind entries. */
438 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
439 0, stub_unwind_size
);
441 /* Now convert them into regular unwind entries. */
442 for (i
= 0; i
< stub_entries
; i
++, index
++)
444 /* Clear out the next unwind entry. */
445 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
447 /* Convert offset & size into region_start and region_end.
448 Stuff away the stub type into "reserved" fields. */
449 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
451 ui
->table
[index
].region_start
+= text_offset
;
453 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
456 ui
->table
[index
].region_end
457 = ui
->table
[index
].region_start
+ 4 *
458 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
464 /* Unwind table needs to be kept sorted. */
465 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
466 compare_unwind_entries
);
468 /* Keep a pointer to the unwind information. */
469 obj_private
= (struct hppa_objfile_private
*)
470 objfile_data (objfile
, hppa_objfile_priv_data
);
471 if (obj_private
== NULL
)
472 obj_private
= hppa_init_objfile_priv_data (objfile
);
474 obj_private
->unwind_info
= ui
;
477 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
478 of the objfiles seeking the unwind table entry for this PC. Each objfile
479 contains a sorted list of struct unwind_table_entry. Since we do a binary
480 search of the unwind tables, we depend upon them to be sorted. */
482 struct unwind_table_entry
*
483 find_unwind_entry (CORE_ADDR pc
)
485 int first
, middle
, last
;
486 struct objfile
*objfile
;
487 struct hppa_objfile_private
*priv
;
490 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry %s -> ",
493 /* A function at address 0? Not in HP-UX! */
494 if (pc
== (CORE_ADDR
) 0)
497 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
501 ALL_OBJFILES (objfile
)
503 struct hppa_unwind_info
*ui
;
505 priv
= ((struct hppa_objfile_private
*)
506 objfile_data (objfile
, hppa_objfile_priv_data
));
508 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
512 read_unwind_info (objfile
);
513 priv
= ((struct hppa_objfile_private
*)
514 objfile_data (objfile
, hppa_objfile_priv_data
));
516 error (_("Internal error reading unwind information."));
517 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
520 /* First, check the cache. */
523 && pc
>= ui
->cache
->region_start
524 && pc
<= ui
->cache
->region_end
)
527 fprintf_unfiltered (gdb_stdlog
, "%s (cached) }\n",
528 hex_string ((uintptr_t) ui
->cache
));
532 /* Not in the cache, do a binary search. */
537 while (first
<= last
)
539 middle
= (first
+ last
) / 2;
540 if (pc
>= ui
->table
[middle
].region_start
541 && pc
<= ui
->table
[middle
].region_end
)
543 ui
->cache
= &ui
->table
[middle
];
545 fprintf_unfiltered (gdb_stdlog
, "%s }\n",
546 hex_string ((uintptr_t) ui
->cache
));
547 return &ui
->table
[middle
];
550 if (pc
< ui
->table
[middle
].region_start
)
555 } /* ALL_OBJFILES() */
558 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
563 /* Implement the stack_frame_destroyed_p gdbarch method.
565 The epilogue is defined here as the area either on the `bv' instruction
566 itself or an instruction which destroys the function's stack frame.
568 We do not assume that the epilogue is at the end of a function as we can
569 also have return sequences in the middle of a function. */
572 hppa_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
574 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
575 unsigned long status
;
579 status
= target_read_memory (pc
, buf
, 4);
583 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
585 /* The most common way to perform a stack adjustment ldo X(sp),sp
586 We are destroying a stack frame if the offset is negative. */
587 if ((inst
& 0xffffc000) == 0x37de0000
588 && hppa_extract_14 (inst
) < 0)
591 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
592 if (((inst
& 0x0fc010e0) == 0x0fc010e0
593 || (inst
& 0x0fc010e0) == 0x0fc010e0)
594 && hppa_extract_14 (inst
) < 0)
597 /* bv %r0(%rp) or bv,n %r0(%rp) */
598 if (inst
== 0xe840c000 || inst
== 0xe840c002)
604 constexpr gdb_byte hppa_break_insn
[] = {0x00, 0x01, 0x00, 0x04};
606 typedef BP_MANIPULATION (hppa_break_insn
) hppa_breakpoint
;
608 /* Return the name of a register. */
611 hppa32_register_name (struct gdbarch
*gdbarch
, int i
)
613 static const char *names
[] = {
614 "flags", "r1", "rp", "r3",
615 "r4", "r5", "r6", "r7",
616 "r8", "r9", "r10", "r11",
617 "r12", "r13", "r14", "r15",
618 "r16", "r17", "r18", "r19",
619 "r20", "r21", "r22", "r23",
620 "r24", "r25", "r26", "dp",
621 "ret0", "ret1", "sp", "r31",
622 "sar", "pcoqh", "pcsqh", "pcoqt",
623 "pcsqt", "eiem", "iir", "isr",
624 "ior", "ipsw", "goto", "sr4",
625 "sr0", "sr1", "sr2", "sr3",
626 "sr5", "sr6", "sr7", "cr0",
627 "cr8", "cr9", "ccr", "cr12",
628 "cr13", "cr24", "cr25", "cr26",
629 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
630 "fpsr", "fpe1", "fpe2", "fpe3",
631 "fpe4", "fpe5", "fpe6", "fpe7",
632 "fr4", "fr4R", "fr5", "fr5R",
633 "fr6", "fr6R", "fr7", "fr7R",
634 "fr8", "fr8R", "fr9", "fr9R",
635 "fr10", "fr10R", "fr11", "fr11R",
636 "fr12", "fr12R", "fr13", "fr13R",
637 "fr14", "fr14R", "fr15", "fr15R",
638 "fr16", "fr16R", "fr17", "fr17R",
639 "fr18", "fr18R", "fr19", "fr19R",
640 "fr20", "fr20R", "fr21", "fr21R",
641 "fr22", "fr22R", "fr23", "fr23R",
642 "fr24", "fr24R", "fr25", "fr25R",
643 "fr26", "fr26R", "fr27", "fr27R",
644 "fr28", "fr28R", "fr29", "fr29R",
645 "fr30", "fr30R", "fr31", "fr31R"
647 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
654 hppa64_register_name (struct gdbarch
*gdbarch
, int i
)
656 static const char *names
[] = {
657 "flags", "r1", "rp", "r3",
658 "r4", "r5", "r6", "r7",
659 "r8", "r9", "r10", "r11",
660 "r12", "r13", "r14", "r15",
661 "r16", "r17", "r18", "r19",
662 "r20", "r21", "r22", "r23",
663 "r24", "r25", "r26", "dp",
664 "ret0", "ret1", "sp", "r31",
665 "sar", "pcoqh", "pcsqh", "pcoqt",
666 "pcsqt", "eiem", "iir", "isr",
667 "ior", "ipsw", "goto", "sr4",
668 "sr0", "sr1", "sr2", "sr3",
669 "sr5", "sr6", "sr7", "cr0",
670 "cr8", "cr9", "ccr", "cr12",
671 "cr13", "cr24", "cr25", "cr26",
672 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
673 "fpsr", "fpe1", "fpe2", "fpe3",
674 "fr4", "fr5", "fr6", "fr7",
675 "fr8", "fr9", "fr10", "fr11",
676 "fr12", "fr13", "fr14", "fr15",
677 "fr16", "fr17", "fr18", "fr19",
678 "fr20", "fr21", "fr22", "fr23",
679 "fr24", "fr25", "fr26", "fr27",
680 "fr28", "fr29", "fr30", "fr31"
682 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
688 /* Map dwarf DBX register numbers to GDB register numbers. */
690 hppa64_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
692 /* The general registers and the sar are the same in both sets. */
693 if (reg
>= 0 && reg
<= 32)
696 /* fr4-fr31 are mapped from 72 in steps of 2. */
697 if (reg
>= 72 && reg
< 72 + 28 * 2 && !(reg
& 1))
698 return HPPA64_FP4_REGNUM
+ (reg
- 72) / 2;
703 /* This function pushes a stack frame with arguments as part of the
704 inferior function calling mechanism.
706 This is the version of the function for the 32-bit PA machines, in
707 which later arguments appear at lower addresses. (The stack always
708 grows towards higher addresses.)
710 We simply allocate the appropriate amount of stack space and put
711 arguments into their proper slots. */
714 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
715 struct regcache
*regcache
, CORE_ADDR bp_addr
,
716 int nargs
, struct value
**args
, CORE_ADDR sp
,
717 int struct_return
, CORE_ADDR struct_addr
)
719 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
721 /* Stack base address at which any pass-by-reference parameters are
723 CORE_ADDR struct_end
= 0;
724 /* Stack base address at which the first parameter is stored. */
725 CORE_ADDR param_end
= 0;
727 /* Two passes. First pass computes the location of everything,
728 second pass writes the bytes out. */
731 /* Global pointer (r19) of the function we are trying to call. */
734 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
736 for (write_pass
= 0; write_pass
< 2; write_pass
++)
738 CORE_ADDR struct_ptr
= 0;
739 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
740 struct_ptr is adjusted for each argument below, so the first
741 argument will end up at sp-36. */
742 CORE_ADDR param_ptr
= 32;
744 int small_struct
= 0;
746 for (i
= 0; i
< nargs
; i
++)
748 struct value
*arg
= args
[i
];
749 struct type
*type
= check_typedef (value_type (arg
));
750 /* The corresponding parameter that is pushed onto the
751 stack, and [possibly] passed in a register. */
752 gdb_byte param_val
[8];
754 memset (param_val
, 0, sizeof param_val
);
755 if (TYPE_LENGTH (type
) > 8)
757 /* Large parameter, pass by reference. Store the value
758 in "struct" area and then pass its address. */
760 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
762 write_memory (struct_end
- struct_ptr
, value_contents (arg
),
764 store_unsigned_integer (param_val
, 4, byte_order
,
765 struct_end
- struct_ptr
);
767 else if (TYPE_CODE (type
) == TYPE_CODE_INT
768 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
770 /* Integer value store, right aligned. "unpack_long"
771 takes care of any sign-extension problems. */
772 param_len
= align_up (TYPE_LENGTH (type
), 4);
773 store_unsigned_integer (param_val
, param_len
, byte_order
,
775 value_contents (arg
)));
777 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
779 /* Floating point value store, right aligned. */
780 param_len
= align_up (TYPE_LENGTH (type
), 4);
781 memcpy (param_val
, value_contents (arg
), param_len
);
785 param_len
= align_up (TYPE_LENGTH (type
), 4);
787 /* Small struct value are stored right-aligned. */
788 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
789 value_contents (arg
), TYPE_LENGTH (type
));
791 /* Structures of size 5, 6 and 7 bytes are special in that
792 the higher-ordered word is stored in the lower-ordered
793 argument, and even though it is a 8-byte quantity the
794 registers need not be 8-byte aligned. */
795 if (param_len
> 4 && param_len
< 8)
799 param_ptr
+= param_len
;
800 if (param_len
== 8 && !small_struct
)
801 param_ptr
= align_up (param_ptr
, 8);
803 /* First 4 non-FP arguments are passed in gr26-gr23.
804 First 4 32-bit FP arguments are passed in fr4L-fr7L.
805 First 2 64-bit FP arguments are passed in fr5 and fr7.
807 The rest go on the stack, starting at sp-36, towards lower
808 addresses. 8-byte arguments must be aligned to a 8-byte
812 write_memory (param_end
- param_ptr
, param_val
, param_len
);
814 /* There are some cases when we don't know the type
815 expected by the callee (e.g. for variadic functions), so
816 pass the parameters in both general and fp regs. */
819 int grreg
= 26 - (param_ptr
- 36) / 4;
820 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
821 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
823 regcache
->cooked_write (grreg
, param_val
);
824 regcache
->cooked_write (fpLreg
, param_val
);
828 regcache
->cooked_write (grreg
+ 1, param_val
+ 4);
830 regcache
->cooked_write (fpreg
, param_val
);
831 regcache
->cooked_write (fpreg
+ 1, param_val
+ 4);
837 /* Update the various stack pointers. */
840 struct_end
= sp
+ align_up (struct_ptr
, 64);
841 /* PARAM_PTR already accounts for all the arguments passed
842 by the user. However, the ABI mandates minimum stack
843 space allocations for outgoing arguments. The ABI also
844 mandates minimum stack alignments which we must
846 param_end
= struct_end
+ align_up (param_ptr
, 64);
850 /* If a structure has to be returned, set up register 28 to hold its
853 regcache_cooked_write_unsigned (regcache
, 28, struct_addr
);
855 gp
= tdep
->find_global_pointer (gdbarch
, function
);
858 regcache_cooked_write_unsigned (regcache
, 19, gp
);
860 /* Set the return address. */
861 if (!gdbarch_push_dummy_code_p (gdbarch
))
862 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
864 /* Update the Stack Pointer. */
865 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
870 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
871 Runtime Architecture for PA-RISC 2.0", which is distributed as part
872 as of the HP-UX Software Transition Kit (STK). This implementation
873 is based on version 3.3, dated October 6, 1997. */
875 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
878 hppa64_integral_or_pointer_p (const struct type
*type
)
880 switch (TYPE_CODE (type
))
886 case TYPE_CODE_RANGE
:
888 int len
= TYPE_LENGTH (type
);
889 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
893 case TYPE_CODE_RVALUE_REF
:
894 return (TYPE_LENGTH (type
) == 8);
902 /* Check whether TYPE is a "Floating Scalar Type". */
905 hppa64_floating_p (const struct type
*type
)
907 switch (TYPE_CODE (type
))
911 int len
= TYPE_LENGTH (type
);
912 return (len
== 4 || len
== 8 || len
== 16);
921 /* If CODE points to a function entry address, try to look up the corresponding
922 function descriptor and return its address instead. If CODE is not a
923 function entry address, then just return it unchanged. */
925 hppa64_convert_code_addr_to_fptr (struct gdbarch
*gdbarch
, CORE_ADDR code
)
927 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
928 struct obj_section
*sec
, *opd
;
930 sec
= find_pc_section (code
);
935 /* If CODE is in a data section, assume it's already a fptr. */
936 if (!(sec
->the_bfd_section
->flags
& SEC_CODE
))
939 ALL_OBJFILE_OSECTIONS (sec
->objfile
, opd
)
941 if (strcmp (opd
->the_bfd_section
->name
, ".opd") == 0)
945 if (opd
< sec
->objfile
->sections_end
)
949 for (addr
= obj_section_addr (opd
);
950 addr
< obj_section_endaddr (opd
);
956 if (target_read_memory (addr
, tmp
, sizeof (tmp
)))
958 opdaddr
= extract_unsigned_integer (tmp
, sizeof (tmp
), byte_order
);
969 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
970 struct regcache
*regcache
, CORE_ADDR bp_addr
,
971 int nargs
, struct value
**args
, CORE_ADDR sp
,
972 int struct_return
, CORE_ADDR struct_addr
)
974 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
975 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
979 /* "The outgoing parameter area [...] must be aligned at a 16-byte
981 sp
= align_up (sp
, 16);
983 for (i
= 0; i
< nargs
; i
++)
985 struct value
*arg
= args
[i
];
986 struct type
*type
= value_type (arg
);
987 int len
= TYPE_LENGTH (type
);
988 const bfd_byte
*valbuf
;
992 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
993 offset
= align_up (offset
, 8);
995 if (hppa64_integral_or_pointer_p (type
))
997 /* "Integral scalar parameters smaller than 64 bits are
998 padded on the left (i.e., the value is in the
999 least-significant bits of the 64-bit storage unit, and
1000 the high-order bits are undefined)." Therefore we can
1001 safely sign-extend them. */
1004 arg
= value_cast (builtin_type (gdbarch
)->builtin_int64
, arg
);
1008 else if (hppa64_floating_p (type
))
1012 /* "Quad-precision (128-bit) floating-point scalar
1013 parameters are aligned on a 16-byte boundary." */
1014 offset
= align_up (offset
, 16);
1016 /* "Double-extended- and quad-precision floating-point
1017 parameters within the first 64 bytes of the parameter
1018 list are always passed in general registers." */
1024 /* "Single-precision (32-bit) floating-point scalar
1025 parameters are padded on the left with 32 bits of
1026 garbage (i.e., the floating-point value is in the
1027 least-significant 32 bits of a 64-bit storage
1032 /* "Single- and double-precision floating-point
1033 parameters in this area are passed according to the
1034 available formal parameter information in a function
1035 prototype. [...] If no prototype is in scope,
1036 floating-point parameters must be passed both in the
1037 corresponding general registers and in the
1038 corresponding floating-point registers." */
1039 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
1041 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
1043 /* "Single-precision floating-point parameters, when
1044 passed in floating-point registers, are passed in
1045 the right halves of the floating point registers;
1046 the left halves are unused." */
1047 regcache_cooked_write_part (regcache
, regnum
, offset
% 8,
1048 len
, value_contents (arg
));
1056 /* "Aggregates larger than 8 bytes are aligned on a
1057 16-byte boundary, possibly leaving an unused argument
1058 slot, which is filled with garbage. If necessary,
1059 they are padded on the right (with garbage), to a
1060 multiple of 8 bytes." */
1061 offset
= align_up (offset
, 16);
1065 /* If we are passing a function pointer, make sure we pass a function
1066 descriptor instead of the function entry address. */
1067 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1068 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1070 ULONGEST codeptr
, fptr
;
1072 codeptr
= unpack_long (type
, value_contents (arg
));
1073 fptr
= hppa64_convert_code_addr_to_fptr (gdbarch
, codeptr
);
1074 store_unsigned_integer (fptrbuf
, TYPE_LENGTH (type
), byte_order
,
1080 valbuf
= value_contents (arg
);
1083 /* Always store the argument in memory. */
1084 write_memory (sp
+ offset
, valbuf
, len
);
1086 regnum
= HPPA_ARG0_REGNUM
- offset
/ 8;
1087 while (regnum
> HPPA_ARG0_REGNUM
- 8 && len
> 0)
1089 regcache_cooked_write_part (regcache
, regnum
,
1090 offset
% 8, std::min (len
, 8), valbuf
);
1091 offset
+= std::min (len
, 8);
1092 valbuf
+= std::min (len
, 8);
1093 len
-= std::min (len
, 8);
1100 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1101 regcache_cooked_write_unsigned (regcache
, HPPA_RET1_REGNUM
, sp
+ 64);
1103 /* Allocate the outgoing parameter area. Make sure the outgoing
1104 parameter area is multiple of 16 bytes in length. */
1105 sp
+= std::max (align_up (offset
, 16), (ULONGEST
) 64);
1107 /* Allocate 32-bytes of scratch space. The documentation doesn't
1108 mention this, but it seems to be needed. */
1111 /* Allocate the frame marker area. */
1114 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1117 regcache_cooked_write_unsigned (regcache
, HPPA_RET0_REGNUM
, struct_addr
);
1119 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1120 gp
= tdep
->find_global_pointer (gdbarch
, function
);
1122 regcache_cooked_write_unsigned (regcache
, HPPA_DP_REGNUM
, gp
);
1124 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1125 if (!gdbarch_push_dummy_code_p (gdbarch
))
1126 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1128 /* Set up GR30 to hold the stack pointer (sp). */
1129 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, sp
);
1135 /* Handle 32/64-bit struct return conventions. */
1137 static enum return_value_convention
1138 hppa32_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1139 struct type
*type
, struct regcache
*regcache
,
1140 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1142 if (TYPE_LENGTH (type
) <= 2 * 4)
1144 /* The value always lives in the right hand end of the register
1145 (or register pair)? */
1147 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
1148 int part
= TYPE_LENGTH (type
) % 4;
1149 /* The left hand register contains only part of the value,
1150 transfer that first so that the rest can be xfered as entire
1151 4-byte registers. */
1154 if (readbuf
!= NULL
)
1155 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
1157 if (writebuf
!= NULL
)
1158 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
1162 /* Now transfer the remaining register values. */
1163 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
1165 if (readbuf
!= NULL
)
1166 regcache
->cooked_read (reg
, readbuf
+ b
);
1167 if (writebuf
!= NULL
)
1168 regcache
->cooked_write (reg
, writebuf
+ b
);
1171 return RETURN_VALUE_REGISTER_CONVENTION
;
1174 return RETURN_VALUE_STRUCT_CONVENTION
;
1177 static enum return_value_convention
1178 hppa64_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1179 struct type
*type
, struct regcache
*regcache
,
1180 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1182 int len
= TYPE_LENGTH (type
);
1187 /* All return values larget than 128 bits must be aggregate
1189 gdb_assert (!hppa64_integral_or_pointer_p (type
));
1190 gdb_assert (!hppa64_floating_p (type
));
1192 /* "Aggregate return values larger than 128 bits are returned in
1193 a buffer allocated by the caller. The address of the buffer
1194 must be passed in GR 28." */
1195 return RETURN_VALUE_STRUCT_CONVENTION
;
1198 if (hppa64_integral_or_pointer_p (type
))
1200 /* "Integral return values are returned in GR 28. Values
1201 smaller than 64 bits are padded on the left (with garbage)." */
1202 regnum
= HPPA_RET0_REGNUM
;
1205 else if (hppa64_floating_p (type
))
1209 /* "Double-extended- and quad-precision floating-point
1210 values are returned in GRs 28 and 29. The sign,
1211 exponent, and most-significant bits of the mantissa are
1212 returned in GR 28; the least-significant bits of the
1213 mantissa are passed in GR 29. For double-extended
1214 precision values, GR 29 is padded on the right with 48
1215 bits of garbage." */
1216 regnum
= HPPA_RET0_REGNUM
;
1221 /* "Single-precision and double-precision floating-point
1222 return values are returned in FR 4R (single precision) or
1223 FR 4 (double-precision)." */
1224 regnum
= HPPA64_FP4_REGNUM
;
1230 /* "Aggregate return values up to 64 bits in size are returned
1231 in GR 28. Aggregates smaller than 64 bits are left aligned
1232 in the register; the pad bits on the right are undefined."
1234 "Aggregate return values between 65 and 128 bits are returned
1235 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1236 the remaining bits are placed, left aligned, in GR 29. The
1237 pad bits on the right of GR 29 (if any) are undefined." */
1238 regnum
= HPPA_RET0_REGNUM
;
1246 regcache_cooked_read_part (regcache
, regnum
, offset
,
1247 std::min (len
, 8), readbuf
);
1248 readbuf
+= std::min (len
, 8);
1249 len
-= std::min (len
, 8);
1258 regcache_cooked_write_part (regcache
, regnum
, offset
,
1259 std::min (len
, 8), writebuf
);
1260 writebuf
+= std::min (len
, 8);
1261 len
-= std::min (len
, 8);
1266 return RETURN_VALUE_REGISTER_CONVENTION
;
1271 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1272 struct target_ops
*targ
)
1276 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1277 CORE_ADDR plabel
= addr
& ~3;
1278 return read_memory_typed_address (plabel
, func_ptr_type
);
1285 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1287 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1289 return align_up (addr
, 64);
1292 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1295 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1297 /* Just always 16-byte align. */
1298 return align_up (addr
, 16);
1302 hppa_read_pc (readable_regcache
*regcache
)
1307 regcache
->cooked_read (HPPA_IPSW_REGNUM
, &ipsw
);
1308 regcache
->cooked_read (HPPA_PCOQ_HEAD_REGNUM
, &pc
);
1310 /* If the current instruction is nullified, then we are effectively
1311 still executing the previous instruction. Pretend we are still
1312 there. This is needed when single stepping; if the nullified
1313 instruction is on a different line, we don't want GDB to think
1314 we've stepped onto that line. */
1315 if (ipsw
& 0x00200000)
1322 hppa_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1324 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pc
);
1325 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4);
1328 /* For the given instruction (INST), return any adjustment it makes
1329 to the stack pointer or zero for no adjustment.
1331 This only handles instructions commonly found in prologues. */
1334 prologue_inst_adjust_sp (unsigned long inst
)
1336 /* This must persist across calls. */
1337 static int save_high21
;
1339 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1340 if ((inst
& 0xffffc000) == 0x37de0000)
1341 return hppa_extract_14 (inst
);
1344 if ((inst
& 0xffe00000) == 0x6fc00000)
1345 return hppa_extract_14 (inst
);
1347 /* std,ma X,D(sp) */
1348 if ((inst
& 0xffe00008) == 0x73c00008)
1349 return (inst
& 0x1 ? -(1 << 13) : 0) | (((inst
>> 4) & 0x3ff) << 3);
1351 /* addil high21,%r30; ldo low11,(%r1),%r30)
1352 save high bits in save_high21 for later use. */
1353 if ((inst
& 0xffe00000) == 0x2bc00000)
1355 save_high21
= hppa_extract_21 (inst
);
1359 if ((inst
& 0xffff0000) == 0x343e0000)
1360 return save_high21
+ hppa_extract_14 (inst
);
1362 /* fstws as used by the HP compilers. */
1363 if ((inst
& 0xffffffe0) == 0x2fd01220)
1364 return hppa_extract_5_load (inst
);
1366 /* No adjustment. */
1370 /* Return nonzero if INST is a branch of some kind, else return zero. */
1373 is_branch (unsigned long inst
)
1402 /* Return the register number for a GR which is saved by INST or
1403 zero if INST does not save a GR.
1408 https://parisc.wiki.kernel.org/images-parisc/6/68/Pa11_acd.pdf
1411 https://parisc.wiki.kernel.org/images-parisc/7/73/Parisc2.0.pdf
1413 According to Table 6-5 of Chapter 6 (Memory Reference Instructions)
1414 on page 106 in parisc 2.0, all instructions for storing values from
1415 the general registers are:
1417 Store: stb, sth, stw, std (according to Chapter 7, they
1418 are only in both "inst >> 26" and "inst >> 6".
1419 Store Absolute: stwa, stda (according to Chapter 7, they are only
1421 Store Bytes: stby, stdby (according to Chapter 7, they are
1422 only in "inst >> 6").
1424 For (inst >> 26), according to Chapter 7:
1426 The effective memory reference address is formed by the addition
1427 of an immediate displacement to a base value.
1429 - stb: 0x18, store a byte from a general register.
1431 - sth: 0x19, store a halfword from a general register.
1433 - stw: 0x1a, store a word from a general register.
1435 - stwm: 0x1b, store a word from a general register and perform base
1436 register modification (2.0 will still treate it as stw).
1438 - std: 0x1c, store a doubleword from a general register (2.0 only).
1440 - stw: 0x1f, store a word from a general register (2.0 only).
1442 For (inst >> 6) when ((inst >> 26) == 0x03), according to Chapter 7:
1444 The effective memory reference address is formed by the addition
1445 of an index value to a base value specified in the instruction.
1447 - stb: 0x08, store a byte from a general register (1.1 calls stbs).
1449 - sth: 0x09, store a halfword from a general register (1.1 calls
1452 - stw: 0x0a, store a word from a general register (1.1 calls stws).
1454 - std: 0x0b: store a doubleword from a general register (2.0 only)
1456 Implement fast byte moves (stores) to unaligned word or doubleword
1459 - stby: 0x0c, for unaligned word (1.1 calls stbys).
1461 - stdby: 0x0d for unaligned doubleword (2.0 only).
1463 Store a word or doubleword using an absolute memory address formed
1464 using short or long displacement or indexed
1466 - stwa: 0x0e, store a word from a general register to an absolute
1467 address (1.0 calls stwas).
1469 - stda: 0x0f, store a doubleword from a general register to an
1470 absolute address (2.0 only). */
1473 inst_saves_gr (unsigned long inst
)
1475 switch ((inst
>> 26) & 0x0f)
1478 switch ((inst
>> 6) & 0x0f)
1488 return hppa_extract_5R_store (inst
);
1497 /* no 0x1d or 0x1e -- according to parisc 2.0 document */
1499 return hppa_extract_5R_store (inst
);
1505 /* Return the register number for a FR which is saved by INST or
1506 zero it INST does not save a FR.
1508 Note we only care about full 64bit register stores (that's the only
1509 kind of stores the prologue will use).
1511 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1514 inst_saves_fr (unsigned long inst
)
1516 /* Is this an FSTD? */
1517 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1518 return hppa_extract_5r_store (inst
);
1519 if ((inst
& 0xfc000002) == 0x70000002)
1520 return hppa_extract_5R_store (inst
);
1521 /* Is this an FSTW? */
1522 if ((inst
& 0xfc00df80) == 0x24001200)
1523 return hppa_extract_5r_store (inst
);
1524 if ((inst
& 0xfc000002) == 0x7c000000)
1525 return hppa_extract_5R_store (inst
);
1529 /* Advance PC across any function entry prologue instructions
1530 to reach some "real" code.
1532 Use information in the unwind table to determine what exactly should
1533 be in the prologue. */
1537 skip_prologue_hard_way (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1538 int stop_before_branch
)
1540 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1542 CORE_ADDR orig_pc
= pc
;
1543 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1544 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1545 struct unwind_table_entry
*u
;
1546 int final_iteration
;
1552 u
= find_unwind_entry (pc
);
1556 /* If we are not at the beginning of a function, then return now. */
1557 if ((pc
& ~0x3) != u
->region_start
)
1560 /* This is how much of a frame adjustment we need to account for. */
1561 stack_remaining
= u
->Total_frame_size
<< 3;
1563 /* Magic register saves we want to know about. */
1564 save_rp
= u
->Save_RP
;
1565 save_sp
= u
->Save_SP
;
1567 /* An indication that args may be stored into the stack. Unfortunately
1568 the HPUX compilers tend to set this in cases where no args were
1572 /* Turn the Entry_GR field into a bitmask. */
1574 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1576 /* Frame pointer gets saved into a special location. */
1577 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1580 save_gr
|= (1 << i
);
1582 save_gr
&= ~restart_gr
;
1584 /* Turn the Entry_FR field into a bitmask too. */
1586 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1587 save_fr
|= (1 << i
);
1588 save_fr
&= ~restart_fr
;
1590 final_iteration
= 0;
1592 /* Loop until we find everything of interest or hit a branch.
1594 For unoptimized GCC code and for any HP CC code this will never ever
1595 examine any user instructions.
1597 For optimzied GCC code we're faced with problems. GCC will schedule
1598 its prologue and make prologue instructions available for delay slot
1599 filling. The end result is user code gets mixed in with the prologue
1600 and a prologue instruction may be in the delay slot of the first branch
1603 Some unexpected things are expected with debugging optimized code, so
1604 we allow this routine to walk past user instructions in optimized
1606 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1609 unsigned int reg_num
;
1610 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1611 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1613 /* Save copies of all the triggers so we can compare them later
1615 old_save_gr
= save_gr
;
1616 old_save_fr
= save_fr
;
1617 old_save_rp
= save_rp
;
1618 old_save_sp
= save_sp
;
1619 old_stack_remaining
= stack_remaining
;
1621 status
= target_read_memory (pc
, buf
, 4);
1622 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1628 /* Note the interesting effects of this instruction. */
1629 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1631 /* There are limited ways to store the return pointer into the
1633 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1636 /* These are the only ways we save SP into the stack. At this time
1637 the HP compilers never bother to save SP into the stack. */
1638 if ((inst
& 0xffffc000) == 0x6fc10000
1639 || (inst
& 0xffffc00c) == 0x73c10008)
1642 /* Are we loading some register with an offset from the argument
1644 if ((inst
& 0xffe00000) == 0x37a00000
1645 || (inst
& 0xffffffe0) == 0x081d0240)
1651 /* Account for general and floating-point register saves. */
1652 reg_num
= inst_saves_gr (inst
);
1653 save_gr
&= ~(1 << reg_num
);
1655 /* Ugh. Also account for argument stores into the stack.
1656 Unfortunately args_stored only tells us that some arguments
1657 where stored into the stack. Not how many or what kind!
1659 This is a kludge as on the HP compiler sets this bit and it
1660 never does prologue scheduling. So once we see one, skip past
1661 all of them. We have similar code for the fp arg stores below.
1663 FIXME. Can still die if we have a mix of GR and FR argument
1665 if (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1668 while (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1672 status
= target_read_memory (pc
, buf
, 4);
1673 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1676 reg_num
= inst_saves_gr (inst
);
1682 reg_num
= inst_saves_fr (inst
);
1683 save_fr
&= ~(1 << reg_num
);
1685 status
= target_read_memory (pc
+ 4, buf
, 4);
1686 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1692 /* We've got to be read to handle the ldo before the fp register
1694 if ((inst
& 0xfc000000) == 0x34000000
1695 && inst_saves_fr (next_inst
) >= 4
1696 && inst_saves_fr (next_inst
)
1697 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1699 /* So we drop into the code below in a reasonable state. */
1700 reg_num
= inst_saves_fr (next_inst
);
1704 /* Ugh. Also account for argument stores into the stack.
1705 This is a kludge as on the HP compiler sets this bit and it
1706 never does prologue scheduling. So once we see one, skip past
1709 && reg_num
<= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1713 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1716 status
= target_read_memory (pc
, buf
, 4);
1717 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1720 if ((inst
& 0xfc000000) != 0x34000000)
1722 status
= target_read_memory (pc
+ 4, buf
, 4);
1723 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1726 reg_num
= inst_saves_fr (next_inst
);
1732 /* Quit if we hit any kind of branch. This can happen if a prologue
1733 instruction is in the delay slot of the first call/branch. */
1734 if (is_branch (inst
) && stop_before_branch
)
1737 /* What a crock. The HP compilers set args_stored even if no
1738 arguments were stored into the stack (boo hiss). This could
1739 cause this code to then skip a bunch of user insns (up to the
1742 To combat this we try to identify when args_stored was bogusly
1743 set and clear it. We only do this when args_stored is nonzero,
1744 all other resources are accounted for, and nothing changed on
1747 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1748 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1749 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1750 && old_stack_remaining
== stack_remaining
)
1756 /* !stop_before_branch, so also look at the insn in the delay slot
1758 if (final_iteration
)
1760 if (is_branch (inst
))
1761 final_iteration
= 1;
1764 /* We've got a tenative location for the end of the prologue. However
1765 because of limitations in the unwind descriptor mechanism we may
1766 have went too far into user code looking for the save of a register
1767 that does not exist. So, if there registers we expected to be saved
1768 but never were, mask them out and restart.
1770 This should only happen in optimized code, and should be very rare. */
1771 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1774 restart_gr
= save_gr
;
1775 restart_fr
= save_fr
;
1783 /* Return the address of the PC after the last prologue instruction if
1784 we can determine it from the debug symbols. Else return zero. */
1787 after_prologue (CORE_ADDR pc
)
1789 struct symtab_and_line sal
;
1790 CORE_ADDR func_addr
, func_end
;
1792 /* If we can not find the symbol in the partial symbol table, then
1793 there is no hope we can determine the function's start address
1795 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1798 /* Get the line associated with FUNC_ADDR. */
1799 sal
= find_pc_line (func_addr
, 0);
1801 /* There are only two cases to consider. First, the end of the source line
1802 is within the function bounds. In that case we return the end of the
1803 source line. Second is the end of the source line extends beyond the
1804 bounds of the current function. We need to use the slow code to
1805 examine instructions in that case.
1807 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1808 the wrong thing to do. In fact, it should be entirely possible for this
1809 function to always return zero since the slow instruction scanning code
1810 is supposed to *always* work. If it does not, then it is a bug. */
1811 if (sal
.end
< func_end
)
1817 /* To skip prologues, I use this predicate. Returns either PC itself
1818 if the code at PC does not look like a function prologue; otherwise
1819 returns an address that (if we're lucky) follows the prologue.
1821 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1822 It doesn't necessarily skips all the insns in the prologue. In fact
1823 we might not want to skip all the insns because a prologue insn may
1824 appear in the delay slot of the first branch, and we don't want to
1825 skip over the branch in that case. */
1828 hppa_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1830 CORE_ADDR post_prologue_pc
;
1832 /* See if we can determine the end of the prologue via the symbol table.
1833 If so, then return either PC, or the PC after the prologue, whichever
1836 post_prologue_pc
= after_prologue (pc
);
1838 /* If after_prologue returned a useful address, then use it. Else
1839 fall back on the instruction skipping code.
1841 Some folks have claimed this causes problems because the breakpoint
1842 may be the first instruction of the prologue. If that happens, then
1843 the instruction skipping code has a bug that needs to be fixed. */
1844 if (post_prologue_pc
!= 0)
1845 return std::max (pc
, post_prologue_pc
);
1847 return (skip_prologue_hard_way (gdbarch
, pc
, 1));
1850 /* Return an unwind entry that falls within the frame's code block. */
1852 static struct unwind_table_entry
*
1853 hppa_find_unwind_entry_in_block (struct frame_info
*this_frame
)
1855 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
1857 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1858 result of get_frame_address_in_block implies a problem.
1859 The bits should have been removed earlier, before the return
1860 value of gdbarch_unwind_pc. That might be happening already;
1861 if it isn't, it should be fixed. Then this call can be
1863 pc
= gdbarch_addr_bits_remove (get_frame_arch (this_frame
), pc
);
1864 return find_unwind_entry (pc
);
1867 struct hppa_frame_cache
1870 struct trad_frame_saved_reg
*saved_regs
;
1873 static struct hppa_frame_cache
*
1874 hppa_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1876 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1877 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1878 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1879 struct hppa_frame_cache
*cache
;
1883 struct unwind_table_entry
*u
;
1884 CORE_ADDR prologue_end
;
1889 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1890 frame_relative_level(this_frame
));
1892 if ((*this_cache
) != NULL
)
1895 fprintf_unfiltered (gdb_stdlog
, "base=%s (cached) }",
1896 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
1897 return (struct hppa_frame_cache
*) (*this_cache
);
1899 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1900 (*this_cache
) = cache
;
1901 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1904 u
= hppa_find_unwind_entry_in_block (this_frame
);
1908 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1909 return (struct hppa_frame_cache
*) (*this_cache
);
1912 /* Turn the Entry_GR field into a bitmask. */
1914 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1916 /* Frame pointer gets saved into a special location. */
1917 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1920 saved_gr_mask
|= (1 << i
);
1923 /* Turn the Entry_FR field into a bitmask too. */
1925 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1926 saved_fr_mask
|= (1 << i
);
1928 /* Loop until we find everything of interest or hit a branch.
1930 For unoptimized GCC code and for any HP CC code this will never ever
1931 examine any user instructions.
1933 For optimized GCC code we're faced with problems. GCC will schedule
1934 its prologue and make prologue instructions available for delay slot
1935 filling. The end result is user code gets mixed in with the prologue
1936 and a prologue instruction may be in the delay slot of the first branch
1939 Some unexpected things are expected with debugging optimized code, so
1940 we allow this routine to walk past user instructions in optimized
1943 int final_iteration
= 0;
1944 CORE_ADDR pc
, start_pc
, end_pc
;
1945 int looking_for_sp
= u
->Save_SP
;
1946 int looking_for_rp
= u
->Save_RP
;
1949 /* We have to use skip_prologue_hard_way instead of just
1950 skip_prologue_using_sal, in case we stepped into a function without
1951 symbol information. hppa_skip_prologue also bounds the returned
1952 pc by the passed in pc, so it will not return a pc in the next
1955 We used to call hppa_skip_prologue to find the end of the prologue,
1956 but if some non-prologue instructions get scheduled into the prologue,
1957 and the program is compiled with debug information, the "easy" way
1958 in hppa_skip_prologue will return a prologue end that is too early
1959 for us to notice any potential frame adjustments. */
1961 /* We used to use get_frame_func to locate the beginning of the
1962 function to pass to skip_prologue. However, when objects are
1963 compiled without debug symbols, get_frame_func can return the wrong
1964 function (or 0). We can do better than that by using unwind records.
1965 This only works if the Region_description of the unwind record
1966 indicates that it includes the entry point of the function.
1967 HP compilers sometimes generate unwind records for regions that
1968 do not include the entry or exit point of a function. GNU tools
1971 if ((u
->Region_description
& 0x2) == 0)
1972 start_pc
= u
->region_start
;
1974 start_pc
= get_frame_func (this_frame
);
1976 prologue_end
= skip_prologue_hard_way (gdbarch
, start_pc
, 0);
1977 end_pc
= get_frame_pc (this_frame
);
1979 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1980 end_pc
= prologue_end
;
1985 ((saved_gr_mask
|| saved_fr_mask
1986 || looking_for_sp
|| looking_for_rp
1987 || frame_size
< (u
->Total_frame_size
<< 3))
1995 if (!safe_frame_unwind_memory (this_frame
, pc
, buf4
, sizeof buf4
))
1997 error (_("Cannot read instruction at %s."),
1998 paddress (gdbarch
, pc
));
1999 return (struct hppa_frame_cache
*) (*this_cache
);
2002 inst
= extract_unsigned_integer (buf4
, sizeof buf4
, byte_order
);
2004 /* Note the interesting effects of this instruction. */
2005 frame_size
+= prologue_inst_adjust_sp (inst
);
2007 /* There are limited ways to store the return pointer into the
2009 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2012 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2014 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
2017 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
2019 else if (inst
== 0x0fc212c1
2020 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2023 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2026 /* Check to see if we saved SP into the stack. This also
2027 happens to indicate the location of the saved frame
2029 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
2030 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2033 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
2035 else if (inst
== 0x08030241) /* copy %r3, %r1 */
2040 /* Account for general and floating-point register saves. */
2041 reg
= inst_saves_gr (inst
);
2042 if (reg
>= 3 && reg
<= 18
2043 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
2045 saved_gr_mask
&= ~(1 << reg
);
2046 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
2047 /* stwm with a positive displacement is a _post_
2049 cache
->saved_regs
[reg
].addr
= 0;
2050 else if ((inst
& 0xfc00000c) == 0x70000008)
2051 /* A std has explicit post_modify forms. */
2052 cache
->saved_regs
[reg
].addr
= 0;
2057 if ((inst
>> 26) == 0x1c)
2058 offset
= (inst
& 0x1 ? -(1 << 13) : 0)
2059 | (((inst
>> 4) & 0x3ff) << 3);
2060 else if ((inst
>> 26) == 0x03)
2061 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
2063 offset
= hppa_extract_14 (inst
);
2065 /* Handle code with and without frame pointers. */
2067 cache
->saved_regs
[reg
].addr
= offset
;
2069 cache
->saved_regs
[reg
].addr
2070 = (u
->Total_frame_size
<< 3) + offset
;
2074 /* GCC handles callee saved FP regs a little differently.
2076 It emits an instruction to put the value of the start of
2077 the FP store area into %r1. It then uses fstds,ma with a
2078 basereg of %r1 for the stores.
2080 HP CC emits them at the current stack pointer modifying the
2081 stack pointer as it stores each register. */
2083 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2084 if ((inst
& 0xffffc000) == 0x34610000
2085 || (inst
& 0xffffc000) == 0x37c10000)
2086 fp_loc
= hppa_extract_14 (inst
);
2088 reg
= inst_saves_fr (inst
);
2089 if (reg
>= 12 && reg
<= 21)
2091 /* Note +4 braindamage below is necessary because the FP
2092 status registers are internally 8 registers rather than
2093 the expected 4 registers. */
2094 saved_fr_mask
&= ~(1 << reg
);
2097 /* 1st HP CC FP register store. After this
2098 instruction we've set enough state that the GCC and
2099 HPCC code are both handled in the same manner. */
2100 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
2105 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
2110 /* Quit if we hit any kind of branch the previous iteration. */
2111 if (final_iteration
)
2113 /* We want to look precisely one instruction beyond the branch
2114 if we have not found everything yet. */
2115 if (is_branch (inst
))
2116 final_iteration
= 1;
2121 /* The frame base always represents the value of %sp at entry to
2122 the current function (and is thus equivalent to the "saved"
2124 CORE_ADDR this_sp
= get_frame_register_unsigned (this_frame
,
2129 fprintf_unfiltered (gdb_stdlog
, " (this_sp=%s, pc=%s, "
2130 "prologue_end=%s) ",
2131 paddress (gdbarch
, this_sp
),
2132 paddress (gdbarch
, get_frame_pc (this_frame
)),
2133 paddress (gdbarch
, prologue_end
));
2135 /* Check to see if a frame pointer is available, and use it for
2136 frame unwinding if it is.
2138 There are some situations where we need to rely on the frame
2139 pointer to do stack unwinding. For example, if a function calls
2140 alloca (), the stack pointer can get adjusted inside the body of
2141 the function. In this case, the ABI requires that the compiler
2142 maintain a frame pointer for the function.
2144 The unwind record has a flag (alloca_frame) that indicates that
2145 a function has a variable frame; unfortunately, gcc/binutils
2146 does not set this flag. Instead, whenever a frame pointer is used
2147 and saved on the stack, the Save_SP flag is set. We use this to
2148 decide whether to use the frame pointer for unwinding.
2150 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2151 instead of Save_SP. */
2153 fp
= get_frame_register_unsigned (this_frame
, HPPA_FP_REGNUM
);
2155 if (u
->alloca_frame
)
2156 fp
-= u
->Total_frame_size
<< 3;
2158 if (get_frame_pc (this_frame
) >= prologue_end
2159 && (u
->Save_SP
|| u
->alloca_frame
) && fp
!= 0)
2164 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [frame pointer]",
2165 paddress (gdbarch
, cache
->base
));
2168 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
2170 /* Both we're expecting the SP to be saved and the SP has been
2171 saved. The entry SP value is saved at this frame's SP
2173 cache
->base
= read_memory_integer (this_sp
, word_size
, byte_order
);
2176 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [saved]",
2177 paddress (gdbarch
, cache
->base
));
2181 /* The prologue has been slowly allocating stack space. Adjust
2183 cache
->base
= this_sp
- frame_size
;
2185 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [unwind adjust]",
2186 paddress (gdbarch
, cache
->base
));
2189 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2192 /* The PC is found in the "return register", "Millicode" uses "r31"
2193 as the return register while normal code uses "rp". */
2196 if (trad_frame_addr_p (cache
->saved_regs
, 31))
2198 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2200 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2204 ULONGEST r31
= get_frame_register_unsigned (this_frame
, 31);
2205 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
2207 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2212 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2214 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2215 cache
->saved_regs
[HPPA_RP_REGNUM
];
2217 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2221 ULONGEST rp
= get_frame_register_unsigned (this_frame
,
2223 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2225 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2229 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2230 frame. However, there is a one-insn window where we haven't saved it
2231 yet, but we've already clobbered it. Detect this case and fix it up.
2233 The prologue sequence for frame-pointer functions is:
2234 0: stw %rp, -20(%sp)
2237 c: stw,ma %r1, XX(%sp)
2239 So if we are at offset c, the r3 value that we want is not yet saved
2240 on the stack, but it's been overwritten. The prologue analyzer will
2241 set fp_in_r1 when it sees the copy insn so we know to get the value
2243 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
2246 ULONGEST r1
= get_frame_register_unsigned (this_frame
, 1);
2247 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
2251 /* Convert all the offsets into addresses. */
2253 for (reg
= 0; reg
< gdbarch_num_regs (gdbarch
); reg
++)
2255 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
2256 cache
->saved_regs
[reg
].addr
+= cache
->base
;
2261 struct gdbarch_tdep
*tdep
;
2263 tdep
= gdbarch_tdep (gdbarch
);
2265 if (tdep
->unwind_adjust_stub
)
2266 tdep
->unwind_adjust_stub (this_frame
, cache
->base
, cache
->saved_regs
);
2270 fprintf_unfiltered (gdb_stdlog
, "base=%s }",
2271 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
2272 return (struct hppa_frame_cache
*) (*this_cache
);
2276 hppa_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2277 struct frame_id
*this_id
)
2279 struct hppa_frame_cache
*info
;
2280 struct unwind_table_entry
*u
;
2282 info
= hppa_frame_cache (this_frame
, this_cache
);
2283 u
= hppa_find_unwind_entry_in_block (this_frame
);
2285 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2288 static struct value
*
2289 hppa_frame_prev_register (struct frame_info
*this_frame
,
2290 void **this_cache
, int regnum
)
2292 struct hppa_frame_cache
*info
= hppa_frame_cache (this_frame
, this_cache
);
2294 return hppa_frame_prev_register_helper (this_frame
,
2295 info
->saved_regs
, regnum
);
2299 hppa_frame_unwind_sniffer (const struct frame_unwind
*self
,
2300 struct frame_info
*this_frame
, void **this_cache
)
2302 if (hppa_find_unwind_entry_in_block (this_frame
))
2308 static const struct frame_unwind hppa_frame_unwind
=
2311 default_frame_unwind_stop_reason
,
2313 hppa_frame_prev_register
,
2315 hppa_frame_unwind_sniffer
2318 /* This is a generic fallback frame unwinder that kicks in if we fail all
2319 the other ones. Normally we would expect the stub and regular unwinder
2320 to work, but in some cases we might hit a function that just doesn't
2321 have any unwind information available. In this case we try to do
2322 unwinding solely based on code reading. This is obviously going to be
2323 slow, so only use this as a last resort. Currently this will only
2324 identify the stack and pc for the frame. */
2326 static struct hppa_frame_cache
*
2327 hppa_fallback_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
2329 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2330 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2331 struct hppa_frame_cache
*cache
;
2332 unsigned int frame_size
= 0;
2337 fprintf_unfiltered (gdb_stdlog
,
2338 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2339 frame_relative_level (this_frame
));
2341 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2342 (*this_cache
) = cache
;
2343 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2345 start_pc
= get_frame_func (this_frame
);
2348 CORE_ADDR cur_pc
= get_frame_pc (this_frame
);
2351 for (pc
= start_pc
; pc
< cur_pc
; pc
+= 4)
2355 insn
= read_memory_unsigned_integer (pc
, 4, byte_order
);
2356 frame_size
+= prologue_inst_adjust_sp (insn
);
2358 /* There are limited ways to store the return pointer into the
2360 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2362 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2365 else if (insn
== 0x0fc212c1
2366 || insn
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2368 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2375 fprintf_unfiltered (gdb_stdlog
, " frame_size=%d, found_rp=%d }\n",
2376 frame_size
, found_rp
);
2378 cache
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2379 cache
->base
-= frame_size
;
2380 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2382 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2384 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2385 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2386 cache
->saved_regs
[HPPA_RP_REGNUM
];
2391 rp
= get_frame_register_unsigned (this_frame
, HPPA_RP_REGNUM
);
2392 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2399 hppa_fallback_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2400 struct frame_id
*this_id
)
2402 struct hppa_frame_cache
*info
=
2403 hppa_fallback_frame_cache (this_frame
, this_cache
);
2405 (*this_id
) = frame_id_build (info
->base
, get_frame_func (this_frame
));
2408 static struct value
*
2409 hppa_fallback_frame_prev_register (struct frame_info
*this_frame
,
2410 void **this_cache
, int regnum
)
2412 struct hppa_frame_cache
*info
2413 = hppa_fallback_frame_cache (this_frame
, this_cache
);
2415 return hppa_frame_prev_register_helper (this_frame
,
2416 info
->saved_regs
, regnum
);
2419 static const struct frame_unwind hppa_fallback_frame_unwind
=
2422 default_frame_unwind_stop_reason
,
2423 hppa_fallback_frame_this_id
,
2424 hppa_fallback_frame_prev_register
,
2426 default_frame_sniffer
2429 /* Stub frames, used for all kinds of call stubs. */
2430 struct hppa_stub_unwind_cache
2433 struct trad_frame_saved_reg
*saved_regs
;
2436 static struct hppa_stub_unwind_cache
*
2437 hppa_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2440 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2441 struct hppa_stub_unwind_cache
*info
;
2442 struct unwind_table_entry
*u
;
2445 return (struct hppa_stub_unwind_cache
*) *this_cache
;
2447 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2449 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2451 info
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2453 /* By default we assume that stubs do not change the rp. */
2454 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2460 hppa_stub_frame_this_id (struct frame_info
*this_frame
,
2461 void **this_prologue_cache
,
2462 struct frame_id
*this_id
)
2464 struct hppa_stub_unwind_cache
*info
2465 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2468 *this_id
= frame_id_build (info
->base
, get_frame_func (this_frame
));
2471 static struct value
*
2472 hppa_stub_frame_prev_register (struct frame_info
*this_frame
,
2473 void **this_prologue_cache
, int regnum
)
2475 struct hppa_stub_unwind_cache
*info
2476 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2479 error (_("Requesting registers from null frame."));
2481 return hppa_frame_prev_register_helper (this_frame
,
2482 info
->saved_regs
, regnum
);
2486 hppa_stub_unwind_sniffer (const struct frame_unwind
*self
,
2487 struct frame_info
*this_frame
,
2490 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
2491 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2492 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2495 || (tdep
->in_solib_call_trampoline
!= NULL
2496 && tdep
->in_solib_call_trampoline (gdbarch
, pc
))
2497 || gdbarch_in_solib_return_trampoline (gdbarch
, pc
, NULL
))
2502 static const struct frame_unwind hppa_stub_frame_unwind
= {
2504 default_frame_unwind_stop_reason
,
2505 hppa_stub_frame_this_id
,
2506 hppa_stub_frame_prev_register
,
2508 hppa_stub_unwind_sniffer
2511 static struct frame_id
2512 hppa_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2514 return frame_id_build (get_frame_register_unsigned (this_frame
,
2516 get_frame_pc (this_frame
));
2520 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2525 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2526 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2528 /* If the current instruction is nullified, then we are effectively
2529 still executing the previous instruction. Pretend we are still
2530 there. This is needed when single stepping; if the nullified
2531 instruction is on a different line, we don't want GDB to think
2532 we've stepped onto that line. */
2533 if (ipsw
& 0x00200000)
2539 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2540 Return NULL if no such symbol was found. */
2542 struct bound_minimal_symbol
2543 hppa_lookup_stub_minimal_symbol (const char *name
,
2544 enum unwind_stub_types stub_type
)
2546 struct objfile
*objfile
;
2547 struct minimal_symbol
*msym
;
2548 struct bound_minimal_symbol result
= { NULL
, NULL
};
2550 ALL_MSYMBOLS (objfile
, msym
)
2552 if (strcmp (MSYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2554 struct unwind_table_entry
*u
;
2556 u
= find_unwind_entry (MSYMBOL_VALUE (msym
));
2557 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2559 result
.objfile
= objfile
;
2560 result
.minsym
= msym
;
2570 unwind_command (const char *exp
, int from_tty
)
2573 struct unwind_table_entry
*u
;
2575 /* If we have an expression, evaluate it and use it as the address. */
2577 if (exp
!= 0 && *exp
!= 0)
2578 address
= parse_and_eval_address (exp
);
2582 u
= find_unwind_entry (address
);
2586 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2590 printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u
));
2592 printf_unfiltered ("\tregion_start = %s\n", hex_string (u
->region_start
));
2593 gdb_flush (gdb_stdout
);
2595 printf_unfiltered ("\tregion_end = %s\n", hex_string (u
->region_end
));
2596 gdb_flush (gdb_stdout
);
2598 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2600 printf_unfiltered ("\n\tflags =");
2601 pif (Cannot_unwind
);
2603 pif (Millicode_save_sr0
);
2606 pif (Variable_Frame
);
2607 pif (Separate_Package_Body
);
2608 pif (Frame_Extension_Millicode
);
2609 pif (Stack_Overflow_Check
);
2610 pif (Two_Instruction_SP_Increment
);
2613 pif (cxx_try_catch
);
2614 pif (sched_entry_seq
);
2617 pif (Save_MRP_in_frame
);
2619 pif (Cleanup_defined
);
2620 pif (MPE_XL_interrupt_marker
);
2621 pif (HP_UX_interrupt_marker
);
2625 putchar_unfiltered ('\n');
2627 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2629 pin (Region_description
);
2632 pin (Total_frame_size
);
2634 if (u
->stub_unwind
.stub_type
)
2636 printf_unfiltered ("\tstub type = ");
2637 switch (u
->stub_unwind
.stub_type
)
2640 printf_unfiltered ("long branch\n");
2642 case PARAMETER_RELOCATION
:
2643 printf_unfiltered ("parameter relocation\n");
2646 printf_unfiltered ("export\n");
2649 printf_unfiltered ("import\n");
2652 printf_unfiltered ("import shlib\n");
2655 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2660 /* Return the GDB type object for the "standard" data type of data in
2663 static struct type
*
2664 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2666 if (regnum
< HPPA_FP4_REGNUM
)
2667 return builtin_type (gdbarch
)->builtin_uint32
;
2669 return builtin_type (gdbarch
)->builtin_float
;
2672 static struct type
*
2673 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2675 if (regnum
< HPPA64_FP4_REGNUM
)
2676 return builtin_type (gdbarch
)->builtin_uint64
;
2678 return builtin_type (gdbarch
)->builtin_double
;
2681 /* Return non-zero if REGNUM is not a register available to the user
2682 through ptrace/ttrace. */
2685 hppa32_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2688 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2689 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2690 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2694 hppa32_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2696 /* cr26 and cr27 are readable (but not writable) from userspace. */
2697 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2700 return hppa32_cannot_store_register (gdbarch
, regnum
);
2704 hppa64_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2707 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2708 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2709 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2713 hppa64_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2715 /* cr26 and cr27 are readable (but not writable) from userspace. */
2716 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2719 return hppa64_cannot_store_register (gdbarch
, regnum
);
2723 hppa_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2725 /* The low two bits of the PC on the PA contain the privilege level.
2726 Some genius implementing a (non-GCC) compiler apparently decided
2727 this means that "addresses" in a text section therefore include a
2728 privilege level, and thus symbol tables should contain these bits.
2729 This seems like a bonehead thing to do--anyway, it seems to work
2730 for our purposes to just ignore those bits. */
2732 return (addr
&= ~0x3);
2735 /* Get the ARGIth function argument for the current function. */
2738 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2741 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2744 static enum register_status
2745 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, readable_regcache
*regcache
,
2746 int regnum
, gdb_byte
*buf
)
2748 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2750 enum register_status status
;
2752 status
= regcache
->raw_read (regnum
, &tmp
);
2753 if (status
== REG_VALID
)
2755 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2757 store_unsigned_integer (buf
, sizeof tmp
, byte_order
, tmp
);
2763 hppa_find_global_pointer (struct gdbarch
*gdbarch
, struct value
*function
)
2769 hppa_frame_prev_register_helper (struct frame_info
*this_frame
,
2770 struct trad_frame_saved_reg saved_regs
[],
2773 struct gdbarch
*arch
= get_frame_arch (this_frame
);
2774 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2776 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2778 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2780 struct value
*pcoq_val
=
2781 trad_frame_get_prev_register (this_frame
, saved_regs
,
2782 HPPA_PCOQ_HEAD_REGNUM
);
2784 pc
= extract_unsigned_integer (value_contents_all (pcoq_val
),
2786 return frame_unwind_got_constant (this_frame
, regnum
, pc
+ 4);
2789 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
2793 /* An instruction to match. */
2796 unsigned int data
; /* See if it matches this.... */
2797 unsigned int mask
; /* ... with this mask. */
2800 /* See bfd/elf32-hppa.c */
2801 static struct insn_pattern hppa_long_branch_stub
[] = {
2802 /* ldil LR'xxx,%r1 */
2803 { 0x20200000, 0xffe00000 },
2804 /* be,n RR'xxx(%sr4,%r1) */
2805 { 0xe0202002, 0xffe02002 },
2809 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
2811 { 0xe8200000, 0xffe00000 },
2812 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2813 { 0x28200000, 0xffe00000 },
2814 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2815 { 0xe0202002, 0xffe02002 },
2819 static struct insn_pattern hppa_import_stub
[] = {
2820 /* addil LR'xxx, %dp */
2821 { 0x2b600000, 0xffe00000 },
2822 /* ldw RR'xxx(%r1), %r21 */
2823 { 0x48350000, 0xffffb000 },
2825 { 0xeaa0c000, 0xffffffff },
2826 /* ldw RR'xxx+4(%r1), %r19 */
2827 { 0x48330000, 0xffffb000 },
2831 static struct insn_pattern hppa_import_pic_stub
[] = {
2832 /* addil LR'xxx,%r19 */
2833 { 0x2a600000, 0xffe00000 },
2834 /* ldw RR'xxx(%r1),%r21 */
2835 { 0x48350000, 0xffffb000 },
2837 { 0xeaa0c000, 0xffffffff },
2838 /* ldw RR'xxx+4(%r1),%r19 */
2839 { 0x48330000, 0xffffb000 },
2843 static struct insn_pattern hppa_plt_stub
[] = {
2844 /* b,l 1b, %r20 - 1b is 3 insns before here */
2845 { 0xea9f1fdd, 0xffffffff },
2846 /* depi 0,31,2,%r20 */
2847 { 0xd6801c1e, 0xffffffff },
2851 /* Maximum number of instructions on the patterns above. */
2852 #define HPPA_MAX_INSN_PATTERN_LEN 4
2854 /* Return non-zero if the instructions at PC match the series
2855 described in PATTERN, or zero otherwise. PATTERN is an array of
2856 'struct insn_pattern' objects, terminated by an entry whose mask is
2859 When the match is successful, fill INSN[i] with what PATTERN[i]
2863 hppa_match_insns (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2864 struct insn_pattern
*pattern
, unsigned int *insn
)
2866 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2870 for (i
= 0; pattern
[i
].mask
; i
++)
2872 gdb_byte buf
[HPPA_INSN_SIZE
];
2874 target_read_memory (npc
, buf
, HPPA_INSN_SIZE
);
2875 insn
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
, byte_order
);
2876 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
2885 /* This relaxed version of the insstruction matcher allows us to match
2886 from somewhere inside the pattern, by looking backwards in the
2887 instruction scheme. */
2890 hppa_match_insns_relaxed (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2891 struct insn_pattern
*pattern
, unsigned int *insn
)
2893 int offset
, len
= 0;
2895 while (pattern
[len
].mask
)
2898 for (offset
= 0; offset
< len
; offset
++)
2899 if (hppa_match_insns (gdbarch
, pc
- offset
* HPPA_INSN_SIZE
,
2907 hppa_in_dyncall (CORE_ADDR pc
)
2909 struct unwind_table_entry
*u
;
2911 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2915 return (pc
>= u
->region_start
&& pc
<= u
->region_end
);
2919 hppa_in_solib_call_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2921 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2922 struct unwind_table_entry
*u
;
2924 if (in_plt_section (pc
) || hppa_in_dyncall (pc
))
2927 /* The GNU toolchain produces linker stubs without unwind
2928 information. Since the pattern matching for linker stubs can be
2929 quite slow, so bail out if we do have an unwind entry. */
2931 u
= find_unwind_entry (pc
);
2936 (hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_stub
, insn
)
2937 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_pic_stub
, insn
)
2938 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_long_branch_stub
, insn
)
2939 || hppa_match_insns_relaxed (gdbarch
, pc
,
2940 hppa_long_branch_pic_stub
, insn
));
2943 /* This code skips several kind of "trampolines" used on PA-RISC
2944 systems: $$dyncall, import stubs and PLT stubs. */
2947 hppa_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
2949 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2950 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
2952 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2955 /* $$dyncall handles both PLABELs and direct addresses. */
2956 if (hppa_in_dyncall (pc
))
2958 pc
= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 22);
2960 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2962 pc
= read_memory_typed_address (pc
& ~0x3, func_ptr_type
);
2967 dp_rel
= hppa_match_insns (gdbarch
, pc
, hppa_import_stub
, insn
);
2968 if (dp_rel
|| hppa_match_insns (gdbarch
, pc
, hppa_import_pic_stub
, insn
))
2970 /* Extract the target address from the addil/ldw sequence. */
2971 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
2974 pc
+= get_frame_register_unsigned (frame
, HPPA_DP_REGNUM
);
2976 pc
+= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 19);
2981 if (in_plt_section (pc
))
2983 pc
= read_memory_typed_address (pc
, func_ptr_type
);
2985 /* If the PLT slot has not yet been resolved, the target will be
2987 if (in_plt_section (pc
))
2989 /* Sanity check: are we pointing to the PLT stub? */
2990 if (!hppa_match_insns (gdbarch
, pc
, hppa_plt_stub
, insn
))
2992 warning (_("Cannot resolve PLT stub at %s."),
2993 paddress (gdbarch
, pc
));
2997 /* This should point to the fixup routine. */
2998 pc
= read_memory_typed_address (pc
+ 8, func_ptr_type
);
3006 /* Here is a table of C type sizes on hppa with various compiles
3007 and options. I measured this on PA 9000/800 with HP-UX 11.11
3008 and these compilers:
3010 /usr/ccs/bin/cc HP92453-01 A.11.01.21
3011 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
3012 /opt/aCC/bin/aCC B3910B A.03.45
3013 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3015 cc : 1 2 4 4 8 : 4 8 -- : 4 4
3016 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3017 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3018 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3019 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3020 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3021 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3022 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3026 compiler and options
3027 char, short, int, long, long long
3028 float, double, long double
3031 So all these compilers use either ILP32 or LP64 model.
3032 TODO: gcc has more options so it needs more investigation.
3034 For floating point types, see:
3036 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3037 HP-UX floating-point guide, hpux 11.00
3039 -- chastain 2003-12-18 */
3041 static struct gdbarch
*
3042 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3044 struct gdbarch_tdep
*tdep
;
3045 struct gdbarch
*gdbarch
;
3047 /* find a candidate among the list of pre-declared architectures. */
3048 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3050 return (arches
->gdbarch
);
3052 /* If none found, then allocate and initialize one. */
3053 tdep
= XCNEW (struct gdbarch_tdep
);
3054 gdbarch
= gdbarch_alloc (&info
, tdep
);
3056 /* Determine from the bfd_arch_info structure if we are dealing with
3057 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3058 then default to a 32bit machine. */
3059 if (info
.bfd_arch_info
!= NULL
)
3060 tdep
->bytes_per_address
=
3061 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3063 tdep
->bytes_per_address
= 4;
3065 tdep
->find_global_pointer
= hppa_find_global_pointer
;
3067 /* Some parts of the gdbarch vector depend on whether we are running
3068 on a 32 bits or 64 bits target. */
3069 switch (tdep
->bytes_per_address
)
3072 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3073 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3074 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3075 set_gdbarch_cannot_store_register (gdbarch
,
3076 hppa32_cannot_store_register
);
3077 set_gdbarch_cannot_fetch_register (gdbarch
,
3078 hppa32_cannot_fetch_register
);
3081 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3082 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3083 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3084 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3085 set_gdbarch_cannot_store_register (gdbarch
,
3086 hppa64_cannot_store_register
);
3087 set_gdbarch_cannot_fetch_register (gdbarch
,
3088 hppa64_cannot_fetch_register
);
3091 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
3092 tdep
->bytes_per_address
);
3095 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3096 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3098 /* The following gdbarch vector elements are the same in both ILP32
3099 and LP64, but might show differences some day. */
3100 set_gdbarch_long_long_bit (gdbarch
, 64);
3101 set_gdbarch_long_double_bit (gdbarch
, 128);
3102 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3104 /* The following gdbarch vector elements do not depend on the address
3105 size, or in any other gdbarch element previously set. */
3106 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3107 set_gdbarch_stack_frame_destroyed_p (gdbarch
,
3108 hppa_stack_frame_destroyed_p
);
3109 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
3110 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3111 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3112 set_gdbarch_addr_bits_remove (gdbarch
, hppa_addr_bits_remove
);
3113 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3114 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
3115 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
3117 /* Helper for function argument information. */
3118 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3120 /* When a hardware watchpoint triggers, we'll move the inferior past
3121 it by removing all eventpoints; stepping past the instruction
3122 that caused the trigger; reinserting eventpoints; and checking
3123 whether any watched location changed. */
3124 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3126 /* Inferior function call methods. */
3127 switch (tdep
->bytes_per_address
)
3130 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3131 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3132 set_gdbarch_convert_from_func_ptr_addr
3133 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
3136 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3137 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3140 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3143 /* Struct return methods. */
3144 switch (tdep
->bytes_per_address
)
3147 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3150 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3153 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3156 set_gdbarch_breakpoint_kind_from_pc (gdbarch
, hppa_breakpoint::kind_from_pc
);
3157 set_gdbarch_sw_breakpoint_from_kind (gdbarch
, hppa_breakpoint::bp_from_kind
);
3158 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
3160 /* Frame unwind methods. */
3161 set_gdbarch_dummy_id (gdbarch
, hppa_dummy_id
);
3162 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3164 /* Hook in ABI-specific overrides, if they have been registered. */
3165 gdbarch_init_osabi (info
, gdbarch
);
3167 /* Hook in the default unwinders. */
3168 frame_unwind_append_unwinder (gdbarch
, &hppa_stub_frame_unwind
);
3169 frame_unwind_append_unwinder (gdbarch
, &hppa_frame_unwind
);
3170 frame_unwind_append_unwinder (gdbarch
, &hppa_fallback_frame_unwind
);
3176 hppa_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
3178 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3180 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
3181 tdep
->bytes_per_address
);
3182 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
3186 _initialize_hppa_tdep (void)
3188 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3190 hppa_objfile_priv_data
= register_objfile_data ();
3192 add_cmd ("unwind", class_maintenance
, unwind_command
,
3193 _("Print unwind table entry at given address."),
3194 &maintenanceprintlist
);
3196 /* Debug this files internals. */
3197 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
3198 Set whether hppa target specific debugging information should be displayed."),
3200 Show whether hppa target specific debugging information is displayed."), _("\
3201 This flag controls whether hppa target specific debugging information is\n\
3202 displayed. This information is particularly useful for debugging frame\n\
3203 unwinding problems."),
3205 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
3206 &setdebuglist
, &showdebuglist
);