1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986-2022 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 bool hppa_debug
= false;
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_key
<hppa_objfile_private
,
88 gdb::noop_deleter
<hppa_objfile_private
>>
89 hppa_objfile_priv_data
;
91 /* Get at various relevant fields of an instruction word. */
94 #define MASK_14 0x3fff
95 #define MASK_21 0x1fffff
97 /* Sizes (in bytes) of the native unwind entries. */
98 #define UNWIND_ENTRY_SIZE 16
99 #define STUB_UNWIND_ENTRY_SIZE 8
101 /* Routines to extract various sized constants out of hppa
104 /* This assumes that no garbage lies outside of the lower bits of
108 hppa_sign_extend (unsigned val
, unsigned bits
)
110 return (int) (val
>> (bits
- 1) ? (-(1 << bits
)) | val
: val
);
113 /* For many immediate values the sign bit is the low bit! */
116 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
118 return (int) ((val
& 0x1 ? (-(1 << (bits
- 1))) : 0) | val
>> 1);
121 /* Extract the bits at positions between FROM and TO, using HP's numbering
125 hppa_get_field (unsigned word
, int from
, int to
)
127 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
130 /* Extract the immediate field from a ld{bhw}s instruction. */
133 hppa_extract_5_load (unsigned word
)
135 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
138 /* Extract the immediate field from a break instruction. */
141 hppa_extract_5r_store (unsigned word
)
143 return (word
& MASK_5
);
146 /* Extract the immediate field from a {sr}sm instruction. */
149 hppa_extract_5R_store (unsigned word
)
151 return (word
>> 16 & MASK_5
);
154 /* Extract a 14 bit immediate field. */
157 hppa_extract_14 (unsigned word
)
159 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
162 /* Extract a 21 bit constant. */
165 hppa_extract_21 (unsigned word
)
171 val
= hppa_get_field (word
, 20, 20);
173 val
|= hppa_get_field (word
, 9, 19);
175 val
|= hppa_get_field (word
, 5, 6);
177 val
|= hppa_get_field (word
, 0, 4);
179 val
|= hppa_get_field (word
, 7, 8);
180 return hppa_sign_extend (val
, 21) << 11;
183 /* extract a 17 bit constant from branch instructions, returning the
184 19 bit signed value. */
187 hppa_extract_17 (unsigned word
)
189 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
190 hppa_get_field (word
, 29, 29) << 10 |
191 hppa_get_field (word
, 11, 15) << 11 |
192 (word
& 0x1) << 16, 17) << 2;
196 hppa_symbol_address(const char *sym
)
198 struct bound_minimal_symbol minsym
;
200 minsym
= lookup_minimal_symbol (sym
, NULL
, NULL
);
202 return BMSYMBOL_VALUE_ADDRESS (minsym
);
204 return (CORE_ADDR
)-1;
207 static struct hppa_objfile_private
*
208 hppa_init_objfile_priv_data (struct objfile
*objfile
)
210 hppa_objfile_private
*priv
211 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
, hppa_objfile_private
);
213 hppa_objfile_priv_data
.set (objfile
, priv
);
219 /* Compare the start address for two unwind entries returning 1 if
220 the first address is larger than the second, -1 if the second is
221 larger than the first, and zero if they are equal. */
224 compare_unwind_entries (const void *arg1
, const void *arg2
)
226 const struct unwind_table_entry
*a
= (const struct unwind_table_entry
*) arg1
;
227 const struct unwind_table_entry
*b
= (const struct unwind_table_entry
*) arg2
;
229 if (a
->region_start
> b
->region_start
)
231 else if (a
->region_start
< b
->region_start
)
238 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
240 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
241 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
243 bfd_vma value
= section
->vma
- section
->filepos
;
244 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
246 if (value
< *low_text_segment_address
)
247 *low_text_segment_address
= value
;
252 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
253 asection
*section
, unsigned int entries
,
254 size_t size
, CORE_ADDR text_offset
)
256 /* We will read the unwind entries into temporary memory, then
257 fill in the actual unwind table. */
261 struct gdbarch
*gdbarch
= objfile
->arch ();
262 hppa_gdbarch_tdep
*tdep
= (hppa_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
265 char *buf
= (char *) alloca (size
);
266 CORE_ADDR low_text_segment_address
;
268 /* For ELF targets, then unwinds are supposed to
269 be segment relative offsets instead of absolute addresses.
271 Note that when loading a shared library (text_offset != 0) the
272 unwinds are already relative to the text_offset that will be
274 if (tdep
->is_elf
&& text_offset
== 0)
276 low_text_segment_address
= -1;
278 bfd_map_over_sections (objfile
->obfd
,
279 record_text_segment_lowaddr
,
280 &low_text_segment_address
);
282 text_offset
= low_text_segment_address
;
284 else if (tdep
->solib_get_text_base
)
286 text_offset
= tdep
->solib_get_text_base (objfile
);
289 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
291 /* Now internalize the information being careful to handle host/target
293 for (i
= 0; i
< entries
; i
++)
295 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
297 table
[i
].region_start
+= text_offset
;
299 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
300 table
[i
].region_end
+= text_offset
;
302 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
304 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
305 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
306 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
307 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
308 table
[i
].reserved
= (tmp
>> 26) & 0x1;
309 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
310 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
311 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
312 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
313 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
314 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
315 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
316 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
317 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
318 table
[i
].sr4export
= (tmp
>> 9) & 0x1;
319 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
320 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
321 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
322 table
[i
].reserved1
= (tmp
>> 5) & 0x1;
323 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
324 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
325 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
326 table
[i
].save_r19
= (tmp
>> 1) & 0x1;
327 table
[i
].Cleanup_defined
= tmp
& 0x1;
328 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
330 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
331 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
332 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
333 table
[i
].alloca_frame
= (tmp
>> 28) & 0x1;
334 table
[i
].reserved2
= (tmp
>> 27) & 0x1;
335 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
337 /* Stub unwinds are handled elsewhere. */
338 table
[i
].stub_unwind
.stub_type
= 0;
339 table
[i
].stub_unwind
.padding
= 0;
344 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
345 the object file. This info is used mainly by find_unwind_entry() to find
346 out the stack frame size and frame pointer used by procedures. We put
347 everything on the psymbol obstack in the objfile so that it automatically
348 gets freed when the objfile is destroyed. */
351 read_unwind_info (struct objfile
*objfile
)
353 asection
*unwind_sec
, *stub_unwind_sec
;
354 size_t unwind_size
, stub_unwind_size
, total_size
;
355 unsigned index
, unwind_entries
;
356 unsigned stub_entries
, total_entries
;
357 CORE_ADDR text_offset
;
358 struct hppa_unwind_info
*ui
;
359 struct hppa_objfile_private
*obj_private
;
361 text_offset
= objfile
->text_section_offset ();
362 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
363 sizeof (struct hppa_unwind_info
));
369 /* For reasons unknown the HP PA64 tools generate multiple unwinder
370 sections in a single executable. So we just iterate over every
371 section in the BFD looking for unwinder sections instead of trying
372 to do a lookup with bfd_get_section_by_name.
374 First determine the total size of the unwind tables so that we
375 can allocate memory in a nice big hunk. */
377 for (unwind_sec
= objfile
->obfd
->sections
;
379 unwind_sec
= unwind_sec
->next
)
381 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
382 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
384 unwind_size
= bfd_section_size (unwind_sec
);
385 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
387 total_entries
+= unwind_entries
;
391 /* Now compute the size of the stub unwinds. Note the ELF tools do not
392 use stub unwinds at the current time. */
393 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
397 stub_unwind_size
= bfd_section_size (stub_unwind_sec
);
398 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
402 stub_unwind_size
= 0;
406 /* Compute total number of unwind entries and their total size. */
407 total_entries
+= stub_entries
;
408 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
410 /* Allocate memory for the unwind table. */
411 ui
->table
= (struct unwind_table_entry
*)
412 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
413 ui
->last
= total_entries
- 1;
415 /* Now read in each unwind section and internalize the standard unwind
418 for (unwind_sec
= objfile
->obfd
->sections
;
420 unwind_sec
= unwind_sec
->next
)
422 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
423 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
425 unwind_size
= bfd_section_size (unwind_sec
);
426 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
428 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
429 unwind_entries
, unwind_size
, text_offset
);
430 index
+= unwind_entries
;
434 /* Now read in and internalize the stub unwind entries. */
435 if (stub_unwind_size
> 0)
438 char *buf
= (char *) alloca (stub_unwind_size
);
440 /* Read in the stub unwind entries. */
441 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
442 0, stub_unwind_size
);
444 /* Now convert them into regular unwind entries. */
445 for (i
= 0; i
< stub_entries
; i
++, index
++)
447 /* Clear out the next unwind entry. */
448 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
450 /* Convert offset & size into region_start and region_end.
451 Stuff away the stub type into "reserved" fields. */
452 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
454 ui
->table
[index
].region_start
+= text_offset
;
456 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
459 ui
->table
[index
].region_end
460 = ui
->table
[index
].region_start
+ 4 *
461 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
467 /* Unwind table needs to be kept sorted. */
468 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
469 compare_unwind_entries
);
471 /* Keep a pointer to the unwind information. */
472 obj_private
= hppa_objfile_priv_data
.get (objfile
);
473 if (obj_private
== NULL
)
474 obj_private
= hppa_init_objfile_priv_data (objfile
);
476 obj_private
->unwind_info
= ui
;
479 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
480 of the objfiles seeking the unwind table entry for this PC. Each objfile
481 contains a sorted list of struct unwind_table_entry. Since we do a binary
482 search of the unwind tables, we depend upon them to be sorted. */
484 struct unwind_table_entry
*
485 find_unwind_entry (CORE_ADDR pc
)
487 int first
, middle
, last
;
488 struct hppa_objfile_private
*priv
;
491 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry %s -> ",
494 /* A function at address 0? Not in HP-UX! */
495 if (pc
== (CORE_ADDR
) 0)
498 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
502 for (objfile
*objfile
: current_program_space
->objfiles ())
504 struct hppa_unwind_info
*ui
;
506 priv
= hppa_objfile_priv_data
.get (objfile
);
508 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
512 read_unwind_info (objfile
);
513 priv
= hppa_objfile_priv_data
.get (objfile
);
515 error (_("Internal error reading unwind information."));
516 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
519 /* First, check the cache. */
522 && pc
>= ui
->cache
->region_start
523 && pc
<= ui
->cache
->region_end
)
526 fprintf_unfiltered (gdb_stdlog
, "%s (cached) }\n",
527 hex_string ((uintptr_t) ui
->cache
));
531 /* Not in the cache, do a binary search. */
536 while (first
<= last
)
538 middle
= (first
+ last
) / 2;
539 if (pc
>= ui
->table
[middle
].region_start
540 && pc
<= ui
->table
[middle
].region_end
)
542 ui
->cache
= &ui
->table
[middle
];
544 fprintf_unfiltered (gdb_stdlog
, "%s }\n",
545 hex_string ((uintptr_t) ui
->cache
));
546 return &ui
->table
[middle
];
549 if (pc
< ui
->table
[middle
].region_start
)
557 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
562 /* Implement the stack_frame_destroyed_p gdbarch method.
564 The epilogue is defined here as the area either on the `bv' instruction
565 itself or an instruction which destroys the function's stack frame.
567 We do not assume that the epilogue is at the end of a function as we can
568 also have return sequences in the middle of a function. */
571 hppa_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
573 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
574 unsigned long status
;
578 status
= target_read_memory (pc
, buf
, 4);
582 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
584 /* The most common way to perform a stack adjustment ldo X(sp),sp
585 We are destroying a stack frame if the offset is negative. */
586 if ((inst
& 0xffffc000) == 0x37de0000
587 && hppa_extract_14 (inst
) < 0)
590 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
591 if (((inst
& 0x0fc010e0) == 0x0fc010e0
592 || (inst
& 0x0fc010e0) == 0x0fc010e0)
593 && hppa_extract_14 (inst
) < 0)
596 /* bv %r0(%rp) or bv,n %r0(%rp) */
597 if (inst
== 0xe840c000 || inst
== 0xe840c002)
603 constexpr gdb_byte hppa_break_insn
[] = {0x00, 0x01, 0x00, 0x04};
605 typedef BP_MANIPULATION (hppa_break_insn
) hppa_breakpoint
;
607 /* Return the name of a register. */
610 hppa32_register_name (struct gdbarch
*gdbarch
, int i
)
612 static const char *names
[] = {
613 "flags", "r1", "rp", "r3",
614 "r4", "r5", "r6", "r7",
615 "r8", "r9", "r10", "r11",
616 "r12", "r13", "r14", "r15",
617 "r16", "r17", "r18", "r19",
618 "r20", "r21", "r22", "r23",
619 "r24", "r25", "r26", "dp",
620 "ret0", "ret1", "sp", "r31",
621 "sar", "pcoqh", "pcsqh", "pcoqt",
622 "pcsqt", "eiem", "iir", "isr",
623 "ior", "ipsw", "goto", "sr4",
624 "sr0", "sr1", "sr2", "sr3",
625 "sr5", "sr6", "sr7", "cr0",
626 "cr8", "cr9", "ccr", "cr12",
627 "cr13", "cr24", "cr25", "cr26",
628 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
629 "fpsr", "fpe1", "fpe2", "fpe3",
630 "fpe4", "fpe5", "fpe6", "fpe7",
631 "fr4", "fr4R", "fr5", "fr5R",
632 "fr6", "fr6R", "fr7", "fr7R",
633 "fr8", "fr8R", "fr9", "fr9R",
634 "fr10", "fr10R", "fr11", "fr11R",
635 "fr12", "fr12R", "fr13", "fr13R",
636 "fr14", "fr14R", "fr15", "fr15R",
637 "fr16", "fr16R", "fr17", "fr17R",
638 "fr18", "fr18R", "fr19", "fr19R",
639 "fr20", "fr20R", "fr21", "fr21R",
640 "fr22", "fr22R", "fr23", "fr23R",
641 "fr24", "fr24R", "fr25", "fr25R",
642 "fr26", "fr26R", "fr27", "fr27R",
643 "fr28", "fr28R", "fr29", "fr29R",
644 "fr30", "fr30R", "fr31", "fr31R"
646 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
653 hppa64_register_name (struct gdbarch
*gdbarch
, int i
)
655 static const char *names
[] = {
656 "flags", "r1", "rp", "r3",
657 "r4", "r5", "r6", "r7",
658 "r8", "r9", "r10", "r11",
659 "r12", "r13", "r14", "r15",
660 "r16", "r17", "r18", "r19",
661 "r20", "r21", "r22", "r23",
662 "r24", "r25", "r26", "dp",
663 "ret0", "ret1", "sp", "r31",
664 "sar", "pcoqh", "pcsqh", "pcoqt",
665 "pcsqt", "eiem", "iir", "isr",
666 "ior", "ipsw", "goto", "sr4",
667 "sr0", "sr1", "sr2", "sr3",
668 "sr5", "sr6", "sr7", "cr0",
669 "cr8", "cr9", "ccr", "cr12",
670 "cr13", "cr24", "cr25", "cr26",
671 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
672 "fpsr", "fpe1", "fpe2", "fpe3",
673 "fr4", "fr5", "fr6", "fr7",
674 "fr8", "fr9", "fr10", "fr11",
675 "fr12", "fr13", "fr14", "fr15",
676 "fr16", "fr17", "fr18", "fr19",
677 "fr20", "fr21", "fr22", "fr23",
678 "fr24", "fr25", "fr26", "fr27",
679 "fr28", "fr29", "fr30", "fr31"
681 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
687 /* Map dwarf DBX register numbers to GDB register numbers. */
689 hppa64_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
691 /* The general registers and the sar are the same in both sets. */
692 if (reg
>= 0 && reg
<= 32)
695 /* fr4-fr31 are mapped from 72 in steps of 2. */
696 if (reg
>= 72 && reg
< 72 + 28 * 2 && !(reg
& 1))
697 return HPPA64_FP4_REGNUM
+ (reg
- 72) / 2;
702 /* This function pushes a stack frame with arguments as part of the
703 inferior function calling mechanism.
705 This is the version of the function for the 32-bit PA machines, in
706 which later arguments appear at lower addresses. (The stack always
707 grows towards higher addresses.)
709 We simply allocate the appropriate amount of stack space and put
710 arguments into their proper slots. */
713 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
714 struct regcache
*regcache
, CORE_ADDR bp_addr
,
715 int nargs
, struct value
**args
, CORE_ADDR sp
,
716 function_call_return_method return_method
,
717 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 hppa_gdbarch_tdep
*tdep
= (hppa_gdbarch_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
,
763 value_contents (arg
).data (), TYPE_LENGTH (type
));
764 store_unsigned_integer (param_val
, 4, byte_order
,
765 struct_end
- struct_ptr
);
767 else if (type
->code () == TYPE_CODE_INT
768 || type
->code () == 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
774 (param_val
, param_len
, byte_order
,
775 unpack_long (type
, value_contents (arg
).data ()));
777 else if (type
->code () == 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
).data (), 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
).data (), 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
852 if (return_method
== return_method_struct
)
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 ())
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 ())
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
)
947 for (CORE_ADDR addr
= opd
->addr (); addr
< opd
->endaddr (); addr
+= 2 * 8)
952 if (target_read_memory (addr
, tmp
, sizeof (tmp
)))
954 opdaddr
= extract_unsigned_integer (tmp
, sizeof (tmp
), byte_order
);
965 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
966 struct regcache
*regcache
, CORE_ADDR bp_addr
,
967 int nargs
, struct value
**args
, CORE_ADDR sp
,
968 function_call_return_method return_method
,
969 CORE_ADDR struct_addr
)
971 hppa_gdbarch_tdep
*tdep
= (hppa_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
972 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
976 /* "The outgoing parameter area [...] must be aligned at a 16-byte
978 sp
= align_up (sp
, 16);
980 for (i
= 0; i
< nargs
; i
++)
982 struct value
*arg
= args
[i
];
983 struct type
*type
= value_type (arg
);
984 int len
= TYPE_LENGTH (type
);
985 const bfd_byte
*valbuf
;
989 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
990 offset
= align_up (offset
, 8);
992 if (hppa64_integral_or_pointer_p (type
))
994 /* "Integral scalar parameters smaller than 64 bits are
995 padded on the left (i.e., the value is in the
996 least-significant bits of the 64-bit storage unit, and
997 the high-order bits are undefined)." Therefore we can
998 safely sign-extend them. */
1001 arg
= value_cast (builtin_type (gdbarch
)->builtin_int64
, arg
);
1005 else if (hppa64_floating_p (type
))
1009 /* "Quad-precision (128-bit) floating-point scalar
1010 parameters are aligned on a 16-byte boundary." */
1011 offset
= align_up (offset
, 16);
1013 /* "Double-extended- and quad-precision floating-point
1014 parameters within the first 64 bytes of the parameter
1015 list are always passed in general registers." */
1021 /* "Single-precision (32-bit) floating-point scalar
1022 parameters are padded on the left with 32 bits of
1023 garbage (i.e., the floating-point value is in the
1024 least-significant 32 bits of a 64-bit storage
1029 /* "Single- and double-precision floating-point
1030 parameters in this area are passed according to the
1031 available formal parameter information in a function
1032 prototype. [...] If no prototype is in scope,
1033 floating-point parameters must be passed both in the
1034 corresponding general registers and in the
1035 corresponding floating-point registers." */
1036 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
1038 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
1040 /* "Single-precision floating-point parameters, when
1041 passed in floating-point registers, are passed in
1042 the right halves of the floating point registers;
1043 the left halves are unused." */
1044 regcache
->cooked_write_part (regnum
, offset
% 8, len
,
1045 value_contents (arg
).data ());
1053 /* "Aggregates larger than 8 bytes are aligned on a
1054 16-byte boundary, possibly leaving an unused argument
1055 slot, which is filled with garbage. If necessary,
1056 they are padded on the right (with garbage), to a
1057 multiple of 8 bytes." */
1058 offset
= align_up (offset
, 16);
1062 /* If we are passing a function pointer, make sure we pass a function
1063 descriptor instead of the function entry address. */
1064 if (type
->code () == TYPE_CODE_PTR
1065 && TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_FUNC
)
1067 ULONGEST codeptr
, fptr
;
1069 codeptr
= unpack_long (type
, value_contents (arg
).data ());
1070 fptr
= hppa64_convert_code_addr_to_fptr (gdbarch
, codeptr
);
1071 store_unsigned_integer (fptrbuf
, TYPE_LENGTH (type
), byte_order
,
1077 valbuf
= value_contents (arg
).data ();
1080 /* Always store the argument in memory. */
1081 write_memory (sp
+ offset
, valbuf
, len
);
1083 regnum
= HPPA_ARG0_REGNUM
- offset
/ 8;
1084 while (regnum
> HPPA_ARG0_REGNUM
- 8 && len
> 0)
1086 regcache
->cooked_write_part (regnum
, offset
% 8, std::min (len
, 8),
1088 offset
+= std::min (len
, 8);
1089 valbuf
+= std::min (len
, 8);
1090 len
-= std::min (len
, 8);
1097 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1098 regcache_cooked_write_unsigned (regcache
, HPPA_RET1_REGNUM
, sp
+ 64);
1100 /* Allocate the outgoing parameter area. Make sure the outgoing
1101 parameter area is multiple of 16 bytes in length. */
1102 sp
+= std::max (align_up (offset
, 16), (ULONGEST
) 64);
1104 /* Allocate 32-bytes of scratch space. The documentation doesn't
1105 mention this, but it seems to be needed. */
1108 /* Allocate the frame marker area. */
1111 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1113 if (return_method
== return_method_struct
)
1114 regcache_cooked_write_unsigned (regcache
, HPPA_RET0_REGNUM
, struct_addr
);
1116 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1117 gp
= tdep
->find_global_pointer (gdbarch
, function
);
1119 regcache_cooked_write_unsigned (regcache
, HPPA_DP_REGNUM
, gp
);
1121 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1122 if (!gdbarch_push_dummy_code_p (gdbarch
))
1123 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1125 /* Set up GR30 to hold the stack pointer (sp). */
1126 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, sp
);
1132 /* Handle 32/64-bit struct return conventions. */
1134 static enum return_value_convention
1135 hppa32_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1136 struct type
*type
, struct regcache
*regcache
,
1137 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1139 if (TYPE_LENGTH (type
) <= 2 * 4)
1141 /* The value always lives in the right hand end of the register
1142 (or register pair)? */
1144 int reg
= type
->code () == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
1145 int part
= TYPE_LENGTH (type
) % 4;
1146 /* The left hand register contains only part of the value,
1147 transfer that first so that the rest can be xfered as entire
1148 4-byte registers. */
1151 if (readbuf
!= NULL
)
1152 regcache
->cooked_read_part (reg
, 4 - part
, part
, readbuf
);
1153 if (writebuf
!= NULL
)
1154 regcache
->cooked_write_part (reg
, 4 - part
, part
, writebuf
);
1157 /* Now transfer the remaining register values. */
1158 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
1160 if (readbuf
!= NULL
)
1161 regcache
->cooked_read (reg
, readbuf
+ b
);
1162 if (writebuf
!= NULL
)
1163 regcache
->cooked_write (reg
, writebuf
+ b
);
1166 return RETURN_VALUE_REGISTER_CONVENTION
;
1169 return RETURN_VALUE_STRUCT_CONVENTION
;
1172 static enum return_value_convention
1173 hppa64_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1174 struct type
*type
, struct regcache
*regcache
,
1175 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1177 int len
= TYPE_LENGTH (type
);
1182 /* All return values larger than 128 bits must be aggregate
1184 gdb_assert (!hppa64_integral_or_pointer_p (type
));
1185 gdb_assert (!hppa64_floating_p (type
));
1187 /* "Aggregate return values larger than 128 bits are returned in
1188 a buffer allocated by the caller. The address of the buffer
1189 must be passed in GR 28." */
1190 return RETURN_VALUE_STRUCT_CONVENTION
;
1193 if (hppa64_integral_or_pointer_p (type
))
1195 /* "Integral return values are returned in GR 28. Values
1196 smaller than 64 bits are padded on the left (with garbage)." */
1197 regnum
= HPPA_RET0_REGNUM
;
1200 else if (hppa64_floating_p (type
))
1204 /* "Double-extended- and quad-precision floating-point
1205 values are returned in GRs 28 and 29. The sign,
1206 exponent, and most-significant bits of the mantissa are
1207 returned in GR 28; the least-significant bits of the
1208 mantissa are passed in GR 29. For double-extended
1209 precision values, GR 29 is padded on the right with 48
1210 bits of garbage." */
1211 regnum
= HPPA_RET0_REGNUM
;
1216 /* "Single-precision and double-precision floating-point
1217 return values are returned in FR 4R (single precision) or
1218 FR 4 (double-precision)." */
1219 regnum
= HPPA64_FP4_REGNUM
;
1225 /* "Aggregate return values up to 64 bits in size are returned
1226 in GR 28. Aggregates smaller than 64 bits are left aligned
1227 in the register; the pad bits on the right are undefined."
1229 "Aggregate return values between 65 and 128 bits are returned
1230 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1231 the remaining bits are placed, left aligned, in GR 29. The
1232 pad bits on the right of GR 29 (if any) are undefined." */
1233 regnum
= HPPA_RET0_REGNUM
;
1241 regcache
->cooked_read_part (regnum
, offset
, std::min (len
, 8),
1243 readbuf
+= std::min (len
, 8);
1244 len
-= std::min (len
, 8);
1253 regcache
->cooked_write_part (regnum
, offset
, std::min (len
, 8),
1255 writebuf
+= std::min (len
, 8);
1256 len
-= std::min (len
, 8);
1261 return RETURN_VALUE_REGISTER_CONVENTION
;
1266 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1267 struct target_ops
*targ
)
1271 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1272 CORE_ADDR plabel
= addr
& ~3;
1273 return read_memory_typed_address (plabel
, func_ptr_type
);
1280 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1282 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1284 return align_up (addr
, 64);
1287 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1290 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1292 /* Just always 16-byte align. */
1293 return align_up (addr
, 16);
1297 hppa_read_pc (readable_regcache
*regcache
)
1302 regcache
->cooked_read (HPPA_IPSW_REGNUM
, &ipsw
);
1303 regcache
->cooked_read (HPPA_PCOQ_HEAD_REGNUM
, &pc
);
1305 /* If the current instruction is nullified, then we are effectively
1306 still executing the previous instruction. Pretend we are still
1307 there. This is needed when single stepping; if the nullified
1308 instruction is on a different line, we don't want GDB to think
1309 we've stepped onto that line. */
1310 if (ipsw
& 0x00200000)
1317 hppa_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1319 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pc
);
1320 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4);
1323 /* For the given instruction (INST), return any adjustment it makes
1324 to the stack pointer or zero for no adjustment.
1326 This only handles instructions commonly found in prologues. */
1329 prologue_inst_adjust_sp (unsigned long inst
)
1331 /* This must persist across calls. */
1332 static int save_high21
;
1334 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1335 if ((inst
& 0xffffc000) == 0x37de0000)
1336 return hppa_extract_14 (inst
);
1339 if ((inst
& 0xffe00000) == 0x6fc00000)
1340 return hppa_extract_14 (inst
);
1342 /* std,ma X,D(sp) */
1343 if ((inst
& 0xffe00008) == 0x73c00008)
1344 return (inst
& 0x1 ? -(1 << 13) : 0) | (((inst
>> 4) & 0x3ff) << 3);
1346 /* addil high21,%r30; ldo low11,(%r1),%r30)
1347 save high bits in save_high21 for later use. */
1348 if ((inst
& 0xffe00000) == 0x2bc00000)
1350 save_high21
= hppa_extract_21 (inst
);
1354 if ((inst
& 0xffff0000) == 0x343e0000)
1355 return save_high21
+ hppa_extract_14 (inst
);
1357 /* fstws as used by the HP compilers. */
1358 if ((inst
& 0xffffffe0) == 0x2fd01220)
1359 return hppa_extract_5_load (inst
);
1361 /* No adjustment. */
1365 /* Return nonzero if INST is a branch of some kind, else return zero. */
1368 is_branch (unsigned long inst
)
1397 /* Return the register number for a GR which is saved by INST or
1398 zero if INST does not save a GR.
1403 https://parisc.wiki.kernel.org/images-parisc/6/68/Pa11_acd.pdf
1406 https://parisc.wiki.kernel.org/images-parisc/7/73/Parisc2.0.pdf
1408 According to Table 6-5 of Chapter 6 (Memory Reference Instructions)
1409 on page 106 in parisc 2.0, all instructions for storing values from
1410 the general registers are:
1412 Store: stb, sth, stw, std (according to Chapter 7, they
1413 are only in both "inst >> 26" and "inst >> 6".
1414 Store Absolute: stwa, stda (according to Chapter 7, they are only
1416 Store Bytes: stby, stdby (according to Chapter 7, they are
1417 only in "inst >> 6").
1419 For (inst >> 26), according to Chapter 7:
1421 The effective memory reference address is formed by the addition
1422 of an immediate displacement to a base value.
1424 - stb: 0x18, store a byte from a general register.
1426 - sth: 0x19, store a halfword from a general register.
1428 - stw: 0x1a, store a word from a general register.
1430 - stwm: 0x1b, store a word from a general register and perform base
1431 register modification (2.0 will still treat it as stw).
1433 - std: 0x1c, store a doubleword from a general register (2.0 only).
1435 - stw: 0x1f, store a word from a general register (2.0 only).
1437 For (inst >> 6) when ((inst >> 26) == 0x03), according to Chapter 7:
1439 The effective memory reference address is formed by the addition
1440 of an index value to a base value specified in the instruction.
1442 - stb: 0x08, store a byte from a general register (1.1 calls stbs).
1444 - sth: 0x09, store a halfword from a general register (1.1 calls
1447 - stw: 0x0a, store a word from a general register (1.1 calls stws).
1449 - std: 0x0b: store a doubleword from a general register (2.0 only)
1451 Implement fast byte moves (stores) to unaligned word or doubleword
1454 - stby: 0x0c, for unaligned word (1.1 calls stbys).
1456 - stdby: 0x0d for unaligned doubleword (2.0 only).
1458 Store a word or doubleword using an absolute memory address formed
1459 using short or long displacement or indexed
1461 - stwa: 0x0e, store a word from a general register to an absolute
1462 address (1.0 calls stwas).
1464 - stda: 0x0f, store a doubleword from a general register to an
1465 absolute address (2.0 only). */
1468 inst_saves_gr (unsigned long inst
)
1470 switch ((inst
>> 26) & 0x0f)
1473 switch ((inst
>> 6) & 0x0f)
1483 return hppa_extract_5R_store (inst
);
1492 /* no 0x1d or 0x1e -- according to parisc 2.0 document */
1494 return hppa_extract_5R_store (inst
);
1500 /* Return the register number for a FR which is saved by INST or
1501 zero it INST does not save a FR.
1503 Note we only care about full 64bit register stores (that's the only
1504 kind of stores the prologue will use).
1506 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1509 inst_saves_fr (unsigned long inst
)
1511 /* Is this an FSTD? */
1512 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1513 return hppa_extract_5r_store (inst
);
1514 if ((inst
& 0xfc000002) == 0x70000002)
1515 return hppa_extract_5R_store (inst
);
1516 /* Is this an FSTW? */
1517 if ((inst
& 0xfc00df80) == 0x24001200)
1518 return hppa_extract_5r_store (inst
);
1519 if ((inst
& 0xfc000002) == 0x7c000000)
1520 return hppa_extract_5R_store (inst
);
1524 /* Advance PC across any function entry prologue instructions
1525 to reach some "real" code.
1527 Use information in the unwind table to determine what exactly should
1528 be in the prologue. */
1532 skip_prologue_hard_way (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1533 int stop_before_branch
)
1535 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1537 CORE_ADDR orig_pc
= pc
;
1538 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1539 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1540 struct unwind_table_entry
*u
;
1541 int final_iteration
;
1547 u
= find_unwind_entry (pc
);
1551 /* If we are not at the beginning of a function, then return now. */
1552 if ((pc
& ~0x3) != u
->region_start
)
1555 /* This is how much of a frame adjustment we need to account for. */
1556 stack_remaining
= u
->Total_frame_size
<< 3;
1558 /* Magic register saves we want to know about. */
1559 save_rp
= u
->Save_RP
;
1560 save_sp
= u
->Save_SP
;
1562 /* An indication that args may be stored into the stack. Unfortunately
1563 the HPUX compilers tend to set this in cases where no args were
1567 /* Turn the Entry_GR field into a bitmask. */
1569 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1571 /* Frame pointer gets saved into a special location. */
1572 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1575 save_gr
|= (1 << i
);
1577 save_gr
&= ~restart_gr
;
1579 /* Turn the Entry_FR field into a bitmask too. */
1581 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1582 save_fr
|= (1 << i
);
1583 save_fr
&= ~restart_fr
;
1585 final_iteration
= 0;
1587 /* Loop until we find everything of interest or hit a branch.
1589 For unoptimized GCC code and for any HP CC code this will never ever
1590 examine any user instructions.
1592 For optimized GCC code we're faced with problems. GCC will schedule
1593 its prologue and make prologue instructions available for delay slot
1594 filling. The end result is user code gets mixed in with the prologue
1595 and a prologue instruction may be in the delay slot of the first branch
1598 Some unexpected things are expected with debugging optimized code, so
1599 we allow this routine to walk past user instructions in optimized
1601 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1604 unsigned int reg_num
;
1605 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1606 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1608 /* Save copies of all the triggers so we can compare them later
1610 old_save_gr
= save_gr
;
1611 old_save_fr
= save_fr
;
1612 old_save_rp
= save_rp
;
1613 old_save_sp
= save_sp
;
1614 old_stack_remaining
= stack_remaining
;
1616 status
= target_read_memory (pc
, buf
, 4);
1617 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1623 /* Note the interesting effects of this instruction. */
1624 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1626 /* There are limited ways to store the return pointer into the
1628 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1631 /* These are the only ways we save SP into the stack. At this time
1632 the HP compilers never bother to save SP into the stack. */
1633 if ((inst
& 0xffffc000) == 0x6fc10000
1634 || (inst
& 0xffffc00c) == 0x73c10008)
1637 /* Are we loading some register with an offset from the argument
1639 if ((inst
& 0xffe00000) == 0x37a00000
1640 || (inst
& 0xffffffe0) == 0x081d0240)
1646 /* Account for general and floating-point register saves. */
1647 reg_num
= inst_saves_gr (inst
);
1648 save_gr
&= ~(1 << reg_num
);
1650 /* Ugh. Also account for argument stores into the stack.
1651 Unfortunately args_stored only tells us that some arguments
1652 where stored into the stack. Not how many or what kind!
1654 This is a kludge as on the HP compiler sets this bit and it
1655 never does prologue scheduling. So once we see one, skip past
1656 all of them. We have similar code for the fp arg stores below.
1658 FIXME. Can still die if we have a mix of GR and FR argument
1660 if (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1663 while (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1667 status
= target_read_memory (pc
, buf
, 4);
1668 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1671 reg_num
= inst_saves_gr (inst
);
1677 reg_num
= inst_saves_fr (inst
);
1678 save_fr
&= ~(1 << reg_num
);
1680 status
= target_read_memory (pc
+ 4, buf
, 4);
1681 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1687 /* We've got to be read to handle the ldo before the fp register
1689 if ((inst
& 0xfc000000) == 0x34000000
1690 && inst_saves_fr (next_inst
) >= 4
1691 && inst_saves_fr (next_inst
)
1692 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1694 /* So we drop into the code below in a reasonable state. */
1695 reg_num
= inst_saves_fr (next_inst
);
1699 /* Ugh. Also account for argument stores into the stack.
1700 This is a kludge as on the HP compiler sets this bit and it
1701 never does prologue scheduling. So once we see one, skip past
1704 && reg_num
<= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1708 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1711 status
= target_read_memory (pc
, buf
, 4);
1712 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1715 if ((inst
& 0xfc000000) != 0x34000000)
1717 status
= target_read_memory (pc
+ 4, buf
, 4);
1718 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1721 reg_num
= inst_saves_fr (next_inst
);
1727 /* Quit if we hit any kind of branch. This can happen if a prologue
1728 instruction is in the delay slot of the first call/branch. */
1729 if (is_branch (inst
) && stop_before_branch
)
1732 /* What a crock. The HP compilers set args_stored even if no
1733 arguments were stored into the stack (boo hiss). This could
1734 cause this code to then skip a bunch of user insns (up to the
1737 To combat this we try to identify when args_stored was bogusly
1738 set and clear it. We only do this when args_stored is nonzero,
1739 all other resources are accounted for, and nothing changed on
1742 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1743 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1744 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1745 && old_stack_remaining
== stack_remaining
)
1751 /* !stop_before_branch, so also look at the insn in the delay slot
1753 if (final_iteration
)
1755 if (is_branch (inst
))
1756 final_iteration
= 1;
1759 /* We've got a tentative location for the end of the prologue. However
1760 because of limitations in the unwind descriptor mechanism we may
1761 have went too far into user code looking for the save of a register
1762 that does not exist. So, if there registers we expected to be saved
1763 but never were, mask them out and restart.
1765 This should only happen in optimized code, and should be very rare. */
1766 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1769 restart_gr
= save_gr
;
1770 restart_fr
= save_fr
;
1778 /* Return the address of the PC after the last prologue instruction if
1779 we can determine it from the debug symbols. Else return zero. */
1782 after_prologue (CORE_ADDR pc
)
1784 struct symtab_and_line sal
;
1785 CORE_ADDR func_addr
, func_end
;
1787 /* If we can not find the symbol in the partial symbol table, then
1788 there is no hope we can determine the function's start address
1790 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1793 /* Get the line associated with FUNC_ADDR. */
1794 sal
= find_pc_line (func_addr
, 0);
1796 /* There are only two cases to consider. First, the end of the source line
1797 is within the function bounds. In that case we return the end of the
1798 source line. Second is the end of the source line extends beyond the
1799 bounds of the current function. We need to use the slow code to
1800 examine instructions in that case.
1802 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1803 the wrong thing to do. In fact, it should be entirely possible for this
1804 function to always return zero since the slow instruction scanning code
1805 is supposed to *always* work. If it does not, then it is a bug. */
1806 if (sal
.end
< func_end
)
1812 /* To skip prologues, I use this predicate. Returns either PC itself
1813 if the code at PC does not look like a function prologue; otherwise
1814 returns an address that (if we're lucky) follows the prologue.
1816 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1817 It doesn't necessarily skips all the insns in the prologue. In fact
1818 we might not want to skip all the insns because a prologue insn may
1819 appear in the delay slot of the first branch, and we don't want to
1820 skip over the branch in that case. */
1823 hppa_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1825 CORE_ADDR post_prologue_pc
;
1827 /* See if we can determine the end of the prologue via the symbol table.
1828 If so, then return either PC, or the PC after the prologue, whichever
1831 post_prologue_pc
= after_prologue (pc
);
1833 /* If after_prologue returned a useful address, then use it. Else
1834 fall back on the instruction skipping code.
1836 Some folks have claimed this causes problems because the breakpoint
1837 may be the first instruction of the prologue. If that happens, then
1838 the instruction skipping code has a bug that needs to be fixed. */
1839 if (post_prologue_pc
!= 0)
1840 return std::max (pc
, post_prologue_pc
);
1842 return (skip_prologue_hard_way (gdbarch
, pc
, 1));
1845 /* Return an unwind entry that falls within the frame's code block. */
1847 static struct unwind_table_entry
*
1848 hppa_find_unwind_entry_in_block (struct frame_info
*this_frame
)
1850 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
1852 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1853 result of get_frame_address_in_block implies a problem.
1854 The bits should have been removed earlier, before the return
1855 value of gdbarch_unwind_pc. That might be happening already;
1856 if it isn't, it should be fixed. Then this call can be
1858 pc
= gdbarch_addr_bits_remove (get_frame_arch (this_frame
), pc
);
1859 return find_unwind_entry (pc
);
1862 struct hppa_frame_cache
1865 trad_frame_saved_reg
*saved_regs
;
1868 static struct hppa_frame_cache
*
1869 hppa_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1871 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1872 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1873 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1874 struct hppa_frame_cache
*cache
;
1878 struct unwind_table_entry
*u
;
1879 CORE_ADDR prologue_end
;
1884 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1885 frame_relative_level(this_frame
));
1887 if ((*this_cache
) != NULL
)
1890 fprintf_unfiltered (gdb_stdlog
, "base=%s (cached) }",
1891 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
1892 return (struct hppa_frame_cache
*) (*this_cache
);
1894 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1895 (*this_cache
) = cache
;
1896 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1899 u
= hppa_find_unwind_entry_in_block (this_frame
);
1903 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1904 return (struct hppa_frame_cache
*) (*this_cache
);
1907 /* Turn the Entry_GR field into a bitmask. */
1909 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1911 /* Frame pointer gets saved into a special location. */
1912 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1915 saved_gr_mask
|= (1 << i
);
1918 /* Turn the Entry_FR field into a bitmask too. */
1920 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1921 saved_fr_mask
|= (1 << i
);
1923 /* Loop until we find everything of interest or hit a branch.
1925 For unoptimized GCC code and for any HP CC code this will never ever
1926 examine any user instructions.
1928 For optimized GCC code we're faced with problems. GCC will schedule
1929 its prologue and make prologue instructions available for delay slot
1930 filling. The end result is user code gets mixed in with the prologue
1931 and a prologue instruction may be in the delay slot of the first branch
1934 Some unexpected things are expected with debugging optimized code, so
1935 we allow this routine to walk past user instructions in optimized
1938 int final_iteration
= 0;
1939 CORE_ADDR pc
, start_pc
, end_pc
;
1940 int looking_for_sp
= u
->Save_SP
;
1941 int looking_for_rp
= u
->Save_RP
;
1944 /* We have to use skip_prologue_hard_way instead of just
1945 skip_prologue_using_sal, in case we stepped into a function without
1946 symbol information. hppa_skip_prologue also bounds the returned
1947 pc by the passed in pc, so it will not return a pc in the next
1950 We used to call hppa_skip_prologue to find the end of the prologue,
1951 but if some non-prologue instructions get scheduled into the prologue,
1952 and the program is compiled with debug information, the "easy" way
1953 in hppa_skip_prologue will return a prologue end that is too early
1954 for us to notice any potential frame adjustments. */
1956 /* We used to use get_frame_func to locate the beginning of the
1957 function to pass to skip_prologue. However, when objects are
1958 compiled without debug symbols, get_frame_func can return the wrong
1959 function (or 0). We can do better than that by using unwind records.
1960 This only works if the Region_description of the unwind record
1961 indicates that it includes the entry point of the function.
1962 HP compilers sometimes generate unwind records for regions that
1963 do not include the entry or exit point of a function. GNU tools
1966 if ((u
->Region_description
& 0x2) == 0)
1967 start_pc
= u
->region_start
;
1969 start_pc
= get_frame_func (this_frame
);
1971 prologue_end
= skip_prologue_hard_way (gdbarch
, start_pc
, 0);
1972 end_pc
= get_frame_pc (this_frame
);
1974 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1975 end_pc
= prologue_end
;
1980 ((saved_gr_mask
|| saved_fr_mask
1981 || looking_for_sp
|| looking_for_rp
1982 || frame_size
< (u
->Total_frame_size
<< 3))
1990 if (!safe_frame_unwind_memory (this_frame
, pc
, buf4
))
1992 error (_("Cannot read instruction at %s."),
1993 paddress (gdbarch
, pc
));
1994 return (struct hppa_frame_cache
*) (*this_cache
);
1997 inst
= extract_unsigned_integer (buf4
, sizeof buf4
, byte_order
);
1999 /* Note the interesting effects of this instruction. */
2000 frame_size
+= prologue_inst_adjust_sp (inst
);
2002 /* There are limited ways to store the return pointer into the
2004 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2007 cache
->saved_regs
[HPPA_RP_REGNUM
].set_addr (-20);
2009 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
2012 cache
->saved_regs
[HPPA_RP_REGNUM
].set_addr (-24);
2014 else if (inst
== 0x0fc212c1
2015 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2018 cache
->saved_regs
[HPPA_RP_REGNUM
].set_addr (-16);
2021 /* Check to see if we saved SP into the stack. This also
2022 happens to indicate the location of the saved frame
2024 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
2025 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2028 cache
->saved_regs
[HPPA_FP_REGNUM
].set_addr (0);
2030 else if (inst
== 0x08030241) /* copy %r3, %r1 */
2035 /* Account for general and floating-point register saves. */
2036 reg
= inst_saves_gr (inst
);
2037 if (reg
>= 3 && reg
<= 18
2038 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
2040 saved_gr_mask
&= ~(1 << reg
);
2041 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
2042 /* stwm with a positive displacement is a _post_
2044 cache
->saved_regs
[reg
].set_addr (0);
2045 else if ((inst
& 0xfc00000c) == 0x70000008)
2046 /* A std has explicit post_modify forms. */
2047 cache
->saved_regs
[reg
].set_addr (0);
2052 if ((inst
>> 26) == 0x1c)
2053 offset
= (inst
& 0x1 ? -(1 << 13) : 0)
2054 | (((inst
>> 4) & 0x3ff) << 3);
2055 else if ((inst
>> 26) == 0x03)
2056 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
2058 offset
= hppa_extract_14 (inst
);
2060 /* Handle code with and without frame pointers. */
2062 cache
->saved_regs
[reg
].set_addr (offset
);
2064 cache
->saved_regs
[reg
].set_addr ((u
->Total_frame_size
<< 3)
2069 /* GCC handles callee saved FP regs a little differently.
2071 It emits an instruction to put the value of the start of
2072 the FP store area into %r1. It then uses fstds,ma with a
2073 basereg of %r1 for the stores.
2075 HP CC emits them at the current stack pointer modifying the
2076 stack pointer as it stores each register. */
2078 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2079 if ((inst
& 0xffffc000) == 0x34610000
2080 || (inst
& 0xffffc000) == 0x37c10000)
2081 fp_loc
= hppa_extract_14 (inst
);
2083 reg
= inst_saves_fr (inst
);
2084 if (reg
>= 12 && reg
<= 21)
2086 /* Note +4 braindamage below is necessary because the FP
2087 status registers are internally 8 registers rather than
2088 the expected 4 registers. */
2089 saved_fr_mask
&= ~(1 << reg
);
2092 /* 1st HP CC FP register store. After this
2093 instruction we've set enough state that the GCC and
2094 HPCC code are both handled in the same manner. */
2095 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].set_addr (0);
2100 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].set_addr (fp_loc
);
2105 /* Quit if we hit any kind of branch the previous iteration. */
2106 if (final_iteration
)
2108 /* We want to look precisely one instruction beyond the branch
2109 if we have not found everything yet. */
2110 if (is_branch (inst
))
2111 final_iteration
= 1;
2116 /* The frame base always represents the value of %sp at entry to
2117 the current function (and is thus equivalent to the "saved"
2119 CORE_ADDR this_sp
= get_frame_register_unsigned (this_frame
,
2124 fprintf_unfiltered (gdb_stdlog
, " (this_sp=%s, pc=%s, "
2125 "prologue_end=%s) ",
2126 paddress (gdbarch
, this_sp
),
2127 paddress (gdbarch
, get_frame_pc (this_frame
)),
2128 paddress (gdbarch
, prologue_end
));
2130 /* Check to see if a frame pointer is available, and use it for
2131 frame unwinding if it is.
2133 There are some situations where we need to rely on the frame
2134 pointer to do stack unwinding. For example, if a function calls
2135 alloca (), the stack pointer can get adjusted inside the body of
2136 the function. In this case, the ABI requires that the compiler
2137 maintain a frame pointer for the function.
2139 The unwind record has a flag (alloca_frame) that indicates that
2140 a function has a variable frame; unfortunately, gcc/binutils
2141 does not set this flag. Instead, whenever a frame pointer is used
2142 and saved on the stack, the Save_SP flag is set. We use this to
2143 decide whether to use the frame pointer for unwinding.
2145 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2146 instead of Save_SP. */
2148 fp
= get_frame_register_unsigned (this_frame
, HPPA_FP_REGNUM
);
2150 if (u
->alloca_frame
)
2151 fp
-= u
->Total_frame_size
<< 3;
2153 if (get_frame_pc (this_frame
) >= prologue_end
2154 && (u
->Save_SP
|| u
->alloca_frame
) && fp
!= 0)
2159 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [frame pointer]",
2160 paddress (gdbarch
, cache
->base
));
2163 && cache
->saved_regs
[HPPA_SP_REGNUM
].is_addr ())
2165 /* Both we're expecting the SP to be saved and the SP has been
2166 saved. The entry SP value is saved at this frame's SP
2168 cache
->base
= read_memory_integer (this_sp
, word_size
, byte_order
);
2171 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [saved]",
2172 paddress (gdbarch
, cache
->base
));
2176 /* The prologue has been slowly allocating stack space. Adjust
2178 cache
->base
= this_sp
- frame_size
;
2180 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [unwind adjust]",
2181 paddress (gdbarch
, cache
->base
));
2184 cache
->saved_regs
[HPPA_SP_REGNUM
].set_value (cache
->base
);
2187 /* The PC is found in the "return register", "Millicode" uses "r31"
2188 as the return register while normal code uses "rp". */
2191 if (cache
->saved_regs
[31].is_addr ())
2193 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2195 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2199 ULONGEST r31
= get_frame_register_unsigned (this_frame
, 31);
2200 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].set_value (r31
);
2202 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2207 if (cache
->saved_regs
[HPPA_RP_REGNUM
].is_addr ())
2209 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2210 cache
->saved_regs
[HPPA_RP_REGNUM
];
2212 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2216 ULONGEST rp
= get_frame_register_unsigned (this_frame
,
2218 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].set_value (rp
);
2220 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2224 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2225 frame. However, there is a one-insn window where we haven't saved it
2226 yet, but we've already clobbered it. Detect this case and fix it up.
2228 The prologue sequence for frame-pointer functions is:
2229 0: stw %rp, -20(%sp)
2232 c: stw,ma %r1, XX(%sp)
2234 So if we are at offset c, the r3 value that we want is not yet saved
2235 on the stack, but it's been overwritten. The prologue analyzer will
2236 set fp_in_r1 when it sees the copy insn so we know to get the value
2238 if (u
->Save_SP
&& !cache
->saved_regs
[HPPA_FP_REGNUM
].is_addr ()
2241 ULONGEST r1
= get_frame_register_unsigned (this_frame
, 1);
2242 cache
->saved_regs
[HPPA_FP_REGNUM
].set_value (r1
);
2246 /* Convert all the offsets into addresses. */
2248 for (reg
= 0; reg
< gdbarch_num_regs (gdbarch
); reg
++)
2250 if (cache
->saved_regs
[reg
].is_addr ())
2251 cache
->saved_regs
[reg
].set_addr (cache
->saved_regs
[reg
].addr ()
2257 hppa_gdbarch_tdep
*tdep
= (hppa_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
2259 if (tdep
->unwind_adjust_stub
)
2260 tdep
->unwind_adjust_stub (this_frame
, cache
->base
, cache
->saved_regs
);
2264 fprintf_unfiltered (gdb_stdlog
, "base=%s }",
2265 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
2266 return (struct hppa_frame_cache
*) (*this_cache
);
2270 hppa_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2271 struct frame_id
*this_id
)
2273 struct hppa_frame_cache
*info
;
2274 struct unwind_table_entry
*u
;
2276 info
= hppa_frame_cache (this_frame
, this_cache
);
2277 u
= hppa_find_unwind_entry_in_block (this_frame
);
2279 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2282 static struct value
*
2283 hppa_frame_prev_register (struct frame_info
*this_frame
,
2284 void **this_cache
, int regnum
)
2286 struct hppa_frame_cache
*info
= hppa_frame_cache (this_frame
, this_cache
);
2288 return hppa_frame_prev_register_helper (this_frame
,
2289 info
->saved_regs
, regnum
);
2293 hppa_frame_unwind_sniffer (const struct frame_unwind
*self
,
2294 struct frame_info
*this_frame
, void **this_cache
)
2296 if (hppa_find_unwind_entry_in_block (this_frame
))
2302 static const struct frame_unwind hppa_frame_unwind
=
2304 "hppa unwind table",
2306 default_frame_unwind_stop_reason
,
2308 hppa_frame_prev_register
,
2310 hppa_frame_unwind_sniffer
2313 /* This is a generic fallback frame unwinder that kicks in if we fail all
2314 the other ones. Normally we would expect the stub and regular unwinder
2315 to work, but in some cases we might hit a function that just doesn't
2316 have any unwind information available. In this case we try to do
2317 unwinding solely based on code reading. This is obviously going to be
2318 slow, so only use this as a last resort. Currently this will only
2319 identify the stack and pc for the frame. */
2321 static struct hppa_frame_cache
*
2322 hppa_fallback_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
2324 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2325 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2326 struct hppa_frame_cache
*cache
;
2327 unsigned int frame_size
= 0;
2332 fprintf_unfiltered (gdb_stdlog
,
2333 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2334 frame_relative_level (this_frame
));
2336 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2337 (*this_cache
) = cache
;
2338 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2340 start_pc
= get_frame_func (this_frame
);
2343 CORE_ADDR cur_pc
= get_frame_pc (this_frame
);
2346 for (pc
= start_pc
; pc
< cur_pc
; pc
+= 4)
2350 insn
= read_memory_unsigned_integer (pc
, 4, byte_order
);
2351 frame_size
+= prologue_inst_adjust_sp (insn
);
2353 /* There are limited ways to store the return pointer into the
2355 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2357 cache
->saved_regs
[HPPA_RP_REGNUM
].set_addr (-20);
2360 else if (insn
== 0x0fc212c1
2361 || insn
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2363 cache
->saved_regs
[HPPA_RP_REGNUM
].set_addr (-16);
2370 fprintf_unfiltered (gdb_stdlog
, " frame_size=%d, found_rp=%d }\n",
2371 frame_size
, found_rp
);
2373 cache
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2374 cache
->base
-= frame_size
;
2375 cache
->saved_regs
[HPPA_SP_REGNUM
].set_value (cache
->base
);
2377 if (cache
->saved_regs
[HPPA_RP_REGNUM
].is_addr ())
2379 cache
->saved_regs
[HPPA_RP_REGNUM
].set_addr (cache
->saved_regs
[HPPA_RP_REGNUM
].addr ()
2381 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2382 cache
->saved_regs
[HPPA_RP_REGNUM
];
2387 rp
= get_frame_register_unsigned (this_frame
, HPPA_RP_REGNUM
);
2388 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].set_value (rp
);
2395 hppa_fallback_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2396 struct frame_id
*this_id
)
2398 struct hppa_frame_cache
*info
=
2399 hppa_fallback_frame_cache (this_frame
, this_cache
);
2401 (*this_id
) = frame_id_build (info
->base
, get_frame_func (this_frame
));
2404 static struct value
*
2405 hppa_fallback_frame_prev_register (struct frame_info
*this_frame
,
2406 void **this_cache
, int regnum
)
2408 struct hppa_frame_cache
*info
2409 = hppa_fallback_frame_cache (this_frame
, this_cache
);
2411 return hppa_frame_prev_register_helper (this_frame
,
2412 info
->saved_regs
, regnum
);
2415 static const struct frame_unwind hppa_fallback_frame_unwind
=
2419 default_frame_unwind_stop_reason
,
2420 hppa_fallback_frame_this_id
,
2421 hppa_fallback_frame_prev_register
,
2423 default_frame_sniffer
2426 /* Stub frames, used for all kinds of call stubs. */
2427 struct hppa_stub_unwind_cache
2430 trad_frame_saved_reg
*saved_regs
;
2433 static struct hppa_stub_unwind_cache
*
2434 hppa_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2437 struct hppa_stub_unwind_cache
*info
;
2440 return (struct hppa_stub_unwind_cache
*) *this_cache
;
2442 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2444 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2446 info
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2448 /* By default we assume that stubs do not change the rp. */
2449 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].set_realreg (HPPA_RP_REGNUM
);
2455 hppa_stub_frame_this_id (struct frame_info
*this_frame
,
2456 void **this_prologue_cache
,
2457 struct frame_id
*this_id
)
2459 struct hppa_stub_unwind_cache
*info
2460 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2463 *this_id
= frame_id_build (info
->base
, get_frame_func (this_frame
));
2466 static struct value
*
2467 hppa_stub_frame_prev_register (struct frame_info
*this_frame
,
2468 void **this_prologue_cache
, int regnum
)
2470 struct hppa_stub_unwind_cache
*info
2471 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2474 error (_("Requesting registers from null frame."));
2476 return hppa_frame_prev_register_helper (this_frame
,
2477 info
->saved_regs
, regnum
);
2481 hppa_stub_unwind_sniffer (const struct frame_unwind
*self
,
2482 struct frame_info
*this_frame
,
2485 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
2486 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2487 hppa_gdbarch_tdep
*tdep
= (hppa_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
2490 || (tdep
->in_solib_call_trampoline
!= NULL
2491 && tdep
->in_solib_call_trampoline (gdbarch
, pc
))
2492 || gdbarch_in_solib_return_trampoline (gdbarch
, pc
, NULL
))
2497 static const struct frame_unwind hppa_stub_frame_unwind
= {
2500 default_frame_unwind_stop_reason
,
2501 hppa_stub_frame_this_id
,
2502 hppa_stub_frame_prev_register
,
2504 hppa_stub_unwind_sniffer
2508 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2513 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2514 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2516 /* If the current instruction is nullified, then we are effectively
2517 still executing the previous instruction. Pretend we are still
2518 there. This is needed when single stepping; if the nullified
2519 instruction is on a different line, we don't want GDB to think
2520 we've stepped onto that line. */
2521 if (ipsw
& 0x00200000)
2527 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2528 Return NULL if no such symbol was found. */
2530 struct bound_minimal_symbol
2531 hppa_lookup_stub_minimal_symbol (const char *name
,
2532 enum unwind_stub_types stub_type
)
2534 struct bound_minimal_symbol result
= { NULL
, NULL
};
2536 for (objfile
*objfile
: current_program_space
->objfiles ())
2538 for (minimal_symbol
*msym
: objfile
->msymbols ())
2540 if (strcmp (msym
->linkage_name (), name
) == 0)
2542 struct unwind_table_entry
*u
;
2544 u
= find_unwind_entry (MSYMBOL_VALUE (msym
));
2545 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2547 result
.objfile
= objfile
;
2548 result
.minsym
= msym
;
2559 unwind_command (const char *exp
, int from_tty
)
2562 struct unwind_table_entry
*u
;
2564 /* If we have an expression, evaluate it and use it as the address. */
2566 if (exp
!= 0 && *exp
!= 0)
2567 address
= parse_and_eval_address (exp
);
2571 u
= find_unwind_entry (address
);
2575 printf_filtered ("Can't find unwind table entry for %s\n", exp
);
2579 printf_filtered ("unwind_table_entry (%s):\n", host_address_to_string (u
));
2581 printf_filtered ("\tregion_start = %s\n", hex_string (u
->region_start
));
2583 printf_filtered ("\tregion_end = %s\n", hex_string (u
->region_end
));
2585 #define pif(FLD) if (u->FLD) printf_filtered (" "#FLD);
2587 printf_filtered ("\n\tflags =");
2588 pif (Cannot_unwind
);
2590 pif (Millicode_save_sr0
);
2593 pif (Variable_Frame
);
2594 pif (Separate_Package_Body
);
2595 pif (Frame_Extension_Millicode
);
2596 pif (Stack_Overflow_Check
);
2597 pif (Two_Instruction_SP_Increment
);
2600 pif (cxx_try_catch
);
2601 pif (sched_entry_seq
);
2604 pif (Save_MRP_in_frame
);
2606 pif (Cleanup_defined
);
2607 pif (MPE_XL_interrupt_marker
);
2608 pif (HP_UX_interrupt_marker
);
2612 putchar_filtered ('\n');
2614 #define pin(FLD) printf_filtered ("\t"#FLD" = 0x%x\n", u->FLD);
2616 pin (Region_description
);
2619 pin (Total_frame_size
);
2621 if (u
->stub_unwind
.stub_type
)
2623 printf_filtered ("\tstub type = ");
2624 switch (u
->stub_unwind
.stub_type
)
2627 printf_filtered ("long branch\n");
2629 case PARAMETER_RELOCATION
:
2630 printf_filtered ("parameter relocation\n");
2633 printf_filtered ("export\n");
2636 printf_filtered ("import\n");
2639 printf_filtered ("import shlib\n");
2642 printf_filtered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2647 /* Return the GDB type object for the "standard" data type of data in
2650 static struct type
*
2651 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2653 if (regnum
< HPPA_FP4_REGNUM
)
2654 return builtin_type (gdbarch
)->builtin_uint32
;
2656 return builtin_type (gdbarch
)->builtin_float
;
2659 static struct type
*
2660 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2662 if (regnum
< HPPA64_FP4_REGNUM
)
2663 return builtin_type (gdbarch
)->builtin_uint64
;
2665 return builtin_type (gdbarch
)->builtin_double
;
2668 /* Return non-zero if REGNUM is not a register available to the user
2669 through ptrace/ttrace. */
2672 hppa32_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2675 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2676 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2677 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2681 hppa32_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2683 /* cr26 and cr27 are readable (but not writable) from userspace. */
2684 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2687 return hppa32_cannot_store_register (gdbarch
, regnum
);
2691 hppa64_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2694 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2695 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2696 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2700 hppa64_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2702 /* cr26 and cr27 are readable (but not writable) from userspace. */
2703 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2706 return hppa64_cannot_store_register (gdbarch
, regnum
);
2710 hppa_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2712 /* The low two bits of the PC on the PA contain the privilege level.
2713 Some genius implementing a (non-GCC) compiler apparently decided
2714 this means that "addresses" in a text section therefore include a
2715 privilege level, and thus symbol tables should contain these bits.
2716 This seems like a bonehead thing to do--anyway, it seems to work
2717 for our purposes to just ignore those bits. */
2719 return (addr
&= ~0x3);
2722 /* Get the ARGIth function argument for the current function. */
2725 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2728 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2731 static enum register_status
2732 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, readable_regcache
*regcache
,
2733 int regnum
, gdb_byte
*buf
)
2735 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2737 enum register_status status
;
2739 status
= regcache
->raw_read (regnum
, &tmp
);
2740 if (status
== REG_VALID
)
2742 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2744 store_unsigned_integer (buf
, sizeof tmp
, byte_order
, tmp
);
2750 hppa_find_global_pointer (struct gdbarch
*gdbarch
, struct value
*function
)
2756 hppa_frame_prev_register_helper (struct frame_info
*this_frame
,
2757 trad_frame_saved_reg saved_regs
[],
2760 struct gdbarch
*arch
= get_frame_arch (this_frame
);
2761 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2763 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2765 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2767 struct value
*pcoq_val
=
2768 trad_frame_get_prev_register (this_frame
, saved_regs
,
2769 HPPA_PCOQ_HEAD_REGNUM
);
2771 pc
= extract_unsigned_integer (value_contents_all (pcoq_val
).data (),
2773 return frame_unwind_got_constant (this_frame
, regnum
, pc
+ 4);
2776 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
2780 /* An instruction to match. */
2783 unsigned int data
; /* See if it matches this.... */
2784 unsigned int mask
; /* ... with this mask. */
2787 /* See bfd/elf32-hppa.c */
2788 static struct insn_pattern hppa_long_branch_stub
[] = {
2789 /* ldil LR'xxx,%r1 */
2790 { 0x20200000, 0xffe00000 },
2791 /* be,n RR'xxx(%sr4,%r1) */
2792 { 0xe0202002, 0xffe02002 },
2796 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
2798 { 0xe8200000, 0xffe00000 },
2799 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2800 { 0x28200000, 0xffe00000 },
2801 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2802 { 0xe0202002, 0xffe02002 },
2806 static struct insn_pattern hppa_import_stub
[] = {
2807 /* addil LR'xxx, %dp */
2808 { 0x2b600000, 0xffe00000 },
2809 /* ldw RR'xxx(%r1), %r21 */
2810 { 0x48350000, 0xffffb000 },
2812 { 0xeaa0c000, 0xffffffff },
2813 /* ldw RR'xxx+4(%r1), %r19 */
2814 { 0x48330000, 0xffffb000 },
2818 static struct insn_pattern hppa_import_pic_stub
[] = {
2819 /* addil LR'xxx,%r19 */
2820 { 0x2a600000, 0xffe00000 },
2821 /* ldw RR'xxx(%r1),%r21 */
2822 { 0x48350000, 0xffffb000 },
2824 { 0xeaa0c000, 0xffffffff },
2825 /* ldw RR'xxx+4(%r1),%r19 */
2826 { 0x48330000, 0xffffb000 },
2830 static struct insn_pattern hppa_plt_stub
[] = {
2831 /* b,l 1b, %r20 - 1b is 3 insns before here */
2832 { 0xea9f1fdd, 0xffffffff },
2833 /* depi 0,31,2,%r20 */
2834 { 0xd6801c1e, 0xffffffff },
2838 /* Maximum number of instructions on the patterns above. */
2839 #define HPPA_MAX_INSN_PATTERN_LEN 4
2841 /* Return non-zero if the instructions at PC match the series
2842 described in PATTERN, or zero otherwise. PATTERN is an array of
2843 'struct insn_pattern' objects, terminated by an entry whose mask is
2846 When the match is successful, fill INSN[i] with what PATTERN[i]
2850 hppa_match_insns (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2851 struct insn_pattern
*pattern
, unsigned int *insn
)
2853 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2857 for (i
= 0; pattern
[i
].mask
; i
++)
2859 gdb_byte buf
[HPPA_INSN_SIZE
];
2861 target_read_memory (npc
, buf
, HPPA_INSN_SIZE
);
2862 insn
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
, byte_order
);
2863 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
2872 /* This relaxed version of the instruction matcher allows us to match
2873 from somewhere inside the pattern, by looking backwards in the
2874 instruction scheme. */
2877 hppa_match_insns_relaxed (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2878 struct insn_pattern
*pattern
, unsigned int *insn
)
2880 int offset
, len
= 0;
2882 while (pattern
[len
].mask
)
2885 for (offset
= 0; offset
< len
; offset
++)
2886 if (hppa_match_insns (gdbarch
, pc
- offset
* HPPA_INSN_SIZE
,
2894 hppa_in_dyncall (CORE_ADDR pc
)
2896 struct unwind_table_entry
*u
;
2898 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2902 return (pc
>= u
->region_start
&& pc
<= u
->region_end
);
2906 hppa_in_solib_call_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2908 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2909 struct unwind_table_entry
*u
;
2911 if (in_plt_section (pc
) || hppa_in_dyncall (pc
))
2914 /* The GNU toolchain produces linker stubs without unwind
2915 information. Since the pattern matching for linker stubs can be
2916 quite slow, so bail out if we do have an unwind entry. */
2918 u
= find_unwind_entry (pc
);
2923 (hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_stub
, insn
)
2924 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_pic_stub
, insn
)
2925 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_long_branch_stub
, insn
)
2926 || hppa_match_insns_relaxed (gdbarch
, pc
,
2927 hppa_long_branch_pic_stub
, insn
));
2930 /* This code skips several kind of "trampolines" used on PA-RISC
2931 systems: $$dyncall, import stubs and PLT stubs. */
2934 hppa_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
2936 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2937 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
2939 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2942 /* $$dyncall handles both PLABELs and direct addresses. */
2943 if (hppa_in_dyncall (pc
))
2945 pc
= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 22);
2947 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2949 pc
= read_memory_typed_address (pc
& ~0x3, func_ptr_type
);
2954 dp_rel
= hppa_match_insns (gdbarch
, pc
, hppa_import_stub
, insn
);
2955 if (dp_rel
|| hppa_match_insns (gdbarch
, pc
, hppa_import_pic_stub
, insn
))
2957 /* Extract the target address from the addil/ldw sequence. */
2958 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
2961 pc
+= get_frame_register_unsigned (frame
, HPPA_DP_REGNUM
);
2963 pc
+= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 19);
2968 if (in_plt_section (pc
))
2970 pc
= read_memory_typed_address (pc
, func_ptr_type
);
2972 /* If the PLT slot has not yet been resolved, the target will be
2974 if (in_plt_section (pc
))
2976 /* Sanity check: are we pointing to the PLT stub? */
2977 if (!hppa_match_insns (gdbarch
, pc
, hppa_plt_stub
, insn
))
2979 warning (_("Cannot resolve PLT stub at %s."),
2980 paddress (gdbarch
, pc
));
2984 /* This should point to the fixup routine. */
2985 pc
= read_memory_typed_address (pc
+ 8, func_ptr_type
);
2993 /* Here is a table of C type sizes on hppa with various compiles
2994 and options. I measured this on PA 9000/800 with HP-UX 11.11
2995 and these compilers:
2997 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2998 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2999 /opt/aCC/bin/aCC B3910B A.03.45
3000 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3002 cc : 1 2 4 4 8 : 4 8 -- : 4 4
3003 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3004 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3005 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3006 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3007 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3008 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3009 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3013 compiler and options
3014 char, short, int, long, long long
3015 float, double, long double
3018 So all these compilers use either ILP32 or LP64 model.
3019 TODO: gcc has more options so it needs more investigation.
3021 For floating point types, see:
3023 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3024 HP-UX floating-point guide, hpux 11.00
3026 -- chastain 2003-12-18 */
3028 static struct gdbarch
*
3029 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3031 struct gdbarch
*gdbarch
;
3033 /* find a candidate among the list of pre-declared architectures. */
3034 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3036 return (arches
->gdbarch
);
3038 /* If none found, then allocate and initialize one. */
3039 hppa_gdbarch_tdep
*tdep
= new hppa_gdbarch_tdep
;
3040 gdbarch
= gdbarch_alloc (&info
, tdep
);
3042 /* Determine from the bfd_arch_info structure if we are dealing with
3043 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3044 then default to a 32bit machine. */
3045 if (info
.bfd_arch_info
!= NULL
)
3046 tdep
->bytes_per_address
=
3047 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3049 tdep
->bytes_per_address
= 4;
3051 tdep
->find_global_pointer
= hppa_find_global_pointer
;
3053 /* Some parts of the gdbarch vector depend on whether we are running
3054 on a 32 bits or 64 bits target. */
3055 switch (tdep
->bytes_per_address
)
3058 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3059 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3060 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3061 set_gdbarch_cannot_store_register (gdbarch
,
3062 hppa32_cannot_store_register
);
3063 set_gdbarch_cannot_fetch_register (gdbarch
,
3064 hppa32_cannot_fetch_register
);
3067 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3068 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3069 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3070 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3071 set_gdbarch_cannot_store_register (gdbarch
,
3072 hppa64_cannot_store_register
);
3073 set_gdbarch_cannot_fetch_register (gdbarch
,
3074 hppa64_cannot_fetch_register
);
3077 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
3078 tdep
->bytes_per_address
);
3081 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3082 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3084 /* The following gdbarch vector elements are the same in both ILP32
3085 and LP64, but might show differences some day. */
3086 set_gdbarch_long_long_bit (gdbarch
, 64);
3087 set_gdbarch_long_double_bit (gdbarch
, 128);
3088 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3090 /* The following gdbarch vector elements do not depend on the address
3091 size, or in any other gdbarch element previously set. */
3092 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3093 set_gdbarch_stack_frame_destroyed_p (gdbarch
,
3094 hppa_stack_frame_destroyed_p
);
3095 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
3096 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3097 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3098 set_gdbarch_addr_bits_remove (gdbarch
, hppa_addr_bits_remove
);
3099 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3100 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
3101 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
3103 /* Helper for function argument information. */
3104 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3106 /* When a hardware watchpoint triggers, we'll move the inferior past
3107 it by removing all eventpoints; stepping past the instruction
3108 that caused the trigger; reinserting eventpoints; and checking
3109 whether any watched location changed. */
3110 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3112 /* Inferior function call methods. */
3113 switch (tdep
->bytes_per_address
)
3116 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3117 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3118 set_gdbarch_convert_from_func_ptr_addr
3119 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
3122 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3123 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3126 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3129 /* Struct return methods. */
3130 switch (tdep
->bytes_per_address
)
3133 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3136 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3139 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3142 set_gdbarch_breakpoint_kind_from_pc (gdbarch
, hppa_breakpoint::kind_from_pc
);
3143 set_gdbarch_sw_breakpoint_from_kind (gdbarch
, hppa_breakpoint::bp_from_kind
);
3144 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
3146 /* Frame unwind methods. */
3147 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3149 /* Hook in ABI-specific overrides, if they have been registered. */
3150 gdbarch_init_osabi (info
, gdbarch
);
3152 /* Hook in the default unwinders. */
3153 frame_unwind_append_unwinder (gdbarch
, &hppa_stub_frame_unwind
);
3154 frame_unwind_append_unwinder (gdbarch
, &hppa_frame_unwind
);
3155 frame_unwind_append_unwinder (gdbarch
, &hppa_fallback_frame_unwind
);
3161 hppa_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
3163 hppa_gdbarch_tdep
*tdep
= (hppa_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
3165 fprintf_filtered (file
, "bytes_per_address = %d\n",
3166 tdep
->bytes_per_address
);
3167 fprintf_filtered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
3170 void _initialize_hppa_tdep ();
3172 _initialize_hppa_tdep ()
3174 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3176 add_cmd ("unwind", class_maintenance
, unwind_command
,
3177 _("Print unwind table entry at given address."),
3178 &maintenanceprintlist
);
3180 /* Debug this files internals. */
3181 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
3182 Set whether hppa target specific debugging information should be displayed."),
3184 Show whether hppa target specific debugging information is displayed."), _("\
3185 This flag controls whether hppa target specific debugging information is\n\
3186 displayed. This information is particularly useful for debugging frame\n\
3187 unwinding problems."),
3189 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
3190 &setdebuglist
, &showdebuglist
);