1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986-2015 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"
43 static int hppa_debug
= 0;
45 /* Some local constants. */
46 static const int hppa32_num_regs
= 128;
47 static const int hppa64_num_regs
= 96;
49 /* hppa-specific object data -- unwind and solib info.
50 TODO/maybe: think about splitting this into two parts; the unwind data is
51 common to all hppa targets, but is only used in this file; we can register
52 that separately and make this static. The solib data is probably hpux-
53 specific, so we can create a separate extern objfile_data that is registered
54 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
55 const struct objfile_data
*hppa_objfile_priv_data
= NULL
;
57 /* Get at various relevent fields of an instruction word. */
60 #define MASK_14 0x3fff
61 #define MASK_21 0x1fffff
63 /* Sizes (in bytes) of the native unwind entries. */
64 #define UNWIND_ENTRY_SIZE 16
65 #define STUB_UNWIND_ENTRY_SIZE 8
67 /* Routines to extract various sized constants out of hppa
70 /* This assumes that no garbage lies outside of the lower bits of
74 hppa_sign_extend (unsigned val
, unsigned bits
)
76 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
79 /* For many immediate values the sign bit is the low bit! */
82 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
84 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
87 /* Extract the bits at positions between FROM and TO, using HP's numbering
91 hppa_get_field (unsigned word
, int from
, int to
)
93 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
96 /* Extract the immediate field from a ld{bhw}s instruction. */
99 hppa_extract_5_load (unsigned word
)
101 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
104 /* Extract the immediate field from a break instruction. */
107 hppa_extract_5r_store (unsigned word
)
109 return (word
& MASK_5
);
112 /* Extract the immediate field from a {sr}sm instruction. */
115 hppa_extract_5R_store (unsigned word
)
117 return (word
>> 16 & MASK_5
);
120 /* Extract a 14 bit immediate field. */
123 hppa_extract_14 (unsigned word
)
125 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
128 /* Extract a 21 bit constant. */
131 hppa_extract_21 (unsigned word
)
137 val
= hppa_get_field (word
, 20, 20);
139 val
|= hppa_get_field (word
, 9, 19);
141 val
|= hppa_get_field (word
, 5, 6);
143 val
|= hppa_get_field (word
, 0, 4);
145 val
|= hppa_get_field (word
, 7, 8);
146 return hppa_sign_extend (val
, 21) << 11;
149 /* extract a 17 bit constant from branch instructions, returning the
150 19 bit signed value. */
153 hppa_extract_17 (unsigned word
)
155 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
156 hppa_get_field (word
, 29, 29) << 10 |
157 hppa_get_field (word
, 11, 15) << 11 |
158 (word
& 0x1) << 16, 17) << 2;
162 hppa_symbol_address(const char *sym
)
164 struct bound_minimal_symbol minsym
;
166 minsym
= lookup_minimal_symbol (sym
, NULL
, NULL
);
168 return BMSYMBOL_VALUE_ADDRESS (minsym
);
170 return (CORE_ADDR
)-1;
173 struct hppa_objfile_private
*
174 hppa_init_objfile_priv_data (struct objfile
*objfile
)
176 struct hppa_objfile_private
*priv
;
178 priv
= (struct hppa_objfile_private
*)
179 obstack_alloc (&objfile
->objfile_obstack
,
180 sizeof (struct hppa_objfile_private
));
181 set_objfile_data (objfile
, hppa_objfile_priv_data
, priv
);
182 memset (priv
, 0, sizeof (*priv
));
188 /* Compare the start address for two unwind entries returning 1 if
189 the first address is larger than the second, -1 if the second is
190 larger than the first, and zero if they are equal. */
193 compare_unwind_entries (const void *arg1
, const void *arg2
)
195 const struct unwind_table_entry
*a
= arg1
;
196 const struct unwind_table_entry
*b
= arg2
;
198 if (a
->region_start
> b
->region_start
)
200 else if (a
->region_start
< b
->region_start
)
207 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
209 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
210 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
212 bfd_vma value
= section
->vma
- section
->filepos
;
213 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
215 if (value
< *low_text_segment_address
)
216 *low_text_segment_address
= value
;
221 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
222 asection
*section
, unsigned int entries
,
223 size_t size
, CORE_ADDR text_offset
)
225 /* We will read the unwind entries into temporary memory, then
226 fill in the actual unwind table. */
230 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
233 char *buf
= alloca (size
);
234 CORE_ADDR low_text_segment_address
;
236 /* For ELF targets, then unwinds are supposed to
237 be segment relative offsets instead of absolute addresses.
239 Note that when loading a shared library (text_offset != 0) the
240 unwinds are already relative to the text_offset that will be
242 if (gdbarch_tdep (gdbarch
)->is_elf
&& text_offset
== 0)
244 low_text_segment_address
= -1;
246 bfd_map_over_sections (objfile
->obfd
,
247 record_text_segment_lowaddr
,
248 &low_text_segment_address
);
250 text_offset
= low_text_segment_address
;
252 else if (gdbarch_tdep (gdbarch
)->solib_get_text_base
)
254 text_offset
= gdbarch_tdep (gdbarch
)->solib_get_text_base (objfile
);
257 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
259 /* Now internalize the information being careful to handle host/target
261 for (i
= 0; i
< entries
; i
++)
263 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
265 table
[i
].region_start
+= text_offset
;
267 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
268 table
[i
].region_end
+= text_offset
;
270 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
272 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
273 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
274 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
275 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
276 table
[i
].reserved
= (tmp
>> 26) & 0x1;
277 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
278 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
279 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
280 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
281 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
282 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
283 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
284 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
285 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
286 table
[i
].sr4export
= (tmp
>> 9) & 0x1;
287 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
288 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
289 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
290 table
[i
].reserved1
= (tmp
>> 5) & 0x1;
291 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
292 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
293 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
294 table
[i
].save_r19
= (tmp
>> 1) & 0x1;
295 table
[i
].Cleanup_defined
= tmp
& 0x1;
296 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
298 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
299 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
300 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
301 table
[i
].alloca_frame
= (tmp
>> 28) & 0x1;
302 table
[i
].reserved2
= (tmp
>> 27) & 0x1;
303 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
305 /* Stub unwinds are handled elsewhere. */
306 table
[i
].stub_unwind
.stub_type
= 0;
307 table
[i
].stub_unwind
.padding
= 0;
312 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
313 the object file. This info is used mainly by find_unwind_entry() to find
314 out the stack frame size and frame pointer used by procedures. We put
315 everything on the psymbol obstack in the objfile so that it automatically
316 gets freed when the objfile is destroyed. */
319 read_unwind_info (struct objfile
*objfile
)
321 asection
*unwind_sec
, *stub_unwind_sec
;
322 size_t unwind_size
, stub_unwind_size
, total_size
;
323 unsigned index
, unwind_entries
;
324 unsigned stub_entries
, total_entries
;
325 CORE_ADDR text_offset
;
326 struct hppa_unwind_info
*ui
;
327 struct hppa_objfile_private
*obj_private
;
329 text_offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
330 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
331 sizeof (struct hppa_unwind_info
));
337 /* For reasons unknown the HP PA64 tools generate multiple unwinder
338 sections in a single executable. So we just iterate over every
339 section in the BFD looking for unwinder sections intead of trying
340 to do a lookup with bfd_get_section_by_name.
342 First determine the total size of the unwind tables so that we
343 can allocate memory in a nice big hunk. */
345 for (unwind_sec
= objfile
->obfd
->sections
;
347 unwind_sec
= unwind_sec
->next
)
349 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
350 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
352 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
353 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
355 total_entries
+= unwind_entries
;
359 /* Now compute the size of the stub unwinds. Note the ELF tools do not
360 use stub unwinds at the current time. */
361 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
365 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
366 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
370 stub_unwind_size
= 0;
374 /* Compute total number of unwind entries and their total size. */
375 total_entries
+= stub_entries
;
376 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
378 /* Allocate memory for the unwind table. */
379 ui
->table
= (struct unwind_table_entry
*)
380 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
381 ui
->last
= total_entries
- 1;
383 /* Now read in each unwind section and internalize the standard unwind
386 for (unwind_sec
= objfile
->obfd
->sections
;
388 unwind_sec
= unwind_sec
->next
)
390 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
391 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
393 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
394 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
396 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
397 unwind_entries
, unwind_size
, text_offset
);
398 index
+= unwind_entries
;
402 /* Now read in and internalize the stub unwind entries. */
403 if (stub_unwind_size
> 0)
406 char *buf
= alloca (stub_unwind_size
);
408 /* Read in the stub unwind entries. */
409 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
410 0, stub_unwind_size
);
412 /* Now convert them into regular unwind entries. */
413 for (i
= 0; i
< stub_entries
; i
++, index
++)
415 /* Clear out the next unwind entry. */
416 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
418 /* Convert offset & size into region_start and region_end.
419 Stuff away the stub type into "reserved" fields. */
420 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
422 ui
->table
[index
].region_start
+= text_offset
;
424 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
427 ui
->table
[index
].region_end
428 = ui
->table
[index
].region_start
+ 4 *
429 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
435 /* Unwind table needs to be kept sorted. */
436 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
437 compare_unwind_entries
);
439 /* Keep a pointer to the unwind information. */
440 obj_private
= (struct hppa_objfile_private
*)
441 objfile_data (objfile
, hppa_objfile_priv_data
);
442 if (obj_private
== NULL
)
443 obj_private
= hppa_init_objfile_priv_data (objfile
);
445 obj_private
->unwind_info
= ui
;
448 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
449 of the objfiles seeking the unwind table entry for this PC. Each objfile
450 contains a sorted list of struct unwind_table_entry. Since we do a binary
451 search of the unwind tables, we depend upon them to be sorted. */
453 struct unwind_table_entry
*
454 find_unwind_entry (CORE_ADDR pc
)
456 int first
, middle
, last
;
457 struct objfile
*objfile
;
458 struct hppa_objfile_private
*priv
;
461 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry %s -> ",
464 /* A function at address 0? Not in HP-UX! */
465 if (pc
== (CORE_ADDR
) 0)
468 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
472 ALL_OBJFILES (objfile
)
474 struct hppa_unwind_info
*ui
;
476 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
478 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
482 read_unwind_info (objfile
);
483 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
485 error (_("Internal error reading unwind information."));
486 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
489 /* First, check the cache. */
492 && pc
>= ui
->cache
->region_start
493 && pc
<= ui
->cache
->region_end
)
496 fprintf_unfiltered (gdb_stdlog
, "%s (cached) }\n",
497 hex_string ((uintptr_t) ui
->cache
));
501 /* Not in the cache, do a binary search. */
506 while (first
<= last
)
508 middle
= (first
+ last
) / 2;
509 if (pc
>= ui
->table
[middle
].region_start
510 && pc
<= ui
->table
[middle
].region_end
)
512 ui
->cache
= &ui
->table
[middle
];
514 fprintf_unfiltered (gdb_stdlog
, "%s }\n",
515 hex_string ((uintptr_t) ui
->cache
));
516 return &ui
->table
[middle
];
519 if (pc
< ui
->table
[middle
].region_start
)
524 } /* ALL_OBJFILES() */
527 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
532 /* The epilogue is defined here as the area either on the `bv' instruction
533 itself or an instruction which destroys the function's stack frame.
535 We do not assume that the epilogue is at the end of a function as we can
536 also have return sequences in the middle of a function. */
538 hppa_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
540 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
541 unsigned long status
;
545 status
= target_read_memory (pc
, buf
, 4);
549 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
551 /* The most common way to perform a stack adjustment ldo X(sp),sp
552 We are destroying a stack frame if the offset is negative. */
553 if ((inst
& 0xffffc000) == 0x37de0000
554 && hppa_extract_14 (inst
) < 0)
557 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
558 if (((inst
& 0x0fc010e0) == 0x0fc010e0
559 || (inst
& 0x0fc010e0) == 0x0fc010e0)
560 && hppa_extract_14 (inst
) < 0)
563 /* bv %r0(%rp) or bv,n %r0(%rp) */
564 if (inst
== 0xe840c000 || inst
== 0xe840c002)
570 static const unsigned char *
571 hppa_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
, int *len
)
573 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
574 (*len
) = sizeof (breakpoint
);
578 /* Return the name of a register. */
581 hppa32_register_name (struct gdbarch
*gdbarch
, int i
)
583 static char *names
[] = {
584 "flags", "r1", "rp", "r3",
585 "r4", "r5", "r6", "r7",
586 "r8", "r9", "r10", "r11",
587 "r12", "r13", "r14", "r15",
588 "r16", "r17", "r18", "r19",
589 "r20", "r21", "r22", "r23",
590 "r24", "r25", "r26", "dp",
591 "ret0", "ret1", "sp", "r31",
592 "sar", "pcoqh", "pcsqh", "pcoqt",
593 "pcsqt", "eiem", "iir", "isr",
594 "ior", "ipsw", "goto", "sr4",
595 "sr0", "sr1", "sr2", "sr3",
596 "sr5", "sr6", "sr7", "cr0",
597 "cr8", "cr9", "ccr", "cr12",
598 "cr13", "cr24", "cr25", "cr26",
599 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
600 "fpsr", "fpe1", "fpe2", "fpe3",
601 "fpe4", "fpe5", "fpe6", "fpe7",
602 "fr4", "fr4R", "fr5", "fr5R",
603 "fr6", "fr6R", "fr7", "fr7R",
604 "fr8", "fr8R", "fr9", "fr9R",
605 "fr10", "fr10R", "fr11", "fr11R",
606 "fr12", "fr12R", "fr13", "fr13R",
607 "fr14", "fr14R", "fr15", "fr15R",
608 "fr16", "fr16R", "fr17", "fr17R",
609 "fr18", "fr18R", "fr19", "fr19R",
610 "fr20", "fr20R", "fr21", "fr21R",
611 "fr22", "fr22R", "fr23", "fr23R",
612 "fr24", "fr24R", "fr25", "fr25R",
613 "fr26", "fr26R", "fr27", "fr27R",
614 "fr28", "fr28R", "fr29", "fr29R",
615 "fr30", "fr30R", "fr31", "fr31R"
617 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
624 hppa64_register_name (struct gdbarch
*gdbarch
, int i
)
626 static char *names
[] = {
627 "flags", "r1", "rp", "r3",
628 "r4", "r5", "r6", "r7",
629 "r8", "r9", "r10", "r11",
630 "r12", "r13", "r14", "r15",
631 "r16", "r17", "r18", "r19",
632 "r20", "r21", "r22", "r23",
633 "r24", "r25", "r26", "dp",
634 "ret0", "ret1", "sp", "r31",
635 "sar", "pcoqh", "pcsqh", "pcoqt",
636 "pcsqt", "eiem", "iir", "isr",
637 "ior", "ipsw", "goto", "sr4",
638 "sr0", "sr1", "sr2", "sr3",
639 "sr5", "sr6", "sr7", "cr0",
640 "cr8", "cr9", "ccr", "cr12",
641 "cr13", "cr24", "cr25", "cr26",
642 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
643 "fpsr", "fpe1", "fpe2", "fpe3",
644 "fr4", "fr5", "fr6", "fr7",
645 "fr8", "fr9", "fr10", "fr11",
646 "fr12", "fr13", "fr14", "fr15",
647 "fr16", "fr17", "fr18", "fr19",
648 "fr20", "fr21", "fr22", "fr23",
649 "fr24", "fr25", "fr26", "fr27",
650 "fr28", "fr29", "fr30", "fr31"
652 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
658 /* Map dwarf DBX register numbers to GDB register numbers. */
660 hppa64_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
662 /* The general registers and the sar are the same in both sets. */
666 /* fr4-fr31 are mapped from 72 in steps of 2. */
667 if (reg
>= 72 && reg
< 72 + 28 * 2 && !(reg
& 1))
668 return HPPA64_FP4_REGNUM
+ (reg
- 72) / 2;
670 warning (_("Unmapped DWARF DBX Register #%d encountered."), reg
);
674 /* This function pushes a stack frame with arguments as part of the
675 inferior function calling mechanism.
677 This is the version of the function for the 32-bit PA machines, in
678 which later arguments appear at lower addresses. (The stack always
679 grows towards higher addresses.)
681 We simply allocate the appropriate amount of stack space and put
682 arguments into their proper slots. */
685 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
686 struct regcache
*regcache
, CORE_ADDR bp_addr
,
687 int nargs
, struct value
**args
, CORE_ADDR sp
,
688 int struct_return
, CORE_ADDR struct_addr
)
690 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
692 /* Stack base address at which any pass-by-reference parameters are
694 CORE_ADDR struct_end
= 0;
695 /* Stack base address at which the first parameter is stored. */
696 CORE_ADDR param_end
= 0;
698 /* The inner most end of the stack after all the parameters have
700 CORE_ADDR new_sp
= 0;
702 /* Two passes. First pass computes the location of everything,
703 second pass writes the bytes out. */
706 /* Global pointer (r19) of the function we are trying to call. */
709 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
711 for (write_pass
= 0; write_pass
< 2; write_pass
++)
713 CORE_ADDR struct_ptr
= 0;
714 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
715 struct_ptr is adjusted for each argument below, so the first
716 argument will end up at sp-36. */
717 CORE_ADDR param_ptr
= 32;
719 int small_struct
= 0;
721 for (i
= 0; i
< nargs
; i
++)
723 struct value
*arg
= args
[i
];
724 struct type
*type
= check_typedef (value_type (arg
));
725 /* The corresponding parameter that is pushed onto the
726 stack, and [possibly] passed in a register. */
727 gdb_byte param_val
[8];
729 memset (param_val
, 0, sizeof param_val
);
730 if (TYPE_LENGTH (type
) > 8)
732 /* Large parameter, pass by reference. Store the value
733 in "struct" area and then pass its address. */
735 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
737 write_memory (struct_end
- struct_ptr
, value_contents (arg
),
739 store_unsigned_integer (param_val
, 4, byte_order
,
740 struct_end
- struct_ptr
);
742 else if (TYPE_CODE (type
) == TYPE_CODE_INT
743 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
745 /* Integer value store, right aligned. "unpack_long"
746 takes care of any sign-extension problems. */
747 param_len
= align_up (TYPE_LENGTH (type
), 4);
748 store_unsigned_integer (param_val
, param_len
, byte_order
,
750 value_contents (arg
)));
752 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
754 /* Floating point value store, right aligned. */
755 param_len
= align_up (TYPE_LENGTH (type
), 4);
756 memcpy (param_val
, value_contents (arg
), param_len
);
760 param_len
= align_up (TYPE_LENGTH (type
), 4);
762 /* Small struct value are stored right-aligned. */
763 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
764 value_contents (arg
), TYPE_LENGTH (type
));
766 /* Structures of size 5, 6 and 7 bytes are special in that
767 the higher-ordered word is stored in the lower-ordered
768 argument, and even though it is a 8-byte quantity the
769 registers need not be 8-byte aligned. */
770 if (param_len
> 4 && param_len
< 8)
774 param_ptr
+= param_len
;
775 if (param_len
== 8 && !small_struct
)
776 param_ptr
= align_up (param_ptr
, 8);
778 /* First 4 non-FP arguments are passed in gr26-gr23.
779 First 4 32-bit FP arguments are passed in fr4L-fr7L.
780 First 2 64-bit FP arguments are passed in fr5 and fr7.
782 The rest go on the stack, starting at sp-36, towards lower
783 addresses. 8-byte arguments must be aligned to a 8-byte
787 write_memory (param_end
- param_ptr
, param_val
, param_len
);
789 /* There are some cases when we don't know the type
790 expected by the callee (e.g. for variadic functions), so
791 pass the parameters in both general and fp regs. */
794 int grreg
= 26 - (param_ptr
- 36) / 4;
795 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
796 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
798 regcache_cooked_write (regcache
, grreg
, param_val
);
799 regcache_cooked_write (regcache
, fpLreg
, param_val
);
803 regcache_cooked_write (regcache
, grreg
+ 1,
806 regcache_cooked_write (regcache
, fpreg
, param_val
);
807 regcache_cooked_write (regcache
, fpreg
+ 1,
814 /* Update the various stack pointers. */
817 struct_end
= sp
+ align_up (struct_ptr
, 64);
818 /* PARAM_PTR already accounts for all the arguments passed
819 by the user. However, the ABI mandates minimum stack
820 space allocations for outgoing arguments. The ABI also
821 mandates minimum stack alignments which we must
823 param_end
= struct_end
+ align_up (param_ptr
, 64);
827 /* If a structure has to be returned, set up register 28 to hold its
830 regcache_cooked_write_unsigned (regcache
, 28, struct_addr
);
832 gp
= tdep
->find_global_pointer (gdbarch
, function
);
835 regcache_cooked_write_unsigned (regcache
, 19, gp
);
837 /* Set the return address. */
838 if (!gdbarch_push_dummy_code_p (gdbarch
))
839 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
841 /* Update the Stack Pointer. */
842 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
847 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
848 Runtime Architecture for PA-RISC 2.0", which is distributed as part
849 as of the HP-UX Software Transition Kit (STK). This implementation
850 is based on version 3.3, dated October 6, 1997. */
852 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
855 hppa64_integral_or_pointer_p (const struct type
*type
)
857 switch (TYPE_CODE (type
))
863 case TYPE_CODE_RANGE
:
865 int len
= TYPE_LENGTH (type
);
866 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
870 return (TYPE_LENGTH (type
) == 8);
878 /* Check whether TYPE is a "Floating Scalar Type". */
881 hppa64_floating_p (const struct type
*type
)
883 switch (TYPE_CODE (type
))
887 int len
= TYPE_LENGTH (type
);
888 return (len
== 4 || len
== 8 || len
== 16);
897 /* If CODE points to a function entry address, try to look up the corresponding
898 function descriptor and return its address instead. If CODE is not a
899 function entry address, then just return it unchanged. */
901 hppa64_convert_code_addr_to_fptr (struct gdbarch
*gdbarch
, CORE_ADDR code
)
903 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
904 struct obj_section
*sec
, *opd
;
906 sec
= find_pc_section (code
);
911 /* If CODE is in a data section, assume it's already a fptr. */
912 if (!(sec
->the_bfd_section
->flags
& SEC_CODE
))
915 ALL_OBJFILE_OSECTIONS (sec
->objfile
, opd
)
917 if (strcmp (opd
->the_bfd_section
->name
, ".opd") == 0)
921 if (opd
< sec
->objfile
->sections_end
)
925 for (addr
= obj_section_addr (opd
);
926 addr
< obj_section_endaddr (opd
);
932 if (target_read_memory (addr
, tmp
, sizeof (tmp
)))
934 opdaddr
= extract_unsigned_integer (tmp
, sizeof (tmp
), byte_order
);
945 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
946 struct regcache
*regcache
, CORE_ADDR bp_addr
,
947 int nargs
, struct value
**args
, CORE_ADDR sp
,
948 int struct_return
, CORE_ADDR struct_addr
)
950 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
951 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
955 /* "The outgoing parameter area [...] must be aligned at a 16-byte
957 sp
= align_up (sp
, 16);
959 for (i
= 0; i
< nargs
; i
++)
961 struct value
*arg
= args
[i
];
962 struct type
*type
= value_type (arg
);
963 int len
= TYPE_LENGTH (type
);
964 const bfd_byte
*valbuf
;
968 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
969 offset
= align_up (offset
, 8);
971 if (hppa64_integral_or_pointer_p (type
))
973 /* "Integral scalar parameters smaller than 64 bits are
974 padded on the left (i.e., the value is in the
975 least-significant bits of the 64-bit storage unit, and
976 the high-order bits are undefined)." Therefore we can
977 safely sign-extend them. */
980 arg
= value_cast (builtin_type (gdbarch
)->builtin_int64
, arg
);
984 else if (hppa64_floating_p (type
))
988 /* "Quad-precision (128-bit) floating-point scalar
989 parameters are aligned on a 16-byte boundary." */
990 offset
= align_up (offset
, 16);
992 /* "Double-extended- and quad-precision floating-point
993 parameters within the first 64 bytes of the parameter
994 list are always passed in general registers." */
1000 /* "Single-precision (32-bit) floating-point scalar
1001 parameters are padded on the left with 32 bits of
1002 garbage (i.e., the floating-point value is in the
1003 least-significant 32 bits of a 64-bit storage
1008 /* "Single- and double-precision floating-point
1009 parameters in this area are passed according to the
1010 available formal parameter information in a function
1011 prototype. [...] If no prototype is in scope,
1012 floating-point parameters must be passed both in the
1013 corresponding general registers and in the
1014 corresponding floating-point registers." */
1015 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
1017 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
1019 /* "Single-precision floating-point parameters, when
1020 passed in floating-point registers, are passed in
1021 the right halves of the floating point registers;
1022 the left halves are unused." */
1023 regcache_cooked_write_part (regcache
, regnum
, offset
% 8,
1024 len
, value_contents (arg
));
1032 /* "Aggregates larger than 8 bytes are aligned on a
1033 16-byte boundary, possibly leaving an unused argument
1034 slot, which is filled with garbage. If necessary,
1035 they are padded on the right (with garbage), to a
1036 multiple of 8 bytes." */
1037 offset
= align_up (offset
, 16);
1041 /* If we are passing a function pointer, make sure we pass a function
1042 descriptor instead of the function entry address. */
1043 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1044 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1046 ULONGEST codeptr
, fptr
;
1048 codeptr
= unpack_long (type
, value_contents (arg
));
1049 fptr
= hppa64_convert_code_addr_to_fptr (gdbarch
, codeptr
);
1050 store_unsigned_integer (fptrbuf
, TYPE_LENGTH (type
), byte_order
,
1056 valbuf
= value_contents (arg
);
1059 /* Always store the argument in memory. */
1060 write_memory (sp
+ offset
, valbuf
, len
);
1062 regnum
= HPPA_ARG0_REGNUM
- offset
/ 8;
1063 while (regnum
> HPPA_ARG0_REGNUM
- 8 && len
> 0)
1065 regcache_cooked_write_part (regcache
, regnum
,
1066 offset
% 8, min (len
, 8), valbuf
);
1067 offset
+= min (len
, 8);
1068 valbuf
+= min (len
, 8);
1069 len
-= min (len
, 8);
1076 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1077 regcache_cooked_write_unsigned (regcache
, HPPA_RET1_REGNUM
, sp
+ 64);
1079 /* Allocate the outgoing parameter area. Make sure the outgoing
1080 parameter area is multiple of 16 bytes in length. */
1081 sp
+= max (align_up (offset
, 16), 64);
1083 /* Allocate 32-bytes of scratch space. The documentation doesn't
1084 mention this, but it seems to be needed. */
1087 /* Allocate the frame marker area. */
1090 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1093 regcache_cooked_write_unsigned (regcache
, HPPA_RET0_REGNUM
, struct_addr
);
1095 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1096 gp
= tdep
->find_global_pointer (gdbarch
, function
);
1098 regcache_cooked_write_unsigned (regcache
, HPPA_DP_REGNUM
, gp
);
1100 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1101 if (!gdbarch_push_dummy_code_p (gdbarch
))
1102 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1104 /* Set up GR30 to hold the stack pointer (sp). */
1105 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, sp
);
1111 /* Handle 32/64-bit struct return conventions. */
1113 static enum return_value_convention
1114 hppa32_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1115 struct type
*type
, struct regcache
*regcache
,
1116 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1118 if (TYPE_LENGTH (type
) <= 2 * 4)
1120 /* The value always lives in the right hand end of the register
1121 (or register pair)? */
1123 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
1124 int part
= TYPE_LENGTH (type
) % 4;
1125 /* The left hand register contains only part of the value,
1126 transfer that first so that the rest can be xfered as entire
1127 4-byte registers. */
1130 if (readbuf
!= NULL
)
1131 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
1133 if (writebuf
!= NULL
)
1134 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
1138 /* Now transfer the remaining register values. */
1139 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
1141 if (readbuf
!= NULL
)
1142 regcache_cooked_read (regcache
, reg
, readbuf
+ b
);
1143 if (writebuf
!= NULL
)
1144 regcache_cooked_write (regcache
, reg
, writebuf
+ b
);
1147 return RETURN_VALUE_REGISTER_CONVENTION
;
1150 return RETURN_VALUE_STRUCT_CONVENTION
;
1153 static enum return_value_convention
1154 hppa64_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1155 struct type
*type
, struct regcache
*regcache
,
1156 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1158 int len
= TYPE_LENGTH (type
);
1163 /* All return values larget than 128 bits must be aggregate
1165 gdb_assert (!hppa64_integral_or_pointer_p (type
));
1166 gdb_assert (!hppa64_floating_p (type
));
1168 /* "Aggregate return values larger than 128 bits are returned in
1169 a buffer allocated by the caller. The address of the buffer
1170 must be passed in GR 28." */
1171 return RETURN_VALUE_STRUCT_CONVENTION
;
1174 if (hppa64_integral_or_pointer_p (type
))
1176 /* "Integral return values are returned in GR 28. Values
1177 smaller than 64 bits are padded on the left (with garbage)." */
1178 regnum
= HPPA_RET0_REGNUM
;
1181 else if (hppa64_floating_p (type
))
1185 /* "Double-extended- and quad-precision floating-point
1186 values are returned in GRs 28 and 29. The sign,
1187 exponent, and most-significant bits of the mantissa are
1188 returned in GR 28; the least-significant bits of the
1189 mantissa are passed in GR 29. For double-extended
1190 precision values, GR 29 is padded on the right with 48
1191 bits of garbage." */
1192 regnum
= HPPA_RET0_REGNUM
;
1197 /* "Single-precision and double-precision floating-point
1198 return values are returned in FR 4R (single precision) or
1199 FR 4 (double-precision)." */
1200 regnum
= HPPA64_FP4_REGNUM
;
1206 /* "Aggregate return values up to 64 bits in size are returned
1207 in GR 28. Aggregates smaller than 64 bits are left aligned
1208 in the register; the pad bits on the right are undefined."
1210 "Aggregate return values between 65 and 128 bits are returned
1211 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1212 the remaining bits are placed, left aligned, in GR 29. The
1213 pad bits on the right of GR 29 (if any) are undefined." */
1214 regnum
= HPPA_RET0_REGNUM
;
1222 regcache_cooked_read_part (regcache
, regnum
, offset
,
1223 min (len
, 8), readbuf
);
1224 readbuf
+= min (len
, 8);
1225 len
-= min (len
, 8);
1234 regcache_cooked_write_part (regcache
, regnum
, offset
,
1235 min (len
, 8), writebuf
);
1236 writebuf
+= min (len
, 8);
1237 len
-= min (len
, 8);
1242 return RETURN_VALUE_REGISTER_CONVENTION
;
1247 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1248 struct target_ops
*targ
)
1252 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1253 CORE_ADDR plabel
= addr
& ~3;
1254 return read_memory_typed_address (plabel
, func_ptr_type
);
1261 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1263 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1265 return align_up (addr
, 64);
1268 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1271 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1273 /* Just always 16-byte align. */
1274 return align_up (addr
, 16);
1278 hppa_read_pc (struct regcache
*regcache
)
1283 regcache_cooked_read_unsigned (regcache
, HPPA_IPSW_REGNUM
, &ipsw
);
1284 regcache_cooked_read_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, &pc
);
1286 /* If the current instruction is nullified, then we are effectively
1287 still executing the previous instruction. Pretend we are still
1288 there. This is needed when single stepping; if the nullified
1289 instruction is on a different line, we don't want GDB to think
1290 we've stepped onto that line. */
1291 if (ipsw
& 0x00200000)
1298 hppa_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1300 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pc
);
1301 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4);
1304 /* For the given instruction (INST), return any adjustment it makes
1305 to the stack pointer or zero for no adjustment.
1307 This only handles instructions commonly found in prologues. */
1310 prologue_inst_adjust_sp (unsigned long inst
)
1312 /* This must persist across calls. */
1313 static int save_high21
;
1315 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1316 if ((inst
& 0xffffc000) == 0x37de0000)
1317 return hppa_extract_14 (inst
);
1320 if ((inst
& 0xffe00000) == 0x6fc00000)
1321 return hppa_extract_14 (inst
);
1323 /* std,ma X,D(sp) */
1324 if ((inst
& 0xffe00008) == 0x73c00008)
1325 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1327 /* addil high21,%r30; ldo low11,(%r1),%r30)
1328 save high bits in save_high21 for later use. */
1329 if ((inst
& 0xffe00000) == 0x2bc00000)
1331 save_high21
= hppa_extract_21 (inst
);
1335 if ((inst
& 0xffff0000) == 0x343e0000)
1336 return save_high21
+ hppa_extract_14 (inst
);
1338 /* fstws as used by the HP compilers. */
1339 if ((inst
& 0xffffffe0) == 0x2fd01220)
1340 return hppa_extract_5_load (inst
);
1342 /* No adjustment. */
1346 /* Return nonzero if INST is a branch of some kind, else return zero. */
1349 is_branch (unsigned long inst
)
1378 /* Return the register number for a GR which is saved by INST or
1379 zero if INST does not save a GR.
1384 https://parisc.wiki.kernel.org/images-parisc/6/68/Pa11_acd.pdf
1387 https://parisc.wiki.kernel.org/images-parisc/7/73/Parisc2.0.pdf
1389 According to Table 6-5 of Chapter 6 (Memory Reference Instructions)
1390 on page 106 in parisc 2.0, all instructions for storing values from
1391 the general registers are:
1393 Store: stb, sth, stw, std (according to Chapter 7, they
1394 are only in both "inst >> 26" and "inst >> 6".
1395 Store Absolute: stwa, stda (according to Chapter 7, they are only
1397 Store Bytes: stby, stdby (according to Chapter 7, they are
1398 only in "inst >> 6").
1400 For (inst >> 26), according to Chapter 7:
1402 The effective memory reference address is formed by the addition
1403 of an immediate displacement to a base value.
1405 - stb: 0x18, store a byte from a general register.
1407 - sth: 0x19, store a halfword from a general register.
1409 - stw: 0x1a, store a word from a general register.
1411 - stwm: 0x1b, store a word from a general register and perform base
1412 register modification (2.0 will still treate it as stw).
1414 - std: 0x1c, store a doubleword from a general register (2.0 only).
1416 - stw: 0x1f, store a word from a general register (2.0 only).
1418 For (inst >> 6) when ((inst >> 26) == 0x03), according to Chapter 7:
1420 The effective memory reference address is formed by the addition
1421 of an index value to a base value specified in the instruction.
1423 - stb: 0x08, store a byte from a general register (1.1 calls stbs).
1425 - sth: 0x09, store a halfword from a general register (1.1 calls
1428 - stw: 0x0a, store a word from a general register (1.1 calls stws).
1430 - std: 0x0b: store a doubleword from a general register (2.0 only)
1432 Implement fast byte moves (stores) to unaligned word or doubleword
1435 - stby: 0x0c, for unaligned word (1.1 calls stbys).
1437 - stdby: 0x0d for unaligned doubleword (2.0 only).
1439 Store a word or doubleword using an absolute memory address formed
1440 using short or long displacement or indexed
1442 - stwa: 0x0e, store a word from a general register to an absolute
1443 address (1.0 calls stwas).
1445 - stda: 0x0f, store a doubleword from a general register to an
1446 absolute address (2.0 only). */
1449 inst_saves_gr (unsigned long inst
)
1451 switch ((inst
>> 26) & 0x0f)
1454 switch ((inst
>> 6) & 0x0f)
1464 return hppa_extract_5R_store (inst
);
1473 /* no 0x1d or 0x1e -- according to parisc 2.0 document */
1475 return hppa_extract_5R_store (inst
);
1481 /* Return the register number for a FR which is saved by INST or
1482 zero it INST does not save a FR.
1484 Note we only care about full 64bit register stores (that's the only
1485 kind of stores the prologue will use).
1487 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1490 inst_saves_fr (unsigned long inst
)
1492 /* Is this an FSTD? */
1493 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1494 return hppa_extract_5r_store (inst
);
1495 if ((inst
& 0xfc000002) == 0x70000002)
1496 return hppa_extract_5R_store (inst
);
1497 /* Is this an FSTW? */
1498 if ((inst
& 0xfc00df80) == 0x24001200)
1499 return hppa_extract_5r_store (inst
);
1500 if ((inst
& 0xfc000002) == 0x7c000000)
1501 return hppa_extract_5R_store (inst
);
1505 /* Advance PC across any function entry prologue instructions
1506 to reach some "real" code.
1508 Use information in the unwind table to determine what exactly should
1509 be in the prologue. */
1513 skip_prologue_hard_way (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1514 int stop_before_branch
)
1516 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1518 CORE_ADDR orig_pc
= pc
;
1519 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1520 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1521 struct unwind_table_entry
*u
;
1522 int final_iteration
;
1528 u
= find_unwind_entry (pc
);
1532 /* If we are not at the beginning of a function, then return now. */
1533 if ((pc
& ~0x3) != u
->region_start
)
1536 /* This is how much of a frame adjustment we need to account for. */
1537 stack_remaining
= u
->Total_frame_size
<< 3;
1539 /* Magic register saves we want to know about. */
1540 save_rp
= u
->Save_RP
;
1541 save_sp
= u
->Save_SP
;
1543 /* An indication that args may be stored into the stack. Unfortunately
1544 the HPUX compilers tend to set this in cases where no args were
1548 /* Turn the Entry_GR field into a bitmask. */
1550 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1552 /* Frame pointer gets saved into a special location. */
1553 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1556 save_gr
|= (1 << i
);
1558 save_gr
&= ~restart_gr
;
1560 /* Turn the Entry_FR field into a bitmask too. */
1562 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1563 save_fr
|= (1 << i
);
1564 save_fr
&= ~restart_fr
;
1566 final_iteration
= 0;
1568 /* Loop until we find everything of interest or hit a branch.
1570 For unoptimized GCC code and for any HP CC code this will never ever
1571 examine any user instructions.
1573 For optimzied GCC code we're faced with problems. GCC will schedule
1574 its prologue and make prologue instructions available for delay slot
1575 filling. The end result is user code gets mixed in with the prologue
1576 and a prologue instruction may be in the delay slot of the first branch
1579 Some unexpected things are expected with debugging optimized code, so
1580 we allow this routine to walk past user instructions in optimized
1582 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1585 unsigned int reg_num
;
1586 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1587 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1589 /* Save copies of all the triggers so we can compare them later
1591 old_save_gr
= save_gr
;
1592 old_save_fr
= save_fr
;
1593 old_save_rp
= save_rp
;
1594 old_save_sp
= save_sp
;
1595 old_stack_remaining
= stack_remaining
;
1597 status
= target_read_memory (pc
, buf
, 4);
1598 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1604 /* Note the interesting effects of this instruction. */
1605 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1607 /* There are limited ways to store the return pointer into the
1609 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1612 /* These are the only ways we save SP into the stack. At this time
1613 the HP compilers never bother to save SP into the stack. */
1614 if ((inst
& 0xffffc000) == 0x6fc10000
1615 || (inst
& 0xffffc00c) == 0x73c10008)
1618 /* Are we loading some register with an offset from the argument
1620 if ((inst
& 0xffe00000) == 0x37a00000
1621 || (inst
& 0xffffffe0) == 0x081d0240)
1627 /* Account for general and floating-point register saves. */
1628 reg_num
= inst_saves_gr (inst
);
1629 save_gr
&= ~(1 << reg_num
);
1631 /* Ugh. Also account for argument stores into the stack.
1632 Unfortunately args_stored only tells us that some arguments
1633 where stored into the stack. Not how many or what kind!
1635 This is a kludge as on the HP compiler sets this bit and it
1636 never does prologue scheduling. So once we see one, skip past
1637 all of them. We have similar code for the fp arg stores below.
1639 FIXME. Can still die if we have a mix of GR and FR argument
1641 if (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1644 while (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1648 status
= target_read_memory (pc
, buf
, 4);
1649 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1652 reg_num
= inst_saves_gr (inst
);
1658 reg_num
= inst_saves_fr (inst
);
1659 save_fr
&= ~(1 << reg_num
);
1661 status
= target_read_memory (pc
+ 4, buf
, 4);
1662 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1668 /* We've got to be read to handle the ldo before the fp register
1670 if ((inst
& 0xfc000000) == 0x34000000
1671 && inst_saves_fr (next_inst
) >= 4
1672 && inst_saves_fr (next_inst
)
1673 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1675 /* So we drop into the code below in a reasonable state. */
1676 reg_num
= inst_saves_fr (next_inst
);
1680 /* Ugh. Also account for argument stores into the stack.
1681 This is a kludge as on the HP compiler sets this bit and it
1682 never does prologue scheduling. So once we see one, skip past
1685 && reg_num
<= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1689 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1692 status
= target_read_memory (pc
, buf
, 4);
1693 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1696 if ((inst
& 0xfc000000) != 0x34000000)
1698 status
= target_read_memory (pc
+ 4, buf
, 4);
1699 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1702 reg_num
= inst_saves_fr (next_inst
);
1708 /* Quit if we hit any kind of branch. This can happen if a prologue
1709 instruction is in the delay slot of the first call/branch. */
1710 if (is_branch (inst
) && stop_before_branch
)
1713 /* What a crock. The HP compilers set args_stored even if no
1714 arguments were stored into the stack (boo hiss). This could
1715 cause this code to then skip a bunch of user insns (up to the
1718 To combat this we try to identify when args_stored was bogusly
1719 set and clear it. We only do this when args_stored is nonzero,
1720 all other resources are accounted for, and nothing changed on
1723 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1724 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1725 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1726 && old_stack_remaining
== stack_remaining
)
1732 /* !stop_before_branch, so also look at the insn in the delay slot
1734 if (final_iteration
)
1736 if (is_branch (inst
))
1737 final_iteration
= 1;
1740 /* We've got a tenative location for the end of the prologue. However
1741 because of limitations in the unwind descriptor mechanism we may
1742 have went too far into user code looking for the save of a register
1743 that does not exist. So, if there registers we expected to be saved
1744 but never were, mask them out and restart.
1746 This should only happen in optimized code, and should be very rare. */
1747 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1750 restart_gr
= save_gr
;
1751 restart_fr
= save_fr
;
1759 /* Return the address of the PC after the last prologue instruction if
1760 we can determine it from the debug symbols. Else return zero. */
1763 after_prologue (CORE_ADDR pc
)
1765 struct symtab_and_line sal
;
1766 CORE_ADDR func_addr
, func_end
;
1768 /* If we can not find the symbol in the partial symbol table, then
1769 there is no hope we can determine the function's start address
1771 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1774 /* Get the line associated with FUNC_ADDR. */
1775 sal
= find_pc_line (func_addr
, 0);
1777 /* There are only two cases to consider. First, the end of the source line
1778 is within the function bounds. In that case we return the end of the
1779 source line. Second is the end of the source line extends beyond the
1780 bounds of the current function. We need to use the slow code to
1781 examine instructions in that case.
1783 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1784 the wrong thing to do. In fact, it should be entirely possible for this
1785 function to always return zero since the slow instruction scanning code
1786 is supposed to *always* work. If it does not, then it is a bug. */
1787 if (sal
.end
< func_end
)
1793 /* To skip prologues, I use this predicate. Returns either PC itself
1794 if the code at PC does not look like a function prologue; otherwise
1795 returns an address that (if we're lucky) follows the prologue.
1797 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1798 It doesn't necessarily skips all the insns in the prologue. In fact
1799 we might not want to skip all the insns because a prologue insn may
1800 appear in the delay slot of the first branch, and we don't want to
1801 skip over the branch in that case. */
1804 hppa_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1806 CORE_ADDR post_prologue_pc
;
1808 /* See if we can determine the end of the prologue via the symbol table.
1809 If so, then return either PC, or the PC after the prologue, whichever
1812 post_prologue_pc
= after_prologue (pc
);
1814 /* If after_prologue returned a useful address, then use it. Else
1815 fall back on the instruction skipping code.
1817 Some folks have claimed this causes problems because the breakpoint
1818 may be the first instruction of the prologue. If that happens, then
1819 the instruction skipping code has a bug that needs to be fixed. */
1820 if (post_prologue_pc
!= 0)
1821 return max (pc
, post_prologue_pc
);
1823 return (skip_prologue_hard_way (gdbarch
, pc
, 1));
1826 /* Return an unwind entry that falls within the frame's code block. */
1828 static struct unwind_table_entry
*
1829 hppa_find_unwind_entry_in_block (struct frame_info
*this_frame
)
1831 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
1833 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1834 result of get_frame_address_in_block implies a problem.
1835 The bits should have been removed earlier, before the return
1836 value of gdbarch_unwind_pc. That might be happening already;
1837 if it isn't, it should be fixed. Then this call can be
1839 pc
= gdbarch_addr_bits_remove (get_frame_arch (this_frame
), pc
);
1840 return find_unwind_entry (pc
);
1843 struct hppa_frame_cache
1846 struct trad_frame_saved_reg
*saved_regs
;
1849 static struct hppa_frame_cache
*
1850 hppa_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1852 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1853 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1854 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1855 struct hppa_frame_cache
*cache
;
1859 struct unwind_table_entry
*u
;
1860 CORE_ADDR prologue_end
;
1865 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1866 frame_relative_level(this_frame
));
1868 if ((*this_cache
) != NULL
)
1871 fprintf_unfiltered (gdb_stdlog
, "base=%s (cached) }",
1872 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
1873 return (*this_cache
);
1875 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1876 (*this_cache
) = cache
;
1877 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1880 u
= hppa_find_unwind_entry_in_block (this_frame
);
1884 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1885 return (*this_cache
);
1888 /* Turn the Entry_GR field into a bitmask. */
1890 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1892 /* Frame pointer gets saved into a special location. */
1893 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1896 saved_gr_mask
|= (1 << i
);
1899 /* Turn the Entry_FR field into a bitmask too. */
1901 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1902 saved_fr_mask
|= (1 << i
);
1904 /* Loop until we find everything of interest or hit a branch.
1906 For unoptimized GCC code and for any HP CC code this will never ever
1907 examine any user instructions.
1909 For optimized GCC code we're faced with problems. GCC will schedule
1910 its prologue and make prologue instructions available for delay slot
1911 filling. The end result is user code gets mixed in with the prologue
1912 and a prologue instruction may be in the delay slot of the first branch
1915 Some unexpected things are expected with debugging optimized code, so
1916 we allow this routine to walk past user instructions in optimized
1919 int final_iteration
= 0;
1920 CORE_ADDR pc
, start_pc
, end_pc
;
1921 int looking_for_sp
= u
->Save_SP
;
1922 int looking_for_rp
= u
->Save_RP
;
1925 /* We have to use skip_prologue_hard_way instead of just
1926 skip_prologue_using_sal, in case we stepped into a function without
1927 symbol information. hppa_skip_prologue also bounds the returned
1928 pc by the passed in pc, so it will not return a pc in the next
1931 We used to call hppa_skip_prologue to find the end of the prologue,
1932 but if some non-prologue instructions get scheduled into the prologue,
1933 and the program is compiled with debug information, the "easy" way
1934 in hppa_skip_prologue will return a prologue end that is too early
1935 for us to notice any potential frame adjustments. */
1937 /* We used to use get_frame_func to locate the beginning of the
1938 function to pass to skip_prologue. However, when objects are
1939 compiled without debug symbols, get_frame_func can return the wrong
1940 function (or 0). We can do better than that by using unwind records.
1941 This only works if the Region_description of the unwind record
1942 indicates that it includes the entry point of the function.
1943 HP compilers sometimes generate unwind records for regions that
1944 do not include the entry or exit point of a function. GNU tools
1947 if ((u
->Region_description
& 0x2) == 0)
1948 start_pc
= u
->region_start
;
1950 start_pc
= get_frame_func (this_frame
);
1952 prologue_end
= skip_prologue_hard_way (gdbarch
, start_pc
, 0);
1953 end_pc
= get_frame_pc (this_frame
);
1955 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1956 end_pc
= prologue_end
;
1961 ((saved_gr_mask
|| saved_fr_mask
1962 || looking_for_sp
|| looking_for_rp
1963 || frame_size
< (u
->Total_frame_size
<< 3))
1971 if (!safe_frame_unwind_memory (this_frame
, pc
, buf4
, sizeof buf4
))
1973 error (_("Cannot read instruction at %s."),
1974 paddress (gdbarch
, pc
));
1975 return (*this_cache
);
1978 inst
= extract_unsigned_integer (buf4
, sizeof buf4
, byte_order
);
1980 /* Note the interesting effects of this instruction. */
1981 frame_size
+= prologue_inst_adjust_sp (inst
);
1983 /* There are limited ways to store the return pointer into the
1985 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1988 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1990 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1993 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1995 else if (inst
== 0x0fc212c1
1996 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1999 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2002 /* Check to see if we saved SP into the stack. This also
2003 happens to indicate the location of the saved frame
2005 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
2006 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2009 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
2011 else if (inst
== 0x08030241) /* copy %r3, %r1 */
2016 /* Account for general and floating-point register saves. */
2017 reg
= inst_saves_gr (inst
);
2018 if (reg
>= 3 && reg
<= 18
2019 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
2021 saved_gr_mask
&= ~(1 << reg
);
2022 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
2023 /* stwm with a positive displacement is a _post_
2025 cache
->saved_regs
[reg
].addr
= 0;
2026 else if ((inst
& 0xfc00000c) == 0x70000008)
2027 /* A std has explicit post_modify forms. */
2028 cache
->saved_regs
[reg
].addr
= 0;
2033 if ((inst
>> 26) == 0x1c)
2034 offset
= (inst
& 0x1 ? -1 << 13 : 0)
2035 | (((inst
>> 4) & 0x3ff) << 3);
2036 else if ((inst
>> 26) == 0x03)
2037 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
2039 offset
= hppa_extract_14 (inst
);
2041 /* Handle code with and without frame pointers. */
2043 cache
->saved_regs
[reg
].addr
= offset
;
2045 cache
->saved_regs
[reg
].addr
2046 = (u
->Total_frame_size
<< 3) + offset
;
2050 /* GCC handles callee saved FP regs a little differently.
2052 It emits an instruction to put the value of the start of
2053 the FP store area into %r1. It then uses fstds,ma with a
2054 basereg of %r1 for the stores.
2056 HP CC emits them at the current stack pointer modifying the
2057 stack pointer as it stores each register. */
2059 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2060 if ((inst
& 0xffffc000) == 0x34610000
2061 || (inst
& 0xffffc000) == 0x37c10000)
2062 fp_loc
= hppa_extract_14 (inst
);
2064 reg
= inst_saves_fr (inst
);
2065 if (reg
>= 12 && reg
<= 21)
2067 /* Note +4 braindamage below is necessary because the FP
2068 status registers are internally 8 registers rather than
2069 the expected 4 registers. */
2070 saved_fr_mask
&= ~(1 << reg
);
2073 /* 1st HP CC FP register store. After this
2074 instruction we've set enough state that the GCC and
2075 HPCC code are both handled in the same manner. */
2076 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
2081 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
2086 /* Quit if we hit any kind of branch the previous iteration. */
2087 if (final_iteration
)
2089 /* We want to look precisely one instruction beyond the branch
2090 if we have not found everything yet. */
2091 if (is_branch (inst
))
2092 final_iteration
= 1;
2097 /* The frame base always represents the value of %sp at entry to
2098 the current function (and is thus equivalent to the "saved"
2100 CORE_ADDR this_sp
= get_frame_register_unsigned (this_frame
,
2105 fprintf_unfiltered (gdb_stdlog
, " (this_sp=%s, pc=%s, "
2106 "prologue_end=%s) ",
2107 paddress (gdbarch
, this_sp
),
2108 paddress (gdbarch
, get_frame_pc (this_frame
)),
2109 paddress (gdbarch
, prologue_end
));
2111 /* Check to see if a frame pointer is available, and use it for
2112 frame unwinding if it is.
2114 There are some situations where we need to rely on the frame
2115 pointer to do stack unwinding. For example, if a function calls
2116 alloca (), the stack pointer can get adjusted inside the body of
2117 the function. In this case, the ABI requires that the compiler
2118 maintain a frame pointer for the function.
2120 The unwind record has a flag (alloca_frame) that indicates that
2121 a function has a variable frame; unfortunately, gcc/binutils
2122 does not set this flag. Instead, whenever a frame pointer is used
2123 and saved on the stack, the Save_SP flag is set. We use this to
2124 decide whether to use the frame pointer for unwinding.
2126 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2127 instead of Save_SP. */
2129 fp
= get_frame_register_unsigned (this_frame
, HPPA_FP_REGNUM
);
2131 if (u
->alloca_frame
)
2132 fp
-= u
->Total_frame_size
<< 3;
2134 if (get_frame_pc (this_frame
) >= prologue_end
2135 && (u
->Save_SP
|| u
->alloca_frame
) && fp
!= 0)
2140 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [frame pointer]",
2141 paddress (gdbarch
, cache
->base
));
2144 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
2146 /* Both we're expecting the SP to be saved and the SP has been
2147 saved. The entry SP value is saved at this frame's SP
2149 cache
->base
= read_memory_integer (this_sp
, word_size
, byte_order
);
2152 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [saved]",
2153 paddress (gdbarch
, cache
->base
));
2157 /* The prologue has been slowly allocating stack space. Adjust
2159 cache
->base
= this_sp
- frame_size
;
2161 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [unwind adjust]",
2162 paddress (gdbarch
, cache
->base
));
2165 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2168 /* The PC is found in the "return register", "Millicode" uses "r31"
2169 as the return register while normal code uses "rp". */
2172 if (trad_frame_addr_p (cache
->saved_regs
, 31))
2174 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2176 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2180 ULONGEST r31
= get_frame_register_unsigned (this_frame
, 31);
2181 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
2183 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2188 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2190 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2191 cache
->saved_regs
[HPPA_RP_REGNUM
];
2193 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2197 ULONGEST rp
= get_frame_register_unsigned (this_frame
,
2199 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2201 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2205 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2206 frame. However, there is a one-insn window where we haven't saved it
2207 yet, but we've already clobbered it. Detect this case and fix it up.
2209 The prologue sequence for frame-pointer functions is:
2210 0: stw %rp, -20(%sp)
2213 c: stw,ma %r1, XX(%sp)
2215 So if we are at offset c, the r3 value that we want is not yet saved
2216 on the stack, but it's been overwritten. The prologue analyzer will
2217 set fp_in_r1 when it sees the copy insn so we know to get the value
2219 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
2222 ULONGEST r1
= get_frame_register_unsigned (this_frame
, 1);
2223 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
2227 /* Convert all the offsets into addresses. */
2229 for (reg
= 0; reg
< gdbarch_num_regs (gdbarch
); reg
++)
2231 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
2232 cache
->saved_regs
[reg
].addr
+= cache
->base
;
2237 struct gdbarch_tdep
*tdep
;
2239 tdep
= gdbarch_tdep (gdbarch
);
2241 if (tdep
->unwind_adjust_stub
)
2242 tdep
->unwind_adjust_stub (this_frame
, cache
->base
, cache
->saved_regs
);
2246 fprintf_unfiltered (gdb_stdlog
, "base=%s }",
2247 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
2248 return (*this_cache
);
2252 hppa_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2253 struct frame_id
*this_id
)
2255 struct hppa_frame_cache
*info
;
2256 CORE_ADDR pc
= get_frame_pc (this_frame
);
2257 struct unwind_table_entry
*u
;
2259 info
= hppa_frame_cache (this_frame
, this_cache
);
2260 u
= hppa_find_unwind_entry_in_block (this_frame
);
2262 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2265 static struct value
*
2266 hppa_frame_prev_register (struct frame_info
*this_frame
,
2267 void **this_cache
, int regnum
)
2269 struct hppa_frame_cache
*info
= hppa_frame_cache (this_frame
, this_cache
);
2271 return hppa_frame_prev_register_helper (this_frame
,
2272 info
->saved_regs
, regnum
);
2276 hppa_frame_unwind_sniffer (const struct frame_unwind
*self
,
2277 struct frame_info
*this_frame
, void **this_cache
)
2279 if (hppa_find_unwind_entry_in_block (this_frame
))
2285 static const struct frame_unwind hppa_frame_unwind
=
2288 default_frame_unwind_stop_reason
,
2290 hppa_frame_prev_register
,
2292 hppa_frame_unwind_sniffer
2295 /* This is a generic fallback frame unwinder that kicks in if we fail all
2296 the other ones. Normally we would expect the stub and regular unwinder
2297 to work, but in some cases we might hit a function that just doesn't
2298 have any unwind information available. In this case we try to do
2299 unwinding solely based on code reading. This is obviously going to be
2300 slow, so only use this as a last resort. Currently this will only
2301 identify the stack and pc for the frame. */
2303 static struct hppa_frame_cache
*
2304 hppa_fallback_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
2306 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2307 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2308 struct hppa_frame_cache
*cache
;
2309 unsigned int frame_size
= 0;
2314 fprintf_unfiltered (gdb_stdlog
,
2315 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2316 frame_relative_level (this_frame
));
2318 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2319 (*this_cache
) = cache
;
2320 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2322 start_pc
= get_frame_func (this_frame
);
2325 CORE_ADDR cur_pc
= get_frame_pc (this_frame
);
2328 for (pc
= start_pc
; pc
< cur_pc
; pc
+= 4)
2332 insn
= read_memory_unsigned_integer (pc
, 4, byte_order
);
2333 frame_size
+= prologue_inst_adjust_sp (insn
);
2335 /* There are limited ways to store the return pointer into the
2337 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2339 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2342 else if (insn
== 0x0fc212c1
2343 || insn
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2345 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2352 fprintf_unfiltered (gdb_stdlog
, " frame_size=%d, found_rp=%d }\n",
2353 frame_size
, found_rp
);
2355 cache
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2356 cache
->base
-= frame_size
;
2357 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2359 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2361 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2362 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2363 cache
->saved_regs
[HPPA_RP_REGNUM
];
2368 rp
= get_frame_register_unsigned (this_frame
, HPPA_RP_REGNUM
);
2369 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2376 hppa_fallback_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2377 struct frame_id
*this_id
)
2379 struct hppa_frame_cache
*info
=
2380 hppa_fallback_frame_cache (this_frame
, this_cache
);
2382 (*this_id
) = frame_id_build (info
->base
, get_frame_func (this_frame
));
2385 static struct value
*
2386 hppa_fallback_frame_prev_register (struct frame_info
*this_frame
,
2387 void **this_cache
, int regnum
)
2389 struct hppa_frame_cache
*info
2390 = hppa_fallback_frame_cache (this_frame
, this_cache
);
2392 return hppa_frame_prev_register_helper (this_frame
,
2393 info
->saved_regs
, regnum
);
2396 static const struct frame_unwind hppa_fallback_frame_unwind
=
2399 default_frame_unwind_stop_reason
,
2400 hppa_fallback_frame_this_id
,
2401 hppa_fallback_frame_prev_register
,
2403 default_frame_sniffer
2406 /* Stub frames, used for all kinds of call stubs. */
2407 struct hppa_stub_unwind_cache
2410 struct trad_frame_saved_reg
*saved_regs
;
2413 static struct hppa_stub_unwind_cache
*
2414 hppa_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2417 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2418 struct hppa_stub_unwind_cache
*info
;
2419 struct unwind_table_entry
*u
;
2424 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2426 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2428 info
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2430 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2432 /* HPUX uses export stubs in function calls; the export stub clobbers
2433 the return value of the caller, and, later restores it from the
2435 u
= find_unwind_entry (get_frame_pc (this_frame
));
2437 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2439 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2445 /* By default we assume that stubs do not change the rp. */
2446 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2452 hppa_stub_frame_this_id (struct frame_info
*this_frame
,
2453 void **this_prologue_cache
,
2454 struct frame_id
*this_id
)
2456 struct hppa_stub_unwind_cache
*info
2457 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2460 *this_id
= frame_id_build (info
->base
, get_frame_func (this_frame
));
2463 static struct value
*
2464 hppa_stub_frame_prev_register (struct frame_info
*this_frame
,
2465 void **this_prologue_cache
, int regnum
)
2467 struct hppa_stub_unwind_cache
*info
2468 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2471 error (_("Requesting registers from null frame."));
2473 return hppa_frame_prev_register_helper (this_frame
,
2474 info
->saved_regs
, regnum
);
2478 hppa_stub_unwind_sniffer (const struct frame_unwind
*self
,
2479 struct frame_info
*this_frame
,
2482 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
2483 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2484 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2487 || (tdep
->in_solib_call_trampoline
!= NULL
2488 && tdep
->in_solib_call_trampoline (gdbarch
, pc
))
2489 || gdbarch_in_solib_return_trampoline (gdbarch
, pc
, NULL
))
2494 static const struct frame_unwind hppa_stub_frame_unwind
= {
2496 default_frame_unwind_stop_reason
,
2497 hppa_stub_frame_this_id
,
2498 hppa_stub_frame_prev_register
,
2500 hppa_stub_unwind_sniffer
2503 static struct frame_id
2504 hppa_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2506 return frame_id_build (get_frame_register_unsigned (this_frame
,
2508 get_frame_pc (this_frame
));
2512 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2517 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2518 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2520 /* If the current instruction is nullified, then we are effectively
2521 still executing the previous instruction. Pretend we are still
2522 there. This is needed when single stepping; if the nullified
2523 instruction is on a different line, we don't want GDB to think
2524 we've stepped onto that line. */
2525 if (ipsw
& 0x00200000)
2531 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2532 Return NULL if no such symbol was found. */
2534 struct bound_minimal_symbol
2535 hppa_lookup_stub_minimal_symbol (const char *name
,
2536 enum unwind_stub_types stub_type
)
2538 struct objfile
*objfile
;
2539 struct minimal_symbol
*msym
;
2540 struct bound_minimal_symbol result
= { NULL
, NULL
};
2542 ALL_MSYMBOLS (objfile
, msym
)
2544 if (strcmp (MSYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2546 struct unwind_table_entry
*u
;
2548 u
= find_unwind_entry (MSYMBOL_VALUE (msym
));
2549 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2551 result
.objfile
= objfile
;
2552 result
.minsym
= msym
;
2562 unwind_command (char *exp
, int from_tty
)
2565 struct unwind_table_entry
*u
;
2567 /* If we have an expression, evaluate it and use it as the address. */
2569 if (exp
!= 0 && *exp
!= 0)
2570 address
= parse_and_eval_address (exp
);
2574 u
= find_unwind_entry (address
);
2578 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2582 printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u
));
2584 printf_unfiltered ("\tregion_start = %s\n", hex_string (u
->region_start
));
2585 gdb_flush (gdb_stdout
);
2587 printf_unfiltered ("\tregion_end = %s\n", hex_string (u
->region_end
));
2588 gdb_flush (gdb_stdout
);
2590 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2592 printf_unfiltered ("\n\tflags =");
2593 pif (Cannot_unwind
);
2595 pif (Millicode_save_sr0
);
2598 pif (Variable_Frame
);
2599 pif (Separate_Package_Body
);
2600 pif (Frame_Extension_Millicode
);
2601 pif (Stack_Overflow_Check
);
2602 pif (Two_Instruction_SP_Increment
);
2605 pif (cxx_try_catch
);
2606 pif (sched_entry_seq
);
2609 pif (Save_MRP_in_frame
);
2611 pif (Cleanup_defined
);
2612 pif (MPE_XL_interrupt_marker
);
2613 pif (HP_UX_interrupt_marker
);
2617 putchar_unfiltered ('\n');
2619 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2621 pin (Region_description
);
2624 pin (Total_frame_size
);
2626 if (u
->stub_unwind
.stub_type
)
2628 printf_unfiltered ("\tstub type = ");
2629 switch (u
->stub_unwind
.stub_type
)
2632 printf_unfiltered ("long branch\n");
2634 case PARAMETER_RELOCATION
:
2635 printf_unfiltered ("parameter relocation\n");
2638 printf_unfiltered ("export\n");
2641 printf_unfiltered ("import\n");
2644 printf_unfiltered ("import shlib\n");
2647 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2652 /* Return the GDB type object for the "standard" data type of data in
2655 static struct type
*
2656 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2658 if (regnum
< HPPA_FP4_REGNUM
)
2659 return builtin_type (gdbarch
)->builtin_uint32
;
2661 return builtin_type (gdbarch
)->builtin_float
;
2664 static struct type
*
2665 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2667 if (regnum
< HPPA64_FP4_REGNUM
)
2668 return builtin_type (gdbarch
)->builtin_uint64
;
2670 return builtin_type (gdbarch
)->builtin_double
;
2673 /* Return non-zero if REGNUM is not a register available to the user
2674 through ptrace/ttrace. */
2677 hppa32_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2680 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2681 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2682 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2686 hppa32_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2688 /* cr26 and cr27 are readable (but not writable) from userspace. */
2689 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2692 return hppa32_cannot_store_register (gdbarch
, regnum
);
2696 hppa64_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2699 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2700 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2701 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2705 hppa64_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2707 /* cr26 and cr27 are readable (but not writable) from userspace. */
2708 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2711 return hppa64_cannot_store_register (gdbarch
, regnum
);
2715 hppa_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2717 /* The low two bits of the PC on the PA contain the privilege level.
2718 Some genius implementing a (non-GCC) compiler apparently decided
2719 this means that "addresses" in a text section therefore include a
2720 privilege level, and thus symbol tables should contain these bits.
2721 This seems like a bonehead thing to do--anyway, it seems to work
2722 for our purposes to just ignore those bits. */
2724 return (addr
&= ~0x3);
2727 /* Get the ARGIth function argument for the current function. */
2730 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2733 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2736 static enum register_status
2737 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2738 int regnum
, gdb_byte
*buf
)
2740 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2742 enum register_status status
;
2744 status
= regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2745 if (status
== REG_VALID
)
2747 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2749 store_unsigned_integer (buf
, sizeof tmp
, byte_order
, tmp
);
2755 hppa_find_global_pointer (struct gdbarch
*gdbarch
, struct value
*function
)
2761 hppa_frame_prev_register_helper (struct frame_info
*this_frame
,
2762 struct trad_frame_saved_reg saved_regs
[],
2765 struct gdbarch
*arch
= get_frame_arch (this_frame
);
2766 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2768 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2770 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2772 struct value
*pcoq_val
=
2773 trad_frame_get_prev_register (this_frame
, saved_regs
,
2774 HPPA_PCOQ_HEAD_REGNUM
);
2776 pc
= extract_unsigned_integer (value_contents_all (pcoq_val
),
2778 return frame_unwind_got_constant (this_frame
, regnum
, pc
+ 4);
2781 /* Make sure the "flags" register is zero in all unwound frames.
2782 The "flags" registers is a HP-UX specific wart, and only the code
2783 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2784 with it here. This shouldn't affect other systems since those
2785 should provide zero for the "flags" register anyway. */
2786 if (regnum
== HPPA_FLAGS_REGNUM
)
2787 return frame_unwind_got_constant (this_frame
, regnum
, 0);
2789 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
2793 /* An instruction to match. */
2796 unsigned int data
; /* See if it matches this.... */
2797 unsigned int mask
; /* ... with this mask. */
2800 /* See bfd/elf32-hppa.c */
2801 static struct insn_pattern hppa_long_branch_stub
[] = {
2802 /* ldil LR'xxx,%r1 */
2803 { 0x20200000, 0xffe00000 },
2804 /* be,n RR'xxx(%sr4,%r1) */
2805 { 0xe0202002, 0xffe02002 },
2809 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
2811 { 0xe8200000, 0xffe00000 },
2812 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2813 { 0x28200000, 0xffe00000 },
2814 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2815 { 0xe0202002, 0xffe02002 },
2819 static struct insn_pattern hppa_import_stub
[] = {
2820 /* addil LR'xxx, %dp */
2821 { 0x2b600000, 0xffe00000 },
2822 /* ldw RR'xxx(%r1), %r21 */
2823 { 0x48350000, 0xffffb000 },
2825 { 0xeaa0c000, 0xffffffff },
2826 /* ldw RR'xxx+4(%r1), %r19 */
2827 { 0x48330000, 0xffffb000 },
2831 static struct insn_pattern hppa_import_pic_stub
[] = {
2832 /* addil LR'xxx,%r19 */
2833 { 0x2a600000, 0xffe00000 },
2834 /* ldw RR'xxx(%r1),%r21 */
2835 { 0x48350000, 0xffffb000 },
2837 { 0xeaa0c000, 0xffffffff },
2838 /* ldw RR'xxx+4(%r1),%r19 */
2839 { 0x48330000, 0xffffb000 },
2843 static struct insn_pattern hppa_plt_stub
[] = {
2844 /* b,l 1b, %r20 - 1b is 3 insns before here */
2845 { 0xea9f1fdd, 0xffffffff },
2846 /* depi 0,31,2,%r20 */
2847 { 0xd6801c1e, 0xffffffff },
2851 /* Maximum number of instructions on the patterns above. */
2852 #define HPPA_MAX_INSN_PATTERN_LEN 4
2854 /* Return non-zero if the instructions at PC match the series
2855 described in PATTERN, or zero otherwise. PATTERN is an array of
2856 'struct insn_pattern' objects, terminated by an entry whose mask is
2859 When the match is successful, fill INSN[i] with what PATTERN[i]
2863 hppa_match_insns (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2864 struct insn_pattern
*pattern
, unsigned int *insn
)
2866 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2870 for (i
= 0; pattern
[i
].mask
; i
++)
2872 gdb_byte buf
[HPPA_INSN_SIZE
];
2874 target_read_memory (npc
, buf
, HPPA_INSN_SIZE
);
2875 insn
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
, byte_order
);
2876 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
2885 /* This relaxed version of the insstruction matcher allows us to match
2886 from somewhere inside the pattern, by looking backwards in the
2887 instruction scheme. */
2890 hppa_match_insns_relaxed (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2891 struct insn_pattern
*pattern
, unsigned int *insn
)
2893 int offset
, len
= 0;
2895 while (pattern
[len
].mask
)
2898 for (offset
= 0; offset
< len
; offset
++)
2899 if (hppa_match_insns (gdbarch
, pc
- offset
* HPPA_INSN_SIZE
,
2907 hppa_in_dyncall (CORE_ADDR pc
)
2909 struct unwind_table_entry
*u
;
2911 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2915 return (pc
>= u
->region_start
&& pc
<= u
->region_end
);
2919 hppa_in_solib_call_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2921 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2922 struct unwind_table_entry
*u
;
2924 if (in_plt_section (pc
) || hppa_in_dyncall (pc
))
2927 /* The GNU toolchain produces linker stubs without unwind
2928 information. Since the pattern matching for linker stubs can be
2929 quite slow, so bail out if we do have an unwind entry. */
2931 u
= find_unwind_entry (pc
);
2936 (hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_stub
, insn
)
2937 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_pic_stub
, insn
)
2938 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_long_branch_stub
, insn
)
2939 || hppa_match_insns_relaxed (gdbarch
, pc
,
2940 hppa_long_branch_pic_stub
, insn
));
2943 /* This code skips several kind of "trampolines" used on PA-RISC
2944 systems: $$dyncall, import stubs and PLT stubs. */
2947 hppa_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
2949 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2950 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
2952 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2955 /* $$dyncall handles both PLABELs and direct addresses. */
2956 if (hppa_in_dyncall (pc
))
2958 pc
= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 22);
2960 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2962 pc
= read_memory_typed_address (pc
& ~0x3, func_ptr_type
);
2967 dp_rel
= hppa_match_insns (gdbarch
, pc
, hppa_import_stub
, insn
);
2968 if (dp_rel
|| hppa_match_insns (gdbarch
, pc
, hppa_import_pic_stub
, insn
))
2970 /* Extract the target address from the addil/ldw sequence. */
2971 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
2974 pc
+= get_frame_register_unsigned (frame
, HPPA_DP_REGNUM
);
2976 pc
+= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 19);
2981 if (in_plt_section (pc
))
2983 pc
= read_memory_typed_address (pc
, func_ptr_type
);
2985 /* If the PLT slot has not yet been resolved, the target will be
2987 if (in_plt_section (pc
))
2989 /* Sanity check: are we pointing to the PLT stub? */
2990 if (!hppa_match_insns (gdbarch
, pc
, hppa_plt_stub
, insn
))
2992 warning (_("Cannot resolve PLT stub at %s."),
2993 paddress (gdbarch
, pc
));
2997 /* This should point to the fixup routine. */
2998 pc
= read_memory_typed_address (pc
+ 8, func_ptr_type
);
3006 /* Here is a table of C type sizes on hppa with various compiles
3007 and options. I measured this on PA 9000/800 with HP-UX 11.11
3008 and these compilers:
3010 /usr/ccs/bin/cc HP92453-01 A.11.01.21
3011 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
3012 /opt/aCC/bin/aCC B3910B A.03.45
3013 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3015 cc : 1 2 4 4 8 : 4 8 -- : 4 4
3016 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3017 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3018 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3019 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3020 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3021 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3022 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3026 compiler and options
3027 char, short, int, long, long long
3028 float, double, long double
3031 So all these compilers use either ILP32 or LP64 model.
3032 TODO: gcc has more options so it needs more investigation.
3034 For floating point types, see:
3036 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3037 HP-UX floating-point guide, hpux 11.00
3039 -- chastain 2003-12-18 */
3041 static struct gdbarch
*
3042 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3044 struct gdbarch_tdep
*tdep
;
3045 struct gdbarch
*gdbarch
;
3047 /* Try to determine the ABI of the object we are loading. */
3048 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
3050 /* If it's a SOM file, assume it's HP/UX SOM. */
3051 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
3052 info
.osabi
= GDB_OSABI_HPUX_SOM
;
3055 /* find a candidate among the list of pre-declared architectures. */
3056 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3058 return (arches
->gdbarch
);
3060 /* If none found, then allocate and initialize one. */
3061 tdep
= XCNEW (struct gdbarch_tdep
);
3062 gdbarch
= gdbarch_alloc (&info
, tdep
);
3064 /* Determine from the bfd_arch_info structure if we are dealing with
3065 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3066 then default to a 32bit machine. */
3067 if (info
.bfd_arch_info
!= NULL
)
3068 tdep
->bytes_per_address
=
3069 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3071 tdep
->bytes_per_address
= 4;
3073 tdep
->find_global_pointer
= hppa_find_global_pointer
;
3075 /* Some parts of the gdbarch vector depend on whether we are running
3076 on a 32 bits or 64 bits target. */
3077 switch (tdep
->bytes_per_address
)
3080 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3081 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3082 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3083 set_gdbarch_cannot_store_register (gdbarch
,
3084 hppa32_cannot_store_register
);
3085 set_gdbarch_cannot_fetch_register (gdbarch
,
3086 hppa32_cannot_fetch_register
);
3089 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3090 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3091 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3092 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3093 set_gdbarch_cannot_store_register (gdbarch
,
3094 hppa64_cannot_store_register
);
3095 set_gdbarch_cannot_fetch_register (gdbarch
,
3096 hppa64_cannot_fetch_register
);
3099 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
3100 tdep
->bytes_per_address
);
3103 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3104 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3106 /* The following gdbarch vector elements are the same in both ILP32
3107 and LP64, but might show differences some day. */
3108 set_gdbarch_long_long_bit (gdbarch
, 64);
3109 set_gdbarch_long_double_bit (gdbarch
, 128);
3110 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3112 /* The following gdbarch vector elements do not depend on the address
3113 size, or in any other gdbarch element previously set. */
3114 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3115 set_gdbarch_in_function_epilogue_p (gdbarch
,
3116 hppa_in_function_epilogue_p
);
3117 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
3118 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3119 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3120 set_gdbarch_addr_bits_remove (gdbarch
, hppa_addr_bits_remove
);
3121 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3122 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
3123 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
3125 /* Helper for function argument information. */
3126 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3128 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
3130 /* When a hardware watchpoint triggers, we'll move the inferior past
3131 it by removing all eventpoints; stepping past the instruction
3132 that caused the trigger; reinserting eventpoints; and checking
3133 whether any watched location changed. */
3134 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3136 /* Inferior function call methods. */
3137 switch (tdep
->bytes_per_address
)
3140 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3141 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3142 set_gdbarch_convert_from_func_ptr_addr
3143 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
3146 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3147 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3150 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3153 /* Struct return methods. */
3154 switch (tdep
->bytes_per_address
)
3157 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3160 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3163 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3166 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
3167 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
3169 /* Frame unwind methods. */
3170 set_gdbarch_dummy_id (gdbarch
, hppa_dummy_id
);
3171 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3173 /* Hook in ABI-specific overrides, if they have been registered. */
3174 gdbarch_init_osabi (info
, gdbarch
);
3176 /* Hook in the default unwinders. */
3177 frame_unwind_append_unwinder (gdbarch
, &hppa_stub_frame_unwind
);
3178 frame_unwind_append_unwinder (gdbarch
, &hppa_frame_unwind
);
3179 frame_unwind_append_unwinder (gdbarch
, &hppa_fallback_frame_unwind
);
3185 hppa_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
3187 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3189 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
3190 tdep
->bytes_per_address
);
3191 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
3194 /* Provide a prototype to silence -Wmissing-prototypes. */
3195 extern initialize_file_ftype _initialize_hppa_tdep
;
3198 _initialize_hppa_tdep (void)
3200 struct cmd_list_element
*c
;
3202 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3204 hppa_objfile_priv_data
= register_objfile_data ();
3206 add_cmd ("unwind", class_maintenance
, unwind_command
,
3207 _("Print unwind table entry at given address."),
3208 &maintenanceprintlist
);
3210 /* Debug this files internals. */
3211 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
3212 Set whether hppa target specific debugging information should be displayed."),
3214 Show whether hppa target specific debugging information is displayed."), _("\
3215 This flag controls whether hppa target specific debugging information is\n\
3216 displayed. This information is particularly useful for debugging frame\n\
3217 unwinding problems."),
3219 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
3220 &setdebuglist
, &showdebuglist
);