1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986-2021 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 ();
264 char *buf
= (char *) alloca (size
);
265 CORE_ADDR low_text_segment_address
;
267 /* For ELF targets, then unwinds are supposed to
268 be segment relative offsets instead of absolute addresses.
270 Note that when loading a shared library (text_offset != 0) the
271 unwinds are already relative to the text_offset that will be
273 if (gdbarch_tdep (gdbarch
)->is_elf
&& text_offset
== 0)
275 low_text_segment_address
= -1;
277 bfd_map_over_sections (objfile
->obfd
,
278 record_text_segment_lowaddr
,
279 &low_text_segment_address
);
281 text_offset
= low_text_segment_address
;
283 else if (gdbarch_tdep (gdbarch
)->solib_get_text_base
)
285 text_offset
= gdbarch_tdep (gdbarch
)->solib_get_text_base (objfile
);
288 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
290 /* Now internalize the information being careful to handle host/target
292 for (i
= 0; i
< entries
; i
++)
294 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
296 table
[i
].region_start
+= text_offset
;
298 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
299 table
[i
].region_end
+= text_offset
;
301 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
303 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
304 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
305 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
306 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
307 table
[i
].reserved
= (tmp
>> 26) & 0x1;
308 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
309 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
310 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
311 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
312 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
313 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
314 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
315 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
316 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
317 table
[i
].sr4export
= (tmp
>> 9) & 0x1;
318 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
319 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
320 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
321 table
[i
].reserved1
= (tmp
>> 5) & 0x1;
322 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
323 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
324 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
325 table
[i
].save_r19
= (tmp
>> 1) & 0x1;
326 table
[i
].Cleanup_defined
= tmp
& 0x1;
327 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
329 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
330 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
331 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
332 table
[i
].alloca_frame
= (tmp
>> 28) & 0x1;
333 table
[i
].reserved2
= (tmp
>> 27) & 0x1;
334 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
336 /* Stub unwinds are handled elsewhere. */
337 table
[i
].stub_unwind
.stub_type
= 0;
338 table
[i
].stub_unwind
.padding
= 0;
343 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
344 the object file. This info is used mainly by find_unwind_entry() to find
345 out the stack frame size and frame pointer used by procedures. We put
346 everything on the psymbol obstack in the objfile so that it automatically
347 gets freed when the objfile is destroyed. */
350 read_unwind_info (struct objfile
*objfile
)
352 asection
*unwind_sec
, *stub_unwind_sec
;
353 size_t unwind_size
, stub_unwind_size
, total_size
;
354 unsigned index
, unwind_entries
;
355 unsigned stub_entries
, total_entries
;
356 CORE_ADDR text_offset
;
357 struct hppa_unwind_info
*ui
;
358 struct hppa_objfile_private
*obj_private
;
360 text_offset
= objfile
->text_section_offset ();
361 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
362 sizeof (struct hppa_unwind_info
));
368 /* For reasons unknown the HP PA64 tools generate multiple unwinder
369 sections in a single executable. So we just iterate over every
370 section in the BFD looking for unwinder sections instead of trying
371 to do a lookup with bfd_get_section_by_name.
373 First determine the total size of the unwind tables so that we
374 can allocate memory in a nice big hunk. */
376 for (unwind_sec
= objfile
->obfd
->sections
;
378 unwind_sec
= unwind_sec
->next
)
380 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
381 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
383 unwind_size
= bfd_section_size (unwind_sec
);
384 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
386 total_entries
+= unwind_entries
;
390 /* Now compute the size of the stub unwinds. Note the ELF tools do not
391 use stub unwinds at the current time. */
392 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
396 stub_unwind_size
= bfd_section_size (stub_unwind_sec
);
397 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
401 stub_unwind_size
= 0;
405 /* Compute total number of unwind entries and their total size. */
406 total_entries
+= stub_entries
;
407 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
409 /* Allocate memory for the unwind table. */
410 ui
->table
= (struct unwind_table_entry
*)
411 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
412 ui
->last
= total_entries
- 1;
414 /* Now read in each unwind section and internalize the standard unwind
417 for (unwind_sec
= objfile
->obfd
->sections
;
419 unwind_sec
= unwind_sec
->next
)
421 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
422 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
424 unwind_size
= bfd_section_size (unwind_sec
);
425 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
427 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
428 unwind_entries
, unwind_size
, text_offset
);
429 index
+= unwind_entries
;
433 /* Now read in and internalize the stub unwind entries. */
434 if (stub_unwind_size
> 0)
437 char *buf
= (char *) alloca (stub_unwind_size
);
439 /* Read in the stub unwind entries. */
440 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
441 0, stub_unwind_size
);
443 /* Now convert them into regular unwind entries. */
444 for (i
= 0; i
< stub_entries
; i
++, index
++)
446 /* Clear out the next unwind entry. */
447 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
449 /* Convert offset & size into region_start and region_end.
450 Stuff away the stub type into "reserved" fields. */
451 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
453 ui
->table
[index
].region_start
+= text_offset
;
455 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
458 ui
->table
[index
].region_end
459 = ui
->table
[index
].region_start
+ 4 *
460 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
466 /* Unwind table needs to be kept sorted. */
467 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
468 compare_unwind_entries
);
470 /* Keep a pointer to the unwind information. */
471 obj_private
= hppa_objfile_priv_data
.get (objfile
);
472 if (obj_private
== NULL
)
473 obj_private
= hppa_init_objfile_priv_data (objfile
);
475 obj_private
->unwind_info
= ui
;
478 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
479 of the objfiles seeking the unwind table entry for this PC. Each objfile
480 contains a sorted list of struct unwind_table_entry. Since we do a binary
481 search of the unwind tables, we depend upon them to be sorted. */
483 struct unwind_table_entry
*
484 find_unwind_entry (CORE_ADDR pc
)
486 int first
, middle
, last
;
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 for (objfile
*objfile
: current_program_space
->objfiles ())
503 struct hppa_unwind_info
*ui
;
505 priv
= hppa_objfile_priv_data
.get (objfile
);
507 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
511 read_unwind_info (objfile
);
512 priv
= hppa_objfile_priv_data
.get (objfile
);
514 error (_("Internal error reading unwind information."));
515 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
518 /* First, check the cache. */
521 && pc
>= ui
->cache
->region_start
522 && pc
<= ui
->cache
->region_end
)
525 fprintf_unfiltered (gdb_stdlog
, "%s (cached) }\n",
526 hex_string ((uintptr_t) ui
->cache
));
530 /* Not in the cache, do a binary search. */
535 while (first
<= last
)
537 middle
= (first
+ last
) / 2;
538 if (pc
>= ui
->table
[middle
].region_start
539 && pc
<= ui
->table
[middle
].region_end
)
541 ui
->cache
= &ui
->table
[middle
];
543 fprintf_unfiltered (gdb_stdlog
, "%s }\n",
544 hex_string ((uintptr_t) ui
->cache
));
545 return &ui
->table
[middle
];
548 if (pc
< ui
->table
[middle
].region_start
)
556 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
561 /* Implement the stack_frame_destroyed_p gdbarch method.
563 The epilogue is defined here as the area either on the `bv' instruction
564 itself or an instruction which destroys the function's stack frame.
566 We do not assume that the epilogue is at the end of a function as we can
567 also have return sequences in the middle of a function. */
570 hppa_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
572 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
573 unsigned long status
;
577 status
= target_read_memory (pc
, buf
, 4);
581 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
583 /* The most common way to perform a stack adjustment ldo X(sp),sp
584 We are destroying a stack frame if the offset is negative. */
585 if ((inst
& 0xffffc000) == 0x37de0000
586 && hppa_extract_14 (inst
) < 0)
589 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
590 if (((inst
& 0x0fc010e0) == 0x0fc010e0
591 || (inst
& 0x0fc010e0) == 0x0fc010e0)
592 && hppa_extract_14 (inst
) < 0)
595 /* bv %r0(%rp) or bv,n %r0(%rp) */
596 if (inst
== 0xe840c000 || inst
== 0xe840c002)
602 constexpr gdb_byte hppa_break_insn
[] = {0x00, 0x01, 0x00, 0x04};
604 typedef BP_MANIPULATION (hppa_break_insn
) hppa_breakpoint
;
606 /* Return the name of a register. */
609 hppa32_register_name (struct gdbarch
*gdbarch
, int i
)
611 static const char *names
[] = {
612 "flags", "r1", "rp", "r3",
613 "r4", "r5", "r6", "r7",
614 "r8", "r9", "r10", "r11",
615 "r12", "r13", "r14", "r15",
616 "r16", "r17", "r18", "r19",
617 "r20", "r21", "r22", "r23",
618 "r24", "r25", "r26", "dp",
619 "ret0", "ret1", "sp", "r31",
620 "sar", "pcoqh", "pcsqh", "pcoqt",
621 "pcsqt", "eiem", "iir", "isr",
622 "ior", "ipsw", "goto", "sr4",
623 "sr0", "sr1", "sr2", "sr3",
624 "sr5", "sr6", "sr7", "cr0",
625 "cr8", "cr9", "ccr", "cr12",
626 "cr13", "cr24", "cr25", "cr26",
627 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
628 "fpsr", "fpe1", "fpe2", "fpe3",
629 "fpe4", "fpe5", "fpe6", "fpe7",
630 "fr4", "fr4R", "fr5", "fr5R",
631 "fr6", "fr6R", "fr7", "fr7R",
632 "fr8", "fr8R", "fr9", "fr9R",
633 "fr10", "fr10R", "fr11", "fr11R",
634 "fr12", "fr12R", "fr13", "fr13R",
635 "fr14", "fr14R", "fr15", "fr15R",
636 "fr16", "fr16R", "fr17", "fr17R",
637 "fr18", "fr18R", "fr19", "fr19R",
638 "fr20", "fr20R", "fr21", "fr21R",
639 "fr22", "fr22R", "fr23", "fr23R",
640 "fr24", "fr24R", "fr25", "fr25R",
641 "fr26", "fr26R", "fr27", "fr27R",
642 "fr28", "fr28R", "fr29", "fr29R",
643 "fr30", "fr30R", "fr31", "fr31R"
645 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
652 hppa64_register_name (struct gdbarch
*gdbarch
, int i
)
654 static const char *names
[] = {
655 "flags", "r1", "rp", "r3",
656 "r4", "r5", "r6", "r7",
657 "r8", "r9", "r10", "r11",
658 "r12", "r13", "r14", "r15",
659 "r16", "r17", "r18", "r19",
660 "r20", "r21", "r22", "r23",
661 "r24", "r25", "r26", "dp",
662 "ret0", "ret1", "sp", "r31",
663 "sar", "pcoqh", "pcsqh", "pcoqt",
664 "pcsqt", "eiem", "iir", "isr",
665 "ior", "ipsw", "goto", "sr4",
666 "sr0", "sr1", "sr2", "sr3",
667 "sr5", "sr6", "sr7", "cr0",
668 "cr8", "cr9", "ccr", "cr12",
669 "cr13", "cr24", "cr25", "cr26",
670 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
671 "fpsr", "fpe1", "fpe2", "fpe3",
672 "fr4", "fr5", "fr6", "fr7",
673 "fr8", "fr9", "fr10", "fr11",
674 "fr12", "fr13", "fr14", "fr15",
675 "fr16", "fr17", "fr18", "fr19",
676 "fr20", "fr21", "fr22", "fr23",
677 "fr24", "fr25", "fr26", "fr27",
678 "fr28", "fr29", "fr30", "fr31"
680 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
686 /* Map dwarf DBX register numbers to GDB register numbers. */
688 hppa64_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
690 /* The general registers and the sar are the same in both sets. */
691 if (reg
>= 0 && reg
<= 32)
694 /* fr4-fr31 are mapped from 72 in steps of 2. */
695 if (reg
>= 72 && reg
< 72 + 28 * 2 && !(reg
& 1))
696 return HPPA64_FP4_REGNUM
+ (reg
- 72) / 2;
701 /* This function pushes a stack frame with arguments as part of the
702 inferior function calling mechanism.
704 This is the version of the function for the 32-bit PA machines, in
705 which later arguments appear at lower addresses. (The stack always
706 grows towards higher addresses.)
708 We simply allocate the appropriate amount of stack space and put
709 arguments into their proper slots. */
712 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
713 struct regcache
*regcache
, CORE_ADDR bp_addr
,
714 int nargs
, struct value
**args
, CORE_ADDR sp
,
715 function_call_return_method return_method
,
716 CORE_ADDR struct_addr
)
718 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
720 /* Stack base address at which any pass-by-reference parameters are
722 CORE_ADDR struct_end
= 0;
723 /* Stack base address at which the first parameter is stored. */
724 CORE_ADDR param_end
= 0;
726 /* Two passes. First pass computes the location of everything,
727 second pass writes the bytes out. */
730 /* Global pointer (r19) of the function we are trying to call. */
733 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
735 for (write_pass
= 0; write_pass
< 2; write_pass
++)
737 CORE_ADDR struct_ptr
= 0;
738 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
739 struct_ptr is adjusted for each argument below, so the first
740 argument will end up at sp-36. */
741 CORE_ADDR param_ptr
= 32;
743 int small_struct
= 0;
745 for (i
= 0; i
< nargs
; i
++)
747 struct value
*arg
= args
[i
];
748 struct type
*type
= check_typedef (value_type (arg
));
749 /* The corresponding parameter that is pushed onto the
750 stack, and [possibly] passed in a register. */
751 gdb_byte param_val
[8];
753 memset (param_val
, 0, sizeof param_val
);
754 if (TYPE_LENGTH (type
) > 8)
756 /* Large parameter, pass by reference. Store the value
757 in "struct" area and then pass its address. */
759 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
761 write_memory (struct_end
- struct_ptr
, value_contents (arg
),
763 store_unsigned_integer (param_val
, 4, byte_order
,
764 struct_end
- struct_ptr
);
766 else if (type
->code () == TYPE_CODE_INT
767 || type
->code () == TYPE_CODE_ENUM
)
769 /* Integer value store, right aligned. "unpack_long"
770 takes care of any sign-extension problems. */
771 param_len
= align_up (TYPE_LENGTH (type
), 4);
772 store_unsigned_integer (param_val
, param_len
, byte_order
,
774 value_contents (arg
)));
776 else if (type
->code () == TYPE_CODE_FLT
)
778 /* Floating point value store, right aligned. */
779 param_len
= align_up (TYPE_LENGTH (type
), 4);
780 memcpy (param_val
, value_contents (arg
), param_len
);
784 param_len
= align_up (TYPE_LENGTH (type
), 4);
786 /* Small struct value are stored right-aligned. */
787 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
788 value_contents (arg
), TYPE_LENGTH (type
));
790 /* Structures of size 5, 6 and 7 bytes are special in that
791 the higher-ordered word is stored in the lower-ordered
792 argument, and even though it is a 8-byte quantity the
793 registers need not be 8-byte aligned. */
794 if (param_len
> 4 && param_len
< 8)
798 param_ptr
+= param_len
;
799 if (param_len
== 8 && !small_struct
)
800 param_ptr
= align_up (param_ptr
, 8);
802 /* First 4 non-FP arguments are passed in gr26-gr23.
803 First 4 32-bit FP arguments are passed in fr4L-fr7L.
804 First 2 64-bit FP arguments are passed in fr5 and fr7.
806 The rest go on the stack, starting at sp-36, towards lower
807 addresses. 8-byte arguments must be aligned to a 8-byte
811 write_memory (param_end
- param_ptr
, param_val
, param_len
);
813 /* There are some cases when we don't know the type
814 expected by the callee (e.g. for variadic functions), so
815 pass the parameters in both general and fp regs. */
818 int grreg
= 26 - (param_ptr
- 36) / 4;
819 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
820 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
822 regcache
->cooked_write (grreg
, param_val
);
823 regcache
->cooked_write (fpLreg
, param_val
);
827 regcache
->cooked_write (grreg
+ 1, param_val
+ 4);
829 regcache
->cooked_write (fpreg
, param_val
);
830 regcache
->cooked_write (fpreg
+ 1, param_val
+ 4);
836 /* Update the various stack pointers. */
839 struct_end
= sp
+ align_up (struct_ptr
, 64);
840 /* PARAM_PTR already accounts for all the arguments passed
841 by the user. However, the ABI mandates minimum stack
842 space allocations for outgoing arguments. The ABI also
843 mandates minimum stack alignments which we must
845 param_end
= struct_end
+ align_up (param_ptr
, 64);
849 /* If a structure has to be returned, set up register 28 to hold its
851 if (return_method
== return_method_struct
)
852 regcache_cooked_write_unsigned (regcache
, 28, struct_addr
);
854 gp
= tdep
->find_global_pointer (gdbarch
, function
);
857 regcache_cooked_write_unsigned (regcache
, 19, gp
);
859 /* Set the return address. */
860 if (!gdbarch_push_dummy_code_p (gdbarch
))
861 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
863 /* Update the Stack Pointer. */
864 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
869 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
870 Runtime Architecture for PA-RISC 2.0", which is distributed as part
871 as of the HP-UX Software Transition Kit (STK). This implementation
872 is based on version 3.3, dated October 6, 1997. */
874 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
877 hppa64_integral_or_pointer_p (const struct type
*type
)
879 switch (type
->code ())
885 case TYPE_CODE_RANGE
:
887 int len
= TYPE_LENGTH (type
);
888 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
892 case TYPE_CODE_RVALUE_REF
:
893 return (TYPE_LENGTH (type
) == 8);
901 /* Check whether TYPE is a "Floating Scalar Type". */
904 hppa64_floating_p (const struct type
*type
)
906 switch (type
->code ())
910 int len
= TYPE_LENGTH (type
);
911 return (len
== 4 || len
== 8 || len
== 16);
920 /* If CODE points to a function entry address, try to look up the corresponding
921 function descriptor and return its address instead. If CODE is not a
922 function entry address, then just return it unchanged. */
924 hppa64_convert_code_addr_to_fptr (struct gdbarch
*gdbarch
, CORE_ADDR code
)
926 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
927 struct obj_section
*sec
, *opd
;
929 sec
= find_pc_section (code
);
934 /* If CODE is in a data section, assume it's already a fptr. */
935 if (!(sec
->the_bfd_section
->flags
& SEC_CODE
))
938 ALL_OBJFILE_OSECTIONS (sec
->objfile
, opd
)
940 if (strcmp (opd
->the_bfd_section
->name
, ".opd") == 0)
944 if (opd
< sec
->objfile
->sections_end
)
946 for (CORE_ADDR addr
= opd
->addr (); addr
< opd
->endaddr (); addr
+= 2 * 8)
951 if (target_read_memory (addr
, tmp
, sizeof (tmp
)))
953 opdaddr
= extract_unsigned_integer (tmp
, sizeof (tmp
), byte_order
);
964 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
965 struct regcache
*regcache
, CORE_ADDR bp_addr
,
966 int nargs
, struct value
**args
, CORE_ADDR sp
,
967 function_call_return_method return_method
,
968 CORE_ADDR struct_addr
)
970 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
971 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
975 /* "The outgoing parameter area [...] must be aligned at a 16-byte
977 sp
= align_up (sp
, 16);
979 for (i
= 0; i
< nargs
; i
++)
981 struct value
*arg
= args
[i
];
982 struct type
*type
= value_type (arg
);
983 int len
= TYPE_LENGTH (type
);
984 const bfd_byte
*valbuf
;
988 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
989 offset
= align_up (offset
, 8);
991 if (hppa64_integral_or_pointer_p (type
))
993 /* "Integral scalar parameters smaller than 64 bits are
994 padded on the left (i.e., the value is in the
995 least-significant bits of the 64-bit storage unit, and
996 the high-order bits are undefined)." Therefore we can
997 safely sign-extend them. */
1000 arg
= value_cast (builtin_type (gdbarch
)->builtin_int64
, arg
);
1004 else if (hppa64_floating_p (type
))
1008 /* "Quad-precision (128-bit) floating-point scalar
1009 parameters are aligned on a 16-byte boundary." */
1010 offset
= align_up (offset
, 16);
1012 /* "Double-extended- and quad-precision floating-point
1013 parameters within the first 64 bytes of the parameter
1014 list are always passed in general registers." */
1020 /* "Single-precision (32-bit) floating-point scalar
1021 parameters are padded on the left with 32 bits of
1022 garbage (i.e., the floating-point value is in the
1023 least-significant 32 bits of a 64-bit storage
1028 /* "Single- and double-precision floating-point
1029 parameters in this area are passed according to the
1030 available formal parameter information in a function
1031 prototype. [...] If no prototype is in scope,
1032 floating-point parameters must be passed both in the
1033 corresponding general registers and in the
1034 corresponding floating-point registers." */
1035 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
1037 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
1039 /* "Single-precision floating-point parameters, when
1040 passed in floating-point registers, are passed in
1041 the right halves of the floating point registers;
1042 the left halves are unused." */
1043 regcache
->cooked_write_part (regnum
, offset
% 8, len
,
1044 value_contents (arg
));
1052 /* "Aggregates larger than 8 bytes are aligned on a
1053 16-byte boundary, possibly leaving an unused argument
1054 slot, which is filled with garbage. If necessary,
1055 they are padded on the right (with garbage), to a
1056 multiple of 8 bytes." */
1057 offset
= align_up (offset
, 16);
1061 /* If we are passing a function pointer, make sure we pass a function
1062 descriptor instead of the function entry address. */
1063 if (type
->code () == TYPE_CODE_PTR
1064 && TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_FUNC
)
1066 ULONGEST codeptr
, fptr
;
1068 codeptr
= unpack_long (type
, value_contents (arg
));
1069 fptr
= hppa64_convert_code_addr_to_fptr (gdbarch
, codeptr
);
1070 store_unsigned_integer (fptrbuf
, TYPE_LENGTH (type
), byte_order
,
1076 valbuf
= value_contents (arg
);
1079 /* Always store the argument in memory. */
1080 write_memory (sp
+ offset
, valbuf
, len
);
1082 regnum
= HPPA_ARG0_REGNUM
- offset
/ 8;
1083 while (regnum
> HPPA_ARG0_REGNUM
- 8 && len
> 0)
1085 regcache
->cooked_write_part (regnum
, offset
% 8, std::min (len
, 8),
1087 offset
+= std::min (len
, 8);
1088 valbuf
+= std::min (len
, 8);
1089 len
-= std::min (len
, 8);
1096 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1097 regcache_cooked_write_unsigned (regcache
, HPPA_RET1_REGNUM
, sp
+ 64);
1099 /* Allocate the outgoing parameter area. Make sure the outgoing
1100 parameter area is multiple of 16 bytes in length. */
1101 sp
+= std::max (align_up (offset
, 16), (ULONGEST
) 64);
1103 /* Allocate 32-bytes of scratch space. The documentation doesn't
1104 mention this, but it seems to be needed. */
1107 /* Allocate the frame marker area. */
1110 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1112 if (return_method
== return_method_struct
)
1113 regcache_cooked_write_unsigned (regcache
, HPPA_RET0_REGNUM
, struct_addr
);
1115 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1116 gp
= tdep
->find_global_pointer (gdbarch
, function
);
1118 regcache_cooked_write_unsigned (regcache
, HPPA_DP_REGNUM
, gp
);
1120 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1121 if (!gdbarch_push_dummy_code_p (gdbarch
))
1122 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1124 /* Set up GR30 to hold the stack pointer (sp). */
1125 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, sp
);
1131 /* Handle 32/64-bit struct return conventions. */
1133 static enum return_value_convention
1134 hppa32_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1135 struct type
*type
, struct regcache
*regcache
,
1136 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1138 if (TYPE_LENGTH (type
) <= 2 * 4)
1140 /* The value always lives in the right hand end of the register
1141 (or register pair)? */
1143 int reg
= type
->code () == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
1144 int part
= TYPE_LENGTH (type
) % 4;
1145 /* The left hand register contains only part of the value,
1146 transfer that first so that the rest can be xfered as entire
1147 4-byte registers. */
1150 if (readbuf
!= NULL
)
1151 regcache
->cooked_read_part (reg
, 4 - part
, part
, readbuf
);
1152 if (writebuf
!= NULL
)
1153 regcache
->cooked_write_part (reg
, 4 - part
, part
, writebuf
);
1156 /* Now transfer the remaining register values. */
1157 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
1159 if (readbuf
!= NULL
)
1160 regcache
->cooked_read (reg
, readbuf
+ b
);
1161 if (writebuf
!= NULL
)
1162 regcache
->cooked_write (reg
, writebuf
+ b
);
1165 return RETURN_VALUE_REGISTER_CONVENTION
;
1168 return RETURN_VALUE_STRUCT_CONVENTION
;
1171 static enum return_value_convention
1172 hppa64_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1173 struct type
*type
, struct regcache
*regcache
,
1174 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1176 int len
= TYPE_LENGTH (type
);
1181 /* All return values larger than 128 bits must be aggregate
1183 gdb_assert (!hppa64_integral_or_pointer_p (type
));
1184 gdb_assert (!hppa64_floating_p (type
));
1186 /* "Aggregate return values larger than 128 bits are returned in
1187 a buffer allocated by the caller. The address of the buffer
1188 must be passed in GR 28." */
1189 return RETURN_VALUE_STRUCT_CONVENTION
;
1192 if (hppa64_integral_or_pointer_p (type
))
1194 /* "Integral return values are returned in GR 28. Values
1195 smaller than 64 bits are padded on the left (with garbage)." */
1196 regnum
= HPPA_RET0_REGNUM
;
1199 else if (hppa64_floating_p (type
))
1203 /* "Double-extended- and quad-precision floating-point
1204 values are returned in GRs 28 and 29. The sign,
1205 exponent, and most-significant bits of the mantissa are
1206 returned in GR 28; the least-significant bits of the
1207 mantissa are passed in GR 29. For double-extended
1208 precision values, GR 29 is padded on the right with 48
1209 bits of garbage." */
1210 regnum
= HPPA_RET0_REGNUM
;
1215 /* "Single-precision and double-precision floating-point
1216 return values are returned in FR 4R (single precision) or
1217 FR 4 (double-precision)." */
1218 regnum
= HPPA64_FP4_REGNUM
;
1224 /* "Aggregate return values up to 64 bits in size are returned
1225 in GR 28. Aggregates smaller than 64 bits are left aligned
1226 in the register; the pad bits on the right are undefined."
1228 "Aggregate return values between 65 and 128 bits are returned
1229 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1230 the remaining bits are placed, left aligned, in GR 29. The
1231 pad bits on the right of GR 29 (if any) are undefined." */
1232 regnum
= HPPA_RET0_REGNUM
;
1240 regcache
->cooked_read_part (regnum
, offset
, std::min (len
, 8),
1242 readbuf
+= std::min (len
, 8);
1243 len
-= std::min (len
, 8);
1252 regcache
->cooked_write_part (regnum
, offset
, std::min (len
, 8),
1254 writebuf
+= std::min (len
, 8);
1255 len
-= std::min (len
, 8);
1260 return RETURN_VALUE_REGISTER_CONVENTION
;
1265 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1266 struct target_ops
*targ
)
1270 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1271 CORE_ADDR plabel
= addr
& ~3;
1272 return read_memory_typed_address (plabel
, func_ptr_type
);
1279 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1281 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1283 return align_up (addr
, 64);
1286 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1289 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1291 /* Just always 16-byte align. */
1292 return align_up (addr
, 16);
1296 hppa_read_pc (readable_regcache
*regcache
)
1301 regcache
->cooked_read (HPPA_IPSW_REGNUM
, &ipsw
);
1302 regcache
->cooked_read (HPPA_PCOQ_HEAD_REGNUM
, &pc
);
1304 /* If the current instruction is nullified, then we are effectively
1305 still executing the previous instruction. Pretend we are still
1306 there. This is needed when single stepping; if the nullified
1307 instruction is on a different line, we don't want GDB to think
1308 we've stepped onto that line. */
1309 if (ipsw
& 0x00200000)
1316 hppa_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1318 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pc
);
1319 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4);
1322 /* For the given instruction (INST), return any adjustment it makes
1323 to the stack pointer or zero for no adjustment.
1325 This only handles instructions commonly found in prologues. */
1328 prologue_inst_adjust_sp (unsigned long inst
)
1330 /* This must persist across calls. */
1331 static int save_high21
;
1333 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1334 if ((inst
& 0xffffc000) == 0x37de0000)
1335 return hppa_extract_14 (inst
);
1338 if ((inst
& 0xffe00000) == 0x6fc00000)
1339 return hppa_extract_14 (inst
);
1341 /* std,ma X,D(sp) */
1342 if ((inst
& 0xffe00008) == 0x73c00008)
1343 return (inst
& 0x1 ? -(1 << 13) : 0) | (((inst
>> 4) & 0x3ff) << 3);
1345 /* addil high21,%r30; ldo low11,(%r1),%r30)
1346 save high bits in save_high21 for later use. */
1347 if ((inst
& 0xffe00000) == 0x2bc00000)
1349 save_high21
= hppa_extract_21 (inst
);
1353 if ((inst
& 0xffff0000) == 0x343e0000)
1354 return save_high21
+ hppa_extract_14 (inst
);
1356 /* fstws as used by the HP compilers. */
1357 if ((inst
& 0xffffffe0) == 0x2fd01220)
1358 return hppa_extract_5_load (inst
);
1360 /* No adjustment. */
1364 /* Return nonzero if INST is a branch of some kind, else return zero. */
1367 is_branch (unsigned long inst
)
1396 /* Return the register number for a GR which is saved by INST or
1397 zero if INST does not save a GR.
1402 https://parisc.wiki.kernel.org/images-parisc/6/68/Pa11_acd.pdf
1405 https://parisc.wiki.kernel.org/images-parisc/7/73/Parisc2.0.pdf
1407 According to Table 6-5 of Chapter 6 (Memory Reference Instructions)
1408 on page 106 in parisc 2.0, all instructions for storing values from
1409 the general registers are:
1411 Store: stb, sth, stw, std (according to Chapter 7, they
1412 are only in both "inst >> 26" and "inst >> 6".
1413 Store Absolute: stwa, stda (according to Chapter 7, they are only
1415 Store Bytes: stby, stdby (according to Chapter 7, they are
1416 only in "inst >> 6").
1418 For (inst >> 26), according to Chapter 7:
1420 The effective memory reference address is formed by the addition
1421 of an immediate displacement to a base value.
1423 - stb: 0x18, store a byte from a general register.
1425 - sth: 0x19, store a halfword from a general register.
1427 - stw: 0x1a, store a word from a general register.
1429 - stwm: 0x1b, store a word from a general register and perform base
1430 register modification (2.0 will still treat it as stw).
1432 - std: 0x1c, store a doubleword from a general register (2.0 only).
1434 - stw: 0x1f, store a word from a general register (2.0 only).
1436 For (inst >> 6) when ((inst >> 26) == 0x03), according to Chapter 7:
1438 The effective memory reference address is formed by the addition
1439 of an index value to a base value specified in the instruction.
1441 - stb: 0x08, store a byte from a general register (1.1 calls stbs).
1443 - sth: 0x09, store a halfword from a general register (1.1 calls
1446 - stw: 0x0a, store a word from a general register (1.1 calls stws).
1448 - std: 0x0b: store a doubleword from a general register (2.0 only)
1450 Implement fast byte moves (stores) to unaligned word or doubleword
1453 - stby: 0x0c, for unaligned word (1.1 calls stbys).
1455 - stdby: 0x0d for unaligned doubleword (2.0 only).
1457 Store a word or doubleword using an absolute memory address formed
1458 using short or long displacement or indexed
1460 - stwa: 0x0e, store a word from a general register to an absolute
1461 address (1.0 calls stwas).
1463 - stda: 0x0f, store a doubleword from a general register to an
1464 absolute address (2.0 only). */
1467 inst_saves_gr (unsigned long inst
)
1469 switch ((inst
>> 26) & 0x0f)
1472 switch ((inst
>> 6) & 0x0f)
1482 return hppa_extract_5R_store (inst
);
1491 /* no 0x1d or 0x1e -- according to parisc 2.0 document */
1493 return hppa_extract_5R_store (inst
);
1499 /* Return the register number for a FR which is saved by INST or
1500 zero it INST does not save a FR.
1502 Note we only care about full 64bit register stores (that's the only
1503 kind of stores the prologue will use).
1505 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1508 inst_saves_fr (unsigned long inst
)
1510 /* Is this an FSTD? */
1511 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1512 return hppa_extract_5r_store (inst
);
1513 if ((inst
& 0xfc000002) == 0x70000002)
1514 return hppa_extract_5R_store (inst
);
1515 /* Is this an FSTW? */
1516 if ((inst
& 0xfc00df80) == 0x24001200)
1517 return hppa_extract_5r_store (inst
);
1518 if ((inst
& 0xfc000002) == 0x7c000000)
1519 return hppa_extract_5R_store (inst
);
1523 /* Advance PC across any function entry prologue instructions
1524 to reach some "real" code.
1526 Use information in the unwind table to determine what exactly should
1527 be in the prologue. */
1531 skip_prologue_hard_way (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1532 int stop_before_branch
)
1534 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1536 CORE_ADDR orig_pc
= pc
;
1537 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1538 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1539 struct unwind_table_entry
*u
;
1540 int final_iteration
;
1546 u
= find_unwind_entry (pc
);
1550 /* If we are not at the beginning of a function, then return now. */
1551 if ((pc
& ~0x3) != u
->region_start
)
1554 /* This is how much of a frame adjustment we need to account for. */
1555 stack_remaining
= u
->Total_frame_size
<< 3;
1557 /* Magic register saves we want to know about. */
1558 save_rp
= u
->Save_RP
;
1559 save_sp
= u
->Save_SP
;
1561 /* An indication that args may be stored into the stack. Unfortunately
1562 the HPUX compilers tend to set this in cases where no args were
1566 /* Turn the Entry_GR field into a bitmask. */
1568 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1570 /* Frame pointer gets saved into a special location. */
1571 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1574 save_gr
|= (1 << i
);
1576 save_gr
&= ~restart_gr
;
1578 /* Turn the Entry_FR field into a bitmask too. */
1580 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1581 save_fr
|= (1 << i
);
1582 save_fr
&= ~restart_fr
;
1584 final_iteration
= 0;
1586 /* Loop until we find everything of interest or hit a branch.
1588 For unoptimized GCC code and for any HP CC code this will never ever
1589 examine any user instructions.
1591 For optimized GCC code we're faced with problems. GCC will schedule
1592 its prologue and make prologue instructions available for delay slot
1593 filling. The end result is user code gets mixed in with the prologue
1594 and a prologue instruction may be in the delay slot of the first branch
1597 Some unexpected things are expected with debugging optimized code, so
1598 we allow this routine to walk past user instructions in optimized
1600 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1603 unsigned int reg_num
;
1604 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1605 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1607 /* Save copies of all the triggers so we can compare them later
1609 old_save_gr
= save_gr
;
1610 old_save_fr
= save_fr
;
1611 old_save_rp
= save_rp
;
1612 old_save_sp
= save_sp
;
1613 old_stack_remaining
= stack_remaining
;
1615 status
= target_read_memory (pc
, buf
, 4);
1616 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1622 /* Note the interesting effects of this instruction. */
1623 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1625 /* There are limited ways to store the return pointer into the
1627 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1630 /* These are the only ways we save SP into the stack. At this time
1631 the HP compilers never bother to save SP into the stack. */
1632 if ((inst
& 0xffffc000) == 0x6fc10000
1633 || (inst
& 0xffffc00c) == 0x73c10008)
1636 /* Are we loading some register with an offset from the argument
1638 if ((inst
& 0xffe00000) == 0x37a00000
1639 || (inst
& 0xffffffe0) == 0x081d0240)
1645 /* Account for general and floating-point register saves. */
1646 reg_num
= inst_saves_gr (inst
);
1647 save_gr
&= ~(1 << reg_num
);
1649 /* Ugh. Also account for argument stores into the stack.
1650 Unfortunately args_stored only tells us that some arguments
1651 where stored into the stack. Not how many or what kind!
1653 This is a kludge as on the HP compiler sets this bit and it
1654 never does prologue scheduling. So once we see one, skip past
1655 all of them. We have similar code for the fp arg stores below.
1657 FIXME. Can still die if we have a mix of GR and FR argument
1659 if (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1662 while (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1666 status
= target_read_memory (pc
, buf
, 4);
1667 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1670 reg_num
= inst_saves_gr (inst
);
1676 reg_num
= inst_saves_fr (inst
);
1677 save_fr
&= ~(1 << reg_num
);
1679 status
= target_read_memory (pc
+ 4, buf
, 4);
1680 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1686 /* We've got to be read to handle the ldo before the fp register
1688 if ((inst
& 0xfc000000) == 0x34000000
1689 && inst_saves_fr (next_inst
) >= 4
1690 && inst_saves_fr (next_inst
)
1691 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1693 /* So we drop into the code below in a reasonable state. */
1694 reg_num
= inst_saves_fr (next_inst
);
1698 /* Ugh. Also account for argument stores into the stack.
1699 This is a kludge as on the HP compiler sets this bit and it
1700 never does prologue scheduling. So once we see one, skip past
1703 && reg_num
<= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1707 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1710 status
= target_read_memory (pc
, buf
, 4);
1711 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1714 if ((inst
& 0xfc000000) != 0x34000000)
1716 status
= target_read_memory (pc
+ 4, buf
, 4);
1717 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1720 reg_num
= inst_saves_fr (next_inst
);
1726 /* Quit if we hit any kind of branch. This can happen if a prologue
1727 instruction is in the delay slot of the first call/branch. */
1728 if (is_branch (inst
) && stop_before_branch
)
1731 /* What a crock. The HP compilers set args_stored even if no
1732 arguments were stored into the stack (boo hiss). This could
1733 cause this code to then skip a bunch of user insns (up to the
1736 To combat this we try to identify when args_stored was bogusly
1737 set and clear it. We only do this when args_stored is nonzero,
1738 all other resources are accounted for, and nothing changed on
1741 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1742 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1743 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1744 && old_stack_remaining
== stack_remaining
)
1750 /* !stop_before_branch, so also look at the insn in the delay slot
1752 if (final_iteration
)
1754 if (is_branch (inst
))
1755 final_iteration
= 1;
1758 /* We've got a tentative location for the end of the prologue. However
1759 because of limitations in the unwind descriptor mechanism we may
1760 have went too far into user code looking for the save of a register
1761 that does not exist. So, if there registers we expected to be saved
1762 but never were, mask them out and restart.
1764 This should only happen in optimized code, and should be very rare. */
1765 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1768 restart_gr
= save_gr
;
1769 restart_fr
= save_fr
;
1777 /* Return the address of the PC after the last prologue instruction if
1778 we can determine it from the debug symbols. Else return zero. */
1781 after_prologue (CORE_ADDR pc
)
1783 struct symtab_and_line sal
;
1784 CORE_ADDR func_addr
, func_end
;
1786 /* If we can not find the symbol in the partial symbol table, then
1787 there is no hope we can determine the function's start address
1789 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1792 /* Get the line associated with FUNC_ADDR. */
1793 sal
= find_pc_line (func_addr
, 0);
1795 /* There are only two cases to consider. First, the end of the source line
1796 is within the function bounds. In that case we return the end of the
1797 source line. Second is the end of the source line extends beyond the
1798 bounds of the current function. We need to use the slow code to
1799 examine instructions in that case.
1801 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1802 the wrong thing to do. In fact, it should be entirely possible for this
1803 function to always return zero since the slow instruction scanning code
1804 is supposed to *always* work. If it does not, then it is a bug. */
1805 if (sal
.end
< func_end
)
1811 /* To skip prologues, I use this predicate. Returns either PC itself
1812 if the code at PC does not look like a function prologue; otherwise
1813 returns an address that (if we're lucky) follows the prologue.
1815 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1816 It doesn't necessarily skips all the insns in the prologue. In fact
1817 we might not want to skip all the insns because a prologue insn may
1818 appear in the delay slot of the first branch, and we don't want to
1819 skip over the branch in that case. */
1822 hppa_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1824 CORE_ADDR post_prologue_pc
;
1826 /* See if we can determine the end of the prologue via the symbol table.
1827 If so, then return either PC, or the PC after the prologue, whichever
1830 post_prologue_pc
= after_prologue (pc
);
1832 /* If after_prologue returned a useful address, then use it. Else
1833 fall back on the instruction skipping code.
1835 Some folks have claimed this causes problems because the breakpoint
1836 may be the first instruction of the prologue. If that happens, then
1837 the instruction skipping code has a bug that needs to be fixed. */
1838 if (post_prologue_pc
!= 0)
1839 return std::max (pc
, post_prologue_pc
);
1841 return (skip_prologue_hard_way (gdbarch
, pc
, 1));
1844 /* Return an unwind entry that falls within the frame's code block. */
1846 static struct unwind_table_entry
*
1847 hppa_find_unwind_entry_in_block (struct frame_info
*this_frame
)
1849 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
1851 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1852 result of get_frame_address_in_block implies a problem.
1853 The bits should have been removed earlier, before the return
1854 value of gdbarch_unwind_pc. That might be happening already;
1855 if it isn't, it should be fixed. Then this call can be
1857 pc
= gdbarch_addr_bits_remove (get_frame_arch (this_frame
), pc
);
1858 return find_unwind_entry (pc
);
1861 struct hppa_frame_cache
1864 trad_frame_saved_reg
*saved_regs
;
1867 static struct hppa_frame_cache
*
1868 hppa_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1870 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1871 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1872 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1873 struct hppa_frame_cache
*cache
;
1877 struct unwind_table_entry
*u
;
1878 CORE_ADDR prologue_end
;
1883 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1884 frame_relative_level(this_frame
));
1886 if ((*this_cache
) != NULL
)
1889 fprintf_unfiltered (gdb_stdlog
, "base=%s (cached) }",
1890 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
1891 return (struct hppa_frame_cache
*) (*this_cache
);
1893 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1894 (*this_cache
) = cache
;
1895 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1898 u
= hppa_find_unwind_entry_in_block (this_frame
);
1902 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1903 return (struct hppa_frame_cache
*) (*this_cache
);
1906 /* Turn the Entry_GR field into a bitmask. */
1908 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1910 /* Frame pointer gets saved into a special location. */
1911 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1914 saved_gr_mask
|= (1 << i
);
1917 /* Turn the Entry_FR field into a bitmask too. */
1919 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1920 saved_fr_mask
|= (1 << i
);
1922 /* Loop until we find everything of interest or hit a branch.
1924 For unoptimized GCC code and for any HP CC code this will never ever
1925 examine any user instructions.
1927 For optimized GCC code we're faced with problems. GCC will schedule
1928 its prologue and make prologue instructions available for delay slot
1929 filling. The end result is user code gets mixed in with the prologue
1930 and a prologue instruction may be in the delay slot of the first branch
1933 Some unexpected things are expected with debugging optimized code, so
1934 we allow this routine to walk past user instructions in optimized
1937 int final_iteration
= 0;
1938 CORE_ADDR pc
, start_pc
, end_pc
;
1939 int looking_for_sp
= u
->Save_SP
;
1940 int looking_for_rp
= u
->Save_RP
;
1943 /* We have to use skip_prologue_hard_way instead of just
1944 skip_prologue_using_sal, in case we stepped into a function without
1945 symbol information. hppa_skip_prologue also bounds the returned
1946 pc by the passed in pc, so it will not return a pc in the next
1949 We used to call hppa_skip_prologue to find the end of the prologue,
1950 but if some non-prologue instructions get scheduled into the prologue,
1951 and the program is compiled with debug information, the "easy" way
1952 in hppa_skip_prologue will return a prologue end that is too early
1953 for us to notice any potential frame adjustments. */
1955 /* We used to use get_frame_func to locate the beginning of the
1956 function to pass to skip_prologue. However, when objects are
1957 compiled without debug symbols, get_frame_func can return the wrong
1958 function (or 0). We can do better than that by using unwind records.
1959 This only works if the Region_description of the unwind record
1960 indicates that it includes the entry point of the function.
1961 HP compilers sometimes generate unwind records for regions that
1962 do not include the entry or exit point of a function. GNU tools
1965 if ((u
->Region_description
& 0x2) == 0)
1966 start_pc
= u
->region_start
;
1968 start_pc
= get_frame_func (this_frame
);
1970 prologue_end
= skip_prologue_hard_way (gdbarch
, start_pc
, 0);
1971 end_pc
= get_frame_pc (this_frame
);
1973 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1974 end_pc
= prologue_end
;
1979 ((saved_gr_mask
|| saved_fr_mask
1980 || looking_for_sp
|| looking_for_rp
1981 || frame_size
< (u
->Total_frame_size
<< 3))
1989 if (!safe_frame_unwind_memory (this_frame
, pc
, buf4
))
1991 error (_("Cannot read instruction at %s."),
1992 paddress (gdbarch
, pc
));
1993 return (struct hppa_frame_cache
*) (*this_cache
);
1996 inst
= extract_unsigned_integer (buf4
, sizeof buf4
, byte_order
);
1998 /* Note the interesting effects of this instruction. */
1999 frame_size
+= prologue_inst_adjust_sp (inst
);
2001 /* There are limited ways to store the return pointer into the
2003 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2006 cache
->saved_regs
[HPPA_RP_REGNUM
].set_addr (-20);
2008 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
2011 cache
->saved_regs
[HPPA_RP_REGNUM
].set_addr (-24);
2013 else if (inst
== 0x0fc212c1
2014 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2017 cache
->saved_regs
[HPPA_RP_REGNUM
].set_addr (-16);
2020 /* Check to see if we saved SP into the stack. This also
2021 happens to indicate the location of the saved frame
2023 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
2024 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2027 cache
->saved_regs
[HPPA_FP_REGNUM
].set_addr (0);
2029 else if (inst
== 0x08030241) /* copy %r3, %r1 */
2034 /* Account for general and floating-point register saves. */
2035 reg
= inst_saves_gr (inst
);
2036 if (reg
>= 3 && reg
<= 18
2037 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
2039 saved_gr_mask
&= ~(1 << reg
);
2040 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
2041 /* stwm with a positive displacement is a _post_
2043 cache
->saved_regs
[reg
].set_addr (0);
2044 else if ((inst
& 0xfc00000c) == 0x70000008)
2045 /* A std has explicit post_modify forms. */
2046 cache
->saved_regs
[reg
].set_addr (0);
2051 if ((inst
>> 26) == 0x1c)
2052 offset
= (inst
& 0x1 ? -(1 << 13) : 0)
2053 | (((inst
>> 4) & 0x3ff) << 3);
2054 else if ((inst
>> 26) == 0x03)
2055 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
2057 offset
= hppa_extract_14 (inst
);
2059 /* Handle code with and without frame pointers. */
2061 cache
->saved_regs
[reg
].set_addr (offset
);
2063 cache
->saved_regs
[reg
].set_addr ((u
->Total_frame_size
<< 3)
2068 /* GCC handles callee saved FP regs a little differently.
2070 It emits an instruction to put the value of the start of
2071 the FP store area into %r1. It then uses fstds,ma with a
2072 basereg of %r1 for the stores.
2074 HP CC emits them at the current stack pointer modifying the
2075 stack pointer as it stores each register. */
2077 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2078 if ((inst
& 0xffffc000) == 0x34610000
2079 || (inst
& 0xffffc000) == 0x37c10000)
2080 fp_loc
= hppa_extract_14 (inst
);
2082 reg
= inst_saves_fr (inst
);
2083 if (reg
>= 12 && reg
<= 21)
2085 /* Note +4 braindamage below is necessary because the FP
2086 status registers are internally 8 registers rather than
2087 the expected 4 registers. */
2088 saved_fr_mask
&= ~(1 << reg
);
2091 /* 1st HP CC FP register store. After this
2092 instruction we've set enough state that the GCC and
2093 HPCC code are both handled in the same manner. */
2094 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].set_addr (0);
2099 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].set_addr (fp_loc
);
2104 /* Quit if we hit any kind of branch the previous iteration. */
2105 if (final_iteration
)
2107 /* We want to look precisely one instruction beyond the branch
2108 if we have not found everything yet. */
2109 if (is_branch (inst
))
2110 final_iteration
= 1;
2115 /* The frame base always represents the value of %sp at entry to
2116 the current function (and is thus equivalent to the "saved"
2118 CORE_ADDR this_sp
= get_frame_register_unsigned (this_frame
,
2123 fprintf_unfiltered (gdb_stdlog
, " (this_sp=%s, pc=%s, "
2124 "prologue_end=%s) ",
2125 paddress (gdbarch
, this_sp
),
2126 paddress (gdbarch
, get_frame_pc (this_frame
)),
2127 paddress (gdbarch
, prologue_end
));
2129 /* Check to see if a frame pointer is available, and use it for
2130 frame unwinding if it is.
2132 There are some situations where we need to rely on the frame
2133 pointer to do stack unwinding. For example, if a function calls
2134 alloca (), the stack pointer can get adjusted inside the body of
2135 the function. In this case, the ABI requires that the compiler
2136 maintain a frame pointer for the function.
2138 The unwind record has a flag (alloca_frame) that indicates that
2139 a function has a variable frame; unfortunately, gcc/binutils
2140 does not set this flag. Instead, whenever a frame pointer is used
2141 and saved on the stack, the Save_SP flag is set. We use this to
2142 decide whether to use the frame pointer for unwinding.
2144 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2145 instead of Save_SP. */
2147 fp
= get_frame_register_unsigned (this_frame
, HPPA_FP_REGNUM
);
2149 if (u
->alloca_frame
)
2150 fp
-= u
->Total_frame_size
<< 3;
2152 if (get_frame_pc (this_frame
) >= prologue_end
2153 && (u
->Save_SP
|| u
->alloca_frame
) && fp
!= 0)
2158 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [frame pointer]",
2159 paddress (gdbarch
, cache
->base
));
2162 && cache
->saved_regs
[HPPA_SP_REGNUM
].is_addr ())
2164 /* Both we're expecting the SP to be saved and the SP has been
2165 saved. The entry SP value is saved at this frame's SP
2167 cache
->base
= read_memory_integer (this_sp
, word_size
, byte_order
);
2170 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [saved]",
2171 paddress (gdbarch
, cache
->base
));
2175 /* The prologue has been slowly allocating stack space. Adjust
2177 cache
->base
= this_sp
- frame_size
;
2179 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [unwind adjust]",
2180 paddress (gdbarch
, cache
->base
));
2183 cache
->saved_regs
[HPPA_SP_REGNUM
].set_value (cache
->base
);
2186 /* The PC is found in the "return register", "Millicode" uses "r31"
2187 as the return register while normal code uses "rp". */
2190 if (cache
->saved_regs
[31].is_addr ())
2192 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2194 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2198 ULONGEST r31
= get_frame_register_unsigned (this_frame
, 31);
2199 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].set_value (r31
);
2201 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2206 if (cache
->saved_regs
[HPPA_RP_REGNUM
].is_addr ())
2208 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2209 cache
->saved_regs
[HPPA_RP_REGNUM
];
2211 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2215 ULONGEST rp
= get_frame_register_unsigned (this_frame
,
2217 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].set_value (rp
);
2219 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2223 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2224 frame. However, there is a one-insn window where we haven't saved it
2225 yet, but we've already clobbered it. Detect this case and fix it up.
2227 The prologue sequence for frame-pointer functions is:
2228 0: stw %rp, -20(%sp)
2231 c: stw,ma %r1, XX(%sp)
2233 So if we are at offset c, the r3 value that we want is not yet saved
2234 on the stack, but it's been overwritten. The prologue analyzer will
2235 set fp_in_r1 when it sees the copy insn so we know to get the value
2237 if (u
->Save_SP
&& !cache
->saved_regs
[HPPA_FP_REGNUM
].is_addr ()
2240 ULONGEST r1
= get_frame_register_unsigned (this_frame
, 1);
2241 cache
->saved_regs
[HPPA_FP_REGNUM
].set_value (r1
);
2245 /* Convert all the offsets into addresses. */
2247 for (reg
= 0; reg
< gdbarch_num_regs (gdbarch
); reg
++)
2249 if (cache
->saved_regs
[reg
].is_addr ())
2250 cache
->saved_regs
[reg
].set_addr (cache
->saved_regs
[reg
].addr ()
2256 struct gdbarch_tdep
*tdep
;
2258 tdep
= gdbarch_tdep (gdbarch
);
2260 if (tdep
->unwind_adjust_stub
)
2261 tdep
->unwind_adjust_stub (this_frame
, cache
->base
, cache
->saved_regs
);
2265 fprintf_unfiltered (gdb_stdlog
, "base=%s }",
2266 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
2267 return (struct hppa_frame_cache
*) (*this_cache
);
2271 hppa_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2272 struct frame_id
*this_id
)
2274 struct hppa_frame_cache
*info
;
2275 struct unwind_table_entry
*u
;
2277 info
= hppa_frame_cache (this_frame
, this_cache
);
2278 u
= hppa_find_unwind_entry_in_block (this_frame
);
2280 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2283 static struct value
*
2284 hppa_frame_prev_register (struct frame_info
*this_frame
,
2285 void **this_cache
, int regnum
)
2287 struct hppa_frame_cache
*info
= hppa_frame_cache (this_frame
, this_cache
);
2289 return hppa_frame_prev_register_helper (this_frame
,
2290 info
->saved_regs
, regnum
);
2294 hppa_frame_unwind_sniffer (const struct frame_unwind
*self
,
2295 struct frame_info
*this_frame
, void **this_cache
)
2297 if (hppa_find_unwind_entry_in_block (this_frame
))
2303 static const struct frame_unwind hppa_frame_unwind
=
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
=
2418 default_frame_unwind_stop_reason
,
2419 hppa_fallback_frame_this_id
,
2420 hppa_fallback_frame_prev_register
,
2422 default_frame_sniffer
2425 /* Stub frames, used for all kinds of call stubs. */
2426 struct hppa_stub_unwind_cache
2429 trad_frame_saved_reg
*saved_regs
;
2432 static struct hppa_stub_unwind_cache
*
2433 hppa_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2436 struct hppa_stub_unwind_cache
*info
;
2439 return (struct hppa_stub_unwind_cache
*) *this_cache
;
2441 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2443 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2445 info
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2447 /* By default we assume that stubs do not change the rp. */
2448 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].set_realreg (HPPA_RP_REGNUM
);
2454 hppa_stub_frame_this_id (struct frame_info
*this_frame
,
2455 void **this_prologue_cache
,
2456 struct frame_id
*this_id
)
2458 struct hppa_stub_unwind_cache
*info
2459 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2462 *this_id
= frame_id_build (info
->base
, get_frame_func (this_frame
));
2465 static struct value
*
2466 hppa_stub_frame_prev_register (struct frame_info
*this_frame
,
2467 void **this_prologue_cache
, int regnum
)
2469 struct hppa_stub_unwind_cache
*info
2470 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2473 error (_("Requesting registers from null frame."));
2475 return hppa_frame_prev_register_helper (this_frame
,
2476 info
->saved_regs
, regnum
);
2480 hppa_stub_unwind_sniffer (const struct frame_unwind
*self
,
2481 struct frame_info
*this_frame
,
2484 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
2485 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2486 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2489 || (tdep
->in_solib_call_trampoline
!= NULL
2490 && tdep
->in_solib_call_trampoline (gdbarch
, pc
))
2491 || gdbarch_in_solib_return_trampoline (gdbarch
, pc
, NULL
))
2496 static const struct frame_unwind hppa_stub_frame_unwind
= {
2498 default_frame_unwind_stop_reason
,
2499 hppa_stub_frame_this_id
,
2500 hppa_stub_frame_prev_register
,
2502 hppa_stub_unwind_sniffer
2506 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2511 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2512 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2514 /* If the current instruction is nullified, then we are effectively
2515 still executing the previous instruction. Pretend we are still
2516 there. This is needed when single stepping; if the nullified
2517 instruction is on a different line, we don't want GDB to think
2518 we've stepped onto that line. */
2519 if (ipsw
& 0x00200000)
2525 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2526 Return NULL if no such symbol was found. */
2528 struct bound_minimal_symbol
2529 hppa_lookup_stub_minimal_symbol (const char *name
,
2530 enum unwind_stub_types stub_type
)
2532 struct bound_minimal_symbol result
= { NULL
, NULL
};
2534 for (objfile
*objfile
: current_program_space
->objfiles ())
2536 for (minimal_symbol
*msym
: objfile
->msymbols ())
2538 if (strcmp (msym
->linkage_name (), name
) == 0)
2540 struct unwind_table_entry
*u
;
2542 u
= find_unwind_entry (MSYMBOL_VALUE (msym
));
2543 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2545 result
.objfile
= objfile
;
2546 result
.minsym
= msym
;
2557 unwind_command (const char *exp
, int from_tty
)
2560 struct unwind_table_entry
*u
;
2562 /* If we have an expression, evaluate it and use it as the address. */
2564 if (exp
!= 0 && *exp
!= 0)
2565 address
= parse_and_eval_address (exp
);
2569 u
= find_unwind_entry (address
);
2573 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2577 printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u
));
2579 printf_unfiltered ("\tregion_start = %s\n", hex_string (u
->region_start
));
2581 printf_unfiltered ("\tregion_end = %s\n", hex_string (u
->region_end
));
2583 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2585 printf_unfiltered ("\n\tflags =");
2586 pif (Cannot_unwind
);
2588 pif (Millicode_save_sr0
);
2591 pif (Variable_Frame
);
2592 pif (Separate_Package_Body
);
2593 pif (Frame_Extension_Millicode
);
2594 pif (Stack_Overflow_Check
);
2595 pif (Two_Instruction_SP_Increment
);
2598 pif (cxx_try_catch
);
2599 pif (sched_entry_seq
);
2602 pif (Save_MRP_in_frame
);
2604 pif (Cleanup_defined
);
2605 pif (MPE_XL_interrupt_marker
);
2606 pif (HP_UX_interrupt_marker
);
2610 putchar_unfiltered ('\n');
2612 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2614 pin (Region_description
);
2617 pin (Total_frame_size
);
2619 if (u
->stub_unwind
.stub_type
)
2621 printf_unfiltered ("\tstub type = ");
2622 switch (u
->stub_unwind
.stub_type
)
2625 printf_unfiltered ("long branch\n");
2627 case PARAMETER_RELOCATION
:
2628 printf_unfiltered ("parameter relocation\n");
2631 printf_unfiltered ("export\n");
2634 printf_unfiltered ("import\n");
2637 printf_unfiltered ("import shlib\n");
2640 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2645 /* Return the GDB type object for the "standard" data type of data in
2648 static struct type
*
2649 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2651 if (regnum
< HPPA_FP4_REGNUM
)
2652 return builtin_type (gdbarch
)->builtin_uint32
;
2654 return builtin_type (gdbarch
)->builtin_float
;
2657 static struct type
*
2658 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2660 if (regnum
< HPPA64_FP4_REGNUM
)
2661 return builtin_type (gdbarch
)->builtin_uint64
;
2663 return builtin_type (gdbarch
)->builtin_double
;
2666 /* Return non-zero if REGNUM is not a register available to the user
2667 through ptrace/ttrace. */
2670 hppa32_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2673 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2674 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2675 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2679 hppa32_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2681 /* cr26 and cr27 are readable (but not writable) from userspace. */
2682 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2685 return hppa32_cannot_store_register (gdbarch
, regnum
);
2689 hppa64_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2692 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2693 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2694 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2698 hppa64_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2700 /* cr26 and cr27 are readable (but not writable) from userspace. */
2701 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2704 return hppa64_cannot_store_register (gdbarch
, regnum
);
2708 hppa_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2710 /* The low two bits of the PC on the PA contain the privilege level.
2711 Some genius implementing a (non-GCC) compiler apparently decided
2712 this means that "addresses" in a text section therefore include a
2713 privilege level, and thus symbol tables should contain these bits.
2714 This seems like a bonehead thing to do--anyway, it seems to work
2715 for our purposes to just ignore those bits. */
2717 return (addr
&= ~0x3);
2720 /* Get the ARGIth function argument for the current function. */
2723 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2726 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2729 static enum register_status
2730 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, readable_regcache
*regcache
,
2731 int regnum
, gdb_byte
*buf
)
2733 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2735 enum register_status status
;
2737 status
= regcache
->raw_read (regnum
, &tmp
);
2738 if (status
== REG_VALID
)
2740 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2742 store_unsigned_integer (buf
, sizeof tmp
, byte_order
, tmp
);
2748 hppa_find_global_pointer (struct gdbarch
*gdbarch
, struct value
*function
)
2754 hppa_frame_prev_register_helper (struct frame_info
*this_frame
,
2755 trad_frame_saved_reg saved_regs
[],
2758 struct gdbarch
*arch
= get_frame_arch (this_frame
);
2759 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2761 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2763 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2765 struct value
*pcoq_val
=
2766 trad_frame_get_prev_register (this_frame
, saved_regs
,
2767 HPPA_PCOQ_HEAD_REGNUM
);
2769 pc
= extract_unsigned_integer (value_contents_all (pcoq_val
),
2771 return frame_unwind_got_constant (this_frame
, regnum
, pc
+ 4);
2774 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
2778 /* An instruction to match. */
2781 unsigned int data
; /* See if it matches this.... */
2782 unsigned int mask
; /* ... with this mask. */
2785 /* See bfd/elf32-hppa.c */
2786 static struct insn_pattern hppa_long_branch_stub
[] = {
2787 /* ldil LR'xxx,%r1 */
2788 { 0x20200000, 0xffe00000 },
2789 /* be,n RR'xxx(%sr4,%r1) */
2790 { 0xe0202002, 0xffe02002 },
2794 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
2796 { 0xe8200000, 0xffe00000 },
2797 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2798 { 0x28200000, 0xffe00000 },
2799 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2800 { 0xe0202002, 0xffe02002 },
2804 static struct insn_pattern hppa_import_stub
[] = {
2805 /* addil LR'xxx, %dp */
2806 { 0x2b600000, 0xffe00000 },
2807 /* ldw RR'xxx(%r1), %r21 */
2808 { 0x48350000, 0xffffb000 },
2810 { 0xeaa0c000, 0xffffffff },
2811 /* ldw RR'xxx+4(%r1), %r19 */
2812 { 0x48330000, 0xffffb000 },
2816 static struct insn_pattern hppa_import_pic_stub
[] = {
2817 /* addil LR'xxx,%r19 */
2818 { 0x2a600000, 0xffe00000 },
2819 /* ldw RR'xxx(%r1),%r21 */
2820 { 0x48350000, 0xffffb000 },
2822 { 0xeaa0c000, 0xffffffff },
2823 /* ldw RR'xxx+4(%r1),%r19 */
2824 { 0x48330000, 0xffffb000 },
2828 static struct insn_pattern hppa_plt_stub
[] = {
2829 /* b,l 1b, %r20 - 1b is 3 insns before here */
2830 { 0xea9f1fdd, 0xffffffff },
2831 /* depi 0,31,2,%r20 */
2832 { 0xd6801c1e, 0xffffffff },
2836 /* Maximum number of instructions on the patterns above. */
2837 #define HPPA_MAX_INSN_PATTERN_LEN 4
2839 /* Return non-zero if the instructions at PC match the series
2840 described in PATTERN, or zero otherwise. PATTERN is an array of
2841 'struct insn_pattern' objects, terminated by an entry whose mask is
2844 When the match is successful, fill INSN[i] with what PATTERN[i]
2848 hppa_match_insns (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2849 struct insn_pattern
*pattern
, unsigned int *insn
)
2851 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2855 for (i
= 0; pattern
[i
].mask
; i
++)
2857 gdb_byte buf
[HPPA_INSN_SIZE
];
2859 target_read_memory (npc
, buf
, HPPA_INSN_SIZE
);
2860 insn
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
, byte_order
);
2861 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
2870 /* This relaxed version of the instruction matcher allows us to match
2871 from somewhere inside the pattern, by looking backwards in the
2872 instruction scheme. */
2875 hppa_match_insns_relaxed (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2876 struct insn_pattern
*pattern
, unsigned int *insn
)
2878 int offset
, len
= 0;
2880 while (pattern
[len
].mask
)
2883 for (offset
= 0; offset
< len
; offset
++)
2884 if (hppa_match_insns (gdbarch
, pc
- offset
* HPPA_INSN_SIZE
,
2892 hppa_in_dyncall (CORE_ADDR pc
)
2894 struct unwind_table_entry
*u
;
2896 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2900 return (pc
>= u
->region_start
&& pc
<= u
->region_end
);
2904 hppa_in_solib_call_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2906 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2907 struct unwind_table_entry
*u
;
2909 if (in_plt_section (pc
) || hppa_in_dyncall (pc
))
2912 /* The GNU toolchain produces linker stubs without unwind
2913 information. Since the pattern matching for linker stubs can be
2914 quite slow, so bail out if we do have an unwind entry. */
2916 u
= find_unwind_entry (pc
);
2921 (hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_stub
, insn
)
2922 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_pic_stub
, insn
)
2923 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_long_branch_stub
, insn
)
2924 || hppa_match_insns_relaxed (gdbarch
, pc
,
2925 hppa_long_branch_pic_stub
, insn
));
2928 /* This code skips several kind of "trampolines" used on PA-RISC
2929 systems: $$dyncall, import stubs and PLT stubs. */
2932 hppa_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
2934 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2935 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
2937 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2940 /* $$dyncall handles both PLABELs and direct addresses. */
2941 if (hppa_in_dyncall (pc
))
2943 pc
= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 22);
2945 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2947 pc
= read_memory_typed_address (pc
& ~0x3, func_ptr_type
);
2952 dp_rel
= hppa_match_insns (gdbarch
, pc
, hppa_import_stub
, insn
);
2953 if (dp_rel
|| hppa_match_insns (gdbarch
, pc
, hppa_import_pic_stub
, insn
))
2955 /* Extract the target address from the addil/ldw sequence. */
2956 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
2959 pc
+= get_frame_register_unsigned (frame
, HPPA_DP_REGNUM
);
2961 pc
+= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 19);
2966 if (in_plt_section (pc
))
2968 pc
= read_memory_typed_address (pc
, func_ptr_type
);
2970 /* If the PLT slot has not yet been resolved, the target will be
2972 if (in_plt_section (pc
))
2974 /* Sanity check: are we pointing to the PLT stub? */
2975 if (!hppa_match_insns (gdbarch
, pc
, hppa_plt_stub
, insn
))
2977 warning (_("Cannot resolve PLT stub at %s."),
2978 paddress (gdbarch
, pc
));
2982 /* This should point to the fixup routine. */
2983 pc
= read_memory_typed_address (pc
+ 8, func_ptr_type
);
2991 /* Here is a table of C type sizes on hppa with various compiles
2992 and options. I measured this on PA 9000/800 with HP-UX 11.11
2993 and these compilers:
2995 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2996 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2997 /opt/aCC/bin/aCC B3910B A.03.45
2998 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3000 cc : 1 2 4 4 8 : 4 8 -- : 4 4
3001 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3002 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3003 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3004 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3005 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3006 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3007 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3011 compiler and options
3012 char, short, int, long, long long
3013 float, double, long double
3016 So all these compilers use either ILP32 or LP64 model.
3017 TODO: gcc has more options so it needs more investigation.
3019 For floating point types, see:
3021 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3022 HP-UX floating-point guide, hpux 11.00
3024 -- chastain 2003-12-18 */
3026 static struct gdbarch
*
3027 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3029 struct gdbarch_tdep
*tdep
;
3030 struct gdbarch
*gdbarch
;
3032 /* find a candidate among the list of pre-declared architectures. */
3033 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3035 return (arches
->gdbarch
);
3037 /* If none found, then allocate and initialize one. */
3038 tdep
= XCNEW (struct gdbarch_tdep
);
3039 gdbarch
= gdbarch_alloc (&info
, tdep
);
3041 /* Determine from the bfd_arch_info structure if we are dealing with
3042 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3043 then default to a 32bit machine. */
3044 if (info
.bfd_arch_info
!= NULL
)
3045 tdep
->bytes_per_address
=
3046 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3048 tdep
->bytes_per_address
= 4;
3050 tdep
->find_global_pointer
= hppa_find_global_pointer
;
3052 /* Some parts of the gdbarch vector depend on whether we are running
3053 on a 32 bits or 64 bits target. */
3054 switch (tdep
->bytes_per_address
)
3057 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3058 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3059 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3060 set_gdbarch_cannot_store_register (gdbarch
,
3061 hppa32_cannot_store_register
);
3062 set_gdbarch_cannot_fetch_register (gdbarch
,
3063 hppa32_cannot_fetch_register
);
3066 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3067 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3068 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3069 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3070 set_gdbarch_cannot_store_register (gdbarch
,
3071 hppa64_cannot_store_register
);
3072 set_gdbarch_cannot_fetch_register (gdbarch
,
3073 hppa64_cannot_fetch_register
);
3076 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
3077 tdep
->bytes_per_address
);
3080 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3081 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3083 /* The following gdbarch vector elements are the same in both ILP32
3084 and LP64, but might show differences some day. */
3085 set_gdbarch_long_long_bit (gdbarch
, 64);
3086 set_gdbarch_long_double_bit (gdbarch
, 128);
3087 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3089 /* The following gdbarch vector elements do not depend on the address
3090 size, or in any other gdbarch element previously set. */
3091 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3092 set_gdbarch_stack_frame_destroyed_p (gdbarch
,
3093 hppa_stack_frame_destroyed_p
);
3094 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
3095 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3096 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3097 set_gdbarch_addr_bits_remove (gdbarch
, hppa_addr_bits_remove
);
3098 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3099 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
3100 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
3102 /* Helper for function argument information. */
3103 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3105 /* When a hardware watchpoint triggers, we'll move the inferior past
3106 it by removing all eventpoints; stepping past the instruction
3107 that caused the trigger; reinserting eventpoints; and checking
3108 whether any watched location changed. */
3109 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3111 /* Inferior function call methods. */
3112 switch (tdep
->bytes_per_address
)
3115 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3116 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3117 set_gdbarch_convert_from_func_ptr_addr
3118 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
3121 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3122 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3125 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3128 /* Struct return methods. */
3129 switch (tdep
->bytes_per_address
)
3132 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3135 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3138 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3141 set_gdbarch_breakpoint_kind_from_pc (gdbarch
, hppa_breakpoint::kind_from_pc
);
3142 set_gdbarch_sw_breakpoint_from_kind (gdbarch
, hppa_breakpoint::bp_from_kind
);
3143 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
3145 /* Frame unwind methods. */
3146 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3148 /* Hook in ABI-specific overrides, if they have been registered. */
3149 gdbarch_init_osabi (info
, gdbarch
);
3151 /* Hook in the default unwinders. */
3152 frame_unwind_append_unwinder (gdbarch
, &hppa_stub_frame_unwind
);
3153 frame_unwind_append_unwinder (gdbarch
, &hppa_frame_unwind
);
3154 frame_unwind_append_unwinder (gdbarch
, &hppa_fallback_frame_unwind
);
3160 hppa_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
3162 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3164 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
3165 tdep
->bytes_per_address
);
3166 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
3169 void _initialize_hppa_tdep ();
3171 _initialize_hppa_tdep ()
3173 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3175 add_cmd ("unwind", class_maintenance
, unwind_command
,
3176 _("Print unwind table entry at given address."),
3177 &maintenanceprintlist
);
3179 /* Debug this files internals. */
3180 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
3181 Set whether hppa target specific debugging information should be displayed."),
3183 Show whether hppa target specific debugging information is displayed."), _("\
3184 This flag controls whether hppa target specific debugging information is\n\
3185 displayed. This information is particularly useful for debugging frame\n\
3186 unwinding problems."),
3188 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
3189 &setdebuglist
, &showdebuglist
);