1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
5 Free Software Foundation, Inc.
7 Contributed by the Center for Software Science at the
8 University of Utah (pa-gdb-bugs@cs.utah.edu).
10 This file is part of GDB.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 51 Franklin Street, Fifth Floor,
25 Boston, MA 02110-1301, USA. */
31 #include "completer.h"
33 #include "gdb_assert.h"
34 #include "gdb_stdint.h"
35 #include "arch-utils.h"
36 /* For argument passing to the inferior */
39 #include "trad-frame.h"
40 #include "frame-unwind.h"
41 #include "frame-base.h"
47 #include "hppa-tdep.h"
49 static int hppa_debug
= 0;
51 /* Some local constants. */
52 static const int hppa32_num_regs
= 128;
53 static const int hppa64_num_regs
= 96;
55 /* hppa-specific object data -- unwind and solib info.
56 TODO/maybe: think about splitting this into two parts; the unwind data is
57 common to all hppa targets, but is only used in this file; we can register
58 that separately and make this static. The solib data is probably hpux-
59 specific, so we can create a separate extern objfile_data that is registered
60 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
61 const struct objfile_data
*hppa_objfile_priv_data
= NULL
;
63 /* Get at various relevent fields of an instruction word. */
66 #define MASK_14 0x3fff
67 #define MASK_21 0x1fffff
69 /* Sizes (in bytes) of the native unwind entries. */
70 #define UNWIND_ENTRY_SIZE 16
71 #define STUB_UNWIND_ENTRY_SIZE 8
73 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
74 following functions static, once we hppa is partially multiarched. */
75 int hppa_pc_requires_run_before_use (CORE_ADDR pc
);
77 /* Routines to extract various sized constants out of hppa
80 /* This assumes that no garbage lies outside of the lower bits of
84 hppa_sign_extend (unsigned val
, unsigned bits
)
86 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
89 /* For many immediate values the sign bit is the low bit! */
92 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
94 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
97 /* Extract the bits at positions between FROM and TO, using HP's numbering
101 hppa_get_field (unsigned word
, int from
, int to
)
103 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
106 /* extract the immediate field from a ld{bhw}s instruction */
109 hppa_extract_5_load (unsigned word
)
111 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
114 /* extract the immediate field from a break instruction */
117 hppa_extract_5r_store (unsigned word
)
119 return (word
& MASK_5
);
122 /* extract the immediate field from a {sr}sm instruction */
125 hppa_extract_5R_store (unsigned word
)
127 return (word
>> 16 & MASK_5
);
130 /* extract a 14 bit immediate field */
133 hppa_extract_14 (unsigned word
)
135 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
138 /* extract a 21 bit constant */
141 hppa_extract_21 (unsigned word
)
147 val
= hppa_get_field (word
, 20, 20);
149 val
|= hppa_get_field (word
, 9, 19);
151 val
|= hppa_get_field (word
, 5, 6);
153 val
|= hppa_get_field (word
, 0, 4);
155 val
|= hppa_get_field (word
, 7, 8);
156 return hppa_sign_extend (val
, 21) << 11;
159 /* extract a 17 bit constant from branch instructions, returning the
160 19 bit signed value. */
163 hppa_extract_17 (unsigned word
)
165 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
166 hppa_get_field (word
, 29, 29) << 10 |
167 hppa_get_field (word
, 11, 15) << 11 |
168 (word
& 0x1) << 16, 17) << 2;
172 hppa_symbol_address(const char *sym
)
174 struct minimal_symbol
*minsym
;
176 minsym
= lookup_minimal_symbol (sym
, NULL
, NULL
);
178 return SYMBOL_VALUE_ADDRESS (minsym
);
180 return (CORE_ADDR
)-1;
183 struct hppa_objfile_private
*
184 hppa_init_objfile_priv_data (struct objfile
*objfile
)
186 struct hppa_objfile_private
*priv
;
188 priv
= (struct hppa_objfile_private
*)
189 obstack_alloc (&objfile
->objfile_obstack
,
190 sizeof (struct hppa_objfile_private
));
191 set_objfile_data (objfile
, hppa_objfile_priv_data
, priv
);
192 memset (priv
, 0, sizeof (*priv
));
198 /* Compare the start address for two unwind entries returning 1 if
199 the first address is larger than the second, -1 if the second is
200 larger than the first, and zero if they are equal. */
203 compare_unwind_entries (const void *arg1
, const void *arg2
)
205 const struct unwind_table_entry
*a
= arg1
;
206 const struct unwind_table_entry
*b
= arg2
;
208 if (a
->region_start
> b
->region_start
)
210 else if (a
->region_start
< b
->region_start
)
217 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
219 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
220 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
222 bfd_vma value
= section
->vma
- section
->filepos
;
223 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
225 if (value
< *low_text_segment_address
)
226 *low_text_segment_address
= value
;
231 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
232 asection
*section
, unsigned int entries
, unsigned int size
,
233 CORE_ADDR text_offset
)
235 /* We will read the unwind entries into temporary memory, then
236 fill in the actual unwind table. */
242 char *buf
= alloca (size
);
243 CORE_ADDR low_text_segment_address
;
245 /* For ELF targets, then unwinds are supposed to
246 be segment relative offsets instead of absolute addresses.
248 Note that when loading a shared library (text_offset != 0) the
249 unwinds are already relative to the text_offset that will be
251 if (gdbarch_tdep (current_gdbarch
)->is_elf
&& text_offset
== 0)
253 low_text_segment_address
= -1;
255 bfd_map_over_sections (objfile
->obfd
,
256 record_text_segment_lowaddr
,
257 &low_text_segment_address
);
259 text_offset
= low_text_segment_address
;
261 else if (gdbarch_tdep (current_gdbarch
)->solib_get_text_base
)
263 text_offset
= gdbarch_tdep (current_gdbarch
)->solib_get_text_base (objfile
);
266 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
268 /* Now internalize the information being careful to handle host/target
270 for (i
= 0; i
< entries
; i
++)
272 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
274 table
[i
].region_start
+= text_offset
;
276 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
277 table
[i
].region_end
+= text_offset
;
279 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
281 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
282 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
283 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
284 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
285 table
[i
].reserved
= (tmp
>> 26) & 0x1;
286 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
287 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
288 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
289 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
290 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
291 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
292 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
293 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
294 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
295 table
[i
].sr4export
= (tmp
>> 9) & 0x1;
296 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
297 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
298 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
299 table
[i
].reserved1
= (tmp
>> 5) & 0x1;
300 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
301 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
302 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
303 table
[i
].save_r19
= (tmp
>> 1) & 0x1;
304 table
[i
].Cleanup_defined
= tmp
& 0x1;
305 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
307 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
308 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
309 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
310 table
[i
].alloca_frame
= (tmp
>> 28) & 0x1;
311 table
[i
].reserved2
= (tmp
>> 27) & 0x1;
312 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
314 /* Stub unwinds are handled elsewhere. */
315 table
[i
].stub_unwind
.stub_type
= 0;
316 table
[i
].stub_unwind
.padding
= 0;
321 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
322 the object file. This info is used mainly by find_unwind_entry() to find
323 out the stack frame size and frame pointer used by procedures. We put
324 everything on the psymbol obstack in the objfile so that it automatically
325 gets freed when the objfile is destroyed. */
328 read_unwind_info (struct objfile
*objfile
)
330 asection
*unwind_sec
, *stub_unwind_sec
;
331 unsigned unwind_size
, stub_unwind_size
, total_size
;
332 unsigned index
, unwind_entries
;
333 unsigned stub_entries
, total_entries
;
334 CORE_ADDR text_offset
;
335 struct hppa_unwind_info
*ui
;
336 struct hppa_objfile_private
*obj_private
;
338 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
339 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
340 sizeof (struct hppa_unwind_info
));
346 /* For reasons unknown the HP PA64 tools generate multiple unwinder
347 sections in a single executable. So we just iterate over every
348 section in the BFD looking for unwinder sections intead of trying
349 to do a lookup with bfd_get_section_by_name.
351 First determine the total size of the unwind tables so that we
352 can allocate memory in a nice big hunk. */
354 for (unwind_sec
= objfile
->obfd
->sections
;
356 unwind_sec
= unwind_sec
->next
)
358 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
359 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
361 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
362 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
364 total_entries
+= unwind_entries
;
368 /* Now compute the size of the stub unwinds. Note the ELF tools do not
369 use stub unwinds at the current time. */
370 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
374 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
375 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
379 stub_unwind_size
= 0;
383 /* Compute total number of unwind entries and their total size. */
384 total_entries
+= stub_entries
;
385 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
387 /* Allocate memory for the unwind table. */
388 ui
->table
= (struct unwind_table_entry
*)
389 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
390 ui
->last
= total_entries
- 1;
392 /* Now read in each unwind section and internalize the standard unwind
395 for (unwind_sec
= objfile
->obfd
->sections
;
397 unwind_sec
= unwind_sec
->next
)
399 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
400 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
402 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
403 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
405 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
406 unwind_entries
, unwind_size
, text_offset
);
407 index
+= unwind_entries
;
411 /* Now read in and internalize the stub unwind entries. */
412 if (stub_unwind_size
> 0)
415 char *buf
= alloca (stub_unwind_size
);
417 /* Read in the stub unwind entries. */
418 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
419 0, stub_unwind_size
);
421 /* Now convert them into regular unwind entries. */
422 for (i
= 0; i
< stub_entries
; i
++, index
++)
424 /* Clear out the next unwind entry. */
425 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
427 /* Convert offset & size into region_start and region_end.
428 Stuff away the stub type into "reserved" fields. */
429 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
431 ui
->table
[index
].region_start
+= text_offset
;
433 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
436 ui
->table
[index
].region_end
437 = ui
->table
[index
].region_start
+ 4 *
438 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
444 /* Unwind table needs to be kept sorted. */
445 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
446 compare_unwind_entries
);
448 /* Keep a pointer to the unwind information. */
449 obj_private
= (struct hppa_objfile_private
*)
450 objfile_data (objfile
, hppa_objfile_priv_data
);
451 if (obj_private
== NULL
)
452 obj_private
= hppa_init_objfile_priv_data (objfile
);
454 obj_private
->unwind_info
= ui
;
457 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
458 of the objfiles seeking the unwind table entry for this PC. Each objfile
459 contains a sorted list of struct unwind_table_entry. Since we do a binary
460 search of the unwind tables, we depend upon them to be sorted. */
462 struct unwind_table_entry
*
463 find_unwind_entry (CORE_ADDR pc
)
465 int first
, middle
, last
;
466 struct objfile
*objfile
;
467 struct hppa_objfile_private
*priv
;
470 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
473 /* A function at address 0? Not in HP-UX! */
474 if (pc
== (CORE_ADDR
) 0)
477 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
481 ALL_OBJFILES (objfile
)
483 struct hppa_unwind_info
*ui
;
485 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
487 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
491 read_unwind_info (objfile
);
492 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
494 error (_("Internal error reading unwind information."));
495 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
498 /* First, check the cache */
501 && pc
>= ui
->cache
->region_start
502 && pc
<= ui
->cache
->region_end
)
505 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
506 paddr_nz ((uintptr_t) ui
->cache
));
510 /* Not in the cache, do a binary search */
515 while (first
<= last
)
517 middle
= (first
+ last
) / 2;
518 if (pc
>= ui
->table
[middle
].region_start
519 && pc
<= ui
->table
[middle
].region_end
)
521 ui
->cache
= &ui
->table
[middle
];
523 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
524 paddr_nz ((uintptr_t) ui
->cache
));
525 return &ui
->table
[middle
];
528 if (pc
< ui
->table
[middle
].region_start
)
533 } /* ALL_OBJFILES() */
536 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
541 /* The epilogue is defined here as the area either on the `bv' instruction
542 itself or an instruction which destroys the function's stack frame.
544 We do not assume that the epilogue is at the end of a function as we can
545 also have return sequences in the middle of a function. */
547 hppa_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
549 unsigned long status
;
554 status
= read_memory_nobpt (pc
, buf
, 4);
558 inst
= extract_unsigned_integer (buf
, 4);
560 /* The most common way to perform a stack adjustment ldo X(sp),sp
561 We are destroying a stack frame if the offset is negative. */
562 if ((inst
& 0xffffc000) == 0x37de0000
563 && hppa_extract_14 (inst
) < 0)
566 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
567 if (((inst
& 0x0fc010e0) == 0x0fc010e0
568 || (inst
& 0x0fc010e0) == 0x0fc010e0)
569 && hppa_extract_14 (inst
) < 0)
572 /* bv %r0(%rp) or bv,n %r0(%rp) */
573 if (inst
== 0xe840c000 || inst
== 0xe840c002)
579 static const unsigned char *
580 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
582 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
583 (*len
) = sizeof (breakpoint
);
587 /* Return the name of a register. */
590 hppa32_register_name (int i
)
592 static char *names
[] = {
593 "flags", "r1", "rp", "r3",
594 "r4", "r5", "r6", "r7",
595 "r8", "r9", "r10", "r11",
596 "r12", "r13", "r14", "r15",
597 "r16", "r17", "r18", "r19",
598 "r20", "r21", "r22", "r23",
599 "r24", "r25", "r26", "dp",
600 "ret0", "ret1", "sp", "r31",
601 "sar", "pcoqh", "pcsqh", "pcoqt",
602 "pcsqt", "eiem", "iir", "isr",
603 "ior", "ipsw", "goto", "sr4",
604 "sr0", "sr1", "sr2", "sr3",
605 "sr5", "sr6", "sr7", "cr0",
606 "cr8", "cr9", "ccr", "cr12",
607 "cr13", "cr24", "cr25", "cr26",
608 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
609 "fpsr", "fpe1", "fpe2", "fpe3",
610 "fpe4", "fpe5", "fpe6", "fpe7",
611 "fr4", "fr4R", "fr5", "fr5R",
612 "fr6", "fr6R", "fr7", "fr7R",
613 "fr8", "fr8R", "fr9", "fr9R",
614 "fr10", "fr10R", "fr11", "fr11R",
615 "fr12", "fr12R", "fr13", "fr13R",
616 "fr14", "fr14R", "fr15", "fr15R",
617 "fr16", "fr16R", "fr17", "fr17R",
618 "fr18", "fr18R", "fr19", "fr19R",
619 "fr20", "fr20R", "fr21", "fr21R",
620 "fr22", "fr22R", "fr23", "fr23R",
621 "fr24", "fr24R", "fr25", "fr25R",
622 "fr26", "fr26R", "fr27", "fr27R",
623 "fr28", "fr28R", "fr29", "fr29R",
624 "fr30", "fr30R", "fr31", "fr31R"
626 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
633 hppa64_register_name (int i
)
635 static char *names
[] = {
636 "flags", "r1", "rp", "r3",
637 "r4", "r5", "r6", "r7",
638 "r8", "r9", "r10", "r11",
639 "r12", "r13", "r14", "r15",
640 "r16", "r17", "r18", "r19",
641 "r20", "r21", "r22", "r23",
642 "r24", "r25", "r26", "dp",
643 "ret0", "ret1", "sp", "r31",
644 "sar", "pcoqh", "pcsqh", "pcoqt",
645 "pcsqt", "eiem", "iir", "isr",
646 "ior", "ipsw", "goto", "sr4",
647 "sr0", "sr1", "sr2", "sr3",
648 "sr5", "sr6", "sr7", "cr0",
649 "cr8", "cr9", "ccr", "cr12",
650 "cr13", "cr24", "cr25", "cr26",
651 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
652 "fpsr", "fpe1", "fpe2", "fpe3",
653 "fr4", "fr5", "fr6", "fr7",
654 "fr8", "fr9", "fr10", "fr11",
655 "fr12", "fr13", "fr14", "fr15",
656 "fr16", "fr17", "fr18", "fr19",
657 "fr20", "fr21", "fr22", "fr23",
658 "fr24", "fr25", "fr26", "fr27",
659 "fr28", "fr29", "fr30", "fr31"
661 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
668 hppa64_dwarf_reg_to_regnum (int reg
)
670 /* r0-r31 and sar map one-to-one. */
674 /* fr4-fr31 are mapped from 72 in steps of 2. */
675 if (reg
>= 72 || reg
< 72 + 28 * 2)
676 return HPPA64_FP4_REGNUM
+ (reg
- 72) / 2;
678 error ("Invalid DWARF register num %d.", reg
);
682 /* This function pushes a stack frame with arguments as part of the
683 inferior function calling mechanism.
685 This is the version of the function for the 32-bit PA machines, in
686 which later arguments appear at lower addresses. (The stack always
687 grows towards higher addresses.)
689 We simply allocate the appropriate amount of stack space and put
690 arguments into their proper slots. */
693 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
694 struct regcache
*regcache
, CORE_ADDR bp_addr
,
695 int nargs
, struct value
**args
, CORE_ADDR sp
,
696 int struct_return
, CORE_ADDR struct_addr
)
698 /* Stack base address at which any pass-by-reference parameters are
700 CORE_ADDR struct_end
= 0;
701 /* Stack base address at which the first parameter is stored. */
702 CORE_ADDR param_end
= 0;
704 /* The inner most end of the stack after all the parameters have
706 CORE_ADDR new_sp
= 0;
708 /* Two passes. First pass computes the location of everything,
709 second pass writes the bytes out. */
712 /* Global pointer (r19) of the function we are trying to call. */
715 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
717 for (write_pass
= 0; write_pass
< 2; write_pass
++)
719 CORE_ADDR struct_ptr
= 0;
720 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
721 struct_ptr is adjusted for each argument below, so the first
722 argument will end up at sp-36. */
723 CORE_ADDR param_ptr
= 32;
725 int small_struct
= 0;
727 for (i
= 0; i
< nargs
; i
++)
729 struct value
*arg
= args
[i
];
730 struct type
*type
= check_typedef (value_type (arg
));
731 /* The corresponding parameter that is pushed onto the
732 stack, and [possibly] passed in a register. */
735 memset (param_val
, 0, sizeof param_val
);
736 if (TYPE_LENGTH (type
) > 8)
738 /* Large parameter, pass by reference. Store the value
739 in "struct" area and then pass its address. */
741 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
743 write_memory (struct_end
- struct_ptr
, value_contents (arg
),
745 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
747 else if (TYPE_CODE (type
) == TYPE_CODE_INT
748 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
750 /* Integer value store, right aligned. "unpack_long"
751 takes care of any sign-extension problems. */
752 param_len
= align_up (TYPE_LENGTH (type
), 4);
753 store_unsigned_integer (param_val
, param_len
,
755 value_contents (arg
)));
757 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
759 /* Floating point value store, right aligned. */
760 param_len
= align_up (TYPE_LENGTH (type
), 4);
761 memcpy (param_val
, value_contents (arg
), param_len
);
765 param_len
= align_up (TYPE_LENGTH (type
), 4);
767 /* Small struct value are stored right-aligned. */
768 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
769 value_contents (arg
), TYPE_LENGTH (type
));
771 /* Structures of size 5, 6 and 7 bytes are special in that
772 the higher-ordered word is stored in the lower-ordered
773 argument, and even though it is a 8-byte quantity the
774 registers need not be 8-byte aligned. */
775 if (param_len
> 4 && param_len
< 8)
779 param_ptr
+= param_len
;
780 if (param_len
== 8 && !small_struct
)
781 param_ptr
= align_up (param_ptr
, 8);
783 /* First 4 non-FP arguments are passed in gr26-gr23.
784 First 4 32-bit FP arguments are passed in fr4L-fr7L.
785 First 2 64-bit FP arguments are passed in fr5 and fr7.
787 The rest go on the stack, starting at sp-36, towards lower
788 addresses. 8-byte arguments must be aligned to a 8-byte
792 write_memory (param_end
- param_ptr
, param_val
, param_len
);
794 /* There are some cases when we don't know the type
795 expected by the callee (e.g. for variadic functions), so
796 pass the parameters in both general and fp regs. */
799 int grreg
= 26 - (param_ptr
- 36) / 4;
800 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
801 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
803 regcache_cooked_write (regcache
, grreg
, param_val
);
804 regcache_cooked_write (regcache
, fpLreg
, param_val
);
808 regcache_cooked_write (regcache
, grreg
+ 1,
811 regcache_cooked_write (regcache
, fpreg
, param_val
);
812 regcache_cooked_write (regcache
, fpreg
+ 1,
819 /* Update the various stack pointers. */
822 struct_end
= sp
+ align_up (struct_ptr
, 64);
823 /* PARAM_PTR already accounts for all the arguments passed
824 by the user. However, the ABI mandates minimum stack
825 space allocations for outgoing arguments. The ABI also
826 mandates minimum stack alignments which we must
828 param_end
= struct_end
+ align_up (param_ptr
, 64);
832 /* If a structure has to be returned, set up register 28 to hold its
835 write_register (28, struct_addr
);
837 gp
= tdep
->find_global_pointer (function
);
840 write_register (19, gp
);
842 /* Set the return address. */
843 if (!gdbarch_push_dummy_code_p (gdbarch
))
844 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
846 /* Update the Stack Pointer. */
847 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
852 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
853 Runtime Architecture for PA-RISC 2.0", which is distributed as part
854 as of the HP-UX Software Transition Kit (STK). This implementation
855 is based on version 3.3, dated October 6, 1997. */
857 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
860 hppa64_integral_or_pointer_p (const struct type
*type
)
862 switch (TYPE_CODE (type
))
868 case TYPE_CODE_RANGE
:
870 int len
= TYPE_LENGTH (type
);
871 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
875 return (TYPE_LENGTH (type
) == 8);
883 /* Check whether TYPE is a "Floating Scalar Type". */
886 hppa64_floating_p (const struct type
*type
)
888 switch (TYPE_CODE (type
))
892 int len
= TYPE_LENGTH (type
);
893 return (len
== 4 || len
== 8 || len
== 16);
902 /* If CODE points to a function entry address, try to look up the corresponding
903 function descriptor and return its address instead. If CODE is not a
904 function entry address, then just return it unchanged. */
906 hppa64_convert_code_addr_to_fptr (CORE_ADDR code
)
908 struct obj_section
*sec
, *opd
;
910 sec
= find_pc_section (code
);
915 /* If CODE is in a data section, assume it's already a fptr. */
916 if (!(sec
->the_bfd_section
->flags
& SEC_CODE
))
919 ALL_OBJFILE_OSECTIONS (sec
->objfile
, opd
)
921 if (strcmp (opd
->the_bfd_section
->name
, ".opd") == 0)
925 if (opd
< sec
->objfile
->sections_end
)
929 for (addr
= opd
->addr
; addr
< opd
->endaddr
; addr
+= 2 * 8)
934 if (target_read_memory (addr
, tmp
, sizeof (tmp
)))
936 opdaddr
= extract_unsigned_integer (tmp
, sizeof (tmp
));
947 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
948 struct regcache
*regcache
, CORE_ADDR bp_addr
,
949 int nargs
, struct value
**args
, CORE_ADDR sp
,
950 int struct_return
, CORE_ADDR struct_addr
)
952 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
956 /* "The outgoing parameter area [...] must be aligned at a 16-byte
958 sp
= align_up (sp
, 16);
960 for (i
= 0; i
< nargs
; i
++)
962 struct value
*arg
= args
[i
];
963 struct type
*type
= value_type (arg
);
964 int len
= TYPE_LENGTH (type
);
965 const bfd_byte
*valbuf
;
969 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
970 offset
= align_up (offset
, 8);
972 if (hppa64_integral_or_pointer_p (type
))
974 /* "Integral scalar parameters smaller than 64 bits are
975 padded on the left (i.e., the value is in the
976 least-significant bits of the 64-bit storage unit, and
977 the high-order bits are undefined)." Therefore we can
978 safely sign-extend them. */
981 arg
= value_cast (builtin_type_int64
, arg
);
985 else if (hppa64_floating_p (type
))
989 /* "Quad-precision (128-bit) floating-point scalar
990 parameters are aligned on a 16-byte boundary." */
991 offset
= align_up (offset
, 16);
993 /* "Double-extended- and quad-precision floating-point
994 parameters within the first 64 bytes of the parameter
995 list are always passed in general registers." */
1001 /* "Single-precision (32-bit) floating-point scalar
1002 parameters are padded on the left with 32 bits of
1003 garbage (i.e., the floating-point value is in the
1004 least-significant 32 bits of a 64-bit storage
1009 /* "Single- and double-precision floating-point
1010 parameters in this area are passed according to the
1011 available formal parameter information in a function
1012 prototype. [...] If no prototype is in scope,
1013 floating-point parameters must be passed both in the
1014 corresponding general registers and in the
1015 corresponding floating-point registers." */
1016 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
1018 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
1020 /* "Single-precision floating-point parameters, when
1021 passed in floating-point registers, are passed in
1022 the right halves of the floating point registers;
1023 the left halves are unused." */
1024 regcache_cooked_write_part (regcache
, regnum
, offset
% 8,
1025 len
, value_contents (arg
));
1033 /* "Aggregates larger than 8 bytes are aligned on a
1034 16-byte boundary, possibly leaving an unused argument
1035 slot, which is filled with garbage. If necessary,
1036 they are padded on the right (with garbage), to a
1037 multiple of 8 bytes." */
1038 offset
= align_up (offset
, 16);
1042 /* If we are passing a function pointer, make sure we pass a function
1043 descriptor instead of the function entry address. */
1044 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1045 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1047 ULONGEST codeptr
, fptr
;
1049 codeptr
= unpack_long (type
, value_contents (arg
));
1050 fptr
= hppa64_convert_code_addr_to_fptr (codeptr
);
1051 store_unsigned_integer (fptrbuf
, TYPE_LENGTH (type
), fptr
);
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 (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
,
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
,
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 CORE_ADDR plabel
= addr
& ~3;
1253 return read_memory_typed_address (plabel
, builtin_type_void_func_ptr
);
1260 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1262 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1264 return align_up (addr
, 64);
1267 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1270 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1272 /* Just always 16-byte align. */
1273 return align_up (addr
, 16);
1277 hppa_read_pc (ptid_t ptid
)
1282 ipsw
= read_register_pid (HPPA_IPSW_REGNUM
, ptid
);
1283 pc
= read_register_pid (HPPA_PCOQ_HEAD_REGNUM
, ptid
);
1285 /* If the current instruction is nullified, then we are effectively
1286 still executing the previous instruction. Pretend we are still
1287 there. This is needed when single stepping; if the nullified
1288 instruction is on a different line, we don't want GDB to think
1289 we've stepped onto that line. */
1290 if (ipsw
& 0x00200000)
1297 hppa_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1299 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, pc
, ptid
);
1300 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4, ptid
);
1303 /* return the alignment of a type in bytes. Structures have the maximum
1304 alignment required by their fields. */
1307 hppa_alignof (struct type
*type
)
1309 int max_align
, align
, i
;
1310 CHECK_TYPEDEF (type
);
1311 switch (TYPE_CODE (type
))
1316 return TYPE_LENGTH (type
);
1317 case TYPE_CODE_ARRAY
:
1318 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1319 case TYPE_CODE_STRUCT
:
1320 case TYPE_CODE_UNION
:
1322 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1324 /* Bit fields have no real alignment. */
1325 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1326 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1328 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1329 max_align
= max (max_align
, align
);
1338 /* For the given instruction (INST), return any adjustment it makes
1339 to the stack pointer or zero for no adjustment.
1341 This only handles instructions commonly found in prologues. */
1344 prologue_inst_adjust_sp (unsigned long inst
)
1346 /* This must persist across calls. */
1347 static int save_high21
;
1349 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1350 if ((inst
& 0xffffc000) == 0x37de0000)
1351 return hppa_extract_14 (inst
);
1354 if ((inst
& 0xffe00000) == 0x6fc00000)
1355 return hppa_extract_14 (inst
);
1357 /* std,ma X,D(sp) */
1358 if ((inst
& 0xffe00008) == 0x73c00008)
1359 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1361 /* addil high21,%r30; ldo low11,(%r1),%r30)
1362 save high bits in save_high21 for later use. */
1363 if ((inst
& 0xffe00000) == 0x2bc00000)
1365 save_high21
= hppa_extract_21 (inst
);
1369 if ((inst
& 0xffff0000) == 0x343e0000)
1370 return save_high21
+ hppa_extract_14 (inst
);
1372 /* fstws as used by the HP compilers. */
1373 if ((inst
& 0xffffffe0) == 0x2fd01220)
1374 return hppa_extract_5_load (inst
);
1376 /* No adjustment. */
1380 /* Return nonzero if INST is a branch of some kind, else return zero. */
1383 is_branch (unsigned long inst
)
1412 /* Return the register number for a GR which is saved by INST or
1413 zero it INST does not save a GR. */
1416 inst_saves_gr (unsigned long inst
)
1418 /* Does it look like a stw? */
1419 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1420 || (inst
>> 26) == 0x1f
1421 || ((inst
>> 26) == 0x1f
1422 && ((inst
>> 6) == 0xa)))
1423 return hppa_extract_5R_store (inst
);
1425 /* Does it look like a std? */
1426 if ((inst
>> 26) == 0x1c
1427 || ((inst
>> 26) == 0x03
1428 && ((inst
>> 6) & 0xf) == 0xb))
1429 return hppa_extract_5R_store (inst
);
1431 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1432 if ((inst
>> 26) == 0x1b)
1433 return hppa_extract_5R_store (inst
);
1435 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1437 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1438 || ((inst
>> 26) == 0x3
1439 && (((inst
>> 6) & 0xf) == 0x8
1440 || (inst
>> 6) & 0xf) == 0x9))
1441 return hppa_extract_5R_store (inst
);
1446 /* Return the register number for a FR which is saved by INST or
1447 zero it INST does not save a FR.
1449 Note we only care about full 64bit register stores (that's the only
1450 kind of stores the prologue will use).
1452 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1455 inst_saves_fr (unsigned long inst
)
1457 /* is this an FSTD ? */
1458 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1459 return hppa_extract_5r_store (inst
);
1460 if ((inst
& 0xfc000002) == 0x70000002)
1461 return hppa_extract_5R_store (inst
);
1462 /* is this an FSTW ? */
1463 if ((inst
& 0xfc00df80) == 0x24001200)
1464 return hppa_extract_5r_store (inst
);
1465 if ((inst
& 0xfc000002) == 0x7c000000)
1466 return hppa_extract_5R_store (inst
);
1470 /* Advance PC across any function entry prologue instructions
1471 to reach some "real" code.
1473 Use information in the unwind table to determine what exactly should
1474 be in the prologue. */
1478 skip_prologue_hard_way (CORE_ADDR pc
, int stop_before_branch
)
1481 CORE_ADDR orig_pc
= pc
;
1482 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1483 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1484 struct unwind_table_entry
*u
;
1485 int final_iteration
;
1491 u
= find_unwind_entry (pc
);
1495 /* If we are not at the beginning of a function, then return now. */
1496 if ((pc
& ~0x3) != u
->region_start
)
1499 /* This is how much of a frame adjustment we need to account for. */
1500 stack_remaining
= u
->Total_frame_size
<< 3;
1502 /* Magic register saves we want to know about. */
1503 save_rp
= u
->Save_RP
;
1504 save_sp
= u
->Save_SP
;
1506 /* An indication that args may be stored into the stack. Unfortunately
1507 the HPUX compilers tend to set this in cases where no args were
1511 /* Turn the Entry_GR field into a bitmask. */
1513 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1515 /* Frame pointer gets saved into a special location. */
1516 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1519 save_gr
|= (1 << i
);
1521 save_gr
&= ~restart_gr
;
1523 /* Turn the Entry_FR field into a bitmask too. */
1525 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1526 save_fr
|= (1 << i
);
1527 save_fr
&= ~restart_fr
;
1529 final_iteration
= 0;
1531 /* Loop until we find everything of interest or hit a branch.
1533 For unoptimized GCC code and for any HP CC code this will never ever
1534 examine any user instructions.
1536 For optimzied GCC code we're faced with problems. GCC will schedule
1537 its prologue and make prologue instructions available for delay slot
1538 filling. The end result is user code gets mixed in with the prologue
1539 and a prologue instruction may be in the delay slot of the first branch
1542 Some unexpected things are expected with debugging optimized code, so
1543 we allow this routine to walk past user instructions in optimized
1545 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1548 unsigned int reg_num
;
1549 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1550 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1552 /* Save copies of all the triggers so we can compare them later
1554 old_save_gr
= save_gr
;
1555 old_save_fr
= save_fr
;
1556 old_save_rp
= save_rp
;
1557 old_save_sp
= save_sp
;
1558 old_stack_remaining
= stack_remaining
;
1560 status
= read_memory_nobpt (pc
, buf
, 4);
1561 inst
= extract_unsigned_integer (buf
, 4);
1567 /* Note the interesting effects of this instruction. */
1568 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1570 /* There are limited ways to store the return pointer into the
1572 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1575 /* These are the only ways we save SP into the stack. At this time
1576 the HP compilers never bother to save SP into the stack. */
1577 if ((inst
& 0xffffc000) == 0x6fc10000
1578 || (inst
& 0xffffc00c) == 0x73c10008)
1581 /* Are we loading some register with an offset from the argument
1583 if ((inst
& 0xffe00000) == 0x37a00000
1584 || (inst
& 0xffffffe0) == 0x081d0240)
1590 /* Account for general and floating-point register saves. */
1591 reg_num
= inst_saves_gr (inst
);
1592 save_gr
&= ~(1 << reg_num
);
1594 /* Ugh. Also account for argument stores into the stack.
1595 Unfortunately args_stored only tells us that some arguments
1596 where stored into the stack. Not how many or what kind!
1598 This is a kludge as on the HP compiler sets this bit and it
1599 never does prologue scheduling. So once we see one, skip past
1600 all of them. We have similar code for the fp arg stores below.
1602 FIXME. Can still die if we have a mix of GR and FR argument
1604 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1606 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1609 status
= read_memory_nobpt (pc
, buf
, 4);
1610 inst
= extract_unsigned_integer (buf
, 4);
1613 reg_num
= inst_saves_gr (inst
);
1619 reg_num
= inst_saves_fr (inst
);
1620 save_fr
&= ~(1 << reg_num
);
1622 status
= read_memory_nobpt (pc
+ 4, buf
, 4);
1623 next_inst
= extract_unsigned_integer (buf
, 4);
1629 /* We've got to be read to handle the ldo before the fp register
1631 if ((inst
& 0xfc000000) == 0x34000000
1632 && inst_saves_fr (next_inst
) >= 4
1633 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1635 /* So we drop into the code below in a reasonable state. */
1636 reg_num
= inst_saves_fr (next_inst
);
1640 /* Ugh. Also account for argument stores into the stack.
1641 This is a kludge as on the HP compiler sets this bit and it
1642 never does prologue scheduling. So once we see one, skip past
1644 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1646 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1649 status
= read_memory_nobpt (pc
, buf
, 4);
1650 inst
= extract_unsigned_integer (buf
, 4);
1653 if ((inst
& 0xfc000000) != 0x34000000)
1655 status
= read_memory_nobpt (pc
+ 4, buf
, 4);
1656 next_inst
= extract_unsigned_integer (buf
, 4);
1659 reg_num
= inst_saves_fr (next_inst
);
1665 /* Quit if we hit any kind of branch. This can happen if a prologue
1666 instruction is in the delay slot of the first call/branch. */
1667 if (is_branch (inst
) && stop_before_branch
)
1670 /* What a crock. The HP compilers set args_stored even if no
1671 arguments were stored into the stack (boo hiss). This could
1672 cause this code to then skip a bunch of user insns (up to the
1675 To combat this we try to identify when args_stored was bogusly
1676 set and clear it. We only do this when args_stored is nonzero,
1677 all other resources are accounted for, and nothing changed on
1680 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1681 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1682 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1683 && old_stack_remaining
== stack_remaining
)
1689 /* !stop_before_branch, so also look at the insn in the delay slot
1691 if (final_iteration
)
1693 if (is_branch (inst
))
1694 final_iteration
= 1;
1697 /* We've got a tenative location for the end of the prologue. However
1698 because of limitations in the unwind descriptor mechanism we may
1699 have went too far into user code looking for the save of a register
1700 that does not exist. So, if there registers we expected to be saved
1701 but never were, mask them out and restart.
1703 This should only happen in optimized code, and should be very rare. */
1704 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1707 restart_gr
= save_gr
;
1708 restart_fr
= save_fr
;
1716 /* Return the address of the PC after the last prologue instruction if
1717 we can determine it from the debug symbols. Else return zero. */
1720 after_prologue (CORE_ADDR pc
)
1722 struct symtab_and_line sal
;
1723 CORE_ADDR func_addr
, func_end
;
1726 /* If we can not find the symbol in the partial symbol table, then
1727 there is no hope we can determine the function's start address
1729 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1732 /* Get the line associated with FUNC_ADDR. */
1733 sal
= find_pc_line (func_addr
, 0);
1735 /* There are only two cases to consider. First, the end of the source line
1736 is within the function bounds. In that case we return the end of the
1737 source line. Second is the end of the source line extends beyond the
1738 bounds of the current function. We need to use the slow code to
1739 examine instructions in that case.
1741 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1742 the wrong thing to do. In fact, it should be entirely possible for this
1743 function to always return zero since the slow instruction scanning code
1744 is supposed to *always* work. If it does not, then it is a bug. */
1745 if (sal
.end
< func_end
)
1751 /* To skip prologues, I use this predicate. Returns either PC itself
1752 if the code at PC does not look like a function prologue; otherwise
1753 returns an address that (if we're lucky) follows the prologue.
1755 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1756 It doesn't necessarily skips all the insns in the prologue. In fact
1757 we might not want to skip all the insns because a prologue insn may
1758 appear in the delay slot of the first branch, and we don't want to
1759 skip over the branch in that case. */
1762 hppa_skip_prologue (CORE_ADDR pc
)
1766 CORE_ADDR post_prologue_pc
;
1769 /* See if we can determine the end of the prologue via the symbol table.
1770 If so, then return either PC, or the PC after the prologue, whichever
1773 post_prologue_pc
= after_prologue (pc
);
1775 /* If after_prologue returned a useful address, then use it. Else
1776 fall back on the instruction skipping code.
1778 Some folks have claimed this causes problems because the breakpoint
1779 may be the first instruction of the prologue. If that happens, then
1780 the instruction skipping code has a bug that needs to be fixed. */
1781 if (post_prologue_pc
!= 0)
1782 return max (pc
, post_prologue_pc
);
1784 return (skip_prologue_hard_way (pc
, 1));
1787 /* Return an unwind entry that falls within the frame's code block. */
1788 static struct unwind_table_entry
*
1789 hppa_find_unwind_entry_in_block (struct frame_info
*f
)
1791 CORE_ADDR pc
= frame_unwind_address_in_block (f
, NORMAL_FRAME
);
1793 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1794 result of frame_unwind_address_in_block implies a problem.
1795 The bits should have been removed earlier, before the return
1796 value of frame_pc_unwind. That might be happening already;
1797 if it isn't, it should be fixed. Then this call can be
1799 pc
= gdbarch_addr_bits_remove (get_frame_arch (f
), pc
);
1800 return find_unwind_entry (pc
);
1803 struct hppa_frame_cache
1806 struct trad_frame_saved_reg
*saved_regs
;
1809 static struct hppa_frame_cache
*
1810 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1812 struct hppa_frame_cache
*cache
;
1817 struct unwind_table_entry
*u
;
1818 CORE_ADDR prologue_end
;
1823 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1824 frame_relative_level(next_frame
));
1826 if ((*this_cache
) != NULL
)
1829 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1830 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1831 return (*this_cache
);
1833 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1834 (*this_cache
) = cache
;
1835 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1838 u
= hppa_find_unwind_entry_in_block (next_frame
);
1842 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1843 return (*this_cache
);
1846 /* Turn the Entry_GR field into a bitmask. */
1848 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1850 /* Frame pointer gets saved into a special location. */
1851 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1854 saved_gr_mask
|= (1 << i
);
1857 /* Turn the Entry_FR field into a bitmask too. */
1859 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1860 saved_fr_mask
|= (1 << i
);
1862 /* Loop until we find everything of interest or hit a branch.
1864 For unoptimized GCC code and for any HP CC code this will never ever
1865 examine any user instructions.
1867 For optimized GCC code we're faced with problems. GCC will schedule
1868 its prologue and make prologue instructions available for delay slot
1869 filling. The end result is user code gets mixed in with the prologue
1870 and a prologue instruction may be in the delay slot of the first branch
1873 Some unexpected things are expected with debugging optimized code, so
1874 we allow this routine to walk past user instructions in optimized
1877 int final_iteration
= 0;
1878 CORE_ADDR pc
, start_pc
, end_pc
;
1879 int looking_for_sp
= u
->Save_SP
;
1880 int looking_for_rp
= u
->Save_RP
;
1883 /* We have to use skip_prologue_hard_way instead of just
1884 skip_prologue_using_sal, in case we stepped into a function without
1885 symbol information. hppa_skip_prologue also bounds the returned
1886 pc by the passed in pc, so it will not return a pc in the next
1889 We used to call hppa_skip_prologue to find the end of the prologue,
1890 but if some non-prologue instructions get scheduled into the prologue,
1891 and the program is compiled with debug information, the "easy" way
1892 in hppa_skip_prologue will return a prologue end that is too early
1893 for us to notice any potential frame adjustments. */
1895 /* We used to use frame_func_unwind () to locate the beginning of the
1896 function to pass to skip_prologue (). However, when objects are
1897 compiled without debug symbols, frame_func_unwind can return the wrong
1898 function (or 0). We can do better than that by using unwind records.
1899 This only works if the Region_description of the unwind record
1900 indicates that it includes the entry point of the function.
1901 HP compilers sometimes generate unwind records for regions that
1902 do not include the entry or exit point of a function. GNU tools
1905 if ((u
->Region_description
& 0x2) == 0)
1906 start_pc
= u
->region_start
;
1908 start_pc
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
1910 prologue_end
= skip_prologue_hard_way (start_pc
, 0);
1911 end_pc
= frame_pc_unwind (next_frame
);
1913 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1914 end_pc
= prologue_end
;
1919 ((saved_gr_mask
|| saved_fr_mask
1920 || looking_for_sp
|| looking_for_rp
1921 || frame_size
< (u
->Total_frame_size
<< 3))
1929 if (!safe_frame_unwind_memory (next_frame
, pc
, buf4
,
1932 error (_("Cannot read instruction at 0x%s."), paddr_nz (pc
));
1933 return (*this_cache
);
1936 inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1938 /* Note the interesting effects of this instruction. */
1939 frame_size
+= prologue_inst_adjust_sp (inst
);
1941 /* There are limited ways to store the return pointer into the
1943 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1946 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1948 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1951 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1953 else if (inst
== 0x0fc212c1
1954 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1957 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1960 /* Check to see if we saved SP into the stack. This also
1961 happens to indicate the location of the saved frame
1963 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1964 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1967 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1969 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1974 /* Account for general and floating-point register saves. */
1975 reg
= inst_saves_gr (inst
);
1976 if (reg
>= 3 && reg
<= 18
1977 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1979 saved_gr_mask
&= ~(1 << reg
);
1980 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1981 /* stwm with a positive displacement is a _post_
1983 cache
->saved_regs
[reg
].addr
= 0;
1984 else if ((inst
& 0xfc00000c) == 0x70000008)
1985 /* A std has explicit post_modify forms. */
1986 cache
->saved_regs
[reg
].addr
= 0;
1991 if ((inst
>> 26) == 0x1c)
1992 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1993 else if ((inst
>> 26) == 0x03)
1994 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1996 offset
= hppa_extract_14 (inst
);
1998 /* Handle code with and without frame pointers. */
2000 cache
->saved_regs
[reg
].addr
= offset
;
2002 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
2006 /* GCC handles callee saved FP regs a little differently.
2008 It emits an instruction to put the value of the start of
2009 the FP store area into %r1. It then uses fstds,ma with a
2010 basereg of %r1 for the stores.
2012 HP CC emits them at the current stack pointer modifying the
2013 stack pointer as it stores each register. */
2015 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2016 if ((inst
& 0xffffc000) == 0x34610000
2017 || (inst
& 0xffffc000) == 0x37c10000)
2018 fp_loc
= hppa_extract_14 (inst
);
2020 reg
= inst_saves_fr (inst
);
2021 if (reg
>= 12 && reg
<= 21)
2023 /* Note +4 braindamage below is necessary because the FP
2024 status registers are internally 8 registers rather than
2025 the expected 4 registers. */
2026 saved_fr_mask
&= ~(1 << reg
);
2029 /* 1st HP CC FP register store. After this
2030 instruction we've set enough state that the GCC and
2031 HPCC code are both handled in the same manner. */
2032 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
2037 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
2042 /* Quit if we hit any kind of branch the previous iteration. */
2043 if (final_iteration
)
2045 /* We want to look precisely one instruction beyond the branch
2046 if we have not found everything yet. */
2047 if (is_branch (inst
))
2048 final_iteration
= 1;
2053 /* The frame base always represents the value of %sp at entry to
2054 the current function (and is thus equivalent to the "saved"
2056 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2060 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
2061 "prologue_end=0x%s) ",
2063 paddr_nz (frame_pc_unwind (next_frame
)),
2064 paddr_nz (prologue_end
));
2066 /* Check to see if a frame pointer is available, and use it for
2067 frame unwinding if it is.
2069 There are some situations where we need to rely on the frame
2070 pointer to do stack unwinding. For example, if a function calls
2071 alloca (), the stack pointer can get adjusted inside the body of
2072 the function. In this case, the ABI requires that the compiler
2073 maintain a frame pointer for the function.
2075 The unwind record has a flag (alloca_frame) that indicates that
2076 a function has a variable frame; unfortunately, gcc/binutils
2077 does not set this flag. Instead, whenever a frame pointer is used
2078 and saved on the stack, the Save_SP flag is set. We use this to
2079 decide whether to use the frame pointer for unwinding.
2081 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2082 instead of Save_SP. */
2084 fp
= frame_unwind_register_unsigned (next_frame
, HPPA_FP_REGNUM
);
2086 if (u
->alloca_frame
)
2087 fp
-= u
->Total_frame_size
<< 3;
2089 if (frame_pc_unwind (next_frame
) >= prologue_end
2090 && (u
->Save_SP
|| u
->alloca_frame
) && fp
!= 0)
2095 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer]",
2096 paddr_nz (cache
->base
));
2099 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
2101 /* Both we're expecting the SP to be saved and the SP has been
2102 saved. The entry SP value is saved at this frame's SP
2104 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
2107 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved]",
2108 paddr_nz (cache
->base
));
2112 /* The prologue has been slowly allocating stack space. Adjust
2114 cache
->base
= this_sp
- frame_size
;
2116 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust]",
2117 paddr_nz (cache
->base
));
2120 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2123 /* The PC is found in the "return register", "Millicode" uses "r31"
2124 as the return register while normal code uses "rp". */
2127 if (trad_frame_addr_p (cache
->saved_regs
, 31))
2129 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2131 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2135 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
2136 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
2138 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2143 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2145 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2146 cache
->saved_regs
[HPPA_RP_REGNUM
];
2148 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2152 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2153 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2155 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2159 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2160 frame. However, there is a one-insn window where we haven't saved it
2161 yet, but we've already clobbered it. Detect this case and fix it up.
2163 The prologue sequence for frame-pointer functions is:
2164 0: stw %rp, -20(%sp)
2167 c: stw,ma %r1, XX(%sp)
2169 So if we are at offset c, the r3 value that we want is not yet saved
2170 on the stack, but it's been overwritten. The prologue analyzer will
2171 set fp_in_r1 when it sees the copy insn so we know to get the value
2173 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
2176 ULONGEST r1
= frame_unwind_register_unsigned (next_frame
, 1);
2177 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
2181 /* Convert all the offsets into addresses. */
2183 for (reg
= 0; reg
< NUM_REGS
; reg
++)
2185 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
2186 cache
->saved_regs
[reg
].addr
+= cache
->base
;
2191 struct gdbarch
*gdbarch
;
2192 struct gdbarch_tdep
*tdep
;
2194 gdbarch
= get_frame_arch (next_frame
);
2195 tdep
= gdbarch_tdep (gdbarch
);
2197 if (tdep
->unwind_adjust_stub
)
2199 tdep
->unwind_adjust_stub (next_frame
, cache
->base
, cache
->saved_regs
);
2204 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
2205 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
2206 return (*this_cache
);
2210 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2211 struct frame_id
*this_id
)
2213 struct hppa_frame_cache
*info
;
2214 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2215 struct unwind_table_entry
*u
;
2217 info
= hppa_frame_cache (next_frame
, this_cache
);
2218 u
= hppa_find_unwind_entry_in_block (next_frame
);
2220 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2224 hppa_frame_prev_register (struct frame_info
*next_frame
,
2226 int regnum
, int *optimizedp
,
2227 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2228 int *realnump
, gdb_byte
*valuep
)
2230 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
2231 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2232 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2235 static const struct frame_unwind hppa_frame_unwind
=
2239 hppa_frame_prev_register
2242 static const struct frame_unwind
*
2243 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
2245 if (hppa_find_unwind_entry_in_block (next_frame
))
2246 return &hppa_frame_unwind
;
2251 /* This is a generic fallback frame unwinder that kicks in if we fail all
2252 the other ones. Normally we would expect the stub and regular unwinder
2253 to work, but in some cases we might hit a function that just doesn't
2254 have any unwind information available. In this case we try to do
2255 unwinding solely based on code reading. This is obviously going to be
2256 slow, so only use this as a last resort. Currently this will only
2257 identify the stack and pc for the frame. */
2259 static struct hppa_frame_cache
*
2260 hppa_fallback_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
2262 struct hppa_frame_cache
*cache
;
2263 unsigned int frame_size
= 0;
2268 fprintf_unfiltered (gdb_stdlog
,
2269 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2270 frame_relative_level (next_frame
));
2272 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2273 (*this_cache
) = cache
;
2274 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2276 start_pc
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
2279 CORE_ADDR cur_pc
= frame_pc_unwind (next_frame
);
2282 for (pc
= start_pc
; pc
< cur_pc
; pc
+= 4)
2286 insn
= read_memory_unsigned_integer (pc
, 4);
2287 frame_size
+= prologue_inst_adjust_sp (insn
);
2289 /* There are limited ways to store the return pointer into the
2291 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2293 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2296 else if (insn
== 0x0fc212c1
2297 || insn
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2299 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2306 fprintf_unfiltered (gdb_stdlog
, " frame_size=%d, found_rp=%d }\n",
2307 frame_size
, found_rp
);
2309 cache
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2310 cache
->base
-= frame_size
;
2311 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2313 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2315 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2316 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2317 cache
->saved_regs
[HPPA_RP_REGNUM
];
2322 rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2323 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2330 hppa_fallback_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2331 struct frame_id
*this_id
)
2333 struct hppa_frame_cache
*info
=
2334 hppa_fallback_frame_cache (next_frame
, this_cache
);
2335 (*this_id
) = frame_id_build (info
->base
,
2336 frame_func_unwind (next_frame
, NORMAL_FRAME
));
2340 hppa_fallback_frame_prev_register (struct frame_info
*next_frame
,
2342 int regnum
, int *optimizedp
,
2343 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2344 int *realnump
, gdb_byte
*valuep
)
2346 struct hppa_frame_cache
*info
=
2347 hppa_fallback_frame_cache (next_frame
, this_cache
);
2348 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2349 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2352 static const struct frame_unwind hppa_fallback_frame_unwind
=
2355 hppa_fallback_frame_this_id
,
2356 hppa_fallback_frame_prev_register
2359 static const struct frame_unwind
*
2360 hppa_fallback_unwind_sniffer (struct frame_info
*next_frame
)
2362 return &hppa_fallback_frame_unwind
;
2365 /* Stub frames, used for all kinds of call stubs. */
2366 struct hppa_stub_unwind_cache
2369 struct trad_frame_saved_reg
*saved_regs
;
2372 static struct hppa_stub_unwind_cache
*
2373 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
2376 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2377 struct hppa_stub_unwind_cache
*info
;
2378 struct unwind_table_entry
*u
;
2383 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2385 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2387 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2389 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2391 /* HPUX uses export stubs in function calls; the export stub clobbers
2392 the return value of the caller, and, later restores it from the
2394 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
2396 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2398 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2404 /* By default we assume that stubs do not change the rp. */
2405 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2411 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
2412 void **this_prologue_cache
,
2413 struct frame_id
*this_id
)
2415 struct hppa_stub_unwind_cache
*info
2416 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2419 *this_id
= frame_id_build (info
->base
,
2420 frame_func_unwind (next_frame
, NORMAL_FRAME
));
2422 *this_id
= null_frame_id
;
2426 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
2427 void **this_prologue_cache
,
2428 int regnum
, int *optimizedp
,
2429 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2430 int *realnump
, gdb_byte
*valuep
)
2432 struct hppa_stub_unwind_cache
*info
2433 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2436 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2437 optimizedp
, lvalp
, addrp
, realnump
,
2440 error (_("Requesting registers from null frame."));
2443 static const struct frame_unwind hppa_stub_frame_unwind
= {
2445 hppa_stub_frame_this_id
,
2446 hppa_stub_frame_prev_register
2449 static const struct frame_unwind
*
2450 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
2452 CORE_ADDR pc
= frame_unwind_address_in_block (next_frame
, NORMAL_FRAME
);
2453 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2454 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2457 || (tdep
->in_solib_call_trampoline
!= NULL
2458 && tdep
->in_solib_call_trampoline (pc
, NULL
))
2459 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
2460 return &hppa_stub_frame_unwind
;
2464 static struct frame_id
2465 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2467 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2469 frame_pc_unwind (next_frame
));
2473 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2478 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2479 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2481 /* If the current instruction is nullified, then we are effectively
2482 still executing the previous instruction. Pretend we are still
2483 there. This is needed when single stepping; if the nullified
2484 instruction is on a different line, we don't want GDB to think
2485 we've stepped onto that line. */
2486 if (ipsw
& 0x00200000)
2492 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2493 Return NULL if no such symbol was found. */
2495 struct minimal_symbol
*
2496 hppa_lookup_stub_minimal_symbol (const char *name
,
2497 enum unwind_stub_types stub_type
)
2499 struct objfile
*objfile
;
2500 struct minimal_symbol
*msym
;
2502 ALL_MSYMBOLS (objfile
, msym
)
2504 if (strcmp (SYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2506 struct unwind_table_entry
*u
;
2508 u
= find_unwind_entry (SYMBOL_VALUE (msym
));
2509 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2518 unwind_command (char *exp
, int from_tty
)
2521 struct unwind_table_entry
*u
;
2523 /* If we have an expression, evaluate it and use it as the address. */
2525 if (exp
!= 0 && *exp
!= 0)
2526 address
= parse_and_eval_address (exp
);
2530 u
= find_unwind_entry (address
);
2534 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2538 printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u
);
2540 printf_unfiltered ("\tregion_start = ");
2541 print_address (u
->region_start
, gdb_stdout
);
2542 gdb_flush (gdb_stdout
);
2544 printf_unfiltered ("\n\tregion_end = ");
2545 print_address (u
->region_end
, gdb_stdout
);
2546 gdb_flush (gdb_stdout
);
2548 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2550 printf_unfiltered ("\n\tflags =");
2551 pif (Cannot_unwind
);
2553 pif (Millicode_save_sr0
);
2556 pif (Variable_Frame
);
2557 pif (Separate_Package_Body
);
2558 pif (Frame_Extension_Millicode
);
2559 pif (Stack_Overflow_Check
);
2560 pif (Two_Instruction_SP_Increment
);
2563 pif (cxx_try_catch
);
2564 pif (sched_entry_seq
);
2567 pif (Save_MRP_in_frame
);
2569 pif (Cleanup_defined
);
2570 pif (MPE_XL_interrupt_marker
);
2571 pif (HP_UX_interrupt_marker
);
2575 putchar_unfiltered ('\n');
2577 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2579 pin (Region_description
);
2582 pin (Total_frame_size
);
2584 if (u
->stub_unwind
.stub_type
)
2586 printf_unfiltered ("\tstub type = ");
2587 switch (u
->stub_unwind
.stub_type
)
2590 printf_unfiltered ("long branch\n");
2592 case PARAMETER_RELOCATION
:
2593 printf_unfiltered ("parameter relocation\n");
2596 printf_unfiltered ("export\n");
2599 printf_unfiltered ("import\n");
2602 printf_unfiltered ("import shlib\n");
2605 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2611 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2613 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2615 An example of this occurs when an a.out is linked against a foo.sl.
2616 The foo.sl defines a global bar(), and the a.out declares a signature
2617 for bar(). However, the a.out doesn't directly call bar(), but passes
2618 its address in another call.
2620 If you have this scenario and attempt to "break bar" before running,
2621 gdb will find a minimal symbol for bar() in the a.out. But that
2622 symbol's address will be negative. What this appears to denote is
2623 an index backwards from the base of the procedure linkage table (PLT)
2624 into the data linkage table (DLT), the end of which is contiguous
2625 with the start of the PLT. This is clearly not a valid address for
2626 us to set a breakpoint on.
2628 Note that one must be careful in how one checks for a negative address.
2629 0xc0000000 is a legitimate address of something in a shared text
2630 segment, for example. Since I don't know what the possible range
2631 is of these "really, truly negative" addresses that come from the
2632 minimal symbols, I'm resorting to the gross hack of checking the
2633 top byte of the address for all 1's. Sigh. */
2635 return (!target_has_stack
&& (pc
& 0xFF000000) == 0xFF000000);
2638 /* Return the GDB type object for the "standard" data type of data in
2641 static struct type
*
2642 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2644 if (regnum
< HPPA_FP4_REGNUM
)
2645 return builtin_type_uint32
;
2647 return builtin_type_ieee_single
;
2650 static struct type
*
2651 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2653 if (regnum
< HPPA64_FP4_REGNUM
)
2654 return builtin_type_uint64
;
2656 return builtin_type_ieee_double
;
2659 /* Return non-zero if REGNUM is not a register available to the user
2660 through ptrace/ttrace. */
2663 hppa32_cannot_store_register (int regnum
)
2666 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2667 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2668 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2672 hppa64_cannot_store_register (int regnum
)
2675 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2676 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2677 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2681 hppa_smash_text_address (CORE_ADDR addr
)
2683 /* The low two bits of the PC on the PA contain the privilege level.
2684 Some genius implementing a (non-GCC) compiler apparently decided
2685 this means that "addresses" in a text section therefore include a
2686 privilege level, and thus symbol tables should contain these bits.
2687 This seems like a bonehead thing to do--anyway, it seems to work
2688 for our purposes to just ignore those bits. */
2690 return (addr
&= ~0x3);
2693 /* Get the ARGIth function argument for the current function. */
2696 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2699 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2703 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2704 int regnum
, gdb_byte
*buf
)
2708 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2709 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2711 store_unsigned_integer (buf
, sizeof tmp
, tmp
);
2715 hppa_find_global_pointer (struct value
*function
)
2721 hppa_frame_prev_register_helper (struct frame_info
*next_frame
,
2722 struct trad_frame_saved_reg saved_regs
[],
2723 int regnum
, int *optimizedp
,
2724 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2725 int *realnump
, gdb_byte
*valuep
)
2727 struct gdbarch
*arch
= get_frame_arch (next_frame
);
2729 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2733 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2736 trad_frame_get_prev_register (next_frame
, saved_regs
,
2737 HPPA_PCOQ_HEAD_REGNUM
, optimizedp
,
2738 lvalp
, addrp
, realnump
, valuep
);
2740 pc
= extract_unsigned_integer (valuep
, size
);
2741 store_unsigned_integer (valuep
, size
, pc
+ 4);
2744 /* It's a computed value. */
2752 /* Make sure the "flags" register is zero in all unwound frames.
2753 The "flags" registers is a HP-UX specific wart, and only the code
2754 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2755 with it here. This shouldn't affect other systems since those
2756 should provide zero for the "flags" register anyway. */
2757 if (regnum
== HPPA_FLAGS_REGNUM
)
2760 store_unsigned_integer (valuep
, register_size (arch
, regnum
), 0);
2762 /* It's a computed value. */
2770 trad_frame_get_prev_register (next_frame
, saved_regs
, regnum
,
2771 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2775 /* An instruction to match. */
2778 unsigned int data
; /* See if it matches this.... */
2779 unsigned int mask
; /* ... with this mask. */
2782 /* See bfd/elf32-hppa.c */
2783 static struct insn_pattern hppa_long_branch_stub
[] = {
2784 /* ldil LR'xxx,%r1 */
2785 { 0x20200000, 0xffe00000 },
2786 /* be,n RR'xxx(%sr4,%r1) */
2787 { 0xe0202002, 0xffe02002 },
2791 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
2793 { 0xe8200000, 0xffe00000 },
2794 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2795 { 0x28200000, 0xffe00000 },
2796 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2797 { 0xe0202002, 0xffe02002 },
2801 static struct insn_pattern hppa_import_stub
[] = {
2802 /* addil LR'xxx, %dp */
2803 { 0x2b600000, 0xffe00000 },
2804 /* ldw RR'xxx(%r1), %r21 */
2805 { 0x48350000, 0xffffb000 },
2807 { 0xeaa0c000, 0xffffffff },
2808 /* ldw RR'xxx+4(%r1), %r19 */
2809 { 0x48330000, 0xffffb000 },
2813 static struct insn_pattern hppa_import_pic_stub
[] = {
2814 /* addil LR'xxx,%r19 */
2815 { 0x2a600000, 0xffe00000 },
2816 /* ldw RR'xxx(%r1),%r21 */
2817 { 0x48350000, 0xffffb000 },
2819 { 0xeaa0c000, 0xffffffff },
2820 /* ldw RR'xxx+4(%r1),%r19 */
2821 { 0x48330000, 0xffffb000 },
2825 static struct insn_pattern hppa_plt_stub
[] = {
2826 /* b,l 1b, %r20 - 1b is 3 insns before here */
2827 { 0xea9f1fdd, 0xffffffff },
2828 /* depi 0,31,2,%r20 */
2829 { 0xd6801c1e, 0xffffffff },
2833 static struct insn_pattern hppa_sigtramp
[] = {
2834 /* ldi 0, %r25 or ldi 1, %r25 */
2835 { 0x34190000, 0xfffffffd },
2836 /* ldi __NR_rt_sigreturn, %r20 */
2837 { 0x3414015a, 0xffffffff },
2838 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
2839 { 0xe4008200, 0xffffffff },
2841 { 0x08000240, 0xffffffff },
2845 /* Maximum number of instructions on the patterns above. */
2846 #define HPPA_MAX_INSN_PATTERN_LEN 4
2848 /* Return non-zero if the instructions at PC match the series
2849 described in PATTERN, or zero otherwise. PATTERN is an array of
2850 'struct insn_pattern' objects, terminated by an entry whose mask is
2853 When the match is successful, fill INSN[i] with what PATTERN[i]
2857 hppa_match_insns (CORE_ADDR pc
, struct insn_pattern
*pattern
,
2863 for (i
= 0; pattern
[i
].mask
; i
++)
2865 gdb_byte buf
[HPPA_INSN_SIZE
];
2867 read_memory_nobpt (npc
, buf
, HPPA_INSN_SIZE
);
2868 insn
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
);
2869 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
2878 /* This relaxed version of the insstruction matcher allows us to match
2879 from somewhere inside the pattern, by looking backwards in the
2880 instruction scheme. */
2883 hppa_match_insns_relaxed (CORE_ADDR pc
, struct insn_pattern
*pattern
,
2886 int offset
, len
= 0;
2888 while (pattern
[len
].mask
)
2891 for (offset
= 0; offset
< len
; offset
++)
2892 if (hppa_match_insns (pc
- offset
* HPPA_INSN_SIZE
, pattern
, insn
))
2899 hppa_in_dyncall (CORE_ADDR pc
)
2901 struct unwind_table_entry
*u
;
2903 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2907 return (pc
>= u
->region_start
&& pc
<= u
->region_end
);
2911 hppa_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
2913 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2914 struct unwind_table_entry
*u
;
2916 if (in_plt_section (pc
, name
) || hppa_in_dyncall (pc
))
2919 /* The GNU toolchain produces linker stubs without unwind
2920 information. Since the pattern matching for linker stubs can be
2921 quite slow, so bail out if we do have an unwind entry. */
2923 u
= find_unwind_entry (pc
);
2927 return (hppa_match_insns_relaxed (pc
, hppa_import_stub
, insn
)
2928 || hppa_match_insns_relaxed (pc
, hppa_import_pic_stub
, insn
)
2929 || hppa_match_insns_relaxed (pc
, hppa_long_branch_stub
, insn
)
2930 || hppa_match_insns_relaxed (pc
, hppa_long_branch_pic_stub
, insn
));
2933 /* This code skips several kind of "trampolines" used on PA-RISC
2934 systems: $$dyncall, import stubs and PLT stubs. */
2937 hppa_skip_trampoline_code (CORE_ADDR pc
)
2939 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2942 /* $$dyncall handles both PLABELs and direct addresses. */
2943 if (hppa_in_dyncall (pc
))
2945 pc
= read_register (HPPA_R0_REGNUM
+ 22);
2947 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2949 pc
= read_memory_typed_address (pc
& ~0x3, builtin_type_void_func_ptr
);
2954 dp_rel
= hppa_match_insns (pc
, hppa_import_stub
, insn
);
2955 if (dp_rel
|| hppa_match_insns (pc
, hppa_import_pic_stub
, insn
))
2957 /* Extract the target address from the addil/ldw sequence. */
2958 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
2961 pc
+= read_register (HPPA_DP_REGNUM
);
2963 pc
+= read_register (HPPA_R0_REGNUM
+ 19);
2968 if (in_plt_section (pc
, NULL
))
2970 pc
= read_memory_typed_address (pc
, builtin_type_void_func_ptr
);
2972 /* If the PLT slot has not yet been resolved, the target will be
2974 if (in_plt_section (pc
, NULL
))
2976 /* Sanity check: are we pointing to the PLT stub? */
2977 if (!hppa_match_insns (pc
, hppa_plt_stub
, insn
))
2979 warning (_("Cannot resolve PLT stub at 0x%s."), paddr_nz (pc
));
2983 /* This should point to the fixup routine. */
2984 pc
= read_memory_typed_address (pc
+ 8, builtin_type_void_func_ptr
);
2992 /* Here is a table of C type sizes on hppa with various compiles
2993 and options. I measured this on PA 9000/800 with HP-UX 11.11
2994 and these compilers:
2996 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2997 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2998 /opt/aCC/bin/aCC B3910B A.03.45
2999 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3001 cc : 1 2 4 4 8 : 4 8 -- : 4 4
3002 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3003 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3004 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3005 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3006 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3007 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3008 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3012 compiler and options
3013 char, short, int, long, long long
3014 float, double, long double
3017 So all these compilers use either ILP32 or LP64 model.
3018 TODO: gcc has more options so it needs more investigation.
3020 For floating point types, see:
3022 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3023 HP-UX floating-point guide, hpux 11.00
3025 -- chastain 2003-12-18 */
3027 static struct gdbarch
*
3028 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3030 struct gdbarch_tdep
*tdep
;
3031 struct gdbarch
*gdbarch
;
3033 /* Try to determine the ABI of the object we are loading. */
3034 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
3036 /* If it's a SOM file, assume it's HP/UX SOM. */
3037 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
3038 info
.osabi
= GDB_OSABI_HPUX_SOM
;
3041 /* find a candidate among the list of pre-declared architectures. */
3042 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3044 return (arches
->gdbarch
);
3046 /* If none found, then allocate and initialize one. */
3047 tdep
= XZALLOC (struct gdbarch_tdep
);
3048 gdbarch
= gdbarch_alloc (&info
, tdep
);
3050 /* Determine from the bfd_arch_info structure if we are dealing with
3051 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3052 then default to a 32bit machine. */
3053 if (info
.bfd_arch_info
!= NULL
)
3054 tdep
->bytes_per_address
=
3055 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3057 tdep
->bytes_per_address
= 4;
3059 tdep
->find_global_pointer
= hppa_find_global_pointer
;
3061 /* Some parts of the gdbarch vector depend on whether we are running
3062 on a 32 bits or 64 bits target. */
3063 switch (tdep
->bytes_per_address
)
3066 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3067 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3068 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3069 set_gdbarch_cannot_store_register (gdbarch
,
3070 hppa32_cannot_store_register
);
3071 set_gdbarch_cannot_fetch_register (gdbarch
,
3072 hppa32_cannot_store_register
);
3075 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3076 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3077 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3078 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3079 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3080 set_gdbarch_cannot_store_register (gdbarch
,
3081 hppa64_cannot_store_register
);
3082 set_gdbarch_cannot_fetch_register (gdbarch
,
3083 hppa64_cannot_store_register
);
3086 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
3087 tdep
->bytes_per_address
);
3090 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3091 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3093 /* The following gdbarch vector elements are the same in both ILP32
3094 and LP64, but might show differences some day. */
3095 set_gdbarch_long_long_bit (gdbarch
, 64);
3096 set_gdbarch_long_double_bit (gdbarch
, 128);
3097 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3099 /* The following gdbarch vector elements do not depend on the address
3100 size, or in any other gdbarch element previously set. */
3101 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3102 set_gdbarch_in_function_epilogue_p (gdbarch
,
3103 hppa_in_function_epilogue_p
);
3104 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
3105 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3106 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3107 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
3108 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
3109 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3110 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
3111 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
3113 /* Helper for function argument information. */
3114 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3116 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
3118 /* When a hardware watchpoint triggers, we'll move the inferior past
3119 it by removing all eventpoints; stepping past the instruction
3120 that caused the trigger; reinserting eventpoints; and checking
3121 whether any watched location changed. */
3122 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3124 /* Inferior function call methods. */
3125 switch (tdep
->bytes_per_address
)
3128 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3129 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3130 set_gdbarch_convert_from_func_ptr_addr
3131 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
3134 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3135 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3138 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3141 /* Struct return methods. */
3142 switch (tdep
->bytes_per_address
)
3145 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3148 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3151 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3154 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
3155 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
3157 /* Frame unwind methods. */
3158 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
3159 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3161 /* Hook in ABI-specific overrides, if they have been registered. */
3162 gdbarch_init_osabi (info
, gdbarch
);
3164 /* Hook in the default unwinders. */
3165 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
3166 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
3167 frame_unwind_append_sniffer (gdbarch
, hppa_fallback_unwind_sniffer
);
3173 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
3175 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
3177 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
3178 tdep
->bytes_per_address
);
3179 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
3183 _initialize_hppa_tdep (void)
3185 struct cmd_list_element
*c
;
3187 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3189 hppa_objfile_priv_data
= register_objfile_data ();
3191 add_cmd ("unwind", class_maintenance
, unwind_command
,
3192 _("Print unwind table entry at given address."),
3193 &maintenanceprintlist
);
3195 /* Debug this files internals. */
3196 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
3197 Set whether hppa target specific debugging information should be displayed."),
3199 Show whether hppa target specific debugging information is displayed."), _("\
3200 This flag controls whether hppa target specific debugging information is\n\
3201 displayed. This information is particularly useful for debugging frame\n\
3202 unwinding problems."),
3204 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
3205 &setdebuglist
, &showdebuglist
);