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
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 0x%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
, "0x%s (cached) }\n",
500 paddr_nz ((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
, "0x%s }\n",
518 paddr_nz ((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 unsigned long status
;
548 status
= target_read_memory (pc
, buf
, 4);
552 inst
= extract_unsigned_integer (buf
, 4);
554 /* The most common way to perform a stack adjustment ldo X(sp),sp
555 We are destroying a stack frame if the offset is negative. */
556 if ((inst
& 0xffffc000) == 0x37de0000
557 && hppa_extract_14 (inst
) < 0)
560 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
561 if (((inst
& 0x0fc010e0) == 0x0fc010e0
562 || (inst
& 0x0fc010e0) == 0x0fc010e0)
563 && hppa_extract_14 (inst
) < 0)
566 /* bv %r0(%rp) or bv,n %r0(%rp) */
567 if (inst
== 0xe840c000 || inst
== 0xe840c002)
573 static const unsigned char *
574 hppa_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
, int *len
)
576 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
577 (*len
) = sizeof (breakpoint
);
581 /* Return the name of a register. */
584 hppa32_register_name (struct gdbarch
*gdbarch
, int i
)
586 static char *names
[] = {
587 "flags", "r1", "rp", "r3",
588 "r4", "r5", "r6", "r7",
589 "r8", "r9", "r10", "r11",
590 "r12", "r13", "r14", "r15",
591 "r16", "r17", "r18", "r19",
592 "r20", "r21", "r22", "r23",
593 "r24", "r25", "r26", "dp",
594 "ret0", "ret1", "sp", "r31",
595 "sar", "pcoqh", "pcsqh", "pcoqt",
596 "pcsqt", "eiem", "iir", "isr",
597 "ior", "ipsw", "goto", "sr4",
598 "sr0", "sr1", "sr2", "sr3",
599 "sr5", "sr6", "sr7", "cr0",
600 "cr8", "cr9", "ccr", "cr12",
601 "cr13", "cr24", "cr25", "cr26",
602 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
603 "fpsr", "fpe1", "fpe2", "fpe3",
604 "fpe4", "fpe5", "fpe6", "fpe7",
605 "fr4", "fr4R", "fr5", "fr5R",
606 "fr6", "fr6R", "fr7", "fr7R",
607 "fr8", "fr8R", "fr9", "fr9R",
608 "fr10", "fr10R", "fr11", "fr11R",
609 "fr12", "fr12R", "fr13", "fr13R",
610 "fr14", "fr14R", "fr15", "fr15R",
611 "fr16", "fr16R", "fr17", "fr17R",
612 "fr18", "fr18R", "fr19", "fr19R",
613 "fr20", "fr20R", "fr21", "fr21R",
614 "fr22", "fr22R", "fr23", "fr23R",
615 "fr24", "fr24R", "fr25", "fr25R",
616 "fr26", "fr26R", "fr27", "fr27R",
617 "fr28", "fr28R", "fr29", "fr29R",
618 "fr30", "fr30R", "fr31", "fr31R"
620 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
627 hppa64_register_name (struct gdbarch
*gdbarch
, int i
)
629 static char *names
[] = {
630 "flags", "r1", "rp", "r3",
631 "r4", "r5", "r6", "r7",
632 "r8", "r9", "r10", "r11",
633 "r12", "r13", "r14", "r15",
634 "r16", "r17", "r18", "r19",
635 "r20", "r21", "r22", "r23",
636 "r24", "r25", "r26", "dp",
637 "ret0", "ret1", "sp", "r31",
638 "sar", "pcoqh", "pcsqh", "pcoqt",
639 "pcsqt", "eiem", "iir", "isr",
640 "ior", "ipsw", "goto", "sr4",
641 "sr0", "sr1", "sr2", "sr3",
642 "sr5", "sr6", "sr7", "cr0",
643 "cr8", "cr9", "ccr", "cr12",
644 "cr13", "cr24", "cr25", "cr26",
645 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
646 "fpsr", "fpe1", "fpe2", "fpe3",
647 "fr4", "fr5", "fr6", "fr7",
648 "fr8", "fr9", "fr10", "fr11",
649 "fr12", "fr13", "fr14", "fr15",
650 "fr16", "fr17", "fr18", "fr19",
651 "fr20", "fr21", "fr22", "fr23",
652 "fr24", "fr25", "fr26", "fr27",
653 "fr28", "fr29", "fr30", "fr31"
655 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
662 hppa64_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
664 /* r0-r31 and sar map one-to-one. */
668 /* fr4-fr31 are mapped from 72 in steps of 2. */
669 if (reg
>= 72 || reg
< 72 + 28 * 2)
670 return HPPA64_FP4_REGNUM
+ (reg
- 72) / 2;
672 error ("Invalid DWARF register num %d.", reg
);
676 /* This function pushes a stack frame with arguments as part of the
677 inferior function calling mechanism.
679 This is the version of the function for the 32-bit PA machines, in
680 which later arguments appear at lower addresses. (The stack always
681 grows towards higher addresses.)
683 We simply allocate the appropriate amount of stack space and put
684 arguments into their proper slots. */
687 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
688 struct regcache
*regcache
, CORE_ADDR bp_addr
,
689 int nargs
, struct value
**args
, CORE_ADDR sp
,
690 int struct_return
, CORE_ADDR struct_addr
)
692 /* Stack base address at which any pass-by-reference parameters are
694 CORE_ADDR struct_end
= 0;
695 /* Stack base address at which the first parameter is stored. */
696 CORE_ADDR param_end
= 0;
698 /* The inner most end of the stack after all the parameters have
700 CORE_ADDR new_sp
= 0;
702 /* Two passes. First pass computes the location of everything,
703 second pass writes the bytes out. */
706 /* Global pointer (r19) of the function we are trying to call. */
709 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
711 for (write_pass
= 0; write_pass
< 2; write_pass
++)
713 CORE_ADDR struct_ptr
= 0;
714 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
715 struct_ptr is adjusted for each argument below, so the first
716 argument will end up at sp-36. */
717 CORE_ADDR param_ptr
= 32;
719 int small_struct
= 0;
721 for (i
= 0; i
< nargs
; i
++)
723 struct value
*arg
= args
[i
];
724 struct type
*type
= check_typedef (value_type (arg
));
725 /* The corresponding parameter that is pushed onto the
726 stack, and [possibly] passed in a register. */
729 memset (param_val
, 0, sizeof param_val
);
730 if (TYPE_LENGTH (type
) > 8)
732 /* Large parameter, pass by reference. Store the value
733 in "struct" area and then pass its address. */
735 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
737 write_memory (struct_end
- struct_ptr
, value_contents (arg
),
739 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
741 else if (TYPE_CODE (type
) == TYPE_CODE_INT
742 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
744 /* Integer value store, right aligned. "unpack_long"
745 takes care of any sign-extension problems. */
746 param_len
= align_up (TYPE_LENGTH (type
), 4);
747 store_unsigned_integer (param_val
, param_len
,
749 value_contents (arg
)));
751 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
753 /* Floating point value store, right aligned. */
754 param_len
= align_up (TYPE_LENGTH (type
), 4);
755 memcpy (param_val
, value_contents (arg
), param_len
);
759 param_len
= align_up (TYPE_LENGTH (type
), 4);
761 /* Small struct value are stored right-aligned. */
762 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
763 value_contents (arg
), TYPE_LENGTH (type
));
765 /* Structures of size 5, 6 and 7 bytes are special in that
766 the higher-ordered word is stored in the lower-ordered
767 argument, and even though it is a 8-byte quantity the
768 registers need not be 8-byte aligned. */
769 if (param_len
> 4 && param_len
< 8)
773 param_ptr
+= param_len
;
774 if (param_len
== 8 && !small_struct
)
775 param_ptr
= align_up (param_ptr
, 8);
777 /* First 4 non-FP arguments are passed in gr26-gr23.
778 First 4 32-bit FP arguments are passed in fr4L-fr7L.
779 First 2 64-bit FP arguments are passed in fr5 and fr7.
781 The rest go on the stack, starting at sp-36, towards lower
782 addresses. 8-byte arguments must be aligned to a 8-byte
786 write_memory (param_end
- param_ptr
, param_val
, param_len
);
788 /* There are some cases when we don't know the type
789 expected by the callee (e.g. for variadic functions), so
790 pass the parameters in both general and fp regs. */
793 int grreg
= 26 - (param_ptr
- 36) / 4;
794 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
795 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
797 regcache_cooked_write (regcache
, grreg
, param_val
);
798 regcache_cooked_write (regcache
, fpLreg
, param_val
);
802 regcache_cooked_write (regcache
, grreg
+ 1,
805 regcache_cooked_write (regcache
, fpreg
, param_val
);
806 regcache_cooked_write (regcache
, fpreg
+ 1,
813 /* Update the various stack pointers. */
816 struct_end
= sp
+ align_up (struct_ptr
, 64);
817 /* PARAM_PTR already accounts for all the arguments passed
818 by the user. However, the ABI mandates minimum stack
819 space allocations for outgoing arguments. The ABI also
820 mandates minimum stack alignments which we must
822 param_end
= struct_end
+ align_up (param_ptr
, 64);
826 /* If a structure has to be returned, set up register 28 to hold its
829 regcache_cooked_write_unsigned (regcache
, 28, struct_addr
);
831 gp
= tdep
->find_global_pointer (gdbarch
, function
);
834 regcache_cooked_write_unsigned (regcache
, 19, gp
);
836 /* Set the return address. */
837 if (!gdbarch_push_dummy_code_p (gdbarch
))
838 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
840 /* Update the Stack Pointer. */
841 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
846 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
847 Runtime Architecture for PA-RISC 2.0", which is distributed as part
848 as of the HP-UX Software Transition Kit (STK). This implementation
849 is based on version 3.3, dated October 6, 1997. */
851 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
854 hppa64_integral_or_pointer_p (const struct type
*type
)
856 switch (TYPE_CODE (type
))
862 case TYPE_CODE_RANGE
:
864 int len
= TYPE_LENGTH (type
);
865 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
869 return (TYPE_LENGTH (type
) == 8);
877 /* Check whether TYPE is a "Floating Scalar Type". */
880 hppa64_floating_p (const struct type
*type
)
882 switch (TYPE_CODE (type
))
886 int len
= TYPE_LENGTH (type
);
887 return (len
== 4 || len
== 8 || len
== 16);
896 /* If CODE points to a function entry address, try to look up the corresponding
897 function descriptor and return its address instead. If CODE is not a
898 function entry address, then just return it unchanged. */
900 hppa64_convert_code_addr_to_fptr (CORE_ADDR code
)
902 struct obj_section
*sec
, *opd
;
904 sec
= find_pc_section (code
);
909 /* If CODE is in a data section, assume it's already a fptr. */
910 if (!(sec
->the_bfd_section
->flags
& SEC_CODE
))
913 ALL_OBJFILE_OSECTIONS (sec
->objfile
, opd
)
915 if (strcmp (opd
->the_bfd_section
->name
, ".opd") == 0)
919 if (opd
< sec
->objfile
->sections_end
)
923 for (addr
= obj_section_addr (opd
);
924 addr
< obj_section_endaddr (opd
);
930 if (target_read_memory (addr
, tmp
, sizeof (tmp
)))
932 opdaddr
= extract_unsigned_integer (tmp
, sizeof (tmp
));
943 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
944 struct regcache
*regcache
, CORE_ADDR bp_addr
,
945 int nargs
, struct value
**args
, CORE_ADDR sp
,
946 int struct_return
, CORE_ADDR struct_addr
)
948 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
952 /* "The outgoing parameter area [...] must be aligned at a 16-byte
954 sp
= align_up (sp
, 16);
956 for (i
= 0; i
< nargs
; i
++)
958 struct value
*arg
= args
[i
];
959 struct type
*type
= value_type (arg
);
960 int len
= TYPE_LENGTH (type
);
961 const bfd_byte
*valbuf
;
965 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
966 offset
= align_up (offset
, 8);
968 if (hppa64_integral_or_pointer_p (type
))
970 /* "Integral scalar parameters smaller than 64 bits are
971 padded on the left (i.e., the value is in the
972 least-significant bits of the 64-bit storage unit, and
973 the high-order bits are undefined)." Therefore we can
974 safely sign-extend them. */
977 arg
= value_cast (builtin_type_int64
, arg
);
981 else if (hppa64_floating_p (type
))
985 /* "Quad-precision (128-bit) floating-point scalar
986 parameters are aligned on a 16-byte boundary." */
987 offset
= align_up (offset
, 16);
989 /* "Double-extended- and quad-precision floating-point
990 parameters within the first 64 bytes of the parameter
991 list are always passed in general registers." */
997 /* "Single-precision (32-bit) floating-point scalar
998 parameters are padded on the left with 32 bits of
999 garbage (i.e., the floating-point value is in the
1000 least-significant 32 bits of a 64-bit storage
1005 /* "Single- and double-precision floating-point
1006 parameters in this area are passed according to the
1007 available formal parameter information in a function
1008 prototype. [...] If no prototype is in scope,
1009 floating-point parameters must be passed both in the
1010 corresponding general registers and in the
1011 corresponding floating-point registers." */
1012 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
1014 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
1016 /* "Single-precision floating-point parameters, when
1017 passed in floating-point registers, are passed in
1018 the right halves of the floating point registers;
1019 the left halves are unused." */
1020 regcache_cooked_write_part (regcache
, regnum
, offset
% 8,
1021 len
, value_contents (arg
));
1029 /* "Aggregates larger than 8 bytes are aligned on a
1030 16-byte boundary, possibly leaving an unused argument
1031 slot, which is filled with garbage. If necessary,
1032 they are padded on the right (with garbage), to a
1033 multiple of 8 bytes." */
1034 offset
= align_up (offset
, 16);
1038 /* If we are passing a function pointer, make sure we pass a function
1039 descriptor instead of the function entry address. */
1040 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1041 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1043 ULONGEST codeptr
, fptr
;
1045 codeptr
= unpack_long (type
, value_contents (arg
));
1046 fptr
= hppa64_convert_code_addr_to_fptr (codeptr
);
1047 store_unsigned_integer (fptrbuf
, TYPE_LENGTH (type
), fptr
);
1052 valbuf
= value_contents (arg
);
1055 /* Always store the argument in memory. */
1056 write_memory (sp
+ offset
, valbuf
, len
);
1058 regnum
= HPPA_ARG0_REGNUM
- offset
/ 8;
1059 while (regnum
> HPPA_ARG0_REGNUM
- 8 && len
> 0)
1061 regcache_cooked_write_part (regcache
, regnum
,
1062 offset
% 8, min (len
, 8), valbuf
);
1063 offset
+= min (len
, 8);
1064 valbuf
+= min (len
, 8);
1065 len
-= min (len
, 8);
1072 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1073 regcache_cooked_write_unsigned (regcache
, HPPA_RET1_REGNUM
, sp
+ 64);
1075 /* Allocate the outgoing parameter area. Make sure the outgoing
1076 parameter area is multiple of 16 bytes in length. */
1077 sp
+= max (align_up (offset
, 16), 64);
1079 /* Allocate 32-bytes of scratch space. The documentation doesn't
1080 mention this, but it seems to be needed. */
1083 /* Allocate the frame marker area. */
1086 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1089 regcache_cooked_write_unsigned (regcache
, HPPA_RET0_REGNUM
, struct_addr
);
1091 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1092 gp
= tdep
->find_global_pointer (gdbarch
, function
);
1094 regcache_cooked_write_unsigned (regcache
, HPPA_DP_REGNUM
, gp
);
1096 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1097 if (!gdbarch_push_dummy_code_p (gdbarch
))
1098 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1100 /* Set up GR30 to hold the stack pointer (sp). */
1101 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, sp
);
1107 /* Handle 32/64-bit struct return conventions. */
1109 static enum return_value_convention
1110 hppa32_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
1111 struct type
*type
, struct regcache
*regcache
,
1112 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1114 if (TYPE_LENGTH (type
) <= 2 * 4)
1116 /* The value always lives in the right hand end of the register
1117 (or register pair)? */
1119 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
1120 int part
= TYPE_LENGTH (type
) % 4;
1121 /* The left hand register contains only part of the value,
1122 transfer that first so that the rest can be xfered as entire
1123 4-byte registers. */
1126 if (readbuf
!= NULL
)
1127 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
1129 if (writebuf
!= NULL
)
1130 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
1134 /* Now transfer the remaining register values. */
1135 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
1137 if (readbuf
!= NULL
)
1138 regcache_cooked_read (regcache
, reg
, readbuf
+ b
);
1139 if (writebuf
!= NULL
)
1140 regcache_cooked_write (regcache
, reg
, writebuf
+ b
);
1143 return RETURN_VALUE_REGISTER_CONVENTION
;
1146 return RETURN_VALUE_STRUCT_CONVENTION
;
1149 static enum return_value_convention
1150 hppa64_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
1151 struct type
*type
, struct regcache
*regcache
,
1152 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1154 int len
= TYPE_LENGTH (type
);
1159 /* All return values larget than 128 bits must be aggregate
1161 gdb_assert (!hppa64_integral_or_pointer_p (type
));
1162 gdb_assert (!hppa64_floating_p (type
));
1164 /* "Aggregate return values larger than 128 bits are returned in
1165 a buffer allocated by the caller. The address of the buffer
1166 must be passed in GR 28." */
1167 return RETURN_VALUE_STRUCT_CONVENTION
;
1170 if (hppa64_integral_or_pointer_p (type
))
1172 /* "Integral return values are returned in GR 28. Values
1173 smaller than 64 bits are padded on the left (with garbage)." */
1174 regnum
= HPPA_RET0_REGNUM
;
1177 else if (hppa64_floating_p (type
))
1181 /* "Double-extended- and quad-precision floating-point
1182 values are returned in GRs 28 and 29. The sign,
1183 exponent, and most-significant bits of the mantissa are
1184 returned in GR 28; the least-significant bits of the
1185 mantissa are passed in GR 29. For double-extended
1186 precision values, GR 29 is padded on the right with 48
1187 bits of garbage." */
1188 regnum
= HPPA_RET0_REGNUM
;
1193 /* "Single-precision and double-precision floating-point
1194 return values are returned in FR 4R (single precision) or
1195 FR 4 (double-precision)." */
1196 regnum
= HPPA64_FP4_REGNUM
;
1202 /* "Aggregate return values up to 64 bits in size are returned
1203 in GR 28. Aggregates smaller than 64 bits are left aligned
1204 in the register; the pad bits on the right are undefined."
1206 "Aggregate return values between 65 and 128 bits are returned
1207 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1208 the remaining bits are placed, left aligned, in GR 29. The
1209 pad bits on the right of GR 29 (if any) are undefined." */
1210 regnum
= HPPA_RET0_REGNUM
;
1218 regcache_cooked_read_part (regcache
, regnum
, offset
,
1219 min (len
, 8), readbuf
);
1220 readbuf
+= min (len
, 8);
1221 len
-= min (len
, 8);
1230 regcache_cooked_write_part (regcache
, regnum
, offset
,
1231 min (len
, 8), writebuf
);
1232 writebuf
+= min (len
, 8);
1233 len
-= min (len
, 8);
1238 return RETURN_VALUE_REGISTER_CONVENTION
;
1243 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1244 struct target_ops
*targ
)
1248 CORE_ADDR plabel
= addr
& ~3;
1249 return read_memory_typed_address (plabel
, builtin_type_void_func_ptr
);
1256 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1258 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1260 return align_up (addr
, 64);
1263 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1266 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1268 /* Just always 16-byte align. */
1269 return align_up (addr
, 16);
1273 hppa_read_pc (struct regcache
*regcache
)
1278 regcache_cooked_read_unsigned (regcache
, HPPA_IPSW_REGNUM
, &ipsw
);
1279 regcache_cooked_read_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, &pc
);
1281 /* If the current instruction is nullified, then we are effectively
1282 still executing the previous instruction. Pretend we are still
1283 there. This is needed when single stepping; if the nullified
1284 instruction is on a different line, we don't want GDB to think
1285 we've stepped onto that line. */
1286 if (ipsw
& 0x00200000)
1293 hppa_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1295 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pc
);
1296 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4);
1299 /* return the alignment of a type in bytes. Structures have the maximum
1300 alignment required by their fields. */
1303 hppa_alignof (struct type
*type
)
1305 int max_align
, align
, i
;
1306 CHECK_TYPEDEF (type
);
1307 switch (TYPE_CODE (type
))
1312 return TYPE_LENGTH (type
);
1313 case TYPE_CODE_ARRAY
:
1314 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1315 case TYPE_CODE_STRUCT
:
1316 case TYPE_CODE_UNION
:
1318 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1320 /* Bit fields have no real alignment. */
1321 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1322 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1324 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1325 max_align
= max (max_align
, align
);
1334 /* For the given instruction (INST), return any adjustment it makes
1335 to the stack pointer or zero for no adjustment.
1337 This only handles instructions commonly found in prologues. */
1340 prologue_inst_adjust_sp (unsigned long inst
)
1342 /* This must persist across calls. */
1343 static int save_high21
;
1345 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1346 if ((inst
& 0xffffc000) == 0x37de0000)
1347 return hppa_extract_14 (inst
);
1350 if ((inst
& 0xffe00000) == 0x6fc00000)
1351 return hppa_extract_14 (inst
);
1353 /* std,ma X,D(sp) */
1354 if ((inst
& 0xffe00008) == 0x73c00008)
1355 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1357 /* addil high21,%r30; ldo low11,(%r1),%r30)
1358 save high bits in save_high21 for later use. */
1359 if ((inst
& 0xffe00000) == 0x2bc00000)
1361 save_high21
= hppa_extract_21 (inst
);
1365 if ((inst
& 0xffff0000) == 0x343e0000)
1366 return save_high21
+ hppa_extract_14 (inst
);
1368 /* fstws as used by the HP compilers. */
1369 if ((inst
& 0xffffffe0) == 0x2fd01220)
1370 return hppa_extract_5_load (inst
);
1372 /* No adjustment. */
1376 /* Return nonzero if INST is a branch of some kind, else return zero. */
1379 is_branch (unsigned long inst
)
1408 /* Return the register number for a GR which is saved by INST or
1409 zero it INST does not save a GR. */
1412 inst_saves_gr (unsigned long inst
)
1414 /* Does it look like a stw? */
1415 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1416 || (inst
>> 26) == 0x1f
1417 || ((inst
>> 26) == 0x1f
1418 && ((inst
>> 6) == 0xa)))
1419 return hppa_extract_5R_store (inst
);
1421 /* Does it look like a std? */
1422 if ((inst
>> 26) == 0x1c
1423 || ((inst
>> 26) == 0x03
1424 && ((inst
>> 6) & 0xf) == 0xb))
1425 return hppa_extract_5R_store (inst
);
1427 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1428 if ((inst
>> 26) == 0x1b)
1429 return hppa_extract_5R_store (inst
);
1431 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1433 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1434 || ((inst
>> 26) == 0x3
1435 && (((inst
>> 6) & 0xf) == 0x8
1436 || (inst
>> 6) & 0xf) == 0x9))
1437 return hppa_extract_5R_store (inst
);
1442 /* Return the register number for a FR which is saved by INST or
1443 zero it INST does not save a FR.
1445 Note we only care about full 64bit register stores (that's the only
1446 kind of stores the prologue will use).
1448 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1451 inst_saves_fr (unsigned long inst
)
1453 /* is this an FSTD ? */
1454 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1455 return hppa_extract_5r_store (inst
);
1456 if ((inst
& 0xfc000002) == 0x70000002)
1457 return hppa_extract_5R_store (inst
);
1458 /* is this an FSTW ? */
1459 if ((inst
& 0xfc00df80) == 0x24001200)
1460 return hppa_extract_5r_store (inst
);
1461 if ((inst
& 0xfc000002) == 0x7c000000)
1462 return hppa_extract_5R_store (inst
);
1466 /* Advance PC across any function entry prologue instructions
1467 to reach some "real" code.
1469 Use information in the unwind table to determine what exactly should
1470 be in the prologue. */
1474 skip_prologue_hard_way (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1475 int stop_before_branch
)
1478 CORE_ADDR orig_pc
= pc
;
1479 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1480 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1481 struct unwind_table_entry
*u
;
1482 int final_iteration
;
1488 u
= find_unwind_entry (pc
);
1492 /* If we are not at the beginning of a function, then return now. */
1493 if ((pc
& ~0x3) != u
->region_start
)
1496 /* This is how much of a frame adjustment we need to account for. */
1497 stack_remaining
= u
->Total_frame_size
<< 3;
1499 /* Magic register saves we want to know about. */
1500 save_rp
= u
->Save_RP
;
1501 save_sp
= u
->Save_SP
;
1503 /* An indication that args may be stored into the stack. Unfortunately
1504 the HPUX compilers tend to set this in cases where no args were
1508 /* Turn the Entry_GR field into a bitmask. */
1510 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1512 /* Frame pointer gets saved into a special location. */
1513 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1516 save_gr
|= (1 << i
);
1518 save_gr
&= ~restart_gr
;
1520 /* Turn the Entry_FR field into a bitmask too. */
1522 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1523 save_fr
|= (1 << i
);
1524 save_fr
&= ~restart_fr
;
1526 final_iteration
= 0;
1528 /* Loop until we find everything of interest or hit a branch.
1530 For unoptimized GCC code and for any HP CC code this will never ever
1531 examine any user instructions.
1533 For optimzied GCC code we're faced with problems. GCC will schedule
1534 its prologue and make prologue instructions available for delay slot
1535 filling. The end result is user code gets mixed in with the prologue
1536 and a prologue instruction may be in the delay slot of the first branch
1539 Some unexpected things are expected with debugging optimized code, so
1540 we allow this routine to walk past user instructions in optimized
1542 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1545 unsigned int reg_num
;
1546 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1547 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1549 /* Save copies of all the triggers so we can compare them later
1551 old_save_gr
= save_gr
;
1552 old_save_fr
= save_fr
;
1553 old_save_rp
= save_rp
;
1554 old_save_sp
= save_sp
;
1555 old_stack_remaining
= stack_remaining
;
1557 status
= target_read_memory (pc
, buf
, 4);
1558 inst
= extract_unsigned_integer (buf
, 4);
1564 /* Note the interesting effects of this instruction. */
1565 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1567 /* There are limited ways to store the return pointer into the
1569 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1572 /* These are the only ways we save SP into the stack. At this time
1573 the HP compilers never bother to save SP into the stack. */
1574 if ((inst
& 0xffffc000) == 0x6fc10000
1575 || (inst
& 0xffffc00c) == 0x73c10008)
1578 /* Are we loading some register with an offset from the argument
1580 if ((inst
& 0xffe00000) == 0x37a00000
1581 || (inst
& 0xffffffe0) == 0x081d0240)
1587 /* Account for general and floating-point register saves. */
1588 reg_num
= inst_saves_gr (inst
);
1589 save_gr
&= ~(1 << reg_num
);
1591 /* Ugh. Also account for argument stores into the stack.
1592 Unfortunately args_stored only tells us that some arguments
1593 where stored into the stack. Not how many or what kind!
1595 This is a kludge as on the HP compiler sets this bit and it
1596 never does prologue scheduling. So once we see one, skip past
1597 all of them. We have similar code for the fp arg stores below.
1599 FIXME. Can still die if we have a mix of GR and FR argument
1601 if (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1604 while (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1608 status
= target_read_memory (pc
, buf
, 4);
1609 inst
= extract_unsigned_integer (buf
, 4);
1612 reg_num
= inst_saves_gr (inst
);
1618 reg_num
= inst_saves_fr (inst
);
1619 save_fr
&= ~(1 << reg_num
);
1621 status
= target_read_memory (pc
+ 4, buf
, 4);
1622 next_inst
= extract_unsigned_integer (buf
, 4);
1628 /* We've got to be read to handle the ldo before the fp register
1630 if ((inst
& 0xfc000000) == 0x34000000
1631 && inst_saves_fr (next_inst
) >= 4
1632 && inst_saves_fr (next_inst
)
1633 <= (gdbarch_ptr_bit (gdbarch
) == 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
1645 && reg_num
<= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1649 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1652 status
= target_read_memory (pc
, buf
, 4);
1653 inst
= extract_unsigned_integer (buf
, 4);
1656 if ((inst
& 0xfc000000) != 0x34000000)
1658 status
= target_read_memory (pc
+ 4, buf
, 4);
1659 next_inst
= extract_unsigned_integer (buf
, 4);
1662 reg_num
= inst_saves_fr (next_inst
);
1668 /* Quit if we hit any kind of branch. This can happen if a prologue
1669 instruction is in the delay slot of the first call/branch. */
1670 if (is_branch (inst
) && stop_before_branch
)
1673 /* What a crock. The HP compilers set args_stored even if no
1674 arguments were stored into the stack (boo hiss). This could
1675 cause this code to then skip a bunch of user insns (up to the
1678 To combat this we try to identify when args_stored was bogusly
1679 set and clear it. We only do this when args_stored is nonzero,
1680 all other resources are accounted for, and nothing changed on
1683 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1684 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1685 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1686 && old_stack_remaining
== stack_remaining
)
1692 /* !stop_before_branch, so also look at the insn in the delay slot
1694 if (final_iteration
)
1696 if (is_branch (inst
))
1697 final_iteration
= 1;
1700 /* We've got a tenative location for the end of the prologue. However
1701 because of limitations in the unwind descriptor mechanism we may
1702 have went too far into user code looking for the save of a register
1703 that does not exist. So, if there registers we expected to be saved
1704 but never were, mask them out and restart.
1706 This should only happen in optimized code, and should be very rare. */
1707 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1710 restart_gr
= save_gr
;
1711 restart_fr
= save_fr
;
1719 /* Return the address of the PC after the last prologue instruction if
1720 we can determine it from the debug symbols. Else return zero. */
1723 after_prologue (CORE_ADDR pc
)
1725 struct symtab_and_line sal
;
1726 CORE_ADDR func_addr
, func_end
;
1729 /* If we can not find the symbol in the partial symbol table, then
1730 there is no hope we can determine the function's start address
1732 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1735 /* Get the line associated with FUNC_ADDR. */
1736 sal
= find_pc_line (func_addr
, 0);
1738 /* There are only two cases to consider. First, the end of the source line
1739 is within the function bounds. In that case we return the end of the
1740 source line. Second is the end of the source line extends beyond the
1741 bounds of the current function. We need to use the slow code to
1742 examine instructions in that case.
1744 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1745 the wrong thing to do. In fact, it should be entirely possible for this
1746 function to always return zero since the slow instruction scanning code
1747 is supposed to *always* work. If it does not, then it is a bug. */
1748 if (sal
.end
< func_end
)
1754 /* To skip prologues, I use this predicate. Returns either PC itself
1755 if the code at PC does not look like a function prologue; otherwise
1756 returns an address that (if we're lucky) follows the prologue.
1758 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1759 It doesn't necessarily skips all the insns in the prologue. In fact
1760 we might not want to skip all the insns because a prologue insn may
1761 appear in the delay slot of the first branch, and we don't want to
1762 skip over the branch in that case. */
1765 hppa_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1769 CORE_ADDR post_prologue_pc
;
1772 /* See if we can determine the end of the prologue via the symbol table.
1773 If so, then return either PC, or the PC after the prologue, whichever
1776 post_prologue_pc
= after_prologue (pc
);
1778 /* If after_prologue returned a useful address, then use it. Else
1779 fall back on the instruction skipping code.
1781 Some folks have claimed this causes problems because the breakpoint
1782 may be the first instruction of the prologue. If that happens, then
1783 the instruction skipping code has a bug that needs to be fixed. */
1784 if (post_prologue_pc
!= 0)
1785 return max (pc
, post_prologue_pc
);
1787 return (skip_prologue_hard_way (gdbarch
, pc
, 1));
1790 /* Return an unwind entry that falls within the frame's code block. */
1792 static struct unwind_table_entry
*
1793 hppa_find_unwind_entry_in_block (struct frame_info
*this_frame
)
1795 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
1797 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1798 result of get_frame_address_in_block implies a problem.
1799 The bits should have been removed earlier, before the return
1800 value of frame_pc_unwind. That might be happening already;
1801 if it isn't, it should be fixed. Then this call can be
1803 pc
= gdbarch_addr_bits_remove (get_frame_arch (this_frame
), pc
);
1804 return find_unwind_entry (pc
);
1807 struct hppa_frame_cache
1810 struct trad_frame_saved_reg
*saved_regs
;
1813 static struct hppa_frame_cache
*
1814 hppa_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1816 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1817 struct hppa_frame_cache
*cache
;
1822 struct unwind_table_entry
*u
;
1823 CORE_ADDR prologue_end
;
1828 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1829 frame_relative_level(this_frame
));
1831 if ((*this_cache
) != NULL
)
1834 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1835 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1836 return (*this_cache
);
1838 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1839 (*this_cache
) = cache
;
1840 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1843 u
= hppa_find_unwind_entry_in_block (this_frame
);
1847 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1848 return (*this_cache
);
1851 /* Turn the Entry_GR field into a bitmask. */
1853 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1855 /* Frame pointer gets saved into a special location. */
1856 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1859 saved_gr_mask
|= (1 << i
);
1862 /* Turn the Entry_FR field into a bitmask too. */
1864 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1865 saved_fr_mask
|= (1 << i
);
1867 /* Loop until we find everything of interest or hit a branch.
1869 For unoptimized GCC code and for any HP CC code this will never ever
1870 examine any user instructions.
1872 For optimized GCC code we're faced with problems. GCC will schedule
1873 its prologue and make prologue instructions available for delay slot
1874 filling. The end result is user code gets mixed in with the prologue
1875 and a prologue instruction may be in the delay slot of the first branch
1878 Some unexpected things are expected with debugging optimized code, so
1879 we allow this routine to walk past user instructions in optimized
1882 int final_iteration
= 0;
1883 CORE_ADDR pc
, start_pc
, end_pc
;
1884 int looking_for_sp
= u
->Save_SP
;
1885 int looking_for_rp
= u
->Save_RP
;
1888 /* We have to use skip_prologue_hard_way instead of just
1889 skip_prologue_using_sal, in case we stepped into a function without
1890 symbol information. hppa_skip_prologue also bounds the returned
1891 pc by the passed in pc, so it will not return a pc in the next
1894 We used to call hppa_skip_prologue to find the end of the prologue,
1895 but if some non-prologue instructions get scheduled into the prologue,
1896 and the program is compiled with debug information, the "easy" way
1897 in hppa_skip_prologue will return a prologue end that is too early
1898 for us to notice any potential frame adjustments. */
1900 /* We used to use get_frame_func to locate the beginning of the
1901 function to pass to skip_prologue. However, when objects are
1902 compiled without debug symbols, get_frame_func can return the wrong
1903 function (or 0). We can do better than that by using unwind records.
1904 This only works if the Region_description of the unwind record
1905 indicates that it includes the entry point of the function.
1906 HP compilers sometimes generate unwind records for regions that
1907 do not include the entry or exit point of a function. GNU tools
1910 if ((u
->Region_description
& 0x2) == 0)
1911 start_pc
= u
->region_start
;
1913 start_pc
= get_frame_func (this_frame
);
1915 prologue_end
= skip_prologue_hard_way (gdbarch
, start_pc
, 0);
1916 end_pc
= get_frame_pc (this_frame
);
1918 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1919 end_pc
= prologue_end
;
1924 ((saved_gr_mask
|| saved_fr_mask
1925 || looking_for_sp
|| looking_for_rp
1926 || frame_size
< (u
->Total_frame_size
<< 3))
1934 if (!safe_frame_unwind_memory (this_frame
, pc
, buf4
, sizeof buf4
))
1936 error (_("Cannot read instruction at 0x%s."), paddr_nz (pc
));
1937 return (*this_cache
);
1940 inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1942 /* Note the interesting effects of this instruction. */
1943 frame_size
+= prologue_inst_adjust_sp (inst
);
1945 /* There are limited ways to store the return pointer into the
1947 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1950 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1952 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1955 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1957 else if (inst
== 0x0fc212c1
1958 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1961 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1964 /* Check to see if we saved SP into the stack. This also
1965 happens to indicate the location of the saved frame
1967 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1968 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1971 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1973 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1978 /* Account for general and floating-point register saves. */
1979 reg
= inst_saves_gr (inst
);
1980 if (reg
>= 3 && reg
<= 18
1981 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1983 saved_gr_mask
&= ~(1 << reg
);
1984 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1985 /* stwm with a positive displacement is a _post_
1987 cache
->saved_regs
[reg
].addr
= 0;
1988 else if ((inst
& 0xfc00000c) == 0x70000008)
1989 /* A std has explicit post_modify forms. */
1990 cache
->saved_regs
[reg
].addr
= 0;
1995 if ((inst
>> 26) == 0x1c)
1996 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1997 else if ((inst
>> 26) == 0x03)
1998 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
2000 offset
= hppa_extract_14 (inst
);
2002 /* Handle code with and without frame pointers. */
2004 cache
->saved_regs
[reg
].addr
= offset
;
2006 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
2010 /* GCC handles callee saved FP regs a little differently.
2012 It emits an instruction to put the value of the start of
2013 the FP store area into %r1. It then uses fstds,ma with a
2014 basereg of %r1 for the stores.
2016 HP CC emits them at the current stack pointer modifying the
2017 stack pointer as it stores each register. */
2019 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2020 if ((inst
& 0xffffc000) == 0x34610000
2021 || (inst
& 0xffffc000) == 0x37c10000)
2022 fp_loc
= hppa_extract_14 (inst
);
2024 reg
= inst_saves_fr (inst
);
2025 if (reg
>= 12 && reg
<= 21)
2027 /* Note +4 braindamage below is necessary because the FP
2028 status registers are internally 8 registers rather than
2029 the expected 4 registers. */
2030 saved_fr_mask
&= ~(1 << reg
);
2033 /* 1st HP CC FP register store. After this
2034 instruction we've set enough state that the GCC and
2035 HPCC code are both handled in the same manner. */
2036 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
2041 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
2046 /* Quit if we hit any kind of branch the previous iteration. */
2047 if (final_iteration
)
2049 /* We want to look precisely one instruction beyond the branch
2050 if we have not found everything yet. */
2051 if (is_branch (inst
))
2052 final_iteration
= 1;
2057 /* The frame base always represents the value of %sp at entry to
2058 the current function (and is thus equivalent to the "saved"
2060 CORE_ADDR this_sp
= get_frame_register_unsigned (this_frame
,
2065 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
2066 "prologue_end=0x%s) ",
2068 paddr_nz (get_frame_pc (this_frame
)),
2069 paddr_nz (prologue_end
));
2071 /* Check to see if a frame pointer is available, and use it for
2072 frame unwinding if it is.
2074 There are some situations where we need to rely on the frame
2075 pointer to do stack unwinding. For example, if a function calls
2076 alloca (), the stack pointer can get adjusted inside the body of
2077 the function. In this case, the ABI requires that the compiler
2078 maintain a frame pointer for the function.
2080 The unwind record has a flag (alloca_frame) that indicates that
2081 a function has a variable frame; unfortunately, gcc/binutils
2082 does not set this flag. Instead, whenever a frame pointer is used
2083 and saved on the stack, the Save_SP flag is set. We use this to
2084 decide whether to use the frame pointer for unwinding.
2086 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2087 instead of Save_SP. */
2089 fp
= get_frame_register_unsigned (this_frame
, HPPA_FP_REGNUM
);
2091 if (u
->alloca_frame
)
2092 fp
-= u
->Total_frame_size
<< 3;
2094 if (get_frame_pc (this_frame
) >= prologue_end
2095 && (u
->Save_SP
|| u
->alloca_frame
) && fp
!= 0)
2100 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer]",
2101 paddr_nz (cache
->base
));
2104 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
2106 /* Both we're expecting the SP to be saved and the SP has been
2107 saved. The entry SP value is saved at this frame's SP
2109 cache
->base
= read_memory_integer
2110 (this_sp
, gdbarch_ptr_bit (gdbarch
) / 8);
2113 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved]",
2114 paddr_nz (cache
->base
));
2118 /* The prologue has been slowly allocating stack space. Adjust
2120 cache
->base
= this_sp
- frame_size
;
2122 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust]",
2123 paddr_nz (cache
->base
));
2126 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2129 /* The PC is found in the "return register", "Millicode" uses "r31"
2130 as the return register while normal code uses "rp". */
2133 if (trad_frame_addr_p (cache
->saved_regs
, 31))
2135 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2137 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2141 ULONGEST r31
= get_frame_register_unsigned (this_frame
, 31);
2142 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
2144 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2149 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2151 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2152 cache
->saved_regs
[HPPA_RP_REGNUM
];
2154 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2158 ULONGEST rp
= get_frame_register_unsigned (this_frame
,
2160 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2162 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2166 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2167 frame. However, there is a one-insn window where we haven't saved it
2168 yet, but we've already clobbered it. Detect this case and fix it up.
2170 The prologue sequence for frame-pointer functions is:
2171 0: stw %rp, -20(%sp)
2174 c: stw,ma %r1, XX(%sp)
2176 So if we are at offset c, the r3 value that we want is not yet saved
2177 on the stack, but it's been overwritten. The prologue analyzer will
2178 set fp_in_r1 when it sees the copy insn so we know to get the value
2180 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
2183 ULONGEST r1
= get_frame_register_unsigned (this_frame
, 1);
2184 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
2188 /* Convert all the offsets into addresses. */
2190 for (reg
= 0; reg
< gdbarch_num_regs (gdbarch
); reg
++)
2192 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
2193 cache
->saved_regs
[reg
].addr
+= cache
->base
;
2198 struct gdbarch_tdep
*tdep
;
2200 tdep
= gdbarch_tdep (gdbarch
);
2202 if (tdep
->unwind_adjust_stub
)
2203 tdep
->unwind_adjust_stub (this_frame
, cache
->base
, cache
->saved_regs
);
2207 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
2208 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
2209 return (*this_cache
);
2213 hppa_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2214 struct frame_id
*this_id
)
2216 struct hppa_frame_cache
*info
;
2217 CORE_ADDR pc
= get_frame_pc (this_frame
);
2218 struct unwind_table_entry
*u
;
2220 info
= hppa_frame_cache (this_frame
, this_cache
);
2221 u
= hppa_find_unwind_entry_in_block (this_frame
);
2223 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2226 static struct value
*
2227 hppa_frame_prev_register (struct frame_info
*this_frame
,
2228 void **this_cache
, int regnum
)
2230 struct hppa_frame_cache
*info
= hppa_frame_cache (this_frame
, this_cache
);
2232 return hppa_frame_prev_register_helper (this_frame
, info
->saved_regs
, regnum
);
2236 hppa_frame_unwind_sniffer (const struct frame_unwind
*self
,
2237 struct frame_info
*this_frame
, void **this_cache
)
2239 if (hppa_find_unwind_entry_in_block (this_frame
))
2245 static const struct frame_unwind hppa_frame_unwind
=
2249 hppa_frame_prev_register
,
2251 hppa_frame_unwind_sniffer
2254 /* This is a generic fallback frame unwinder that kicks in if we fail all
2255 the other ones. Normally we would expect the stub and regular unwinder
2256 to work, but in some cases we might hit a function that just doesn't
2257 have any unwind information available. In this case we try to do
2258 unwinding solely based on code reading. This is obviously going to be
2259 slow, so only use this as a last resort. Currently this will only
2260 identify the stack and pc for the frame. */
2262 static struct hppa_frame_cache
*
2263 hppa_fallback_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
2265 struct hppa_frame_cache
*cache
;
2266 unsigned int frame_size
= 0;
2271 fprintf_unfiltered (gdb_stdlog
,
2272 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2273 frame_relative_level (this_frame
));
2275 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2276 (*this_cache
) = cache
;
2277 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2279 start_pc
= get_frame_func (this_frame
);
2282 CORE_ADDR cur_pc
= get_frame_pc (this_frame
);
2285 for (pc
= start_pc
; pc
< cur_pc
; pc
+= 4)
2289 insn
= read_memory_unsigned_integer (pc
, 4);
2290 frame_size
+= prologue_inst_adjust_sp (insn
);
2292 /* There are limited ways to store the return pointer into the
2294 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2296 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2299 else if (insn
== 0x0fc212c1
2300 || insn
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2302 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2309 fprintf_unfiltered (gdb_stdlog
, " frame_size=%d, found_rp=%d }\n",
2310 frame_size
, found_rp
);
2312 cache
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2313 cache
->base
-= frame_size
;
2314 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2316 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2318 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2319 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2320 cache
->saved_regs
[HPPA_RP_REGNUM
];
2325 rp
= get_frame_register_unsigned (this_frame
, HPPA_RP_REGNUM
);
2326 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2333 hppa_fallback_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2334 struct frame_id
*this_id
)
2336 struct hppa_frame_cache
*info
=
2337 hppa_fallback_frame_cache (this_frame
, this_cache
);
2339 (*this_id
) = frame_id_build (info
->base
, get_frame_func (this_frame
));
2342 static struct value
*
2343 hppa_fallback_frame_prev_register (struct frame_info
*this_frame
,
2344 void **this_cache
, int regnum
)
2346 struct hppa_frame_cache
*info
=
2347 hppa_fallback_frame_cache (this_frame
, this_cache
);
2349 return hppa_frame_prev_register_helper (this_frame
, info
->saved_regs
, regnum
);
2352 static const struct frame_unwind hppa_fallback_frame_unwind
=
2355 hppa_fallback_frame_this_id
,
2356 hppa_fallback_frame_prev_register
,
2358 default_frame_sniffer
2361 /* Stub frames, used for all kinds of call stubs. */
2362 struct hppa_stub_unwind_cache
2365 struct trad_frame_saved_reg
*saved_regs
;
2368 static struct hppa_stub_unwind_cache
*
2369 hppa_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2372 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2373 struct hppa_stub_unwind_cache
*info
;
2374 struct unwind_table_entry
*u
;
2379 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2381 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2383 info
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2385 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2387 /* HPUX uses export stubs in function calls; the export stub clobbers
2388 the return value of the caller, and, later restores it from the
2390 u
= find_unwind_entry (get_frame_pc (this_frame
));
2392 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2394 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2400 /* By default we assume that stubs do not change the rp. */
2401 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2407 hppa_stub_frame_this_id (struct frame_info
*this_frame
,
2408 void **this_prologue_cache
,
2409 struct frame_id
*this_id
)
2411 struct hppa_stub_unwind_cache
*info
2412 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2415 *this_id
= frame_id_build (info
->base
, get_frame_func (this_frame
));
2417 *this_id
= null_frame_id
;
2420 static struct value
*
2421 hppa_stub_frame_prev_register (struct frame_info
*this_frame
,
2422 void **this_prologue_cache
, int regnum
)
2424 struct hppa_stub_unwind_cache
*info
2425 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2428 error (_("Requesting registers from null frame."));
2430 return hppa_frame_prev_register_helper (this_frame
, info
->saved_regs
, regnum
);
2434 hppa_stub_unwind_sniffer (const struct frame_unwind
*self
,
2435 struct frame_info
*this_frame
,
2438 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
2439 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2440 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2443 || (tdep
->in_solib_call_trampoline
!= NULL
2444 && tdep
->in_solib_call_trampoline (pc
, NULL
))
2445 || gdbarch_in_solib_return_trampoline (gdbarch
, pc
, NULL
))
2450 static const struct frame_unwind hppa_stub_frame_unwind
= {
2452 hppa_stub_frame_this_id
,
2453 hppa_stub_frame_prev_register
,
2455 hppa_stub_unwind_sniffer
2458 static struct frame_id
2459 hppa_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2461 return frame_id_build (get_frame_register_unsigned (this_frame
,
2463 get_frame_pc (this_frame
));
2467 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2472 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2473 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2475 /* If the current instruction is nullified, then we are effectively
2476 still executing the previous instruction. Pretend we are still
2477 there. This is needed when single stepping; if the nullified
2478 instruction is on a different line, we don't want GDB to think
2479 we've stepped onto that line. */
2480 if (ipsw
& 0x00200000)
2486 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2487 Return NULL if no such symbol was found. */
2489 struct minimal_symbol
*
2490 hppa_lookup_stub_minimal_symbol (const char *name
,
2491 enum unwind_stub_types stub_type
)
2493 struct objfile
*objfile
;
2494 struct minimal_symbol
*msym
;
2496 ALL_MSYMBOLS (objfile
, msym
)
2498 if (strcmp (SYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2500 struct unwind_table_entry
*u
;
2502 u
= find_unwind_entry (SYMBOL_VALUE (msym
));
2503 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2512 unwind_command (char *exp
, int from_tty
)
2515 struct unwind_table_entry
*u
;
2517 /* If we have an expression, evaluate it and use it as the address. */
2519 if (exp
!= 0 && *exp
!= 0)
2520 address
= parse_and_eval_address (exp
);
2524 u
= find_unwind_entry (address
);
2528 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2532 printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u
);
2534 printf_unfiltered ("\tregion_start = ");
2535 print_address (u
->region_start
, gdb_stdout
);
2536 gdb_flush (gdb_stdout
);
2538 printf_unfiltered ("\n\tregion_end = ");
2539 print_address (u
->region_end
, gdb_stdout
);
2540 gdb_flush (gdb_stdout
);
2542 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2544 printf_unfiltered ("\n\tflags =");
2545 pif (Cannot_unwind
);
2547 pif (Millicode_save_sr0
);
2550 pif (Variable_Frame
);
2551 pif (Separate_Package_Body
);
2552 pif (Frame_Extension_Millicode
);
2553 pif (Stack_Overflow_Check
);
2554 pif (Two_Instruction_SP_Increment
);
2557 pif (cxx_try_catch
);
2558 pif (sched_entry_seq
);
2561 pif (Save_MRP_in_frame
);
2563 pif (Cleanup_defined
);
2564 pif (MPE_XL_interrupt_marker
);
2565 pif (HP_UX_interrupt_marker
);
2569 putchar_unfiltered ('\n');
2571 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2573 pin (Region_description
);
2576 pin (Total_frame_size
);
2578 if (u
->stub_unwind
.stub_type
)
2580 printf_unfiltered ("\tstub type = ");
2581 switch (u
->stub_unwind
.stub_type
)
2584 printf_unfiltered ("long branch\n");
2586 case PARAMETER_RELOCATION
:
2587 printf_unfiltered ("parameter relocation\n");
2590 printf_unfiltered ("export\n");
2593 printf_unfiltered ("import\n");
2596 printf_unfiltered ("import shlib\n");
2599 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2604 /* Return the GDB type object for the "standard" data type of data in
2607 static struct type
*
2608 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2610 if (regnum
< HPPA_FP4_REGNUM
)
2611 return builtin_type_uint32
;
2613 return builtin_type_ieee_single
;
2616 static struct type
*
2617 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2619 if (regnum
< HPPA64_FP4_REGNUM
)
2620 return builtin_type_uint64
;
2622 return builtin_type_ieee_double
;
2625 /* Return non-zero if REGNUM is not a register available to the user
2626 through ptrace/ttrace. */
2629 hppa32_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2632 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2633 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2634 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2638 hppa32_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2640 /* cr26 and cr27 are readable (but not writable) from userspace. */
2641 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2644 return hppa32_cannot_store_register (gdbarch
, regnum
);
2648 hppa64_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2651 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2652 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2653 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2657 hppa64_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2659 /* cr26 and cr27 are readable (but not writable) from userspace. */
2660 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2663 return hppa64_cannot_store_register (gdbarch
, regnum
);
2667 hppa_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2669 /* The low two bits of the PC on the PA contain the privilege level.
2670 Some genius implementing a (non-GCC) compiler apparently decided
2671 this means that "addresses" in a text section therefore include a
2672 privilege level, and thus symbol tables should contain these bits.
2673 This seems like a bonehead thing to do--anyway, it seems to work
2674 for our purposes to just ignore those bits. */
2676 return (addr
&= ~0x3);
2679 /* Get the ARGIth function argument for the current function. */
2682 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2685 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2689 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2690 int regnum
, gdb_byte
*buf
)
2694 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2695 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2697 store_unsigned_integer (buf
, sizeof tmp
, tmp
);
2701 hppa_find_global_pointer (struct gdbarch
*gdbarch
, struct value
*function
)
2707 hppa_frame_prev_register_helper (struct frame_info
*this_frame
,
2708 struct trad_frame_saved_reg saved_regs
[],
2711 struct gdbarch
*arch
= get_frame_arch (this_frame
);
2713 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2715 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2717 struct value
*pcoq_val
=
2718 trad_frame_get_prev_register (this_frame
, saved_regs
,
2719 HPPA_PCOQ_HEAD_REGNUM
);
2721 pc
= extract_unsigned_integer (value_contents_all (pcoq_val
), size
);
2722 return frame_unwind_got_constant (this_frame
, regnum
, pc
+ 4);
2725 /* Make sure the "flags" register is zero in all unwound frames.
2726 The "flags" registers is a HP-UX specific wart, and only the code
2727 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2728 with it here. This shouldn't affect other systems since those
2729 should provide zero for the "flags" register anyway. */
2730 if (regnum
== HPPA_FLAGS_REGNUM
)
2731 return frame_unwind_got_constant (this_frame
, regnum
, 0);
2733 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
2737 /* An instruction to match. */
2740 unsigned int data
; /* See if it matches this.... */
2741 unsigned int mask
; /* ... with this mask. */
2744 /* See bfd/elf32-hppa.c */
2745 static struct insn_pattern hppa_long_branch_stub
[] = {
2746 /* ldil LR'xxx,%r1 */
2747 { 0x20200000, 0xffe00000 },
2748 /* be,n RR'xxx(%sr4,%r1) */
2749 { 0xe0202002, 0xffe02002 },
2753 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
2755 { 0xe8200000, 0xffe00000 },
2756 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2757 { 0x28200000, 0xffe00000 },
2758 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2759 { 0xe0202002, 0xffe02002 },
2763 static struct insn_pattern hppa_import_stub
[] = {
2764 /* addil LR'xxx, %dp */
2765 { 0x2b600000, 0xffe00000 },
2766 /* ldw RR'xxx(%r1), %r21 */
2767 { 0x48350000, 0xffffb000 },
2769 { 0xeaa0c000, 0xffffffff },
2770 /* ldw RR'xxx+4(%r1), %r19 */
2771 { 0x48330000, 0xffffb000 },
2775 static struct insn_pattern hppa_import_pic_stub
[] = {
2776 /* addil LR'xxx,%r19 */
2777 { 0x2a600000, 0xffe00000 },
2778 /* ldw RR'xxx(%r1),%r21 */
2779 { 0x48350000, 0xffffb000 },
2781 { 0xeaa0c000, 0xffffffff },
2782 /* ldw RR'xxx+4(%r1),%r19 */
2783 { 0x48330000, 0xffffb000 },
2787 static struct insn_pattern hppa_plt_stub
[] = {
2788 /* b,l 1b, %r20 - 1b is 3 insns before here */
2789 { 0xea9f1fdd, 0xffffffff },
2790 /* depi 0,31,2,%r20 */
2791 { 0xd6801c1e, 0xffffffff },
2795 static struct insn_pattern hppa_sigtramp
[] = {
2796 /* ldi 0, %r25 or ldi 1, %r25 */
2797 { 0x34190000, 0xfffffffd },
2798 /* ldi __NR_rt_sigreturn, %r20 */
2799 { 0x3414015a, 0xffffffff },
2800 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
2801 { 0xe4008200, 0xffffffff },
2803 { 0x08000240, 0xffffffff },
2807 /* Maximum number of instructions on the patterns above. */
2808 #define HPPA_MAX_INSN_PATTERN_LEN 4
2810 /* Return non-zero if the instructions at PC match the series
2811 described in PATTERN, or zero otherwise. PATTERN is an array of
2812 'struct insn_pattern' objects, terminated by an entry whose mask is
2815 When the match is successful, fill INSN[i] with what PATTERN[i]
2819 hppa_match_insns (CORE_ADDR pc
, struct insn_pattern
*pattern
,
2825 for (i
= 0; pattern
[i
].mask
; i
++)
2827 gdb_byte buf
[HPPA_INSN_SIZE
];
2829 target_read_memory (npc
, buf
, HPPA_INSN_SIZE
);
2830 insn
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
);
2831 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
2840 /* This relaxed version of the insstruction matcher allows us to match
2841 from somewhere inside the pattern, by looking backwards in the
2842 instruction scheme. */
2845 hppa_match_insns_relaxed (CORE_ADDR pc
, struct insn_pattern
*pattern
,
2848 int offset
, len
= 0;
2850 while (pattern
[len
].mask
)
2853 for (offset
= 0; offset
< len
; offset
++)
2854 if (hppa_match_insns (pc
- offset
* HPPA_INSN_SIZE
, pattern
, insn
))
2861 hppa_in_dyncall (CORE_ADDR pc
)
2863 struct unwind_table_entry
*u
;
2865 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2869 return (pc
>= u
->region_start
&& pc
<= u
->region_end
);
2873 hppa_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
2875 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2876 struct unwind_table_entry
*u
;
2878 if (in_plt_section (pc
, name
) || hppa_in_dyncall (pc
))
2881 /* The GNU toolchain produces linker stubs without unwind
2882 information. Since the pattern matching for linker stubs can be
2883 quite slow, so bail out if we do have an unwind entry. */
2885 u
= find_unwind_entry (pc
);
2889 return (hppa_match_insns_relaxed (pc
, hppa_import_stub
, insn
)
2890 || hppa_match_insns_relaxed (pc
, hppa_import_pic_stub
, insn
)
2891 || hppa_match_insns_relaxed (pc
, hppa_long_branch_stub
, insn
)
2892 || hppa_match_insns_relaxed (pc
, hppa_long_branch_pic_stub
, insn
));
2895 /* This code skips several kind of "trampolines" used on PA-RISC
2896 systems: $$dyncall, import stubs and PLT stubs. */
2899 hppa_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
2901 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2904 /* $$dyncall handles both PLABELs and direct addresses. */
2905 if (hppa_in_dyncall (pc
))
2907 pc
= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 22);
2909 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2911 pc
= read_memory_typed_address (pc
& ~0x3, builtin_type_void_func_ptr
);
2916 dp_rel
= hppa_match_insns (pc
, hppa_import_stub
, insn
);
2917 if (dp_rel
|| hppa_match_insns (pc
, hppa_import_pic_stub
, insn
))
2919 /* Extract the target address from the addil/ldw sequence. */
2920 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
2923 pc
+= get_frame_register_unsigned (frame
, HPPA_DP_REGNUM
);
2925 pc
+= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 19);
2930 if (in_plt_section (pc
, NULL
))
2932 pc
= read_memory_typed_address (pc
, builtin_type_void_func_ptr
);
2934 /* If the PLT slot has not yet been resolved, the target will be
2936 if (in_plt_section (pc
, NULL
))
2938 /* Sanity check: are we pointing to the PLT stub? */
2939 if (!hppa_match_insns (pc
, hppa_plt_stub
, insn
))
2941 warning (_("Cannot resolve PLT stub at 0x%s."), paddr_nz (pc
));
2945 /* This should point to the fixup routine. */
2946 pc
= read_memory_typed_address (pc
+ 8, builtin_type_void_func_ptr
);
2954 /* Here is a table of C type sizes on hppa with various compiles
2955 and options. I measured this on PA 9000/800 with HP-UX 11.11
2956 and these compilers:
2958 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2959 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2960 /opt/aCC/bin/aCC B3910B A.03.45
2961 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2963 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2964 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2965 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2966 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2967 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2968 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2969 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2970 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2974 compiler and options
2975 char, short, int, long, long long
2976 float, double, long double
2979 So all these compilers use either ILP32 or LP64 model.
2980 TODO: gcc has more options so it needs more investigation.
2982 For floating point types, see:
2984 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2985 HP-UX floating-point guide, hpux 11.00
2987 -- chastain 2003-12-18 */
2989 static struct gdbarch
*
2990 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2992 struct gdbarch_tdep
*tdep
;
2993 struct gdbarch
*gdbarch
;
2995 /* Try to determine the ABI of the object we are loading. */
2996 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2998 /* If it's a SOM file, assume it's HP/UX SOM. */
2999 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
3000 info
.osabi
= GDB_OSABI_HPUX_SOM
;
3003 /* find a candidate among the list of pre-declared architectures. */
3004 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3006 return (arches
->gdbarch
);
3008 /* If none found, then allocate and initialize one. */
3009 tdep
= XZALLOC (struct gdbarch_tdep
);
3010 gdbarch
= gdbarch_alloc (&info
, tdep
);
3012 /* Determine from the bfd_arch_info structure if we are dealing with
3013 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3014 then default to a 32bit machine. */
3015 if (info
.bfd_arch_info
!= NULL
)
3016 tdep
->bytes_per_address
=
3017 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3019 tdep
->bytes_per_address
= 4;
3021 tdep
->find_global_pointer
= hppa_find_global_pointer
;
3023 /* Some parts of the gdbarch vector depend on whether we are running
3024 on a 32 bits or 64 bits target. */
3025 switch (tdep
->bytes_per_address
)
3028 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3029 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3030 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3031 set_gdbarch_cannot_store_register (gdbarch
,
3032 hppa32_cannot_store_register
);
3033 set_gdbarch_cannot_fetch_register (gdbarch
,
3034 hppa32_cannot_fetch_register
);
3037 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3038 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3039 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3040 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3041 set_gdbarch_cannot_store_register (gdbarch
,
3042 hppa64_cannot_store_register
);
3043 set_gdbarch_cannot_fetch_register (gdbarch
,
3044 hppa64_cannot_fetch_register
);
3047 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
3048 tdep
->bytes_per_address
);
3051 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3052 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3054 /* The following gdbarch vector elements are the same in both ILP32
3055 and LP64, but might show differences some day. */
3056 set_gdbarch_long_long_bit (gdbarch
, 64);
3057 set_gdbarch_long_double_bit (gdbarch
, 128);
3058 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3060 /* The following gdbarch vector elements do not depend on the address
3061 size, or in any other gdbarch element previously set. */
3062 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3063 set_gdbarch_in_function_epilogue_p (gdbarch
,
3064 hppa_in_function_epilogue_p
);
3065 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
3066 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3067 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3068 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
3069 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
3070 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3071 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
3072 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
3074 /* Helper for function argument information. */
3075 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3077 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
3079 /* When a hardware watchpoint triggers, we'll move the inferior past
3080 it by removing all eventpoints; stepping past the instruction
3081 that caused the trigger; reinserting eventpoints; and checking
3082 whether any watched location changed. */
3083 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3085 /* Inferior function call methods. */
3086 switch (tdep
->bytes_per_address
)
3089 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3090 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3091 set_gdbarch_convert_from_func_ptr_addr
3092 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
3095 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3096 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3099 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3102 /* Struct return methods. */
3103 switch (tdep
->bytes_per_address
)
3106 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3109 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3112 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3115 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
3116 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
3118 /* Frame unwind methods. */
3119 set_gdbarch_dummy_id (gdbarch
, hppa_dummy_id
);
3120 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3122 /* Hook in ABI-specific overrides, if they have been registered. */
3123 gdbarch_init_osabi (info
, gdbarch
);
3125 /* Hook in the default unwinders. */
3126 frame_unwind_append_unwinder (gdbarch
, &hppa_stub_frame_unwind
);
3127 frame_unwind_append_unwinder (gdbarch
, &hppa_frame_unwind
);
3128 frame_unwind_append_unwinder (gdbarch
, &hppa_fallback_frame_unwind
);
3134 hppa_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
3136 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3138 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
3139 tdep
->bytes_per_address
);
3140 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
3144 _initialize_hppa_tdep (void)
3146 struct cmd_list_element
*c
;
3148 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3150 hppa_objfile_priv_data
= register_objfile_data ();
3152 add_cmd ("unwind", class_maintenance
, unwind_command
,
3153 _("Print unwind table entry at given address."),
3154 &maintenanceprintlist
);
3156 /* Debug this files internals. */
3157 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
3158 Set whether hppa target specific debugging information should be displayed."),
3160 Show whether hppa target specific debugging information is displayed."), _("\
3161 This flag controls whether hppa target specific debugging information is\n\
3162 displayed. This information is particularly useful for debugging frame\n\
3163 unwinding problems."),
3165 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
3166 &setdebuglist
, &showdebuglist
);