1 /* Target-dependent code for the HP PA-RISC architecture.
3 Copyright 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., 59 Temple Place - Suite 330,
25 Boston, MA 02111-1307, 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
)))
665 /* This function pushes a stack frame with arguments as part of the
666 inferior function calling mechanism.
668 This is the version of the function for the 32-bit PA machines, in
669 which later arguments appear at lower addresses. (The stack always
670 grows towards higher addresses.)
672 We simply allocate the appropriate amount of stack space and put
673 arguments into their proper slots. */
676 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
677 struct regcache
*regcache
, CORE_ADDR bp_addr
,
678 int nargs
, struct value
**args
, CORE_ADDR sp
,
679 int struct_return
, CORE_ADDR struct_addr
)
681 /* Stack base address at which any pass-by-reference parameters are
683 CORE_ADDR struct_end
= 0;
684 /* Stack base address at which the first parameter is stored. */
685 CORE_ADDR param_end
= 0;
687 /* The inner most end of the stack after all the parameters have
689 CORE_ADDR new_sp
= 0;
691 /* Two passes. First pass computes the location of everything,
692 second pass writes the bytes out. */
695 /* Global pointer (r19) of the function we are trying to call. */
698 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
700 for (write_pass
= 0; write_pass
< 2; write_pass
++)
702 CORE_ADDR struct_ptr
= 0;
703 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
704 struct_ptr is adjusted for each argument below, so the first
705 argument will end up at sp-36. */
706 CORE_ADDR param_ptr
= 32;
708 int small_struct
= 0;
710 for (i
= 0; i
< nargs
; i
++)
712 struct value
*arg
= args
[i
];
713 struct type
*type
= check_typedef (value_type (arg
));
714 /* The corresponding parameter that is pushed onto the
715 stack, and [possibly] passed in a register. */
718 memset (param_val
, 0, sizeof param_val
);
719 if (TYPE_LENGTH (type
) > 8)
721 /* Large parameter, pass by reference. Store the value
722 in "struct" area and then pass its address. */
724 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
726 write_memory (struct_end
- struct_ptr
, value_contents (arg
),
728 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
730 else if (TYPE_CODE (type
) == TYPE_CODE_INT
731 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
733 /* Integer value store, right aligned. "unpack_long"
734 takes care of any sign-extension problems. */
735 param_len
= align_up (TYPE_LENGTH (type
), 4);
736 store_unsigned_integer (param_val
, param_len
,
738 value_contents (arg
)));
740 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
742 /* Floating point value store, right aligned. */
743 param_len
= align_up (TYPE_LENGTH (type
), 4);
744 memcpy (param_val
, value_contents (arg
), param_len
);
748 param_len
= align_up (TYPE_LENGTH (type
), 4);
750 /* Small struct value are stored right-aligned. */
751 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
752 value_contents (arg
), TYPE_LENGTH (type
));
754 /* Structures of size 5, 6 and 7 bytes are special in that
755 the higher-ordered word is stored in the lower-ordered
756 argument, and even though it is a 8-byte quantity the
757 registers need not be 8-byte aligned. */
758 if (param_len
> 4 && param_len
< 8)
762 param_ptr
+= param_len
;
763 if (param_len
== 8 && !small_struct
)
764 param_ptr
= align_up (param_ptr
, 8);
766 /* First 4 non-FP arguments are passed in gr26-gr23.
767 First 4 32-bit FP arguments are passed in fr4L-fr7L.
768 First 2 64-bit FP arguments are passed in fr5 and fr7.
770 The rest go on the stack, starting at sp-36, towards lower
771 addresses. 8-byte arguments must be aligned to a 8-byte
775 write_memory (param_end
- param_ptr
, param_val
, param_len
);
777 /* There are some cases when we don't know the type
778 expected by the callee (e.g. for variadic functions), so
779 pass the parameters in both general and fp regs. */
782 int grreg
= 26 - (param_ptr
- 36) / 4;
783 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
784 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
786 regcache_cooked_write (regcache
, grreg
, param_val
);
787 regcache_cooked_write (regcache
, fpLreg
, param_val
);
791 regcache_cooked_write (regcache
, grreg
+ 1,
794 regcache_cooked_write (regcache
, fpreg
, param_val
);
795 regcache_cooked_write (regcache
, fpreg
+ 1,
802 /* Update the various stack pointers. */
805 struct_end
= sp
+ align_up (struct_ptr
, 64);
806 /* PARAM_PTR already accounts for all the arguments passed
807 by the user. However, the ABI mandates minimum stack
808 space allocations for outgoing arguments. The ABI also
809 mandates minimum stack alignments which we must
811 param_end
= struct_end
+ align_up (param_ptr
, 64);
815 /* If a structure has to be returned, set up register 28 to hold its
818 write_register (28, struct_addr
);
820 gp
= tdep
->find_global_pointer (function
);
823 write_register (19, gp
);
825 /* Set the return address. */
826 if (!gdbarch_push_dummy_code_p (gdbarch
))
827 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
829 /* Update the Stack Pointer. */
830 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
835 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
836 Runtime Architecture for PA-RISC 2.0", which is distributed as part
837 as of the HP-UX Software Transition Kit (STK). This implementation
838 is based on version 3.3, dated October 6, 1997. */
840 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
843 hppa64_integral_or_pointer_p (const struct type
*type
)
845 switch (TYPE_CODE (type
))
851 case TYPE_CODE_RANGE
:
853 int len
= TYPE_LENGTH (type
);
854 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
858 return (TYPE_LENGTH (type
) == 8);
866 /* Check whether TYPE is a "Floating Scalar Type". */
869 hppa64_floating_p (const struct type
*type
)
871 switch (TYPE_CODE (type
))
875 int len
= TYPE_LENGTH (type
);
876 return (len
== 4 || len
== 8 || len
== 16);
886 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
887 struct regcache
*regcache
, CORE_ADDR bp_addr
,
888 int nargs
, struct value
**args
, CORE_ADDR sp
,
889 int struct_return
, CORE_ADDR struct_addr
)
891 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
895 /* "The outgoing parameter area [...] must be aligned at a 16-byte
897 sp
= align_up (sp
, 16);
899 for (i
= 0; i
< nargs
; i
++)
901 struct value
*arg
= args
[i
];
902 struct type
*type
= value_type (arg
);
903 int len
= TYPE_LENGTH (type
);
904 const bfd_byte
*valbuf
;
907 /* "Each parameter begins on a 64-bit (8-byte) boundary." */
908 offset
= align_up (offset
, 8);
910 if (hppa64_integral_or_pointer_p (type
))
912 /* "Integral scalar parameters smaller than 64 bits are
913 padded on the left (i.e., the value is in the
914 least-significant bits of the 64-bit storage unit, and
915 the high-order bits are undefined)." Therefore we can
916 safely sign-extend them. */
919 arg
= value_cast (builtin_type_int64
, arg
);
923 else if (hppa64_floating_p (type
))
927 /* "Quad-precision (128-bit) floating-point scalar
928 parameters are aligned on a 16-byte boundary." */
929 offset
= align_up (offset
, 16);
931 /* "Double-extended- and quad-precision floating-point
932 parameters within the first 64 bytes of the parameter
933 list are always passed in general registers." */
939 /* "Single-precision (32-bit) floating-point scalar
940 parameters are padded on the left with 32 bits of
941 garbage (i.e., the floating-point value is in the
942 least-significant 32 bits of a 64-bit storage
947 /* "Single- and double-precision floating-point
948 parameters in this area are passed according to the
949 available formal parameter information in a function
950 prototype. [...] If no prototype is in scope,
951 floating-point parameters must be passed both in the
952 corresponding general registers and in the
953 corresponding floating-point registers." */
954 regnum
= HPPA64_FP4_REGNUM
+ offset
/ 8;
956 if (regnum
< HPPA64_FP4_REGNUM
+ 8)
958 /* "Single-precision floating-point parameters, when
959 passed in floating-point registers, are passed in
960 the right halves of the floating point registers;
961 the left halves are unused." */
962 regcache_cooked_write_part (regcache
, regnum
, offset
% 8,
963 len
, value_contents (arg
));
971 /* "Aggregates larger than 8 bytes are aligned on a
972 16-byte boundary, possibly leaving an unused argument
973 slot, which is filled with garbage. If necessary,
974 they are padded on the right (with garbage), to a
975 multiple of 8 bytes." */
976 offset
= align_up (offset
, 16);
980 /* Always store the argument in memory. */
981 write_memory (sp
+ offset
, value_contents (arg
), len
);
983 valbuf
= value_contents (arg
);
984 regnum
= HPPA_ARG0_REGNUM
- offset
/ 8;
985 while (regnum
> HPPA_ARG0_REGNUM
- 8 && len
> 0)
987 regcache_cooked_write_part (regcache
, regnum
,
988 offset
% 8, min (len
, 8), valbuf
);
989 offset
+= min (len
, 8);
990 valbuf
+= min (len
, 8);
998 /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
999 regcache_cooked_write_unsigned (regcache
, HPPA_RET1_REGNUM
, sp
+ 64);
1001 /* Allocate the outgoing parameter area. Make sure the outgoing
1002 parameter area is multiple of 16 bytes in length. */
1003 sp
+= max (align_up (offset
, 16), 64);
1005 /* Allocate 32-bytes of scratch space. The documentation doesn't
1006 mention this, but it seems to be needed. */
1009 /* Allocate the frame marker area. */
1012 /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1015 regcache_cooked_write_unsigned (regcache
, HPPA_RET0_REGNUM
, struct_addr
);
1017 /* Set up GR27 (%dp) to hold the global pointer (gp). */
1018 gp
= tdep
->find_global_pointer (function
);
1020 regcache_cooked_write_unsigned (regcache
, HPPA_DP_REGNUM
, gp
);
1022 /* Set up GR2 (%rp) to hold the return pointer (rp). */
1023 if (!gdbarch_push_dummy_code_p (gdbarch
))
1024 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1026 /* Set up GR30 to hold the stack pointer (sp). */
1027 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, sp
);
1033 /* Handle 32/64-bit struct return conventions. */
1035 static enum return_value_convention
1036 hppa32_return_value (struct gdbarch
*gdbarch
,
1037 struct type
*type
, struct regcache
*regcache
,
1038 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1040 if (TYPE_LENGTH (type
) <= 2 * 4)
1042 /* The value always lives in the right hand end of the register
1043 (or register pair)? */
1045 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
1046 int part
= TYPE_LENGTH (type
) % 4;
1047 /* The left hand register contains only part of the value,
1048 transfer that first so that the rest can be xfered as entire
1049 4-byte registers. */
1052 if (readbuf
!= NULL
)
1053 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
1055 if (writebuf
!= NULL
)
1056 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
1060 /* Now transfer the remaining register values. */
1061 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
1063 if (readbuf
!= NULL
)
1064 regcache_cooked_read (regcache
, reg
, readbuf
+ b
);
1065 if (writebuf
!= NULL
)
1066 regcache_cooked_write (regcache
, reg
, writebuf
+ b
);
1069 return RETURN_VALUE_REGISTER_CONVENTION
;
1072 return RETURN_VALUE_STRUCT_CONVENTION
;
1075 static enum return_value_convention
1076 hppa64_return_value (struct gdbarch
*gdbarch
,
1077 struct type
*type
, struct regcache
*regcache
,
1078 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1080 int len
= TYPE_LENGTH (type
);
1085 /* All return values larget than 128 bits must be aggregate
1087 gdb_assert (!hppa64_integral_or_pointer_p (type
));
1088 gdb_assert (!hppa64_floating_p (type
));
1090 /* "Aggregate return values larger than 128 bits are returned in
1091 a buffer allocated by the caller. The address of the buffer
1092 must be passed in GR 28." */
1093 return RETURN_VALUE_STRUCT_CONVENTION
;
1096 if (hppa64_integral_or_pointer_p (type
))
1098 /* "Integral return values are returned in GR 28. Values
1099 smaller than 64 bits are padded on the left (with garbage)." */
1100 regnum
= HPPA_RET0_REGNUM
;
1103 else if (hppa64_floating_p (type
))
1107 /* "Double-extended- and quad-precision floating-point
1108 values are returned in GRs 28 and 29. The sign,
1109 exponent, and most-significant bits of the mantissa are
1110 returned in GR 28; the least-significant bits of the
1111 mantissa are passed in GR 29. For double-extended
1112 precision values, GR 29 is padded on the right with 48
1113 bits of garbage." */
1114 regnum
= HPPA_RET0_REGNUM
;
1119 /* "Single-precision and double-precision floating-point
1120 return values are returned in FR 4R (single precision) or
1121 FR 4 (double-precision)." */
1122 regnum
= HPPA64_FP4_REGNUM
;
1128 /* "Aggregate return values up to 64 bits in size are returned
1129 in GR 28. Aggregates smaller than 64 bits are left aligned
1130 in the register; the pad bits on the right are undefined."
1132 "Aggregate return values between 65 and 128 bits are returned
1133 in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1134 the remaining bits are placed, left aligned, in GR 29. The
1135 pad bits on the right of GR 29 (if any) are undefined." */
1136 regnum
= HPPA_RET0_REGNUM
;
1144 regcache_cooked_read_part (regcache
, regnum
, offset
,
1145 min (len
, 8), readbuf
);
1146 readbuf
+= min (len
, 8);
1147 len
-= min (len
, 8);
1156 regcache_cooked_write_part (regcache
, regnum
, offset
,
1157 min (len
, 8), writebuf
);
1158 writebuf
+= min (len
, 8);
1159 len
-= min (len
, 8);
1164 return RETURN_VALUE_REGISTER_CONVENTION
;
1169 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1170 struct target_ops
*targ
)
1174 CORE_ADDR plabel
= addr
& ~3;
1175 return read_memory_typed_address (plabel
, builtin_type_void_func_ptr
);
1182 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1184 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1186 return align_up (addr
, 64);
1189 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1192 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1194 /* Just always 16-byte align. */
1195 return align_up (addr
, 16);
1199 hppa_read_pc (ptid_t ptid
)
1204 ipsw
= read_register_pid (HPPA_IPSW_REGNUM
, ptid
);
1205 pc
= read_register_pid (HPPA_PCOQ_HEAD_REGNUM
, ptid
);
1207 /* If the current instruction is nullified, then we are effectively
1208 still executing the previous instruction. Pretend we are still
1209 there. This is needed when single stepping; if the nullified
1210 instruction is on a different line, we don't want GDB to think
1211 we've stepped onto that line. */
1212 if (ipsw
& 0x00200000)
1219 hppa_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1221 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, pc
, ptid
);
1222 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4, ptid
);
1225 /* return the alignment of a type in bytes. Structures have the maximum
1226 alignment required by their fields. */
1229 hppa_alignof (struct type
*type
)
1231 int max_align
, align
, i
;
1232 CHECK_TYPEDEF (type
);
1233 switch (TYPE_CODE (type
))
1238 return TYPE_LENGTH (type
);
1239 case TYPE_CODE_ARRAY
:
1240 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1241 case TYPE_CODE_STRUCT
:
1242 case TYPE_CODE_UNION
:
1244 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1246 /* Bit fields have no real alignment. */
1247 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1248 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1250 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1251 max_align
= max (max_align
, align
);
1260 /* For the given instruction (INST), return any adjustment it makes
1261 to the stack pointer or zero for no adjustment.
1263 This only handles instructions commonly found in prologues. */
1266 prologue_inst_adjust_sp (unsigned long inst
)
1268 /* This must persist across calls. */
1269 static int save_high21
;
1271 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1272 if ((inst
& 0xffffc000) == 0x37de0000)
1273 return hppa_extract_14 (inst
);
1276 if ((inst
& 0xffe00000) == 0x6fc00000)
1277 return hppa_extract_14 (inst
);
1279 /* std,ma X,D(sp) */
1280 if ((inst
& 0xffe00008) == 0x73c00008)
1281 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1283 /* addil high21,%r30; ldo low11,(%r1),%r30)
1284 save high bits in save_high21 for later use. */
1285 if ((inst
& 0xffe00000) == 0x2bc00000)
1287 save_high21
= hppa_extract_21 (inst
);
1291 if ((inst
& 0xffff0000) == 0x343e0000)
1292 return save_high21
+ hppa_extract_14 (inst
);
1294 /* fstws as used by the HP compilers. */
1295 if ((inst
& 0xffffffe0) == 0x2fd01220)
1296 return hppa_extract_5_load (inst
);
1298 /* No adjustment. */
1302 /* Return nonzero if INST is a branch of some kind, else return zero. */
1305 is_branch (unsigned long inst
)
1334 /* Return the register number for a GR which is saved by INST or
1335 zero it INST does not save a GR. */
1338 inst_saves_gr (unsigned long inst
)
1340 /* Does it look like a stw? */
1341 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1342 || (inst
>> 26) == 0x1f
1343 || ((inst
>> 26) == 0x1f
1344 && ((inst
>> 6) == 0xa)))
1345 return hppa_extract_5R_store (inst
);
1347 /* Does it look like a std? */
1348 if ((inst
>> 26) == 0x1c
1349 || ((inst
>> 26) == 0x03
1350 && ((inst
>> 6) & 0xf) == 0xb))
1351 return hppa_extract_5R_store (inst
);
1353 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1354 if ((inst
>> 26) == 0x1b)
1355 return hppa_extract_5R_store (inst
);
1357 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1359 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1360 || ((inst
>> 26) == 0x3
1361 && (((inst
>> 6) & 0xf) == 0x8
1362 || (inst
>> 6) & 0xf) == 0x9))
1363 return hppa_extract_5R_store (inst
);
1368 /* Return the register number for a FR which is saved by INST or
1369 zero it INST does not save a FR.
1371 Note we only care about full 64bit register stores (that's the only
1372 kind of stores the prologue will use).
1374 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1377 inst_saves_fr (unsigned long inst
)
1379 /* is this an FSTD ? */
1380 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1381 return hppa_extract_5r_store (inst
);
1382 if ((inst
& 0xfc000002) == 0x70000002)
1383 return hppa_extract_5R_store (inst
);
1384 /* is this an FSTW ? */
1385 if ((inst
& 0xfc00df80) == 0x24001200)
1386 return hppa_extract_5r_store (inst
);
1387 if ((inst
& 0xfc000002) == 0x7c000000)
1388 return hppa_extract_5R_store (inst
);
1392 /* Advance PC across any function entry prologue instructions
1393 to reach some "real" code.
1395 Use information in the unwind table to determine what exactly should
1396 be in the prologue. */
1400 skip_prologue_hard_way (CORE_ADDR pc
, int stop_before_branch
)
1403 CORE_ADDR orig_pc
= pc
;
1404 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1405 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1406 struct unwind_table_entry
*u
;
1407 int final_iteration
;
1413 u
= find_unwind_entry (pc
);
1417 /* If we are not at the beginning of a function, then return now. */
1418 if ((pc
& ~0x3) != u
->region_start
)
1421 /* This is how much of a frame adjustment we need to account for. */
1422 stack_remaining
= u
->Total_frame_size
<< 3;
1424 /* Magic register saves we want to know about. */
1425 save_rp
= u
->Save_RP
;
1426 save_sp
= u
->Save_SP
;
1428 /* An indication that args may be stored into the stack. Unfortunately
1429 the HPUX compilers tend to set this in cases where no args were
1433 /* Turn the Entry_GR field into a bitmask. */
1435 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1437 /* Frame pointer gets saved into a special location. */
1438 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1441 save_gr
|= (1 << i
);
1443 save_gr
&= ~restart_gr
;
1445 /* Turn the Entry_FR field into a bitmask too. */
1447 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1448 save_fr
|= (1 << i
);
1449 save_fr
&= ~restart_fr
;
1451 final_iteration
= 0;
1453 /* Loop until we find everything of interest or hit a branch.
1455 For unoptimized GCC code and for any HP CC code this will never ever
1456 examine any user instructions.
1458 For optimzied GCC code we're faced with problems. GCC will schedule
1459 its prologue and make prologue instructions available for delay slot
1460 filling. The end result is user code gets mixed in with the prologue
1461 and a prologue instruction may be in the delay slot of the first branch
1464 Some unexpected things are expected with debugging optimized code, so
1465 we allow this routine to walk past user instructions in optimized
1467 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1470 unsigned int reg_num
;
1471 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1472 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1474 /* Save copies of all the triggers so we can compare them later
1476 old_save_gr
= save_gr
;
1477 old_save_fr
= save_fr
;
1478 old_save_rp
= save_rp
;
1479 old_save_sp
= save_sp
;
1480 old_stack_remaining
= stack_remaining
;
1482 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1483 inst
= extract_unsigned_integer (buf
, 4);
1489 /* Note the interesting effects of this instruction. */
1490 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1492 /* There are limited ways to store the return pointer into the
1494 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1 || inst
== 0x73c23fe1)
1497 /* These are the only ways we save SP into the stack. At this time
1498 the HP compilers never bother to save SP into the stack. */
1499 if ((inst
& 0xffffc000) == 0x6fc10000
1500 || (inst
& 0xffffc00c) == 0x73c10008)
1503 /* Are we loading some register with an offset from the argument
1505 if ((inst
& 0xffe00000) == 0x37a00000
1506 || (inst
& 0xffffffe0) == 0x081d0240)
1512 /* Account for general and floating-point register saves. */
1513 reg_num
= inst_saves_gr (inst
);
1514 save_gr
&= ~(1 << reg_num
);
1516 /* Ugh. Also account for argument stores into the stack.
1517 Unfortunately args_stored only tells us that some arguments
1518 where stored into the stack. Not how many or what kind!
1520 This is a kludge as on the HP compiler sets this bit and it
1521 never does prologue scheduling. So once we see one, skip past
1522 all of them. We have similar code for the fp arg stores below.
1524 FIXME. Can still die if we have a mix of GR and FR argument
1526 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1528 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1531 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1532 inst
= extract_unsigned_integer (buf
, 4);
1535 reg_num
= inst_saves_gr (inst
);
1541 reg_num
= inst_saves_fr (inst
);
1542 save_fr
&= ~(1 << reg_num
);
1544 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1545 next_inst
= extract_unsigned_integer (buf
, 4);
1551 /* We've got to be read to handle the ldo before the fp register
1553 if ((inst
& 0xfc000000) == 0x34000000
1554 && inst_saves_fr (next_inst
) >= 4
1555 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1557 /* So we drop into the code below in a reasonable state. */
1558 reg_num
= inst_saves_fr (next_inst
);
1562 /* Ugh. Also account for argument stores into the stack.
1563 This is a kludge as on the HP compiler sets this bit and it
1564 never does prologue scheduling. So once we see one, skip past
1566 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1568 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1571 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1572 inst
= extract_unsigned_integer (buf
, 4);
1575 if ((inst
& 0xfc000000) != 0x34000000)
1577 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1578 next_inst
= extract_unsigned_integer (buf
, 4);
1581 reg_num
= inst_saves_fr (next_inst
);
1587 /* Quit if we hit any kind of branch. This can happen if a prologue
1588 instruction is in the delay slot of the first call/branch. */
1589 if (is_branch (inst
) && stop_before_branch
)
1592 /* What a crock. The HP compilers set args_stored even if no
1593 arguments were stored into the stack (boo hiss). This could
1594 cause this code to then skip a bunch of user insns (up to the
1597 To combat this we try to identify when args_stored was bogusly
1598 set and clear it. We only do this when args_stored is nonzero,
1599 all other resources are accounted for, and nothing changed on
1602 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1603 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1604 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1605 && old_stack_remaining
== stack_remaining
)
1611 /* !stop_before_branch, so also look at the insn in the delay slot
1613 if (final_iteration
)
1615 if (is_branch (inst
))
1616 final_iteration
= 1;
1619 /* We've got a tenative location for the end of the prologue. However
1620 because of limitations in the unwind descriptor mechanism we may
1621 have went too far into user code looking for the save of a register
1622 that does not exist. So, if there registers we expected to be saved
1623 but never were, mask them out and restart.
1625 This should only happen in optimized code, and should be very rare. */
1626 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1629 restart_gr
= save_gr
;
1630 restart_fr
= save_fr
;
1638 /* Return the address of the PC after the last prologue instruction if
1639 we can determine it from the debug symbols. Else return zero. */
1642 after_prologue (CORE_ADDR pc
)
1644 struct symtab_and_line sal
;
1645 CORE_ADDR func_addr
, func_end
;
1648 /* If we can not find the symbol in the partial symbol table, then
1649 there is no hope we can determine the function's start address
1651 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1654 /* Get the line associated with FUNC_ADDR. */
1655 sal
= find_pc_line (func_addr
, 0);
1657 /* There are only two cases to consider. First, the end of the source line
1658 is within the function bounds. In that case we return the end of the
1659 source line. Second is the end of the source line extends beyond the
1660 bounds of the current function. We need to use the slow code to
1661 examine instructions in that case.
1663 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1664 the wrong thing to do. In fact, it should be entirely possible for this
1665 function to always return zero since the slow instruction scanning code
1666 is supposed to *always* work. If it does not, then it is a bug. */
1667 if (sal
.end
< func_end
)
1673 /* To skip prologues, I use this predicate. Returns either PC itself
1674 if the code at PC does not look like a function prologue; otherwise
1675 returns an address that (if we're lucky) follows the prologue.
1677 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1678 It doesn't necessarily skips all the insns in the prologue. In fact
1679 we might not want to skip all the insns because a prologue insn may
1680 appear in the delay slot of the first branch, and we don't want to
1681 skip over the branch in that case. */
1684 hppa_skip_prologue (CORE_ADDR pc
)
1688 CORE_ADDR post_prologue_pc
;
1691 /* See if we can determine the end of the prologue via the symbol table.
1692 If so, then return either PC, or the PC after the prologue, whichever
1695 post_prologue_pc
= after_prologue (pc
);
1697 /* If after_prologue returned a useful address, then use it. Else
1698 fall back on the instruction skipping code.
1700 Some folks have claimed this causes problems because the breakpoint
1701 may be the first instruction of the prologue. If that happens, then
1702 the instruction skipping code has a bug that needs to be fixed. */
1703 if (post_prologue_pc
!= 0)
1704 return max (pc
, post_prologue_pc
);
1706 return (skip_prologue_hard_way (pc
, 1));
1709 struct hppa_frame_cache
1712 struct trad_frame_saved_reg
*saved_regs
;
1715 static struct hppa_frame_cache
*
1716 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1718 struct hppa_frame_cache
*cache
;
1723 struct unwind_table_entry
*u
;
1724 CORE_ADDR prologue_end
;
1729 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1730 frame_relative_level(next_frame
));
1732 if ((*this_cache
) != NULL
)
1735 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1736 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1737 return (*this_cache
);
1739 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1740 (*this_cache
) = cache
;
1741 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1744 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
1748 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1749 return (*this_cache
);
1752 /* Turn the Entry_GR field into a bitmask. */
1754 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1756 /* Frame pointer gets saved into a special location. */
1757 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1760 saved_gr_mask
|= (1 << i
);
1763 /* Turn the Entry_FR field into a bitmask too. */
1765 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1766 saved_fr_mask
|= (1 << i
);
1768 /* Loop until we find everything of interest or hit a branch.
1770 For unoptimized GCC code and for any HP CC code this will never ever
1771 examine any user instructions.
1773 For optimized GCC code we're faced with problems. GCC will schedule
1774 its prologue and make prologue instructions available for delay slot
1775 filling. The end result is user code gets mixed in with the prologue
1776 and a prologue instruction may be in the delay slot of the first branch
1779 Some unexpected things are expected with debugging optimized code, so
1780 we allow this routine to walk past user instructions in optimized
1783 int final_iteration
= 0;
1784 CORE_ADDR pc
, end_pc
;
1785 int looking_for_sp
= u
->Save_SP
;
1786 int looking_for_rp
= u
->Save_RP
;
1789 /* We have to use skip_prologue_hard_way instead of just
1790 skip_prologue_using_sal, in case we stepped into a function without
1791 symbol information. hppa_skip_prologue also bounds the returned
1792 pc by the passed in pc, so it will not return a pc in the next
1795 We used to call hppa_skip_prologue to find the end of the prologue,
1796 but if some non-prologue instructions get scheduled into the prologue,
1797 and the program is compiled with debug information, the "easy" way
1798 in hppa_skip_prologue will return a prologue end that is too early
1799 for us to notice any potential frame adjustments. */
1801 /* We used to use frame_func_unwind () to locate the beginning of the
1802 function to pass to skip_prologue (). However, when objects are
1803 compiled without debug symbols, frame_func_unwind can return the wrong
1804 function (or 0). We can do better than that by using unwind records. */
1806 prologue_end
= skip_prologue_hard_way (u
->region_start
, 0);
1807 end_pc
= frame_pc_unwind (next_frame
);
1809 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1810 end_pc
= prologue_end
;
1814 for (pc
= u
->region_start
;
1815 ((saved_gr_mask
|| saved_fr_mask
1816 || looking_for_sp
|| looking_for_rp
1817 || frame_size
< (u
->Total_frame_size
<< 3))
1825 if (!safe_frame_unwind_memory (next_frame
, pc
, buf4
,
1828 error (_("Cannot read instruction at 0x%s."), paddr_nz (pc
));
1829 return (*this_cache
);
1832 inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1834 /* Note the interesting effects of this instruction. */
1835 frame_size
+= prologue_inst_adjust_sp (inst
);
1837 /* There are limited ways to store the return pointer into the
1839 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1842 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1844 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1847 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1849 else if (inst
== 0x0fc212c1
1850 || inst
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
1853 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1856 /* Check to see if we saved SP into the stack. This also
1857 happens to indicate the location of the saved frame
1859 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1860 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1863 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1865 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1870 /* Account for general and floating-point register saves. */
1871 reg
= inst_saves_gr (inst
);
1872 if (reg
>= 3 && reg
<= 18
1873 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1875 saved_gr_mask
&= ~(1 << reg
);
1876 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1877 /* stwm with a positive displacement is a _post_
1879 cache
->saved_regs
[reg
].addr
= 0;
1880 else if ((inst
& 0xfc00000c) == 0x70000008)
1881 /* A std has explicit post_modify forms. */
1882 cache
->saved_regs
[reg
].addr
= 0;
1887 if ((inst
>> 26) == 0x1c)
1888 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1889 else if ((inst
>> 26) == 0x03)
1890 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1892 offset
= hppa_extract_14 (inst
);
1894 /* Handle code with and without frame pointers. */
1896 cache
->saved_regs
[reg
].addr
= offset
;
1898 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1902 /* GCC handles callee saved FP regs a little differently.
1904 It emits an instruction to put the value of the start of
1905 the FP store area into %r1. It then uses fstds,ma with a
1906 basereg of %r1 for the stores.
1908 HP CC emits them at the current stack pointer modifying the
1909 stack pointer as it stores each register. */
1911 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1912 if ((inst
& 0xffffc000) == 0x34610000
1913 || (inst
& 0xffffc000) == 0x37c10000)
1914 fp_loc
= hppa_extract_14 (inst
);
1916 reg
= inst_saves_fr (inst
);
1917 if (reg
>= 12 && reg
<= 21)
1919 /* Note +4 braindamage below is necessary because the FP
1920 status registers are internally 8 registers rather than
1921 the expected 4 registers. */
1922 saved_fr_mask
&= ~(1 << reg
);
1925 /* 1st HP CC FP register store. After this
1926 instruction we've set enough state that the GCC and
1927 HPCC code are both handled in the same manner. */
1928 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
1933 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
1938 /* Quit if we hit any kind of branch the previous iteration. */
1939 if (final_iteration
)
1941 /* We want to look precisely one instruction beyond the branch
1942 if we have not found everything yet. */
1943 if (is_branch (inst
))
1944 final_iteration
= 1;
1949 /* The frame base always represents the value of %sp at entry to
1950 the current function (and is thus equivalent to the "saved"
1952 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1956 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
1957 "prologue_end=0x%s) ",
1959 paddr_nz (frame_pc_unwind (next_frame
)),
1960 paddr_nz (prologue_end
));
1962 /* Check to see if a frame pointer is available, and use it for
1963 frame unwinding if it is.
1965 There are some situations where we need to rely on the frame
1966 pointer to do stack unwinding. For example, if a function calls
1967 alloca (), the stack pointer can get adjusted inside the body of
1968 the function. In this case, the ABI requires that the compiler
1969 maintain a frame pointer for the function.
1971 The unwind record has a flag (alloca_frame) that indicates that
1972 a function has a variable frame; unfortunately, gcc/binutils
1973 does not set this flag. Instead, whenever a frame pointer is used
1974 and saved on the stack, the Save_SP flag is set. We use this to
1975 decide whether to use the frame pointer for unwinding.
1977 TODO: For the HP compiler, maybe we should use the alloca_frame flag
1978 instead of Save_SP. */
1980 fp
= frame_unwind_register_unsigned (next_frame
, HPPA_FP_REGNUM
);
1982 if (frame_pc_unwind (next_frame
) >= prologue_end
1983 && u
->Save_SP
&& fp
!= 0)
1988 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer]",
1989 paddr_nz (cache
->base
));
1992 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
1994 /* Both we're expecting the SP to be saved and the SP has been
1995 saved. The entry SP value is saved at this frame's SP
1997 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
2000 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved]",
2001 paddr_nz (cache
->base
));
2005 /* The prologue has been slowly allocating stack space. Adjust
2007 cache
->base
= this_sp
- frame_size
;
2009 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust]",
2010 paddr_nz (cache
->base
));
2013 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2016 /* The PC is found in the "return register", "Millicode" uses "r31"
2017 as the return register while normal code uses "rp". */
2020 if (trad_frame_addr_p (cache
->saved_regs
, 31))
2022 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2024 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [stack] } ");
2028 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
2029 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
2031 fprintf_unfiltered (gdb_stdlog
, " (pc=r31) [frame] } ");
2036 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2038 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2039 cache
->saved_regs
[HPPA_RP_REGNUM
];
2041 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [stack] } ");
2045 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2046 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2048 fprintf_unfiltered (gdb_stdlog
, " (pc=rp) [frame] } ");
2052 /* If Save_SP is set, then we expect the frame pointer to be saved in the
2053 frame. However, there is a one-insn window where we haven't saved it
2054 yet, but we've already clobbered it. Detect this case and fix it up.
2056 The prologue sequence for frame-pointer functions is:
2057 0: stw %rp, -20(%sp)
2060 c: stw,ma %r1, XX(%sp)
2062 So if we are at offset c, the r3 value that we want is not yet saved
2063 on the stack, but it's been overwritten. The prologue analyzer will
2064 set fp_in_r1 when it sees the copy insn so we know to get the value
2066 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
2069 ULONGEST r1
= frame_unwind_register_unsigned (next_frame
, 1);
2070 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
2074 /* Convert all the offsets into addresses. */
2076 for (reg
= 0; reg
< NUM_REGS
; reg
++)
2078 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
2079 cache
->saved_regs
[reg
].addr
+= cache
->base
;
2084 struct gdbarch
*gdbarch
;
2085 struct gdbarch_tdep
*tdep
;
2087 gdbarch
= get_frame_arch (next_frame
);
2088 tdep
= gdbarch_tdep (gdbarch
);
2090 if (tdep
->unwind_adjust_stub
)
2092 tdep
->unwind_adjust_stub (next_frame
, cache
->base
, cache
->saved_regs
);
2097 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
2098 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
2099 return (*this_cache
);
2103 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2104 struct frame_id
*this_id
)
2106 struct hppa_frame_cache
*info
;
2107 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2108 struct unwind_table_entry
*u
;
2110 info
= hppa_frame_cache (next_frame
, this_cache
);
2111 u
= find_unwind_entry (pc
);
2113 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2117 hppa_frame_prev_register (struct frame_info
*next_frame
,
2119 int regnum
, int *optimizedp
,
2120 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2121 int *realnump
, gdb_byte
*valuep
)
2123 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
2124 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2125 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2128 static const struct frame_unwind hppa_frame_unwind
=
2132 hppa_frame_prev_register
2135 static const struct frame_unwind
*
2136 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
2138 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2140 if (find_unwind_entry (pc
))
2141 return &hppa_frame_unwind
;
2146 /* This is a generic fallback frame unwinder that kicks in if we fail all
2147 the other ones. Normally we would expect the stub and regular unwinder
2148 to work, but in some cases we might hit a function that just doesn't
2149 have any unwind information available. In this case we try to do
2150 unwinding solely based on code reading. This is obviously going to be
2151 slow, so only use this as a last resort. Currently this will only
2152 identify the stack and pc for the frame. */
2154 static struct hppa_frame_cache
*
2155 hppa_fallback_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
2157 struct hppa_frame_cache
*cache
;
2158 unsigned int frame_size
= 0;
2163 fprintf_unfiltered (gdb_stdlog
,
2164 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2165 frame_relative_level (next_frame
));
2167 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2168 (*this_cache
) = cache
;
2169 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2171 start_pc
= frame_func_unwind (next_frame
);
2174 CORE_ADDR cur_pc
= frame_pc_unwind (next_frame
);
2177 for (pc
= start_pc
; pc
< cur_pc
; pc
+= 4)
2181 insn
= read_memory_unsigned_integer (pc
, 4);
2182 frame_size
+= prologue_inst_adjust_sp (insn
);
2184 /* There are limited ways to store the return pointer into the
2186 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2188 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2191 else if (insn
== 0x0fc212c1
2192 || insn
== 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2194 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2201 fprintf_unfiltered (gdb_stdlog
, " frame_size=%d, found_rp=%d }\n",
2202 frame_size
, found_rp
);
2204 cache
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2205 cache
->base
-= frame_size
;
2206 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2208 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2210 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2211 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] =
2212 cache
->saved_regs
[HPPA_RP_REGNUM
];
2217 rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2218 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2225 hppa_fallback_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2226 struct frame_id
*this_id
)
2228 struct hppa_frame_cache
*info
=
2229 hppa_fallback_frame_cache (next_frame
, this_cache
);
2230 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2234 hppa_fallback_frame_prev_register (struct frame_info
*next_frame
,
2236 int regnum
, int *optimizedp
,
2237 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2238 int *realnump
, gdb_byte
*valuep
)
2240 struct hppa_frame_cache
*info
=
2241 hppa_fallback_frame_cache (next_frame
, this_cache
);
2242 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2243 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2246 static const struct frame_unwind hppa_fallback_frame_unwind
=
2249 hppa_fallback_frame_this_id
,
2250 hppa_fallback_frame_prev_register
2253 static const struct frame_unwind
*
2254 hppa_fallback_unwind_sniffer (struct frame_info
*next_frame
)
2256 return &hppa_fallback_frame_unwind
;
2259 /* Stub frames, used for all kinds of call stubs. */
2260 struct hppa_stub_unwind_cache
2263 struct trad_frame_saved_reg
*saved_regs
;
2266 static struct hppa_stub_unwind_cache
*
2267 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
2270 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2271 struct hppa_stub_unwind_cache
*info
;
2272 struct unwind_table_entry
*u
;
2277 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2279 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2281 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2283 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2285 /* HPUX uses export stubs in function calls; the export stub clobbers
2286 the return value of the caller, and, later restores it from the
2288 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
2290 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2292 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2298 /* By default we assume that stubs do not change the rp. */
2299 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2305 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
2306 void **this_prologue_cache
,
2307 struct frame_id
*this_id
)
2309 struct hppa_stub_unwind_cache
*info
2310 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2313 *this_id
= frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2315 *this_id
= null_frame_id
;
2319 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
2320 void **this_prologue_cache
,
2321 int regnum
, int *optimizedp
,
2322 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2323 int *realnump
, gdb_byte
*valuep
)
2325 struct hppa_stub_unwind_cache
*info
2326 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2329 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2330 optimizedp
, lvalp
, addrp
, realnump
,
2333 error (_("Requesting registers from null frame."));
2336 static const struct frame_unwind hppa_stub_frame_unwind
= {
2338 hppa_stub_frame_this_id
,
2339 hppa_stub_frame_prev_register
2342 static const struct frame_unwind
*
2343 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
2345 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2346 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2347 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2350 || (tdep
->in_solib_call_trampoline
!= NULL
2351 && tdep
->in_solib_call_trampoline (pc
, NULL
))
2352 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
2353 return &hppa_stub_frame_unwind
;
2357 static struct frame_id
2358 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2360 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2362 frame_pc_unwind (next_frame
));
2366 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2371 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2372 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2374 /* If the current instruction is nullified, then we are effectively
2375 still executing the previous instruction. Pretend we are still
2376 there. This is needed when single stepping; if the nullified
2377 instruction is on a different line, we don't want GDB to think
2378 we've stepped onto that line. */
2379 if (ipsw
& 0x00200000)
2385 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2386 Return NULL if no such symbol was found. */
2388 struct minimal_symbol
*
2389 hppa_lookup_stub_minimal_symbol (const char *name
,
2390 enum unwind_stub_types stub_type
)
2392 struct objfile
*objfile
;
2393 struct minimal_symbol
*msym
;
2395 ALL_MSYMBOLS (objfile
, msym
)
2397 if (strcmp (SYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2399 struct unwind_table_entry
*u
;
2401 u
= find_unwind_entry (SYMBOL_VALUE (msym
));
2402 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2411 unwind_command (char *exp
, int from_tty
)
2414 struct unwind_table_entry
*u
;
2416 /* If we have an expression, evaluate it and use it as the address. */
2418 if (exp
!= 0 && *exp
!= 0)
2419 address
= parse_and_eval_address (exp
);
2423 u
= find_unwind_entry (address
);
2427 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2431 printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u
);
2433 printf_unfiltered ("\tregion_start = ");
2434 print_address (u
->region_start
, gdb_stdout
);
2435 gdb_flush (gdb_stdout
);
2437 printf_unfiltered ("\n\tregion_end = ");
2438 print_address (u
->region_end
, gdb_stdout
);
2439 gdb_flush (gdb_stdout
);
2441 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2443 printf_unfiltered ("\n\tflags =");
2444 pif (Cannot_unwind
);
2446 pif (Millicode_save_sr0
);
2449 pif (Variable_Frame
);
2450 pif (Separate_Package_Body
);
2451 pif (Frame_Extension_Millicode
);
2452 pif (Stack_Overflow_Check
);
2453 pif (Two_Instruction_SP_Increment
);
2457 pif (Save_MRP_in_frame
);
2458 pif (extn_ptr_defined
);
2459 pif (Cleanup_defined
);
2460 pif (MPE_XL_interrupt_marker
);
2461 pif (HP_UX_interrupt_marker
);
2464 putchar_unfiltered ('\n');
2466 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2468 pin (Region_description
);
2471 pin (Total_frame_size
);
2473 if (u
->stub_unwind
.stub_type
)
2475 printf_unfiltered ("\tstub type = ");
2476 switch (u
->stub_unwind
.stub_type
)
2479 printf_unfiltered ("long branch\n");
2481 case PARAMETER_RELOCATION
:
2482 printf_unfiltered ("parameter relocation\n");
2485 printf_unfiltered ("export\n");
2488 printf_unfiltered ("import\n");
2491 printf_unfiltered ("import shlib\n");
2494 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2500 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2502 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2504 An example of this occurs when an a.out is linked against a foo.sl.
2505 The foo.sl defines a global bar(), and the a.out declares a signature
2506 for bar(). However, the a.out doesn't directly call bar(), but passes
2507 its address in another call.
2509 If you have this scenario and attempt to "break bar" before running,
2510 gdb will find a minimal symbol for bar() in the a.out. But that
2511 symbol's address will be negative. What this appears to denote is
2512 an index backwards from the base of the procedure linkage table (PLT)
2513 into the data linkage table (DLT), the end of which is contiguous
2514 with the start of the PLT. This is clearly not a valid address for
2515 us to set a breakpoint on.
2517 Note that one must be careful in how one checks for a negative address.
2518 0xc0000000 is a legitimate address of something in a shared text
2519 segment, for example. Since I don't know what the possible range
2520 is of these "really, truly negative" addresses that come from the
2521 minimal symbols, I'm resorting to the gross hack of checking the
2522 top byte of the address for all 1's. Sigh. */
2524 return (!target_has_stack
&& (pc
& 0xFF000000) == 0xFF000000);
2527 /* Return the GDB type object for the "standard" data type of data in
2530 static struct type
*
2531 hppa32_register_type (struct gdbarch
*gdbarch
, int regnum
)
2533 if (regnum
< HPPA_FP4_REGNUM
)
2534 return builtin_type_uint32
;
2536 return builtin_type_ieee_single_big
;
2539 static struct type
*
2540 hppa64_register_type (struct gdbarch
*gdbarch
, int regnum
)
2542 if (regnum
< HPPA64_FP4_REGNUM
)
2543 return builtin_type_uint64
;
2545 return builtin_type_ieee_double_big
;
2548 /* Return non-zero if REGNUM is not a register available to the user
2549 through ptrace/ttrace. */
2552 hppa32_cannot_store_register (int regnum
)
2555 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2556 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2557 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2561 hppa64_cannot_store_register (int regnum
)
2564 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2565 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2566 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA64_FP4_REGNUM
));
2570 hppa_smash_text_address (CORE_ADDR addr
)
2572 /* The low two bits of the PC on the PA contain the privilege level.
2573 Some genius implementing a (non-GCC) compiler apparently decided
2574 this means that "addresses" in a text section therefore include a
2575 privilege level, and thus symbol tables should contain these bits.
2576 This seems like a bonehead thing to do--anyway, it seems to work
2577 for our purposes to just ignore those bits. */
2579 return (addr
&= ~0x3);
2582 /* Get the ARGIth function argument for the current function. */
2585 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2588 return get_frame_register_unsigned (frame
, HPPA_R0_REGNUM
+ 26 - argi
);
2592 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2593 int regnum
, gdb_byte
*buf
)
2597 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2598 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2600 store_unsigned_integer (buf
, sizeof tmp
, tmp
);
2604 hppa_find_global_pointer (struct value
*function
)
2610 hppa_frame_prev_register_helper (struct frame_info
*next_frame
,
2611 struct trad_frame_saved_reg saved_regs
[],
2612 int regnum
, int *optimizedp
,
2613 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2614 int *realnump
, gdb_byte
*valuep
)
2616 struct gdbarch
*arch
= get_frame_arch (next_frame
);
2618 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2622 int size
= register_size (arch
, HPPA_PCOQ_HEAD_REGNUM
);
2625 trad_frame_get_prev_register (next_frame
, saved_regs
,
2626 HPPA_PCOQ_HEAD_REGNUM
, optimizedp
,
2627 lvalp
, addrp
, realnump
, valuep
);
2629 pc
= extract_unsigned_integer (valuep
, size
);
2630 store_unsigned_integer (valuep
, size
, pc
+ 4);
2633 /* It's a computed value. */
2641 /* Make sure the "flags" register is zero in all unwound frames.
2642 The "flags" registers is a HP-UX specific wart, and only the code
2643 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2644 with it here. This shouldn't affect other systems since those
2645 should provide zero for the "flags" register anyway. */
2646 if (regnum
== HPPA_FLAGS_REGNUM
)
2649 store_unsigned_integer (valuep
, register_size (arch
, regnum
), 0);
2651 /* It's a computed value. */
2659 trad_frame_get_prev_register (next_frame
, saved_regs
, regnum
,
2660 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2664 /* Here is a table of C type sizes on hppa with various compiles
2665 and options. I measured this on PA 9000/800 with HP-UX 11.11
2666 and these compilers:
2668 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2669 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2670 /opt/aCC/bin/aCC B3910B A.03.45
2671 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2673 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2674 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2675 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2676 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2677 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2678 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2679 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2680 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2684 compiler and options
2685 char, short, int, long, long long
2686 float, double, long double
2689 So all these compilers use either ILP32 or LP64 model.
2690 TODO: gcc has more options so it needs more investigation.
2692 For floating point types, see:
2694 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2695 HP-UX floating-point guide, hpux 11.00
2697 -- chastain 2003-12-18 */
2699 static struct gdbarch
*
2700 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2702 struct gdbarch_tdep
*tdep
;
2703 struct gdbarch
*gdbarch
;
2705 /* Try to determine the ABI of the object we are loading. */
2706 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2708 /* If it's a SOM file, assume it's HP/UX SOM. */
2709 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2710 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2713 /* find a candidate among the list of pre-declared architectures. */
2714 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2716 return (arches
->gdbarch
);
2718 /* If none found, then allocate and initialize one. */
2719 tdep
= XZALLOC (struct gdbarch_tdep
);
2720 gdbarch
= gdbarch_alloc (&info
, tdep
);
2722 /* Determine from the bfd_arch_info structure if we are dealing with
2723 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2724 then default to a 32bit machine. */
2725 if (info
.bfd_arch_info
!= NULL
)
2726 tdep
->bytes_per_address
=
2727 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
2729 tdep
->bytes_per_address
= 4;
2731 tdep
->find_global_pointer
= hppa_find_global_pointer
;
2733 /* Some parts of the gdbarch vector depend on whether we are running
2734 on a 32 bits or 64 bits target. */
2735 switch (tdep
->bytes_per_address
)
2738 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
2739 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
2740 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
2741 set_gdbarch_cannot_store_register (gdbarch
,
2742 hppa32_cannot_store_register
);
2743 set_gdbarch_cannot_fetch_register (gdbarch
,
2744 hppa32_cannot_store_register
);
2747 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
2748 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
2749 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
2750 set_gdbarch_cannot_store_register (gdbarch
,
2751 hppa64_cannot_store_register
);
2752 set_gdbarch_cannot_fetch_register (gdbarch
,
2753 hppa64_cannot_store_register
);
2756 internal_error (__FILE__
, __LINE__
, _("Unsupported address size: %d"),
2757 tdep
->bytes_per_address
);
2760 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2761 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2763 /* The following gdbarch vector elements are the same in both ILP32
2764 and LP64, but might show differences some day. */
2765 set_gdbarch_long_long_bit (gdbarch
, 64);
2766 set_gdbarch_long_double_bit (gdbarch
, 128);
2767 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
2769 /* The following gdbarch vector elements do not depend on the address
2770 size, or in any other gdbarch element previously set. */
2771 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
2772 set_gdbarch_in_function_epilogue_p (gdbarch
,
2773 hppa_in_function_epilogue_p
);
2774 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
2775 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
2776 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
2777 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
2778 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
2779 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
2780 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
2781 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
2783 /* Helper for function argument information. */
2784 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
2786 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
2788 /* When a hardware watchpoint triggers, we'll move the inferior past
2789 it by removing all eventpoints; stepping past the instruction
2790 that caused the trigger; reinserting eventpoints; and checking
2791 whether any watched location changed. */
2792 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
2794 /* Inferior function call methods. */
2795 switch (tdep
->bytes_per_address
)
2798 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
2799 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
2800 set_gdbarch_convert_from_func_ptr_addr
2801 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
2804 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
2805 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
2808 internal_error (__FILE__
, __LINE__
, _("bad switch"));
2811 /* Struct return methods. */
2812 switch (tdep
->bytes_per_address
)
2815 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
2818 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
2821 internal_error (__FILE__
, __LINE__
, _("bad switch"));
2824 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
2825 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
2827 /* Frame unwind methods. */
2828 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
2829 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
2831 /* Hook in ABI-specific overrides, if they have been registered. */
2832 gdbarch_init_osabi (info
, gdbarch
);
2834 /* Hook in the default unwinders. */
2835 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
2836 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
2837 frame_unwind_append_sniffer (gdbarch
, hppa_fallback_unwind_sniffer
);
2843 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2845 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2847 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
2848 tdep
->bytes_per_address
);
2849 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
2853 _initialize_hppa_tdep (void)
2855 struct cmd_list_element
*c
;
2857 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
2859 hppa_objfile_priv_data
= register_objfile_data ();
2861 add_cmd ("unwind", class_maintenance
, unwind_command
,
2862 _("Print unwind table entry at given address."),
2863 &maintenanceprintlist
);
2865 /* Debug this files internals. */
2866 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, _("\
2867 Set whether hppa target specific debugging information should be displayed."),
2869 Show whether hppa target specific debugging information is displayed."), _("\
2870 This flag controls whether hppa target specific debugging information is\n\
2871 displayed. This information is particularly useful for debugging frame\n\
2872 unwinding problems."),
2874 NULL
, /* FIXME: i18n: hppa debug flag is %s. */
2875 &setdebuglist
, &showdebuglist
);