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. */
33 #include "completer.h"
36 #include "gdb_assert.h"
37 #include "infttrace.h"
38 #include "arch-utils.h"
39 /* For argument passing to the inferior */
43 #include "trad-frame.h"
44 #include "frame-unwind.h"
45 #include "frame-base.h"
48 #include <sys/types.h>
52 #include <sys/param.h>
55 #include <sys/ptrace.h>
56 #include <machine/save_state.h>
58 #ifdef COFF_ENCAPSULATE
59 #include "a.out.encap.h"
63 /*#include <sys/user.h> After a.out.h */
73 #include "hppa-tdep.h"
75 /* Some local constants. */
76 static const int hppa32_num_regs
= 128;
77 static const int hppa64_num_regs
= 96;
79 /* Get at various relevent fields of an instruction word. */
82 #define MASK_14 0x3fff
83 #define MASK_21 0x1fffff
85 /* Define offsets into the call dummy for the _sr4export address.
86 See comments related to CALL_DUMMY for more info. */
87 #define SR4EXPORT_LDIL_OFFSET (INSTRUCTION_SIZE * 12)
88 #define SR4EXPORT_LDO_OFFSET (INSTRUCTION_SIZE * 13)
90 /* To support detection of the pseudo-initial frame
92 #define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
93 #define THREAD_INITIAL_FRAME_SYM_LEN sizeof(THREAD_INITIAL_FRAME_SYMBOL)
95 /* Sizes (in bytes) of the native unwind entries. */
96 #define UNWIND_ENTRY_SIZE 16
97 #define STUB_UNWIND_ENTRY_SIZE 8
99 static int get_field (unsigned word
, int from
, int to
);
101 static int extract_5_load (unsigned int);
103 static unsigned extract_5R_store (unsigned int);
105 static unsigned extract_5r_store (unsigned int);
107 struct unwind_table_entry
*find_unwind_entry (CORE_ADDR
);
109 static int extract_17 (unsigned int);
111 static int extract_21 (unsigned);
113 static int extract_14 (unsigned);
115 static void unwind_command (char *, int);
117 static int low_sign_extend (unsigned int, unsigned int);
119 static int sign_extend (unsigned int, unsigned int);
121 static int hppa_alignof (struct type
*);
123 static int prologue_inst_adjust_sp (unsigned long);
125 static int is_branch (unsigned long);
127 static int inst_saves_gr (unsigned long);
129 static int inst_saves_fr (unsigned long);
131 static int compare_unwind_entries (const void *, const void *);
133 static void read_unwind_info (struct objfile
*);
135 static void internalize_unwinds (struct objfile
*,
136 struct unwind_table_entry
*,
137 asection
*, unsigned int,
138 unsigned int, CORE_ADDR
);
139 static void record_text_segment_lowaddr (bfd
*, asection
*, void *);
140 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
141 following functions static, once we hppa is partially multiarched. */
142 int hppa_reg_struct_has_addr (int gcc_p
, struct type
*type
);
143 CORE_ADDR
hppa_skip_prologue (CORE_ADDR pc
);
144 CORE_ADDR
hppa_skip_trampoline_code (CORE_ADDR pc
);
145 int hppa_in_solib_call_trampoline (CORE_ADDR pc
, char *name
);
146 int hppa_in_solib_return_trampoline (CORE_ADDR pc
, char *name
);
147 int hppa_inner_than (CORE_ADDR lhs
, CORE_ADDR rhs
);
148 int hppa_pc_requires_run_before_use (CORE_ADDR pc
);
149 int hppa_instruction_nullified (void);
150 int hppa_cannot_store_register (int regnum
);
151 CORE_ADDR
hppa_smash_text_address (CORE_ADDR addr
);
152 CORE_ADDR
hppa_target_read_pc (ptid_t ptid
);
153 void hppa_target_write_pc (CORE_ADDR v
, ptid_t ptid
);
157 struct minimal_symbol
*msym
;
158 CORE_ADDR solib_handle
;
159 CORE_ADDR return_val
;
163 static int cover_find_stub_with_shl_get (void *);
165 static int is_pa_2
= 0; /* False */
167 /* This is declared in symtab.c; set to 1 in hp-symtab-read.c */
168 extern int hp_som_som_object_present
;
170 /* In breakpoint.c */
171 extern int exception_catchpoints_are_fragile
;
173 /* Handle 32/64-bit struct return conventions. */
175 static enum return_value_convention
176 hppa32_return_value (struct gdbarch
*gdbarch
,
177 struct type
*type
, struct regcache
*regcache
,
178 void *readbuf
, const void *writebuf
)
180 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
183 regcache_cooked_read_part (regcache
, FP4_REGNUM
, 0,
184 TYPE_LENGTH (type
), readbuf
);
185 if (writebuf
!= NULL
)
186 regcache_cooked_write_part (regcache
, FP4_REGNUM
, 0,
187 TYPE_LENGTH (type
), writebuf
);
188 return RETURN_VALUE_REGISTER_CONVENTION
;
190 if (TYPE_LENGTH (type
) <= 2 * 4)
192 /* The value always lives in the right hand end of the register
193 (or register pair)? */
196 int part
= TYPE_LENGTH (type
) % 4;
197 /* The left hand register contains only part of the value,
198 transfer that first so that the rest can be xfered as entire
203 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
205 if (writebuf
!= NULL
)
206 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
210 /* Now transfer the remaining register values. */
211 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
214 regcache_cooked_read (regcache
, reg
, (char *) readbuf
+ b
);
215 if (writebuf
!= NULL
)
216 regcache_cooked_write (regcache
, reg
, (const char *) writebuf
+ b
);
219 return RETURN_VALUE_REGISTER_CONVENTION
;
222 return RETURN_VALUE_STRUCT_CONVENTION
;
225 static enum return_value_convention
226 hppa64_return_value (struct gdbarch
*gdbarch
,
227 struct type
*type
, struct regcache
*regcache
,
228 void *readbuf
, const void *writebuf
)
230 /* RM: Floats are returned in FR4R, doubles in FR4. Integral values
231 are in r28, padded on the left. Aggregates less that 65 bits are
232 in r28, right padded. Aggregates upto 128 bits are in r28 and
233 r29, right padded. */
234 if (TYPE_CODE (type
) == TYPE_CODE_FLT
235 && TYPE_LENGTH (type
) <= 8)
237 /* Floats are right aligned? */
238 int offset
= register_size (gdbarch
, FP4_REGNUM
) - TYPE_LENGTH (type
);
240 regcache_cooked_read_part (regcache
, FP4_REGNUM
, offset
,
241 TYPE_LENGTH (type
), readbuf
);
242 if (writebuf
!= NULL
)
243 regcache_cooked_write_part (regcache
, FP4_REGNUM
, offset
,
244 TYPE_LENGTH (type
), writebuf
);
245 return RETURN_VALUE_REGISTER_CONVENTION
;
247 else if (TYPE_LENGTH (type
) <= 8 && is_integral_type (type
))
249 /* Integrals are right aligned. */
250 int offset
= register_size (gdbarch
, FP4_REGNUM
) - TYPE_LENGTH (type
);
252 regcache_cooked_read_part (regcache
, 28, offset
,
253 TYPE_LENGTH (type
), readbuf
);
254 if (writebuf
!= NULL
)
255 regcache_cooked_write_part (regcache
, 28, offset
,
256 TYPE_LENGTH (type
), writebuf
);
257 return RETURN_VALUE_REGISTER_CONVENTION
;
259 else if (TYPE_LENGTH (type
) <= 2 * 8)
261 /* Composite values are left aligned. */
263 for (b
= 0; b
< TYPE_LENGTH (type
); b
+= 8)
265 int part
= min (8, TYPE_LENGTH (type
) - b
);
267 regcache_cooked_read_part (regcache
, 28 + b
/ 8, 0, part
,
268 (char *) readbuf
+ b
);
269 if (writebuf
!= NULL
)
270 regcache_cooked_write_part (regcache
, 28 + b
/ 8, 0, part
,
271 (const char *) writebuf
+ b
);
273 return RETURN_VALUE_REGISTER_CONVENTION
;
276 return RETURN_VALUE_STRUCT_CONVENTION
;
279 /* Routines to extract various sized constants out of hppa
282 /* This assumes that no garbage lies outside of the lower bits of
286 sign_extend (unsigned val
, unsigned bits
)
288 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
291 /* For many immediate values the sign bit is the low bit! */
294 low_sign_extend (unsigned val
, unsigned bits
)
296 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
299 /* Extract the bits at positions between FROM and TO, using HP's numbering
303 get_field (unsigned word
, int from
, int to
)
305 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
308 /* extract the immediate field from a ld{bhw}s instruction */
311 extract_5_load (unsigned word
)
313 return low_sign_extend (word
>> 16 & MASK_5
, 5);
316 /* extract the immediate field from a break instruction */
319 extract_5r_store (unsigned word
)
321 return (word
& MASK_5
);
324 /* extract the immediate field from a {sr}sm instruction */
327 extract_5R_store (unsigned word
)
329 return (word
>> 16 & MASK_5
);
332 /* extract a 14 bit immediate field */
335 extract_14 (unsigned word
)
337 return low_sign_extend (word
& MASK_14
, 14);
340 /* extract a 21 bit constant */
343 extract_21 (unsigned word
)
349 val
= get_field (word
, 20, 20);
351 val
|= get_field (word
, 9, 19);
353 val
|= get_field (word
, 5, 6);
355 val
|= get_field (word
, 0, 4);
357 val
|= get_field (word
, 7, 8);
358 return sign_extend (val
, 21) << 11;
361 /* extract a 17 bit constant from branch instructions, returning the
362 19 bit signed value. */
365 extract_17 (unsigned word
)
367 return sign_extend (get_field (word
, 19, 28) |
368 get_field (word
, 29, 29) << 10 |
369 get_field (word
, 11, 15) << 11 |
370 (word
& 0x1) << 16, 17) << 2;
374 /* Compare the start address for two unwind entries returning 1 if
375 the first address is larger than the second, -1 if the second is
376 larger than the first, and zero if they are equal. */
379 compare_unwind_entries (const void *arg1
, const void *arg2
)
381 const struct unwind_table_entry
*a
= arg1
;
382 const struct unwind_table_entry
*b
= arg2
;
384 if (a
->region_start
> b
->region_start
)
386 else if (a
->region_start
< b
->region_start
)
392 static CORE_ADDR low_text_segment_address
;
395 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *ignored
)
397 if (((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
398 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
399 && section
->vma
< low_text_segment_address
)
400 low_text_segment_address
= section
->vma
;
404 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
405 asection
*section
, unsigned int entries
, unsigned int size
,
406 CORE_ADDR text_offset
)
408 /* We will read the unwind entries into temporary memory, then
409 fill in the actual unwind table. */
414 char *buf
= alloca (size
);
416 low_text_segment_address
= -1;
418 /* If addresses are 64 bits wide, then unwinds are supposed to
419 be segment relative offsets instead of absolute addresses.
421 Note that when loading a shared library (text_offset != 0) the
422 unwinds are already relative to the text_offset that will be
424 if (TARGET_PTR_BIT
== 64 && text_offset
== 0)
426 bfd_map_over_sections (objfile
->obfd
,
427 record_text_segment_lowaddr
, NULL
);
429 /* ?!? Mask off some low bits. Should this instead subtract
430 out the lowest section's filepos or something like that?
431 This looks very hokey to me. */
432 low_text_segment_address
&= ~0xfff;
433 text_offset
+= low_text_segment_address
;
436 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
438 /* Now internalize the information being careful to handle host/target
440 for (i
= 0; i
< entries
; i
++)
442 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
444 table
[i
].region_start
+= text_offset
;
446 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
447 table
[i
].region_end
+= text_offset
;
449 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
451 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
452 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
453 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
454 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
455 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
456 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
457 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
458 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
459 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
460 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
461 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
462 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
463 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
464 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
465 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
466 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
467 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
468 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
469 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
470 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
471 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
472 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
473 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
474 table
[i
].Cleanup_defined
= tmp
& 0x1;
475 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
477 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
478 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
479 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
480 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
481 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
482 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
484 /* Stub unwinds are handled elsewhere. */
485 table
[i
].stub_unwind
.stub_type
= 0;
486 table
[i
].stub_unwind
.padding
= 0;
491 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
492 the object file. This info is used mainly by find_unwind_entry() to find
493 out the stack frame size and frame pointer used by procedures. We put
494 everything on the psymbol obstack in the objfile so that it automatically
495 gets freed when the objfile is destroyed. */
498 read_unwind_info (struct objfile
*objfile
)
500 asection
*unwind_sec
, *stub_unwind_sec
;
501 unsigned unwind_size
, stub_unwind_size
, total_size
;
502 unsigned index
, unwind_entries
;
503 unsigned stub_entries
, total_entries
;
504 CORE_ADDR text_offset
;
505 struct obj_unwind_info
*ui
;
506 obj_private_data_t
*obj_private
;
508 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
509 ui
= (struct obj_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
510 sizeof (struct obj_unwind_info
));
516 /* For reasons unknown the HP PA64 tools generate multiple unwinder
517 sections in a single executable. So we just iterate over every
518 section in the BFD looking for unwinder sections intead of trying
519 to do a lookup with bfd_get_section_by_name.
521 First determine the total size of the unwind tables so that we
522 can allocate memory in a nice big hunk. */
524 for (unwind_sec
= objfile
->obfd
->sections
;
526 unwind_sec
= unwind_sec
->next
)
528 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
529 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
531 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
532 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
534 total_entries
+= unwind_entries
;
538 /* Now compute the size of the stub unwinds. Note the ELF tools do not
539 use stub unwinds at the curren time. */
540 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
544 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
545 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
549 stub_unwind_size
= 0;
553 /* Compute total number of unwind entries and their total size. */
554 total_entries
+= stub_entries
;
555 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
557 /* Allocate memory for the unwind table. */
558 ui
->table
= (struct unwind_table_entry
*)
559 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
560 ui
->last
= total_entries
- 1;
562 /* Now read in each unwind section and internalize the standard unwind
565 for (unwind_sec
= objfile
->obfd
->sections
;
567 unwind_sec
= unwind_sec
->next
)
569 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
570 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
572 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
573 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
575 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
576 unwind_entries
, unwind_size
, text_offset
);
577 index
+= unwind_entries
;
581 /* Now read in and internalize the stub unwind entries. */
582 if (stub_unwind_size
> 0)
585 char *buf
= alloca (stub_unwind_size
);
587 /* Read in the stub unwind entries. */
588 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
589 0, stub_unwind_size
);
591 /* Now convert them into regular unwind entries. */
592 for (i
= 0; i
< stub_entries
; i
++, index
++)
594 /* Clear out the next unwind entry. */
595 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
597 /* Convert offset & size into region_start and region_end.
598 Stuff away the stub type into "reserved" fields. */
599 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
601 ui
->table
[index
].region_start
+= text_offset
;
603 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
606 ui
->table
[index
].region_end
607 = ui
->table
[index
].region_start
+ 4 *
608 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
614 /* Unwind table needs to be kept sorted. */
615 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
616 compare_unwind_entries
);
618 /* Keep a pointer to the unwind information. */
619 if (objfile
->obj_private
== NULL
)
621 obj_private
= (obj_private_data_t
*)
622 obstack_alloc (&objfile
->objfile_obstack
,
623 sizeof (obj_private_data_t
));
624 obj_private
->unwind_info
= NULL
;
625 obj_private
->so_info
= NULL
;
628 objfile
->obj_private
= obj_private
;
630 obj_private
= (obj_private_data_t
*) objfile
->obj_private
;
631 obj_private
->unwind_info
= ui
;
634 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
635 of the objfiles seeking the unwind table entry for this PC. Each objfile
636 contains a sorted list of struct unwind_table_entry. Since we do a binary
637 search of the unwind tables, we depend upon them to be sorted. */
639 struct unwind_table_entry
*
640 find_unwind_entry (CORE_ADDR pc
)
642 int first
, middle
, last
;
643 struct objfile
*objfile
;
645 /* A function at address 0? Not in HP-UX! */
646 if (pc
== (CORE_ADDR
) 0)
649 ALL_OBJFILES (objfile
)
651 struct obj_unwind_info
*ui
;
653 if (objfile
->obj_private
)
654 ui
= ((obj_private_data_t
*) (objfile
->obj_private
))->unwind_info
;
658 read_unwind_info (objfile
);
659 if (objfile
->obj_private
== NULL
)
660 error ("Internal error reading unwind information.");
661 ui
= ((obj_private_data_t
*) (objfile
->obj_private
))->unwind_info
;
664 /* First, check the cache */
667 && pc
>= ui
->cache
->region_start
668 && pc
<= ui
->cache
->region_end
)
671 /* Not in the cache, do a binary search */
676 while (first
<= last
)
678 middle
= (first
+ last
) / 2;
679 if (pc
>= ui
->table
[middle
].region_start
680 && pc
<= ui
->table
[middle
].region_end
)
682 ui
->cache
= &ui
->table
[middle
];
683 return &ui
->table
[middle
];
686 if (pc
< ui
->table
[middle
].region_start
)
691 } /* ALL_OBJFILES() */
695 const unsigned char *
696 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
698 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
699 (*len
) = sizeof (breakpoint
);
703 /* Return the name of a register. */
706 hppa32_register_name (int i
)
708 static char *names
[] = {
709 "flags", "r1", "rp", "r3",
710 "r4", "r5", "r6", "r7",
711 "r8", "r9", "r10", "r11",
712 "r12", "r13", "r14", "r15",
713 "r16", "r17", "r18", "r19",
714 "r20", "r21", "r22", "r23",
715 "r24", "r25", "r26", "dp",
716 "ret0", "ret1", "sp", "r31",
717 "sar", "pcoqh", "pcsqh", "pcoqt",
718 "pcsqt", "eiem", "iir", "isr",
719 "ior", "ipsw", "goto", "sr4",
720 "sr0", "sr1", "sr2", "sr3",
721 "sr5", "sr6", "sr7", "cr0",
722 "cr8", "cr9", "ccr", "cr12",
723 "cr13", "cr24", "cr25", "cr26",
724 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
725 "fpsr", "fpe1", "fpe2", "fpe3",
726 "fpe4", "fpe5", "fpe6", "fpe7",
727 "fr4", "fr4R", "fr5", "fr5R",
728 "fr6", "fr6R", "fr7", "fr7R",
729 "fr8", "fr8R", "fr9", "fr9R",
730 "fr10", "fr10R", "fr11", "fr11R",
731 "fr12", "fr12R", "fr13", "fr13R",
732 "fr14", "fr14R", "fr15", "fr15R",
733 "fr16", "fr16R", "fr17", "fr17R",
734 "fr18", "fr18R", "fr19", "fr19R",
735 "fr20", "fr20R", "fr21", "fr21R",
736 "fr22", "fr22R", "fr23", "fr23R",
737 "fr24", "fr24R", "fr25", "fr25R",
738 "fr26", "fr26R", "fr27", "fr27R",
739 "fr28", "fr28R", "fr29", "fr29R",
740 "fr30", "fr30R", "fr31", "fr31R"
742 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
749 hppa64_register_name (int i
)
751 static char *names
[] = {
752 "flags", "r1", "rp", "r3",
753 "r4", "r5", "r6", "r7",
754 "r8", "r9", "r10", "r11",
755 "r12", "r13", "r14", "r15",
756 "r16", "r17", "r18", "r19",
757 "r20", "r21", "r22", "r23",
758 "r24", "r25", "r26", "dp",
759 "ret0", "ret1", "sp", "r31",
760 "sar", "pcoqh", "pcsqh", "pcoqt",
761 "pcsqt", "eiem", "iir", "isr",
762 "ior", "ipsw", "goto", "sr4",
763 "sr0", "sr1", "sr2", "sr3",
764 "sr5", "sr6", "sr7", "cr0",
765 "cr8", "cr9", "ccr", "cr12",
766 "cr13", "cr24", "cr25", "cr26",
767 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
768 "fpsr", "fpe1", "fpe2", "fpe3",
769 "fr4", "fr5", "fr6", "fr7",
770 "fr8", "fr9", "fr10", "fr11",
771 "fr12", "fr13", "fr14", "fr15",
772 "fr16", "fr17", "fr18", "fr19",
773 "fr20", "fr21", "fr22", "fr23",
774 "fr24", "fr25", "fr26", "fr27",
775 "fr28", "fr29", "fr30", "fr31"
777 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
785 /* Return the adjustment necessary to make for addresses on the stack
786 as presented by hpread.c.
788 This is necessary because of the stack direction on the PA and the
789 bizarre way in which someone (?) decided they wanted to handle
790 frame pointerless code in GDB. */
792 hpread_adjust_stack_address (CORE_ADDR func_addr
)
794 struct unwind_table_entry
*u
;
796 u
= find_unwind_entry (func_addr
);
800 return u
->Total_frame_size
<< 3;
803 /* This function pushes a stack frame with arguments as part of the
804 inferior function calling mechanism.
806 This is the version of the function for the 32-bit PA machines, in
807 which later arguments appear at lower addresses. (The stack always
808 grows towards higher addresses.)
810 We simply allocate the appropriate amount of stack space and put
811 arguments into their proper slots. */
814 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
815 struct regcache
*regcache
, CORE_ADDR bp_addr
,
816 int nargs
, struct value
**args
, CORE_ADDR sp
,
817 int struct_return
, CORE_ADDR struct_addr
)
819 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
820 reverse engineering testsuite failures. */
822 /* Stack base address at which any pass-by-reference parameters are
824 CORE_ADDR struct_end
= 0;
825 /* Stack base address at which the first parameter is stored. */
826 CORE_ADDR param_end
= 0;
828 /* The inner most end of the stack after all the parameters have
830 CORE_ADDR new_sp
= 0;
832 /* Two passes. First pass computes the location of everything,
833 second pass writes the bytes out. */
835 for (write_pass
= 0; write_pass
< 2; write_pass
++)
837 CORE_ADDR struct_ptr
= 0;
838 CORE_ADDR param_ptr
= 0;
839 int reg
= 27; /* NOTE: Registers go down. */
841 for (i
= 0; i
< nargs
; i
++)
843 struct value
*arg
= args
[i
];
844 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
845 /* The corresponding parameter that is pushed onto the
846 stack, and [possibly] passed in a register. */
849 memset (param_val
, 0, sizeof param_val
);
850 if (TYPE_LENGTH (type
) > 8)
852 /* Large parameter, pass by reference. Store the value
853 in "struct" area and then pass its address. */
855 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
857 write_memory (struct_end
- struct_ptr
, VALUE_CONTENTS (arg
),
859 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
861 else if (TYPE_CODE (type
) == TYPE_CODE_INT
862 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
864 /* Integer value store, right aligned. "unpack_long"
865 takes care of any sign-extension problems. */
866 param_len
= align_up (TYPE_LENGTH (type
), 4);
867 store_unsigned_integer (param_val
, param_len
,
869 VALUE_CONTENTS (arg
)));
873 /* Small struct value, store right aligned? */
874 param_len
= align_up (TYPE_LENGTH (type
), 4);
875 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
876 VALUE_CONTENTS (arg
), TYPE_LENGTH (type
));
878 param_ptr
+= param_len
;
879 reg
-= param_len
/ 4;
882 write_memory (param_end
- param_ptr
, param_val
, param_len
);
885 regcache_cooked_write (regcache
, reg
, param_val
);
887 regcache_cooked_write (regcache
, reg
+ 1, param_val
+ 4);
892 /* Update the various stack pointers. */
895 struct_end
= sp
+ struct_ptr
;
896 /* PARAM_PTR already accounts for all the arguments passed
897 by the user. However, the ABI mandates minimum stack
898 space allocations for outgoing arguments. The ABI also
899 mandates minimum stack alignments which we must
901 param_end
= struct_end
+ max (align_up (param_ptr
, 8),
902 REG_PARM_STACK_SPACE
);
906 /* If a structure has to be returned, set up register 28 to hold its
909 write_register (28, struct_addr
);
911 /* Set the return address. */
912 regcache_cooked_write_unsigned (regcache
, RP_REGNUM
, bp_addr
);
914 /* Update the Stack Pointer. */
915 regcache_cooked_write_unsigned (regcache
, SP_REGNUM
, param_end
+ 32);
917 /* The stack will have 32 bytes of additional space for a frame marker. */
918 return param_end
+ 32;
921 /* This function pushes a stack frame with arguments as part of the
922 inferior function calling mechanism.
924 This is the version for the PA64, in which later arguments appear
925 at higher addresses. (The stack always grows towards higher
928 We simply allocate the appropriate amount of stack space and put
929 arguments into their proper slots.
931 This ABI also requires that the caller provide an argument pointer
932 to the callee, so we do that too. */
935 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
936 struct regcache
*regcache
, CORE_ADDR bp_addr
,
937 int nargs
, struct value
**args
, CORE_ADDR sp
,
938 int struct_return
, CORE_ADDR struct_addr
)
940 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
941 reverse engineering testsuite failures. */
943 /* Stack base address at which any pass-by-reference parameters are
945 CORE_ADDR struct_end
= 0;
946 /* Stack base address at which the first parameter is stored. */
947 CORE_ADDR param_end
= 0;
949 /* The inner most end of the stack after all the parameters have
951 CORE_ADDR new_sp
= 0;
953 /* Two passes. First pass computes the location of everything,
954 second pass writes the bytes out. */
956 for (write_pass
= 0; write_pass
< 2; write_pass
++)
958 CORE_ADDR struct_ptr
= 0;
959 CORE_ADDR param_ptr
= 0;
961 for (i
= 0; i
< nargs
; i
++)
963 struct value
*arg
= args
[i
];
964 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
965 if ((TYPE_CODE (type
) == TYPE_CODE_INT
966 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
967 && TYPE_LENGTH (type
) <= 8)
969 /* Integer value store, right aligned. "unpack_long"
970 takes care of any sign-extension problems. */
974 ULONGEST val
= unpack_long (type
, VALUE_CONTENTS (arg
));
975 int reg
= 27 - param_ptr
/ 8;
976 write_memory_unsigned_integer (param_end
- param_ptr
,
979 regcache_cooked_write_unsigned (regcache
, reg
, val
);
984 /* Small struct value, store left aligned? */
986 if (TYPE_LENGTH (type
) > 8)
988 param_ptr
= align_up (param_ptr
, 16);
989 reg
= 26 - param_ptr
/ 8;
990 param_ptr
+= align_up (TYPE_LENGTH (type
), 16);
994 param_ptr
= align_up (param_ptr
, 8);
995 reg
= 26 - param_ptr
/ 8;
996 param_ptr
+= align_up (TYPE_LENGTH (type
), 8);
1001 write_memory (param_end
- param_ptr
, VALUE_CONTENTS (arg
),
1002 TYPE_LENGTH (type
));
1003 for (byte
= 0; byte
< TYPE_LENGTH (type
); byte
+= 8)
1007 int len
= min (8, TYPE_LENGTH (type
) - byte
);
1008 regcache_cooked_write_part (regcache
, reg
, 0, len
,
1009 VALUE_CONTENTS (arg
) + byte
);
1016 /* Update the various stack pointers. */
1019 struct_end
= sp
+ struct_ptr
;
1020 /* PARAM_PTR already accounts for all the arguments passed
1021 by the user. However, the ABI mandates minimum stack
1022 space allocations for outgoing arguments. The ABI also
1023 mandates minimum stack alignments which we must
1025 param_end
= struct_end
+ max (align_up (param_ptr
, 16),
1026 REG_PARM_STACK_SPACE
);
1030 /* If a structure has to be returned, set up register 28 to hold its
1033 write_register (28, struct_addr
);
1035 /* Set the return address. */
1036 regcache_cooked_write_unsigned (regcache
, RP_REGNUM
, bp_addr
);
1038 /* Update the Stack Pointer. */
1039 regcache_cooked_write_unsigned (regcache
, SP_REGNUM
, param_end
+ 64);
1041 /* The stack will have 32 bytes of additional space for a frame marker. */
1042 return param_end
+ 64;
1046 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1048 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1050 return align_up (addr
, 64);
1053 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1056 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1058 /* Just always 16-byte align. */
1059 return align_up (addr
, 16);
1063 /* elz: Used to lookup a symbol in the shared libraries.
1064 This function calls shl_findsym, indirectly through a
1065 call to __d_shl_get. __d_shl_get is in end.c, which is always
1066 linked in by the hp compilers/linkers.
1067 The call to shl_findsym cannot be made directly because it needs
1068 to be active in target address space.
1069 inputs: - minimal symbol pointer for the function we want to look up
1070 - address in target space of the descriptor for the library
1071 where we want to look the symbol up.
1072 This address is retrieved using the
1073 som_solib_get_solib_by_pc function (somsolib.c).
1074 output: - real address in the library of the function.
1075 note: the handle can be null, in which case shl_findsym will look for
1076 the symbol in all the loaded shared libraries.
1077 files to look at if you need reference on this stuff:
1078 dld.c, dld_shl_findsym.c
1080 man entry for shl_findsym */
1083 find_stub_with_shl_get (struct minimal_symbol
*function
, CORE_ADDR handle
)
1085 struct symbol
*get_sym
, *symbol2
;
1086 struct minimal_symbol
*buff_minsym
, *msymbol
;
1088 struct value
**args
;
1089 struct value
*funcval
;
1092 int x
, namelen
, err_value
, tmp
= -1;
1093 CORE_ADDR endo_buff_addr
, value_return_addr
, errno_return_addr
;
1094 CORE_ADDR stub_addr
;
1097 args
= alloca (sizeof (struct value
*) * 8); /* 6 for the arguments and one null one??? */
1098 funcval
= find_function_in_inferior ("__d_shl_get");
1099 get_sym
= lookup_symbol ("__d_shl_get", NULL
, VAR_DOMAIN
, NULL
, NULL
);
1100 buff_minsym
= lookup_minimal_symbol ("__buffer", NULL
, NULL
);
1101 msymbol
= lookup_minimal_symbol ("__shldp", NULL
, NULL
);
1102 symbol2
= lookup_symbol ("__shldp", NULL
, VAR_DOMAIN
, NULL
, NULL
);
1103 endo_buff_addr
= SYMBOL_VALUE_ADDRESS (buff_minsym
);
1104 namelen
= strlen (DEPRECATED_SYMBOL_NAME (function
));
1105 value_return_addr
= endo_buff_addr
+ namelen
;
1106 ftype
= check_typedef (SYMBOL_TYPE (get_sym
));
1109 if ((x
= value_return_addr
% 64) != 0)
1110 value_return_addr
= value_return_addr
+ 64 - x
;
1112 errno_return_addr
= value_return_addr
+ 64;
1115 /* set up stuff needed by __d_shl_get in buffer in end.o */
1117 target_write_memory (endo_buff_addr
, DEPRECATED_SYMBOL_NAME (function
), namelen
);
1119 target_write_memory (value_return_addr
, (char *) &tmp
, 4);
1121 target_write_memory (errno_return_addr
, (char *) &tmp
, 4);
1123 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol
),
1124 (char *) &handle
, 4);
1126 /* now prepare the arguments for the call */
1128 args
[0] = value_from_longest (TYPE_FIELD_TYPE (ftype
, 0), 12);
1129 args
[1] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 1), SYMBOL_VALUE_ADDRESS (msymbol
));
1130 args
[2] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 2), endo_buff_addr
);
1131 args
[3] = value_from_longest (TYPE_FIELD_TYPE (ftype
, 3), TYPE_PROCEDURE
);
1132 args
[4] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 4), value_return_addr
);
1133 args
[5] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 5), errno_return_addr
);
1135 /* now call the function */
1137 val
= call_function_by_hand (funcval
, 6, args
);
1139 /* now get the results */
1141 target_read_memory (errno_return_addr
, (char *) &err_value
, sizeof (err_value
));
1143 target_read_memory (value_return_addr
, (char *) &stub_addr
, sizeof (stub_addr
));
1145 error ("call to __d_shl_get failed, error code is %d", err_value
);
1150 /* Cover routine for find_stub_with_shl_get to pass to catch_errors */
1152 cover_find_stub_with_shl_get (void *args_untyped
)
1154 args_for_find_stub
*args
= args_untyped
;
1155 args
->return_val
= find_stub_with_shl_get (args
->msym
, args
->solib_handle
);
1159 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1163 hppa_target_read_pc (ptid_t ptid
)
1165 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
1167 /* The following test does not belong here. It is OS-specific, and belongs
1169 /* Test SS_INSYSCALL */
1171 return read_register_pid (31, ptid
) & ~0x3;
1173 return read_register_pid (PCOQ_HEAD_REGNUM
, ptid
) & ~0x3;
1176 /* Write out the PC. If currently in a syscall, then also write the new
1177 PC value into %r31. */
1180 hppa_target_write_pc (CORE_ADDR v
, ptid_t ptid
)
1182 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
1184 /* The following test does not belong here. It is OS-specific, and belongs
1186 /* If in a syscall, then set %r31. Also make sure to get the
1187 privilege bits set correctly. */
1188 /* Test SS_INSYSCALL */
1190 write_register_pid (31, v
| 0x3, ptid
);
1192 write_register_pid (PCOQ_HEAD_REGNUM
, v
, ptid
);
1193 write_register_pid (PCOQ_TAIL_REGNUM
, v
+ 4, ptid
);
1196 /* return the alignment of a type in bytes. Structures have the maximum
1197 alignment required by their fields. */
1200 hppa_alignof (struct type
*type
)
1202 int max_align
, align
, i
;
1203 CHECK_TYPEDEF (type
);
1204 switch (TYPE_CODE (type
))
1209 return TYPE_LENGTH (type
);
1210 case TYPE_CODE_ARRAY
:
1211 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1212 case TYPE_CODE_STRUCT
:
1213 case TYPE_CODE_UNION
:
1215 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1217 /* Bit fields have no real alignment. */
1218 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1219 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1221 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1222 max_align
= max (max_align
, align
);
1231 /* Return one if PC is in the call path of a trampoline, else return zero.
1233 Note we return one for *any* call trampoline (long-call, arg-reloc), not
1234 just shared library trampolines (import, export). */
1237 hppa_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
1239 struct minimal_symbol
*minsym
;
1240 struct unwind_table_entry
*u
;
1241 static CORE_ADDR dyncall
= 0;
1242 static CORE_ADDR sr4export
= 0;
1244 #ifdef GDB_TARGET_IS_HPPA_20W
1245 /* PA64 has a completely different stub/trampoline scheme. Is it
1246 better? Maybe. It's certainly harder to determine with any
1247 certainty that we are in a stub because we can not refer to the
1250 The heuristic is simple. Try to lookup the current PC value in th
1251 minimal symbol table. If that fails, then assume we are not in a
1254 Then see if the PC value falls within the section bounds for the
1255 section containing the minimal symbol we found in the first
1256 step. If it does, then assume we are not in a stub and return.
1258 Finally peek at the instructions to see if they look like a stub. */
1260 struct minimal_symbol
*minsym
;
1265 minsym
= lookup_minimal_symbol_by_pc (pc
);
1269 sec
= SYMBOL_BFD_SECTION (minsym
);
1271 if (bfd_get_section_vma (sec
->owner
, sec
) <= pc
1272 && pc
< (bfd_get_section_vma (sec
->owner
, sec
)
1273 + bfd_section_size (sec
->owner
, sec
)))
1276 /* We might be in a stub. Peek at the instructions. Stubs are 3
1277 instructions long. */
1278 insn
= read_memory_integer (pc
, 4);
1280 /* Find out where we think we are within the stub. */
1281 if ((insn
& 0xffffc00e) == 0x53610000)
1283 else if ((insn
& 0xffffffff) == 0xe820d000)
1285 else if ((insn
& 0xffffc00e) == 0x537b0000)
1290 /* Now verify each insn in the range looks like a stub instruction. */
1291 insn
= read_memory_integer (addr
, 4);
1292 if ((insn
& 0xffffc00e) != 0x53610000)
1295 /* Now verify each insn in the range looks like a stub instruction. */
1296 insn
= read_memory_integer (addr
+ 4, 4);
1297 if ((insn
& 0xffffffff) != 0xe820d000)
1300 /* Now verify each insn in the range looks like a stub instruction. */
1301 insn
= read_memory_integer (addr
+ 8, 4);
1302 if ((insn
& 0xffffc00e) != 0x537b0000)
1305 /* Looks like a stub. */
1310 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
1313 /* First see if PC is in one of the two C-library trampolines. */
1316 minsym
= lookup_minimal_symbol ("$$dyncall", NULL
, NULL
);
1318 dyncall
= SYMBOL_VALUE_ADDRESS (minsym
);
1325 minsym
= lookup_minimal_symbol ("_sr4export", NULL
, NULL
);
1327 sr4export
= SYMBOL_VALUE_ADDRESS (minsym
);
1332 if (pc
== dyncall
|| pc
== sr4export
)
1335 minsym
= lookup_minimal_symbol_by_pc (pc
);
1336 if (minsym
&& strcmp (DEPRECATED_SYMBOL_NAME (minsym
), ".stub") == 0)
1339 /* Get the unwind descriptor corresponding to PC, return zero
1340 if no unwind was found. */
1341 u
= find_unwind_entry (pc
);
1345 /* If this isn't a linker stub, then return now. */
1346 if (u
->stub_unwind
.stub_type
== 0)
1349 /* By definition a long-branch stub is a call stub. */
1350 if (u
->stub_unwind
.stub_type
== LONG_BRANCH
)
1353 /* The call and return path execute the same instructions within
1354 an IMPORT stub! So an IMPORT stub is both a call and return
1356 if (u
->stub_unwind
.stub_type
== IMPORT
)
1359 /* Parameter relocation stubs always have a call path and may have a
1361 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
1362 || u
->stub_unwind
.stub_type
== EXPORT
)
1366 /* Search forward from the current PC until we hit a branch
1367 or the end of the stub. */
1368 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
1372 insn
= read_memory_integer (addr
, 4);
1374 /* Does it look like a bl? If so then it's the call path, if
1375 we find a bv or be first, then we're on the return path. */
1376 if ((insn
& 0xfc00e000) == 0xe8000000)
1378 else if ((insn
& 0xfc00e001) == 0xe800c000
1379 || (insn
& 0xfc000000) == 0xe0000000)
1383 /* Should never happen. */
1384 warning ("Unable to find branch in parameter relocation stub.\n");
1388 /* Unknown stub type. For now, just return zero. */
1392 /* Return one if PC is in the return path of a trampoline, else return zero.
1394 Note we return one for *any* call trampoline (long-call, arg-reloc), not
1395 just shared library trampolines (import, export). */
1398 hppa_in_solib_return_trampoline (CORE_ADDR pc
, char *name
)
1400 struct unwind_table_entry
*u
;
1402 /* Get the unwind descriptor corresponding to PC, return zero
1403 if no unwind was found. */
1404 u
= find_unwind_entry (pc
);
1408 /* If this isn't a linker stub or it's just a long branch stub, then
1410 if (u
->stub_unwind
.stub_type
== 0 || u
->stub_unwind
.stub_type
== LONG_BRANCH
)
1413 /* The call and return path execute the same instructions within
1414 an IMPORT stub! So an IMPORT stub is both a call and return
1416 if (u
->stub_unwind
.stub_type
== IMPORT
)
1419 /* Parameter relocation stubs always have a call path and may have a
1421 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
1422 || u
->stub_unwind
.stub_type
== EXPORT
)
1426 /* Search forward from the current PC until we hit a branch
1427 or the end of the stub. */
1428 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
1432 insn
= read_memory_integer (addr
, 4);
1434 /* Does it look like a bl? If so then it's the call path, if
1435 we find a bv or be first, then we're on the return path. */
1436 if ((insn
& 0xfc00e000) == 0xe8000000)
1438 else if ((insn
& 0xfc00e001) == 0xe800c000
1439 || (insn
& 0xfc000000) == 0xe0000000)
1443 /* Should never happen. */
1444 warning ("Unable to find branch in parameter relocation stub.\n");
1448 /* Unknown stub type. For now, just return zero. */
1453 /* Figure out if PC is in a trampoline, and if so find out where
1454 the trampoline will jump to. If not in a trampoline, return zero.
1456 Simple code examination probably is not a good idea since the code
1457 sequences in trampolines can also appear in user code.
1459 We use unwinds and information from the minimal symbol table to
1460 determine when we're in a trampoline. This won't work for ELF
1461 (yet) since it doesn't create stub unwind entries. Whether or
1462 not ELF will create stub unwinds or normal unwinds for linker
1463 stubs is still being debated.
1465 This should handle simple calls through dyncall or sr4export,
1466 long calls, argument relocation stubs, and dyncall/sr4export
1467 calling an argument relocation stub. It even handles some stubs
1468 used in dynamic executables. */
1471 hppa_skip_trampoline_code (CORE_ADDR pc
)
1474 long prev_inst
, curr_inst
, loc
;
1475 static CORE_ADDR dyncall
= 0;
1476 static CORE_ADDR dyncall_external
= 0;
1477 static CORE_ADDR sr4export
= 0;
1478 struct minimal_symbol
*msym
;
1479 struct unwind_table_entry
*u
;
1481 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
1486 msym
= lookup_minimal_symbol ("$$dyncall", NULL
, NULL
);
1488 dyncall
= SYMBOL_VALUE_ADDRESS (msym
);
1493 if (!dyncall_external
)
1495 msym
= lookup_minimal_symbol ("$$dyncall_external", NULL
, NULL
);
1497 dyncall_external
= SYMBOL_VALUE_ADDRESS (msym
);
1499 dyncall_external
= -1;
1504 msym
= lookup_minimal_symbol ("_sr4export", NULL
, NULL
);
1506 sr4export
= SYMBOL_VALUE_ADDRESS (msym
);
1511 /* Addresses passed to dyncall may *NOT* be the actual address
1512 of the function. So we may have to do something special. */
1515 pc
= (CORE_ADDR
) read_register (22);
1517 /* If bit 30 (counting from the left) is on, then pc is the address of
1518 the PLT entry for this function, not the address of the function
1519 itself. Bit 31 has meaning too, but only for MPE. */
1521 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
1523 if (pc
== dyncall_external
)
1525 pc
= (CORE_ADDR
) read_register (22);
1526 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
1528 else if (pc
== sr4export
)
1529 pc
= (CORE_ADDR
) (read_register (22));
1531 /* Get the unwind descriptor corresponding to PC, return zero
1532 if no unwind was found. */
1533 u
= find_unwind_entry (pc
);
1537 /* If this isn't a linker stub, then return now. */
1538 /* elz: attention here! (FIXME) because of a compiler/linker
1539 error, some stubs which should have a non zero stub_unwind.stub_type
1540 have unfortunately a value of zero. So this function would return here
1541 as if we were not in a trampoline. To fix this, we go look at the partial
1542 symbol information, which reports this guy as a stub.
1543 (FIXME): Unfortunately, we are not that lucky: it turns out that the
1544 partial symbol information is also wrong sometimes. This is because
1545 when it is entered (somread.c::som_symtab_read()) it can happen that
1546 if the type of the symbol (from the som) is Entry, and the symbol is
1547 in a shared library, then it can also be a trampoline. This would
1548 be OK, except that I believe the way they decide if we are ina shared library
1549 does not work. SOOOO..., even if we have a regular function w/o trampolines
1550 its minimal symbol can be assigned type mst_solib_trampoline.
1551 Also, if we find that the symbol is a real stub, then we fix the unwind
1552 descriptor, and define the stub type to be EXPORT.
1553 Hopefully this is correct most of the times. */
1554 if (u
->stub_unwind
.stub_type
== 0)
1557 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
1558 we can delete all the code which appears between the lines */
1559 /*--------------------------------------------------------------------------*/
1560 msym
= lookup_minimal_symbol_by_pc (pc
);
1562 if (msym
== NULL
|| MSYMBOL_TYPE (msym
) != mst_solib_trampoline
)
1563 return orig_pc
== pc
? 0 : pc
& ~0x3;
1565 else if (msym
!= NULL
&& MSYMBOL_TYPE (msym
) == mst_solib_trampoline
)
1567 struct objfile
*objfile
;
1568 struct minimal_symbol
*msymbol
;
1569 int function_found
= 0;
1571 /* go look if there is another minimal symbol with the same name as
1572 this one, but with type mst_text. This would happen if the msym
1573 is an actual trampoline, in which case there would be another
1574 symbol with the same name corresponding to the real function */
1576 ALL_MSYMBOLS (objfile
, msymbol
)
1578 if (MSYMBOL_TYPE (msymbol
) == mst_text
1579 && DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (msymbol
), DEPRECATED_SYMBOL_NAME (msym
)))
1587 /* the type of msym is correct (mst_solib_trampoline), but
1588 the unwind info is wrong, so set it to the correct value */
1589 u
->stub_unwind
.stub_type
= EXPORT
;
1591 /* the stub type info in the unwind is correct (this is not a
1592 trampoline), but the msym type information is wrong, it
1593 should be mst_text. So we need to fix the msym, and also
1594 get out of this function */
1596 MSYMBOL_TYPE (msym
) = mst_text
;
1597 return orig_pc
== pc
? 0 : pc
& ~0x3;
1601 /*--------------------------------------------------------------------------*/
1604 /* It's a stub. Search for a branch and figure out where it goes.
1605 Note we have to handle multi insn branch sequences like ldil;ble.
1606 Most (all?) other branches can be determined by examining the contents
1607 of certain registers and the stack. */
1614 /* Make sure we haven't walked outside the range of this stub. */
1615 if (u
!= find_unwind_entry (loc
))
1617 warning ("Unable to find branch in linker stub");
1618 return orig_pc
== pc
? 0 : pc
& ~0x3;
1621 prev_inst
= curr_inst
;
1622 curr_inst
= read_memory_integer (loc
, 4);
1624 /* Does it look like a branch external using %r1? Then it's the
1625 branch from the stub to the actual function. */
1626 if ((curr_inst
& 0xffe0e000) == 0xe0202000)
1628 /* Yup. See if the previous instruction loaded
1629 a value into %r1. If so compute and return the jump address. */
1630 if ((prev_inst
& 0xffe00000) == 0x20200000)
1631 return (extract_21 (prev_inst
) + extract_17 (curr_inst
)) & ~0x3;
1634 warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
1635 return orig_pc
== pc
? 0 : pc
& ~0x3;
1639 /* Does it look like a be 0(sr0,%r21)? OR
1640 Does it look like a be, n 0(sr0,%r21)? OR
1641 Does it look like a bve (r21)? (this is on PA2.0)
1642 Does it look like a bve, n(r21)? (this is also on PA2.0)
1643 That's the branch from an
1644 import stub to an export stub.
1646 It is impossible to determine the target of the branch via
1647 simple examination of instructions and/or data (consider
1648 that the address in the plabel may be the address of the
1649 bind-on-reference routine in the dynamic loader).
1651 So we have try an alternative approach.
1653 Get the name of the symbol at our current location; it should
1654 be a stub symbol with the same name as the symbol in the
1657 Then lookup a minimal symbol with the same name; we should
1658 get the minimal symbol for the target routine in the shared
1659 library as those take precedence of import/export stubs. */
1660 if ((curr_inst
== 0xe2a00000) ||
1661 (curr_inst
== 0xe2a00002) ||
1662 (curr_inst
== 0xeaa0d000) ||
1663 (curr_inst
== 0xeaa0d002))
1665 struct minimal_symbol
*stubsym
, *libsym
;
1667 stubsym
= lookup_minimal_symbol_by_pc (loc
);
1668 if (stubsym
== NULL
)
1670 warning ("Unable to find symbol for 0x%lx", loc
);
1671 return orig_pc
== pc
? 0 : pc
& ~0x3;
1674 libsym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym
), NULL
, NULL
);
1677 warning ("Unable to find library symbol for %s\n",
1678 DEPRECATED_SYMBOL_NAME (stubsym
));
1679 return orig_pc
== pc
? 0 : pc
& ~0x3;
1682 return SYMBOL_VALUE (libsym
);
1685 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
1686 branch from the stub to the actual function. */
1688 else if ((curr_inst
& 0xffe0e000) == 0xe8400000
1689 || (curr_inst
& 0xffe0e000) == 0xe8000000
1690 || (curr_inst
& 0xffe0e000) == 0xe800A000)
1691 return (loc
+ extract_17 (curr_inst
) + 8) & ~0x3;
1693 /* Does it look like bv (rp)? Note this depends on the
1694 current stack pointer being the same as the stack
1695 pointer in the stub itself! This is a branch on from the
1696 stub back to the original caller. */
1697 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
1698 else if ((curr_inst
& 0xffe0f000) == 0xe840c000)
1700 /* Yup. See if the previous instruction loaded
1702 if (prev_inst
== 0x4bc23ff1)
1703 return (read_memory_integer
1704 (read_register (HPPA_SP_REGNUM
) - 8, 4)) & ~0x3;
1707 warning ("Unable to find restore of %%rp before bv (%%rp).");
1708 return orig_pc
== pc
? 0 : pc
& ~0x3;
1712 /* elz: added this case to capture the new instruction
1713 at the end of the return part of an export stub used by
1714 the PA2.0: BVE, n (rp) */
1715 else if ((curr_inst
& 0xffe0f000) == 0xe840d000)
1717 return (read_memory_integer
1718 (read_register (HPPA_SP_REGNUM
) - 24, TARGET_PTR_BIT
/ 8)) & ~0x3;
1721 /* What about be,n 0(sr0,%rp)? It's just another way we return to
1722 the original caller from the stub. Used in dynamic executables. */
1723 else if (curr_inst
== 0xe0400002)
1725 /* The value we jump to is sitting in sp - 24. But that's
1726 loaded several instructions before the be instruction.
1727 I guess we could check for the previous instruction being
1728 mtsp %r1,%sr0 if we want to do sanity checking. */
1729 return (read_memory_integer
1730 (read_register (HPPA_SP_REGNUM
) - 24, TARGET_PTR_BIT
/ 8)) & ~0x3;
1733 /* Haven't found the branch yet, but we're still in the stub.
1740 /* For the given instruction (INST), return any adjustment it makes
1741 to the stack pointer or zero for no adjustment.
1743 This only handles instructions commonly found in prologues. */
1746 prologue_inst_adjust_sp (unsigned long inst
)
1748 /* This must persist across calls. */
1749 static int save_high21
;
1751 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1752 if ((inst
& 0xffffc000) == 0x37de0000)
1753 return extract_14 (inst
);
1756 if ((inst
& 0xffe00000) == 0x6fc00000)
1757 return extract_14 (inst
);
1759 /* std,ma X,D(sp) */
1760 if ((inst
& 0xffe00008) == 0x73c00008)
1761 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1763 /* addil high21,%r1; ldo low11,(%r1),%r30)
1764 save high bits in save_high21 for later use. */
1765 if ((inst
& 0xffe00000) == 0x28200000)
1767 save_high21
= extract_21 (inst
);
1771 if ((inst
& 0xffff0000) == 0x343e0000)
1772 return save_high21
+ extract_14 (inst
);
1774 /* fstws as used by the HP compilers. */
1775 if ((inst
& 0xffffffe0) == 0x2fd01220)
1776 return extract_5_load (inst
);
1778 /* No adjustment. */
1782 /* Return nonzero if INST is a branch of some kind, else return zero. */
1785 is_branch (unsigned long inst
)
1814 /* Return the register number for a GR which is saved by INST or
1815 zero it INST does not save a GR. */
1818 inst_saves_gr (unsigned long inst
)
1820 /* Does it look like a stw? */
1821 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1822 || (inst
>> 26) == 0x1f
1823 || ((inst
>> 26) == 0x1f
1824 && ((inst
>> 6) == 0xa)))
1825 return extract_5R_store (inst
);
1827 /* Does it look like a std? */
1828 if ((inst
>> 26) == 0x1c
1829 || ((inst
>> 26) == 0x03
1830 && ((inst
>> 6) & 0xf) == 0xb))
1831 return extract_5R_store (inst
);
1833 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1834 if ((inst
>> 26) == 0x1b)
1835 return extract_5R_store (inst
);
1837 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1839 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1840 || ((inst
>> 26) == 0x3
1841 && (((inst
>> 6) & 0xf) == 0x8
1842 || (inst
>> 6) & 0xf) == 0x9))
1843 return extract_5R_store (inst
);
1848 /* Return the register number for a FR which is saved by INST or
1849 zero it INST does not save a FR.
1851 Note we only care about full 64bit register stores (that's the only
1852 kind of stores the prologue will use).
1854 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1857 inst_saves_fr (unsigned long inst
)
1859 /* is this an FSTD ? */
1860 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1861 return extract_5r_store (inst
);
1862 if ((inst
& 0xfc000002) == 0x70000002)
1863 return extract_5R_store (inst
);
1864 /* is this an FSTW ? */
1865 if ((inst
& 0xfc00df80) == 0x24001200)
1866 return extract_5r_store (inst
);
1867 if ((inst
& 0xfc000002) == 0x7c000000)
1868 return extract_5R_store (inst
);
1872 /* Advance PC across any function entry prologue instructions
1873 to reach some "real" code.
1875 Use information in the unwind table to determine what exactly should
1876 be in the prologue. */
1880 skip_prologue_hard_way (CORE_ADDR pc
)
1883 CORE_ADDR orig_pc
= pc
;
1884 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1885 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1886 struct unwind_table_entry
*u
;
1892 u
= find_unwind_entry (pc
);
1896 /* If we are not at the beginning of a function, then return now. */
1897 if ((pc
& ~0x3) != u
->region_start
)
1900 /* This is how much of a frame adjustment we need to account for. */
1901 stack_remaining
= u
->Total_frame_size
<< 3;
1903 /* Magic register saves we want to know about. */
1904 save_rp
= u
->Save_RP
;
1905 save_sp
= u
->Save_SP
;
1907 /* An indication that args may be stored into the stack. Unfortunately
1908 the HPUX compilers tend to set this in cases where no args were
1912 /* Turn the Entry_GR field into a bitmask. */
1914 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1916 /* Frame pointer gets saved into a special location. */
1917 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1920 save_gr
|= (1 << i
);
1922 save_gr
&= ~restart_gr
;
1924 /* Turn the Entry_FR field into a bitmask too. */
1926 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1927 save_fr
|= (1 << i
);
1928 save_fr
&= ~restart_fr
;
1930 /* Loop until we find everything of interest or hit a branch.
1932 For unoptimized GCC code and for any HP CC code this will never ever
1933 examine any user instructions.
1935 For optimzied GCC code we're faced with problems. GCC will schedule
1936 its prologue and make prologue instructions available for delay slot
1937 filling. The end result is user code gets mixed in with the prologue
1938 and a prologue instruction may be in the delay slot of the first branch
1941 Some unexpected things are expected with debugging optimized code, so
1942 we allow this routine to walk past user instructions in optimized
1944 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1947 unsigned int reg_num
;
1948 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1949 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1951 /* Save copies of all the triggers so we can compare them later
1953 old_save_gr
= save_gr
;
1954 old_save_fr
= save_fr
;
1955 old_save_rp
= save_rp
;
1956 old_save_sp
= save_sp
;
1957 old_stack_remaining
= stack_remaining
;
1959 status
= target_read_memory (pc
, buf
, 4);
1960 inst
= extract_unsigned_integer (buf
, 4);
1966 /* Note the interesting effects of this instruction. */
1967 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1969 /* There are limited ways to store the return pointer into the
1971 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
1974 /* These are the only ways we save SP into the stack. At this time
1975 the HP compilers never bother to save SP into the stack. */
1976 if ((inst
& 0xffffc000) == 0x6fc10000
1977 || (inst
& 0xffffc00c) == 0x73c10008)
1980 /* Are we loading some register with an offset from the argument
1982 if ((inst
& 0xffe00000) == 0x37a00000
1983 || (inst
& 0xffffffe0) == 0x081d0240)
1989 /* Account for general and floating-point register saves. */
1990 reg_num
= inst_saves_gr (inst
);
1991 save_gr
&= ~(1 << reg_num
);
1993 /* Ugh. Also account for argument stores into the stack.
1994 Unfortunately args_stored only tells us that some arguments
1995 where stored into the stack. Not how many or what kind!
1997 This is a kludge as on the HP compiler sets this bit and it
1998 never does prologue scheduling. So once we see one, skip past
1999 all of them. We have similar code for the fp arg stores below.
2001 FIXME. Can still die if we have a mix of GR and FR argument
2003 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
2005 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
2008 status
= target_read_memory (pc
, buf
, 4);
2009 inst
= extract_unsigned_integer (buf
, 4);
2012 reg_num
= inst_saves_gr (inst
);
2018 reg_num
= inst_saves_fr (inst
);
2019 save_fr
&= ~(1 << reg_num
);
2021 status
= target_read_memory (pc
+ 4, buf
, 4);
2022 next_inst
= extract_unsigned_integer (buf
, 4);
2028 /* We've got to be read to handle the ldo before the fp register
2030 if ((inst
& 0xfc000000) == 0x34000000
2031 && inst_saves_fr (next_inst
) >= 4
2032 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
2034 /* So we drop into the code below in a reasonable state. */
2035 reg_num
= inst_saves_fr (next_inst
);
2039 /* Ugh. Also account for argument stores into the stack.
2040 This is a kludge as on the HP compiler sets this bit and it
2041 never does prologue scheduling. So once we see one, skip past
2043 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
2045 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
2048 status
= target_read_memory (pc
, buf
, 4);
2049 inst
= extract_unsigned_integer (buf
, 4);
2052 if ((inst
& 0xfc000000) != 0x34000000)
2054 status
= target_read_memory (pc
+ 4, buf
, 4);
2055 next_inst
= extract_unsigned_integer (buf
, 4);
2058 reg_num
= inst_saves_fr (next_inst
);
2064 /* Quit if we hit any kind of branch. This can happen if a prologue
2065 instruction is in the delay slot of the first call/branch. */
2066 if (is_branch (inst
))
2069 /* What a crock. The HP compilers set args_stored even if no
2070 arguments were stored into the stack (boo hiss). This could
2071 cause this code to then skip a bunch of user insns (up to the
2074 To combat this we try to identify when args_stored was bogusly
2075 set and clear it. We only do this when args_stored is nonzero,
2076 all other resources are accounted for, and nothing changed on
2079 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
2080 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
2081 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
2082 && old_stack_remaining
== stack_remaining
)
2089 /* We've got a tenative location for the end of the prologue. However
2090 because of limitations in the unwind descriptor mechanism we may
2091 have went too far into user code looking for the save of a register
2092 that does not exist. So, if there registers we expected to be saved
2093 but never were, mask them out and restart.
2095 This should only happen in optimized code, and should be very rare. */
2096 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
2099 restart_gr
= save_gr
;
2100 restart_fr
= save_fr
;
2108 /* Return the address of the PC after the last prologue instruction if
2109 we can determine it from the debug symbols. Else return zero. */
2112 after_prologue (CORE_ADDR pc
)
2114 struct symtab_and_line sal
;
2115 CORE_ADDR func_addr
, func_end
;
2118 /* If we can not find the symbol in the partial symbol table, then
2119 there is no hope we can determine the function's start address
2121 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
2124 /* Get the line associated with FUNC_ADDR. */
2125 sal
= find_pc_line (func_addr
, 0);
2127 /* There are only two cases to consider. First, the end of the source line
2128 is within the function bounds. In that case we return the end of the
2129 source line. Second is the end of the source line extends beyond the
2130 bounds of the current function. We need to use the slow code to
2131 examine instructions in that case.
2133 Anything else is simply a bug elsewhere. Fixing it here is absolutely
2134 the wrong thing to do. In fact, it should be entirely possible for this
2135 function to always return zero since the slow instruction scanning code
2136 is supposed to *always* work. If it does not, then it is a bug. */
2137 if (sal
.end
< func_end
)
2143 /* To skip prologues, I use this predicate. Returns either PC itself
2144 if the code at PC does not look like a function prologue; otherwise
2145 returns an address that (if we're lucky) follows the prologue. If
2146 LENIENT, then we must skip everything which is involved in setting
2147 up the frame (it's OK to skip more, just so long as we don't skip
2148 anything which might clobber the registers which are being saved.
2149 Currently we must not skip more on the alpha, but we might the lenient
2153 hppa_skip_prologue (CORE_ADDR pc
)
2157 CORE_ADDR post_prologue_pc
;
2160 /* See if we can determine the end of the prologue via the symbol table.
2161 If so, then return either PC, or the PC after the prologue, whichever
2164 post_prologue_pc
= after_prologue (pc
);
2166 /* If after_prologue returned a useful address, then use it. Else
2167 fall back on the instruction skipping code.
2169 Some folks have claimed this causes problems because the breakpoint
2170 may be the first instruction of the prologue. If that happens, then
2171 the instruction skipping code has a bug that needs to be fixed. */
2172 if (post_prologue_pc
!= 0)
2173 return max (pc
, post_prologue_pc
);
2175 return (skip_prologue_hard_way (pc
));
2178 struct hppa_frame_cache
2181 struct trad_frame_saved_reg
*saved_regs
;
2184 static struct hppa_frame_cache
*
2185 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
2187 struct hppa_frame_cache
*cache
;
2192 struct unwind_table_entry
*u
;
2195 if ((*this_cache
) != NULL
)
2196 return (*this_cache
);
2197 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2198 (*this_cache
) = cache
;
2199 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2202 u
= find_unwind_entry (frame_func_unwind (next_frame
));
2204 return (*this_cache
);
2206 /* Turn the Entry_GR field into a bitmask. */
2208 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
2210 /* Frame pointer gets saved into a special location. */
2211 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
2214 saved_gr_mask
|= (1 << i
);
2217 /* Turn the Entry_FR field into a bitmask too. */
2219 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
2220 saved_fr_mask
|= (1 << i
);
2222 /* Loop until we find everything of interest or hit a branch.
2224 For unoptimized GCC code and for any HP CC code this will never ever
2225 examine any user instructions.
2227 For optimized GCC code we're faced with problems. GCC will schedule
2228 its prologue and make prologue instructions available for delay slot
2229 filling. The end result is user code gets mixed in with the prologue
2230 and a prologue instruction may be in the delay slot of the first branch
2233 Some unexpected things are expected with debugging optimized code, so
2234 we allow this routine to walk past user instructions in optimized
2237 int final_iteration
= 0;
2239 CORE_ADDR end_pc
= skip_prologue_using_sal (pc
);
2240 int looking_for_sp
= u
->Save_SP
;
2241 int looking_for_rp
= u
->Save_RP
;
2244 end_pc
= frame_pc_unwind (next_frame
);
2246 for (pc
= frame_func_unwind (next_frame
);
2247 ((saved_gr_mask
|| saved_fr_mask
2248 || looking_for_sp
|| looking_for_rp
2249 || frame_size
< (u
->Total_frame_size
<< 3))
2255 long status
= target_read_memory (pc
, buf4
, sizeof buf4
);
2256 long inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
2258 /* Note the interesting effects of this instruction. */
2259 frame_size
+= prologue_inst_adjust_sp (inst
);
2261 /* There are limited ways to store the return pointer into the
2263 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2266 cache
->saved_regs
[RP_REGNUM
].addr
= -20;
2268 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
2271 cache
->saved_regs
[RP_REGNUM
].addr
= -16;
2274 /* Check to see if we saved SP into the stack. This also
2275 happens to indicate the location of the saved frame
2277 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
2278 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2281 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
2284 /* Account for general and floating-point register saves. */
2285 reg
= inst_saves_gr (inst
);
2286 if (reg
>= 3 && reg
<= 18
2287 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
2289 saved_gr_mask
&= ~(1 << reg
);
2290 if ((inst
>> 26) == 0x1b && extract_14 (inst
) >= 0)
2291 /* stwm with a positive displacement is a _post_
2293 cache
->saved_regs
[reg
].addr
= 0;
2294 else if ((inst
& 0xfc00000c) == 0x70000008)
2295 /* A std has explicit post_modify forms. */
2296 cache
->saved_regs
[reg
].addr
= 0;
2301 if ((inst
>> 26) == 0x1c)
2302 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
2303 else if ((inst
>> 26) == 0x03)
2304 offset
= low_sign_extend (inst
& 0x1f, 5);
2306 offset
= extract_14 (inst
);
2308 /* Handle code with and without frame pointers. */
2310 cache
->saved_regs
[reg
].addr
= offset
;
2312 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
2316 /* GCC handles callee saved FP regs a little differently.
2318 It emits an instruction to put the value of the start of
2319 the FP store area into %r1. It then uses fstds,ma with a
2320 basereg of %r1 for the stores.
2322 HP CC emits them at the current stack pointer modifying the
2323 stack pointer as it stores each register. */
2325 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2326 if ((inst
& 0xffffc000) == 0x34610000
2327 || (inst
& 0xffffc000) == 0x37c10000)
2328 fp_loc
= extract_14 (inst
);
2330 reg
= inst_saves_fr (inst
);
2331 if (reg
>= 12 && reg
<= 21)
2333 /* Note +4 braindamage below is necessary because the FP
2334 status registers are internally 8 registers rather than
2335 the expected 4 registers. */
2336 saved_fr_mask
&= ~(1 << reg
);
2339 /* 1st HP CC FP register store. After this
2340 instruction we've set enough state that the GCC and
2341 HPCC code are both handled in the same manner. */
2342 cache
->saved_regs
[reg
+ FP4_REGNUM
+ 4].addr
= 0;
2347 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
2352 /* Quit if we hit any kind of branch the previous iteration. */
2353 if (final_iteration
)
2355 /* We want to look precisely one instruction beyond the branch
2356 if we have not found everything yet. */
2357 if (is_branch (inst
))
2358 final_iteration
= 1;
2363 /* The frame base always represents the value of %sp at entry to
2364 the current function (and is thus equivalent to the "saved"
2366 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2367 /* FIXME: cagney/2004-02-22: This assumes that the frame has been
2368 created. If it hasn't everything will be out-of-wack. */
2369 if (u
->Save_SP
&& trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
2370 /* Both we're expecting the SP to be saved and the SP has been
2371 saved. The entry SP value is saved at this frame's SP
2373 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
2375 /* The prologue has been slowly allocating stack space. Adjust
2377 cache
->base
= this_sp
- frame_size
;
2378 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2381 /* The PC is found in the "return register", "Millicode" uses "r31"
2382 as the return register while normal code uses "rp". */
2384 cache
->saved_regs
[PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
2386 cache
->saved_regs
[PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[RP_REGNUM
];
2389 /* Convert all the offsets into addresses. */
2391 for (reg
= 0; reg
< NUM_REGS
; reg
++)
2393 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
2394 cache
->saved_regs
[reg
].addr
+= cache
->base
;
2398 return (*this_cache
);
2402 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2403 struct frame_id
*this_id
)
2405 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
2406 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2410 hppa_frame_prev_register (struct frame_info
*next_frame
,
2412 int regnum
, int *optimizedp
,
2413 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2414 int *realnump
, void *valuep
)
2416 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
2417 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2418 if (regnum
== PCOQ_TAIL_REGNUM
)
2420 /* The PCOQ TAIL, or NPC, needs to be computed from the unwound
2428 int regsize
= register_size (gdbarch
, PCOQ_HEAD_REGNUM
);
2431 enum lval_type lval
;
2434 bfd_byte value
[MAX_REGISTER_SIZE
];
2435 trad_frame_prev_register (next_frame
, info
->saved_regs
,
2436 PCOQ_HEAD_REGNUM
, &optimized
, &lval
, &addr
,
2438 pc
= extract_unsigned_integer (&value
, regsize
);
2439 store_unsigned_integer (valuep
, regsize
, pc
+ 4);
2444 trad_frame_prev_register (next_frame
, info
->saved_regs
, regnum
,
2445 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2449 static const struct frame_unwind hppa_frame_unwind
=
2453 hppa_frame_prev_register
2456 static const struct frame_unwind
*
2457 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
2459 return &hppa_frame_unwind
;
2463 hppa_frame_base_address (struct frame_info
*next_frame
,
2466 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
,
2471 static const struct frame_base hppa_frame_base
= {
2473 hppa_frame_base_address
,
2474 hppa_frame_base_address
,
2475 hppa_frame_base_address
2478 static const struct frame_base
*
2479 hppa_frame_base_sniffer (struct frame_info
*next_frame
)
2481 return &hppa_frame_base
;
2484 static struct frame_id
2485 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2487 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2489 frame_pc_unwind (next_frame
));
2493 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2495 return frame_unwind_register_signed (next_frame
, PCOQ_HEAD_REGNUM
) & ~3;
2498 /* Exception handling support for the HP-UX ANSI C++ compiler.
2499 The compiler (aCC) provides a callback for exception events;
2500 GDB can set a breakpoint on this callback and find out what
2501 exception event has occurred. */
2503 /* The name of the hook to be set to point to the callback function */
2504 static char HP_ACC_EH_notify_hook
[] = "__eh_notify_hook";
2505 /* The name of the function to be used to set the hook value */
2506 static char HP_ACC_EH_set_hook_value
[] = "__eh_set_hook_value";
2507 /* The name of the callback function in end.o */
2508 static char HP_ACC_EH_notify_callback
[] = "__d_eh_notify_callback";
2509 /* Name of function in end.o on which a break is set (called by above) */
2510 static char HP_ACC_EH_break
[] = "__d_eh_break";
2511 /* Name of flag (in end.o) that enables catching throws */
2512 static char HP_ACC_EH_catch_throw
[] = "__d_eh_catch_throw";
2513 /* Name of flag (in end.o) that enables catching catching */
2514 static char HP_ACC_EH_catch_catch
[] = "__d_eh_catch_catch";
2515 /* The enum used by aCC */
2523 /* Is exception-handling support available with this executable? */
2524 static int hp_cxx_exception_support
= 0;
2525 /* Has the initialize function been run? */
2526 int hp_cxx_exception_support_initialized
= 0;
2527 /* Similar to above, but imported from breakpoint.c -- non-target-specific */
2528 extern int exception_support_initialized
;
2529 /* Address of __eh_notify_hook */
2530 static CORE_ADDR eh_notify_hook_addr
= 0;
2531 /* Address of __d_eh_notify_callback */
2532 static CORE_ADDR eh_notify_callback_addr
= 0;
2533 /* Address of __d_eh_break */
2534 static CORE_ADDR eh_break_addr
= 0;
2535 /* Address of __d_eh_catch_catch */
2536 static CORE_ADDR eh_catch_catch_addr
= 0;
2537 /* Address of __d_eh_catch_throw */
2538 static CORE_ADDR eh_catch_throw_addr
= 0;
2539 /* Sal for __d_eh_break */
2540 static struct symtab_and_line
*break_callback_sal
= 0;
2542 /* Code in end.c expects __d_pid to be set in the inferior,
2543 otherwise __d_eh_notify_callback doesn't bother to call
2544 __d_eh_break! So we poke the pid into this symbol
2549 setup_d_pid_in_inferior (void)
2552 struct minimal_symbol
*msymbol
;
2553 char buf
[4]; /* FIXME 32x64? */
2555 /* Slam the pid of the process into __d_pid; failing is only a warning! */
2556 msymbol
= lookup_minimal_symbol ("__d_pid", NULL
, symfile_objfile
);
2557 if (msymbol
== NULL
)
2559 warning ("Unable to find __d_pid symbol in object file.");
2560 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
2564 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
2565 store_unsigned_integer (buf
, 4, PIDGET (inferior_ptid
)); /* FIXME 32x64? */
2566 if (target_write_memory (anaddr
, buf
, 4)) /* FIXME 32x64? */
2568 warning ("Unable to write __d_pid");
2569 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
2575 /* Initialize exception catchpoint support by looking for the
2576 necessary hooks/callbacks in end.o, etc., and set the hook value to
2577 point to the required debug function
2583 initialize_hp_cxx_exception_support (void)
2585 struct symtabs_and_lines sals
;
2586 struct cleanup
*old_chain
;
2587 struct cleanup
*canonical_strings_chain
= NULL
;
2590 char *addr_end
= NULL
;
2591 char **canonical
= (char **) NULL
;
2593 struct symbol
*sym
= NULL
;
2594 struct minimal_symbol
*msym
= NULL
;
2595 struct objfile
*objfile
;
2596 asection
*shlib_info
;
2598 /* Detect and disallow recursion. On HP-UX with aCC, infinite
2599 recursion is a possibility because finding the hook for exception
2600 callbacks involves making a call in the inferior, which means
2601 re-inserting breakpoints which can re-invoke this code */
2603 static int recurse
= 0;
2606 hp_cxx_exception_support_initialized
= 0;
2607 exception_support_initialized
= 0;
2611 hp_cxx_exception_support
= 0;
2613 /* First check if we have seen any HP compiled objects; if not,
2614 it is very unlikely that HP's idiosyncratic callback mechanism
2615 for exception handling debug support will be available!
2616 This will percolate back up to breakpoint.c, where our callers
2617 will decide to try the g++ exception-handling support instead. */
2618 if (!hp_som_som_object_present
)
2621 /* We have a SOM executable with SOM debug info; find the hooks */
2623 /* First look for the notify hook provided by aCC runtime libs */
2624 /* If we find this symbol, we conclude that the executable must
2625 have HP aCC exception support built in. If this symbol is not
2626 found, even though we're a HP SOM-SOM file, we may have been
2627 built with some other compiler (not aCC). This results percolates
2628 back up to our callers in breakpoint.c which can decide to
2629 try the g++ style of exception support instead.
2630 If this symbol is found but the other symbols we require are
2631 not found, there is something weird going on, and g++ support
2632 should *not* be tried as an alternative.
2634 ASSUMPTION: Only HP aCC code will have __eh_notify_hook defined.
2635 ASSUMPTION: HP aCC and g++ modules cannot be linked together. */
2637 /* libCsup has this hook; it'll usually be non-debuggable */
2638 msym
= lookup_minimal_symbol (HP_ACC_EH_notify_hook
, NULL
, NULL
);
2641 eh_notify_hook_addr
= SYMBOL_VALUE_ADDRESS (msym
);
2642 hp_cxx_exception_support
= 1;
2646 warning ("Unable to find exception callback hook (%s).", HP_ACC_EH_notify_hook
);
2647 warning ("Executable may not have been compiled debuggable with HP aCC.");
2648 warning ("GDB will be unable to intercept exception events.");
2649 eh_notify_hook_addr
= 0;
2650 hp_cxx_exception_support
= 0;
2654 /* Next look for the notify callback routine in end.o */
2655 /* This is always available in the SOM symbol dictionary if end.o is linked in */
2656 msym
= lookup_minimal_symbol (HP_ACC_EH_notify_callback
, NULL
, NULL
);
2659 eh_notify_callback_addr
= SYMBOL_VALUE_ADDRESS (msym
);
2660 hp_cxx_exception_support
= 1;
2664 warning ("Unable to find exception callback routine (%s).", HP_ACC_EH_notify_callback
);
2665 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
2666 warning ("GDB will be unable to intercept exception events.");
2667 eh_notify_callback_addr
= 0;
2671 #ifndef GDB_TARGET_IS_HPPA_20W
2672 /* Check whether the executable is dynamically linked or archive bound */
2673 /* With an archive-bound executable we can use the raw addresses we find
2674 for the callback function, etc. without modification. For an executable
2675 with shared libraries, we have to do more work to find the plabel, which
2676 can be the target of a call through $$dyncall from the aCC runtime support
2677 library (libCsup) which is linked shared by default by aCC. */
2678 /* This test below was copied from somsolib.c/somread.c. It may not be a very
2679 reliable one to test that an executable is linked shared. pai/1997-07-18 */
2680 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
2681 if (shlib_info
&& (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) != 0))
2683 /* The minsym we have has the local code address, but that's not the
2684 plabel that can be used by an inter-load-module call. */
2685 /* Find solib handle for main image (which has end.o), and use that
2686 and the min sym as arguments to __d_shl_get() (which does the equivalent
2687 of shl_findsym()) to find the plabel. */
2689 args_for_find_stub args
;
2690 static char message
[] = "Error while finding exception callback hook:\n";
2692 args
.solib_handle
= som_solib_get_solib_by_pc (eh_notify_callback_addr
);
2694 args
.return_val
= 0;
2697 catch_errors (cover_find_stub_with_shl_get
, &args
, message
,
2699 eh_notify_callback_addr
= args
.return_val
;
2702 exception_catchpoints_are_fragile
= 1;
2704 if (!eh_notify_callback_addr
)
2706 /* We can get here either if there is no plabel in the export list
2707 for the main image, or if something strange happened (?) */
2708 warning ("Couldn't find a plabel (indirect function label) for the exception callback.");
2709 warning ("GDB will not be able to intercept exception events.");
2714 exception_catchpoints_are_fragile
= 0;
2717 /* Now, look for the breakpointable routine in end.o */
2718 /* This should also be available in the SOM symbol dict. if end.o linked in */
2719 msym
= lookup_minimal_symbol (HP_ACC_EH_break
, NULL
, NULL
);
2722 eh_break_addr
= SYMBOL_VALUE_ADDRESS (msym
);
2723 hp_cxx_exception_support
= 1;
2727 warning ("Unable to find exception callback routine to set breakpoint (%s).", HP_ACC_EH_break
);
2728 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
2729 warning ("GDB will be unable to intercept exception events.");
2734 /* Next look for the catch enable flag provided in end.o */
2735 sym
= lookup_symbol (HP_ACC_EH_catch_catch
, (struct block
*) NULL
,
2736 VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
2737 if (sym
) /* sometimes present in debug info */
2739 eh_catch_catch_addr
= SYMBOL_VALUE_ADDRESS (sym
);
2740 hp_cxx_exception_support
= 1;
2743 /* otherwise look in SOM symbol dict. */
2745 msym
= lookup_minimal_symbol (HP_ACC_EH_catch_catch
, NULL
, NULL
);
2748 eh_catch_catch_addr
= SYMBOL_VALUE_ADDRESS (msym
);
2749 hp_cxx_exception_support
= 1;
2753 warning ("Unable to enable interception of exception catches.");
2754 warning ("Executable may not have been compiled debuggable with HP aCC.");
2755 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
2760 /* Next look for the catch enable flag provided end.o */
2761 sym
= lookup_symbol (HP_ACC_EH_catch_catch
, (struct block
*) NULL
,
2762 VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
2763 if (sym
) /* sometimes present in debug info */
2765 eh_catch_throw_addr
= SYMBOL_VALUE_ADDRESS (sym
);
2766 hp_cxx_exception_support
= 1;
2769 /* otherwise look in SOM symbol dict. */
2771 msym
= lookup_minimal_symbol (HP_ACC_EH_catch_throw
, NULL
, NULL
);
2774 eh_catch_throw_addr
= SYMBOL_VALUE_ADDRESS (msym
);
2775 hp_cxx_exception_support
= 1;
2779 warning ("Unable to enable interception of exception throws.");
2780 warning ("Executable may not have been compiled debuggable with HP aCC.");
2781 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
2787 hp_cxx_exception_support
= 2; /* everything worked so far */
2788 hp_cxx_exception_support_initialized
= 1;
2789 exception_support_initialized
= 1;
2794 /* Target operation for enabling or disabling interception of
2796 KIND is either EX_EVENT_THROW or EX_EVENT_CATCH
2797 ENABLE is either 0 (disable) or 1 (enable).
2798 Return value is NULL if no support found;
2799 -1 if something went wrong,
2800 or a pointer to a symtab/line struct if the breakpointable
2801 address was found. */
2803 struct symtab_and_line
*
2804 child_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2808 if (!exception_support_initialized
|| !hp_cxx_exception_support_initialized
)
2809 if (!initialize_hp_cxx_exception_support ())
2812 switch (hp_cxx_exception_support
)
2815 /* Assuming no HP support at all */
2818 /* HP support should be present, but something went wrong */
2819 return (struct symtab_and_line
*) -1; /* yuck! */
2820 /* there may be other cases in the future */
2823 /* Set the EH hook to point to the callback routine */
2824 store_unsigned_integer (buf
, 4, enable
? eh_notify_callback_addr
: 0); /* FIXME 32x64 problem */
2825 /* pai: (temp) FIXME should there be a pack operation first? */
2826 if (target_write_memory (eh_notify_hook_addr
, buf
, 4)) /* FIXME 32x64 problem */
2828 warning ("Could not write to target memory for exception event callback.");
2829 warning ("Interception of exception events may not work.");
2830 return (struct symtab_and_line
*) -1;
2834 /* Ensure that __d_pid is set up correctly -- end.c code checks this. :-( */
2835 if (PIDGET (inferior_ptid
) > 0)
2837 if (setup_d_pid_in_inferior ())
2838 return (struct symtab_and_line
*) -1;
2842 warning ("Internal error: Invalid inferior pid? Cannot intercept exception events.");
2843 return (struct symtab_and_line
*) -1;
2849 case EX_EVENT_THROW
:
2850 store_unsigned_integer (buf
, 4, enable
? 1 : 0);
2851 if (target_write_memory (eh_catch_throw_addr
, buf
, 4)) /* FIXME 32x64? */
2853 warning ("Couldn't enable exception throw interception.");
2854 return (struct symtab_and_line
*) -1;
2857 case EX_EVENT_CATCH
:
2858 store_unsigned_integer (buf
, 4, enable
? 1 : 0);
2859 if (target_write_memory (eh_catch_catch_addr
, buf
, 4)) /* FIXME 32x64? */
2861 warning ("Couldn't enable exception catch interception.");
2862 return (struct symtab_and_line
*) -1;
2866 error ("Request to enable unknown or unsupported exception event.");
2869 /* Copy break address into new sal struct, malloc'ing if needed. */
2870 if (!break_callback_sal
)
2872 break_callback_sal
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
2874 init_sal (break_callback_sal
);
2875 break_callback_sal
->symtab
= NULL
;
2876 break_callback_sal
->pc
= eh_break_addr
;
2877 break_callback_sal
->line
= 0;
2878 break_callback_sal
->end
= eh_break_addr
;
2880 return break_callback_sal
;
2883 /* Record some information about the current exception event */
2884 static struct exception_event_record current_ex_event
;
2885 /* Convenience struct */
2886 static struct symtab_and_line null_symtab_and_line
=
2889 /* Report current exception event. Returns a pointer to a record
2890 that describes the kind of the event, where it was thrown from,
2891 and where it will be caught. More information may be reported
2893 struct exception_event_record
*
2894 child_get_current_exception_event (void)
2896 CORE_ADDR event_kind
;
2897 CORE_ADDR throw_addr
;
2898 CORE_ADDR catch_addr
;
2899 struct frame_info
*fi
, *curr_frame
;
2902 curr_frame
= get_current_frame ();
2904 return (struct exception_event_record
*) NULL
;
2906 /* Go up one frame to __d_eh_notify_callback, because at the
2907 point when this code is executed, there's garbage in the
2908 arguments of __d_eh_break. */
2909 fi
= find_relative_frame (curr_frame
, &level
);
2911 return (struct exception_event_record
*) NULL
;
2915 /* Read in the arguments */
2916 /* __d_eh_notify_callback() is called with 3 arguments:
2917 1. event kind catch or throw
2918 2. the target address if known
2919 3. a flag -- not sure what this is. pai/1997-07-17 */
2920 event_kind
= read_register (ARG0_REGNUM
);
2921 catch_addr
= read_register (ARG1_REGNUM
);
2923 /* Now go down to a user frame */
2924 /* For a throw, __d_eh_break is called by
2925 __d_eh_notify_callback which is called by
2926 __notify_throw which is called
2928 For a catch, __d_eh_break is called by
2929 __d_eh_notify_callback which is called by
2930 <stackwalking stuff> which is called by
2931 __throw__<stuff> or __rethrow_<stuff> which is called
2933 /* FIXME: Don't use such magic numbers; search for the frames */
2934 level
= (event_kind
== EX_EVENT_THROW
) ? 3 : 4;
2935 fi
= find_relative_frame (curr_frame
, &level
);
2937 return (struct exception_event_record
*) NULL
;
2940 throw_addr
= get_frame_pc (fi
);
2942 /* Go back to original (top) frame */
2943 select_frame (curr_frame
);
2945 current_ex_event
.kind
= (enum exception_event_kind
) event_kind
;
2946 current_ex_event
.throw_sal
= find_pc_line (throw_addr
, 1);
2947 current_ex_event
.catch_sal
= find_pc_line (catch_addr
, 1);
2949 return ¤t_ex_event
;
2952 /* Instead of this nasty cast, add a method pvoid() that prints out a
2953 host VOID data type (remember %p isn't portable). */
2956 hppa_pointer_to_address_hack (void *ptr
)
2958 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2959 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2963 unwind_command (char *exp
, int from_tty
)
2966 struct unwind_table_entry
*u
;
2968 /* If we have an expression, evaluate it and use it as the address. */
2970 if (exp
!= 0 && *exp
!= 0)
2971 address
= parse_and_eval_address (exp
);
2975 u
= find_unwind_entry (address
);
2979 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2983 printf_unfiltered ("unwind_table_entry (0x%s):\n",
2984 paddr_nz (hppa_pointer_to_address_hack (u
)));
2986 printf_unfiltered ("\tregion_start = ");
2987 print_address (u
->region_start
, gdb_stdout
);
2989 printf_unfiltered ("\n\tregion_end = ");
2990 print_address (u
->region_end
, gdb_stdout
);
2992 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2994 printf_unfiltered ("\n\tflags =");
2995 pif (Cannot_unwind
);
2997 pif (Millicode_save_sr0
);
3000 pif (Variable_Frame
);
3001 pif (Separate_Package_Body
);
3002 pif (Frame_Extension_Millicode
);
3003 pif (Stack_Overflow_Check
);
3004 pif (Two_Instruction_SP_Increment
);
3008 pif (Save_MRP_in_frame
);
3009 pif (extn_ptr_defined
);
3010 pif (Cleanup_defined
);
3011 pif (MPE_XL_interrupt_marker
);
3012 pif (HP_UX_interrupt_marker
);
3015 putchar_unfiltered ('\n');
3017 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
3019 pin (Region_description
);
3022 pin (Total_frame_size
);
3026 hppa_skip_permanent_breakpoint (void)
3028 /* To step over a breakpoint instruction on the PA takes some
3029 fiddling with the instruction address queue.
3031 When we stop at a breakpoint, the IA queue front (the instruction
3032 we're executing now) points at the breakpoint instruction, and
3033 the IA queue back (the next instruction to execute) points to
3034 whatever instruction we would execute after the breakpoint, if it
3035 were an ordinary instruction. This is the case even if the
3036 breakpoint is in the delay slot of a branch instruction.
3038 Clearly, to step past the breakpoint, we need to set the queue
3039 front to the back. But what do we put in the back? What
3040 instruction comes after that one? Because of the branch delay
3041 slot, the next insn is always at the back + 4. */
3042 write_register (PCOQ_HEAD_REGNUM
, read_register (PCOQ_TAIL_REGNUM
));
3043 write_register (PCSQ_HEAD_REGNUM
, read_register (PCSQ_TAIL_REGNUM
));
3045 write_register (PCOQ_TAIL_REGNUM
, read_register (PCOQ_TAIL_REGNUM
) + 4);
3046 /* We can leave the tail's space the same, since there's no jump. */
3050 hppa_reg_struct_has_addr (int gcc_p
, struct type
*type
)
3052 /* On the PA, any pass-by-value structure > 8 bytes is actually passed
3053 via a pointer regardless of its type or the compiler used. */
3054 return (TYPE_LENGTH (type
) > 8);
3058 hppa_inner_than (CORE_ADDR lhs
, CORE_ADDR rhs
)
3060 /* Stack grows upward */
3065 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
3067 /* Sometimes we may pluck out a minimal symbol that has a negative address.
3069 An example of this occurs when an a.out is linked against a foo.sl.
3070 The foo.sl defines a global bar(), and the a.out declares a signature
3071 for bar(). However, the a.out doesn't directly call bar(), but passes
3072 its address in another call.
3074 If you have this scenario and attempt to "break bar" before running,
3075 gdb will find a minimal symbol for bar() in the a.out. But that
3076 symbol's address will be negative. What this appears to denote is
3077 an index backwards from the base of the procedure linkage table (PLT)
3078 into the data linkage table (DLT), the end of which is contiguous
3079 with the start of the PLT. This is clearly not a valid address for
3080 us to set a breakpoint on.
3082 Note that one must be careful in how one checks for a negative address.
3083 0xc0000000 is a legitimate address of something in a shared text
3084 segment, for example. Since I don't know what the possible range
3085 is of these "really, truly negative" addresses that come from the
3086 minimal symbols, I'm resorting to the gross hack of checking the
3087 top byte of the address for all 1's. Sigh. */
3089 return (!target_has_stack
&& (pc
& 0xFF000000));
3093 hppa_instruction_nullified (void)
3095 /* brobecker 2002/11/07: Couldn't we use a ULONGEST here? It would
3096 avoid the type cast. I'm leaving it as is for now as I'm doing
3097 semi-mechanical multiarching-related changes. */
3098 const int ipsw
= (int) read_register (IPSW_REGNUM
);
3099 const int flags
= (int) read_register (FLAGS_REGNUM
);
3101 return ((ipsw
& 0x00200000) && !(flags
& 0x2));
3104 /* Return the GDB type object for the "standard" data type of data
3107 static struct type
*
3108 hppa32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
3110 if (reg_nr
< FP4_REGNUM
)
3111 return builtin_type_uint32
;
3113 return builtin_type_ieee_single_big
;
3116 /* Return the GDB type object for the "standard" data type of data
3117 in register N. hppa64 version. */
3119 static struct type
*
3120 hppa64_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
3122 if (reg_nr
< FP4_REGNUM
)
3123 return builtin_type_uint64
;
3125 return builtin_type_ieee_double_big
;
3128 /* Return True if REGNUM is not a register available to the user
3129 through ptrace(). */
3132 hppa_cannot_store_register (int regnum
)
3135 || regnum
== PCSQ_HEAD_REGNUM
3136 || (regnum
>= PCSQ_TAIL_REGNUM
&& regnum
< IPSW_REGNUM
)
3137 || (regnum
> IPSW_REGNUM
&& regnum
< FP4_REGNUM
));
3142 hppa_smash_text_address (CORE_ADDR addr
)
3144 /* The low two bits of the PC on the PA contain the privilege level.
3145 Some genius implementing a (non-GCC) compiler apparently decided
3146 this means that "addresses" in a text section therefore include a
3147 privilege level, and thus symbol tables should contain these bits.
3148 This seems like a bonehead thing to do--anyway, it seems to work
3149 for our purposes to just ignore those bits. */
3151 return (addr
&= ~0x3);
3154 /* Get the ith function argument for the current function. */
3156 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
3160 get_frame_register (frame
, R0_REGNUM
+ 26 - argi
, &addr
);
3164 /* Here is a table of C type sizes on hppa with various compiles
3165 and options. I measured this on PA 9000/800 with HP-UX 11.11
3166 and these compilers:
3168 /usr/ccs/bin/cc HP92453-01 A.11.01.21
3169 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
3170 /opt/aCC/bin/aCC B3910B A.03.45
3171 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3173 cc : 1 2 4 4 8 : 4 8 -- : 4 4
3174 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3175 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3176 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3177 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3178 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3179 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3180 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3184 compiler and options
3185 char, short, int, long, long long
3186 float, double, long double
3189 So all these compilers use either ILP32 or LP64 model.
3190 TODO: gcc has more options so it needs more investigation.
3192 For floating point types, see:
3194 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3195 HP-UX floating-point guide, hpux 11.00
3197 -- chastain 2003-12-18 */
3199 static struct gdbarch
*
3200 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3202 struct gdbarch_tdep
*tdep
;
3203 struct gdbarch
*gdbarch
;
3205 /* Try to determine the ABI of the object we are loading. */
3206 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
3208 /* If it's a SOM file, assume it's HP/UX SOM. */
3209 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
3210 info
.osabi
= GDB_OSABI_HPUX_SOM
;
3213 /* find a candidate among the list of pre-declared architectures. */
3214 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3216 return (arches
->gdbarch
);
3218 /* If none found, then allocate and initialize one. */
3219 tdep
= XMALLOC (struct gdbarch_tdep
);
3220 gdbarch
= gdbarch_alloc (&info
, tdep
);
3222 /* Determine from the bfd_arch_info structure if we are dealing with
3223 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3224 then default to a 32bit machine. */
3225 if (info
.bfd_arch_info
!= NULL
)
3226 tdep
->bytes_per_address
=
3227 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
3229 tdep
->bytes_per_address
= 4;
3231 /* Some parts of the gdbarch vector depend on whether we are running
3232 on a 32 bits or 64 bits target. */
3233 switch (tdep
->bytes_per_address
)
3236 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
3237 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
3238 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
3241 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
3242 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
3243 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
3246 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
3247 tdep
->bytes_per_address
);
3250 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3251 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
3253 /* The following gdbarch vector elements are the same in both ILP32
3254 and LP64, but might show differences some day. */
3255 set_gdbarch_long_long_bit (gdbarch
, 64);
3256 set_gdbarch_long_double_bit (gdbarch
, 128);
3257 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
3259 /* The following gdbarch vector elements do not depend on the address
3260 size, or in any other gdbarch element previously set. */
3261 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
3262 set_gdbarch_skip_trampoline_code (gdbarch
, hppa_skip_trampoline_code
);
3263 set_gdbarch_in_solib_call_trampoline (gdbarch
, hppa_in_solib_call_trampoline
);
3264 set_gdbarch_in_solib_return_trampoline (gdbarch
,
3265 hppa_in_solib_return_trampoline
);
3266 set_gdbarch_inner_than (gdbarch
, hppa_inner_than
);
3267 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
3268 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
3269 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
3270 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
3271 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
3272 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3273 set_gdbarch_read_pc (gdbarch
, hppa_target_read_pc
);
3274 set_gdbarch_write_pc (gdbarch
, hppa_target_write_pc
);
3276 /* Helper for function argument information. */
3277 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
3279 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
3281 /* When a hardware watchpoint triggers, we'll move the inferior past
3282 it by removing all eventpoints; stepping past the instruction
3283 that caused the trigger; reinserting eventpoints; and checking
3284 whether any watched location changed. */
3285 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
3287 /* Inferior function call methods. */
3288 switch (tdep
->bytes_per_address
)
3291 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
3292 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
3295 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
3296 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
3299 internal_error (__FILE__
, __LINE__
, "bad switch");
3302 /* Struct return methods. */
3303 switch (tdep
->bytes_per_address
)
3306 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
3309 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
3312 internal_error (__FILE__
, __LINE__
, "bad switch");
3315 /* Frame unwind methods. */
3316 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
3317 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
3318 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
3319 frame_base_append_sniffer (gdbarch
, hppa_frame_base_sniffer
);
3321 /* Hook in ABI-specific overrides, if they have been registered. */
3322 gdbarch_init_osabi (info
, gdbarch
);
3328 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
3330 /* Nothing to print for the moment. */
3334 _initialize_hppa_tdep (void)
3336 struct cmd_list_element
*c
;
3337 void break_at_finish_command (char *arg
, int from_tty
);
3338 void tbreak_at_finish_command (char *arg
, int from_tty
);
3339 void break_at_finish_at_depth_command (char *arg
, int from_tty
);
3341 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
3343 add_cmd ("unwind", class_maintenance
, unwind_command
,
3344 "Print unwind table entry at given address.",
3345 &maintenanceprintlist
);
3347 deprecate_cmd (add_com ("xbreak", class_breakpoint
,
3348 break_at_finish_command
,
3349 concat ("Set breakpoint at procedure exit. \n\
3350 Argument may be function name, or \"*\" and an address.\n\
3351 If function is specified, break at end of code for that function.\n\
3352 If an address is specified, break at the end of the function that contains \n\
3353 that exact address.\n",
3354 "With no arg, uses current execution address of selected stack frame.\n\
3355 This is useful for breaking on return to a stack frame.\n\
3357 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
3359 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
)), NULL
);
3360 deprecate_cmd (add_com_alias ("xb", "xbreak", class_breakpoint
, 1), NULL
);
3361 deprecate_cmd (add_com_alias ("xbr", "xbreak", class_breakpoint
, 1), NULL
);
3362 deprecate_cmd (add_com_alias ("xbre", "xbreak", class_breakpoint
, 1), NULL
);
3363 deprecate_cmd (add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1), NULL
);
3365 deprecate_cmd (c
= add_com ("txbreak", class_breakpoint
,
3366 tbreak_at_finish_command
,
3367 "Set temporary breakpoint at procedure exit. Either there should\n\
3368 be no argument or the argument must be a depth.\n"), NULL
);
3369 set_cmd_completer (c
, location_completer
);
3372 deprecate_cmd (add_com ("bx", class_breakpoint
,
3373 break_at_finish_at_depth_command
,
3374 "Set breakpoint at procedure exit. Either there should\n\
3375 be no argument or the argument must be a depth.\n"), NULL
);