1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
5 Free Software Foundation, Inc.
7 Contributed by the Center for Software Science at the
8 University of Utah (pa-gdb-bugs@cs.utah.edu).
10 This file is part of GDB.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 51 Franklin Street, Fifth Floor,
25 Boston, MA 02110-1301, USA. */
31 #include "completer.h"
33 #include "gdb_assert.h"
34 #include "arch-utils.h"
35 /* For argument passing to the inferior */
38 #include "trad-frame.h"
39 #include "frame-unwind.h"
40 #include "frame-base.h"
45 #include "hppa-tdep.h"
47 static int hppa_debug
= 0;
49 /* Some local constants. */
50 static const int hppa32_num_regs
= 128;
51 static const int hppa64_num_regs
= 96;
53 /* hppa-specific object data -- unwind and solib info.
54 TODO/maybe: think about splitting this into two parts; the unwind data is
55 common to all hppa targets, but is only used in this file; we can register
56 that separately and make this static. The solib data is probably hpux-
57 specific, so we can create a separate extern objfile_data that is registered
58 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
59 const struct objfile_data
*hppa_objfile_priv_data
= NULL
;
61 /* Get at various relevent fields of an instruction word. */
64 #define MASK_14 0x3fff
65 #define MASK_21 0x1fffff
67 /* Sizes (in bytes) of the native unwind entries. */
68 #define UNWIND_ENTRY_SIZE 16
69 #define STUB_UNWIND_ENTRY_SIZE 8
71 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
72 following functions static, once we hppa is partially multiarched. */
73 int hppa_pc_requires_run_before_use (CORE_ADDR pc
);
75 /* Routines to extract various sized constants out of hppa
78 /* This assumes that no garbage lies outside of the lower bits of
82 hppa_sign_extend (unsigned val
, unsigned bits
)
84 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
87 /* For many immediate values the sign bit is the low bit! */
90 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
92 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
95 /* Extract the bits at positions between FROM and TO, using HP's numbering
99 hppa_get_field (unsigned word
, int from
, int to
)
101 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
104 /* extract the immediate field from a ld{bhw}s instruction */
107 hppa_extract_5_load (unsigned word
)
109 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
112 /* extract the immediate field from a break instruction */
115 hppa_extract_5r_store (unsigned word
)
117 return (word
& MASK_5
);
120 /* extract the immediate field from a {sr}sm instruction */
123 hppa_extract_5R_store (unsigned word
)
125 return (word
>> 16 & MASK_5
);
128 /* extract a 14 bit immediate field */
131 hppa_extract_14 (unsigned word
)
133 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
136 /* extract a 21 bit constant */
139 hppa_extract_21 (unsigned word
)
145 val
= hppa_get_field (word
, 20, 20);
147 val
|= hppa_get_field (word
, 9, 19);
149 val
|= hppa_get_field (word
, 5, 6);
151 val
|= hppa_get_field (word
, 0, 4);
153 val
|= hppa_get_field (word
, 7, 8);
154 return hppa_sign_extend (val
, 21) << 11;
157 /* extract a 17 bit constant from branch instructions, returning the
158 19 bit signed value. */
161 hppa_extract_17 (unsigned word
)
163 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
164 hppa_get_field (word
, 29, 29) << 10 |
165 hppa_get_field (word
, 11, 15) << 11 |
166 (word
& 0x1) << 16, 17) << 2;
170 hppa_symbol_address(const char *sym
)
172 struct minimal_symbol
*minsym
;
174 minsym
= lookup_minimal_symbol (sym
, NULL
, NULL
);
176 return SYMBOL_VALUE_ADDRESS (minsym
);
178 return (CORE_ADDR
)-1;
181 struct hppa_objfile_private
*
182 hppa_init_objfile_priv_data (struct objfile
*objfile
)
184 struct hppa_objfile_private
*priv
;
186 priv
= (struct hppa_objfile_private
*)
187 obstack_alloc (&objfile
->objfile_obstack
,
188 sizeof (struct hppa_objfile_private
));
189 set_objfile_data (objfile
, hppa_objfile_priv_data
, priv
);
190 memset (priv
, 0, sizeof (*priv
));
196 /* Compare the start address for two unwind entries returning 1 if
197 the first address is larger than the second, -1 if the second is
198 larger than the first, and zero if they are equal. */
201 compare_unwind_entries (const void *arg1
, const void *arg2
)
203 const struct unwind_table_entry
*a
= arg1
;
204 const struct unwind_table_entry
*b
= arg2
;
206 if (a
->region_start
> b
->region_start
)
208 else if (a
->region_start
< b
->region_start
)
215 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
217 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
218 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
220 bfd_vma value
= section
->vma
- section
->filepos
;
221 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
223 if (value
< *low_text_segment_address
)
224 *low_text_segment_address
= value
;
229 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
230 asection
*section
, unsigned int entries
, unsigned int size
,
231 CORE_ADDR text_offset
)
233 /* We will read the unwind entries into temporary memory, then
234 fill in the actual unwind table. */
240 char *buf
= alloca (size
);
241 CORE_ADDR low_text_segment_address
;
243 /* For ELF targets, then unwinds are supposed to
244 be segment relative offsets instead of absolute addresses.
246 Note that when loading a shared library (text_offset != 0) the
247 unwinds are already relative to the text_offset that will be
249 if (gdbarch_tdep (current_gdbarch
)->is_elf
&& text_offset
== 0)
251 low_text_segment_address
= -1;
253 bfd_map_over_sections (objfile
->obfd
,
254 record_text_segment_lowaddr
,
255 &low_text_segment_address
);
257 text_offset
= low_text_segment_address
;
259 else if (gdbarch_tdep (current_gdbarch
)->solib_get_text_base
)
261 text_offset
= gdbarch_tdep (current_gdbarch
)->solib_get_text_base (objfile
);
264 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
266 /* Now internalize the information being careful to handle host/target
268 for (i
= 0; i
< entries
; i
++)
270 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
272 table
[i
].region_start
+= text_offset
;
274 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
275 table
[i
].region_end
+= text_offset
;
277 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
279 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
280 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
281 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
282 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
283 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
284 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
285 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
286 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
287 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
288 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
289 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
290 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
291 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
292 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
293 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
294 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
295 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
296 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
297 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
298 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
299 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
300 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
301 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
302 table
[i
].Cleanup_defined
= tmp
& 0x1;
303 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
305 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
306 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
307 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
308 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
309 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
310 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
312 /* Stub unwinds are handled elsewhere. */
313 table
[i
].stub_unwind
.stub_type
= 0;
314 table
[i
].stub_unwind
.padding
= 0;
319 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
320 the object file. This info is used mainly by find_unwind_entry() to find
321 out the stack frame size and frame pointer used by procedures. We put
322 everything on the psymbol obstack in the objfile so that it automatically
323 gets freed when the objfile is destroyed. */
326 read_unwind_info (struct objfile
*objfile
)
328 asection
*unwind_sec
, *stub_unwind_sec
;
329 unsigned unwind_size
, stub_unwind_size
, total_size
;
330 unsigned index
, unwind_entries
;
331 unsigned stub_entries
, total_entries
;
332 CORE_ADDR text_offset
;
333 struct hppa_unwind_info
*ui
;
334 struct hppa_objfile_private
*obj_private
;
336 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
337 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
338 sizeof (struct hppa_unwind_info
));
344 /* For reasons unknown the HP PA64 tools generate multiple unwinder
345 sections in a single executable. So we just iterate over every
346 section in the BFD looking for unwinder sections intead of trying
347 to do a lookup with bfd_get_section_by_name.
349 First determine the total size of the unwind tables so that we
350 can allocate memory in a nice big hunk. */
352 for (unwind_sec
= objfile
->obfd
->sections
;
354 unwind_sec
= unwind_sec
->next
)
356 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
357 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
359 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
360 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
362 total_entries
+= unwind_entries
;
366 /* Now compute the size of the stub unwinds. Note the ELF tools do not
367 use stub unwinds at the current time. */
368 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
372 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
373 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
377 stub_unwind_size
= 0;
381 /* Compute total number of unwind entries and their total size. */
382 total_entries
+= stub_entries
;
383 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
385 /* Allocate memory for the unwind table. */
386 ui
->table
= (struct unwind_table_entry
*)
387 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
388 ui
->last
= total_entries
- 1;
390 /* Now read in each unwind section and internalize the standard unwind
393 for (unwind_sec
= objfile
->obfd
->sections
;
395 unwind_sec
= unwind_sec
->next
)
397 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
398 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
400 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
401 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
403 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
404 unwind_entries
, unwind_size
, text_offset
);
405 index
+= unwind_entries
;
409 /* Now read in and internalize the stub unwind entries. */
410 if (stub_unwind_size
> 0)
413 char *buf
= alloca (stub_unwind_size
);
415 /* Read in the stub unwind entries. */
416 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
417 0, stub_unwind_size
);
419 /* Now convert them into regular unwind entries. */
420 for (i
= 0; i
< stub_entries
; i
++, index
++)
422 /* Clear out the next unwind entry. */
423 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
425 /* Convert offset & size into region_start and region_end.
426 Stuff away the stub type into "reserved" fields. */
427 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
429 ui
->table
[index
].region_start
+= text_offset
;
431 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
434 ui
->table
[index
].region_end
435 = ui
->table
[index
].region_start
+ 4 *
436 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
442 /* Unwind table needs to be kept sorted. */
443 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
444 compare_unwind_entries
);
446 /* Keep a pointer to the unwind information. */
447 obj_private
= (struct hppa_objfile_private
*)
448 objfile_data (objfile
, hppa_objfile_priv_data
);
449 if (obj_private
== NULL
)
450 obj_private
= hppa_init_objfile_priv_data (objfile
);
452 obj_private
->unwind_info
= ui
;
455 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
456 of the objfiles seeking the unwind table entry for this PC. Each objfile
457 contains a sorted list of struct unwind_table_entry. Since we do a binary
458 search of the unwind tables, we depend upon them to be sorted. */
460 struct unwind_table_entry
*
461 find_unwind_entry (CORE_ADDR pc
)
463 int first
, middle
, last
;
464 struct objfile
*objfile
;
465 struct hppa_objfile_private
*priv
;
468 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
471 /* A function at address 0? Not in HP-UX! */
472 if (pc
== (CORE_ADDR
) 0)
475 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
479 ALL_OBJFILES (objfile
)
481 struct hppa_unwind_info
*ui
;
483 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
485 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
489 read_unwind_info (objfile
);
490 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
492 error (_("Internal error reading unwind information."));
493 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
496 /* First, check the cache */
499 && pc
>= ui
->cache
->region_start
500 && pc
<= ui
->cache
->region_end
)
503 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
504 paddr_nz ((CORE_ADDR
) ui
->cache
));
508 /* Not in the cache, do a binary search */
513 while (first
<= last
)
515 middle
= (first
+ last
) / 2;
516 if (pc
>= ui
->table
[middle
].region_start
517 && pc
<= ui
->table
[middle
].region_end
)
519 ui
->cache
= &ui
->table
[middle
];
521 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
522 paddr_nz ((CORE_ADDR
) ui
->cache
));
523 return &ui
->table
[middle
];
526 if (pc
< ui
->table
[middle
].region_start
)
531 } /* ALL_OBJFILES() */
534 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
539 /* The epilogue is defined here as the area either on the `bv' instruction
540 itself or an instruction which destroys the function's stack frame.
542 We do not assume that the epilogue is at the end of a function as we can
543 also have return sequences in the middle of a function. */
545 hppa_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
547 unsigned long status
;
552 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
556 inst
= extract_unsigned_integer (buf
, 4);
558 /* The most common way to perform a stack adjustment ldo X(sp),sp
559 We are destroying a stack frame if the offset is negative. */
560 if ((inst
& 0xffffc000) == 0x37de0000
561 && hppa_extract_14 (inst
) < 0)
564 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
565 if (((inst
& 0x0fc010e0) == 0x0fc010e0
566 || (inst
& 0x0fc010e0) == 0x0fc010e0)
567 && hppa_extract_14 (inst
) < 0)
570 /* bv %r0(%rp) or bv,n %r0(%rp) */
571 if (inst
== 0xe840c000 || inst
== 0xe840c002)
577 static const unsigned char *
578 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
580 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
581 (*len
) = sizeof (breakpoint
);
585 /* Return the name of a register. */
588 hppa32_register_name (int i
)
590 static char *names
[] = {
591 "flags", "r1", "rp", "r3",
592 "r4", "r5", "r6", "r7",
593 "r8", "r9", "r10", "r11",
594 "r12", "r13", "r14", "r15",
595 "r16", "r17", "r18", "r19",
596 "r20", "r21", "r22", "r23",
597 "r24", "r25", "r26", "dp",
598 "ret0", "ret1", "sp", "r31",
599 "sar", "pcoqh", "pcsqh", "pcoqt",
600 "pcsqt", "eiem", "iir", "isr",
601 "ior", "ipsw", "goto", "sr4",
602 "sr0", "sr1", "sr2", "sr3",
603 "sr5", "sr6", "sr7", "cr0",
604 "cr8", "cr9", "ccr", "cr12",
605 "cr13", "cr24", "cr25", "cr26",
606 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
607 "fpsr", "fpe1", "fpe2", "fpe3",
608 "fpe4", "fpe5", "fpe6", "fpe7",
609 "fr4", "fr4R", "fr5", "fr5R",
610 "fr6", "fr6R", "fr7", "fr7R",
611 "fr8", "fr8R", "fr9", "fr9R",
612 "fr10", "fr10R", "fr11", "fr11R",
613 "fr12", "fr12R", "fr13", "fr13R",
614 "fr14", "fr14R", "fr15", "fr15R",
615 "fr16", "fr16R", "fr17", "fr17R",
616 "fr18", "fr18R", "fr19", "fr19R",
617 "fr20", "fr20R", "fr21", "fr21R",
618 "fr22", "fr22R", "fr23", "fr23R",
619 "fr24", "fr24R", "fr25", "fr25R",
620 "fr26", "fr26R", "fr27", "fr27R",
621 "fr28", "fr28R", "fr29", "fr29R",
622 "fr30", "fr30R", "fr31", "fr31R"
624 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
631 hppa64_register_name (int i
)
633 static char *names
[] = {
634 "flags", "r1", "rp", "r3",
635 "r4", "r5", "r6", "r7",
636 "r8", "r9", "r10", "r11",
637 "r12", "r13", "r14", "r15",
638 "r16", "r17", "r18", "r19",
639 "r20", "r21", "r22", "r23",
640 "r24", "r25", "r26", "dp",
641 "ret0", "ret1", "sp", "r31",
642 "sar", "pcoqh", "pcsqh", "pcoqt",
643 "pcsqt", "eiem", "iir", "isr",
644 "ior", "ipsw", "goto", "sr4",
645 "sr0", "sr1", "sr2", "sr3",
646 "sr5", "sr6", "sr7", "cr0",
647 "cr8", "cr9", "ccr", "cr12",
648 "cr13", "cr24", "cr25", "cr26",
649 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
650 "fpsr", "fpe1", "fpe2", "fpe3",
651 "fr4", "fr5", "fr6", "fr7",
652 "fr8", "fr9", "fr10", "fr11",
653 "fr12", "fr13", "fr14", "fr15",
654 "fr16", "fr17", "fr18", "fr19",
655 "fr20", "fr21", "fr22", "fr23",
656 "fr24", "fr25", "fr26", "fr27",
657 "fr28", "fr29", "fr30", "fr31"
659 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
666 hppa64_dwarf_reg_to_regnum (int reg
)
668 /* r0-r31 and sar map one-to-one. */
672 /* fr4-fr31 are mapped from 72 in steps of 2. */
673 if (reg
>= 72 || reg
< 72 + 28 * 2)
674 return HPPA64_FP4_REGNUM
+ (reg
- 72) / 2;
676 error ("Invalid DWARF register num %d.", reg
);
680 /* This function pushes a stack frame with arguments as part of the
681 inferior function calling mechanism.
683 This is the version of the function for the 32-bit PA machines, in
684 which later arguments appear at lower addresses. (The stack always
685 grows towards higher addresses.)
687 We simply allocate the appropriate amount of stack space and put
688 arguments into their proper slots. */
691 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
692 struct regcache
*regcache
, CORE_ADDR bp_addr
,
693 int nargs
, struct value
**args
, CORE_ADDR sp
,
694 int struct_return
, CORE_ADDR struct_addr
)
696 /* Stack base address at which any pass-by-reference parameters are
698 CORE_ADDR struct_end
= 0;
699 /* Stack base address at which the first parameter is stored. */
700 CORE_ADDR param_end
= 0;
702 /* The inner most end of the stack after all the parameters have
704 CORE_ADDR new_sp
= 0;
706 /* Two passes. First pass computes the location of everything,
707 second pass writes the bytes out. */
710 /* Global pointer (r19) of the function we are trying to call. */
713 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
715 for (write_pass
= 0; write_pass
< 2; write_pass
++)
717 CORE_ADDR struct_ptr
= 0;
718 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
719 struct_ptr is adjusted for each argument below, so the first
720 argument will end up at sp-36. */
721 CORE_ADDR param_ptr
= 32;
723 int small_struct
= 0;
725 for (i
= 0; i
< nargs
; i
++)
727 struct value
*arg
= args
[i
];
728 struct type
*type
= check_typedef (value_type (arg
));
729 /* The corresponding parameter that is pushed onto the
730 stack, and [possibly] passed in a register. */
733 memset (param_val
, 0, sizeof param_val
);
734 if (TYPE_LENGTH (type
) > 8)
736 /* Large parameter, pass by reference. Store the value
737 in "struct" area and then pass its address. */
739 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
741 write_memory (struct_end
- struct_ptr
, value_contents (arg
),
743 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
745 else if (TYPE_CODE (type
) == TYPE_CODE_INT
746 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
748 /* Integer value store, right aligned. "unpack_long"
749 takes care of any sign-extension problems. */
750 param_len
= align_up (TYPE_LENGTH (type
), 4);
751 store_unsigned_integer (param_val
, param_len
,
753 value_contents (arg
)));
755 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
757 /* Floating point value store, right aligned. */
758 param_len
= align_up (TYPE_LENGTH (type
), 4);
759 memcpy (param_val
, value_contents (arg
), param_len
);
763 param_len
= align_up (TYPE_LENGTH (type
), 4);
765 /* Small struct value are stored right-aligned. */
766 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
767 value_contents (arg
), TYPE_LENGTH (type
));
769 /* Structures of size 5, 6 and 7 bytes are special in that
770 the higher-ordered word is stored in the lower-ordered
771 argument, and even though it is a 8-byte quantity the
772 registers need not be 8-byte aligned. */
773 if (param_len
> 4 && param_len
< 8)
777 param_ptr
+= param_len
;
778 if (param_len
== 8 && !small_struct
)
779 param_ptr
= align_up (param_ptr
, 8);
781 /* First 4 non-FP arguments are passed in gr26-gr23.
782 First 4 32-bit FP arguments are passed in fr4L-fr7L.
783 First 2 64-bit FP arguments are passed in fr5 and fr7.
785 The rest go on the stack, starting at sp-36, towards lower
786 addresses. 8-byte arguments must be aligned to a 8-byte
790 write_memory (param_end
- param_ptr
, param_val
, param_len
);
792 /* There are some cases when we don't know the type
793 expected by the callee (e.g. for variadic functions), so
794 pass the parameters in both general and fp regs. */
797 int grreg
= 26 - (param_ptr
- 36) / 4;
798 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
799 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
801 regcache_cooked_write (regcache
, grreg
, param_val
);
802 regcache_cooked_write (regcache
, fpLreg
, param_val
);
806 regcache_cooked_write (regcache
, grreg
+ 1,
809 regcache_cooked_write (regcache
, fpreg
, param_val
);
810 regcache_cooked_write (regcache
, fpreg
+ 1,
817 /* Update the various stack pointers. */
820 struct_end
= sp
+ align_up (struct_ptr
, 64);
821 /* PARAM_PTR already accounts for all the arguments passed
822 by the user. However, the ABI mandates minimum stack
823 space allocations for outgoing arguments. The ABI also
824 mandates minimum stack alignments which we must
826 param_end
= struct_end
+ align_up (param_ptr
, 64);
830 /* If a structure has to be returned, set up register 28 to hold its
833 write_register (28, struct_addr
);
835 gp
= tdep
->find_global_pointer (function
);
838 write_register (19, gp
);
840 /* Set the return address. */
841 if (!gdbarch_push_dummy_code_p (gdbarch
))
842 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
844 /* Update the Stack Pointer. */
845 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
850 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
851 Runtime Architecture for PA-RISC 2.0", which is distributed as part
852 as of the HP-UX Software Transition Kit (STK). This implementation
853 is based on version 3.3, dated October 6, 1997. */
855 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
858 hppa64_integral_or_pointer_p (const struct type
*type
)
860 switch (TYPE_CODE (type
))
866 case TYPE_CODE_RANGE
:
868 int len
= TYPE_LENGTH (type
);
869 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
873 return (TYPE_LENGTH (type
) == 8);
881 /* Check whether TYPE is a "Floating Scalar Type". */
884 hppa64_floating_p (const struct type
*type
)
886 switch (TYPE_CODE (type
))
890 int len
= TYPE_LENGTH (type
);
891 return (len
== 4 || len
== 8 || len
== 16);
900 /* If CODE points to a function entry address, try to look up the corresponding
901 function descriptor and return its address instead. If CODE is not a
902 function entry address, then just return it unchanged. */
904 hppa64_convert_code_addr_to_fptr (CORE_ADDR code
)
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
= opd
->addr
; addr
< opd
->endaddr
; addr
+= 2 * 8)
932 if (target_read_memory (addr
, tmp
, sizeof (tmp
)))
934 opdaddr
= extract_unsigned_integer (tmp
, sizeof (tmp
));
945 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
946 struct regcache
*regcache
, CORE_ADDR bp_addr
,
947 int nargs
, struct value
**args
, CORE_ADDR sp
,
948 int struct_return
, CORE_ADDR struct_addr
)
950 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
954 /* "The outgoing parameter area [...] must be aligned at a 16-byte
956 sp
= align_up (sp
, 16);
958 for (i
= 0; i
< nargs
; i
++)
960 struct value
*arg
= args
[i
];
961 struct type
*type
= value_type (arg
);
962 int len
= TYPE_LENGTH (type
);
963 const bfd_byte
*valbuf
;
967 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
968 offset
= align_up (offset
, 8);
970 if (hppa64_integral_or_pointer_p (type
))
972 /* "Integral scalar parameters smaller than 64 bits are
973 padded on the left (i.e., the value is in the
974 least-significant bits of the 64-bit storage unit, and
975 the high-order bits are undefined)." Therefore we can
976 safely sign-extend them. */
979 arg
= value_cast (builtin_type_int64
, arg
);
983 else if (hppa64_floating_p (type
))
987 /* "Quad-precision (128-bit) floating-point scalar
988 parameters are aligned on a 16-byte boundary." */
989 offset
= align_up (offset
, 16);
991 /* "Double-extended- and quad-precision floating-point
992 parameters within the first 64 bytes of the parameter
993 list are always passed in general registers." */
999 /* "Single-precision (32-bit) floating-point scalar
1000 parameters are padded on the left with 32 bits of
1001 garbage (i.e., the floating-point value is in the
1002 least-significant 32 bits of a 64-bit storage
1007 /* "Single- and double-precision floating-point
1008 parameters in this area are passed according to the
1009 available formal parameter information in a function
1010 prototype. [...] If no prototype is in scope,
1011 floating-point parameters must be passed both in the
1012 corresponding general registers and in the
1013 corresponding floating-point registers." */
1014 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
1016 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
1018 /* "Single-precision floating-point parameters, when
1019 passed in floating-point registers, are passed in
1020 the right halves of the floating point registers;
1021 the left halves are unused." */
1022 regcache_cooked_write_part (regcache
, regnum
, offset
% 8,
1023 len
, value_contents (arg
));
1031 /* "Aggregates larger than 8 bytes are aligned on a
1032 16-byte boundary, possibly leaving an unused argument
1033 slot, which is filled with garbage. If necessary,
1034 they are padded on the right (with garbage), to a
1035 multiple of 8 bytes." */
1036 offset
= align_up (offset
, 16);
1040 /* If we are passing a function pointer, make sure we pass a function
1041 descriptor instead of the function entry address. */
1042 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1043 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
)
1045 ULONGEST codeptr
, fptr
;
1047 codeptr
= unpack_long (type
, value_contents (arg
));
1048 fptr
= hppa64_convert_code_addr_to_fptr (codeptr
);
1049 store_unsigned_integer (fptrbuf
, TYPE_LENGTH (type
), fptr
);
1054 valbuf
= value_contents (arg
);
1057 /* Always store the argument in memory. */
1058 write_memory (sp
+ offset
, valbuf
, len
);
1060 regnum
= HPPA_ARG0_REGNUM
- offset
/ 8;
1061 while (regnum
> HPPA_ARG0_REGNUM
- 8 && len
> 0)
1063 regcache_cooked_write_part (regcache
, regnum
,
1064 offset
% 8, min (len
, 8), valbuf
);
1065 offset
+= min (len
, 8);
1066 valbuf
+= min (len
, 8);
1067 len
-= min (len
, 8);
1074 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1075 regcache_cooked_write_unsigned (regcache
, HPPA_RET1_REGNUM
, sp
+ 64);
1077 /* Allocate the outgoing parameter area. Make sure the outgoing
1078 parameter area is multiple of 16 bytes in length. */
1079 sp
+= max (align_up (offset
, 16), 64);
1081 /* Allocate 32-bytes of scratch space. The documentation doesn't
1082 mention this, but it seems to be needed. */
1085 /* Allocate the frame marker area. */
1088 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1091 regcache_cooked_write_unsigned (regcache
, HPPA_RET0_REGNUM
, struct_addr
);
1093 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1094 gp
= tdep
->find_global_pointer (function
);
1096 regcache_cooked_write_unsigned (regcache
, HPPA_DP_REGNUM
, gp
);
1098 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1099 if (!gdbarch_push_dummy_code_p (gdbarch
))
1100 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1102 /* Set up GR30 to hold the stack pointer (sp). */
1103 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, sp
);
1109 /* Handle 32/64-bit struct return conventions. */
1111 static enum return_value_convention
1112 hppa32_return_value (struct gdbarch
*gdbarch
,
1113 struct type
*type
, struct regcache
*regcache
,
1114 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1116 if (TYPE_LENGTH (type
) <= 2 * 4)
1118 /* The value always lives in the right hand end of the register
1119 (or register pair)? */
1121 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
1122 int part
= TYPE_LENGTH (type
) % 4;
1123 /* The left hand register contains only part of the value,
1124 transfer that first so that the rest can be xfered as entire
1125 4-byte registers. */
1128 if (readbuf
!= NULL
)
1129 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
1131 if (writebuf
!= NULL
)
1132 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
1136 /* Now transfer the remaining register values. */
1137 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
1139 if (readbuf
!= NULL
)
1140 regcache_cooked_read (regcache
, reg
, readbuf
+ b
);
1141 if (writebuf
!= NULL
)
1142 regcache_cooked_write (regcache
, reg
, writebuf
+ b
);
1145 return RETURN_VALUE_REGISTER_CONVENTION
;
1148 return RETURN_VALUE_STRUCT_CONVENTION
;
1151 static enum return_value_convention
1152 hppa64_return_value (struct gdbarch
*gdbarch
,
1153 struct type
*type
, struct regcache
*regcache
,
1154 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1156 int len
= TYPE_LENGTH (type
);
1161 /* All return values larget than 128 bits must be aggregate
1163 gdb_assert (!hppa64_integral_or_pointer_p (type
));
1164 gdb_assert (!hppa64_floating_p (type
));
1166 /* "Aggregate return values larger than 128 bits are returned in
1167 a buffer allocated by the caller. The address of the buffer
1168 must be passed in GR 28." */
1169 return RETURN_VALUE_STRUCT_CONVENTION
;
1172 if (hppa64_integral_or_pointer_p (type
))
1174 /* "Integral return values are returned in GR 28. Values
1175 smaller than 64 bits are padded on the left (with garbage)." */
1176 regnum
= HPPA_RET0_REGNUM
;
1179 else if (hppa64_floating_p (type
))
1183 /* "Double-extended- and quad-precision floating-point
1184 values are returned in GRs 28 and 29. The sign,
1185 exponent, and most-significant bits of the mantissa are
1186 returned in GR 28; the least-significant bits of the
1187 mantissa are passed in GR 29. For double-extended
1188 precision values, GR 29 is padded on the right with 48
1189 bits of garbage." */
1190 regnum
= HPPA_RET0_REGNUM
;
1195 /* "Single-precision and double-precision floating-point
1196 return values are returned in FR 4R (single precision) or
1197 FR 4 (double-precision)." */
1198 regnum
= HPPA64_FP4_REGNUM
;
1204 /* "Aggregate return values up to 64 bits in size are returned
1205 in GR 28. Aggregates smaller than 64 bits are left aligned
1206 in the register; the pad bits on the right are undefined."
1208 "Aggregate return values between 65 and 128 bits are returned
1209 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1210 the remaining bits are placed, left aligned, in GR 29. The
1211 pad bits on the right of GR 29 (if any) are undefined." */
1212 regnum
= HPPA_RET0_REGNUM
;
1220 regcache_cooked_read_part (regcache
, regnum
, offset
,
1221 min (len
, 8), readbuf
);
1222 readbuf
+= min (len
, 8);
1223 len
-= min (len
, 8);
1232 regcache_cooked_write_part (regcache
, regnum
, offset
,
1233 min (len
, 8), writebuf
);
1234 writebuf
+= min (len
, 8);
1235 len
-= min (len
, 8);
1240 return RETURN_VALUE_REGISTER_CONVENTION
;
1245 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1246 struct target_ops
*targ
)
1250 CORE_ADDR plabel
= addr
& ~3;
1251 return read_memory_typed_address (plabel
, builtin_type_void_func_ptr
);
1258 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1260 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1262 return align_up (addr
, 64);
1265 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1268 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1270 /* Just always 16-byte align. */
1271 return align_up (addr
, 16);
1275 hppa_read_pc (ptid_t ptid
)
1280 ipsw
= read_register_pid (HPPA_IPSW_REGNUM
, ptid
);
1281 pc
= read_register_pid (HPPA_PCOQ_HEAD_REGNUM
, ptid
);
1283 /* If the current instruction is nullified, then we are effectively
1284 still executing the previous instruction. Pretend we are still
1285 there. This is needed when single stepping; if the nullified
1286 instruction is on a different line, we don't want GDB to think
1287 we've stepped onto that line. */
1288 if (ipsw
& 0x00200000)
1295 hppa_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1297 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, pc
, ptid
);
1298 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4, ptid
);
1301 /* return the alignment of a type in bytes. Structures have the maximum
1302 alignment required by their fields. */
1305 hppa_alignof (struct type
*type
)
1307 int max_align
, align
, i
;
1308 CHECK_TYPEDEF (type
);
1309 switch (TYPE_CODE (type
))
1314 return TYPE_LENGTH (type
);
1315 case TYPE_CODE_ARRAY
:
1316 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1317 case TYPE_CODE_STRUCT
:
1318 case TYPE_CODE_UNION
:
1320 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1322 /* Bit fields have no real alignment. */
1323 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1324 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1326 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1327 max_align
= max (max_align
, align
);
1336 /* For the given instruction (INST), return any adjustment it makes
1337 to the stack pointer or zero for no adjustment.
1339 This only handles instructions commonly found in prologues. */
1342 prologue_inst_adjust_sp (unsigned long inst
)
1344 /* This must persist across calls. */
1345 static int save_high21
;
1347 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1348 if ((inst
& 0xffffc000) == 0x37de0000)
1349 return hppa_extract_14 (inst
);
1352 if ((inst
& 0xffe00000) == 0x6fc00000)
1353 return hppa_extract_14 (inst
);
1355 /* std,ma X,D(sp) */
1356 if ((inst
& 0xffe00008) == 0x73c00008)
1357 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1359 /* addil high21,%r30; ldo low11,(%r1),%r30)
1360 save high bits in save_high21 for later use. */
1361 if ((inst
& 0xffe00000) == 0x2bc00000)
1363 save_high21
= hppa_extract_21 (inst
);
1367 if ((inst
& 0xffff0000) == 0x343e0000)
1368 return save_high21
+ hppa_extract_14 (inst
);
1370 /* fstws as used by the HP compilers. */
1371 if ((inst
& 0xffffffe0) == 0x2fd01220)
1372 return hppa_extract_5_load (inst
);
1374 /* No adjustment. */
1378 /* Return nonzero if INST is a branch of some kind, else return zero. */
1381 is_branch (unsigned long inst
)
1410 /* Return the register number for a GR which is saved by INST or
1411 zero it INST does not save a GR. */
1414 inst_saves_gr (unsigned long inst
)
1416 /* Does it look like a stw? */
1417 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1418 || (inst
>> 26) == 0x1f
1419 || ((inst
>> 26) == 0x1f
1420 && ((inst
>> 6) == 0xa)))
1421 return hppa_extract_5R_store (inst
);
1423 /* Does it look like a std? */
1424 if ((inst
>> 26) == 0x1c
1425 || ((inst
>> 26) == 0x03
1426 && ((inst
>> 6) & 0xf) == 0xb))
1427 return hppa_extract_5R_store (inst
);
1429 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1430 if ((inst
>> 26) == 0x1b)
1431 return hppa_extract_5R_store (inst
);
1433 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1435 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1436 || ((inst
>> 26) == 0x3
1437 && (((inst
>> 6) & 0xf) == 0x8
1438 || (inst
>> 6) & 0xf) == 0x9))
1439 return hppa_extract_5R_store (inst
);
1444 /* Return the register number for a FR which is saved by INST or
1445 zero it INST does not save a FR.
1447 Note we only care about full 64bit register stores (that's the only
1448 kind of stores the prologue will use).
1450 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1453 inst_saves_fr (unsigned long inst
)
1455 /* is this an FSTD ? */
1456 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1457 return hppa_extract_5r_store (inst
);
1458 if ((inst
& 0xfc000002) == 0x70000002)
1459 return hppa_extract_5R_store (inst
);
1460 /* is this an FSTW ? */
1461 if ((inst
& 0xfc00df80) == 0x24001200)
1462 return hppa_extract_5r_store (inst
);
1463 if ((inst
& 0xfc000002) == 0x7c000000)
1464 return hppa_extract_5R_store (inst
);
1468 /* Advance PC across any function entry prologue instructions
1469 to reach some "real" code.
1471 Use information in the unwind table to determine what exactly should
1472 be in the prologue. */
1476 skip_prologue_hard_way (CORE_ADDR pc
, int stop_before_branch
)
1479 CORE_ADDR orig_pc
= pc
;
1480 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1481 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1482 struct unwind_table_entry
*u
;
1483 int final_iteration
;
1489 u
= find_unwind_entry (pc
);
1493 /* If we are not at the beginning of a function, then return now. */
1494 if ((pc
& ~0x3) != u
->region_start
)
1497 /* This is how much of a frame adjustment we need to account for. */
1498 stack_remaining
= u
->Total_frame_size
<< 3;
1500 /* Magic register saves we want to know about. */
1501 save_rp
= u
->Save_RP
;
1502 save_sp
= u
->Save_SP
;
1504 /* An indication that args may be stored into the stack. Unfortunately
1505 the HPUX compilers tend to set this in cases where no args were
1509 /* Turn the Entry_GR field into a bitmask. */
1511 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1513 /* Frame pointer gets saved into a special location. */
1514 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1517 save_gr
|= (1 << i
);
1519 save_gr
&= ~restart_gr
;
1521 /* Turn the Entry_FR field into a bitmask too. */
1523 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1524 save_fr
|= (1 << i
);
1525 save_fr
&= ~restart_fr
;
1527 final_iteration
= 0;
1529 /* Loop until we find everything of interest or hit a branch.
1531 For unoptimized GCC code and for any HP CC code this will never ever
1532 examine any user instructions.
1534 For optimzied GCC code we're faced with problems. GCC will schedule
1535 its prologue and make prologue instructions available for delay slot
1536 filling. The end result is user code gets mixed in with the prologue
1537 and a prologue instruction may be in the delay slot of the first branch
1540 Some unexpected things are expected with debugging optimized code, so
1541 we allow this routine to walk past user instructions in optimized
1543 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1546 unsigned int reg_num
;
1547 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1548 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1550 /* Save copies of all the triggers so we can compare them later
1552 old_save_gr
= save_gr
;
1553 old_save_fr
= save_fr
;
1554 old_save_rp
= save_rp
;
1555 old_save_sp
= save_sp
;
1556 old_stack_remaining
= stack_remaining
;
1558 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1559 inst
= extract_unsigned_integer (buf
, 4);
1565 /* Note the interesting effects of this instruction. */
1566 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1568 /* There are limited ways to store the return pointer into the
1570 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1573 /* These are the only ways we save SP into the stack. At this time
1574 the HP compilers never bother to save SP into the stack. */
1575 if ((inst
& 0xffffc000) == 0x6fc10000
1576 || (inst
& 0xffffc00c) == 0x73c10008)
1579 /* Are we loading some register with an offset from the argument
1581 if ((inst
& 0xffe00000) == 0x37a00000
1582 || (inst
& 0xffffffe0) == 0x081d0240)
1588 /* Account for general and floating-point register saves. */
1589 reg_num
= inst_saves_gr (inst
);
1590 save_gr
&= ~(1 << reg_num
);
1592 /* Ugh. Also account for argument stores into the stack.
1593 Unfortunately args_stored only tells us that some arguments
1594 where stored into the stack. Not how many or what kind!
1596 This is a kludge as on the HP compiler sets this bit and it
1597 never does prologue scheduling. So once we see one, skip past
1598 all of them. We have similar code for the fp arg stores below.
1600 FIXME. Can still die if we have a mix of GR and FR argument
1602 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1604 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1607 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1608 inst
= extract_unsigned_integer (buf
, 4);
1611 reg_num
= inst_saves_gr (inst
);
1617 reg_num
= inst_saves_fr (inst
);
1618 save_fr
&= ~(1 << reg_num
);
1620 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1621 next_inst
= extract_unsigned_integer (buf
, 4);
1627 /* We've got to be read to handle the ldo before the fp register
1629 if ((inst
& 0xfc000000) == 0x34000000
1630 && inst_saves_fr (next_inst
) >= 4
1631 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1633 /* So we drop into the code below in a reasonable state. */
1634 reg_num
= inst_saves_fr (next_inst
);
1638 /* Ugh. Also account for argument stores into the stack.
1639 This is a kludge as on the HP compiler sets this bit and it
1640 never does prologue scheduling. So once we see one, skip past
1642 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1644 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1647 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1648 inst
= extract_unsigned_integer (buf
, 4);
1651 if ((inst
& 0xfc000000) != 0x34000000)
1653 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1654 next_inst
= extract_unsigned_integer (buf
, 4);
1657 reg_num
= inst_saves_fr (next_inst
);
1663 /* Quit if we hit any kind of branch. This can happen if a prologue
1664 instruction is in the delay slot of the first call/branch. */
1665 if (is_branch (inst
) && stop_before_branch
)
1668 /* What a crock. The HP compilers set args_stored even if no
1669 arguments were stored into the stack (boo hiss). This could
1670 cause this code to then skip a bunch of user insns (up to the
1673 To combat this we try to identify when args_stored was bogusly
1674 set and clear it. We only do this when args_stored is nonzero,
1675 all other resources are accounted for, and nothing changed on
1678 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1679 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1680 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1681 && old_stack_remaining
== stack_remaining
)
1687 /* !stop_before_branch, so also look at the insn in the delay slot
1689 if (final_iteration
)
1691 if (is_branch (inst
))
1692 final_iteration
= 1;
1695 /* We've got a tenative location for the end of the prologue. However
1696 because of limitations in the unwind descriptor mechanism we may
1697 have went too far into user code looking for the save of a register
1698 that does not exist. So, if there registers we expected to be saved
1699 but never were, mask them out and restart.
1701 This should only happen in optimized code, and should be very rare. */
1702 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1705 restart_gr
= save_gr
;
1706 restart_fr
= save_fr
;
1714 /* Return the address of the PC after the last prologue instruction if
1715 we can determine it from the debug symbols. Else return zero. */
1718 after_prologue (CORE_ADDR pc
)
1720 struct symtab_and_line sal
;
1721 CORE_ADDR func_addr
, func_end
;
1724 /* If we can not find the symbol in the partial symbol table, then
1725 there is no hope we can determine the function's start address
1727 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1730 /* Get the line associated with FUNC_ADDR. */
1731 sal
= find_pc_line (func_addr
, 0);
1733 /* There are only two cases to consider. First, the end of the source line
1734 is within the function bounds. In that case we return the end of the
1735 source line. Second is the end of the source line extends beyond the
1736 bounds of the current function. We need to use the slow code to
1737 examine instructions in that case.
1739 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1740 the wrong thing to do. In fact, it should be entirely possible for this
1741 function to always return zero since the slow instruction scanning code
1742 is supposed to *always* work. If it does not, then it is a bug. */
1743 if (sal
.end
< func_end
)
1749 /* To skip prologues, I use this predicate. Returns either PC itself
1750 if the code at PC does not look like a function prologue; otherwise
1751 returns an address that (if we're lucky) follows the prologue.
1753 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1754 It doesn't necessarily skips all the insns in the prologue. In fact
1755 we might not want to skip all the insns because a prologue insn may
1756 appear in the delay slot of the first branch, and we don't want to
1757 skip over the branch in that case. */
1760 hppa_skip_prologue (CORE_ADDR pc
)
1764 CORE_ADDR post_prologue_pc
;
1767 /* See if we can determine the end of the prologue via the symbol table.
1768 If so, then return either PC, or the PC after the prologue, whichever
1771 post_prologue_pc
= after_prologue (pc
);
1773 /* If after_prologue returned a useful address, then use it. Else
1774 fall back on the instruction skipping code.
1776 Some folks have claimed this causes problems because the breakpoint
1777 may be the first instruction of the prologue. If that happens, then
1778 the instruction skipping code has a bug that needs to be fixed. */
1779 if (post_prologue_pc
!= 0)
1780 return max (pc
, post_prologue_pc
);
1782 return (skip_prologue_hard_way (pc
, 1));
1785 struct hppa_frame_cache
1788 struct trad_frame_saved_reg
*saved_regs
;
1791 static struct hppa_frame_cache
*
1792 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1794 struct hppa_frame_cache
*cache
;
1799 struct unwind_table_entry
*u
;
1800 CORE_ADDR prologue_end
;
1805 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1806 frame_relative_level(next_frame
));
1808 if ((*this_cache
) != NULL
)
1811 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1812 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1813 return (*this_cache
);
1815 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1816 (*this_cache
) = cache
;
1817 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1820 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
1824 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1825 return (*this_cache
);
1828 /* Turn the Entry_GR field into a bitmask. */
1830 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1832 /* Frame pointer gets saved into a special location. */
1833 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1836 saved_gr_mask
|= (1 << i
);
1839 /* Turn the Entry_FR field into a bitmask too. */
1841 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1842 saved_fr_mask
|= (1 << i
);
1844 /* Loop until we find everything of interest or hit a branch.
1846 For unoptimized GCC code and for any HP CC code this will never ever
1847 examine any user instructions.
1849 For optimized GCC code we're faced with problems. GCC will schedule
1850 its prologue and make prologue instructions available for delay slot
1851 filling. The end result is user code gets mixed in with the prologue
1852 and a prologue instruction may be in the delay slot of the first branch
1855 Some unexpected things are expected with debugging optimized code, so
1856 we allow this routine to walk past user instructions in optimized
1859 int final_iteration
= 0;
1860 CORE_ADDR pc
, end_pc
;
1861 int looking_for_sp
= u
->Save_SP
;
1862 int looking_for_rp
= u
->Save_RP
;
1865 /* We have to use skip_prologue_hard_way instead of just
1866 skip_prologue_using_sal, in case we stepped into a function without
1867 symbol information. hppa_skip_prologue also bounds the returned
1868 pc by the passed in pc, so it will not return a pc in the next
1871 We used to call hppa_skip_prologue to find the end of the prologue,
1872 but if some non-prologue instructions get scheduled into the prologue,
1873 and the program is compiled with debug information, the "easy" way
1874 in hppa_skip_prologue will return a prologue end that is too early
1875 for us to notice any potential frame adjustments. */
1877 /* We used to use frame_func_unwind () to locate the beginning of the
1878 function to pass to skip_prologue (). However, when objects are
1879 compiled without debug symbols, frame_func_unwind can return the wrong
1880 function (or 0). We can do better than that by using unwind records. */
1882 prologue_end
= skip_prologue_hard_way (u
->region_start
, 0);
1883 end_pc
= frame_pc_unwind (next_frame
);
1885 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1886 end_pc
= prologue_end
;
1890 for (pc
= u
->region_start
;
1891 ((saved_gr_mask
|| saved_fr_mask
1892 || looking_for_sp
|| looking_for_rp
1893 || frame_size
< (u
->Total_frame_size
<< 3))
1901 if (!safe_frame_unwind_memory (next_frame
, pc
, buf4
,
1904 error (_("Cannot read instruction at 0x%s."), paddr_nz (pc
));
1905 return (*this_cache
);
1908 inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1910 /* Note the interesting effects of this instruction. */
1911 frame_size
+= prologue_inst_adjust_sp (inst
);
1913 /* There are limited ways to store the return pointer into the
1915 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1918 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1920 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1923 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1925 else if (inst
== 0x0fc212c1
1926 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1929 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1932 /* Check to see if we saved SP into the stack. This also
1933 happens to indicate the location of the saved frame
1935 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1936 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1939 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1941 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1946 /* Account for general and floating-point register saves. */
1947 reg
= inst_saves_gr (inst
);
1948 if (reg
>= 3 && reg
<= 18
1949 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1951 saved_gr_mask
&= ~(1 << reg
);
1952 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1953 /* stwm with a positive displacement is a _post_
1955 cache
->saved_regs
[reg
].addr
= 0;
1956 else if ((inst
& 0xfc00000c) == 0x70000008)
1957 /* A std has explicit post_modify forms. */
1958 cache
->saved_regs
[reg
].addr
= 0;
1963 if ((inst
>> 26) == 0x1c)
1964 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1965 else if ((inst
>> 26) == 0x03)
1966 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1968 offset
= hppa_extract_14 (inst
);
1970 /* Handle code with and without frame pointers. */
1972 cache
->saved_regs
[reg
].addr
= offset
;
1974 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1978 /* GCC handles callee saved FP regs a little differently.
1980 It emits an instruction to put the value of the start of
1981 the FP store area into %r1. It then uses fstds,ma with a
1982 basereg of %r1 for the stores.
1984 HP CC emits them at the current stack pointer modifying the
1985 stack pointer as it stores each register. */
1987 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1988 if ((inst
& 0xffffc000) == 0x34610000
1989 || (inst
& 0xffffc000) == 0x37c10000)
1990 fp_loc
= hppa_extract_14 (inst
);
1992 reg
= inst_saves_fr (inst
);
1993 if (reg
>= 12 && reg
<= 21)
1995 /* Note +4 braindamage below is necessary because the FP
1996 status registers are internally 8 registers rather than
1997 the expected 4 registers. */
1998 saved_fr_mask
&= ~(1 << reg
);
2001 /* 1st HP CC FP register store. After this
2002 instruction we've set enough state that the GCC and
2003 HPCC code are both handled in the same manner. */
2004 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
2009 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
2014 /* Quit if we hit any kind of branch the previous iteration. */
2015 if (final_iteration
)
2017 /* We want to look precisely one instruction beyond the branch
2018 if we have not found everything yet. */
2019 if (is_branch (inst
))
2020 final_iteration
= 1;
2025 /* The frame base always represents the value of %sp at entry to
2026 the current function (and is thus equivalent to the "saved"
2028 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2032 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
2033 "prologue_end=0x%s) ",
2035 paddr_nz (frame_pc_unwind (next_frame
)),
2036 paddr_nz (prologue_end
));
2038 /* Check to see if a frame pointer is available, and use it for
2039 frame unwinding if it is.
2041 There are some situations where we need to rely on the frame
2042 pointer to do stack unwinding. For example, if a function calls
2043 alloca (), the stack pointer can get adjusted inside the body of
2044 the function. In this case, the ABI requires that the compiler
2045 maintain a frame pointer for the function.
2047 The unwind record has a flag (alloca_frame) that indicates that
2048 a function has a variable frame; unfortunately, gcc/binutils
2049 does not set this flag. Instead, whenever a frame pointer is used
2050 and saved on the stack, the Save_SP flag is set. We use this to
2051 decide whether to use the frame pointer for unwinding.
2053 TODO: For the HP compiler, maybe we should use the alloca_frame flag
2054 instead of Save_SP. */
2056 fp
= frame_unwind_register_unsigned (next_frame
, HPPA_FP_REGNUM
);
2058 if (frame_pc_unwind (next_frame
) >= prologue_end
2059 && u
->Save_SP
&& fp
!= 0)
2064 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer]",
2065 paddr_nz (cache
->base
));
2068 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
2070 /* Both we're expecting the SP to be saved and the SP has been
2071 saved. The entry SP value is saved at this frame's SP
2073 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
2076 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved]",
2077 paddr_nz (cache
->base
));
2081 /* The prologue has been slowly allocating stack space. Adjust
2083 cache
->base
= this_sp
- frame_size
;
2085 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust]",
2086 paddr_nz (cache
->base
));
2089 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2092 /* The PC is found in the "return register", "Millicode" uses "r31"
2093 as the return register while normal code uses "rp". */
2096 if (trad_frame_addr_p (cache
->saved_regs
, 31))
2098 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2100 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2104 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
2105 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
2107 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2112 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2114 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2115 cache
->saved_regs
[HPPA_RP_REGNUM
];
2117 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2121 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2122 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2124 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2128 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2129 frame. However, there is a one-insn window where we haven't saved it
2130 yet, but we've already clobbered it. Detect this case and fix it up.
2132 The prologue sequence for frame-pointer functions is:
2133 0: stw %rp, -20(%sp)
2136 c: stw,ma %r1, XX(%sp)
2138 So if we are at offset c, the r3 value that we want is not yet saved
2139 on the stack, but it's been overwritten. The prologue analyzer will
2140 set fp_in_r1 when it sees the copy insn so we know to get the value
2142 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
2145 ULONGEST r1
= frame_unwind_register_unsigned (next_frame
, 1);
2146 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
2150 /* Convert all the offsets into addresses. */
2152 for (reg
= 0; reg
< NUM_REGS
; reg
++)
2154 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
2155 cache
->saved_regs
[reg
].addr
+= cache
->base
;
2160 struct gdbarch
*gdbarch
;
2161 struct gdbarch_tdep
*tdep
;
2163 gdbarch
= get_frame_arch (next_frame
);
2164 tdep
= gdbarch_tdep (gdbarch
);
2166 if (tdep
->unwind_adjust_stub
)
2168 tdep
->unwind_adjust_stub (next_frame
, cache
->base
, cache
->saved_regs
);
2173 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
2174 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
2175 return (*this_cache
);
2179 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2180 struct frame_id
*this_id
)
2182 struct hppa_frame_cache
*info
;
2183 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2184 struct unwind_table_entry
*u
;
2186 info
= hppa_frame_cache (next_frame
, this_cache
);
2187 u
= find_unwind_entry (pc
);
2189 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2193 hppa_frame_prev_register (struct frame_info
*next_frame
,
2195 int regnum
, int *optimizedp
,
2196 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2197 int *realnump
, gdb_byte
*valuep
)
2199 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
2200 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2201 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2204 static const struct frame_unwind hppa_frame_unwind
=
2208 hppa_frame_prev_register
2211 static const struct frame_unwind
*
2212 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
2214 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2216 if (find_unwind_entry (pc
))
2217 return &hppa_frame_unwind
;
2222 /* This is a generic fallback frame unwinder that kicks in if we fail all
2223 the other ones. Normally we would expect the stub and regular unwinder
2224 to work, but in some cases we might hit a function that just doesn't
2225 have any unwind information available. In this case we try to do
2226 unwinding solely based on code reading. This is obviously going to be
2227 slow, so only use this as a last resort. Currently this will only
2228 identify the stack and pc for the frame. */
2230 static struct hppa_frame_cache
*
2231 hppa_fallback_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
2233 struct hppa_frame_cache
*cache
;
2234 unsigned int frame_size
= 0;
2239 fprintf_unfiltered (gdb_stdlog
,
2240 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2241 frame_relative_level (next_frame
));
2243 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2244 (*this_cache
) = cache
;
2245 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2247 start_pc
= frame_func_unwind (next_frame
);
2250 CORE_ADDR cur_pc
= frame_pc_unwind (next_frame
);
2253 for (pc
= start_pc
; pc
< cur_pc
; pc
+= 4)
2257 insn
= read_memory_unsigned_integer (pc
, 4);
2258 frame_size
+= prologue_inst_adjust_sp (insn
);
2260 /* There are limited ways to store the return pointer into the
2262 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2264 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2267 else if (insn
== 0x0fc212c1
2268 || insn
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2270 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2277 fprintf_unfiltered (gdb_stdlog
, " frame_size=%d, found_rp=%d }\n",
2278 frame_size
, found_rp
);
2280 cache
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2281 cache
->base
-= frame_size
;
2282 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2284 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2286 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2287 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2288 cache
->saved_regs
[HPPA_RP_REGNUM
];
2293 rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2294 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2301 hppa_fallback_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2302 struct frame_id
*this_id
)
2304 struct hppa_frame_cache
*info
=
2305 hppa_fallback_frame_cache (next_frame
, this_cache
);
2306 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2310 hppa_fallback_frame_prev_register (struct frame_info
*next_frame
,
2312 int regnum
, int *optimizedp
,
2313 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2314 int *realnump
, gdb_byte
*valuep
)
2316 struct hppa_frame_cache
*info
=
2317 hppa_fallback_frame_cache (next_frame
, this_cache
);
2318 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2319 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2322 static const struct frame_unwind hppa_fallback_frame_unwind
=
2325 hppa_fallback_frame_this_id
,
2326 hppa_fallback_frame_prev_register
2329 static const struct frame_unwind
*
2330 hppa_fallback_unwind_sniffer (struct frame_info
*next_frame
)
2332 return &hppa_fallback_frame_unwind
;
2335 /* Stub frames, used for all kinds of call stubs. */
2336 struct hppa_stub_unwind_cache
2339 struct trad_frame_saved_reg
*saved_regs
;
2342 static struct hppa_stub_unwind_cache
*
2343 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
2346 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2347 struct hppa_stub_unwind_cache
*info
;
2348 struct unwind_table_entry
*u
;
2353 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2355 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2357 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2359 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2361 /* HPUX uses export stubs in function calls; the export stub clobbers
2362 the return value of the caller, and, later restores it from the
2364 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
2366 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2368 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2374 /* By default we assume that stubs do not change the rp. */
2375 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2381 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
2382 void **this_prologue_cache
,
2383 struct frame_id
*this_id
)
2385 struct hppa_stub_unwind_cache
*info
2386 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2389 *this_id
= frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2391 *this_id
= null_frame_id
;
2395 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
2396 void **this_prologue_cache
,
2397 int regnum
, int *optimizedp
,
2398 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2399 int *realnump
, gdb_byte
*valuep
)
2401 struct hppa_stub_unwind_cache
*info
2402 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2405 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2406 optimizedp
, lvalp
, addrp
, realnump
,
2409 error (_("Requesting registers from null frame."));
2412 static const struct frame_unwind hppa_stub_frame_unwind
= {
2414 hppa_stub_frame_this_id
,
2415 hppa_stub_frame_prev_register
2418 static const struct frame_unwind
*
2419 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
2421 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2422 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2423 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2426 || (tdep
->in_solib_call_trampoline
!= NULL
2427 && tdep
->in_solib_call_trampoline (pc
, NULL
))
2428 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
2429 return &hppa_stub_frame_unwind
;
2433 static struct frame_id
2434 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2436 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2438 frame_pc_unwind (next_frame
));
2442 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2447 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2448 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2450 /* If the current instruction is nullified, then we are effectively
2451 still executing the previous instruction. Pretend we are still
2452 there. This is needed when single stepping; if the nullified
2453 instruction is on a different line, we don't want GDB to think
2454 we've stepped onto that line. */
2455 if (ipsw
& 0x00200000)
2461 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2462 Return NULL if no such symbol was found. */
2464 struct minimal_symbol
*
2465 hppa_lookup_stub_minimal_symbol (const char *name
,
2466 enum unwind_stub_types stub_type
)
2468 struct objfile
*objfile
;
2469 struct minimal_symbol
*msym
;
2471 ALL_MSYMBOLS (objfile
, msym
)
2473 if (strcmp (SYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2475 struct unwind_table_entry
*u
;
2477 u
= find_unwind_entry (SYMBOL_VALUE (msym
));
2478 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2487 unwind_command (char *exp
, int from_tty
)
2490 struct unwind_table_entry
*u
;
2492 /* If we have an expression, evaluate it and use it as the address. */
2494 if (exp
!= 0 && *exp
!= 0)
2495 address
= parse_and_eval_address (exp
);
2499 u
= find_unwind_entry (address
);
2503 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2507 printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u
);
2509 printf_unfiltered ("\tregion_start = ");
2510 print_address (u
->region_start
, gdb_stdout
);
2511 gdb_flush (gdb_stdout
);
2513 printf_unfiltered ("\n\tregion_end = ");
2514 print_address (u
->region_end
, gdb_stdout
);
2515 gdb_flush (gdb_stdout
);
2517 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2519 printf_unfiltered ("\n\tflags =");
2520 pif (Cannot_unwind
);
2522 pif (Millicode_save_sr0
);
2525 pif (Variable_Frame
);
2526 pif (Separate_Package_Body
);
2527 pif (Frame_Extension_Millicode
);
2528 pif (Stack_Overflow_Check
);
2529 pif (Two_Instruction_SP_Increment
);
2533 pif (Save_MRP_in_frame
);
2534 pif (extn_ptr_defined
);
2535 pif (Cleanup_defined
);
2536 pif (MPE_XL_interrupt_marker
);
2537 pif (HP_UX_interrupt_marker
);
2540 putchar_unfiltered ('\n');
2542 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2544 pin (Region_description
);
2547 pin (Total_frame_size
);
2549 if (u
->stub_unwind
.stub_type
)
2551 printf_unfiltered ("\tstub type = ");
2552 switch (u
->stub_unwind
.stub_type
)
2555 printf_unfiltered ("long branch\n");
2557 case PARAMETER_RELOCATION
:
2558 printf_unfiltered ("parameter relocation\n");
2561 printf_unfiltered ("export\n");
2564 printf_unfiltered ("import\n");
2567 printf_unfiltered ("import shlib\n");
2570 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2576 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2578 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2580 An example of this occurs when an a.out is linked against a foo.sl.
2581 The foo.sl defines a global bar(), and the a.out declares a signature
2582 for bar(). However, the a.out doesn't directly call bar(), but passes
2583 its address in another call.
2585 If you have this scenario and attempt to "break bar" before running,
2586 gdb will find a minimal symbol for bar() in the a.out. But that
2587 symbol's address will be negative. What this appears to denote is
2588 an index backwards from the base of the procedure linkage table (PLT)
2589 into the data linkage table (DLT), the end of which is contiguous
2590 with the start of the PLT. This is clearly not a valid address for
2591 us to set a breakpoint on.
2593 Note that one must be careful in how one checks for a negative address.
2594 0xc0000000 is a legitimate address of something in a shared text
2595 segment, for example. Since I don't know what the possible range
2596 is of these "really, truly negative" addresses that come from the
2597 minimal symbols, I'm resorting to the gross hack of checking the
2598 top byte of the address for all 1's. Sigh. */
2600 return (!target_has_stack
&& (pc
& 0xFF000000) == 0xFF000000);
2603 /* Return the GDB type object for the "standard" data type of data in
2606 static struct type
*
2607 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2609 if (regnum
< HPPA_FP4_REGNUM
)
2610 return builtin_type_uint32
;
2612 return builtin_type_ieee_single_big
;
2615 static struct type
*
2616 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2618 if (regnum
< HPPA64_FP4_REGNUM
)
2619 return builtin_type_uint64
;
2621 return builtin_type_ieee_double_big
;
2624 /* Return non-zero if REGNUM is not a register available to the user
2625 through ptrace/ttrace. */
2628 hppa32_cannot_store_register (int regnum
)
2631 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2632 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2633 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2637 hppa64_cannot_store_register (int regnum
)
2640 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2641 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2642 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2646 hppa_smash_text_address (CORE_ADDR addr
)
2648 /* The low two bits of the PC on the PA contain the privilege level.
2649 Some genius implementing a (non-GCC) compiler apparently decided
2650 this means that "addresses" in a text section therefore include a
2651 privilege level, and thus symbol tables should contain these bits.
2652 This seems like a bonehead thing to do--anyway, it seems to work
2653 for our purposes to just ignore those bits. */
2655 return (addr
&= ~0x3);
2658 /* Get the ARGIth function argument for the current function. */
2661 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2664 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2668 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2669 int regnum
, gdb_byte
*buf
)
2673 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2674 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2676 store_unsigned_integer (buf
, sizeof tmp
, tmp
);
2680 hppa_find_global_pointer (struct value
*function
)
2686 hppa_frame_prev_register_helper (struct frame_info
*next_frame
,
2687 struct trad_frame_saved_reg saved_regs
[],
2688 int regnum
, int *optimizedp
,
2689 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2690 int *realnump
, gdb_byte
*valuep
)
2692 struct gdbarch
*arch
= get_frame_arch (next_frame
);
2694 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2698 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2701 trad_frame_get_prev_register (next_frame
, saved_regs
,
2702 HPPA_PCOQ_HEAD_REGNUM
, optimizedp
,
2703 lvalp
, addrp
, realnump
, valuep
);
2705 pc
= extract_unsigned_integer (valuep
, size
);
2706 store_unsigned_integer (valuep
, size
, pc
+ 4);
2709 /* It's a computed value. */
2717 /* Make sure the "flags" register is zero in all unwound frames.
2718 The "flags" registers is a HP-UX specific wart, and only the code
2719 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2720 with it here. This shouldn't affect other systems since those
2721 should provide zero for the "flags" register anyway. */
2722 if (regnum
== HPPA_FLAGS_REGNUM
)
2725 store_unsigned_integer (valuep
, register_size (arch
, regnum
), 0);
2727 /* It's a computed value. */
2735 trad_frame_get_prev_register (next_frame
, saved_regs
, regnum
,
2736 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2740 /* An instruction to match. */
2743 unsigned int data
; /* See if it matches this.... */
2744 unsigned int mask
; /* ... with this mask. */
2747 /* See bfd/elf32-hppa.c */
2748 static struct insn_pattern hppa_long_branch_stub
[] = {
2749 /* ldil LR'xxx,%r1 */
2750 { 0x20200000, 0xffe00000 },
2751 /* be,n RR'xxx(%sr4,%r1) */
2752 { 0xe0202002, 0xffe02002 },
2756 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
2758 { 0xe8200000, 0xffe00000 },
2759 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2760 { 0x28200000, 0xffe00000 },
2761 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2762 { 0xe0202002, 0xffe02002 },
2766 static struct insn_pattern hppa_import_stub
[] = {
2767 /* addil LR'xxx, %dp */
2768 { 0x2b600000, 0xffe00000 },
2769 /* ldw RR'xxx(%r1), %r21 */
2770 { 0x48350000, 0xffffb000 },
2772 { 0xeaa0c000, 0xffffffff },
2773 /* ldw RR'xxx+4(%r1), %r19 */
2774 { 0x48330000, 0xffffb000 },
2778 static struct insn_pattern hppa_import_pic_stub
[] = {
2779 /* addil LR'xxx,%r19 */
2780 { 0x2a600000, 0xffe00000 },
2781 /* ldw RR'xxx(%r1),%r21 */
2782 { 0x48350000, 0xffffb000 },
2784 { 0xeaa0c000, 0xffffffff },
2785 /* ldw RR'xxx+4(%r1),%r19 */
2786 { 0x48330000, 0xffffb000 },
2790 static struct insn_pattern hppa_plt_stub
[] = {
2791 /* b,l 1b, %r20 - 1b is 3 insns before here */
2792 { 0xea9f1fdd, 0xffffffff },
2793 /* depi 0,31,2,%r20 */
2794 { 0xd6801c1e, 0xffffffff },
2798 static struct insn_pattern hppa_sigtramp
[] = {
2799 /* ldi 0, %r25 or ldi 1, %r25 */
2800 { 0x34190000, 0xfffffffd },
2801 /* ldi __NR_rt_sigreturn, %r20 */
2802 { 0x3414015a, 0xffffffff },
2803 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
2804 { 0xe4008200, 0xffffffff },
2806 { 0x08000240, 0xffffffff },
2810 /* Maximum number of instructions on the patterns above. */
2811 #define HPPA_MAX_INSN_PATTERN_LEN 4
2813 /* Return non-zero if the instructions at PC match the series
2814 described in PATTERN, or zero otherwise. PATTERN is an array of
2815 'struct insn_pattern' objects, terminated by an entry whose mask is
2818 When the match is successful, fill INSN[i] with what PATTERN[i]
2822 hppa_match_insns (CORE_ADDR pc
, struct insn_pattern
*pattern
,
2828 for (i
= 0; pattern
[i
].mask
; i
++)
2830 gdb_byte buf
[HPPA_INSN_SIZE
];
2832 deprecated_read_memory_nobpt (npc
, buf
, HPPA_INSN_SIZE
);
2833 insn
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
);
2834 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
2843 /* This relaxed version of the insstruction matcher allows us to match
2844 from somewhere inside the pattern, by looking backwards in the
2845 instruction scheme. */
2848 hppa_match_insns_relaxed (CORE_ADDR pc
, struct insn_pattern
*pattern
,
2851 int offset
, len
= 0;
2853 while (pattern
[len
].mask
)
2856 for (offset
= 0; offset
< len
; offset
++)
2857 if (hppa_match_insns (pc
- offset
* HPPA_INSN_SIZE
, pattern
, insn
))
2864 hppa_in_dyncall (CORE_ADDR pc
)
2866 struct unwind_table_entry
*u
;
2868 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2872 return (pc
>= u
->region_start
&& pc
<= u
->region_end
);
2876 hppa_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
2878 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2879 struct unwind_table_entry
*u
;
2881 if (in_plt_section (pc
, name
) || hppa_in_dyncall (pc
))
2884 /* The GNU toolchain produces linker stubs without unwind
2885 information. Since the pattern matching for linker stubs can be
2886 quite slow, so bail out if we do have an unwind entry. */
2888 u
= find_unwind_entry (pc
);
2892 return (hppa_match_insns_relaxed (pc
, hppa_import_stub
, insn
)
2893 || hppa_match_insns_relaxed (pc
, hppa_import_pic_stub
, insn
)
2894 || hppa_match_insns_relaxed (pc
, hppa_long_branch_stub
, insn
)
2895 || hppa_match_insns_relaxed (pc
, hppa_long_branch_pic_stub
, insn
));
2898 /* This code skips several kind of "trampolines" used on PA-RISC
2899 systems: $$dyncall, import stubs and PLT stubs. */
2902 hppa_skip_trampoline_code (CORE_ADDR pc
)
2904 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
2907 /* $$dyncall handles both PLABELs and direct addresses. */
2908 if (hppa_in_dyncall (pc
))
2910 pc
= read_register (HPPA_R0_REGNUM
+ 22);
2912 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2914 pc
= read_memory_typed_address (pc
& ~0x3, builtin_type_void_func_ptr
);
2919 dp_rel
= hppa_match_insns (pc
, hppa_import_stub
, insn
);
2920 if (dp_rel
|| hppa_match_insns (pc
, hppa_import_pic_stub
, insn
))
2922 /* Extract the target address from the addil/ldw sequence. */
2923 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
2926 pc
+= read_register (HPPA_DP_REGNUM
);
2928 pc
+= read_register (HPPA_R0_REGNUM
+ 19);
2933 if (in_plt_section (pc
, NULL
))
2935 pc
= read_memory_typed_address (pc
, builtin_type_void_func_ptr
);
2937 /* If the PLT slot has not yet been resolved, the target will be
2939 if (in_plt_section (pc
, NULL
))
2941 /* Sanity check: are we pointing to the PLT stub? */
2942 if (!hppa_match_insns (pc
, hppa_plt_stub
, insn
))
2944 warning (_("Cannot resolve PLT stub at 0x%s."), paddr_nz (pc
));
2948 /* This should point to the fixup routine. */
2949 pc
= read_memory_typed_address (pc
+ 8, builtin_type_void_func_ptr
);
2957 /* Here is a table of C type sizes on hppa with various compiles
2958 and options. I measured this on PA 9000/800 with HP-UX 11.11
2959 and these compilers:
2961 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2962 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2963 /opt/aCC/bin/aCC B3910B A.03.45
2964 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2966 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2967 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2968 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2969 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2970 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2971 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2972 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2973 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2977 compiler and options
2978 char, short, int, long, long long
2979 float, double, long double
2982 So all these compilers use either ILP32 or LP64 model.
2983 TODO: gcc has more options so it needs more investigation.
2985 For floating point types, see:
2987 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2988 HP-UX floating-point guide, hpux 11.00
2990 -- chastain 2003-12-18 */
2992 static struct gdbarch
*
2993 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2995 struct gdbarch_tdep
*tdep
;
2996 struct gdbarch
*gdbarch
;
2998 /* Try to determine the ABI of the object we are loading. */
2999 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
3001 /* If it's a SOM file, assume it's HP/UX SOM. */
3002 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
3003 info
.osabi
= GDB_OSABI_HPUX_SOM
;
3006 /* find a candidate among the list of pre-declared architectures. */
3007 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3009 return (arches
->gdbarch
);
3011 /* If none found, then allocate and initialize one. */
3012 tdep
= XZALLOC (struct gdbarch_tdep
);
3013 gdbarch
= gdbarch_alloc (&info
, tdep
);
3015 /* Determine from the bfd_arch_info structure if we are dealing with
3016 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3017 then default to a 32bit machine. */
3018 if (info
.bfd_arch_info
!= NULL
)
3019 tdep
->bytes_per_address
=
3020 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3022 tdep
->bytes_per_address
= 4;
3024 tdep
->find_global_pointer
= hppa_find_global_pointer
;
3026 /* Some parts of the gdbarch vector depend on whether we are running
3027 on a 32 bits or 64 bits target. */
3028 switch (tdep
->bytes_per_address
)
3031 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3032 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3033 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3034 set_gdbarch_cannot_store_register (gdbarch
,
3035 hppa32_cannot_store_register
);
3036 set_gdbarch_cannot_fetch_register (gdbarch
,
3037 hppa32_cannot_store_register
);
3040 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3041 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3042 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3043 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3044 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa64_dwarf_reg_to_regnum
);
3045 set_gdbarch_cannot_store_register (gdbarch
,
3046 hppa64_cannot_store_register
);
3047 set_gdbarch_cannot_fetch_register (gdbarch
,
3048 hppa64_cannot_store_register
);
3051 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
3052 tdep
->bytes_per_address
);
3055 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3056 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3058 /* The following gdbarch vector elements are the same in both ILP32
3059 and LP64, but might show differences some day. */
3060 set_gdbarch_long_long_bit (gdbarch
, 64);
3061 set_gdbarch_long_double_bit (gdbarch
, 128);
3062 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
3064 /* The following gdbarch vector elements do not depend on the address
3065 size, or in any other gdbarch element previously set. */
3066 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3067 set_gdbarch_in_function_epilogue_p (gdbarch
,
3068 hppa_in_function_epilogue_p
);
3069 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
3070 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3071 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3072 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
3073 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
3074 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3075 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
3076 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
3078 /* Helper for function argument information. */
3079 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3081 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
3083 /* When a hardware watchpoint triggers, we'll move the inferior past
3084 it by removing all eventpoints; stepping past the instruction
3085 that caused the trigger; reinserting eventpoints; and checking
3086 whether any watched location changed. */
3087 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3089 /* Inferior function call methods. */
3090 switch (tdep
->bytes_per_address
)
3093 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3094 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3095 set_gdbarch_convert_from_func_ptr_addr
3096 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
3099 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3100 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3103 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3106 /* Struct return methods. */
3107 switch (tdep
->bytes_per_address
)
3110 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3113 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3116 internal_error (__FILE__
, __LINE__
, _("bad switch"));
3119 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
3120 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
3122 /* Frame unwind methods. */
3123 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
3124 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3126 /* Hook in ABI-specific overrides, if they have been registered. */
3127 gdbarch_init_osabi (info
, gdbarch
);
3129 /* Hook in the default unwinders. */
3130 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
3131 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
3132 frame_unwind_append_sniffer (gdbarch
, hppa_fallback_unwind_sniffer
);
3138 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
3140 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
3142 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
3143 tdep
->bytes_per_address
);
3144 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
3148 _initialize_hppa_tdep (void)
3150 struct cmd_list_element
*c
;
3152 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3154 hppa_objfile_priv_data
= register_objfile_data ();
3156 add_cmd ("unwind", class_maintenance
, unwind_command
,
3157 _("Print unwind table entry at given address."),
3158 &maintenanceprintlist
);
3160 /* Debug this files internals. */
3161 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
3162 Set whether hppa target specific debugging information should be displayed."),
3164 Show whether hppa target specific debugging information is displayed."), _("\
3165 This flag controls whether hppa target specific debugging information is\n\
3166 displayed. This information is particularly useful for debugging frame\n\
3167 unwinding problems."),
3169 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
3170 &setdebuglist
, &showdebuglist
);