1 /* Target-dependent code for the HP PA architecture, for GDB.
3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
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 /* Handle 32/64-bit struct return conventions. */
77 static enum return_value_convention
78 hppa32_return_value (struct gdbarch
*gdbarch
,
79 struct type
*type
, struct regcache
*regcache
,
80 void *readbuf
, const void *writebuf
)
82 if (TYPE_LENGTH (type
) <= 2 * 4)
84 /* The value always lives in the right hand end of the register
85 (or register pair)? */
87 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
88 int part
= TYPE_LENGTH (type
) % 4;
89 /* The left hand register contains only part of the value,
90 transfer that first so that the rest can be xfered as entire
95 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
98 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
102 /* Now transfer the remaining register values. */
103 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
106 regcache_cooked_read (regcache
, reg
, (char *) readbuf
+ b
);
107 if (writebuf
!= NULL
)
108 regcache_cooked_write (regcache
, reg
, (const char *) writebuf
+ b
);
111 return RETURN_VALUE_REGISTER_CONVENTION
;
114 return RETURN_VALUE_STRUCT_CONVENTION
;
117 static enum return_value_convention
118 hppa64_return_value (struct gdbarch
*gdbarch
,
119 struct type
*type
, struct regcache
*regcache
,
120 void *readbuf
, const void *writebuf
)
122 /* RM: Floats are returned in FR4R, doubles in FR4. Integral values
123 are in r28, padded on the left. Aggregates less that 65 bits are
124 in r28, right padded. Aggregates upto 128 bits are in r28 and
125 r29, right padded. */
126 if (TYPE_CODE (type
) == TYPE_CODE_FLT
127 && TYPE_LENGTH (type
) <= 8)
129 /* Floats are right aligned? */
130 int offset
= register_size (gdbarch
, HPPA_FP4_REGNUM
) - TYPE_LENGTH (type
);
132 regcache_cooked_read_part (regcache
, HPPA_FP4_REGNUM
, offset
,
133 TYPE_LENGTH (type
), readbuf
);
134 if (writebuf
!= NULL
)
135 regcache_cooked_write_part (regcache
, HPPA_FP4_REGNUM
, offset
,
136 TYPE_LENGTH (type
), writebuf
);
137 return RETURN_VALUE_REGISTER_CONVENTION
;
139 else if (TYPE_LENGTH (type
) <= 8 && is_integral_type (type
))
141 /* Integrals are right aligned. */
142 int offset
= register_size (gdbarch
, HPPA_FP4_REGNUM
) - TYPE_LENGTH (type
);
144 regcache_cooked_read_part (regcache
, 28, offset
,
145 TYPE_LENGTH (type
), readbuf
);
146 if (writebuf
!= NULL
)
147 regcache_cooked_write_part (regcache
, 28, offset
,
148 TYPE_LENGTH (type
), writebuf
);
149 return RETURN_VALUE_REGISTER_CONVENTION
;
151 else if (TYPE_LENGTH (type
) <= 2 * 8)
153 /* Composite values are left aligned. */
155 for (b
= 0; b
< TYPE_LENGTH (type
); b
+= 8)
157 int part
= min (8, TYPE_LENGTH (type
) - b
);
159 regcache_cooked_read_part (regcache
, 28 + b
/ 8, 0, part
,
160 (char *) readbuf
+ b
);
161 if (writebuf
!= NULL
)
162 regcache_cooked_write_part (regcache
, 28 + b
/ 8, 0, part
,
163 (const char *) writebuf
+ b
);
165 return RETURN_VALUE_REGISTER_CONVENTION
;
168 return RETURN_VALUE_STRUCT_CONVENTION
;
171 /* Routines to extract various sized constants out of hppa
174 /* This assumes that no garbage lies outside of the lower bits of
178 hppa_sign_extend (unsigned val
, unsigned bits
)
180 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
183 /* For many immediate values the sign bit is the low bit! */
186 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
188 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
191 /* Extract the bits at positions between FROM and TO, using HP's numbering
195 hppa_get_field (unsigned word
, int from
, int to
)
197 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
200 /* extract the immediate field from a ld{bhw}s instruction */
203 hppa_extract_5_load (unsigned word
)
205 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
208 /* extract the immediate field from a break instruction */
211 hppa_extract_5r_store (unsigned word
)
213 return (word
& MASK_5
);
216 /* extract the immediate field from a {sr}sm instruction */
219 hppa_extract_5R_store (unsigned word
)
221 return (word
>> 16 & MASK_5
);
224 /* extract a 14 bit immediate field */
227 hppa_extract_14 (unsigned word
)
229 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
232 /* extract a 21 bit constant */
235 hppa_extract_21 (unsigned word
)
241 val
= hppa_get_field (word
, 20, 20);
243 val
|= hppa_get_field (word
, 9, 19);
245 val
|= hppa_get_field (word
, 5, 6);
247 val
|= hppa_get_field (word
, 0, 4);
249 val
|= hppa_get_field (word
, 7, 8);
250 return hppa_sign_extend (val
, 21) << 11;
253 /* extract a 17 bit constant from branch instructions, returning the
254 19 bit signed value. */
257 hppa_extract_17 (unsigned word
)
259 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
260 hppa_get_field (word
, 29, 29) << 10 |
261 hppa_get_field (word
, 11, 15) << 11 |
262 (word
& 0x1) << 16, 17) << 2;
266 hppa_symbol_address(const char *sym
)
268 struct minimal_symbol
*minsym
;
270 minsym
= lookup_minimal_symbol (sym
, NULL
, NULL
);
272 return SYMBOL_VALUE_ADDRESS (minsym
);
274 return (CORE_ADDR
)-1;
278 /* Compare the start address for two unwind entries returning 1 if
279 the first address is larger than the second, -1 if the second is
280 larger than the first, and zero if they are equal. */
283 compare_unwind_entries (const void *arg1
, const void *arg2
)
285 const struct unwind_table_entry
*a
= arg1
;
286 const struct unwind_table_entry
*b
= arg2
;
288 if (a
->region_start
> b
->region_start
)
290 else if (a
->region_start
< b
->region_start
)
297 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
299 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
300 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
302 bfd_vma value
= section
->vma
- section
->filepos
;
303 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
305 if (value
< *low_text_segment_address
)
306 *low_text_segment_address
= value
;
311 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
312 asection
*section
, unsigned int entries
, unsigned int size
,
313 CORE_ADDR text_offset
)
315 /* We will read the unwind entries into temporary memory, then
316 fill in the actual unwind table. */
322 char *buf
= alloca (size
);
323 CORE_ADDR low_text_segment_address
;
325 /* For ELF targets, then unwinds are supposed to
326 be segment relative offsets instead of absolute addresses.
328 Note that when loading a shared library (text_offset != 0) the
329 unwinds are already relative to the text_offset that will be
331 if (gdbarch_tdep (current_gdbarch
)->is_elf
&& text_offset
== 0)
333 low_text_segment_address
= -1;
335 bfd_map_over_sections (objfile
->obfd
,
336 record_text_segment_lowaddr
,
337 &low_text_segment_address
);
339 text_offset
= low_text_segment_address
;
342 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
344 /* Now internalize the information being careful to handle host/target
346 for (i
= 0; i
< entries
; i
++)
348 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
350 table
[i
].region_start
+= text_offset
;
352 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
353 table
[i
].region_end
+= text_offset
;
355 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
357 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
358 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
359 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
360 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
361 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
362 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
363 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
364 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
365 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
366 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
367 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
368 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
369 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
370 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
371 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
372 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
373 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
374 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
375 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
376 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
377 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
378 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
379 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
380 table
[i
].Cleanup_defined
= tmp
& 0x1;
381 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
383 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
384 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
385 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
386 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
387 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
388 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
390 /* Stub unwinds are handled elsewhere. */
391 table
[i
].stub_unwind
.stub_type
= 0;
392 table
[i
].stub_unwind
.padding
= 0;
397 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
398 the object file. This info is used mainly by find_unwind_entry() to find
399 out the stack frame size and frame pointer used by procedures. We put
400 everything on the psymbol obstack in the objfile so that it automatically
401 gets freed when the objfile is destroyed. */
404 read_unwind_info (struct objfile
*objfile
)
406 asection
*unwind_sec
, *stub_unwind_sec
;
407 unsigned unwind_size
, stub_unwind_size
, total_size
;
408 unsigned index
, unwind_entries
;
409 unsigned stub_entries
, total_entries
;
410 CORE_ADDR text_offset
;
411 struct hppa_unwind_info
*ui
;
412 struct hppa_objfile_private
*obj_private
;
414 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
415 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
416 sizeof (struct hppa_unwind_info
));
422 /* For reasons unknown the HP PA64 tools generate multiple unwinder
423 sections in a single executable. So we just iterate over every
424 section in the BFD looking for unwinder sections intead of trying
425 to do a lookup with bfd_get_section_by_name.
427 First determine the total size of the unwind tables so that we
428 can allocate memory in a nice big hunk. */
430 for (unwind_sec
= objfile
->obfd
->sections
;
432 unwind_sec
= unwind_sec
->next
)
434 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
435 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
437 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
438 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
440 total_entries
+= unwind_entries
;
444 /* Now compute the size of the stub unwinds. Note the ELF tools do not
445 use stub unwinds at the curren time. */
446 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
450 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
451 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
455 stub_unwind_size
= 0;
459 /* Compute total number of unwind entries and their total size. */
460 total_entries
+= stub_entries
;
461 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
463 /* Allocate memory for the unwind table. */
464 ui
->table
= (struct unwind_table_entry
*)
465 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
466 ui
->last
= total_entries
- 1;
468 /* Now read in each unwind section and internalize the standard unwind
471 for (unwind_sec
= objfile
->obfd
->sections
;
473 unwind_sec
= unwind_sec
->next
)
475 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
476 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
478 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
479 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
481 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
482 unwind_entries
, unwind_size
, text_offset
);
483 index
+= unwind_entries
;
487 /* Now read in and internalize the stub unwind entries. */
488 if (stub_unwind_size
> 0)
491 char *buf
= alloca (stub_unwind_size
);
493 /* Read in the stub unwind entries. */
494 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
495 0, stub_unwind_size
);
497 /* Now convert them into regular unwind entries. */
498 for (i
= 0; i
< stub_entries
; i
++, index
++)
500 /* Clear out the next unwind entry. */
501 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
503 /* Convert offset & size into region_start and region_end.
504 Stuff away the stub type into "reserved" fields. */
505 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
507 ui
->table
[index
].region_start
+= text_offset
;
509 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
512 ui
->table
[index
].region_end
513 = ui
->table
[index
].region_start
+ 4 *
514 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
520 /* Unwind table needs to be kept sorted. */
521 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
522 compare_unwind_entries
);
524 /* Keep a pointer to the unwind information. */
525 obj_private
= (struct hppa_objfile_private
*)
526 objfile_data (objfile
, hppa_objfile_priv_data
);
527 if (obj_private
== NULL
)
529 obj_private
= (struct hppa_objfile_private
*)
530 obstack_alloc (&objfile
->objfile_obstack
,
531 sizeof (struct hppa_objfile_private
));
532 set_objfile_data (objfile
, hppa_objfile_priv_data
, obj_private
);
533 obj_private
->unwind_info
= NULL
;
534 obj_private
->so_info
= NULL
;
537 obj_private
->unwind_info
= ui
;
540 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
541 of the objfiles seeking the unwind table entry for this PC. Each objfile
542 contains a sorted list of struct unwind_table_entry. Since we do a binary
543 search of the unwind tables, we depend upon them to be sorted. */
545 struct unwind_table_entry
*
546 find_unwind_entry (CORE_ADDR pc
)
548 int first
, middle
, last
;
549 struct objfile
*objfile
;
550 struct hppa_objfile_private
*priv
;
553 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
556 /* A function at address 0? Not in HP-UX! */
557 if (pc
== (CORE_ADDR
) 0)
560 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
564 ALL_OBJFILES (objfile
)
566 struct hppa_unwind_info
*ui
;
568 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
570 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
574 read_unwind_info (objfile
);
575 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
577 error ("Internal error reading unwind information.");
578 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
581 /* First, check the cache */
584 && pc
>= ui
->cache
->region_start
585 && pc
<= ui
->cache
->region_end
)
588 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
589 paddr_nz ((CORE_ADDR
) ui
->cache
));
593 /* Not in the cache, do a binary search */
598 while (first
<= last
)
600 middle
= (first
+ last
) / 2;
601 if (pc
>= ui
->table
[middle
].region_start
602 && pc
<= ui
->table
[middle
].region_end
)
604 ui
->cache
= &ui
->table
[middle
];
606 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
607 paddr_nz ((CORE_ADDR
) ui
->cache
));
608 return &ui
->table
[middle
];
611 if (pc
< ui
->table
[middle
].region_start
)
616 } /* ALL_OBJFILES() */
619 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
624 static const unsigned char *
625 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
627 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
628 (*len
) = sizeof (breakpoint
);
632 /* Return the name of a register. */
635 hppa32_register_name (int i
)
637 static char *names
[] = {
638 "flags", "r1", "rp", "r3",
639 "r4", "r5", "r6", "r7",
640 "r8", "r9", "r10", "r11",
641 "r12", "r13", "r14", "r15",
642 "r16", "r17", "r18", "r19",
643 "r20", "r21", "r22", "r23",
644 "r24", "r25", "r26", "dp",
645 "ret0", "ret1", "sp", "r31",
646 "sar", "pcoqh", "pcsqh", "pcoqt",
647 "pcsqt", "eiem", "iir", "isr",
648 "ior", "ipsw", "goto", "sr4",
649 "sr0", "sr1", "sr2", "sr3",
650 "sr5", "sr6", "sr7", "cr0",
651 "cr8", "cr9", "ccr", "cr12",
652 "cr13", "cr24", "cr25", "cr26",
653 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
654 "fpsr", "fpe1", "fpe2", "fpe3",
655 "fpe4", "fpe5", "fpe6", "fpe7",
656 "fr4", "fr4R", "fr5", "fr5R",
657 "fr6", "fr6R", "fr7", "fr7R",
658 "fr8", "fr8R", "fr9", "fr9R",
659 "fr10", "fr10R", "fr11", "fr11R",
660 "fr12", "fr12R", "fr13", "fr13R",
661 "fr14", "fr14R", "fr15", "fr15R",
662 "fr16", "fr16R", "fr17", "fr17R",
663 "fr18", "fr18R", "fr19", "fr19R",
664 "fr20", "fr20R", "fr21", "fr21R",
665 "fr22", "fr22R", "fr23", "fr23R",
666 "fr24", "fr24R", "fr25", "fr25R",
667 "fr26", "fr26R", "fr27", "fr27R",
668 "fr28", "fr28R", "fr29", "fr29R",
669 "fr30", "fr30R", "fr31", "fr31R"
671 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
678 hppa64_register_name (int i
)
680 static char *names
[] = {
681 "flags", "r1", "rp", "r3",
682 "r4", "r5", "r6", "r7",
683 "r8", "r9", "r10", "r11",
684 "r12", "r13", "r14", "r15",
685 "r16", "r17", "r18", "r19",
686 "r20", "r21", "r22", "r23",
687 "r24", "r25", "r26", "dp",
688 "ret0", "ret1", "sp", "r31",
689 "sar", "pcoqh", "pcsqh", "pcoqt",
690 "pcsqt", "eiem", "iir", "isr",
691 "ior", "ipsw", "goto", "sr4",
692 "sr0", "sr1", "sr2", "sr3",
693 "sr5", "sr6", "sr7", "cr0",
694 "cr8", "cr9", "ccr", "cr12",
695 "cr13", "cr24", "cr25", "cr26",
696 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
697 "fpsr", "fpe1", "fpe2", "fpe3",
698 "fr4", "fr5", "fr6", "fr7",
699 "fr8", "fr9", "fr10", "fr11",
700 "fr12", "fr13", "fr14", "fr15",
701 "fr16", "fr17", "fr18", "fr19",
702 "fr20", "fr21", "fr22", "fr23",
703 "fr24", "fr25", "fr26", "fr27",
704 "fr28", "fr29", "fr30", "fr31"
706 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
712 /* This function pushes a stack frame with arguments as part of the
713 inferior function calling mechanism.
715 This is the version of the function for the 32-bit PA machines, in
716 which later arguments appear at lower addresses. (The stack always
717 grows towards higher addresses.)
719 We simply allocate the appropriate amount of stack space and put
720 arguments into their proper slots. */
723 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
724 struct regcache
*regcache
, CORE_ADDR bp_addr
,
725 int nargs
, struct value
**args
, CORE_ADDR sp
,
726 int struct_return
, CORE_ADDR struct_addr
)
728 /* Stack base address at which any pass-by-reference parameters are
730 CORE_ADDR struct_end
= 0;
731 /* Stack base address at which the first parameter is stored. */
732 CORE_ADDR param_end
= 0;
734 /* The inner most end of the stack after all the parameters have
736 CORE_ADDR new_sp
= 0;
738 /* Two passes. First pass computes the location of everything,
739 second pass writes the bytes out. */
742 /* Global pointer (r19) of the function we are trying to call. */
745 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
747 for (write_pass
= 0; write_pass
< 2; write_pass
++)
749 CORE_ADDR struct_ptr
= 0;
750 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
751 struct_ptr is adjusted for each argument below, so the first
752 argument will end up at sp-36. */
753 CORE_ADDR param_ptr
= 32;
755 int small_struct
= 0;
757 for (i
= 0; i
< nargs
; i
++)
759 struct value
*arg
= args
[i
];
760 struct type
*type
= check_typedef (value_type (arg
));
761 /* The corresponding parameter that is pushed onto the
762 stack, and [possibly] passed in a register. */
765 memset (param_val
, 0, sizeof param_val
);
766 if (TYPE_LENGTH (type
) > 8)
768 /* Large parameter, pass by reference. Store the value
769 in "struct" area and then pass its address. */
771 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
773 write_memory (struct_end
- struct_ptr
, VALUE_CONTENTS (arg
),
775 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
777 else if (TYPE_CODE (type
) == TYPE_CODE_INT
778 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
780 /* Integer value store, right aligned. "unpack_long"
781 takes care of any sign-extension problems. */
782 param_len
= align_up (TYPE_LENGTH (type
), 4);
783 store_unsigned_integer (param_val
, param_len
,
785 VALUE_CONTENTS (arg
)));
787 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
789 /* Floating point value store, right aligned. */
790 param_len
= align_up (TYPE_LENGTH (type
), 4);
791 memcpy (param_val
, VALUE_CONTENTS (arg
), param_len
);
795 param_len
= align_up (TYPE_LENGTH (type
), 4);
797 /* Small struct value are stored right-aligned. */
798 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
799 VALUE_CONTENTS (arg
), TYPE_LENGTH (type
));
801 /* Structures of size 5, 6 and 7 bytes are special in that
802 the higher-ordered word is stored in the lower-ordered
803 argument, and even though it is a 8-byte quantity the
804 registers need not be 8-byte aligned. */
805 if (param_len
> 4 && param_len
< 8)
809 param_ptr
+= param_len
;
810 if (param_len
== 8 && !small_struct
)
811 param_ptr
= align_up (param_ptr
, 8);
813 /* First 4 non-FP arguments are passed in gr26-gr23.
814 First 4 32-bit FP arguments are passed in fr4L-fr7L.
815 First 2 64-bit FP arguments are passed in fr5 and fr7.
817 The rest go on the stack, starting at sp-36, towards lower
818 addresses. 8-byte arguments must be aligned to a 8-byte
822 write_memory (param_end
- param_ptr
, param_val
, param_len
);
824 /* There are some cases when we don't know the type
825 expected by the callee (e.g. for variadic functions), so
826 pass the parameters in both general and fp regs. */
829 int grreg
= 26 - (param_ptr
- 36) / 4;
830 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
831 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
833 regcache_cooked_write (regcache
, grreg
, param_val
);
834 regcache_cooked_write (regcache
, fpLreg
, param_val
);
838 regcache_cooked_write (regcache
, grreg
+ 1,
841 regcache_cooked_write (regcache
, fpreg
, param_val
);
842 regcache_cooked_write (regcache
, fpreg
+ 1,
849 /* Update the various stack pointers. */
852 struct_end
= sp
+ align_up (struct_ptr
, 64);
853 /* PARAM_PTR already accounts for all the arguments passed
854 by the user. However, the ABI mandates minimum stack
855 space allocations for outgoing arguments. The ABI also
856 mandates minimum stack alignments which we must
858 param_end
= struct_end
+ align_up (param_ptr
, 64);
862 /* If a structure has to be returned, set up register 28 to hold its
865 write_register (28, struct_addr
);
867 gp
= tdep
->find_global_pointer (function
);
870 write_register (19, gp
);
872 /* Set the return address. */
873 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
875 /* Update the Stack Pointer. */
876 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
881 /* This function pushes a stack frame with arguments as part of the
882 inferior function calling mechanism.
884 This is the version for the PA64, in which later arguments appear
885 at higher addresses. (The stack always grows towards higher
888 We simply allocate the appropriate amount of stack space and put
889 arguments into their proper slots.
891 This ABI also requires that the caller provide an argument pointer
892 to the callee, so we do that too. */
895 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
896 struct regcache
*regcache
, CORE_ADDR bp_addr
,
897 int nargs
, struct value
**args
, CORE_ADDR sp
,
898 int struct_return
, CORE_ADDR struct_addr
)
900 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
901 reverse engineering testsuite failures. */
903 /* Stack base address at which any pass-by-reference parameters are
905 CORE_ADDR struct_end
= 0;
906 /* Stack base address at which the first parameter is stored. */
907 CORE_ADDR param_end
= 0;
909 /* The inner most end of the stack after all the parameters have
911 CORE_ADDR new_sp
= 0;
913 /* Two passes. First pass computes the location of everything,
914 second pass writes the bytes out. */
916 for (write_pass
= 0; write_pass
< 2; write_pass
++)
918 CORE_ADDR struct_ptr
= 0;
919 CORE_ADDR param_ptr
= 0;
921 for (i
= 0; i
< nargs
; i
++)
923 struct value
*arg
= args
[i
];
924 struct type
*type
= check_typedef (value_type (arg
));
925 if ((TYPE_CODE (type
) == TYPE_CODE_INT
926 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
927 && TYPE_LENGTH (type
) <= 8)
929 /* Integer value store, right aligned. "unpack_long"
930 takes care of any sign-extension problems. */
934 ULONGEST val
= unpack_long (type
, VALUE_CONTENTS (arg
));
935 int reg
= 27 - param_ptr
/ 8;
936 write_memory_unsigned_integer (param_end
- param_ptr
,
939 regcache_cooked_write_unsigned (regcache
, reg
, val
);
944 /* Small struct value, store left aligned? */
946 if (TYPE_LENGTH (type
) > 8)
948 param_ptr
= align_up (param_ptr
, 16);
949 reg
= 26 - param_ptr
/ 8;
950 param_ptr
+= align_up (TYPE_LENGTH (type
), 16);
954 param_ptr
= align_up (param_ptr
, 8);
955 reg
= 26 - param_ptr
/ 8;
956 param_ptr
+= align_up (TYPE_LENGTH (type
), 8);
961 write_memory (param_end
- param_ptr
, VALUE_CONTENTS (arg
),
963 for (byte
= 0; byte
< TYPE_LENGTH (type
); byte
+= 8)
967 int len
= min (8, TYPE_LENGTH (type
) - byte
);
968 regcache_cooked_write_part (regcache
, reg
, 0, len
,
969 VALUE_CONTENTS (arg
) + byte
);
976 /* Update the various stack pointers. */
979 struct_end
= sp
+ struct_ptr
;
980 /* PARAM_PTR already accounts for all the arguments passed
981 by the user. However, the ABI mandates minimum stack
982 space allocations for outgoing arguments. The ABI also
983 mandates minimum stack alignments which we must
985 param_end
= struct_end
+ max (align_up (param_ptr
, 16), 64);
989 /* If a structure has to be returned, set up register 28 to hold its
992 write_register (28, struct_addr
);
994 /* Set the return address. */
995 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
997 /* Update the Stack Pointer. */
998 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
+ 64);
1000 /* The stack will have 32 bytes of additional space for a frame marker. */
1001 return param_end
+ 64;
1005 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
1007 struct target_ops
*targ
)
1014 target_read_memory(plabel
, (char *)&addr
, 4);
1021 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1023 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1025 return align_up (addr
, 64);
1028 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1031 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1033 /* Just always 16-byte align. */
1034 return align_up (addr
, 16);
1038 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1042 hppa_target_read_pc (ptid_t ptid
)
1044 int flags
= read_register_pid (HPPA_FLAGS_REGNUM
, ptid
);
1045 ULONGEST ipsw
= read_register_pid (HPPA_IPSW_REGNUM
, ptid
);
1048 /* The following test does not belong here. It is OS-specific, and belongs
1050 /* Test SS_INSYSCALL */
1052 return read_register_pid (31, ptid
) & ~0x3;
1054 pc
= read_register_pid (HPPA_PCOQ_HEAD_REGNUM
, ptid
) & ~0x3;
1056 /* If the current instruction is nullified, then we are effectively
1057 still executing the previous instruction. Pretend we are still
1058 there. This is needed when single stepping; if the nullified instruction
1059 is on a different line, we don't want gdb to think we've stepped onto
1061 if (ipsw
& 0x00200000)
1067 /* Write out the PC. If currently in a syscall, then also write the new
1068 PC value into %r31. */
1071 hppa_target_write_pc (CORE_ADDR v
, ptid_t ptid
)
1073 int flags
= read_register_pid (HPPA_FLAGS_REGNUM
, ptid
);
1075 /* The following test does not belong here. It is OS-specific, and belongs
1077 /* If in a syscall, then set %r31. Also make sure to get the
1078 privilege bits set correctly. */
1079 /* Test SS_INSYSCALL */
1081 write_register_pid (31, v
| 0x3, ptid
);
1083 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, v
, ptid
);
1084 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, v
+ 4, ptid
);
1087 /* return the alignment of a type in bytes. Structures have the maximum
1088 alignment required by their fields. */
1091 hppa_alignof (struct type
*type
)
1093 int max_align
, align
, i
;
1094 CHECK_TYPEDEF (type
);
1095 switch (TYPE_CODE (type
))
1100 return TYPE_LENGTH (type
);
1101 case TYPE_CODE_ARRAY
:
1102 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1103 case TYPE_CODE_STRUCT
:
1104 case TYPE_CODE_UNION
:
1106 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1108 /* Bit fields have no real alignment. */
1109 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1110 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1112 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1113 max_align
= max (max_align
, align
);
1122 /* For the given instruction (INST), return any adjustment it makes
1123 to the stack pointer or zero for no adjustment.
1125 This only handles instructions commonly found in prologues. */
1128 prologue_inst_adjust_sp (unsigned long inst
)
1130 /* This must persist across calls. */
1131 static int save_high21
;
1133 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1134 if ((inst
& 0xffffc000) == 0x37de0000)
1135 return hppa_extract_14 (inst
);
1138 if ((inst
& 0xffe00000) == 0x6fc00000)
1139 return hppa_extract_14 (inst
);
1141 /* std,ma X,D(sp) */
1142 if ((inst
& 0xffe00008) == 0x73c00008)
1143 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1145 /* addil high21,%r1; ldo low11,(%r1),%r30)
1146 save high bits in save_high21 for later use. */
1147 if ((inst
& 0xffe00000) == 0x28200000)
1149 save_high21
= hppa_extract_21 (inst
);
1153 if ((inst
& 0xffff0000) == 0x343e0000)
1154 return save_high21
+ hppa_extract_14 (inst
);
1156 /* fstws as used by the HP compilers. */
1157 if ((inst
& 0xffffffe0) == 0x2fd01220)
1158 return hppa_extract_5_load (inst
);
1160 /* No adjustment. */
1164 /* Return nonzero if INST is a branch of some kind, else return zero. */
1167 is_branch (unsigned long inst
)
1196 /* Return the register number for a GR which is saved by INST or
1197 zero it INST does not save a GR. */
1200 inst_saves_gr (unsigned long inst
)
1202 /* Does it look like a stw? */
1203 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1204 || (inst
>> 26) == 0x1f
1205 || ((inst
>> 26) == 0x1f
1206 && ((inst
>> 6) == 0xa)))
1207 return hppa_extract_5R_store (inst
);
1209 /* Does it look like a std? */
1210 if ((inst
>> 26) == 0x1c
1211 || ((inst
>> 26) == 0x03
1212 && ((inst
>> 6) & 0xf) == 0xb))
1213 return hppa_extract_5R_store (inst
);
1215 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1216 if ((inst
>> 26) == 0x1b)
1217 return hppa_extract_5R_store (inst
);
1219 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1221 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1222 || ((inst
>> 26) == 0x3
1223 && (((inst
>> 6) & 0xf) == 0x8
1224 || (inst
>> 6) & 0xf) == 0x9))
1225 return hppa_extract_5R_store (inst
);
1230 /* Return the register number for a FR which is saved by INST or
1231 zero it INST does not save a FR.
1233 Note we only care about full 64bit register stores (that's the only
1234 kind of stores the prologue will use).
1236 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1239 inst_saves_fr (unsigned long inst
)
1241 /* is this an FSTD ? */
1242 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1243 return hppa_extract_5r_store (inst
);
1244 if ((inst
& 0xfc000002) == 0x70000002)
1245 return hppa_extract_5R_store (inst
);
1246 /* is this an FSTW ? */
1247 if ((inst
& 0xfc00df80) == 0x24001200)
1248 return hppa_extract_5r_store (inst
);
1249 if ((inst
& 0xfc000002) == 0x7c000000)
1250 return hppa_extract_5R_store (inst
);
1254 /* Advance PC across any function entry prologue instructions
1255 to reach some "real" code.
1257 Use information in the unwind table to determine what exactly should
1258 be in the prologue. */
1262 skip_prologue_hard_way (CORE_ADDR pc
, int stop_before_branch
)
1265 CORE_ADDR orig_pc
= pc
;
1266 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1267 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1268 struct unwind_table_entry
*u
;
1269 int final_iteration
;
1275 u
= find_unwind_entry (pc
);
1279 /* If we are not at the beginning of a function, then return now. */
1280 if ((pc
& ~0x3) != u
->region_start
)
1283 /* This is how much of a frame adjustment we need to account for. */
1284 stack_remaining
= u
->Total_frame_size
<< 3;
1286 /* Magic register saves we want to know about. */
1287 save_rp
= u
->Save_RP
;
1288 save_sp
= u
->Save_SP
;
1290 /* An indication that args may be stored into the stack. Unfortunately
1291 the HPUX compilers tend to set this in cases where no args were
1295 /* Turn the Entry_GR field into a bitmask. */
1297 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1299 /* Frame pointer gets saved into a special location. */
1300 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1303 save_gr
|= (1 << i
);
1305 save_gr
&= ~restart_gr
;
1307 /* Turn the Entry_FR field into a bitmask too. */
1309 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1310 save_fr
|= (1 << i
);
1311 save_fr
&= ~restart_fr
;
1313 final_iteration
= 0;
1315 /* Loop until we find everything of interest or hit a branch.
1317 For unoptimized GCC code and for any HP CC code this will never ever
1318 examine any user instructions.
1320 For optimzied GCC code we're faced with problems. GCC will schedule
1321 its prologue and make prologue instructions available for delay slot
1322 filling. The end result is user code gets mixed in with the prologue
1323 and a prologue instruction may be in the delay slot of the first branch
1326 Some unexpected things are expected with debugging optimized code, so
1327 we allow this routine to walk past user instructions in optimized
1329 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1332 unsigned int reg_num
;
1333 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1334 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1336 /* Save copies of all the triggers so we can compare them later
1338 old_save_gr
= save_gr
;
1339 old_save_fr
= save_fr
;
1340 old_save_rp
= save_rp
;
1341 old_save_sp
= save_sp
;
1342 old_stack_remaining
= stack_remaining
;
1344 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1345 inst
= extract_unsigned_integer (buf
, 4);
1351 /* Note the interesting effects of this instruction. */
1352 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1354 /* There are limited ways to store the return pointer into the
1356 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
1359 /* These are the only ways we save SP into the stack. At this time
1360 the HP compilers never bother to save SP into the stack. */
1361 if ((inst
& 0xffffc000) == 0x6fc10000
1362 || (inst
& 0xffffc00c) == 0x73c10008)
1365 /* Are we loading some register with an offset from the argument
1367 if ((inst
& 0xffe00000) == 0x37a00000
1368 || (inst
& 0xffffffe0) == 0x081d0240)
1374 /* Account for general and floating-point register saves. */
1375 reg_num
= inst_saves_gr (inst
);
1376 save_gr
&= ~(1 << reg_num
);
1378 /* Ugh. Also account for argument stores into the stack.
1379 Unfortunately args_stored only tells us that some arguments
1380 where stored into the stack. Not how many or what kind!
1382 This is a kludge as on the HP compiler sets this bit and it
1383 never does prologue scheduling. So once we see one, skip past
1384 all of them. We have similar code for the fp arg stores below.
1386 FIXME. Can still die if we have a mix of GR and FR argument
1388 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1390 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1393 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1394 inst
= extract_unsigned_integer (buf
, 4);
1397 reg_num
= inst_saves_gr (inst
);
1403 reg_num
= inst_saves_fr (inst
);
1404 save_fr
&= ~(1 << reg_num
);
1406 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1407 next_inst
= extract_unsigned_integer (buf
, 4);
1413 /* We've got to be read to handle the ldo before the fp register
1415 if ((inst
& 0xfc000000) == 0x34000000
1416 && inst_saves_fr (next_inst
) >= 4
1417 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1419 /* So we drop into the code below in a reasonable state. */
1420 reg_num
= inst_saves_fr (next_inst
);
1424 /* Ugh. Also account for argument stores into the stack.
1425 This is a kludge as on the HP compiler sets this bit and it
1426 never does prologue scheduling. So once we see one, skip past
1428 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1430 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1433 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1434 inst
= extract_unsigned_integer (buf
, 4);
1437 if ((inst
& 0xfc000000) != 0x34000000)
1439 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1440 next_inst
= extract_unsigned_integer (buf
, 4);
1443 reg_num
= inst_saves_fr (next_inst
);
1449 /* Quit if we hit any kind of branch. This can happen if a prologue
1450 instruction is in the delay slot of the first call/branch. */
1451 if (is_branch (inst
) && stop_before_branch
)
1454 /* What a crock. The HP compilers set args_stored even if no
1455 arguments were stored into the stack (boo hiss). This could
1456 cause this code to then skip a bunch of user insns (up to the
1459 To combat this we try to identify when args_stored was bogusly
1460 set and clear it. We only do this when args_stored is nonzero,
1461 all other resources are accounted for, and nothing changed on
1464 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1465 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1466 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1467 && old_stack_remaining
== stack_remaining
)
1473 /* !stop_before_branch, so also look at the insn in the delay slot
1475 if (final_iteration
)
1477 if (is_branch (inst
))
1478 final_iteration
= 1;
1481 /* We've got a tenative location for the end of the prologue. However
1482 because of limitations in the unwind descriptor mechanism we may
1483 have went too far into user code looking for the save of a register
1484 that does not exist. So, if there registers we expected to be saved
1485 but never were, mask them out and restart.
1487 This should only happen in optimized code, and should be very rare. */
1488 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1491 restart_gr
= save_gr
;
1492 restart_fr
= save_fr
;
1500 /* Return the address of the PC after the last prologue instruction if
1501 we can determine it from the debug symbols. Else return zero. */
1504 after_prologue (CORE_ADDR pc
)
1506 struct symtab_and_line sal
;
1507 CORE_ADDR func_addr
, func_end
;
1510 /* If we can not find the symbol in the partial symbol table, then
1511 there is no hope we can determine the function's start address
1513 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1516 /* Get the line associated with FUNC_ADDR. */
1517 sal
= find_pc_line (func_addr
, 0);
1519 /* There are only two cases to consider. First, the end of the source line
1520 is within the function bounds. In that case we return the end of the
1521 source line. Second is the end of the source line extends beyond the
1522 bounds of the current function. We need to use the slow code to
1523 examine instructions in that case.
1525 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1526 the wrong thing to do. In fact, it should be entirely possible for this
1527 function to always return zero since the slow instruction scanning code
1528 is supposed to *always* work. If it does not, then it is a bug. */
1529 if (sal
.end
< func_end
)
1535 /* To skip prologues, I use this predicate. Returns either PC itself
1536 if the code at PC does not look like a function prologue; otherwise
1537 returns an address that (if we're lucky) follows the prologue.
1539 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1540 It doesn't necessarily skips all the insns in the prologue. In fact
1541 we might not want to skip all the insns because a prologue insn may
1542 appear in the delay slot of the first branch, and we don't want to
1543 skip over the branch in that case. */
1546 hppa_skip_prologue (CORE_ADDR pc
)
1550 CORE_ADDR post_prologue_pc
;
1553 /* See if we can determine the end of the prologue via the symbol table.
1554 If so, then return either PC, or the PC after the prologue, whichever
1557 post_prologue_pc
= after_prologue (pc
);
1559 /* If after_prologue returned a useful address, then use it. Else
1560 fall back on the instruction skipping code.
1562 Some folks have claimed this causes problems because the breakpoint
1563 may be the first instruction of the prologue. If that happens, then
1564 the instruction skipping code has a bug that needs to be fixed. */
1565 if (post_prologue_pc
!= 0)
1566 return max (pc
, post_prologue_pc
);
1568 return (skip_prologue_hard_way (pc
, 1));
1571 struct hppa_frame_cache
1574 struct trad_frame_saved_reg
*saved_regs
;
1577 static struct hppa_frame_cache
*
1578 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1580 struct hppa_frame_cache
*cache
;
1585 struct unwind_table_entry
*u
;
1586 CORE_ADDR prologue_end
;
1591 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1592 frame_relative_level(next_frame
));
1594 if ((*this_cache
) != NULL
)
1597 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1598 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1599 return (*this_cache
);
1601 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1602 (*this_cache
) = cache
;
1603 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1606 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
1610 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1611 return (*this_cache
);
1614 /* Turn the Entry_GR field into a bitmask. */
1616 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1618 /* Frame pointer gets saved into a special location. */
1619 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1622 saved_gr_mask
|= (1 << i
);
1625 /* Turn the Entry_FR field into a bitmask too. */
1627 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1628 saved_fr_mask
|= (1 << i
);
1630 /* Loop until we find everything of interest or hit a branch.
1632 For unoptimized GCC code and for any HP CC code this will never ever
1633 examine any user instructions.
1635 For optimized GCC code we're faced with problems. GCC will schedule
1636 its prologue and make prologue instructions available for delay slot
1637 filling. The end result is user code gets mixed in with the prologue
1638 and a prologue instruction may be in the delay slot of the first branch
1641 Some unexpected things are expected with debugging optimized code, so
1642 we allow this routine to walk past user instructions in optimized
1645 int final_iteration
= 0;
1646 CORE_ADDR pc
, end_pc
;
1647 int looking_for_sp
= u
->Save_SP
;
1648 int looking_for_rp
= u
->Save_RP
;
1651 /* We have to use skip_prologue_hard_way instead of just
1652 skip_prologue_using_sal, in case we stepped into a function without
1653 symbol information. hppa_skip_prologue also bounds the returned
1654 pc by the passed in pc, so it will not return a pc in the next
1657 We used to call hppa_skip_prologue to find the end of the prologue,
1658 but if some non-prologue instructions get scheduled into the prologue,
1659 and the program is compiled with debug information, the "easy" way
1660 in hppa_skip_prologue will return a prologue end that is too early
1661 for us to notice any potential frame adjustments. */
1663 /* We used to use frame_func_unwind () to locate the beginning of the
1664 function to pass to skip_prologue (). However, when objects are
1665 compiled without debug symbols, frame_func_unwind can return the wrong
1666 function (or 0). We can do better than that by using unwind records. */
1668 prologue_end
= skip_prologue_hard_way (u
->region_start
, 0);
1669 end_pc
= frame_pc_unwind (next_frame
);
1671 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1672 end_pc
= prologue_end
;
1676 for (pc
= u
->region_start
;
1677 ((saved_gr_mask
|| saved_fr_mask
1678 || looking_for_sp
|| looking_for_rp
1679 || frame_size
< (u
->Total_frame_size
<< 3))
1687 if (!safe_frame_unwind_memory (next_frame
, pc
, buf4
,
1690 error ("Cannot read instruction at 0x%s\n", paddr_nz (pc
));
1691 return (*this_cache
);
1694 inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1696 /* Note the interesting effects of this instruction. */
1697 frame_size
+= prologue_inst_adjust_sp (inst
);
1699 /* There are limited ways to store the return pointer into the
1701 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1704 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1706 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1709 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1711 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1714 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1717 /* Check to see if we saved SP into the stack. This also
1718 happens to indicate the location of the saved frame
1720 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1721 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1724 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1726 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1731 /* Account for general and floating-point register saves. */
1732 reg
= inst_saves_gr (inst
);
1733 if (reg
>= 3 && reg
<= 18
1734 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1736 saved_gr_mask
&= ~(1 << reg
);
1737 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1738 /* stwm with a positive displacement is a _post_
1740 cache
->saved_regs
[reg
].addr
= 0;
1741 else if ((inst
& 0xfc00000c) == 0x70000008)
1742 /* A std has explicit post_modify forms. */
1743 cache
->saved_regs
[reg
].addr
= 0;
1748 if ((inst
>> 26) == 0x1c)
1749 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1750 else if ((inst
>> 26) == 0x03)
1751 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1753 offset
= hppa_extract_14 (inst
);
1755 /* Handle code with and without frame pointers. */
1757 cache
->saved_regs
[reg
].addr
= offset
;
1759 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1763 /* GCC handles callee saved FP regs a little differently.
1765 It emits an instruction to put the value of the start of
1766 the FP store area into %r1. It then uses fstds,ma with a
1767 basereg of %r1 for the stores.
1769 HP CC emits them at the current stack pointer modifying the
1770 stack pointer as it stores each register. */
1772 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1773 if ((inst
& 0xffffc000) == 0x34610000
1774 || (inst
& 0xffffc000) == 0x37c10000)
1775 fp_loc
= hppa_extract_14 (inst
);
1777 reg
= inst_saves_fr (inst
);
1778 if (reg
>= 12 && reg
<= 21)
1780 /* Note +4 braindamage below is necessary because the FP
1781 status registers are internally 8 registers rather than
1782 the expected 4 registers. */
1783 saved_fr_mask
&= ~(1 << reg
);
1786 /* 1st HP CC FP register store. After this
1787 instruction we've set enough state that the GCC and
1788 HPCC code are both handled in the same manner. */
1789 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
1794 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
1799 /* Quit if we hit any kind of branch the previous iteration. */
1800 if (final_iteration
)
1802 /* We want to look precisely one instruction beyond the branch
1803 if we have not found everything yet. */
1804 if (is_branch (inst
))
1805 final_iteration
= 1;
1810 /* The frame base always represents the value of %sp at entry to
1811 the current function (and is thus equivalent to the "saved"
1813 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1817 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
1818 "prologue_end=0x%s) ",
1820 paddr_nz (frame_pc_unwind (next_frame
)),
1821 paddr_nz (prologue_end
));
1823 /* Check to see if a frame pointer is available, and use it for
1824 frame unwinding if it is.
1826 There are some situations where we need to rely on the frame
1827 pointer to do stack unwinding. For example, if a function calls
1828 alloca (), the stack pointer can get adjusted inside the body of
1829 the function. In this case, the ABI requires that the compiler
1830 maintain a frame pointer for the function.
1832 The unwind record has a flag (alloca_frame) that indicates that
1833 a function has a variable frame; unfortunately, gcc/binutils
1834 does not set this flag. Instead, whenever a frame pointer is used
1835 and saved on the stack, the Save_SP flag is set. We use this to
1836 decide whether to use the frame pointer for unwinding.
1838 TODO: For the HP compiler, maybe we should use the alloca_frame flag
1839 instead of Save_SP. */
1841 fp
= frame_unwind_register_unsigned (next_frame
, HPPA_FP_REGNUM
);
1843 if (frame_pc_unwind (next_frame
) >= prologue_end
1844 && u
->Save_SP
&& fp
!= 0)
1849 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer] }",
1850 paddr_nz (cache
->base
));
1853 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
1855 /* Both we're expecting the SP to be saved and the SP has been
1856 saved. The entry SP value is saved at this frame's SP
1858 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
1861 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved] }",
1862 paddr_nz (cache
->base
));
1866 /* The prologue has been slowly allocating stack space. Adjust
1868 cache
->base
= this_sp
- frame_size
;
1870 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust] } ",
1871 paddr_nz (cache
->base
));
1874 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
1877 /* The PC is found in the "return register", "Millicode" uses "r31"
1878 as the return register while normal code uses "rp". */
1881 if (trad_frame_addr_p (cache
->saved_regs
, 31))
1882 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
1885 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
1886 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
1891 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
1892 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
1895 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
1896 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
1900 /* If Save_SP is set, then we expect the frame pointer to be saved in the
1901 frame. However, there is a one-insn window where we haven't saved it
1902 yet, but we've already clobbered it. Detect this case and fix it up.
1904 The prologue sequence for frame-pointer functions is:
1905 0: stw %rp, -20(%sp)
1908 c: stw,ma %r1, XX(%sp)
1910 So if we are at offset c, the r3 value that we want is not yet saved
1911 on the stack, but it's been overwritten. The prologue analyzer will
1912 set fp_in_r1 when it sees the copy insn so we know to get the value
1914 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
1917 ULONGEST r1
= frame_unwind_register_unsigned (next_frame
, 1);
1918 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
1922 /* Convert all the offsets into addresses. */
1924 for (reg
= 0; reg
< NUM_REGS
; reg
++)
1926 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
1927 cache
->saved_regs
[reg
].addr
+= cache
->base
;
1932 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
1933 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1934 return (*this_cache
);
1938 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1939 struct frame_id
*this_id
)
1941 struct hppa_frame_cache
*info
;
1942 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1943 struct unwind_table_entry
*u
;
1945 info
= hppa_frame_cache (next_frame
, this_cache
);
1946 u
= find_unwind_entry (pc
);
1948 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
1952 hppa_frame_prev_register (struct frame_info
*next_frame
,
1954 int regnum
, int *optimizedp
,
1955 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1956 int *realnump
, void *valuep
)
1958 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1959 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
1960 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
1963 static const struct frame_unwind hppa_frame_unwind
=
1967 hppa_frame_prev_register
1970 static const struct frame_unwind
*
1971 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
1973 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1975 if (find_unwind_entry (pc
))
1976 return &hppa_frame_unwind
;
1981 /* This is a generic fallback frame unwinder that kicks in if we fail all
1982 the other ones. Normally we would expect the stub and regular unwinder
1983 to work, but in some cases we might hit a function that just doesn't
1984 have any unwind information available. In this case we try to do
1985 unwinding solely based on code reading. This is obviously going to be
1986 slow, so only use this as a last resort. Currently this will only
1987 identify the stack and pc for the frame. */
1989 static struct hppa_frame_cache
*
1990 hppa_fallback_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1992 struct hppa_frame_cache
*cache
;
1993 unsigned int frame_size
;
1995 CORE_ADDR pc
, start_pc
, end_pc
, cur_pc
;
1998 fprintf_unfiltered (gdb_stdlog
, "{ hppa_fallback_frame_cache (frame=%d)-> ",
1999 frame_relative_level(next_frame
));
2001 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2002 (*this_cache
) = cache
;
2003 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2005 pc
= frame_func_unwind (next_frame
);
2006 cur_pc
= frame_pc_unwind (next_frame
);
2010 find_pc_partial_function (pc
, NULL
, &start_pc
, &end_pc
);
2012 if (start_pc
== 0 || end_pc
== 0)
2014 error ("Cannot find bounds of current function (@0x%s), unwinding will "
2015 "fail.", paddr_nz (pc
));
2019 if (end_pc
> cur_pc
)
2022 for (pc
= start_pc
; pc
< end_pc
; pc
+= 4)
2026 insn
= read_memory_unsigned_integer (pc
, 4);
2028 frame_size
+= prologue_inst_adjust_sp (insn
);
2030 /* There are limited ways to store the return pointer into the
2032 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2034 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2037 else if (insn
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
2039 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2045 fprintf_unfiltered (gdb_stdlog
, " frame_size = %d, found_rp = %d }\n",
2046 frame_size
, found_rp
);
2048 cache
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
) - frame_size
;
2049 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2051 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2053 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2054 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
2058 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2059 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2066 hppa_fallback_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2067 struct frame_id
*this_id
)
2069 struct hppa_frame_cache
*info
=
2070 hppa_fallback_frame_cache (next_frame
, this_cache
);
2071 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2075 hppa_fallback_frame_prev_register (struct frame_info
*next_frame
,
2077 int regnum
, int *optimizedp
,
2078 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2079 int *realnump
, void *valuep
)
2081 struct hppa_frame_cache
*info
=
2082 hppa_fallback_frame_cache (next_frame
, this_cache
);
2083 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2084 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2087 static const struct frame_unwind hppa_fallback_frame_unwind
=
2090 hppa_fallback_frame_this_id
,
2091 hppa_fallback_frame_prev_register
2094 static const struct frame_unwind
*
2095 hppa_fallback_unwind_sniffer (struct frame_info
*next_frame
)
2097 return &hppa_fallback_frame_unwind
;
2100 /* Stub frames, used for all kinds of call stubs. */
2101 struct hppa_stub_unwind_cache
2104 struct trad_frame_saved_reg
*saved_regs
;
2107 static struct hppa_stub_unwind_cache
*
2108 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
2111 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2112 struct hppa_stub_unwind_cache
*info
;
2113 struct unwind_table_entry
*u
;
2118 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2120 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2122 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2124 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2126 /* HPUX uses export stubs in function calls; the export stub clobbers
2127 the return value of the caller, and, later restores it from the
2129 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
2131 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2133 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2139 /* By default we assume that stubs do not change the rp. */
2140 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2146 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
2147 void **this_prologue_cache
,
2148 struct frame_id
*this_id
)
2150 struct hppa_stub_unwind_cache
*info
2151 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2152 *this_id
= frame_id_build (info
->base
, frame_pc_unwind (next_frame
));
2156 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
2157 void **this_prologue_cache
,
2158 int regnum
, int *optimizedp
,
2159 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2160 int *realnump
, void *valuep
)
2162 struct hppa_stub_unwind_cache
*info
2163 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2164 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2165 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2168 static const struct frame_unwind hppa_stub_frame_unwind
= {
2170 hppa_stub_frame_this_id
,
2171 hppa_stub_frame_prev_register
2174 static const struct frame_unwind
*
2175 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
2177 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2178 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2179 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2182 || (tdep
->in_solib_call_trampoline
!= NULL
2183 && tdep
->in_solib_call_trampoline (pc
, NULL
))
2184 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
2185 return &hppa_stub_frame_unwind
;
2189 static struct frame_id
2190 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2192 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2194 frame_pc_unwind (next_frame
));
2198 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2203 ipsw
= frame_unwind_register_signed (next_frame
, HPPA_IPSW_REGNUM
);
2204 pc
= frame_unwind_register_signed (next_frame
, HPPA_PCOQ_HEAD_REGNUM
) & ~3;
2206 /* If the current instruction is nullified, then we are effectively
2207 still executing the previous instruction. Pretend we are still
2208 there. This is needed when single stepping; if the nullified instruction
2209 is on a different line, we don't want gdb to think we've stepped onto
2211 if (ipsw
& 0x00200000)
2217 /* Instead of this nasty cast, add a method pvoid() that prints out a
2218 host VOID data type (remember %p isn't portable). */
2221 hppa_pointer_to_address_hack (void *ptr
)
2223 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2224 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2228 unwind_command (char *exp
, int from_tty
)
2231 struct unwind_table_entry
*u
;
2233 /* If we have an expression, evaluate it and use it as the address. */
2235 if (exp
!= 0 && *exp
!= 0)
2236 address
= parse_and_eval_address (exp
);
2240 u
= find_unwind_entry (address
);
2244 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2248 printf_unfiltered ("unwind_table_entry (0x%s):\n",
2249 paddr_nz (hppa_pointer_to_address_hack (u
)));
2251 printf_unfiltered ("\tregion_start = ");
2252 print_address (u
->region_start
, gdb_stdout
);
2253 gdb_flush (gdb_stdout
);
2255 printf_unfiltered ("\n\tregion_end = ");
2256 print_address (u
->region_end
, gdb_stdout
);
2257 gdb_flush (gdb_stdout
);
2259 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2261 printf_unfiltered ("\n\tflags =");
2262 pif (Cannot_unwind
);
2264 pif (Millicode_save_sr0
);
2267 pif (Variable_Frame
);
2268 pif (Separate_Package_Body
);
2269 pif (Frame_Extension_Millicode
);
2270 pif (Stack_Overflow_Check
);
2271 pif (Two_Instruction_SP_Increment
);
2275 pif (Save_MRP_in_frame
);
2276 pif (extn_ptr_defined
);
2277 pif (Cleanup_defined
);
2278 pif (MPE_XL_interrupt_marker
);
2279 pif (HP_UX_interrupt_marker
);
2282 putchar_unfiltered ('\n');
2284 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2286 pin (Region_description
);
2289 pin (Total_frame_size
);
2293 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2295 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2297 An example of this occurs when an a.out is linked against a foo.sl.
2298 The foo.sl defines a global bar(), and the a.out declares a signature
2299 for bar(). However, the a.out doesn't directly call bar(), but passes
2300 its address in another call.
2302 If you have this scenario and attempt to "break bar" before running,
2303 gdb will find a minimal symbol for bar() in the a.out. But that
2304 symbol's address will be negative. What this appears to denote is
2305 an index backwards from the base of the procedure linkage table (PLT)
2306 into the data linkage table (DLT), the end of which is contiguous
2307 with the start of the PLT. This is clearly not a valid address for
2308 us to set a breakpoint on.
2310 Note that one must be careful in how one checks for a negative address.
2311 0xc0000000 is a legitimate address of something in a shared text
2312 segment, for example. Since I don't know what the possible range
2313 is of these "really, truly negative" addresses that come from the
2314 minimal symbols, I'm resorting to the gross hack of checking the
2315 top byte of the address for all 1's. Sigh. */
2317 return (!target_has_stack
&& (pc
& 0xFF000000));
2320 /* Return the GDB type object for the "standard" data type of data
2323 static struct type
*
2324 hppa32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2326 if (reg_nr
< HPPA_FP4_REGNUM
)
2327 return builtin_type_uint32
;
2329 return builtin_type_ieee_single_big
;
2332 /* Return the GDB type object for the "standard" data type of data
2333 in register N. hppa64 version. */
2335 static struct type
*
2336 hppa64_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2338 if (reg_nr
< HPPA_FP4_REGNUM
)
2339 return builtin_type_uint64
;
2341 return builtin_type_ieee_double_big
;
2344 /* Return True if REGNUM is not a register available to the user
2345 through ptrace(). */
2348 hppa_cannot_store_register (int regnum
)
2351 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2352 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2353 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2358 hppa_smash_text_address (CORE_ADDR addr
)
2360 /* The low two bits of the PC on the PA contain the privilege level.
2361 Some genius implementing a (non-GCC) compiler apparently decided
2362 this means that "addresses" in a text section therefore include a
2363 privilege level, and thus symbol tables should contain these bits.
2364 This seems like a bonehead thing to do--anyway, it seems to work
2365 for our purposes to just ignore those bits. */
2367 return (addr
&= ~0x3);
2370 /* Get the ith function argument for the current function. */
2372 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2376 get_frame_register (frame
, HPPA_R0_REGNUM
+ 26 - argi
, &addr
);
2381 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2382 int regnum
, void *buf
)
2386 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2387 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2389 store_unsigned_integer (buf
, sizeof(tmp
), tmp
);
2393 hppa_find_global_pointer (struct value
*function
)
2399 hppa_frame_prev_register_helper (struct frame_info
*next_frame
,
2400 struct trad_frame_saved_reg saved_regs
[],
2401 int regnum
, int *optimizedp
,
2402 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2403 int *realnump
, void *valuep
)
2405 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2411 trad_frame_get_prev_register (next_frame
, saved_regs
,
2412 HPPA_PCOQ_HEAD_REGNUM
, optimizedp
,
2413 lvalp
, addrp
, realnump
, valuep
);
2415 pc
= extract_unsigned_integer (valuep
, 4);
2416 store_unsigned_integer (valuep
, 4, pc
+ 4);
2419 /* It's a computed value. */
2427 trad_frame_get_prev_register (next_frame
, saved_regs
, regnum
,
2428 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2432 /* Here is a table of C type sizes on hppa with various compiles
2433 and options. I measured this on PA 9000/800 with HP-UX 11.11
2434 and these compilers:
2436 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2437 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2438 /opt/aCC/bin/aCC B3910B A.03.45
2439 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2441 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2442 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2443 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2444 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2445 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2446 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2447 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2448 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2452 compiler and options
2453 char, short, int, long, long long
2454 float, double, long double
2457 So all these compilers use either ILP32 or LP64 model.
2458 TODO: gcc has more options so it needs more investigation.
2460 For floating point types, see:
2462 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2463 HP-UX floating-point guide, hpux 11.00
2465 -- chastain 2003-12-18 */
2467 static struct gdbarch
*
2468 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2470 struct gdbarch_tdep
*tdep
;
2471 struct gdbarch
*gdbarch
;
2473 /* Try to determine the ABI of the object we are loading. */
2474 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2476 /* If it's a SOM file, assume it's HP/UX SOM. */
2477 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2478 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2481 /* find a candidate among the list of pre-declared architectures. */
2482 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2484 return (arches
->gdbarch
);
2486 /* If none found, then allocate and initialize one. */
2487 tdep
= XZALLOC (struct gdbarch_tdep
);
2488 gdbarch
= gdbarch_alloc (&info
, tdep
);
2490 /* Determine from the bfd_arch_info structure if we are dealing with
2491 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2492 then default to a 32bit machine. */
2493 if (info
.bfd_arch_info
!= NULL
)
2494 tdep
->bytes_per_address
=
2495 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
2497 tdep
->bytes_per_address
= 4;
2499 tdep
->find_global_pointer
= hppa_find_global_pointer
;
2501 /* Some parts of the gdbarch vector depend on whether we are running
2502 on a 32 bits or 64 bits target. */
2503 switch (tdep
->bytes_per_address
)
2506 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
2507 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
2508 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
2511 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
2512 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
2513 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
2516 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
2517 tdep
->bytes_per_address
);
2520 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2521 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2523 /* The following gdbarch vector elements are the same in both ILP32
2524 and LP64, but might show differences some day. */
2525 set_gdbarch_long_long_bit (gdbarch
, 64);
2526 set_gdbarch_long_double_bit (gdbarch
, 128);
2527 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
2529 /* The following gdbarch vector elements do not depend on the address
2530 size, or in any other gdbarch element previously set. */
2531 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
2532 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
2533 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
2534 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
2535 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
2536 set_gdbarch_cannot_fetch_register (gdbarch
, hppa_cannot_store_register
);
2537 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
2538 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
2539 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
2540 set_gdbarch_read_pc (gdbarch
, hppa_target_read_pc
);
2541 set_gdbarch_write_pc (gdbarch
, hppa_target_write_pc
);
2543 /* Helper for function argument information. */
2544 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
2546 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
2548 /* When a hardware watchpoint triggers, we'll move the inferior past
2549 it by removing all eventpoints; stepping past the instruction
2550 that caused the trigger; reinserting eventpoints; and checking
2551 whether any watched location changed. */
2552 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
2554 /* Inferior function call methods. */
2555 switch (tdep
->bytes_per_address
)
2558 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
2559 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
2560 set_gdbarch_convert_from_func_ptr_addr
2561 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
2564 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
2565 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
2568 internal_error (__FILE__
, __LINE__
, "bad switch");
2571 /* Struct return methods. */
2572 switch (tdep
->bytes_per_address
)
2575 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
2578 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
2581 internal_error (__FILE__
, __LINE__
, "bad switch");
2584 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
2585 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
2587 /* Frame unwind methods. */
2588 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
2589 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
2591 /* Hook in ABI-specific overrides, if they have been registered. */
2592 gdbarch_init_osabi (info
, gdbarch
);
2594 /* Hook in the default unwinders. */
2595 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
2596 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
2597 frame_unwind_append_sniffer (gdbarch
, hppa_fallback_unwind_sniffer
);
2603 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2605 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2607 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
2608 tdep
->bytes_per_address
);
2609 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
2613 _initialize_hppa_tdep (void)
2615 struct cmd_list_element
*c
;
2617 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
2619 hppa_objfile_priv_data
= register_objfile_data ();
2621 add_cmd ("unwind", class_maintenance
, unwind_command
,
2622 "Print unwind table entry at given address.",
2623 &maintenanceprintlist
);
2625 /* Debug this files internals. */
2626 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, "\
2627 Set whether hppa target specific debugging information should be displayed.", "\
2628 Show whether hppa target specific debugging information is displayed.", "\
2629 This flag controls whether hppa target specific debugging information is\n\
2630 displayed. This information is particularly useful for debugging frame\n\
2631 unwinding problems.", "hppa debug flag is %s.",
2632 NULL
, NULL
, &setdebuglist
, &showdebuglist
);