1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986-1987, 1989-1996, 1998-2005, 2007-2012 Free
4 Software Foundation, Inc.
6 Contributed by the Center for Software Science at the
7 University of Utah (pa-gdb-bugs@cs.utah.edu).
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "completer.h"
30 #include "gdb_assert.h"
31 #include "arch-utils.h"
32 /* For argument passing to the inferior. */
35 #include "trad-frame.h"
36 #include "frame-unwind.h"
37 #include "frame-base.h"
43 #include "hppa-tdep.h"
45 static int hppa_debug
= 0;
47 /* Some local constants. */
48 static const int hppa32_num_regs
= 128;
49 static const int hppa64_num_regs
= 96;
51 /* hppa-specific object data -- unwind and solib info.
52 TODO/maybe: think about splitting this into two parts; the unwind data is
53 common to all hppa targets, but is only used in this file; we can register
54 that separately and make this static. The solib data is probably hpux-
55 specific, so we can create a separate extern objfile_data that is registered
56 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
57 const struct objfile_data
*hppa_objfile_priv_data
= NULL
;
59 /* Get at various relevent fields of an instruction word. */
62 #define MASK_14 0x3fff
63 #define MASK_21 0x1fffff
65 /* Sizes (in bytes) of the native unwind entries. */
66 #define UNWIND_ENTRY_SIZE 16
67 #define STUB_UNWIND_ENTRY_SIZE 8
69 /* Routines to extract various sized constants out of hppa
72 /* This assumes that no garbage lies outside of the lower bits of
76 hppa_sign_extend (unsigned val
, unsigned bits
)
78 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
81 /* For many immediate values the sign bit is the low bit! */
84 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
86 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
89 /* Extract the bits at positions between FROM and TO, using HP's numbering
93 hppa_get_field (unsigned word
, int from
, int to
)
95 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
98 /* Extract the immediate field from a ld{bhw}s instruction. */
101 hppa_extract_5_load (unsigned word
)
103 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
106 /* Extract the immediate field from a break instruction. */
109 hppa_extract_5r_store (unsigned word
)
111 return (word
& MASK_5
);
114 /* Extract the immediate field from a {sr}sm instruction. */
117 hppa_extract_5R_store (unsigned word
)
119 return (word
>> 16 & MASK_5
);
122 /* Extract a 14 bit immediate field. */
125 hppa_extract_14 (unsigned word
)
127 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
130 /* Extract a 21 bit constant. */
133 hppa_extract_21 (unsigned word
)
139 val
= hppa_get_field (word
, 20, 20);
141 val
|= hppa_get_field (word
, 9, 19);
143 val
|= hppa_get_field (word
, 5, 6);
145 val
|= hppa_get_field (word
, 0, 4);
147 val
|= hppa_get_field (word
, 7, 8);
148 return hppa_sign_extend (val
, 21) << 11;
151 /* extract a 17 bit constant from branch instructions, returning the
152 19 bit signed value. */
155 hppa_extract_17 (unsigned word
)
157 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
158 hppa_get_field (word
, 29, 29) << 10 |
159 hppa_get_field (word
, 11, 15) << 11 |
160 (word
& 0x1) << 16, 17) << 2;
164 hppa_symbol_address(const char *sym
)
166 struct minimal_symbol
*minsym
;
168 minsym
= lookup_minimal_symbol (sym
, NULL
, NULL
);
170 return SYMBOL_VALUE_ADDRESS (minsym
);
172 return (CORE_ADDR
)-1;
175 struct hppa_objfile_private
*
176 hppa_init_objfile_priv_data (struct objfile
*objfile
)
178 struct hppa_objfile_private
*priv
;
180 priv
= (struct hppa_objfile_private
*)
181 obstack_alloc (&objfile
->objfile_obstack
,
182 sizeof (struct hppa_objfile_private
));
183 set_objfile_data (objfile
, hppa_objfile_priv_data
, priv
);
184 memset (priv
, 0, sizeof (*priv
));
190 /* Compare the start address for two unwind entries returning 1 if
191 the first address is larger than the second, -1 if the second is
192 larger than the first, and zero if they are equal. */
195 compare_unwind_entries (const void *arg1
, const void *arg2
)
197 const struct unwind_table_entry
*a
= arg1
;
198 const struct unwind_table_entry
*b
= arg2
;
200 if (a
->region_start
> b
->region_start
)
202 else if (a
->region_start
< b
->region_start
)
209 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
211 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
212 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
214 bfd_vma value
= section
->vma
- section
->filepos
;
215 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
217 if (value
< *low_text_segment_address
)
218 *low_text_segment_address
= value
;
223 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
224 asection
*section
, unsigned int entries
,
225 unsigned int size
, CORE_ADDR text_offset
)
227 /* We will read the unwind entries into temporary memory, then
228 fill in the actual unwind table. */
232 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
235 char *buf
= alloca (size
);
236 CORE_ADDR low_text_segment_address
;
238 /* For ELF targets, then unwinds are supposed to
239 be segment relative offsets instead of absolute addresses.
241 Note that when loading a shared library (text_offset != 0) the
242 unwinds are already relative to the text_offset that will be
244 if (gdbarch_tdep (gdbarch
)->is_elf
&& text_offset
== 0)
246 low_text_segment_address
= -1;
248 bfd_map_over_sections (objfile
->obfd
,
249 record_text_segment_lowaddr
,
250 &low_text_segment_address
);
252 text_offset
= low_text_segment_address
;
254 else if (gdbarch_tdep (gdbarch
)->solib_get_text_base
)
256 text_offset
= gdbarch_tdep (gdbarch
)->solib_get_text_base (objfile
);
259 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
261 /* Now internalize the information being careful to handle host/target
263 for (i
= 0; i
< entries
; i
++)
265 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
267 table
[i
].region_start
+= text_offset
;
269 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
270 table
[i
].region_end
+= text_offset
;
272 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
274 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
275 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
276 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
277 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
278 table
[i
].reserved
= (tmp
>> 26) & 0x1;
279 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
280 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
281 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
282 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
283 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
284 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
285 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
286 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
287 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
288 table
[i
].sr4export
= (tmp
>> 9) & 0x1;
289 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
290 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
291 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
292 table
[i
].reserved1
= (tmp
>> 5) & 0x1;
293 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
294 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
295 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
296 table
[i
].save_r19
= (tmp
>> 1) & 0x1;
297 table
[i
].Cleanup_defined
= tmp
& 0x1;
298 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
300 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
301 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
302 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
303 table
[i
].alloca_frame
= (tmp
>> 28) & 0x1;
304 table
[i
].reserved2
= (tmp
>> 27) & 0x1;
305 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
307 /* Stub unwinds are handled elsewhere. */
308 table
[i
].stub_unwind
.stub_type
= 0;
309 table
[i
].stub_unwind
.padding
= 0;
314 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
315 the object file. This info is used mainly by find_unwind_entry() to find
316 out the stack frame size and frame pointer used by procedures. We put
317 everything on the psymbol obstack in the objfile so that it automatically
318 gets freed when the objfile is destroyed. */
321 read_unwind_info (struct objfile
*objfile
)
323 asection
*unwind_sec
, *stub_unwind_sec
;
324 unsigned unwind_size
, stub_unwind_size
, total_size
;
325 unsigned index
, unwind_entries
;
326 unsigned stub_entries
, total_entries
;
327 CORE_ADDR text_offset
;
328 struct hppa_unwind_info
*ui
;
329 struct hppa_objfile_private
*obj_private
;
331 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
332 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
333 sizeof (struct hppa_unwind_info
));
339 /* For reasons unknown the HP PA64 tools generate multiple unwinder
340 sections in a single executable. So we just iterate over every
341 section in the BFD looking for unwinder sections intead of trying
342 to do a lookup with bfd_get_section_by_name.
344 First determine the total size of the unwind tables so that we
345 can allocate memory in a nice big hunk. */
347 for (unwind_sec
= objfile
->obfd
->sections
;
349 unwind_sec
= unwind_sec
->next
)
351 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
352 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
354 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
355 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
357 total_entries
+= unwind_entries
;
361 /* Now compute the size of the stub unwinds. Note the ELF tools do not
362 use stub unwinds at the current time. */
363 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
367 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
368 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
372 stub_unwind_size
= 0;
376 /* Compute total number of unwind entries and their total size. */
377 total_entries
+= stub_entries
;
378 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
380 /* Allocate memory for the unwind table. */
381 ui
->table
= (struct unwind_table_entry
*)
382 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
383 ui
->last
= total_entries
- 1;
385 /* Now read in each unwind section and internalize the standard unwind
388 for (unwind_sec
= objfile
->obfd
->sections
;
390 unwind_sec
= unwind_sec
->next
)
392 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
393 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
395 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
396 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
398 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
399 unwind_entries
, unwind_size
, text_offset
);
400 index
+= unwind_entries
;
404 /* Now read in and internalize the stub unwind entries. */
405 if (stub_unwind_size
> 0)
408 char *buf
= alloca (stub_unwind_size
);
410 /* Read in the stub unwind entries. */
411 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
412 0, stub_unwind_size
);
414 /* Now convert them into regular unwind entries. */
415 for (i
= 0; i
< stub_entries
; i
++, index
++)
417 /* Clear out the next unwind entry. */
418 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
420 /* Convert offset & size into region_start and region_end.
421 Stuff away the stub type into "reserved" fields. */
422 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
424 ui
->table
[index
].region_start
+= text_offset
;
426 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
429 ui
->table
[index
].region_end
430 = ui
->table
[index
].region_start
+ 4 *
431 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
437 /* Unwind table needs to be kept sorted. */
438 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
439 compare_unwind_entries
);
441 /* Keep a pointer to the unwind information. */
442 obj_private
= (struct hppa_objfile_private
*)
443 objfile_data (objfile
, hppa_objfile_priv_data
);
444 if (obj_private
== NULL
)
445 obj_private
= hppa_init_objfile_priv_data (objfile
);
447 obj_private
->unwind_info
= ui
;
450 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
451 of the objfiles seeking the unwind table entry for this PC. Each objfile
452 contains a sorted list of struct unwind_table_entry. Since we do a binary
453 search of the unwind tables, we depend upon them to be sorted. */
455 struct unwind_table_entry
*
456 find_unwind_entry (CORE_ADDR pc
)
458 int first
, middle
, last
;
459 struct objfile
*objfile
;
460 struct hppa_objfile_private
*priv
;
463 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry %s -> ",
466 /* A function at address 0? Not in HP-UX! */
467 if (pc
== (CORE_ADDR
) 0)
470 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
474 ALL_OBJFILES (objfile
)
476 struct hppa_unwind_info
*ui
;
478 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
480 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
484 read_unwind_info (objfile
);
485 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
487 error (_("Internal error reading unwind information."));
488 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
491 /* First, check the cache. */
494 && pc
>= ui
->cache
->region_start
495 && pc
<= ui
->cache
->region_end
)
498 fprintf_unfiltered (gdb_stdlog
, "%s (cached) }\n",
499 hex_string ((uintptr_t) ui
->cache
));
503 /* Not in the cache, do a binary search. */
508 while (first
<= last
)
510 middle
= (first
+ last
) / 2;
511 if (pc
>= ui
->table
[middle
].region_start
512 && pc
<= ui
->table
[middle
].region_end
)
514 ui
->cache
= &ui
->table
[middle
];
516 fprintf_unfiltered (gdb_stdlog
, "%s }\n",
517 hex_string ((uintptr_t) ui
->cache
));
518 return &ui
->table
[middle
];
521 if (pc
< ui
->table
[middle
].region_start
)
526 } /* ALL_OBJFILES() */
529 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
534 /* The epilogue is defined here as the area either on the `bv' instruction
535 itself or an instruction which destroys the function's stack frame.
537 We do not assume that the epilogue is at the end of a function as we can
538 also have return sequences in the middle of a function. */
540 hppa_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
542 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
543 unsigned long status
;
547 status
= target_read_memory (pc
, buf
, 4);
551 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
553 /* The most common way to perform a stack adjustment ldo X(sp),sp
554 We are destroying a stack frame if the offset is negative. */
555 if ((inst
& 0xffffc000) == 0x37de0000
556 && hppa_extract_14 (inst
) < 0)
559 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
560 if (((inst
& 0x0fc010e0) == 0x0fc010e0
561 || (inst
& 0x0fc010e0) == 0x0fc010e0)
562 && hppa_extract_14 (inst
) < 0)
565 /* bv %r0(%rp) or bv,n %r0(%rp) */
566 if (inst
== 0xe840c000 || inst
== 0xe840c002)
572 static const unsigned char *
573 hppa_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
, int *len
)
575 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
576 (*len
) = sizeof (breakpoint
);
580 /* Return the name of a register. */
583 hppa32_register_name (struct gdbarch
*gdbarch
, int i
)
585 static char *names
[] = {
586 "flags", "r1", "rp", "r3",
587 "r4", "r5", "r6", "r7",
588 "r8", "r9", "r10", "r11",
589 "r12", "r13", "r14", "r15",
590 "r16", "r17", "r18", "r19",
591 "r20", "r21", "r22", "r23",
592 "r24", "r25", "r26", "dp",
593 "ret0", "ret1", "sp", "r31",
594 "sar", "pcoqh", "pcsqh", "pcoqt",
595 "pcsqt", "eiem", "iir", "isr",
596 "ior", "ipsw", "goto", "sr4",
597 "sr0", "sr1", "sr2", "sr3",
598 "sr5", "sr6", "sr7", "cr0",
599 "cr8", "cr9", "ccr", "cr12",
600 "cr13", "cr24", "cr25", "cr26",
601 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
602 "fpsr", "fpe1", "fpe2", "fpe3",
603 "fpe4", "fpe5", "fpe6", "fpe7",
604 "fr4", "fr4R", "fr5", "fr5R",
605 "fr6", "fr6R", "fr7", "fr7R",
606 "fr8", "fr8R", "fr9", "fr9R",
607 "fr10", "fr10R", "fr11", "fr11R",
608 "fr12", "fr12R", "fr13", "fr13R",
609 "fr14", "fr14R", "fr15", "fr15R",
610 "fr16", "fr16R", "fr17", "fr17R",
611 "fr18", "fr18R", "fr19", "fr19R",
612 "fr20", "fr20R", "fr21", "fr21R",
613 "fr22", "fr22R", "fr23", "fr23R",
614 "fr24", "fr24R", "fr25", "fr25R",
615 "fr26", "fr26R", "fr27", "fr27R",
616 "fr28", "fr28R", "fr29", "fr29R",
617 "fr30", "fr30R", "fr31", "fr31R"
619 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
626 hppa64_register_name (struct gdbarch
*gdbarch
, int i
)
628 static char *names
[] = {
629 "flags", "r1", "rp", "r3",
630 "r4", "r5", "r6", "r7",
631 "r8", "r9", "r10", "r11",
632 "r12", "r13", "r14", "r15",
633 "r16", "r17", "r18", "r19",
634 "r20", "r21", "r22", "r23",
635 "r24", "r25", "r26", "dp",
636 "ret0", "ret1", "sp", "r31",
637 "sar", "pcoqh", "pcsqh", "pcoqt",
638 "pcsqt", "eiem", "iir", "isr",
639 "ior", "ipsw", "goto", "sr4",
640 "sr0", "sr1", "sr2", "sr3",
641 "sr5", "sr6", "sr7", "cr0",
642 "cr8", "cr9", "ccr", "cr12",
643 "cr13", "cr24", "cr25", "cr26",
644 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
645 "fpsr", "fpe1", "fpe2", "fpe3",
646 "fr4", "fr5", "fr6", "fr7",
647 "fr8", "fr9", "fr10", "fr11",
648 "fr12", "fr13", "fr14", "fr15",
649 "fr16", "fr17", "fr18", "fr19",
650 "fr20", "fr21", "fr22", "fr23",
651 "fr24", "fr25", "fr26", "fr27",
652 "fr28", "fr29", "fr30", "fr31"
654 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
660 /* Map dwarf DBX register numbers to GDB register numbers. */
662 hppa64_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
664 /* The general registers and the sar are the same in both sets. */
668 /* fr4-fr31 are mapped from 72 in steps of 2. */
669 if (reg
>= 72 && reg
< 72 + 28 * 2 && !(reg
& 1))
670 return HPPA64_FP4_REGNUM
+ (reg
- 72) / 2;
672 warning (_("Unmapped DWARF DBX Register #%d encountered."), 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 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
694 /* Stack base address at which any pass-by-reference parameters are
696 CORE_ADDR struct_end
= 0;
697 /* Stack base address at which the first parameter is stored. */
698 CORE_ADDR param_end
= 0;
700 /* The inner most end of the stack after all the parameters have
702 CORE_ADDR new_sp
= 0;
704 /* Two passes. First pass computes the location of everything,
705 second pass writes the bytes out. */
708 /* Global pointer (r19) of the function we are trying to call. */
711 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
713 for (write_pass
= 0; write_pass
< 2; write_pass
++)
715 CORE_ADDR struct_ptr
= 0;
716 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
717 struct_ptr is adjusted for each argument below, so the first
718 argument will end up at sp-36. */
719 CORE_ADDR param_ptr
= 32;
721 int small_struct
= 0;
723 for (i
= 0; i
< nargs
; i
++)
725 struct value
*arg
= args
[i
];
726 struct type
*type
= check_typedef (value_type (arg
));
727 /* The corresponding parameter that is pushed onto the
728 stack, and [possibly] passed in a register. */
731 memset (param_val
, 0, sizeof param_val
);
732 if (TYPE_LENGTH (type
) > 8)
734 /* Large parameter, pass by reference. Store the value
735 in "struct" area and then pass its address. */
737 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
739 write_memory (struct_end
- struct_ptr
, value_contents (arg
),
741 store_unsigned_integer (param_val
, 4, byte_order
,
742 struct_end
- struct_ptr
);
744 else if (TYPE_CODE (type
) == TYPE_CODE_INT
745 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
747 /* Integer value store, right aligned. "unpack_long"
748 takes care of any sign-extension problems. */
749 param_len
= align_up (TYPE_LENGTH (type
), 4);
750 store_unsigned_integer (param_val
, param_len
, byte_order
,
752 value_contents (arg
)));
754 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
756 /* Floating point value store, right aligned. */
757 param_len
= align_up (TYPE_LENGTH (type
), 4);
758 memcpy (param_val
, value_contents (arg
), param_len
);
762 param_len
= align_up (TYPE_LENGTH (type
), 4);
764 /* Small struct value are stored right-aligned. */
765 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
766 value_contents (arg
), TYPE_LENGTH (type
));
768 /* Structures of size 5, 6 and 7 bytes are special in that
769 the higher-ordered word is stored in the lower-ordered
770 argument, and even though it is a 8-byte quantity the
771 registers need not be 8-byte aligned. */
772 if (param_len
> 4 && param_len
< 8)
776 param_ptr
+= param_len
;
777 if (param_len
== 8 && !small_struct
)
778 param_ptr
= align_up (param_ptr
, 8);
780 /* First 4 non-FP arguments are passed in gr26-gr23.
781 First 4 32-bit FP arguments are passed in fr4L-fr7L.
782 First 2 64-bit FP arguments are passed in fr5 and fr7.
784 The rest go on the stack, starting at sp-36, towards lower
785 addresses. 8-byte arguments must be aligned to a 8-byte
789 write_memory (param_end
- param_ptr
, param_val
, param_len
);
791 /* There are some cases when we don't know the type
792 expected by the callee (e.g. for variadic functions), so
793 pass the parameters in both general and fp regs. */
796 int grreg
= 26 - (param_ptr
- 36) / 4;
797 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
798 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
800 regcache_cooked_write (regcache
, grreg
, param_val
);
801 regcache_cooked_write (regcache
, fpLreg
, param_val
);
805 regcache_cooked_write (regcache
, grreg
+ 1,
808 regcache_cooked_write (regcache
, fpreg
, param_val
);
809 regcache_cooked_write (regcache
, fpreg
+ 1,
816 /* Update the various stack pointers. */
819 struct_end
= sp
+ align_up (struct_ptr
, 64);
820 /* PARAM_PTR already accounts for all the arguments passed
821 by the user. However, the ABI mandates minimum stack
822 space allocations for outgoing arguments. The ABI also
823 mandates minimum stack alignments which we must
825 param_end
= struct_end
+ align_up (param_ptr
, 64);
829 /* If a structure has to be returned, set up register 28 to hold its
832 regcache_cooked_write_unsigned (regcache
, 28, struct_addr
);
834 gp
= tdep
->find_global_pointer (gdbarch
, function
);
837 regcache_cooked_write_unsigned (regcache
, 19, gp
);
839 /* Set the return address. */
840 if (!gdbarch_push_dummy_code_p (gdbarch
))
841 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
843 /* Update the Stack Pointer. */
844 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
849 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
850 Runtime Architecture for PA-RISC 2.0", which is distributed as part
851 as of the HP-UX Software Transition Kit (STK). This implementation
852 is based on version 3.3, dated October 6, 1997. */
854 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
857 hppa64_integral_or_pointer_p (const struct type
*type
)
859 switch (TYPE_CODE (type
))
865 case TYPE_CODE_RANGE
:
867 int len
= TYPE_LENGTH (type
);
868 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
872 return (TYPE_LENGTH (type
) == 8);
880 /* Check whether TYPE is a "Floating Scalar Type". */
883 hppa64_floating_p (const struct type
*type
)
885 switch (TYPE_CODE (type
))
889 int len
= TYPE_LENGTH (type
);
890 return (len
== 4 || len
== 8 || len
== 16);
899 /* If CODE points to a function entry address, try to look up the corresponding
900 function descriptor and return its address instead. If CODE is not a
901 function entry address, then just return it unchanged. */
903 hppa64_convert_code_addr_to_fptr (struct gdbarch
*gdbarch
, CORE_ADDR code
)
905 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
906 struct obj_section
*sec
, *opd
;
908 sec
= find_pc_section (code
);
913 /* If CODE is in a data section, assume it's already a fptr. */
914 if (!(sec
->the_bfd_section
->flags
& SEC_CODE
))
917 ALL_OBJFILE_OSECTIONS (sec
->objfile
, opd
)
919 if (strcmp (opd
->the_bfd_section
->name
, ".opd") == 0)
923 if (opd
< sec
->objfile
->sections_end
)
927 for (addr
= obj_section_addr (opd
);
928 addr
< obj_section_endaddr (opd
);
934 if (target_read_memory (addr
, tmp
, sizeof (tmp
)))
936 opdaddr
= extract_unsigned_integer (tmp
, sizeof (tmp
), byte_order
);
947 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
948 struct regcache
*regcache
, CORE_ADDR bp_addr
,
949 int nargs
, struct value
**args
, CORE_ADDR sp
,
950 int struct_return
, CORE_ADDR struct_addr
)
952 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
953 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
957 /* "The outgoing parameter area [...] must be aligned at a 16-byte
959 sp
= align_up (sp
, 16);
961 for (i
= 0; i
< nargs
; i
++)
963 struct value
*arg
= args
[i
];
964 struct type
*type
= value_type (arg
);
965 int len
= TYPE_LENGTH (type
);
966 const bfd_byte
*valbuf
;
970 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
971 offset
= align_up (offset
, 8);
973 if (hppa64_integral_or_pointer_p (type
))
975 /* "Integral scalar parameters smaller than 64 bits are
976 padded on the left (i.e., the value is in the
977 least-significant bits of the 64-bit storage unit, and
978 the high-order bits are undefined)." Therefore we can
979 safely sign-extend them. */
982 arg
= value_cast (builtin_type (gdbarch
)->builtin_int64
, arg
);
986 else if (hppa64_floating_p (type
))
990 /* "Quad-precision (128-bit) floating-point scalar
991 parameters are aligned on a 16-byte boundary." */
992 offset
= align_up (offset
, 16);
994 /* "Double-extended- and quad-precision floating-point
995 parameters within the first 64 bytes of the parameter
996 list are always passed in general registers." */
1002 /* "Single-precision (32-bit) floating-point scalar
1003 parameters are padded on the left with 32 bits of
1004 garbage (i.e., the floating-point value is in the
1005 least-significant 32 bits of a 64-bit storage
1010 /* "Single- and double-precision floating-point
1011 parameters in this area are passed according to the
1012 available formal parameter information in a function
1013 prototype. [...] If no prototype is in scope,
1014 floating-point parameters must be passed both in the
1015 corresponding general registers and in the
1016 corresponding floating-point registers." */
1017 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
1019 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
1021 /* "Single-precision floating-point parameters, when
1022 passed in floating-point registers, are passed in
1023 the right halves of the floating point registers;
1024 the left halves are unused." */
1025 regcache_cooked_write_part (regcache
, regnum
, offset
% 8,
1026 len
, value_contents (arg
));
1034 /* "Aggregates larger than 8 bytes are aligned on a
1035 16-byte boundary, possibly leaving an unused argument
1036 slot, which is filled with garbage. If necessary,
1037 they are padded on the right (with garbage), to a
1038 multiple of 8 bytes." */
1039 offset
= align_up (offset
, 16);
1043 /* If we are passing a function pointer, make sure we pass a function
1044 descriptor instead of the function entry address. */
1045 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1046 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1048 ULONGEST codeptr
, fptr
;
1050 codeptr
= unpack_long (type
, value_contents (arg
));
1051 fptr
= hppa64_convert_code_addr_to_fptr (gdbarch
, codeptr
);
1052 store_unsigned_integer (fptrbuf
, TYPE_LENGTH (type
), byte_order
,
1058 valbuf
= value_contents (arg
);
1061 /* Always store the argument in memory. */
1062 write_memory (sp
+ offset
, valbuf
, len
);
1064 regnum
= HPPA_ARG0_REGNUM
- offset
/ 8;
1065 while (regnum
> HPPA_ARG0_REGNUM
- 8 && len
> 0)
1067 regcache_cooked_write_part (regcache
, regnum
,
1068 offset
% 8, min (len
, 8), valbuf
);
1069 offset
+= min (len
, 8);
1070 valbuf
+= min (len
, 8);
1071 len
-= min (len
, 8);
1078 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1079 regcache_cooked_write_unsigned (regcache
, HPPA_RET1_REGNUM
, sp
+ 64);
1081 /* Allocate the outgoing parameter area. Make sure the outgoing
1082 parameter area is multiple of 16 bytes in length. */
1083 sp
+= max (align_up (offset
, 16), 64);
1085 /* Allocate 32-bytes of scratch space. The documentation doesn't
1086 mention this, but it seems to be needed. */
1089 /* Allocate the frame marker area. */
1092 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1095 regcache_cooked_write_unsigned (regcache
, HPPA_RET0_REGNUM
, struct_addr
);
1097 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1098 gp
= tdep
->find_global_pointer (gdbarch
, function
);
1100 regcache_cooked_write_unsigned (regcache
, HPPA_DP_REGNUM
, gp
);
1102 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1103 if (!gdbarch_push_dummy_code_p (gdbarch
))
1104 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1106 /* Set up GR30 to hold the stack pointer (sp). */
1107 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, sp
);
1113 /* Handle 32/64-bit struct return conventions. */
1115 static enum return_value_convention
1116 hppa32_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1117 struct type
*type
, struct regcache
*regcache
,
1118 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1120 if (TYPE_LENGTH (type
) <= 2 * 4)
1122 /* The value always lives in the right hand end of the register
1123 (or register pair)? */
1125 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
1126 int part
= TYPE_LENGTH (type
) % 4;
1127 /* The left hand register contains only part of the value,
1128 transfer that first so that the rest can be xfered as entire
1129 4-byte registers. */
1132 if (readbuf
!= NULL
)
1133 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
1135 if (writebuf
!= NULL
)
1136 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
1140 /* Now transfer the remaining register values. */
1141 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
1143 if (readbuf
!= NULL
)
1144 regcache_cooked_read (regcache
, reg
, readbuf
+ b
);
1145 if (writebuf
!= NULL
)
1146 regcache_cooked_write (regcache
, reg
, writebuf
+ b
);
1149 return RETURN_VALUE_REGISTER_CONVENTION
;
1152 return RETURN_VALUE_STRUCT_CONVENTION
;
1155 static enum return_value_convention
1156 hppa64_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1157 struct type
*type
, struct regcache
*regcache
,
1158 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1160 int len
= TYPE_LENGTH (type
);
1165 /* All return values larget than 128 bits must be aggregate
1167 gdb_assert (!hppa64_integral_or_pointer_p (type
));
1168 gdb_assert (!hppa64_floating_p (type
));
1170 /* "Aggregate return values larger than 128 bits are returned in
1171 a buffer allocated by the caller. The address of the buffer
1172 must be passed in GR 28." */
1173 return RETURN_VALUE_STRUCT_CONVENTION
;
1176 if (hppa64_integral_or_pointer_p (type
))
1178 /* "Integral return values are returned in GR 28. Values
1179 smaller than 64 bits are padded on the left (with garbage)." */
1180 regnum
= HPPA_RET0_REGNUM
;
1183 else if (hppa64_floating_p (type
))
1187 /* "Double-extended- and quad-precision floating-point
1188 values are returned in GRs 28 and 29. The sign,
1189 exponent, and most-significant bits of the mantissa are
1190 returned in GR 28; the least-significant bits of the
1191 mantissa are passed in GR 29. For double-extended
1192 precision values, GR 29 is padded on the right with 48
1193 bits of garbage." */
1194 regnum
= HPPA_RET0_REGNUM
;
1199 /* "Single-precision and double-precision floating-point
1200 return values are returned in FR 4R (single precision) or
1201 FR 4 (double-precision)." */
1202 regnum
= HPPA64_FP4_REGNUM
;
1208 /* "Aggregate return values up to 64 bits in size are returned
1209 in GR 28. Aggregates smaller than 64 bits are left aligned
1210 in the register; the pad bits on the right are undefined."
1212 "Aggregate return values between 65 and 128 bits are returned
1213 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1214 the remaining bits are placed, left aligned, in GR 29. The
1215 pad bits on the right of GR 29 (if any) are undefined." */
1216 regnum
= HPPA_RET0_REGNUM
;
1224 regcache_cooked_read_part (regcache
, regnum
, offset
,
1225 min (len
, 8), readbuf
);
1226 readbuf
+= min (len
, 8);
1227 len
-= min (len
, 8);
1236 regcache_cooked_write_part (regcache
, regnum
, offset
,
1237 min (len
, 8), writebuf
);
1238 writebuf
+= min (len
, 8);
1239 len
-= min (len
, 8);
1244 return RETURN_VALUE_REGISTER_CONVENTION
;
1249 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1250 struct target_ops
*targ
)
1254 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1255 CORE_ADDR plabel
= addr
& ~3;
1256 return read_memory_typed_address (plabel
, func_ptr_type
);
1263 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1265 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1267 return align_up (addr
, 64);
1270 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1273 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1275 /* Just always 16-byte align. */
1276 return align_up (addr
, 16);
1280 hppa_read_pc (struct regcache
*regcache
)
1285 regcache_cooked_read_unsigned (regcache
, HPPA_IPSW_REGNUM
, &ipsw
);
1286 regcache_cooked_read_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, &pc
);
1288 /* If the current instruction is nullified, then we are effectively
1289 still executing the previous instruction. Pretend we are still
1290 there. This is needed when single stepping; if the nullified
1291 instruction is on a different line, we don't want GDB to think
1292 we've stepped onto that line. */
1293 if (ipsw
& 0x00200000)
1300 hppa_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1302 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pc
);
1303 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4);
1306 /* For the given instruction (INST), return any adjustment it makes
1307 to the stack pointer or zero for no adjustment.
1309 This only handles instructions commonly found in prologues. */
1312 prologue_inst_adjust_sp (unsigned long inst
)
1314 /* This must persist across calls. */
1315 static int save_high21
;
1317 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1318 if ((inst
& 0xffffc000) == 0x37de0000)
1319 return hppa_extract_14 (inst
);
1322 if ((inst
& 0xffe00000) == 0x6fc00000)
1323 return hppa_extract_14 (inst
);
1325 /* std,ma X,D(sp) */
1326 if ((inst
& 0xffe00008) == 0x73c00008)
1327 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1329 /* addil high21,%r30; ldo low11,(%r1),%r30)
1330 save high bits in save_high21 for later use. */
1331 if ((inst
& 0xffe00000) == 0x2bc00000)
1333 save_high21
= hppa_extract_21 (inst
);
1337 if ((inst
& 0xffff0000) == 0x343e0000)
1338 return save_high21
+ hppa_extract_14 (inst
);
1340 /* fstws as used by the HP compilers. */
1341 if ((inst
& 0xffffffe0) == 0x2fd01220)
1342 return hppa_extract_5_load (inst
);
1344 /* No adjustment. */
1348 /* Return nonzero if INST is a branch of some kind, else return zero. */
1351 is_branch (unsigned long inst
)
1380 /* Return the register number for a GR which is saved by INST or
1381 zero it INST does not save a GR. */
1384 inst_saves_gr (unsigned long inst
)
1386 /* Does it look like a stw? */
1387 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1388 || (inst
>> 26) == 0x1f
1389 || ((inst
>> 26) == 0x1f
1390 && ((inst
>> 6) == 0xa)))
1391 return hppa_extract_5R_store (inst
);
1393 /* Does it look like a std? */
1394 if ((inst
>> 26) == 0x1c
1395 || ((inst
>> 26) == 0x03
1396 && ((inst
>> 6) & 0xf) == 0xb))
1397 return hppa_extract_5R_store (inst
);
1399 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1400 if ((inst
>> 26) == 0x1b)
1401 return hppa_extract_5R_store (inst
);
1403 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1405 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1406 || ((inst
>> 26) == 0x3
1407 && (((inst
>> 6) & 0xf) == 0x8
1408 || (inst
>> 6) & 0xf) == 0x9))
1409 return hppa_extract_5R_store (inst
);
1414 /* Return the register number for a FR which is saved by INST or
1415 zero it INST does not save a FR.
1417 Note we only care about full 64bit register stores (that's the only
1418 kind of stores the prologue will use).
1420 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1423 inst_saves_fr (unsigned long inst
)
1425 /* Is this an FSTD? */
1426 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1427 return hppa_extract_5r_store (inst
);
1428 if ((inst
& 0xfc000002) == 0x70000002)
1429 return hppa_extract_5R_store (inst
);
1430 /* Is this an FSTW? */
1431 if ((inst
& 0xfc00df80) == 0x24001200)
1432 return hppa_extract_5r_store (inst
);
1433 if ((inst
& 0xfc000002) == 0x7c000000)
1434 return hppa_extract_5R_store (inst
);
1438 /* Advance PC across any function entry prologue instructions
1439 to reach some "real" code.
1441 Use information in the unwind table to determine what exactly should
1442 be in the prologue. */
1446 skip_prologue_hard_way (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1447 int stop_before_branch
)
1449 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1451 CORE_ADDR orig_pc
= pc
;
1452 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1453 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1454 struct unwind_table_entry
*u
;
1455 int final_iteration
;
1461 u
= find_unwind_entry (pc
);
1465 /* If we are not at the beginning of a function, then return now. */
1466 if ((pc
& ~0x3) != u
->region_start
)
1469 /* This is how much of a frame adjustment we need to account for. */
1470 stack_remaining
= u
->Total_frame_size
<< 3;
1472 /* Magic register saves we want to know about. */
1473 save_rp
= u
->Save_RP
;
1474 save_sp
= u
->Save_SP
;
1476 /* An indication that args may be stored into the stack. Unfortunately
1477 the HPUX compilers tend to set this in cases where no args were
1481 /* Turn the Entry_GR field into a bitmask. */
1483 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1485 /* Frame pointer gets saved into a special location. */
1486 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1489 save_gr
|= (1 << i
);
1491 save_gr
&= ~restart_gr
;
1493 /* Turn the Entry_FR field into a bitmask too. */
1495 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1496 save_fr
|= (1 << i
);
1497 save_fr
&= ~restart_fr
;
1499 final_iteration
= 0;
1501 /* Loop until we find everything of interest or hit a branch.
1503 For unoptimized GCC code and for any HP CC code this will never ever
1504 examine any user instructions.
1506 For optimzied GCC code we're faced with problems. GCC will schedule
1507 its prologue and make prologue instructions available for delay slot
1508 filling. The end result is user code gets mixed in with the prologue
1509 and a prologue instruction may be in the delay slot of the first branch
1512 Some unexpected things are expected with debugging optimized code, so
1513 we allow this routine to walk past user instructions in optimized
1515 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1518 unsigned int reg_num
;
1519 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1520 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1522 /* Save copies of all the triggers so we can compare them later
1524 old_save_gr
= save_gr
;
1525 old_save_fr
= save_fr
;
1526 old_save_rp
= save_rp
;
1527 old_save_sp
= save_sp
;
1528 old_stack_remaining
= stack_remaining
;
1530 status
= target_read_memory (pc
, buf
, 4);
1531 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1537 /* Note the interesting effects of this instruction. */
1538 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1540 /* There are limited ways to store the return pointer into the
1542 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1545 /* These are the only ways we save SP into the stack. At this time
1546 the HP compilers never bother to save SP into the stack. */
1547 if ((inst
& 0xffffc000) == 0x6fc10000
1548 || (inst
& 0xffffc00c) == 0x73c10008)
1551 /* Are we loading some register with an offset from the argument
1553 if ((inst
& 0xffe00000) == 0x37a00000
1554 || (inst
& 0xffffffe0) == 0x081d0240)
1560 /* Account for general and floating-point register saves. */
1561 reg_num
= inst_saves_gr (inst
);
1562 save_gr
&= ~(1 << reg_num
);
1564 /* Ugh. Also account for argument stores into the stack.
1565 Unfortunately args_stored only tells us that some arguments
1566 where stored into the stack. Not how many or what kind!
1568 This is a kludge as on the HP compiler sets this bit and it
1569 never does prologue scheduling. So once we see one, skip past
1570 all of them. We have similar code for the fp arg stores below.
1572 FIXME. Can still die if we have a mix of GR and FR argument
1574 if (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1577 while (reg_num
>= (gdbarch_ptr_bit (gdbarch
) == 64 ? 19 : 23)
1581 status
= target_read_memory (pc
, buf
, 4);
1582 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1585 reg_num
= inst_saves_gr (inst
);
1591 reg_num
= inst_saves_fr (inst
);
1592 save_fr
&= ~(1 << reg_num
);
1594 status
= target_read_memory (pc
+ 4, buf
, 4);
1595 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1601 /* We've got to be read to handle the ldo before the fp register
1603 if ((inst
& 0xfc000000) == 0x34000000
1604 && inst_saves_fr (next_inst
) >= 4
1605 && inst_saves_fr (next_inst
)
1606 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1608 /* So we drop into the code below in a reasonable state. */
1609 reg_num
= inst_saves_fr (next_inst
);
1613 /* Ugh. Also account for argument stores into the stack.
1614 This is a kludge as on the HP compiler sets this bit and it
1615 never does prologue scheduling. So once we see one, skip past
1618 && reg_num
<= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1622 <= (gdbarch_ptr_bit (gdbarch
) == 64 ? 11 : 7))
1625 status
= target_read_memory (pc
, buf
, 4);
1626 inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1629 if ((inst
& 0xfc000000) != 0x34000000)
1631 status
= target_read_memory (pc
+ 4, buf
, 4);
1632 next_inst
= extract_unsigned_integer (buf
, 4, byte_order
);
1635 reg_num
= inst_saves_fr (next_inst
);
1641 /* Quit if we hit any kind of branch. This can happen if a prologue
1642 instruction is in the delay slot of the first call/branch. */
1643 if (is_branch (inst
) && stop_before_branch
)
1646 /* What a crock. The HP compilers set args_stored even if no
1647 arguments were stored into the stack (boo hiss). This could
1648 cause this code to then skip a bunch of user insns (up to the
1651 To combat this we try to identify when args_stored was bogusly
1652 set and clear it. We only do this when args_stored is nonzero,
1653 all other resources are accounted for, and nothing changed on
1656 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1657 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1658 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1659 && old_stack_remaining
== stack_remaining
)
1665 /* !stop_before_branch, so also look at the insn in the delay slot
1667 if (final_iteration
)
1669 if (is_branch (inst
))
1670 final_iteration
= 1;
1673 /* We've got a tenative location for the end of the prologue. However
1674 because of limitations in the unwind descriptor mechanism we may
1675 have went too far into user code looking for the save of a register
1676 that does not exist. So, if there registers we expected to be saved
1677 but never were, mask them out and restart.
1679 This should only happen in optimized code, and should be very rare. */
1680 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1683 restart_gr
= save_gr
;
1684 restart_fr
= save_fr
;
1692 /* Return the address of the PC after the last prologue instruction if
1693 we can determine it from the debug symbols. Else return zero. */
1696 after_prologue (CORE_ADDR pc
)
1698 struct symtab_and_line sal
;
1699 CORE_ADDR func_addr
, func_end
;
1701 /* If we can not find the symbol in the partial symbol table, then
1702 there is no hope we can determine the function's start address
1704 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1707 /* Get the line associated with FUNC_ADDR. */
1708 sal
= find_pc_line (func_addr
, 0);
1710 /* There are only two cases to consider. First, the end of the source line
1711 is within the function bounds. In that case we return the end of the
1712 source line. Second is the end of the source line extends beyond the
1713 bounds of the current function. We need to use the slow code to
1714 examine instructions in that case.
1716 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1717 the wrong thing to do. In fact, it should be entirely possible for this
1718 function to always return zero since the slow instruction scanning code
1719 is supposed to *always* work. If it does not, then it is a bug. */
1720 if (sal
.end
< func_end
)
1726 /* To skip prologues, I use this predicate. Returns either PC itself
1727 if the code at PC does not look like a function prologue; otherwise
1728 returns an address that (if we're lucky) follows the prologue.
1730 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1731 It doesn't necessarily skips all the insns in the prologue. In fact
1732 we might not want to skip all the insns because a prologue insn may
1733 appear in the delay slot of the first branch, and we don't want to
1734 skip over the branch in that case. */
1737 hppa_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1739 CORE_ADDR post_prologue_pc
;
1741 /* See if we can determine the end of the prologue via the symbol table.
1742 If so, then return either PC, or the PC after the prologue, whichever
1745 post_prologue_pc
= after_prologue (pc
);
1747 /* If after_prologue returned a useful address, then use it. Else
1748 fall back on the instruction skipping code.
1750 Some folks have claimed this causes problems because the breakpoint
1751 may be the first instruction of the prologue. If that happens, then
1752 the instruction skipping code has a bug that needs to be fixed. */
1753 if (post_prologue_pc
!= 0)
1754 return max (pc
, post_prologue_pc
);
1756 return (skip_prologue_hard_way (gdbarch
, pc
, 1));
1759 /* Return an unwind entry that falls within the frame's code block. */
1761 static struct unwind_table_entry
*
1762 hppa_find_unwind_entry_in_block (struct frame_info
*this_frame
)
1764 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
1766 /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1767 result of get_frame_address_in_block implies a problem.
1768 The bits should have been removed earlier, before the return
1769 value of gdbarch_unwind_pc. That might be happening already;
1770 if it isn't, it should be fixed. Then this call can be
1772 pc
= gdbarch_addr_bits_remove (get_frame_arch (this_frame
), pc
);
1773 return find_unwind_entry (pc
);
1776 struct hppa_frame_cache
1779 struct trad_frame_saved_reg
*saved_regs
;
1782 static struct hppa_frame_cache
*
1783 hppa_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1785 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1786 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1787 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1788 struct hppa_frame_cache
*cache
;
1792 struct unwind_table_entry
*u
;
1793 CORE_ADDR prologue_end
;
1798 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1799 frame_relative_level(this_frame
));
1801 if ((*this_cache
) != NULL
)
1804 fprintf_unfiltered (gdb_stdlog
, "base=%s (cached) }",
1805 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
1806 return (*this_cache
);
1808 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1809 (*this_cache
) = cache
;
1810 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1813 u
= hppa_find_unwind_entry_in_block (this_frame
);
1817 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1818 return (*this_cache
);
1821 /* Turn the Entry_GR field into a bitmask. */
1823 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1825 /* Frame pointer gets saved into a special location. */
1826 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1829 saved_gr_mask
|= (1 << i
);
1832 /* Turn the Entry_FR field into a bitmask too. */
1834 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1835 saved_fr_mask
|= (1 << i
);
1837 /* Loop until we find everything of interest or hit a branch.
1839 For unoptimized GCC code and for any HP CC code this will never ever
1840 examine any user instructions.
1842 For optimized GCC code we're faced with problems. GCC will schedule
1843 its prologue and make prologue instructions available for delay slot
1844 filling. The end result is user code gets mixed in with the prologue
1845 and a prologue instruction may be in the delay slot of the first branch
1848 Some unexpected things are expected with debugging optimized code, so
1849 we allow this routine to walk past user instructions in optimized
1852 int final_iteration
= 0;
1853 CORE_ADDR pc
, start_pc
, end_pc
;
1854 int looking_for_sp
= u
->Save_SP
;
1855 int looking_for_rp
= u
->Save_RP
;
1858 /* We have to use skip_prologue_hard_way instead of just
1859 skip_prologue_using_sal, in case we stepped into a function without
1860 symbol information. hppa_skip_prologue also bounds the returned
1861 pc by the passed in pc, so it will not return a pc in the next
1864 We used to call hppa_skip_prologue to find the end of the prologue,
1865 but if some non-prologue instructions get scheduled into the prologue,
1866 and the program is compiled with debug information, the "easy" way
1867 in hppa_skip_prologue will return a prologue end that is too early
1868 for us to notice any potential frame adjustments. */
1870 /* We used to use get_frame_func to locate the beginning of the
1871 function to pass to skip_prologue. However, when objects are
1872 compiled without debug symbols, get_frame_func can return the wrong
1873 function (or 0). We can do better than that by using unwind records.
1874 This only works if the Region_description of the unwind record
1875 indicates that it includes the entry point of the function.
1876 HP compilers sometimes generate unwind records for regions that
1877 do not include the entry or exit point of a function. GNU tools
1880 if ((u
->Region_description
& 0x2) == 0)
1881 start_pc
= u
->region_start
;
1883 start_pc
= get_frame_func (this_frame
);
1885 prologue_end
= skip_prologue_hard_way (gdbarch
, start_pc
, 0);
1886 end_pc
= get_frame_pc (this_frame
);
1888 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1889 end_pc
= prologue_end
;
1894 ((saved_gr_mask
|| saved_fr_mask
1895 || looking_for_sp
|| looking_for_rp
1896 || frame_size
< (u
->Total_frame_size
<< 3))
1904 if (!safe_frame_unwind_memory (this_frame
, pc
, buf4
, sizeof buf4
))
1906 error (_("Cannot read instruction at %s."),
1907 paddress (gdbarch
, pc
));
1908 return (*this_cache
);
1911 inst
= extract_unsigned_integer (buf4
, sizeof buf4
, byte_order
);
1913 /* Note the interesting effects of this instruction. */
1914 frame_size
+= prologue_inst_adjust_sp (inst
);
1916 /* There are limited ways to store the return pointer into the
1918 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1921 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1923 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1926 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1928 else if (inst
== 0x0fc212c1
1929 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1932 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1935 /* Check to see if we saved SP into the stack. This also
1936 happens to indicate the location of the saved frame
1938 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1939 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1942 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1944 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1949 /* Account for general and floating-point register saves. */
1950 reg
= inst_saves_gr (inst
);
1951 if (reg
>= 3 && reg
<= 18
1952 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1954 saved_gr_mask
&= ~(1 << reg
);
1955 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1956 /* stwm with a positive displacement is a _post_
1958 cache
->saved_regs
[reg
].addr
= 0;
1959 else if ((inst
& 0xfc00000c) == 0x70000008)
1960 /* A std has explicit post_modify forms. */
1961 cache
->saved_regs
[reg
].addr
= 0;
1966 if ((inst
>> 26) == 0x1c)
1967 offset
= (inst
& 0x1 ? -1 << 13 : 0)
1968 | (((inst
>> 4) & 0x3ff) << 3);
1969 else if ((inst
>> 26) == 0x03)
1970 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1972 offset
= hppa_extract_14 (inst
);
1974 /* Handle code with and without frame pointers. */
1976 cache
->saved_regs
[reg
].addr
= offset
;
1978 cache
->saved_regs
[reg
].addr
1979 = (u
->Total_frame_size
<< 3) + offset
;
1983 /* GCC handles callee saved FP regs a little differently.
1985 It emits an instruction to put the value of the start of
1986 the FP store area into %r1. It then uses fstds,ma with a
1987 basereg of %r1 for the stores.
1989 HP CC emits them at the current stack pointer modifying the
1990 stack pointer as it stores each register. */
1992 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1993 if ((inst
& 0xffffc000) == 0x34610000
1994 || (inst
& 0xffffc000) == 0x37c10000)
1995 fp_loc
= hppa_extract_14 (inst
);
1997 reg
= inst_saves_fr (inst
);
1998 if (reg
>= 12 && reg
<= 21)
2000 /* Note +4 braindamage below is necessary because the FP
2001 status registers are internally 8 registers rather than
2002 the expected 4 registers. */
2003 saved_fr_mask
&= ~(1 << reg
);
2006 /* 1st HP CC FP register store. After this
2007 instruction we've set enough state that the GCC and
2008 HPCC code are both handled in the same manner. */
2009 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
2014 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
2019 /* Quit if we hit any kind of branch the previous iteration. */
2020 if (final_iteration
)
2022 /* We want to look precisely one instruction beyond the branch
2023 if we have not found everything yet. */
2024 if (is_branch (inst
))
2025 final_iteration
= 1;
2030 /* The frame base always represents the value of %sp at entry to
2031 the current function (and is thus equivalent to the "saved"
2033 CORE_ADDR this_sp
= get_frame_register_unsigned (this_frame
,
2038 fprintf_unfiltered (gdb_stdlog
, " (this_sp=%s, pc=%s, "
2039 "prologue_end=%s) ",
2040 paddress (gdbarch
, this_sp
),
2041 paddress (gdbarch
, get_frame_pc (this_frame
)),
2042 paddress (gdbarch
, prologue_end
));
2044 /* Check to see if a frame pointer is available, and use it for
2045 frame unwinding if it is.
2047 There are some situations where we need to rely on the frame
2048 pointer to do stack unwinding. For example, if a function calls
2049 alloca (), the stack pointer can get adjusted inside the body of
2050 the function. In this case, the ABI requires that the compiler
2051 maintain a frame pointer for the function.
2053 The unwind record has a flag (alloca_frame) that indicates that
2054 a function has a variable frame; unfortunately, gcc/binutils
2055 does not set this flag. Instead, whenever a frame pointer is used
2056 and saved on the stack, the Save_SP flag is set. We use this to
2057 decide whether to use the frame pointer for unwinding.
2059 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2060 instead of Save_SP. */
2062 fp
= get_frame_register_unsigned (this_frame
, HPPA_FP_REGNUM
);
2064 if (u
->alloca_frame
)
2065 fp
-= u
->Total_frame_size
<< 3;
2067 if (get_frame_pc (this_frame
) >= prologue_end
2068 && (u
->Save_SP
|| u
->alloca_frame
) && fp
!= 0)
2073 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [frame pointer]",
2074 paddress (gdbarch
, cache
->base
));
2077 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
2079 /* Both we're expecting the SP to be saved and the SP has been
2080 saved. The entry SP value is saved at this frame's SP
2082 cache
->base
= read_memory_integer (this_sp
, word_size
, byte_order
);
2085 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [saved]",
2086 paddress (gdbarch
, cache
->base
));
2090 /* The prologue has been slowly allocating stack space. Adjust
2092 cache
->base
= this_sp
- frame_size
;
2094 fprintf_unfiltered (gdb_stdlog
, " (base=%s) [unwind adjust]",
2095 paddress (gdbarch
, cache
->base
));
2098 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2101 /* The PC is found in the "return register", "Millicode" uses "r31"
2102 as the return register while normal code uses "rp". */
2105 if (trad_frame_addr_p (cache
->saved_regs
, 31))
2107 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2109 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2113 ULONGEST r31
= get_frame_register_unsigned (this_frame
, 31);
2114 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
2116 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2121 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2123 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2124 cache
->saved_regs
[HPPA_RP_REGNUM
];
2126 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2130 ULONGEST rp
= get_frame_register_unsigned (this_frame
,
2132 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2134 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2138 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2139 frame. However, there is a one-insn window where we haven't saved it
2140 yet, but we've already clobbered it. Detect this case and fix it up.
2142 The prologue sequence for frame-pointer functions is:
2143 0: stw %rp, -20(%sp)
2146 c: stw,ma %r1, XX(%sp)
2148 So if we are at offset c, the r3 value that we want is not yet saved
2149 on the stack, but it's been overwritten. The prologue analyzer will
2150 set fp_in_r1 when it sees the copy insn so we know to get the value
2152 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
2155 ULONGEST r1
= get_frame_register_unsigned (this_frame
, 1);
2156 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
2160 /* Convert all the offsets into addresses. */
2162 for (reg
= 0; reg
< gdbarch_num_regs (gdbarch
); reg
++)
2164 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
2165 cache
->saved_regs
[reg
].addr
+= cache
->base
;
2170 struct gdbarch_tdep
*tdep
;
2172 tdep
= gdbarch_tdep (gdbarch
);
2174 if (tdep
->unwind_adjust_stub
)
2175 tdep
->unwind_adjust_stub (this_frame
, cache
->base
, cache
->saved_regs
);
2179 fprintf_unfiltered (gdb_stdlog
, "base=%s }",
2180 paddress (gdbarch
, ((struct hppa_frame_cache
*)*this_cache
)->base
));
2181 return (*this_cache
);
2185 hppa_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2186 struct frame_id
*this_id
)
2188 struct hppa_frame_cache
*info
;
2189 CORE_ADDR pc
= get_frame_pc (this_frame
);
2190 struct unwind_table_entry
*u
;
2192 info
= hppa_frame_cache (this_frame
, this_cache
);
2193 u
= hppa_find_unwind_entry_in_block (this_frame
);
2195 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2198 static struct value
*
2199 hppa_frame_prev_register (struct frame_info
*this_frame
,
2200 void **this_cache
, int regnum
)
2202 struct hppa_frame_cache
*info
= hppa_frame_cache (this_frame
, this_cache
);
2204 return hppa_frame_prev_register_helper (this_frame
,
2205 info
->saved_regs
, regnum
);
2209 hppa_frame_unwind_sniffer (const struct frame_unwind
*self
,
2210 struct frame_info
*this_frame
, void **this_cache
)
2212 if (hppa_find_unwind_entry_in_block (this_frame
))
2218 static const struct frame_unwind hppa_frame_unwind
=
2221 default_frame_unwind_stop_reason
,
2223 hppa_frame_prev_register
,
2225 hppa_frame_unwind_sniffer
2228 /* This is a generic fallback frame unwinder that kicks in if we fail all
2229 the other ones. Normally we would expect the stub and regular unwinder
2230 to work, but in some cases we might hit a function that just doesn't
2231 have any unwind information available. In this case we try to do
2232 unwinding solely based on code reading. This is obviously going to be
2233 slow, so only use this as a last resort. Currently this will only
2234 identify the stack and pc for the frame. */
2236 static struct hppa_frame_cache
*
2237 hppa_fallback_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
2239 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2240 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2241 struct hppa_frame_cache
*cache
;
2242 unsigned int frame_size
= 0;
2247 fprintf_unfiltered (gdb_stdlog
,
2248 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2249 frame_relative_level (this_frame
));
2251 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2252 (*this_cache
) = cache
;
2253 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2255 start_pc
= get_frame_func (this_frame
);
2258 CORE_ADDR cur_pc
= get_frame_pc (this_frame
);
2261 for (pc
= start_pc
; pc
< cur_pc
; pc
+= 4)
2265 insn
= read_memory_unsigned_integer (pc
, 4, byte_order
);
2266 frame_size
+= prologue_inst_adjust_sp (insn
);
2268 /* There are limited ways to store the return pointer into the
2270 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2272 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2275 else if (insn
== 0x0fc212c1
2276 || insn
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2278 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2285 fprintf_unfiltered (gdb_stdlog
, " frame_size=%d, found_rp=%d }\n",
2286 frame_size
, found_rp
);
2288 cache
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2289 cache
->base
-= frame_size
;
2290 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2292 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2294 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2295 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2296 cache
->saved_regs
[HPPA_RP_REGNUM
];
2301 rp
= get_frame_register_unsigned (this_frame
, HPPA_RP_REGNUM
);
2302 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2309 hppa_fallback_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
2310 struct frame_id
*this_id
)
2312 struct hppa_frame_cache
*info
=
2313 hppa_fallback_frame_cache (this_frame
, this_cache
);
2315 (*this_id
) = frame_id_build (info
->base
, get_frame_func (this_frame
));
2318 static struct value
*
2319 hppa_fallback_frame_prev_register (struct frame_info
*this_frame
,
2320 void **this_cache
, int regnum
)
2322 struct hppa_frame_cache
*info
2323 = hppa_fallback_frame_cache (this_frame
, this_cache
);
2325 return hppa_frame_prev_register_helper (this_frame
,
2326 info
->saved_regs
, regnum
);
2329 static const struct frame_unwind hppa_fallback_frame_unwind
=
2332 default_frame_unwind_stop_reason
,
2333 hppa_fallback_frame_this_id
,
2334 hppa_fallback_frame_prev_register
,
2336 default_frame_sniffer
2339 /* Stub frames, used for all kinds of call stubs. */
2340 struct hppa_stub_unwind_cache
2343 struct trad_frame_saved_reg
*saved_regs
;
2346 static struct hppa_stub_unwind_cache
*
2347 hppa_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2350 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2351 struct hppa_stub_unwind_cache
*info
;
2352 struct unwind_table_entry
*u
;
2357 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2359 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2361 info
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
2363 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2365 /* HPUX uses export stubs in function calls; the export stub clobbers
2366 the return value of the caller, and, later restores it from the
2368 u
= find_unwind_entry (get_frame_pc (this_frame
));
2370 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2372 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2378 /* By default we assume that stubs do not change the rp. */
2379 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2385 hppa_stub_frame_this_id (struct frame_info
*this_frame
,
2386 void **this_prologue_cache
,
2387 struct frame_id
*this_id
)
2389 struct hppa_stub_unwind_cache
*info
2390 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2393 *this_id
= frame_id_build (info
->base
, get_frame_func (this_frame
));
2396 static struct value
*
2397 hppa_stub_frame_prev_register (struct frame_info
*this_frame
,
2398 void **this_prologue_cache
, int regnum
)
2400 struct hppa_stub_unwind_cache
*info
2401 = hppa_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2404 error (_("Requesting registers from null frame."));
2406 return hppa_frame_prev_register_helper (this_frame
,
2407 info
->saved_regs
, regnum
);
2411 hppa_stub_unwind_sniffer (const struct frame_unwind
*self
,
2412 struct frame_info
*this_frame
,
2415 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
2416 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2417 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2420 || (tdep
->in_solib_call_trampoline
!= NULL
2421 && tdep
->in_solib_call_trampoline (gdbarch
, pc
, NULL
))
2422 || gdbarch_in_solib_return_trampoline (gdbarch
, pc
, NULL
))
2427 static const struct frame_unwind hppa_stub_frame_unwind
= {
2429 default_frame_unwind_stop_reason
,
2430 hppa_stub_frame_this_id
,
2431 hppa_stub_frame_prev_register
,
2433 hppa_stub_unwind_sniffer
2436 static struct frame_id
2437 hppa_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2439 return frame_id_build (get_frame_register_unsigned (this_frame
,
2441 get_frame_pc (this_frame
));
2445 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2450 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2451 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2453 /* If the current instruction is nullified, then we are effectively
2454 still executing the previous instruction. Pretend we are still
2455 there. This is needed when single stepping; if the nullified
2456 instruction is on a different line, we don't want GDB to think
2457 we've stepped onto that line. */
2458 if (ipsw
& 0x00200000)
2464 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2465 Return NULL if no such symbol was found. */
2467 struct minimal_symbol
*
2468 hppa_lookup_stub_minimal_symbol (const char *name
,
2469 enum unwind_stub_types stub_type
)
2471 struct objfile
*objfile
;
2472 struct minimal_symbol
*msym
;
2474 ALL_MSYMBOLS (objfile
, msym
)
2476 if (strcmp (SYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2478 struct unwind_table_entry
*u
;
2480 u
= find_unwind_entry (SYMBOL_VALUE (msym
));
2481 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2490 unwind_command (char *exp
, int from_tty
)
2493 struct unwind_table_entry
*u
;
2495 /* If we have an expression, evaluate it and use it as the address. */
2497 if (exp
!= 0 && *exp
!= 0)
2498 address
= parse_and_eval_address (exp
);
2502 u
= find_unwind_entry (address
);
2506 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2510 printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u
));
2512 printf_unfiltered ("\tregion_start = %s\n", hex_string (u
->region_start
));
2513 gdb_flush (gdb_stdout
);
2515 printf_unfiltered ("\tregion_end = %s\n", hex_string (u
->region_end
));
2516 gdb_flush (gdb_stdout
);
2518 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2520 printf_unfiltered ("\n\tflags =");
2521 pif (Cannot_unwind
);
2523 pif (Millicode_save_sr0
);
2526 pif (Variable_Frame
);
2527 pif (Separate_Package_Body
);
2528 pif (Frame_Extension_Millicode
);
2529 pif (Stack_Overflow_Check
);
2530 pif (Two_Instruction_SP_Increment
);
2533 pif (cxx_try_catch
);
2534 pif (sched_entry_seq
);
2537 pif (Save_MRP_in_frame
);
2539 pif (Cleanup_defined
);
2540 pif (MPE_XL_interrupt_marker
);
2541 pif (HP_UX_interrupt_marker
);
2545 putchar_unfiltered ('\n');
2547 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2549 pin (Region_description
);
2552 pin (Total_frame_size
);
2554 if (u
->stub_unwind
.stub_type
)
2556 printf_unfiltered ("\tstub type = ");
2557 switch (u
->stub_unwind
.stub_type
)
2560 printf_unfiltered ("long branch\n");
2562 case PARAMETER_RELOCATION
:
2563 printf_unfiltered ("parameter relocation\n");
2566 printf_unfiltered ("export\n");
2569 printf_unfiltered ("import\n");
2572 printf_unfiltered ("import shlib\n");
2575 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2580 /* Return the GDB type object for the "standard" data type of data in
2583 static struct type
*
2584 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2586 if (regnum
< HPPA_FP4_REGNUM
)
2587 return builtin_type (gdbarch
)->builtin_uint32
;
2589 return builtin_type (gdbarch
)->builtin_float
;
2592 static struct type
*
2593 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2595 if (regnum
< HPPA64_FP4_REGNUM
)
2596 return builtin_type (gdbarch
)->builtin_uint64
;
2598 return builtin_type (gdbarch
)->builtin_double
;
2601 /* Return non-zero if REGNUM is not a register available to the user
2602 through ptrace/ttrace. */
2605 hppa32_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2608 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2609 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2610 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2614 hppa32_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2616 /* cr26 and cr27 are readable (but not writable) from userspace. */
2617 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2620 return hppa32_cannot_store_register (gdbarch
, regnum
);
2624 hppa64_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
2627 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2628 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2629 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2633 hppa64_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
2635 /* cr26 and cr27 are readable (but not writable) from userspace. */
2636 if (regnum
== HPPA_CR26_REGNUM
|| regnum
== HPPA_CR27_REGNUM
)
2639 return hppa64_cannot_store_register (gdbarch
, regnum
);
2643 hppa_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2645 /* The low two bits of the PC on the PA contain the privilege level.
2646 Some genius implementing a (non-GCC) compiler apparently decided
2647 this means that "addresses" in a text section therefore include a
2648 privilege level, and thus symbol tables should contain these bits.
2649 This seems like a bonehead thing to do--anyway, it seems to work
2650 for our purposes to just ignore those bits. */
2652 return (addr
&= ~0x3);
2655 /* Get the ARGIth function argument for the current function. */
2658 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2661 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2664 static enum register_status
2665 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2666 int regnum
, gdb_byte
*buf
)
2668 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2670 enum register_status status
;
2672 status
= regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2673 if (status
== REG_VALID
)
2675 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2677 store_unsigned_integer (buf
, sizeof tmp
, byte_order
, tmp
);
2683 hppa_find_global_pointer (struct gdbarch
*gdbarch
, struct value
*function
)
2689 hppa_frame_prev_register_helper (struct frame_info
*this_frame
,
2690 struct trad_frame_saved_reg saved_regs
[],
2693 struct gdbarch
*arch
= get_frame_arch (this_frame
);
2694 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
2696 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2698 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2700 struct value
*pcoq_val
=
2701 trad_frame_get_prev_register (this_frame
, saved_regs
,
2702 HPPA_PCOQ_HEAD_REGNUM
);
2704 pc
= extract_unsigned_integer (value_contents_all (pcoq_val
),
2706 return frame_unwind_got_constant (this_frame
, regnum
, pc
+ 4);
2709 /* Make sure the "flags" register is zero in all unwound frames.
2710 The "flags" registers is a HP-UX specific wart, and only the code
2711 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2712 with it here. This shouldn't affect other systems since those
2713 should provide zero for the "flags" register anyway. */
2714 if (regnum
== HPPA_FLAGS_REGNUM
)
2715 return frame_unwind_got_constant (this_frame
, regnum
, 0);
2717 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
2721 /* An instruction to match. */
2724 unsigned int data
; /* See if it matches this.... */
2725 unsigned int mask
; /* ... with this mask. */
2728 /* See bfd/elf32-hppa.c */
2729 static struct insn_pattern hppa_long_branch_stub
[] = {
2730 /* ldil LR'xxx,%r1 */
2731 { 0x20200000, 0xffe00000 },
2732 /* be,n RR'xxx(%sr4,%r1) */
2733 { 0xe0202002, 0xffe02002 },
2737 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
2739 { 0xe8200000, 0xffe00000 },
2740 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2741 { 0x28200000, 0xffe00000 },
2742 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2743 { 0xe0202002, 0xffe02002 },
2747 static struct insn_pattern hppa_import_stub
[] = {
2748 /* addil LR'xxx, %dp */
2749 { 0x2b600000, 0xffe00000 },
2750 /* ldw RR'xxx(%r1), %r21 */
2751 { 0x48350000, 0xffffb000 },
2753 { 0xeaa0c000, 0xffffffff },
2754 /* ldw RR'xxx+4(%r1), %r19 */
2755 { 0x48330000, 0xffffb000 },
2759 static struct insn_pattern hppa_import_pic_stub
[] = {
2760 /* addil LR'xxx,%r19 */
2761 { 0x2a600000, 0xffe00000 },
2762 /* ldw RR'xxx(%r1),%r21 */
2763 { 0x48350000, 0xffffb000 },
2765 { 0xeaa0c000, 0xffffffff },
2766 /* ldw RR'xxx+4(%r1),%r19 */
2767 { 0x48330000, 0xffffb000 },
2771 static struct insn_pattern hppa_plt_stub
[] = {
2772 /* b,l 1b, %r20 - 1b is 3 insns before here */
2773 { 0xea9f1fdd, 0xffffffff },
2774 /* depi 0,31,2,%r20 */
2775 { 0xd6801c1e, 0xffffffff },
2779 static struct insn_pattern hppa_sigtramp
[] = {
2780 /* ldi 0, %r25 or ldi 1, %r25 */
2781 { 0x34190000, 0xfffffffd },
2782 /* ldi __NR_rt_sigreturn, %r20 */
2783 { 0x3414015a, 0xffffffff },
2784 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
2785 { 0xe4008200, 0xffffffff },
2787 { 0x08000240, 0xffffffff },
2791 /* Maximum number of instructions on the patterns above. */
2792 #define HPPA_MAX_INSN_PATTERN_LEN 4
2794 /* Return non-zero if the instructions at PC match the series
2795 described in PATTERN, or zero otherwise. PATTERN is an array of
2796 'struct insn_pattern' objects, terminated by an entry whose mask is
2799 When the match is successful, fill INSN[i] with what PATTERN[i]
2803 hppa_match_insns (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2804 struct insn_pattern
*pattern
, unsigned int *insn
)
2806 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2810 for (i
= 0; pattern
[i
].mask
; i
++)
2812 gdb_byte buf
[HPPA_INSN_SIZE
];
2814 target_read_memory (npc
, buf
, HPPA_INSN_SIZE
);
2815 insn
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
, byte_order
);
2816 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
2825 /* This relaxed version of the insstruction matcher allows us to match
2826 from somewhere inside the pattern, by looking backwards in the
2827 instruction scheme. */
2830 hppa_match_insns_relaxed (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
2831 struct insn_pattern
*pattern
, unsigned int *insn
)
2833 int offset
, len
= 0;
2835 while (pattern
[len
].mask
)
2838 for (offset
= 0; offset
< len
; offset
++)
2839 if (hppa_match_insns (gdbarch
, pc
- offset
* HPPA_INSN_SIZE
,
2847 hppa_in_dyncall (CORE_ADDR pc
)
2849 struct unwind_table_entry
*u
;
2851 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2855 return (pc
>= u
->region_start
&& pc
<= u
->region_end
);
2859 hppa_in_solib_call_trampoline (struct gdbarch
*gdbarch
,
2860 CORE_ADDR pc
, char *name
)
2862 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2863 struct unwind_table_entry
*u
;
2865 if (in_plt_section (pc
, name
) || hppa_in_dyncall (pc
))
2868 /* The GNU toolchain produces linker stubs without unwind
2869 information. Since the pattern matching for linker stubs can be
2870 quite slow, so bail out if we do have an unwind entry. */
2872 u
= find_unwind_entry (pc
);
2877 (hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_stub
, insn
)
2878 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_import_pic_stub
, insn
)
2879 || hppa_match_insns_relaxed (gdbarch
, pc
, hppa_long_branch_stub
, insn
)
2880 || hppa_match_insns_relaxed (gdbarch
, pc
,
2881 hppa_long_branch_pic_stub
, insn
));
2884 /* This code skips several kind of "trampolines" used on PA-RISC
2885 systems: $$dyncall, import stubs and PLT stubs. */
2888 hppa_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
2890 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2891 struct type
*func_ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
2893 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2896 /* $$dyncall handles both PLABELs and direct addresses. */
2897 if (hppa_in_dyncall (pc
))
2899 pc
= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 22);
2901 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2903 pc
= read_memory_typed_address (pc
& ~0x3, func_ptr_type
);
2908 dp_rel
= hppa_match_insns (gdbarch
, pc
, hppa_import_stub
, insn
);
2909 if (dp_rel
|| hppa_match_insns (gdbarch
, pc
, hppa_import_pic_stub
, insn
))
2911 /* Extract the target address from the addil/ldw sequence. */
2912 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
2915 pc
+= get_frame_register_unsigned (frame
, HPPA_DP_REGNUM
);
2917 pc
+= get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 19);
2922 if (in_plt_section (pc
, NULL
))
2924 pc
= read_memory_typed_address (pc
, func_ptr_type
);
2926 /* If the PLT slot has not yet been resolved, the target will be
2928 if (in_plt_section (pc
, NULL
))
2930 /* Sanity check: are we pointing to the PLT stub? */
2931 if (!hppa_match_insns (gdbarch
, pc
, hppa_plt_stub
, insn
))
2933 warning (_("Cannot resolve PLT stub at %s."),
2934 paddress (gdbarch
, pc
));
2938 /* This should point to the fixup routine. */
2939 pc
= read_memory_typed_address (pc
+ 8, func_ptr_type
);
2947 /* Here is a table of C type sizes on hppa with various compiles
2948 and options. I measured this on PA 9000/800 with HP-UX 11.11
2949 and these compilers:
2951 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2952 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2953 /opt/aCC/bin/aCC B3910B A.03.45
2954 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2956 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2957 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2958 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2959 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2960 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2961 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2962 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2963 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2967 compiler and options
2968 char, short, int, long, long long
2969 float, double, long double
2972 So all these compilers use either ILP32 or LP64 model.
2973 TODO: gcc has more options so it needs more investigation.
2975 For floating point types, see:
2977 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2978 HP-UX floating-point guide, hpux 11.00
2980 -- chastain 2003-12-18 */
2982 static struct gdbarch
*
2983 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2985 struct gdbarch_tdep
*tdep
;
2986 struct gdbarch
*gdbarch
;
2988 /* Try to determine the ABI of the object we are loading. */
2989 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2991 /* If it's a SOM file, assume it's HP/UX SOM. */
2992 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2993 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2996 /* find a candidate among the list of pre-declared architectures. */
2997 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2999 return (arches
->gdbarch
);
3001 /* If none found, then allocate and initialize one. */
3002 tdep
= XZALLOC (struct gdbarch_tdep
);
3003 gdbarch
= gdbarch_alloc (&info
, tdep
);
3005 /* Determine from the bfd_arch_info structure if we are dealing with
3006 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3007 then default to a 32bit machine. */
3008 if (info
.bfd_arch_info
!= NULL
)
3009 tdep
->bytes_per_address
=
3010 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3012 tdep
->bytes_per_address
= 4;
3014 tdep
->find_global_pointer
= hppa_find_global_pointer
;
3016 /* Some parts of the gdbarch vector depend on whether we are running
3017 on a 32 bits or 64 bits target. */
3018 switch (tdep
->bytes_per_address
)
3021 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3022 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3023 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3024 set_gdbarch_cannot_store_register (gdbarch
,
3025 hppa32_cannot_store_register
);
3026 set_gdbarch_cannot_fetch_register (gdbarch
,
3027 hppa32_cannot_fetch_register
);
3030 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3031 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3032 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3033 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3034 set_gdbarch_cannot_store_register (gdbarch
,
3035 hppa64_cannot_store_register
);
3036 set_gdbarch_cannot_fetch_register (gdbarch
,
3037 hppa64_cannot_fetch_register
);
3040 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
3041 tdep
->bytes_per_address
);
3044 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3045 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3047 /* The following gdbarch vector elements are the same in both ILP32
3048 and LP64, but might show differences some day. */
3049 set_gdbarch_long_long_bit (gdbarch
, 64);
3050 set_gdbarch_long_double_bit (gdbarch
, 128);
3051 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3053 /* The following gdbarch vector elements do not depend on the address
3054 size, or in any other gdbarch element previously set. */
3055 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3056 set_gdbarch_in_function_epilogue_p (gdbarch
,
3057 hppa_in_function_epilogue_p
);
3058 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
3059 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3060 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3061 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
3062 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
3063 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3064 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
3065 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
3067 /* Helper for function argument information. */
3068 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3070 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
3072 /* When a hardware watchpoint triggers, we'll move the inferior past
3073 it by removing all eventpoints; stepping past the instruction
3074 that caused the trigger; reinserting eventpoints; and checking
3075 whether any watched location changed. */
3076 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3078 /* Inferior function call methods. */
3079 switch (tdep
->bytes_per_address
)
3082 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3083 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3084 set_gdbarch_convert_from_func_ptr_addr
3085 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
3088 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3089 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3092 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3095 /* Struct return methods. */
3096 switch (tdep
->bytes_per_address
)
3099 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3102 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3105 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3108 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
3109 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
3111 /* Frame unwind methods. */
3112 set_gdbarch_dummy_id (gdbarch
, hppa_dummy_id
);
3113 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3115 /* Hook in ABI-specific overrides, if they have been registered. */
3116 gdbarch_init_osabi (info
, gdbarch
);
3118 /* Hook in the default unwinders. */
3119 frame_unwind_append_unwinder (gdbarch
, &hppa_stub_frame_unwind
);
3120 frame_unwind_append_unwinder (gdbarch
, &hppa_frame_unwind
);
3121 frame_unwind_append_unwinder (gdbarch
, &hppa_fallback_frame_unwind
);
3127 hppa_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
3129 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3131 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
3132 tdep
->bytes_per_address
);
3133 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
3136 /* Provide a prototype to silence -Wmissing-prototypes. */
3137 extern initialize_file_ftype _initialize_hppa_tdep
;
3140 _initialize_hppa_tdep (void)
3142 struct cmd_list_element
*c
;
3144 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3146 hppa_objfile_priv_data
= register_objfile_data ();
3148 add_cmd ("unwind", class_maintenance
, unwind_command
,
3149 _("Print unwind table entry at given address."),
3150 &maintenanceprintlist
);
3152 /* Debug this files internals. */
3153 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
3154 Set whether hppa target specific debugging information should be displayed."),
3156 Show whether hppa target specific debugging information is displayed."), _("\
3157 This flag controls whether hppa target specific debugging information is\n\
3158 displayed. This information is particularly useful for debugging frame\n\
3159 unwinding problems."),
3161 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
3162 &setdebuglist
, &showdebuglist
);