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, 2008, 2009
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 3 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, see <http://www.gnu.org/licenses/>. */
29 #include "completer.h"
31 #include "gdb_assert.h"
32 #include "arch-utils.h"
33 /* For argument passing to the inferior */
36 #include "trad-frame.h"
37 #include "frame-unwind.h"
38 #include "frame-base.h"
44 #include "hppa-tdep.h"
46 static int hppa_debug
= 0;
48 /* Some local constants. */
49 static const int hppa32_num_regs
= 128;
50 static const int hppa64_num_regs
= 96;
52 /* hppa-specific object data -- unwind and solib info.
53 TODO/maybe: think about splitting this into two parts; the unwind data is
54 common to all hppa targets, but is only used in this file; we can register
55 that separately and make this static. The solib data is probably hpux-
56 specific, so we can create a separate extern objfile_data that is registered
57 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
58 const struct objfile_data
*hppa_objfile_priv_data
= NULL
;
60 /* Get at various relevent fields of an instruction word. */
63 #define MASK_14 0x3fff
64 #define MASK_21 0x1fffff
66 /* Sizes (in bytes) of the native unwind entries. */
67 #define UNWIND_ENTRY_SIZE 16
68 #define STUB_UNWIND_ENTRY_SIZE 8
70 /* Routines to extract various sized constants out of hppa
73 /* This assumes that no garbage lies outside of the lower bits of
77 hppa_sign_extend (unsigned val
, unsigned bits
)
79 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
82 /* For many immediate values the sign bit is the low bit! */
85 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
87 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
90 /* Extract the bits at positions between FROM and TO, using HP's numbering
94 hppa_get_field (unsigned word
, int from
, int to
)
96 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
99 /* extract the immediate field from a ld{bhw}s instruction */
102 hppa_extract_5_load (unsigned word
)
104 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
107 /* extract the immediate field from a break instruction */
110 hppa_extract_5r_store (unsigned word
)
112 return (word
& MASK_5
);
115 /* extract the immediate field from a {sr}sm instruction */
118 hppa_extract_5R_store (unsigned word
)
120 return (word
>> 16 & MASK_5
);
123 /* extract a 14 bit immediate field */
126 hppa_extract_14 (unsigned word
)
128 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
131 /* extract a 21 bit constant */
134 hppa_extract_21 (unsigned word
)
140 val
= hppa_get_field (word
, 20, 20);
142 val
|= hppa_get_field (word
, 9, 19);
144 val
|= hppa_get_field (word
, 5, 6);
146 val
|= hppa_get_field (word
, 0, 4);
148 val
|= hppa_get_field (word
, 7, 8);
149 return hppa_sign_extend (val
, 21) << 11;
152 /* extract a 17 bit constant from branch instructions, returning the
153 19 bit signed value. */
156 hppa_extract_17 (unsigned word
)
158 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
159 hppa_get_field (word
, 29, 29) << 10 |
160 hppa_get_field (word
, 11, 15) << 11 |
161 (word
& 0x1) << 16, 17) << 2;
165 hppa_symbol_address(const char *sym
)
167 struct minimal_symbol
*minsym
;
169 minsym
= lookup_minimal_symbol (sym
, NULL
, NULL
);
171 return SYMBOL_VALUE_ADDRESS (minsym
);
173 return (CORE_ADDR
)-1;
176 struct hppa_objfile_private
*
177 hppa_init_objfile_priv_data (struct objfile
*objfile
)
179 struct hppa_objfile_private
*priv
;
181 priv
= (struct hppa_objfile_private
*)
182 obstack_alloc (&objfile
->objfile_obstack
,
183 sizeof (struct hppa_objfile_private
));
184 set_objfile_data (objfile
, hppa_objfile_priv_data
, priv
);
185 memset (priv
, 0, sizeof (*priv
));
191 /* Compare the start address for two unwind entries returning 1 if
192 the first address is larger than the second, -1 if the second is
193 larger than the first, and zero if they are equal. */
196 compare_unwind_entries (const void *arg1
, const void *arg2
)
198 const struct unwind_table_entry
*a
= arg1
;
199 const struct unwind_table_entry
*b
= arg2
;
201 if (a
->region_start
> b
->region_start
)
203 else if (a
->region_start
< b
->region_start
)
210 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
212 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
213 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
215 bfd_vma value
= section
->vma
- section
->filepos
;
216 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
218 if (value
< *low_text_segment_address
)
219 *low_text_segment_address
= value
;
224 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
225 asection
*section
, unsigned int entries
, unsigned int size
,
226 CORE_ADDR text_offset
)
228 /* We will read the unwind entries into temporary memory, then
229 fill in the actual unwind table. */
233 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
236 char *buf
= alloca (size
);
237 CORE_ADDR low_text_segment_address
;
239 /* For ELF targets, then unwinds are supposed to
240 be segment relative offsets instead of absolute addresses.
242 Note that when loading a shared library (text_offset != 0) the
243 unwinds are already relative to the text_offset that will be
245 if (gdbarch_tdep (gdbarch
)->is_elf
&& text_offset
== 0)
247 low_text_segment_address
= -1;
249 bfd_map_over_sections (objfile
->obfd
,
250 record_text_segment_lowaddr
,
251 &low_text_segment_address
);
253 text_offset
= low_text_segment_address
;
255 else if (gdbarch_tdep (gdbarch
)->solib_get_text_base
)
257 text_offset
= gdbarch_tdep (gdbarch
)->solib_get_text_base (objfile
);
260 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
262 /* Now internalize the information being careful to handle host/target
264 for (i
= 0; i
< entries
; i
++)
266 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
268 table
[i
].region_start
+= text_offset
;
270 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
271 table
[i
].region_end
+= text_offset
;
273 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
275 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
276 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
277 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
278 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
279 table
[i
].reserved
= (tmp
>> 26) & 0x1;
280 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
281 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
282 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
283 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
284 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
285 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
286 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
287 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
288 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
289 table
[i
].sr4export
= (tmp
>> 9) & 0x1;
290 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
291 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
292 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
293 table
[i
].reserved1
= (tmp
>> 5) & 0x1;
294 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
295 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
296 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
297 table
[i
].save_r19
= (tmp
>> 1) & 0x1;
298 table
[i
].Cleanup_defined
= tmp
& 0x1;
299 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
301 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
302 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
303 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
304 table
[i
].alloca_frame
= (tmp
>> 28) & 0x1;
305 table
[i
].reserved2
= (tmp
>> 27) & 0x1;
306 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
308 /* Stub unwinds are handled elsewhere. */
309 table
[i
].stub_unwind
.stub_type
= 0;
310 table
[i
].stub_unwind
.padding
= 0;
315 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
316 the object file. This info is used mainly by find_unwind_entry() to find
317 out the stack frame size and frame pointer used by procedures. We put
318 everything on the psymbol obstack in the objfile so that it automatically
319 gets freed when the objfile is destroyed. */
322 read_unwind_info (struct objfile
*objfile
)
324 asection
*unwind_sec
, *stub_unwind_sec
;
325 unsigned unwind_size
, stub_unwind_size
, total_size
;
326 unsigned index
, unwind_entries
;
327 unsigned stub_entries
, total_entries
;
328 CORE_ADDR text_offset
;
329 struct hppa_unwind_info
*ui
;
330 struct hppa_objfile_private
*obj_private
;
332 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
333 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
334 sizeof (struct hppa_unwind_info
));
340 /* For reasons unknown the HP PA64 tools generate multiple unwinder
341 sections in a single executable. So we just iterate over every
342 section in the BFD looking for unwinder sections intead of trying
343 to do a lookup with bfd_get_section_by_name.
345 First determine the total size of the unwind tables so that we
346 can allocate memory in a nice big hunk. */
348 for (unwind_sec
= objfile
->obfd
->sections
;
350 unwind_sec
= unwind_sec
->next
)
352 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
353 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
355 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
356 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
358 total_entries
+= unwind_entries
;
362 /* Now compute the size of the stub unwinds. Note the ELF tools do not
363 use stub unwinds at the current time. */
364 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
368 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
369 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
373 stub_unwind_size
= 0;
377 /* Compute total number of unwind entries and their total size. */
378 total_entries
+= stub_entries
;
379 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
381 /* Allocate memory for the unwind table. */
382 ui
->table
= (struct unwind_table_entry
*)
383 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
384 ui
->last
= total_entries
- 1;
386 /* Now read in each unwind section and internalize the standard unwind
389 for (unwind_sec
= objfile
->obfd
->sections
;
391 unwind_sec
= unwind_sec
->next
)
393 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
394 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
396 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
397 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
399 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
400 unwind_entries
, unwind_size
, text_offset
);
401 index
+= unwind_entries
;
405 /* Now read in and internalize the stub unwind entries. */
406 if (stub_unwind_size
> 0)
409 char *buf
= alloca (stub_unwind_size
);
411 /* Read in the stub unwind entries. */
412 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
413 0, stub_unwind_size
);
415 /* Now convert them into regular unwind entries. */
416 for (i
= 0; i
< stub_entries
; i
++, index
++)
418 /* Clear out the next unwind entry. */
419 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
421 /* Convert offset & size into region_start and region_end.
422 Stuff away the stub type into "reserved" fields. */
423 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
425 ui
->table
[index
].region_start
+= text_offset
;
427 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
430 ui
->table
[index
].region_end
431 = ui
->table
[index
].region_start
+ 4 *
432 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
438 /* Unwind table needs to be kept sorted. */
439 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
440 compare_unwind_entries
);
442 /* Keep a pointer to the unwind information. */
443 obj_private
= (struct hppa_objfile_private
*)
444 objfile_data (objfile
, hppa_objfile_priv_data
);
445 if (obj_private
== NULL
)
446 obj_private
= hppa_init_objfile_priv_data (objfile
);
448 obj_private
->unwind_info
= ui
;
451 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
452 of the objfiles seeking the unwind table entry for this PC. Each objfile
453 contains a sorted list of struct unwind_table_entry. Since we do a binary
454 search of the unwind tables, we depend upon them to be sorted. */
456 struct unwind_table_entry
*
457 find_unwind_entry (CORE_ADDR pc
)
459 int first
, middle
, last
;
460 struct objfile
*objfile
;
461 struct hppa_objfile_private
*priv
;
464 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry %s -> ",
467 /* A function at address 0? Not in HP-UX! */
468 if (pc
== (CORE_ADDR
) 0)
471 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
475 ALL_OBJFILES (objfile
)
477 struct hppa_unwind_info
*ui
;
479 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
481 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
485 read_unwind_info (objfile
);
486 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
488 error (_("Internal error reading unwind information."));
489 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
492 /* First, check the cache */
495 && pc
>= ui
->cache
->region_start
496 && pc
<= ui
->cache
->region_end
)
499 fprintf_unfiltered (gdb_stdlog
, "%s (cached) }\n",
500 hex_string ((uintptr_t) ui
->cache
));
504 /* Not in the cache, do a binary search */
509 while (first
<= last
)
511 middle
= (first
+ last
) / 2;
512 if (pc
>= ui
->table
[middle
].region_start
513 && pc
<= ui
->table
[middle
].region_end
)
515 ui
->cache
= &ui
->table
[middle
];
517 fprintf_unfiltered (gdb_stdlog
, "%s }\n",
518 hex_string ((uintptr_t) ui
->cache
));
519 return &ui
->table
[middle
];
522 if (pc
< ui
->table
[middle
].region_start
)
527 } /* ALL_OBJFILES() */
530 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
535 /* The epilogue is defined here as the area either on the `bv' instruction
536 itself or an instruction which destroys the function's stack frame.
538 We do not assume that the epilogue is at the end of a function as we can
539 also have return sequences in the middle of a function. */
541 hppa_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
543 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
544 unsigned long status
;
549 status
= target_read_memory (pc
, buf
, 4);
553 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
555 /* The most common way to perform a stack adjustment ldo X(sp),sp
556 We are destroying a stack frame if the offset is negative. */
557 if ((inst
& 0xffffc000) == 0x37de0000
558 && hppa_extract_14 (inst
) < 0)
561 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
562 if (((inst
& 0x0fc010e0) == 0x0fc010e0
563 || (inst
& 0x0fc010e0) == 0x0fc010e0)
564 && hppa_extract_14 (inst
) < 0)
567 /* bv %r0(%rp) or bv,n %r0(%rp) */
568 if (inst
== 0xe840c000 || inst
== 0xe840c002)
574 static const unsigned char *
575 hppa_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
, int *len
)
577 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
578 (*len
) = sizeof (breakpoint
);
582 /* Return the name of a register. */
585 hppa32_register_name (struct gdbarch
*gdbarch
, int i
)
587 static char *names
[] = {
588 "flags", "r1", "rp", "r3",
589 "r4", "r5", "r6", "r7",
590 "r8", "r9", "r10", "r11",
591 "r12", "r13", "r14", "r15",
592 "r16", "r17", "r18", "r19",
593 "r20", "r21", "r22", "r23",
594 "r24", "r25", "r26", "dp",
595 "ret0", "ret1", "sp", "r31",
596 "sar", "pcoqh", "pcsqh", "pcoqt",
597 "pcsqt", "eiem", "iir", "isr",
598 "ior", "ipsw", "goto", "sr4",
599 "sr0", "sr1", "sr2", "sr3",
600 "sr5", "sr6", "sr7", "cr0",
601 "cr8", "cr9", "ccr", "cr12",
602 "cr13", "cr24", "cr25", "cr26",
603 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
604 "fpsr", "fpe1", "fpe2", "fpe3",
605 "fpe4", "fpe5", "fpe6", "fpe7",
606 "fr4", "fr4R", "fr5", "fr5R",
607 "fr6", "fr6R", "fr7", "fr7R",
608 "fr8", "fr8R", "fr9", "fr9R",
609 "fr10", "fr10R", "fr11", "fr11R",
610 "fr12", "fr12R", "fr13", "fr13R",
611 "fr14", "fr14R", "fr15", "fr15R",
612 "fr16", "fr16R", "fr17", "fr17R",
613 "fr18", "fr18R", "fr19", "fr19R",
614 "fr20", "fr20R", "fr21", "fr21R",
615 "fr22", "fr22R", "fr23", "fr23R",
616 "fr24", "fr24R", "fr25", "fr25R",
617 "fr26", "fr26R", "fr27", "fr27R",
618 "fr28", "fr28R", "fr29", "fr29R",
619 "fr30", "fr30R", "fr31", "fr31R"
621 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
628 hppa64_register_name (struct gdbarch
*gdbarch
, int i
)
630 static char *names
[] = {
631 "flags", "r1", "rp", "r3",
632 "r4", "r5", "r6", "r7",
633 "r8", "r9", "r10", "r11",
634 "r12", "r13", "r14", "r15",
635 "r16", "r17", "r18", "r19",
636 "r20", "r21", "r22", "r23",
637 "r24", "r25", "r26", "dp",
638 "ret0", "ret1", "sp", "r31",
639 "sar", "pcoqh", "pcsqh", "pcoqt",
640 "pcsqt", "eiem", "iir", "isr",
641 "ior", "ipsw", "goto", "sr4",
642 "sr0", "sr1", "sr2", "sr3",
643 "sr5", "sr6", "sr7", "cr0",
644 "cr8", "cr9", "ccr", "cr12",
645 "cr13", "cr24", "cr25", "cr26",
646 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
647 "fpsr", "fpe1", "fpe2", "fpe3",
648 "fr4", "fr5", "fr6", "fr7",
649 "fr8", "fr9", "fr10", "fr11",
650 "fr12", "fr13", "fr14", "fr15",
651 "fr16", "fr17", "fr18", "fr19",
652 "fr20", "fr21", "fr22", "fr23",
653 "fr24", "fr25", "fr26", "fr27",
654 "fr28", "fr29", "fr30", "fr31"
656 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
662 /* Map dwarf DBX register numbers to GDB register numbers. */
664 hppa64_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
666 /* The general registers and the sar are the same in both sets. */
670 /* fr4-fr31 are mapped from 72 in steps of 2. */
671 if (reg
>= 72 && reg
< 72 + 28 * 2 && !(reg
& 1))
672 return HPPA64_FP4_REGNUM
+ (reg
- 72) / 2;
674 warning (_("Unmapped DWARF DBX Register #%d encountered."), reg
);
678 /* This function pushes a stack frame with arguments as part of the
679 inferior function calling mechanism.
681 This is the version of the function for the 32-bit PA machines, in
682 which later arguments appear at lower addresses. (The stack always
683 grows towards higher addresses.)
685 We simply allocate the appropriate amount of stack space and put
686 arguments into their proper slots. */
689 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
690 struct regcache
*regcache
, CORE_ADDR bp_addr
,
691 int nargs
, struct value
**args
, CORE_ADDR sp
,
692 int struct_return
, CORE_ADDR struct_addr
)
694 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
696 /* Stack base address at which any pass-by-reference parameters are
698 CORE_ADDR struct_end
= 0;
699 /* Stack base address at which the first parameter is stored. */
700 CORE_ADDR param_end
= 0;
702 /* The inner most end of the stack after all the parameters have
704 CORE_ADDR new_sp
= 0;
706 /* Two passes. First pass computes the location of everything,
707 second pass writes the bytes out. */
710 /* Global pointer (r19) of the function we are trying to call. */
713 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
715 for (write_pass
= 0; write_pass
< 2; write_pass
++)
717 CORE_ADDR struct_ptr
= 0;
718 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
719 struct_ptr is adjusted for each argument below, so the first
720 argument will end up at sp-36. */
721 CORE_ADDR param_ptr
= 32;
723 int small_struct
= 0;
725 for (i
= 0; i
< nargs
; i
++)
727 struct value
*arg
= args
[i
];
728 struct type
*type
= check_typedef (value_type (arg
));
729 /* The corresponding parameter that is pushed onto the
730 stack, and [possibly] passed in a register. */
733 memset (param_val
, 0, sizeof param_val
);
734 if (TYPE_LENGTH (type
) > 8)
736 /* Large parameter, pass by reference. Store the value
737 in "struct" area and then pass its address. */
739 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
741 write_memory (struct_end
- struct_ptr
, value_contents (arg
),
743 store_unsigned_integer (param_val
, 4, byte_order
,
744 struct_end
- struct_ptr
);
746 else if (TYPE_CODE (type
) == TYPE_CODE_INT
747 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
749 /* Integer value store, right aligned. "unpack_long"
750 takes care of any sign-extension problems. */
751 param_len
= align_up (TYPE_LENGTH (type
), 4);
752 store_unsigned_integer (param_val
, param_len
, byte_order
,
754 value_contents (arg
)));
756 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
758 /* Floating point value store, right aligned. */
759 param_len
= align_up (TYPE_LENGTH (type
), 4);
760 memcpy (param_val
, value_contents (arg
), param_len
);
764 param_len
= align_up (TYPE_LENGTH (type
), 4);
766 /* Small struct value are stored right-aligned. */
767 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
768 value_contents (arg
), TYPE_LENGTH (type
));
770 /* Structures of size 5, 6 and 7 bytes are special in that
771 the higher-ordered word is stored in the lower-ordered
772 argument, and even though it is a 8-byte quantity the
773 registers need not be 8-byte aligned. */
774 if (param_len
> 4 && param_len
< 8)
778 param_ptr
+= param_len
;
779 if (param_len
== 8 && !small_struct
)
780 param_ptr
= align_up (param_ptr
, 8);
782 /* First 4 non-FP arguments are passed in gr26-gr23.
783 First 4 32-bit FP arguments are passed in fr4L-fr7L.
784 First 2 64-bit FP arguments are passed in fr5 and fr7.
786 The rest go on the stack, starting at sp-36, towards lower
787 addresses. 8-byte arguments must be aligned to a 8-byte
791 write_memory (param_end
- param_ptr
, param_val
, param_len
);
793 /* There are some cases when we don't know the type
794 expected by the callee (e.g. for variadic functions), so
795 pass the parameters in both general and fp regs. */
798 int grreg
= 26 - (param_ptr
- 36) / 4;
799 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
800 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
802 regcache_cooked_write (regcache
, grreg
, param_val
);
803 regcache_cooked_write (regcache
, fpLreg
, param_val
);
807 regcache_cooked_write (regcache
, grreg
+ 1,
810 regcache_cooked_write (regcache
, fpreg
, param_val
);
811 regcache_cooked_write (regcache
, fpreg
+ 1,
818 /* Update the various stack pointers. */
821 struct_end
= sp
+ align_up (struct_ptr
, 64);
822 /* PARAM_PTR already accounts for all the arguments passed
823 by the user. However, the ABI mandates minimum stack
824 space allocations for outgoing arguments. The ABI also
825 mandates minimum stack alignments which we must
827 param_end
= struct_end
+ align_up (param_ptr
, 64);
831 /* If a structure has to be returned, set up register 28 to hold its
834 regcache_cooked_write_unsigned (regcache
, 28, struct_addr
);
836 gp
= tdep
->find_global_pointer (gdbarch
, function
);
839 regcache_cooked_write_unsigned (regcache
, 19, gp
);
841 /* Set the return address. */
842 if (!gdbarch_push_dummy_code_p (gdbarch
))
843 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
845 /* Update the Stack Pointer. */
846 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
851 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
852 Runtime Architecture for PA-RISC 2.0", which is distributed as part
853 as of the HP-UX Software Transition Kit (STK). This implementation
854 is based on version 3.3, dated October 6, 1997. */
856 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
859 hppa64_integral_or_pointer_p (const struct type
*type
)
861 switch (TYPE_CODE (type
))
867 case TYPE_CODE_RANGE
:
869 int len
= TYPE_LENGTH (type
);
870 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
874 return (TYPE_LENGTH (type
) == 8);
882 /* Check whether TYPE is a "Floating Scalar Type". */
885 hppa64_floating_p (const struct type
*type
)
887 switch (TYPE_CODE (type
))
891 int len
= TYPE_LENGTH (type
);
892 return (len
== 4 || len
== 8 || len
== 16);
901 /* If CODE points to a function entry address, try to look up the corresponding
902 function descriptor and return its address instead. If CODE is not a
903 function entry address, then just return it unchanged. */
905 hppa64_convert_code_addr_to_fptr (struct gdbarch
*gdbarch
, CORE_ADDR code
)
907 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
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
= obj_section_addr (opd
);
930 addr
< obj_section_endaddr (opd
);
936 if (target_read_memory (addr
, tmp
, sizeof (tmp
)))
938 opdaddr
= extract_unsigned_integer (tmp
, sizeof (tmp
), byte_order
);
949 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
950 struct regcache
*regcache
, CORE_ADDR bp_addr
,
951 int nargs
, struct value
**args
, CORE_ADDR sp
,
952 int struct_return
, CORE_ADDR struct_addr
)
954 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
955 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
959 /* "The outgoing parameter area [...] must be aligned at a 16-byte
961 sp
= align_up (sp
, 16);
963 for (i
= 0; i
< nargs
; i
++)
965 struct value
*arg
= args
[i
];
966 struct type
*type
= value_type (arg
);
967 int len
= TYPE_LENGTH (type
);
968 const bfd_byte
*valbuf
;
972 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
973 offset
= align_up (offset
, 8);
975 if (hppa64_integral_or_pointer_p (type
))
977 /* "Integral scalar parameters smaller than 64 bits are
978 padded on the left (i.e., the value is in the
979 least-significant bits of the 64-bit storage unit, and
980 the high-order bits are undefined)." Therefore we can
981 safely sign-extend them. */
984 arg
= value_cast (builtin_type (gdbarch
)->builtin_int64
, arg
);
988 else if (hppa64_floating_p (type
))
992 /* "Quad-precision (128-bit) floating-point scalar
993 parameters are aligned on a 16-byte boundary." */
994 offset
= align_up (offset
, 16);
996 /* "Double-extended- and quad-precision floating-point
997 parameters within the first 64 bytes of the parameter
998 list are always passed in general registers." */
1004 /* "Single-precision (32-bit) floating-point scalar
1005 parameters are padded on the left with 32 bits of
1006 garbage (i.e., the floating-point value is in the
1007 least-significant 32 bits of a 64-bit storage
1012 /* "Single- and double-precision floating-point
1013 parameters in this area are passed according to the
1014 available formal parameter information in a function
1015 prototype. [...] If no prototype is in scope,
1016 floating-point parameters must be passed both in the
1017 corresponding general registers and in the
1018 corresponding floating-point registers." */
1019 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
1021 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
1023 /* "Single-precision floating-point parameters, when
1024 passed in floating-point registers, are passed in
1025 the right halves of the floating point registers;
1026 the left halves are unused." */
1027 regcache_cooked_write_part (regcache
, regnum
, offset
% 8,
1028 len
, value_contents (arg
));
1036 /* "Aggregates larger than 8 bytes are aligned on a
1037 16-byte boundary, possibly leaving an unused argument
1038 slot, which is filled with garbage. If necessary,
1039 they are padded on the right (with garbage), to a
1040 multiple of 8 bytes." */
1041 offset
= align_up (offset
, 16);
1045 /* If we are passing a function pointer, make sure we pass a function
1046 descriptor instead of the function entry address. */
1047 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1048 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1050 ULONGEST codeptr
, fptr
;
1052 codeptr
= unpack_long (type
, value_contents (arg
));
1053 fptr
= hppa64_convert_code_addr_to_fptr (gdbarch
, codeptr
);
1054 store_unsigned_integer (fptrbuf
, TYPE_LENGTH (type
), byte_order
,
1060 valbuf
= value_contents (arg
);
1063 /* Always store the argument in memory. */
1064 write_memory (sp
+ offset
, valbuf
, len
);
1066 regnum
= HPPA_ARG0_REGNUM
- offset
/ 8;
1067 while (regnum
> HPPA_ARG0_REGNUM
- 8 && len
> 0)
1069 regcache_cooked_write_part (regcache
, regnum
,
1070 offset
% 8, min (len
, 8), valbuf
);
1071 offset
+= min (len
, 8);
1072 valbuf
+= min (len
, 8);
1073 len
-= min (len
, 8);
1080 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1081 regcache_cooked_write_unsigned (regcache
, HPPA_RET1_REGNUM
, sp
+ 64);
1083 /* Allocate the outgoing parameter area. Make sure the outgoing
1084 parameter area is multiple of 16 bytes in length. */
1085 sp
+= max (align_up (offset
, 16), 64);
1087 /* Allocate 32-bytes of scratch space. The documentation doesn't
1088 mention this, but it seems to be needed. */
1091 /* Allocate the frame marker area. */
1094 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1097 regcache_cooked_write_unsigned (regcache
, HPPA_RET0_REGNUM
, struct_addr
);
1099 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1100 gp
= tdep
->find_global_pointer (gdbarch
, function
);
1102 regcache_cooked_write_unsigned (regcache
, HPPA_DP_REGNUM
, gp
);
1104 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1105 if (!gdbarch_push_dummy_code_p (gdbarch
))
1106 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1108 /* Set up GR30 to hold the stack pointer (sp). */
1109 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, sp
);
1115 /* Handle 32/64-bit struct return conventions. */
1117 static enum return_value_convention
1118 hppa32_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
1119 struct type
*type
, struct regcache
*regcache
,
1120 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1122 if (TYPE_LENGTH (type
) <= 2 * 4)
1124 /* The value always lives in the right hand end of the register
1125 (or register pair)? */
1127 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
1128 int part
= TYPE_LENGTH (type
) % 4;
1129 /* The left hand register contains only part of the value,
1130 transfer that first so that the rest can be xfered as entire
1131 4-byte registers. */
1134 if (readbuf
!= NULL
)
1135 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
1137 if (writebuf
!= NULL
)
1138 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
1142 /* Now transfer the remaining register values. */
1143 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
1145 if (readbuf
!= NULL
)
1146 regcache_cooked_read (regcache
, reg
, readbuf
+ b
);
1147 if (writebuf
!= NULL
)
1148 regcache_cooked_write (regcache
, reg
, writebuf
+ b
);
1151 return RETURN_VALUE_REGISTER_CONVENTION
;
1154 return RETURN_VALUE_STRUCT_CONVENTION
;
1157 static enum return_value_convention
1158 hppa64_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
1159 struct type
*type
, struct regcache
*regcache
,
1160 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1162 int len
= TYPE_LENGTH (type
);
1167 /* All return values larget than 128 bits must be aggregate
1169 gdb_assert (!hppa64_integral_or_pointer_p (type
));
1170 gdb_assert (!hppa64_floating_p (type
));
1172 /* "Aggregate return values larger than 128 bits are returned in
1173 a buffer allocated by the caller. The address of the buffer
1174 must be passed in GR 28." */
1175 return RETURN_VALUE_STRUCT_CONVENTION
;
1178 if (hppa64_integral_or_pointer_p (type
))
1180 /* "Integral return values are returned in GR 28. Values
1181 smaller than 64 bits are padded on the left (with garbage)." */
1182 regnum
= HPPA_RET0_REGNUM
;
1185 else if (hppa64_floating_p (type
))
1189 /* "Double-extended- and quad-precision floating-point
1190 values are returned in GRs 28 and 29. The sign,
1191 exponent, and most-significant bits of the mantissa are
1192 returned in GR 28; the least-significant bits of the
1193 mantissa are passed in GR 29. For double-extended
1194 precision values, GR 29 is padded on the right with 48
1195 bits of garbage." */
1196 regnum
= HPPA_RET0_REGNUM
;
1201 /* "Single-precision and double-precision floating-point
1202 return values are returned in FR 4R (single precision) or
1203 FR 4 (double-precision)." */
1204 regnum
= HPPA64_FP4_REGNUM
;
1210 /* "Aggregate return values up to 64 bits in size are returned
1211 in GR 28. Aggregates smaller than 64 bits are left aligned
1212 in the register; the pad bits on the right are undefined."
1214 "Aggregate return values between 65 and 128 bits are returned
1215 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1216 the remaining bits are placed, left aligned, in GR 29. The
1217 pad bits on the right of GR 29 (if any) are undefined." */
1218 regnum
= HPPA_RET0_REGNUM
;
1226 regcache_cooked_read_part (regcache
, regnum
, offset
,
1227 min (len
, 8), readbuf
);
1228 readbuf
+= min (len
, 8);
1229 len
-= min (len
, 8);
1238 regcache_cooked_write_part (regcache
, regnum
, offset
,
1239 min (len
, 8), writebuf
);
1240 writebuf
+= min (len
, 8);
1241 len
-= min (len
, 8);
1246 return RETURN_VALUE_REGISTER_CONVENTION
;
1251 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1252 struct target_ops
*targ
)
1256 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1257 CORE_ADDR plabel
= addr
& ~3;
1258 return read_memory_typed_address (plabel
, func_ptr_type
);
1265 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1267 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1269 return align_up (addr
, 64);
1272 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1275 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1277 /* Just always 16-byte align. */
1278 return align_up (addr
, 16);
1282 hppa_read_pc (struct regcache
*regcache
)
1287 regcache_cooked_read_unsigned (regcache
, HPPA_IPSW_REGNUM
, &ipsw
);
1288 regcache_cooked_read_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, &pc
);
1290 /* If the current instruction is nullified, then we are effectively
1291 still executing the previous instruction. Pretend we are still
1292 there. This is needed when single stepping; if the nullified
1293 instruction is on a different line, we don't want GDB to think
1294 we've stepped onto that line. */
1295 if (ipsw
& 0x00200000)
1302 hppa_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1304 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pc
);
1305 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4);
1308 /* return the alignment of a type in bytes. Structures have the maximum
1309 alignment required by their fields. */
1312 hppa_alignof (struct type
*type
)
1314 int max_align
, align
, i
;
1315 CHECK_TYPEDEF (type
);
1316 switch (TYPE_CODE (type
))
1321 return TYPE_LENGTH (type
);
1322 case TYPE_CODE_ARRAY
:
1323 return hppa_alignof (TYPE_INDEX_TYPE (type
));
1324 case TYPE_CODE_STRUCT
:
1325 case TYPE_CODE_UNION
:
1327 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1329 /* Bit fields have no real alignment. */
1330 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1331 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1333 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1334 max_align
= max (max_align
, align
);
1343 /* For the given instruction (INST), return any adjustment it makes
1344 to the stack pointer or zero for no adjustment.
1346 This only handles instructions commonly found in prologues. */
1349 prologue_inst_adjust_sp (unsigned long inst
)
1351 /* This must persist across calls. */
1352 static int save_high21
;
1354 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1355 if ((inst
& 0xffffc000) == 0x37de0000)
1356 return hppa_extract_14 (inst
);
1359 if ((inst
& 0xffe00000) == 0x6fc00000)
1360 return hppa_extract_14 (inst
);
1362 /* std,ma X,D(sp) */
1363 if ((inst
& 0xffe00008) == 0x73c00008)
1364 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1366 /* addil high21,%r30; ldo low11,(%r1),%r30)
1367 save high bits in save_high21 for later use. */
1368 if ((inst
& 0xffe00000) == 0x2bc00000)
1370 save_high21
= hppa_extract_21 (inst
);
1374 if ((inst
& 0xffff0000) == 0x343e0000)
1375 return save_high21
+ hppa_extract_14 (inst
);
1377 /* fstws as used by the HP compilers. */
1378 if ((inst
& 0xffffffe0) == 0x2fd01220)
1379 return hppa_extract_5_load (inst
);
1381 /* No adjustment. */
1385 /* Return nonzero if INST is a branch of some kind, else return zero. */
1388 is_branch (unsigned long inst
)
1417 /* Return the register number for a GR which is saved by INST or
1418 zero it INST does not save a GR. */
1421 inst_saves_gr (unsigned long inst
)
1423 /* Does it look like a stw? */
1424 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1425 || (inst
>> 26) == 0x1f
1426 || ((inst
>> 26) == 0x1f
1427 && ((inst
>> 6) == 0xa)))
1428 return hppa_extract_5R_store (inst
);
1430 /* Does it look like a std? */
1431 if ((inst
>> 26) == 0x1c
1432 || ((inst
>> 26) == 0x03
1433 && ((inst
>> 6) & 0xf) == 0xb))
1434 return hppa_extract_5R_store (inst
);
1436 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1437 if ((inst
>> 26) == 0x1b)
1438 return hppa_extract_5R_store (inst
);
1440 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1442 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1443 || ((inst
>> 26) == 0x3
1444 && (((inst
>> 6) & 0xf) == 0x8
1445 || (inst
>> 6) & 0xf) == 0x9))
1446 return hppa_extract_5R_store (inst
);
1451 /* Return the register number for a FR which is saved by INST or
1452 zero it INST does not save a FR.
1454 Note we only care about full 64bit register stores (that's the only
1455 kind of stores the prologue will use).
1457 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1460 inst_saves_fr (unsigned long inst
)
1462 /* is this an FSTD ? */
1463 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1464 return hppa_extract_5r_store (inst
);
1465 if ((inst
& 0xfc000002) == 0x70000002)
1466 return hppa_extract_5R_store (inst
);
1467 /* is this an FSTW ? */
1468 if ((inst
& 0xfc00df80) == 0x24001200)
1469 return hppa_extract_5r_store (inst
);
1470 if ((inst
& 0xfc000002) == 0x7c000000)
1471 return hppa_extract_5R_store (inst
);
1475 /* Advance PC across any function entry prologue instructions
1476 to reach some "real" code.
1478 Use information in the unwind table to determine what exactly should
1479 be in the prologue. */
1483 skip_prologue_hard_way (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1484 int stop_before_branch
)
1486 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1488 CORE_ADDR orig_pc
= pc
;
1489 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1490 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1491 struct unwind_table_entry
*u
;
1492 int final_iteration
;
1498 u
= find_unwind_entry (pc
);
1502 /* If we are not at the beginning of a function, then return now. */
1503 if ((pc
& ~0x3) != u
->region_start
)
1506 /* This is how much of a frame adjustment we need to account for. */
1507 stack_remaining
= u
->Total_frame_size
<< 3;
1509 /* Magic register saves we want to know about. */
1510 save_rp
= u
->Save_RP
;
1511 save_sp
= u
->Save_SP
;
1513 /* An indication that args may be stored into the stack. Unfortunately
1514 the HPUX compilers tend to set this in cases where no args were
1518 /* Turn the Entry_GR field into a bitmask. */
1520 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1522 /* Frame pointer gets saved into a special location. */
1523 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1526 save_gr
|= (1 << i
);
1528 save_gr
&= ~restart_gr
;
1530 /* Turn the Entry_FR field into a bitmask too. */
1532 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1533 save_fr
|= (1 << i
);
1534 save_fr
&= ~restart_fr
;
1536 final_iteration
= 0;
1538 /* Loop until we find everything of interest or hit a branch.
1540 For unoptimized GCC code and for any HP CC code this will never ever
1541 examine any user instructions.
1543 For optimzied GCC code we're faced with problems. GCC will schedule
1544 its prologue and make prologue instructions available for delay slot
1545 filling. The end result is user code gets mixed in with the prologue
1546 and a prologue instruction may be in the delay slot of the first branch
1549 Some unexpected things are expected with debugging optimized code, so
1550 we allow this routine to walk past user instructions in optimized
1552 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1555 unsigned int reg_num
;
1556 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1557 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1559 /* Save copies of all the triggers so we can compare them later
1561 old_save_gr
= save_gr
;
1562 old_save_fr
= save_fr
;
1563 old_save_rp
= save_rp
;
1564 old_save_sp
= save_sp
;
1565 old_stack_remaining
= stack_remaining
;
1567 status
= target_read_memory (pc
, buf
, 4);
1568 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1574 /* Note the interesting effects of this instruction. */
1575 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1577 /* There are limited ways to store the return pointer into the
1579 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1582 /* These are the only ways we save SP into the stack. At this time
1583 the HP compilers never bother to save SP into the stack. */
1584 if ((inst
& 0xffffc000) == 0x6fc10000
1585 || (inst
& 0xffffc00c) == 0x73c10008)
1588 /* Are we loading some register with an offset from the argument
1590 if ((inst
& 0xffe00000) == 0x37a00000
1591 || (inst
& 0xffffffe0) == 0x081d0240)
1597 /* Account for general and floating-point register saves. */
1598 reg_num
= inst_saves_gr (inst
);
1599 save_gr
&= ~(1 << reg_num
);
1601 /* Ugh. Also account for argument stores into the stack.
1602 Unfortunately args_stored only tells us that some arguments
1603 where stored into the stack. Not how many or what kind!
1605 This is a kludge as on the HP compiler sets this bit and it
1606 never does prologue scheduling. So once we see one, skip past
1607 all of them. We have similar code for the fp arg stores below.
1609 FIXME. Can still die if we have a mix of GR and FR argument
1611 if (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1614 while (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1618 status
= target_read_memory (pc
, buf
, 4);
1619 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1622 reg_num
= inst_saves_gr (inst
);
1628 reg_num
= inst_saves_fr (inst
);
1629 save_fr
&= ~(1 << reg_num
);
1631 status
= target_read_memory (pc
+ 4, buf
, 4);
1632 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1638 /* We've got to be read to handle the ldo before the fp register
1640 if ((inst
& 0xfc000000) == 0x34000000
1641 && inst_saves_fr (next_inst
) >= 4
1642 && inst_saves_fr (next_inst
)
1643 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1645 /* So we drop into the code below in a reasonable state. */
1646 reg_num
= inst_saves_fr (next_inst
);
1650 /* Ugh. Also account for argument stores into the stack.
1651 This is a kludge as on the HP compiler sets this bit and it
1652 never does prologue scheduling. So once we see one, skip past
1655 && reg_num
<= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1659 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1662 status
= target_read_memory (pc
, buf
, 4);
1663 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1666 if ((inst
& 0xfc000000) != 0x34000000)
1668 status
= target_read_memory (pc
+ 4, buf
, 4);
1669 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1672 reg_num
= inst_saves_fr (next_inst
);
1678 /* Quit if we hit any kind of branch. This can happen if a prologue
1679 instruction is in the delay slot of the first call/branch. */
1680 if (is_branch (inst
) && stop_before_branch
)
1683 /* What a crock. The HP compilers set args_stored even if no
1684 arguments were stored into the stack (boo hiss). This could
1685 cause this code to then skip a bunch of user insns (up to the
1688 To combat this we try to identify when args_stored was bogusly
1689 set and clear it. We only do this when args_stored is nonzero,
1690 all other resources are accounted for, and nothing changed on
1693 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1694 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1695 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1696 && old_stack_remaining
== stack_remaining
)
1702 /* !stop_before_branch, so also look at the insn in the delay slot
1704 if (final_iteration
)
1706 if (is_branch (inst
))
1707 final_iteration
= 1;
1710 /* We've got a tenative location for the end of the prologue. However
1711 because of limitations in the unwind descriptor mechanism we may
1712 have went too far into user code looking for the save of a register
1713 that does not exist. So, if there registers we expected to be saved
1714 but never were, mask them out and restart.
1716 This should only happen in optimized code, and should be very rare. */
1717 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1720 restart_gr
= save_gr
;
1721 restart_fr
= save_fr
;
1729 /* Return the address of the PC after the last prologue instruction if
1730 we can determine it from the debug symbols. Else return zero. */
1733 after_prologue (CORE_ADDR pc
)
1735 struct symtab_and_line sal
;
1736 CORE_ADDR func_addr
, func_end
;
1739 /* If we can not find the symbol in the partial symbol table, then
1740 there is no hope we can determine the function's start address
1742 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1745 /* Get the line associated with FUNC_ADDR. */
1746 sal
= find_pc_line (func_addr
, 0);
1748 /* There are only two cases to consider. First, the end of the source line
1749 is within the function bounds. In that case we return the end of the
1750 source line. Second is the end of the source line extends beyond the
1751 bounds of the current function. We need to use the slow code to
1752 examine instructions in that case.
1754 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1755 the wrong thing to do. In fact, it should be entirely possible for this
1756 function to always return zero since the slow instruction scanning code
1757 is supposed to *always* work. If it does not, then it is a bug. */
1758 if (sal
.end
< func_end
)
1764 /* To skip prologues, I use this predicate. Returns either PC itself
1765 if the code at PC does not look like a function prologue; otherwise
1766 returns an address that (if we're lucky) follows the prologue.
1768 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1769 It doesn't necessarily skips all the insns in the prologue. In fact
1770 we might not want to skip all the insns because a prologue insn may
1771 appear in the delay slot of the first branch, and we don't want to
1772 skip over the branch in that case. */
1775 hppa_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1779 CORE_ADDR post_prologue_pc
;
1782 /* See if we can determine the end of the prologue via the symbol table.
1783 If so, then return either PC, or the PC after the prologue, whichever
1786 post_prologue_pc
= after_prologue (pc
);
1788 /* If after_prologue returned a useful address, then use it. Else
1789 fall back on the instruction skipping code.
1791 Some folks have claimed this causes problems because the breakpoint
1792 may be the first instruction of the prologue. If that happens, then
1793 the instruction skipping code has a bug that needs to be fixed. */
1794 if (post_prologue_pc
!= 0)
1795 return max (pc
, post_prologue_pc
);
1797 return (skip_prologue_hard_way (gdbarch
, pc
, 1));
1800 /* Return an unwind entry that falls within the frame's code block. */
1802 static struct unwind_table_entry
*
1803 hppa_find_unwind_entry_in_block (struct frame_info
*this_frame
)
1805 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
1807 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1808 result of get_frame_address_in_block implies a problem.
1809 The bits should have been removed earlier, before the return
1810 value of gdbarch_unwind_pc. That might be happening already;
1811 if it isn't, it should be fixed. Then this call can be
1813 pc
= gdbarch_addr_bits_remove (get_frame_arch (this_frame
), pc
);
1814 return find_unwind_entry (pc
);
1817 struct hppa_frame_cache
1820 struct trad_frame_saved_reg
*saved_regs
;
1823 static struct hppa_frame_cache
*
1824 hppa_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1826 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1827 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1828 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1829 struct hppa_frame_cache
*cache
;
1834 struct unwind_table_entry
*u
;
1835 CORE_ADDR prologue_end
;
1840 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1841 frame_relative_level(this_frame
));
1843 if ((*this_cache
) != NULL
)
1846 fprintf_unfiltered (gdb_stdlog
, "base=%s (cached) }",
1847 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
1848 return (*this_cache
);
1850 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1851 (*this_cache
) = cache
;
1852 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1855 u
= hppa_find_unwind_entry_in_block (this_frame
);
1859 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1860 return (*this_cache
);
1863 /* Turn the Entry_GR field into a bitmask. */
1865 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1867 /* Frame pointer gets saved into a special location. */
1868 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1871 saved_gr_mask
|= (1 << i
);
1874 /* Turn the Entry_FR field into a bitmask too. */
1876 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1877 saved_fr_mask
|= (1 << i
);
1879 /* Loop until we find everything of interest or hit a branch.
1881 For unoptimized GCC code and for any HP CC code this will never ever
1882 examine any user instructions.
1884 For optimized GCC code we're faced with problems. GCC will schedule
1885 its prologue and make prologue instructions available for delay slot
1886 filling. The end result is user code gets mixed in with the prologue
1887 and a prologue instruction may be in the delay slot of the first branch
1890 Some unexpected things are expected with debugging optimized code, so
1891 we allow this routine to walk past user instructions in optimized
1894 int final_iteration
= 0;
1895 CORE_ADDR pc
, start_pc
, end_pc
;
1896 int looking_for_sp
= u
->Save_SP
;
1897 int looking_for_rp
= u
->Save_RP
;
1900 /* We have to use skip_prologue_hard_way instead of just
1901 skip_prologue_using_sal, in case we stepped into a function without
1902 symbol information. hppa_skip_prologue also bounds the returned
1903 pc by the passed in pc, so it will not return a pc in the next
1906 We used to call hppa_skip_prologue to find the end of the prologue,
1907 but if some non-prologue instructions get scheduled into the prologue,
1908 and the program is compiled with debug information, the "easy" way
1909 in hppa_skip_prologue will return a prologue end that is too early
1910 for us to notice any potential frame adjustments. */
1912 /* We used to use get_frame_func to locate the beginning of the
1913 function to pass to skip_prologue. However, when objects are
1914 compiled without debug symbols, get_frame_func can return the wrong
1915 function (or 0). We can do better than that by using unwind records.
1916 This only works if the Region_description of the unwind record
1917 indicates that it includes the entry point of the function.
1918 HP compilers sometimes generate unwind records for regions that
1919 do not include the entry or exit point of a function. GNU tools
1922 if ((u
->Region_description
& 0x2) == 0)
1923 start_pc
= u
->region_start
;
1925 start_pc
= get_frame_func (this_frame
);
1927 prologue_end
= skip_prologue_hard_way (gdbarch
, start_pc
, 0);
1928 end_pc
= get_frame_pc (this_frame
);
1930 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1931 end_pc
= prologue_end
;
1936 ((saved_gr_mask
|| saved_fr_mask
1937 || looking_for_sp
|| looking_for_rp
1938 || frame_size
< (u
->Total_frame_size
<< 3))
1946 if (!safe_frame_unwind_memory (this_frame
, pc
, buf4
, sizeof buf4
))
1948 error (_("Cannot read instruction at %s."),
1949 paddress (gdbarch
, pc
));
1950 return (*this_cache
);
1953 inst
= extract_unsigned_integer (buf4
, sizeof buf4
, byte_order
);
1955 /* Note the interesting effects of this instruction. */
1956 frame_size
+= prologue_inst_adjust_sp (inst
);
1958 /* There are limited ways to store the return pointer into the
1960 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1963 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1965 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1968 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1970 else if (inst
== 0x0fc212c1
1971 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1974 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1977 /* Check to see if we saved SP into the stack. This also
1978 happens to indicate the location of the saved frame
1980 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1981 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1984 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1986 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1991 /* Account for general and floating-point register saves. */
1992 reg
= inst_saves_gr (inst
);
1993 if (reg
>= 3 && reg
<= 18
1994 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1996 saved_gr_mask
&= ~(1 << reg
);
1997 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1998 /* stwm with a positive displacement is a _post_
2000 cache
->saved_regs
[reg
].addr
= 0;
2001 else if ((inst
& 0xfc00000c) == 0x70000008)
2002 /* A std has explicit post_modify forms. */
2003 cache
->saved_regs
[reg
].addr
= 0;
2008 if ((inst
>> 26) == 0x1c)
2009 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
2010 else if ((inst
>> 26) == 0x03)
2011 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
2013 offset
= hppa_extract_14 (inst
);
2015 /* Handle code with and without frame pointers. */
2017 cache
->saved_regs
[reg
].addr
= offset
;
2019 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
2023 /* GCC handles callee saved FP regs a little differently.
2025 It emits an instruction to put the value of the start of
2026 the FP store area into %r1. It then uses fstds,ma with a
2027 basereg of %r1 for the stores.
2029 HP CC emits them at the current stack pointer modifying the
2030 stack pointer as it stores each register. */
2032 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2033 if ((inst
& 0xffffc000) == 0x34610000
2034 || (inst
& 0xffffc000) == 0x37c10000)
2035 fp_loc
= hppa_extract_14 (inst
);
2037 reg
= inst_saves_fr (inst
);
2038 if (reg
>= 12 && reg
<= 21)
2040 /* Note +4 braindamage below is necessary because the FP
2041 status registers are internally 8 registers rather than
2042 the expected 4 registers. */
2043 saved_fr_mask
&= ~(1 << reg
);
2046 /* 1st HP CC FP register store. After this
2047 instruction we've set enough state that the GCC and
2048 HPCC code are both handled in the same manner. */
2049 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
2054 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
2059 /* Quit if we hit any kind of branch the previous iteration. */
2060 if (final_iteration
)
2062 /* We want to look precisely one instruction beyond the branch
2063 if we have not found everything yet. */
2064 if (is_branch (inst
))
2065 final_iteration
= 1;
2070 /* The frame base always represents the value of %sp at entry to
2071 the current function (and is thus equivalent to the "saved"
2073 CORE_ADDR this_sp
= get_frame_register_unsigned (this_frame
,
2078 fprintf_unfiltered (gdb_stdlog
, " (this_sp=%s, pc=%s, "
2079 "prologue_end=%s) ",
2080 paddress (gdbarch
, this_sp
),
2081 paddress (gdbarch
, get_frame_pc (this_frame
)),
2082 paddress (gdbarch
, prologue_end
));
2084 /* Check to see if a frame pointer is available, and use it for
2085 frame unwinding if it is.
2087 There are some situations where we need to rely on the frame
2088 pointer to do stack unwinding. For example, if a function calls
2089 alloca (), the stack pointer can get adjusted inside the body of
2090 the function. In this case, the ABI requires that the compiler
2091 maintain a frame pointer for the function.
2093 The unwind record has a flag (alloca_frame) that indicates that
2094 a function has a variable frame; unfortunately, gcc/binutils
2095 does not set this flag. Instead, whenever a frame pointer is used
2096 and saved on the stack, the Save_SP flag is set. We use this to
2097 decide whether to use the frame pointer for unwinding.
2099 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2100 instead of Save_SP. */
2102 fp
= get_frame_register_unsigned (this_frame
, HPPA_FP_REGNUM
);
2104 if (u
->alloca_frame
)
2105 fp
-= u
->Total_frame_size
<< 3;
2107 if (get_frame_pc (this_frame
) >= prologue_end
2108 && (u
->Save_SP
|| u
->alloca_frame
) && fp
!= 0)
2113 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [frame pointer]",
2114 paddress (gdbarch
, cache
->base
));
2117 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
2119 /* Both we're expecting the SP to be saved and the SP has been
2120 saved. The entry SP value is saved at this frame's SP
2122 cache
->base
= read_memory_integer (this_sp
, word_size
, byte_order
);
2125 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [saved]",
2126 paddress (gdbarch
, cache
->base
));
2130 /* The prologue has been slowly allocating stack space. Adjust
2132 cache
->base
= this_sp
- frame_size
;
2134 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [unwind adjust]",
2135 paddress (gdbarch
, cache
->base
));
2138 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2141 /* The PC is found in the "return register", "Millicode" uses "r31"
2142 as the return register while normal code uses "rp". */
2145 if (trad_frame_addr_p (cache
->saved_regs
, 31))
2147 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2149 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2153 ULONGEST r31
= get_frame_register_unsigned (this_frame
, 31);
2154 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
2156 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2161 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2163 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2164 cache
->saved_regs
[HPPA_RP_REGNUM
];
2166 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2170 ULONGEST rp
= get_frame_register_unsigned (this_frame
,
2172 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2174 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2178 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2179 frame. However, there is a one-insn window where we haven't saved it
2180 yet, but we've already clobbered it. Detect this case and fix it up.
2182 The prologue sequence for frame-pointer functions is:
2183 0: stw %rp, -20(%sp)
2186 c: stw,ma %r1, XX(%sp)
2188 So if we are at offset c, the r3 value that we want is not yet saved
2189 on the stack, but it's been overwritten. The prologue analyzer will
2190 set fp_in_r1 when it sees the copy insn so we know to get the value
2192 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
2195 ULONGEST r1
= get_frame_register_unsigned (this_frame
, 1);
2196 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
2200 /* Convert all the offsets into addresses. */
2202 for (reg
= 0; reg
< gdbarch_num_regs (gdbarch
); reg
++)
2204 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
2205 cache
->saved_regs
[reg
].addr
+= cache
->base
;
2210 struct gdbarch_tdep
*tdep
;
2212 tdep
= gdbarch_tdep (gdbarch
);
2214 if (tdep
->unwind_adjust_stub
)
2215 tdep
->unwind_adjust_stub (this_frame
, cache
->base
, cache
->saved_regs
);
2219 fprintf_unfiltered (gdb_stdlog
, "base=%s }",
2220 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
2221 return (*this_cache
);
2225 hppa_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2226 struct frame_id
*this_id
)
2228 struct hppa_frame_cache
*info
;
2229 CORE_ADDR pc
= get_frame_pc (this_frame
);
2230 struct unwind_table_entry
*u
;
2232 info
= hppa_frame_cache (this_frame
, this_cache
);
2233 u
= hppa_find_unwind_entry_in_block (this_frame
);
2235 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2238 static struct value
*
2239 hppa_frame_prev_register (struct frame_info
*this_frame
,
2240 void **this_cache
, int regnum
)
2242 struct hppa_frame_cache
*info
= hppa_frame_cache (this_frame
, this_cache
);
2244 return hppa_frame_prev_register_helper (this_frame
, info
->saved_regs
, regnum
);
2248 hppa_frame_unwind_sniffer (const struct frame_unwind
*self
,
2249 struct frame_info
*this_frame
, void **this_cache
)
2251 if (hppa_find_unwind_entry_in_block (this_frame
))
2257 static const struct frame_unwind hppa_frame_unwind
=
2261 hppa_frame_prev_register
,
2263 hppa_frame_unwind_sniffer
2266 /* This is a generic fallback frame unwinder that kicks in if we fail all
2267 the other ones. Normally we would expect the stub and regular unwinder
2268 to work, but in some cases we might hit a function that just doesn't
2269 have any unwind information available. In this case we try to do
2270 unwinding solely based on code reading. This is obviously going to be
2271 slow, so only use this as a last resort. Currently this will only
2272 identify the stack and pc for the frame. */
2274 static struct hppa_frame_cache
*
2275 hppa_fallback_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
2277 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2278 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2279 struct hppa_frame_cache
*cache
;
2280 unsigned int frame_size
= 0;
2285 fprintf_unfiltered (gdb_stdlog
,
2286 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2287 frame_relative_level (this_frame
));
2289 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2290 (*this_cache
) = cache
;
2291 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2293 start_pc
= get_frame_func (this_frame
);
2296 CORE_ADDR cur_pc
= get_frame_pc (this_frame
);
2299 for (pc
= start_pc
; pc
< cur_pc
; pc
+= 4)
2303 insn
= read_memory_unsigned_integer (pc
, 4, byte_order
);
2304 frame_size
+= prologue_inst_adjust_sp (insn
);
2306 /* There are limited ways to store the return pointer into the
2308 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2310 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2313 else if (insn
== 0x0fc212c1
2314 || insn
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2316 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2323 fprintf_unfiltered (gdb_stdlog
, " frame_size=%d, found_rp=%d }\n",
2324 frame_size
, found_rp
);
2326 cache
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2327 cache
->base
-= frame_size
;
2328 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2330 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2332 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2333 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2334 cache
->saved_regs
[HPPA_RP_REGNUM
];
2339 rp
= get_frame_register_unsigned (this_frame
, HPPA_RP_REGNUM
);
2340 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2347 hppa_fallback_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2348 struct frame_id
*this_id
)
2350 struct hppa_frame_cache
*info
=
2351 hppa_fallback_frame_cache (this_frame
, this_cache
);
2353 (*this_id
) = frame_id_build (info
->base
, get_frame_func (this_frame
));
2356 static struct value
*
2357 hppa_fallback_frame_prev_register (struct frame_info
*this_frame
,
2358 void **this_cache
, int regnum
)
2360 struct hppa_frame_cache
*info
=
2361 hppa_fallback_frame_cache (this_frame
, this_cache
);
2363 return hppa_frame_prev_register_helper (this_frame
, info
->saved_regs
, regnum
);
2366 static const struct frame_unwind hppa_fallback_frame_unwind
=
2369 hppa_fallback_frame_this_id
,
2370 hppa_fallback_frame_prev_register
,
2372 default_frame_sniffer
2375 /* Stub frames, used for all kinds of call stubs. */
2376 struct hppa_stub_unwind_cache
2379 struct trad_frame_saved_reg
*saved_regs
;
2382 static struct hppa_stub_unwind_cache
*
2383 hppa_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2386 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2387 struct hppa_stub_unwind_cache
*info
;
2388 struct unwind_table_entry
*u
;
2393 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2395 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2397 info
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2399 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2401 /* HPUX uses export stubs in function calls; the export stub clobbers
2402 the return value of the caller, and, later restores it from the
2404 u
= find_unwind_entry (get_frame_pc (this_frame
));
2406 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2408 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2414 /* By default we assume that stubs do not change the rp. */
2415 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2421 hppa_stub_frame_this_id (struct frame_info
*this_frame
,
2422 void **this_prologue_cache
,
2423 struct frame_id
*this_id
)
2425 struct hppa_stub_unwind_cache
*info
2426 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2429 *this_id
= frame_id_build (info
->base
, get_frame_func (this_frame
));
2432 static struct value
*
2433 hppa_stub_frame_prev_register (struct frame_info
*this_frame
,
2434 void **this_prologue_cache
, int regnum
)
2436 struct hppa_stub_unwind_cache
*info
2437 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2440 error (_("Requesting registers from null frame."));
2442 return hppa_frame_prev_register_helper (this_frame
, info
->saved_regs
, regnum
);
2446 hppa_stub_unwind_sniffer (const struct frame_unwind
*self
,
2447 struct frame_info
*this_frame
,
2450 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
2451 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2452 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2455 || (tdep
->in_solib_call_trampoline
!= NULL
2456 && tdep
->in_solib_call_trampoline (gdbarch
, pc
, NULL
))
2457 || gdbarch_in_solib_return_trampoline (gdbarch
, pc
, NULL
))
2462 static const struct frame_unwind hppa_stub_frame_unwind
= {
2464 hppa_stub_frame_this_id
,
2465 hppa_stub_frame_prev_register
,
2467 hppa_stub_unwind_sniffer
2470 static struct frame_id
2471 hppa_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2473 return frame_id_build (get_frame_register_unsigned (this_frame
,
2475 get_frame_pc (this_frame
));
2479 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2484 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2485 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2487 /* If the current instruction is nullified, then we are effectively
2488 still executing the previous instruction. Pretend we are still
2489 there. This is needed when single stepping; if the nullified
2490 instruction is on a different line, we don't want GDB to think
2491 we've stepped onto that line. */
2492 if (ipsw
& 0x00200000)
2498 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2499 Return NULL if no such symbol was found. */
2501 struct minimal_symbol
*
2502 hppa_lookup_stub_minimal_symbol (const char *name
,
2503 enum unwind_stub_types stub_type
)
2505 struct objfile
*objfile
;
2506 struct minimal_symbol
*msym
;
2508 ALL_MSYMBOLS (objfile
, msym
)
2510 if (strcmp (SYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2512 struct unwind_table_entry
*u
;
2514 u
= find_unwind_entry (SYMBOL_VALUE (msym
));
2515 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2524 unwind_command (char *exp
, int from_tty
)
2527 struct unwind_table_entry
*u
;
2529 /* If we have an expression, evaluate it and use it as the address. */
2531 if (exp
!= 0 && *exp
!= 0)
2532 address
= parse_and_eval_address (exp
);
2536 u
= find_unwind_entry (address
);
2540 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2544 printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u
);
2546 printf_unfiltered ("\tregion_start = %s\n", hex_string (u
->region_start
));
2547 gdb_flush (gdb_stdout
);
2549 printf_unfiltered ("\tregion_end = %s\n", hex_string (u
->region_end
));
2550 gdb_flush (gdb_stdout
);
2552 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2554 printf_unfiltered ("\n\tflags =");
2555 pif (Cannot_unwind
);
2557 pif (Millicode_save_sr0
);
2560 pif (Variable_Frame
);
2561 pif (Separate_Package_Body
);
2562 pif (Frame_Extension_Millicode
);
2563 pif (Stack_Overflow_Check
);
2564 pif (Two_Instruction_SP_Increment
);
2567 pif (cxx_try_catch
);
2568 pif (sched_entry_seq
);
2571 pif (Save_MRP_in_frame
);
2573 pif (Cleanup_defined
);
2574 pif (MPE_XL_interrupt_marker
);
2575 pif (HP_UX_interrupt_marker
);
2579 putchar_unfiltered ('\n');
2581 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2583 pin (Region_description
);
2586 pin (Total_frame_size
);
2588 if (u
->stub_unwind
.stub_type
)
2590 printf_unfiltered ("\tstub type = ");
2591 switch (u
->stub_unwind
.stub_type
)
2594 printf_unfiltered ("long branch\n");
2596 case PARAMETER_RELOCATION
:
2597 printf_unfiltered ("parameter relocation\n");
2600 printf_unfiltered ("export\n");
2603 printf_unfiltered ("import\n");
2606 printf_unfiltered ("import shlib\n");
2609 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2614 /* Return the GDB type object for the "standard" data type of data in
2617 static struct type
*
2618 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2620 if (regnum
< HPPA_FP4_REGNUM
)
2621 return builtin_type (gdbarch
)->builtin_uint32
;
2623 return builtin_type (gdbarch
)->builtin_float
;
2626 static struct type
*
2627 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2629 if (regnum
< HPPA64_FP4_REGNUM
)
2630 return builtin_type (gdbarch
)->builtin_uint64
;
2632 return builtin_type (gdbarch
)->builtin_double
;
2635 /* Return non-zero if REGNUM is not a register available to the user
2636 through ptrace/ttrace. */
2639 hppa32_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2642 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2643 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2644 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2648 hppa32_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2650 /* cr26 and cr27 are readable (but not writable) from userspace. */
2651 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2654 return hppa32_cannot_store_register (gdbarch
, regnum
);
2658 hppa64_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2661 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2662 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2663 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2667 hppa64_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2669 /* cr26 and cr27 are readable (but not writable) from userspace. */
2670 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2673 return hppa64_cannot_store_register (gdbarch
, regnum
);
2677 hppa_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2679 /* The low two bits of the PC on the PA contain the privilege level.
2680 Some genius implementing a (non-GCC) compiler apparently decided
2681 this means that "addresses" in a text section therefore include a
2682 privilege level, and thus symbol tables should contain these bits.
2683 This seems like a bonehead thing to do--anyway, it seems to work
2684 for our purposes to just ignore those bits. */
2686 return (addr
&= ~0x3);
2689 /* Get the ARGIth function argument for the current function. */
2692 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2695 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2699 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2700 int regnum
, gdb_byte
*buf
)
2702 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2705 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2706 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2708 store_unsigned_integer (buf
, sizeof tmp
, byte_order
, tmp
);
2712 hppa_find_global_pointer (struct gdbarch
*gdbarch
, struct value
*function
)
2718 hppa_frame_prev_register_helper (struct frame_info
*this_frame
,
2719 struct trad_frame_saved_reg saved_regs
[],
2722 struct gdbarch
*arch
= get_frame_arch (this_frame
);
2723 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2725 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2727 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2729 struct value
*pcoq_val
=
2730 trad_frame_get_prev_register (this_frame
, saved_regs
,
2731 HPPA_PCOQ_HEAD_REGNUM
);
2733 pc
= extract_unsigned_integer (value_contents_all (pcoq_val
),
2735 return frame_unwind_got_constant (this_frame
, regnum
, pc
+ 4);
2738 /* Make sure the "flags" register is zero in all unwound frames.
2739 The "flags" registers is a HP-UX specific wart, and only the code
2740 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2741 with it here. This shouldn't affect other systems since those
2742 should provide zero for the "flags" register anyway. */
2743 if (regnum
== HPPA_FLAGS_REGNUM
)
2744 return frame_unwind_got_constant (this_frame
, regnum
, 0);
2746 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
2750 /* An instruction to match. */
2753 unsigned int data
; /* See if it matches this.... */
2754 unsigned int mask
; /* ... with this mask. */
2757 /* See bfd/elf32-hppa.c */
2758 static struct insn_pattern hppa_long_branch_stub
[] = {
2759 /* ldil LR'xxx,%r1 */
2760 { 0x20200000, 0xffe00000 },
2761 /* be,n RR'xxx(%sr4,%r1) */
2762 { 0xe0202002, 0xffe02002 },
2766 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
2768 { 0xe8200000, 0xffe00000 },
2769 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2770 { 0x28200000, 0xffe00000 },
2771 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2772 { 0xe0202002, 0xffe02002 },
2776 static struct insn_pattern hppa_import_stub
[] = {
2777 /* addil LR'xxx, %dp */
2778 { 0x2b600000, 0xffe00000 },
2779 /* ldw RR'xxx(%r1), %r21 */
2780 { 0x48350000, 0xffffb000 },
2782 { 0xeaa0c000, 0xffffffff },
2783 /* ldw RR'xxx+4(%r1), %r19 */
2784 { 0x48330000, 0xffffb000 },
2788 static struct insn_pattern hppa_import_pic_stub
[] = {
2789 /* addil LR'xxx,%r19 */
2790 { 0x2a600000, 0xffe00000 },
2791 /* ldw RR'xxx(%r1),%r21 */
2792 { 0x48350000, 0xffffb000 },
2794 { 0xeaa0c000, 0xffffffff },
2795 /* ldw RR'xxx+4(%r1),%r19 */
2796 { 0x48330000, 0xffffb000 },
2800 static struct insn_pattern hppa_plt_stub
[] = {
2801 /* b,l 1b, %r20 - 1b is 3 insns before here */
2802 { 0xea9f1fdd, 0xffffffff },
2803 /* depi 0,31,2,%r20 */
2804 { 0xd6801c1e, 0xffffffff },
2808 static struct insn_pattern hppa_sigtramp
[] = {
2809 /* ldi 0, %r25 or ldi 1, %r25 */
2810 { 0x34190000, 0xfffffffd },
2811 /* ldi __NR_rt_sigreturn, %r20 */
2812 { 0x3414015a, 0xffffffff },
2813 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
2814 { 0xe4008200, 0xffffffff },
2816 { 0x08000240, 0xffffffff },
2820 /* Maximum number of instructions on the patterns above. */
2821 #define HPPA_MAX_INSN_PATTERN_LEN 4
2823 /* Return non-zero if the instructions at PC match the series
2824 described in PATTERN, or zero otherwise. PATTERN is an array of
2825 'struct insn_pattern' objects, terminated by an entry whose mask is
2828 When the match is successful, fill INSN[i] with what PATTERN[i]
2832 hppa_match_insns (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2833 struct insn_pattern
*pattern
, unsigned int *insn
)
2835 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2839 for (i
= 0; pattern
[i
].mask
; i
++)
2841 gdb_byte buf
[HPPA_INSN_SIZE
];
2843 target_read_memory (npc
, buf
, HPPA_INSN_SIZE
);
2844 insn
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
, byte_order
);
2845 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
2854 /* This relaxed version of the insstruction matcher allows us to match
2855 from somewhere inside the pattern, by looking backwards in the
2856 instruction scheme. */
2859 hppa_match_insns_relaxed (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2860 struct insn_pattern
*pattern
, unsigned int *insn
)
2862 int offset
, len
= 0;
2864 while (pattern
[len
].mask
)
2867 for (offset
= 0; offset
< len
; offset
++)
2868 if (hppa_match_insns (gdbarch
, pc
- offset
* HPPA_INSN_SIZE
,
2876 hppa_in_dyncall (CORE_ADDR pc
)
2878 struct unwind_table_entry
*u
;
2880 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2884 return (pc
>= u
->region_start
&& pc
<= u
->region_end
);
2888 hppa_in_solib_call_trampoline (struct gdbarch
*gdbarch
,
2889 CORE_ADDR pc
, char *name
)
2891 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2892 struct unwind_table_entry
*u
;
2894 if (in_plt_section (pc
, name
) || hppa_in_dyncall (pc
))
2897 /* The GNU toolchain produces linker stubs without unwind
2898 information. Since the pattern matching for linker stubs can be
2899 quite slow, so bail out if we do have an unwind entry. */
2901 u
= find_unwind_entry (pc
);
2906 (hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_stub
, insn
)
2907 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_pic_stub
, insn
)
2908 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_long_branch_stub
, insn
)
2909 || hppa_match_insns_relaxed (gdbarch
, pc
,
2910 hppa_long_branch_pic_stub
, insn
));
2913 /* This code skips several kind of "trampolines" used on PA-RISC
2914 systems: $$dyncall, import stubs and PLT stubs. */
2917 hppa_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
2919 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2920 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
2922 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2925 /* $$dyncall handles both PLABELs and direct addresses. */
2926 if (hppa_in_dyncall (pc
))
2928 pc
= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 22);
2930 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2932 pc
= read_memory_typed_address (pc
& ~0x3, func_ptr_type
);
2937 dp_rel
= hppa_match_insns (gdbarch
, pc
, hppa_import_stub
, insn
);
2938 if (dp_rel
|| hppa_match_insns (gdbarch
, pc
, hppa_import_pic_stub
, insn
))
2940 /* Extract the target address from the addil/ldw sequence. */
2941 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
2944 pc
+= get_frame_register_unsigned (frame
, HPPA_DP_REGNUM
);
2946 pc
+= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 19);
2951 if (in_plt_section (pc
, NULL
))
2953 pc
= read_memory_typed_address (pc
, func_ptr_type
);
2955 /* If the PLT slot has not yet been resolved, the target will be
2957 if (in_plt_section (pc
, NULL
))
2959 /* Sanity check: are we pointing to the PLT stub? */
2960 if (!hppa_match_insns (gdbarch
, pc
, hppa_plt_stub
, insn
))
2962 warning (_("Cannot resolve PLT stub at %s."),
2963 paddress (gdbarch
, pc
));
2967 /* This should point to the fixup routine. */
2968 pc
= read_memory_typed_address (pc
+ 8, func_ptr_type
);
2976 /* Here is a table of C type sizes on hppa with various compiles
2977 and options. I measured this on PA 9000/800 with HP-UX 11.11
2978 and these compilers:
2980 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2981 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2982 /opt/aCC/bin/aCC B3910B A.03.45
2983 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2985 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2986 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2987 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2988 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2989 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2990 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2991 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2992 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2996 compiler and options
2997 char, short, int, long, long long
2998 float, double, long double
3001 So all these compilers use either ILP32 or LP64 model.
3002 TODO: gcc has more options so it needs more investigation.
3004 For floating point types, see:
3006 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3007 HP-UX floating-point guide, hpux 11.00
3009 -- chastain 2003-12-18 */
3011 static struct gdbarch
*
3012 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3014 struct gdbarch_tdep
*tdep
;
3015 struct gdbarch
*gdbarch
;
3017 /* Try to determine the ABI of the object we are loading. */
3018 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
3020 /* If it's a SOM file, assume it's HP/UX SOM. */
3021 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
3022 info
.osabi
= GDB_OSABI_HPUX_SOM
;
3025 /* find a candidate among the list of pre-declared architectures. */
3026 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3028 return (arches
->gdbarch
);
3030 /* If none found, then allocate and initialize one. */
3031 tdep
= XZALLOC (struct gdbarch_tdep
);
3032 gdbarch
= gdbarch_alloc (&info
, tdep
);
3034 /* Determine from the bfd_arch_info structure if we are dealing with
3035 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3036 then default to a 32bit machine. */
3037 if (info
.bfd_arch_info
!= NULL
)
3038 tdep
->bytes_per_address
=
3039 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3041 tdep
->bytes_per_address
= 4;
3043 tdep
->find_global_pointer
= hppa_find_global_pointer
;
3045 /* Some parts of the gdbarch vector depend on whether we are running
3046 on a 32 bits or 64 bits target. */
3047 switch (tdep
->bytes_per_address
)
3050 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3051 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3052 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3053 set_gdbarch_cannot_store_register (gdbarch
,
3054 hppa32_cannot_store_register
);
3055 set_gdbarch_cannot_fetch_register (gdbarch
,
3056 hppa32_cannot_fetch_register
);
3059 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3060 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3061 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3062 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3063 set_gdbarch_cannot_store_register (gdbarch
,
3064 hppa64_cannot_store_register
);
3065 set_gdbarch_cannot_fetch_register (gdbarch
,
3066 hppa64_cannot_fetch_register
);
3069 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
3070 tdep
->bytes_per_address
);
3073 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3074 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3076 /* The following gdbarch vector elements are the same in both ILP32
3077 and LP64, but might show differences some day. */
3078 set_gdbarch_long_long_bit (gdbarch
, 64);
3079 set_gdbarch_long_double_bit (gdbarch
, 128);
3080 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3082 /* The following gdbarch vector elements do not depend on the address
3083 size, or in any other gdbarch element previously set. */
3084 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3085 set_gdbarch_in_function_epilogue_p (gdbarch
,
3086 hppa_in_function_epilogue_p
);
3087 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
3088 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3089 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3090 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
3091 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
3092 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3093 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
3094 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
3096 /* Helper for function argument information. */
3097 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3099 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
3101 /* When a hardware watchpoint triggers, we'll move the inferior past
3102 it by removing all eventpoints; stepping past the instruction
3103 that caused the trigger; reinserting eventpoints; and checking
3104 whether any watched location changed. */
3105 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3107 /* Inferior function call methods. */
3108 switch (tdep
->bytes_per_address
)
3111 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3112 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3113 set_gdbarch_convert_from_func_ptr_addr
3114 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
3117 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3118 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3121 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3124 /* Struct return methods. */
3125 switch (tdep
->bytes_per_address
)
3128 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3131 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3134 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3137 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
3138 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
3140 /* Frame unwind methods. */
3141 set_gdbarch_dummy_id (gdbarch
, hppa_dummy_id
);
3142 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3144 /* Hook in ABI-specific overrides, if they have been registered. */
3145 gdbarch_init_osabi (info
, gdbarch
);
3147 /* Hook in the default unwinders. */
3148 frame_unwind_append_unwinder (gdbarch
, &hppa_stub_frame_unwind
);
3149 frame_unwind_append_unwinder (gdbarch
, &hppa_frame_unwind
);
3150 frame_unwind_append_unwinder (gdbarch
, &hppa_fallback_frame_unwind
);
3156 hppa_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
3158 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3160 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
3161 tdep
->bytes_per_address
);
3162 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
3165 /* Provide a prototype to silence -Wmissing-prototypes. */
3166 extern initialize_file_ftype _initialize_hppa_tdep
;
3169 _initialize_hppa_tdep (void)
3171 struct cmd_list_element
*c
;
3173 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3175 hppa_objfile_priv_data
= register_objfile_data ();
3177 add_cmd ("unwind", class_maintenance
, unwind_command
,
3178 _("Print unwind table entry at given address."),
3179 &maintenanceprintlist
);
3181 /* Debug this files internals. */
3182 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
3183 Set whether hppa target specific debugging information should be displayed."),
3185 Show whether hppa target specific debugging information is displayed."), _("\
3186 This flag controls whether hppa target specific debugging information is\n\
3187 displayed. This information is particularly useful for debugging frame\n\
3188 unwinding problems."),
3190 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
3191 &setdebuglist
, &showdebuglist
);