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 static const int hppa64_call_dummy_breakpoint_offset
= 22 * 4;
81 /* DEPRECATED_CALL_DUMMY_LENGTH is computed based on the size of a
82 word on the target machine, not the size of an instruction. Since
83 a word on this target holds two instructions we have to divide the
84 instruction size by two to get the word size of the dummy. */
85 static const int hppa32_call_dummy_length
= INSTRUCTION_SIZE
* 28;
86 static const int hppa64_call_dummy_length
= INSTRUCTION_SIZE
* 26 / 2;
88 /* Get at various relevent fields of an instruction word. */
91 #define MASK_14 0x3fff
92 #define MASK_21 0x1fffff
94 /* Define offsets into the call dummy for the target function address.
95 See comments related to CALL_DUMMY for more info. */
96 #define FUNC_LDIL_OFFSET (INSTRUCTION_SIZE * 9)
97 #define FUNC_LDO_OFFSET (INSTRUCTION_SIZE * 10)
99 /* Define offsets into the call dummy for the _sr4export address.
100 See comments related to CALL_DUMMY for more info. */
101 #define SR4EXPORT_LDIL_OFFSET (INSTRUCTION_SIZE * 12)
102 #define SR4EXPORT_LDO_OFFSET (INSTRUCTION_SIZE * 13)
104 /* To support detection of the pseudo-initial frame
105 that threads have. */
106 #define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
107 #define THREAD_INITIAL_FRAME_SYM_LEN sizeof(THREAD_INITIAL_FRAME_SYMBOL)
109 /* Sizes (in bytes) of the native unwind entries. */
110 #define UNWIND_ENTRY_SIZE 16
111 #define STUB_UNWIND_ENTRY_SIZE 8
113 static int get_field (unsigned word
, int from
, int to
);
115 static int extract_5_load (unsigned int);
117 static unsigned extract_5R_store (unsigned int);
119 static unsigned extract_5r_store (unsigned int);
121 static void hppa_frame_init_saved_regs (struct frame_info
*frame
);
123 static void find_dummy_frame_regs (struct frame_info
*, CORE_ADDR
*);
125 static int find_proc_framesize (CORE_ADDR
);
127 static int find_return_regnum (CORE_ADDR
);
129 struct unwind_table_entry
*find_unwind_entry (CORE_ADDR
);
131 static int extract_17 (unsigned int);
133 static unsigned deposit_21 (unsigned int, unsigned int);
135 static int extract_21 (unsigned);
137 static unsigned deposit_14 (int, unsigned int);
139 static int extract_14 (unsigned);
141 static void unwind_command (char *, int);
143 static int low_sign_extend (unsigned int, unsigned int);
145 static int sign_extend (unsigned int, unsigned int);
147 static int restore_pc_queue (CORE_ADDR
*);
149 static int hppa_alignof (struct type
*);
151 static int prologue_inst_adjust_sp (unsigned long);
153 static int is_branch (unsigned long);
155 static int inst_saves_gr (unsigned long);
157 static int inst_saves_fr (unsigned long);
159 static int pc_in_interrupt_handler (CORE_ADDR
);
161 static int pc_in_linker_stub (CORE_ADDR
);
163 static int compare_unwind_entries (const void *, const void *);
165 static void read_unwind_info (struct objfile
*);
167 static void internalize_unwinds (struct objfile
*,
168 struct unwind_table_entry
*,
169 asection
*, unsigned int,
170 unsigned int, CORE_ADDR
);
171 static void pa_print_registers (char *, int, int);
172 static void pa_strcat_registers (char *, int, int, struct ui_file
*);
173 static void pa_register_look_aside (char *, int, long *);
174 static void pa_print_fp_reg (int);
175 static void pa_strcat_fp_reg (int, struct ui_file
*, enum precision_type
);
176 static void record_text_segment_lowaddr (bfd
*, asection
*, void *);
177 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
178 following functions static, once we hppa is partially multiarched. */
179 int hppa_reg_struct_has_addr (int gcc_p
, struct type
*type
);
180 CORE_ADDR
hppa_skip_prologue (CORE_ADDR pc
);
181 CORE_ADDR
hppa_skip_trampoline_code (CORE_ADDR pc
);
182 int hppa_in_solib_call_trampoline (CORE_ADDR pc
, char *name
);
183 int hppa_in_solib_return_trampoline (CORE_ADDR pc
, char *name
);
184 CORE_ADDR
hppa_saved_pc_after_call (struct frame_info
*frame
);
185 int hppa_inner_than (CORE_ADDR lhs
, CORE_ADDR rhs
);
186 CORE_ADDR
hppa32_stack_align (CORE_ADDR sp
);
187 CORE_ADDR
hppa64_stack_align (CORE_ADDR sp
);
188 int hppa_pc_requires_run_before_use (CORE_ADDR pc
);
189 int hppa_instruction_nullified (void);
190 int hppa_register_raw_size (int reg_nr
);
191 int hppa_register_byte (int reg_nr
);
192 struct type
* hppa32_register_virtual_type (int reg_nr
);
193 struct type
* hppa64_register_virtual_type (int reg_nr
);
194 void hppa_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
);
195 void hppa32_extract_return_value (struct type
*type
, char *regbuf
,
197 void hppa64_extract_return_value (struct type
*type
, char *regbuf
,
199 int hppa32_use_struct_convention (int gcc_p
, struct type
*type
);
200 int hppa64_use_struct_convention (int gcc_p
, struct type
*type
);
201 void hppa32_store_return_value (struct type
*type
, char *valbuf
);
202 void hppa64_store_return_value (struct type
*type
, char *valbuf
);
203 int hppa_cannot_store_register (int regnum
);
204 void hppa_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
);
205 CORE_ADDR
hppa_frame_chain (struct frame_info
*frame
);
206 int hppa_frame_chain_valid (CORE_ADDR chain
, struct frame_info
*thisframe
);
207 int hppa_frameless_function_invocation (struct frame_info
*frame
);
208 CORE_ADDR
hppa_frame_saved_pc (struct frame_info
*frame
);
209 CORE_ADDR
hppa_frame_args_address (struct frame_info
*fi
);
210 int hppa_frame_num_args (struct frame_info
*frame
);
211 void hppa_push_dummy_frame (void);
212 void hppa_pop_frame (void);
213 CORE_ADDR
hppa_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
,
214 int nargs
, struct value
**args
,
215 struct type
*type
, int gcc_p
);
216 CORE_ADDR
hppa_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
217 int struct_return
, CORE_ADDR struct_addr
);
218 CORE_ADDR
hppa_smash_text_address (CORE_ADDR addr
);
219 CORE_ADDR
hppa_target_read_pc (ptid_t ptid
);
220 void hppa_target_write_pc (CORE_ADDR v
, ptid_t ptid
);
221 CORE_ADDR
hppa_target_read_fp (void);
225 struct minimal_symbol
*msym
;
226 CORE_ADDR solib_handle
;
227 CORE_ADDR return_val
;
231 static int cover_find_stub_with_shl_get (void *);
233 static int is_pa_2
= 0; /* False */
235 /* This is declared in symtab.c; set to 1 in hp-symtab-read.c */
236 extern int hp_som_som_object_present
;
238 /* In breakpoint.c */
239 extern int exception_catchpoints_are_fragile
;
241 /* Should call_function allocate stack space for a struct return? */
244 hppa32_use_struct_convention (int gcc_p
, struct type
*type
)
246 return (TYPE_LENGTH (type
) > 2 * DEPRECATED_REGISTER_SIZE
);
249 /* Same as hppa32_use_struct_convention() for the PA64 ABI. */
252 hppa64_use_struct_convention (int gcc_p
, struct type
*type
)
254 /* RM: struct upto 128 bits are returned in registers */
255 return TYPE_LENGTH (type
) > 16;
258 /* Routines to extract various sized constants out of hppa
261 /* This assumes that no garbage lies outside of the lower bits of
265 sign_extend (unsigned val
, unsigned bits
)
267 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
270 /* For many immediate values the sign bit is the low bit! */
273 low_sign_extend (unsigned val
, unsigned bits
)
275 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
278 /* Extract the bits at positions between FROM and TO, using HP's numbering
282 get_field (unsigned word
, int from
, int to
)
284 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
287 /* extract the immediate field from a ld{bhw}s instruction */
290 extract_5_load (unsigned word
)
292 return low_sign_extend (word
>> 16 & MASK_5
, 5);
295 /* extract the immediate field from a break instruction */
298 extract_5r_store (unsigned word
)
300 return (word
& MASK_5
);
303 /* extract the immediate field from a {sr}sm instruction */
306 extract_5R_store (unsigned word
)
308 return (word
>> 16 & MASK_5
);
311 /* extract a 14 bit immediate field */
314 extract_14 (unsigned word
)
316 return low_sign_extend (word
& MASK_14
, 14);
319 /* deposit a 14 bit constant in a word */
322 deposit_14 (int opnd
, unsigned word
)
324 unsigned sign
= (opnd
< 0 ? 1 : 0);
326 return word
| ((unsigned) opnd
<< 1 & MASK_14
) | sign
;
329 /* extract a 21 bit constant */
332 extract_21 (unsigned word
)
338 val
= get_field (word
, 20, 20);
340 val
|= get_field (word
, 9, 19);
342 val
|= get_field (word
, 5, 6);
344 val
|= get_field (word
, 0, 4);
346 val
|= get_field (word
, 7, 8);
347 return sign_extend (val
, 21) << 11;
350 /* deposit a 21 bit constant in a word. Although 21 bit constants are
351 usually the top 21 bits of a 32 bit constant, we assume that only
352 the low 21 bits of opnd are relevant */
355 deposit_21 (unsigned opnd
, unsigned word
)
359 val
|= get_field (opnd
, 11 + 14, 11 + 18);
361 val
|= get_field (opnd
, 11 + 12, 11 + 13);
363 val
|= get_field (opnd
, 11 + 19, 11 + 20);
365 val
|= get_field (opnd
, 11 + 1, 11 + 11);
367 val
|= get_field (opnd
, 11 + 0, 11 + 0);
371 /* extract a 17 bit constant from branch instructions, returning the
372 19 bit signed value. */
375 extract_17 (unsigned word
)
377 return sign_extend (get_field (word
, 19, 28) |
378 get_field (word
, 29, 29) << 10 |
379 get_field (word
, 11, 15) << 11 |
380 (word
& 0x1) << 16, 17) << 2;
384 /* Compare the start address for two unwind entries returning 1 if
385 the first address is larger than the second, -1 if the second is
386 larger than the first, and zero if they are equal. */
389 compare_unwind_entries (const void *arg1
, const void *arg2
)
391 const struct unwind_table_entry
*a
= arg1
;
392 const struct unwind_table_entry
*b
= arg2
;
394 if (a
->region_start
> b
->region_start
)
396 else if (a
->region_start
< b
->region_start
)
402 static CORE_ADDR low_text_segment_address
;
405 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *ignored
)
407 if (((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
408 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
409 && section
->vma
< low_text_segment_address
)
410 low_text_segment_address
= section
->vma
;
414 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
415 asection
*section
, unsigned int entries
, unsigned int size
,
416 CORE_ADDR text_offset
)
418 /* We will read the unwind entries into temporary memory, then
419 fill in the actual unwind table. */
424 char *buf
= alloca (size
);
426 low_text_segment_address
= -1;
428 /* If addresses are 64 bits wide, then unwinds are supposed to
429 be segment relative offsets instead of absolute addresses.
431 Note that when loading a shared library (text_offset != 0) the
432 unwinds are already relative to the text_offset that will be
434 if (TARGET_PTR_BIT
== 64 && text_offset
== 0)
436 bfd_map_over_sections (objfile
->obfd
,
437 record_text_segment_lowaddr
, NULL
);
439 /* ?!? Mask off some low bits. Should this instead subtract
440 out the lowest section's filepos or something like that?
441 This looks very hokey to me. */
442 low_text_segment_address
&= ~0xfff;
443 text_offset
+= low_text_segment_address
;
446 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
448 /* Now internalize the information being careful to handle host/target
450 for (i
= 0; i
< entries
; i
++)
452 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
454 table
[i
].region_start
+= text_offset
;
456 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
457 table
[i
].region_end
+= text_offset
;
459 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
461 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
462 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
463 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
464 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
465 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
466 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
467 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
468 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
469 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
470 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
471 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
472 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
473 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
474 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
475 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
476 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
477 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
478 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
479 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
480 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
481 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
482 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
483 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
484 table
[i
].Cleanup_defined
= tmp
& 0x1;
485 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
487 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
488 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
489 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
490 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
491 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
492 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
494 /* Stub unwinds are handled elsewhere. */
495 table
[i
].stub_unwind
.stub_type
= 0;
496 table
[i
].stub_unwind
.padding
= 0;
501 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
502 the object file. This info is used mainly by find_unwind_entry() to find
503 out the stack frame size and frame pointer used by procedures. We put
504 everything on the psymbol obstack in the objfile so that it automatically
505 gets freed when the objfile is destroyed. */
508 read_unwind_info (struct objfile
*objfile
)
510 asection
*unwind_sec
, *stub_unwind_sec
;
511 unsigned unwind_size
, stub_unwind_size
, total_size
;
512 unsigned index
, unwind_entries
;
513 unsigned stub_entries
, total_entries
;
514 CORE_ADDR text_offset
;
515 struct obj_unwind_info
*ui
;
516 obj_private_data_t
*obj_private
;
518 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
519 ui
= (struct obj_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
520 sizeof (struct obj_unwind_info
));
526 /* For reasons unknown the HP PA64 tools generate multiple unwinder
527 sections in a single executable. So we just iterate over every
528 section in the BFD looking for unwinder sections intead of trying
529 to do a lookup with bfd_get_section_by_name.
531 First determine the total size of the unwind tables so that we
532 can allocate memory in a nice big hunk. */
534 for (unwind_sec
= objfile
->obfd
->sections
;
536 unwind_sec
= unwind_sec
->next
)
538 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
539 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
541 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
542 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
544 total_entries
+= unwind_entries
;
548 /* Now compute the size of the stub unwinds. Note the ELF tools do not
549 use stub unwinds at the curren time. */
550 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
554 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
555 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
559 stub_unwind_size
= 0;
563 /* Compute total number of unwind entries and their total size. */
564 total_entries
+= stub_entries
;
565 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
567 /* Allocate memory for the unwind table. */
568 ui
->table
= (struct unwind_table_entry
*)
569 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
570 ui
->last
= total_entries
- 1;
572 /* Now read in each unwind section and internalize the standard unwind
575 for (unwind_sec
= objfile
->obfd
->sections
;
577 unwind_sec
= unwind_sec
->next
)
579 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
580 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
582 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
583 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
585 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
586 unwind_entries
, unwind_size
, text_offset
);
587 index
+= unwind_entries
;
591 /* Now read in and internalize the stub unwind entries. */
592 if (stub_unwind_size
> 0)
595 char *buf
= alloca (stub_unwind_size
);
597 /* Read in the stub unwind entries. */
598 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
599 0, stub_unwind_size
);
601 /* Now convert them into regular unwind entries. */
602 for (i
= 0; i
< stub_entries
; i
++, index
++)
604 /* Clear out the next unwind entry. */
605 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
607 /* Convert offset & size into region_start and region_end.
608 Stuff away the stub type into "reserved" fields. */
609 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
611 ui
->table
[index
].region_start
+= text_offset
;
613 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
616 ui
->table
[index
].region_end
617 = ui
->table
[index
].region_start
+ 4 *
618 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
624 /* Unwind table needs to be kept sorted. */
625 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
626 compare_unwind_entries
);
628 /* Keep a pointer to the unwind information. */
629 if (objfile
->obj_private
== NULL
)
631 obj_private
= (obj_private_data_t
*)
632 obstack_alloc (&objfile
->objfile_obstack
,
633 sizeof (obj_private_data_t
));
634 obj_private
->unwind_info
= NULL
;
635 obj_private
->so_info
= NULL
;
638 objfile
->obj_private
= obj_private
;
640 obj_private
= (obj_private_data_t
*) objfile
->obj_private
;
641 obj_private
->unwind_info
= ui
;
644 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
645 of the objfiles seeking the unwind table entry for this PC. Each objfile
646 contains a sorted list of struct unwind_table_entry. Since we do a binary
647 search of the unwind tables, we depend upon them to be sorted. */
649 struct unwind_table_entry
*
650 find_unwind_entry (CORE_ADDR pc
)
652 int first
, middle
, last
;
653 struct objfile
*objfile
;
655 /* A function at address 0? Not in HP-UX! */
656 if (pc
== (CORE_ADDR
) 0)
659 ALL_OBJFILES (objfile
)
661 struct obj_unwind_info
*ui
;
663 if (objfile
->obj_private
)
664 ui
= ((obj_private_data_t
*) (objfile
->obj_private
))->unwind_info
;
668 read_unwind_info (objfile
);
669 if (objfile
->obj_private
== NULL
)
670 error ("Internal error reading unwind information.");
671 ui
= ((obj_private_data_t
*) (objfile
->obj_private
))->unwind_info
;
674 /* First, check the cache */
677 && pc
>= ui
->cache
->region_start
678 && pc
<= ui
->cache
->region_end
)
681 /* Not in the cache, do a binary search */
686 while (first
<= last
)
688 middle
= (first
+ last
) / 2;
689 if (pc
>= ui
->table
[middle
].region_start
690 && pc
<= ui
->table
[middle
].region_end
)
692 ui
->cache
= &ui
->table
[middle
];
693 return &ui
->table
[middle
];
696 if (pc
< ui
->table
[middle
].region_start
)
701 } /* ALL_OBJFILES() */
705 const unsigned char *
706 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
708 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
709 (*len
) = sizeof (breakpoint
);
713 /* Return the name of a register. */
716 hppa32_register_name (int i
)
718 static char *names
[] = {
719 "flags", "r1", "rp", "r3",
720 "r4", "r5", "r6", "r7",
721 "r8", "r9", "r10", "r11",
722 "r12", "r13", "r14", "r15",
723 "r16", "r17", "r18", "r19",
724 "r20", "r21", "r22", "r23",
725 "r24", "r25", "r26", "dp",
726 "ret0", "ret1", "sp", "r31",
727 "sar", "pcoqh", "pcsqh", "pcoqt",
728 "pcsqt", "eiem", "iir", "isr",
729 "ior", "ipsw", "goto", "sr4",
730 "sr0", "sr1", "sr2", "sr3",
731 "sr5", "sr6", "sr7", "cr0",
732 "cr8", "cr9", "ccr", "cr12",
733 "cr13", "cr24", "cr25", "cr26",
734 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
735 "fpsr", "fpe1", "fpe2", "fpe3",
736 "fpe4", "fpe5", "fpe6", "fpe7",
737 "fr4", "fr4R", "fr5", "fr5R",
738 "fr6", "fr6R", "fr7", "fr7R",
739 "fr8", "fr8R", "fr9", "fr9R",
740 "fr10", "fr10R", "fr11", "fr11R",
741 "fr12", "fr12R", "fr13", "fr13R",
742 "fr14", "fr14R", "fr15", "fr15R",
743 "fr16", "fr16R", "fr17", "fr17R",
744 "fr18", "fr18R", "fr19", "fr19R",
745 "fr20", "fr20R", "fr21", "fr21R",
746 "fr22", "fr22R", "fr23", "fr23R",
747 "fr24", "fr24R", "fr25", "fr25R",
748 "fr26", "fr26R", "fr27", "fr27R",
749 "fr28", "fr28R", "fr29", "fr29R",
750 "fr30", "fr30R", "fr31", "fr31R"
752 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
759 hppa64_register_name (int i
)
761 static char *names
[] = {
762 "flags", "r1", "rp", "r3",
763 "r4", "r5", "r6", "r7",
764 "r8", "r9", "r10", "r11",
765 "r12", "r13", "r14", "r15",
766 "r16", "r17", "r18", "r19",
767 "r20", "r21", "r22", "r23",
768 "r24", "r25", "r26", "dp",
769 "ret0", "ret1", "sp", "r31",
770 "sar", "pcoqh", "pcsqh", "pcoqt",
771 "pcsqt", "eiem", "iir", "isr",
772 "ior", "ipsw", "goto", "sr4",
773 "sr0", "sr1", "sr2", "sr3",
774 "sr5", "sr6", "sr7", "cr0",
775 "cr8", "cr9", "ccr", "cr12",
776 "cr13", "cr24", "cr25", "cr26",
777 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
778 "fpsr", "fpe1", "fpe2", "fpe3",
779 "fr4", "fr5", "fr6", "fr7",
780 "fr8", "fr9", "fr10", "fr11",
781 "fr12", "fr13", "fr14", "fr15",
782 "fr16", "fr17", "fr18", "fr19",
783 "fr20", "fr21", "fr22", "fr23",
784 "fr24", "fr25", "fr26", "fr27",
785 "fr28", "fr29", "fr30", "fr31"
787 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
795 /* Return the adjustment necessary to make for addresses on the stack
796 as presented by hpread.c.
798 This is necessary because of the stack direction on the PA and the
799 bizarre way in which someone (?) decided they wanted to handle
800 frame pointerless code in GDB. */
802 hpread_adjust_stack_address (CORE_ADDR func_addr
)
804 struct unwind_table_entry
*u
;
806 u
= find_unwind_entry (func_addr
);
810 return u
->Total_frame_size
<< 3;
813 /* Called to determine if PC is in an interrupt handler of some
817 pc_in_interrupt_handler (CORE_ADDR pc
)
819 struct unwind_table_entry
*u
;
820 struct minimal_symbol
*msym_us
;
822 u
= find_unwind_entry (pc
);
826 /* Oh joys. HPUX sets the interrupt bit for _sigreturn even though
827 its frame isn't a pure interrupt frame. Deal with this. */
828 msym_us
= lookup_minimal_symbol_by_pc (pc
);
830 return (u
->HP_UX_interrupt_marker
831 && !PC_IN_SIGTRAMP (pc
, DEPRECATED_SYMBOL_NAME (msym_us
)));
834 /* Called when no unwind descriptor was found for PC. Returns 1 if it
835 appears that PC is in a linker stub.
837 ?!? Need to handle stubs which appear in PA64 code. */
840 pc_in_linker_stub (CORE_ADDR pc
)
842 int found_magic_instruction
= 0;
846 /* If unable to read memory, assume pc is not in a linker stub. */
847 if (target_read_memory (pc
, buf
, 4) != 0)
850 /* We are looking for something like
852 ; $$dyncall jams RP into this special spot in the frame (RP')
853 ; before calling the "call stub"
856 ldsid (rp),r1 ; Get space associated with RP into r1
857 mtsp r1,sp ; Move it into space register 0
858 be,n 0(sr0),rp) ; back to your regularly scheduled program */
860 /* Maximum known linker stub size is 4 instructions. Search forward
861 from the given PC, then backward. */
862 for (i
= 0; i
< 4; i
++)
864 /* If we hit something with an unwind, stop searching this direction. */
866 if (find_unwind_entry (pc
+ i
* 4) != 0)
869 /* Check for ldsid (rp),r1 which is the magic instruction for a
870 return from a cross-space function call. */
871 if (read_memory_integer (pc
+ i
* 4, 4) == 0x004010a1)
873 found_magic_instruction
= 1;
876 /* Add code to handle long call/branch and argument relocation stubs
880 if (found_magic_instruction
!= 0)
883 /* Now look backward. */
884 for (i
= 0; i
< 4; i
++)
886 /* If we hit something with an unwind, stop searching this direction. */
888 if (find_unwind_entry (pc
- i
* 4) != 0)
891 /* Check for ldsid (rp),r1 which is the magic instruction for a
892 return from a cross-space function call. */
893 if (read_memory_integer (pc
- i
* 4, 4) == 0x004010a1)
895 found_magic_instruction
= 1;
898 /* Add code to handle long call/branch and argument relocation stubs
901 return found_magic_instruction
;
905 find_return_regnum (CORE_ADDR pc
)
907 struct unwind_table_entry
*u
;
909 u
= find_unwind_entry (pc
);
920 /* Return size of frame, or -1 if we should use a frame pointer. */
922 find_proc_framesize (CORE_ADDR pc
)
924 struct unwind_table_entry
*u
;
925 struct minimal_symbol
*msym_us
;
927 /* This may indicate a bug in our callers... */
928 if (pc
== (CORE_ADDR
) 0)
931 u
= find_unwind_entry (pc
);
935 if (pc_in_linker_stub (pc
))
936 /* Linker stubs have a zero size frame. */
942 msym_us
= lookup_minimal_symbol_by_pc (pc
);
944 /* If Save_SP is set, and we're not in an interrupt or signal caller,
945 then we have a frame pointer. Use it. */
947 && !pc_in_interrupt_handler (pc
)
949 && !PC_IN_SIGTRAMP (pc
, DEPRECATED_SYMBOL_NAME (msym_us
)))
952 return u
->Total_frame_size
<< 3;
955 /* Return offset from sp at which rp is saved, or 0 if not saved. */
956 static int rp_saved (CORE_ADDR
);
959 rp_saved (CORE_ADDR pc
)
961 struct unwind_table_entry
*u
;
963 /* A function at, and thus a return PC from, address 0? Not in HP-UX! */
964 if (pc
== (CORE_ADDR
) 0)
967 u
= find_unwind_entry (pc
);
971 if (pc_in_linker_stub (pc
))
972 /* This is the so-called RP'. */
979 return (TARGET_PTR_BIT
== 64 ? -16 : -20);
980 else if (u
->stub_unwind
.stub_type
!= 0)
982 switch (u
->stub_unwind
.stub_type
)
987 case PARAMETER_RELOCATION
:
998 hppa_frameless_function_invocation (struct frame_info
*frame
)
1000 struct unwind_table_entry
*u
;
1002 u
= find_unwind_entry (get_frame_pc (frame
));
1007 return (u
->Total_frame_size
== 0 && u
->stub_unwind
.stub_type
== 0);
1010 /* Immediately after a function call, return the saved pc.
1011 Can't go through the frames for this because on some machines
1012 the new frame is not set up until the new function executes
1013 some instructions. */
1016 hppa_saved_pc_after_call (struct frame_info
*frame
)
1020 struct unwind_table_entry
*u
;
1022 ret_regnum
= find_return_regnum (get_frame_pc (frame
));
1023 pc
= read_register (ret_regnum
) & ~0x3;
1025 /* If PC is in a linker stub, then we need to dig the address
1026 the stub will return to out of the stack. */
1027 u
= find_unwind_entry (pc
);
1028 if (u
&& u
->stub_unwind
.stub_type
!= 0)
1029 return DEPRECATED_FRAME_SAVED_PC (frame
);
1035 hppa_frame_saved_pc (struct frame_info
*frame
)
1037 CORE_ADDR pc
= get_frame_pc (frame
);
1038 struct unwind_table_entry
*u
;
1039 CORE_ADDR old_pc
= 0;
1040 int spun_around_loop
= 0;
1043 /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
1044 at the base of the frame in an interrupt handler. Registers within
1045 are saved in the exact same order as GDB numbers registers. How
1047 if (pc_in_interrupt_handler (pc
))
1048 return read_memory_integer (get_frame_base (frame
) + PC_REGNUM
* 4,
1049 TARGET_PTR_BIT
/ 8) & ~0x3;
1051 if ((get_frame_pc (frame
) >= get_frame_base (frame
)
1052 && (get_frame_pc (frame
)
1053 <= (get_frame_base (frame
)
1054 /* A call dummy is sized in words, but it is actually a
1055 series of instructions. Account for that scaling
1057 + ((DEPRECATED_REGISTER_SIZE
/ INSTRUCTION_SIZE
)
1058 * DEPRECATED_CALL_DUMMY_LENGTH
)
1059 /* Similarly we have to account for 64bit wide register
1061 + (32 * DEPRECATED_REGISTER_SIZE
)
1062 /* We always consider FP regs 8 bytes long. */
1063 + (NUM_REGS
- FP0_REGNUM
) * 8
1064 /* Similarly we have to account for 64bit wide register
1066 + (6 * DEPRECATED_REGISTER_SIZE
)))))
1068 return read_memory_integer ((get_frame_base (frame
)
1069 + (TARGET_PTR_BIT
== 64 ? -16 : -20)),
1070 TARGET_PTR_BIT
/ 8) & ~0x3;
1073 #ifdef FRAME_SAVED_PC_IN_SIGTRAMP
1074 /* Deal with signal handler caller frames too. */
1075 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
1078 FRAME_SAVED_PC_IN_SIGTRAMP (frame
, &rp
);
1083 if (hppa_frameless_function_invocation (frame
))
1087 ret_regnum
= find_return_regnum (pc
);
1089 /* If the next frame is an interrupt frame or a signal
1090 handler caller, then we need to look in the saved
1091 register area to get the return pointer (the values
1092 in the registers may not correspond to anything useful). */
1093 if (get_next_frame (frame
)
1094 && ((get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
)
1095 || pc_in_interrupt_handler (get_frame_pc (get_next_frame (frame
)))))
1097 CORE_ADDR
*saved_regs
;
1098 hppa_frame_init_saved_regs (get_next_frame (frame
));
1099 saved_regs
= deprecated_get_frame_saved_regs (get_next_frame (frame
));
1100 if (read_memory_integer (saved_regs
[FLAGS_REGNUM
],
1101 TARGET_PTR_BIT
/ 8) & 0x2)
1103 pc
= read_memory_integer (saved_regs
[31],
1104 TARGET_PTR_BIT
/ 8) & ~0x3;
1106 /* Syscalls are really two frames. The syscall stub itself
1107 with a return pointer in %rp and the kernel call with
1108 a return pointer in %r31. We return the %rp variant
1109 if %r31 is the same as frame->pc. */
1110 if (pc
== get_frame_pc (frame
))
1111 pc
= read_memory_integer (saved_regs
[RP_REGNUM
],
1112 TARGET_PTR_BIT
/ 8) & ~0x3;
1115 pc
= read_memory_integer (saved_regs
[RP_REGNUM
],
1116 TARGET_PTR_BIT
/ 8) & ~0x3;
1119 pc
= read_register (ret_regnum
) & ~0x3;
1123 spun_around_loop
= 0;
1127 rp_offset
= rp_saved (pc
);
1129 /* Similar to code in frameless function case. If the next
1130 frame is a signal or interrupt handler, then dig the right
1131 information out of the saved register info. */
1133 && get_next_frame (frame
)
1134 && ((get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
)
1135 || pc_in_interrupt_handler (get_frame_pc (get_next_frame (frame
)))))
1137 CORE_ADDR
*saved_regs
;
1138 hppa_frame_init_saved_regs (get_next_frame (frame
));
1139 saved_regs
= deprecated_get_frame_saved_regs (get_next_frame (frame
));
1140 if (read_memory_integer (saved_regs
[FLAGS_REGNUM
],
1141 TARGET_PTR_BIT
/ 8) & 0x2)
1143 pc
= read_memory_integer (saved_regs
[31],
1144 TARGET_PTR_BIT
/ 8) & ~0x3;
1146 /* Syscalls are really two frames. The syscall stub itself
1147 with a return pointer in %rp and the kernel call with
1148 a return pointer in %r31. We return the %rp variant
1149 if %r31 is the same as frame->pc. */
1150 if (pc
== get_frame_pc (frame
))
1151 pc
= read_memory_integer (saved_regs
[RP_REGNUM
],
1152 TARGET_PTR_BIT
/ 8) & ~0x3;
1155 pc
= read_memory_integer (saved_regs
[RP_REGNUM
],
1156 TARGET_PTR_BIT
/ 8) & ~0x3;
1158 else if (rp_offset
== 0)
1161 pc
= read_register (RP_REGNUM
) & ~0x3;
1166 pc
= read_memory_integer (get_frame_base (frame
) + rp_offset
,
1167 TARGET_PTR_BIT
/ 8) & ~0x3;
1171 /* If PC is inside a linker stub, then dig out the address the stub
1174 Don't do this for long branch stubs. Why? For some unknown reason
1175 _start is marked as a long branch stub in hpux10. */
1176 u
= find_unwind_entry (pc
);
1177 if (u
&& u
->stub_unwind
.stub_type
!= 0
1178 && u
->stub_unwind
.stub_type
!= LONG_BRANCH
)
1182 /* If this is a dynamic executable, and we're in a signal handler,
1183 then the call chain will eventually point us into the stub for
1184 _sigreturn. Unlike most cases, we'll be pointed to the branch
1185 to the real sigreturn rather than the code after the real branch!.
1187 Else, try to dig the address the stub will return to in the normal
1189 insn
= read_memory_integer (pc
, 4);
1190 if ((insn
& 0xfc00e000) == 0xe8000000)
1191 return (pc
+ extract_17 (insn
) + 8) & ~0x3;
1197 if (spun_around_loop
> 1)
1199 /* We're just about to go around the loop again with
1200 no more hope of success. Die. */
1201 error ("Unable to find return pc for this frame");
1211 /* We need to correct the PC and the FP for the outermost frame when we are
1212 in a system call. */
1215 hppa_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
1220 if (get_next_frame (frame
) && !fromleaf
)
1223 /* If the next frame represents a frameless function invocation then
1224 we have to do some adjustments that are normally done by
1225 DEPRECATED_FRAME_CHAIN. (DEPRECATED_FRAME_CHAIN is not called in
1229 /* Find the framesize of *this* frame without peeking at the PC
1230 in the current frame structure (it isn't set yet). */
1231 framesize
= find_proc_framesize (DEPRECATED_FRAME_SAVED_PC (get_next_frame (frame
)));
1233 /* Now adjust our base frame accordingly. If we have a frame pointer
1234 use it, else subtract the size of this frame from the current
1235 frame. (we always want frame->frame to point at the lowest address
1237 if (framesize
== -1)
1238 deprecated_update_frame_base_hack (frame
, deprecated_read_fp ());
1240 deprecated_update_frame_base_hack (frame
, get_frame_base (frame
) - framesize
);
1244 flags
= read_register (FLAGS_REGNUM
);
1245 if (flags
& 2) /* In system call? */
1246 deprecated_update_frame_pc_hack (frame
, read_register (31) & ~0x3);
1248 /* The outermost frame is always derived from PC-framesize
1250 One might think frameless innermost frames should have
1251 a frame->frame that is the same as the parent's frame->frame.
1252 That is wrong; frame->frame in that case should be the *high*
1253 address of the parent's frame. It's complicated as hell to
1254 explain, but the parent *always* creates some stack space for
1255 the child. So the child actually does have a frame of some
1256 sorts, and its base is the high address in its parent's frame. */
1257 framesize
= find_proc_framesize (get_frame_pc (frame
));
1258 if (framesize
== -1)
1259 deprecated_update_frame_base_hack (frame
, deprecated_read_fp ());
1261 deprecated_update_frame_base_hack (frame
, read_register (SP_REGNUM
) - framesize
);
1264 /* Given a GDB frame, determine the address of the calling function's
1265 frame. This will be used to create a new GDB frame struct, and
1266 then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
1267 will be called for the new frame.
1269 This may involve searching through prologues for several functions
1270 at boundaries where GCC calls HP C code, or where code which has
1271 a frame pointer calls code without a frame pointer. */
1274 hppa_frame_chain (struct frame_info
*frame
)
1276 int my_framesize
, caller_framesize
;
1277 struct unwind_table_entry
*u
;
1278 CORE_ADDR frame_base
;
1279 struct frame_info
*tmp_frame
;
1281 /* A frame in the current frame list, or zero. */
1282 struct frame_info
*saved_regs_frame
= 0;
1283 /* Where the registers were saved in saved_regs_frame. If
1284 saved_regs_frame is zero, this is garbage. */
1285 CORE_ADDR
*saved_regs
= NULL
;
1287 CORE_ADDR caller_pc
;
1289 struct minimal_symbol
*min_frame_symbol
;
1290 struct symbol
*frame_symbol
;
1291 char *frame_symbol_name
;
1293 /* If this is a threaded application, and we see the
1294 routine "__pthread_exit", treat it as the stack root
1296 min_frame_symbol
= lookup_minimal_symbol_by_pc (get_frame_pc (frame
));
1297 frame_symbol
= find_pc_function (get_frame_pc (frame
));
1299 if ((min_frame_symbol
!= 0) /* && (frame_symbol == 0) */ )
1301 /* The test above for "no user function name" would defend
1302 against the slim likelihood that a user might define a
1303 routine named "__pthread_exit" and then try to debug it.
1305 If it weren't commented out, and you tried to debug the
1306 pthread library itself, you'd get errors.
1308 So for today, we don't make that check. */
1309 frame_symbol_name
= DEPRECATED_SYMBOL_NAME (min_frame_symbol
);
1310 if (frame_symbol_name
!= 0)
1312 if (0 == strncmp (frame_symbol_name
,
1313 THREAD_INITIAL_FRAME_SYMBOL
,
1314 THREAD_INITIAL_FRAME_SYM_LEN
))
1316 /* Pretend we've reached the bottom of the stack. */
1317 return (CORE_ADDR
) 0;
1320 } /* End of hacky code for threads. */
1322 /* Handle HPUX, BSD, and OSF1 style interrupt frames first. These
1323 are easy; at *sp we have a full save state strucutre which we can
1324 pull the old stack pointer from. Also see frame_saved_pc for
1325 code to dig a saved PC out of the save state structure. */
1326 if (pc_in_interrupt_handler (get_frame_pc (frame
)))
1327 frame_base
= read_memory_integer (get_frame_base (frame
) + SP_REGNUM
* 4,
1328 TARGET_PTR_BIT
/ 8);
1329 #ifdef FRAME_BASE_BEFORE_SIGTRAMP
1330 else if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
1332 FRAME_BASE_BEFORE_SIGTRAMP (frame
, &frame_base
);
1336 frame_base
= get_frame_base (frame
);
1338 /* Get frame sizes for the current frame and the frame of the
1340 my_framesize
= find_proc_framesize (get_frame_pc (frame
));
1341 caller_pc
= DEPRECATED_FRAME_SAVED_PC (frame
);
1343 /* If we can't determine the caller's PC, then it's not likely we can
1344 really determine anything meaningful about its frame. We'll consider
1345 this to be stack bottom. */
1346 if (caller_pc
== (CORE_ADDR
) 0)
1347 return (CORE_ADDR
) 0;
1349 caller_framesize
= find_proc_framesize (DEPRECATED_FRAME_SAVED_PC (frame
));
1351 /* If caller does not have a frame pointer, then its frame
1352 can be found at current_frame - caller_framesize. */
1353 if (caller_framesize
!= -1)
1355 return frame_base
- caller_framesize
;
1357 /* Both caller and callee have frame pointers and are GCC compiled
1358 (SAVE_SP bit in unwind descriptor is on for both functions.
1359 The previous frame pointer is found at the top of the current frame. */
1360 if (caller_framesize
== -1 && my_framesize
== -1)
1362 return read_memory_integer (frame_base
, TARGET_PTR_BIT
/ 8);
1364 /* Caller has a frame pointer, but callee does not. This is a little
1365 more difficult as GCC and HP C lay out locals and callee register save
1366 areas very differently.
1368 The previous frame pointer could be in a register, or in one of
1369 several areas on the stack.
1371 Walk from the current frame to the innermost frame examining
1372 unwind descriptors to determine if %r3 ever gets saved into the
1373 stack. If so return whatever value got saved into the stack.
1374 If it was never saved in the stack, then the value in %r3 is still
1377 We use information from unwind descriptors to determine if %r3
1378 is saved into the stack (Entry_GR field has this information). */
1380 for (tmp_frame
= frame
; tmp_frame
; tmp_frame
= get_next_frame (tmp_frame
))
1382 u
= find_unwind_entry (get_frame_pc (tmp_frame
));
1386 /* We could find this information by examining prologues. I don't
1387 think anyone has actually written any tools (not even "strip")
1388 which leave them out of an executable, so maybe this is a moot
1390 /* ??rehrauer: Actually, it's quite possible to stepi your way into
1391 code that doesn't have unwind entries. For example, stepping into
1392 the dynamic linker will give you a PC that has none. Thus, I've
1393 disabled this warning. */
1395 warning ("Unable to find unwind for PC 0x%x -- Help!", get_frame_pc (tmp_frame
));
1397 return (CORE_ADDR
) 0;
1401 || (get_frame_type (tmp_frame
) == SIGTRAMP_FRAME
)
1402 || pc_in_interrupt_handler (get_frame_pc (tmp_frame
)))
1405 /* Entry_GR specifies the number of callee-saved general registers
1406 saved in the stack. It starts at %r3, so %r3 would be 1. */
1407 if (u
->Entry_GR
>= 1)
1409 /* The unwind entry claims that r3 is saved here. However,
1410 in optimized code, GCC often doesn't actually save r3.
1411 We'll discover this if we look at the prologue. */
1412 hppa_frame_init_saved_regs (tmp_frame
);
1413 saved_regs
= deprecated_get_frame_saved_regs (tmp_frame
);
1414 saved_regs_frame
= tmp_frame
;
1416 /* If we have an address for r3, that's good. */
1417 if (saved_regs
[DEPRECATED_FP_REGNUM
])
1424 /* We may have walked down the chain into a function with a frame
1427 && !(get_frame_type (tmp_frame
) == SIGTRAMP_FRAME
)
1428 && !pc_in_interrupt_handler (get_frame_pc (tmp_frame
)))
1430 return read_memory_integer (get_frame_base (tmp_frame
), TARGET_PTR_BIT
/ 8);
1432 /* %r3 was saved somewhere in the stack. Dig it out. */
1437 For optimization purposes many kernels don't have the
1438 callee saved registers into the save_state structure upon
1439 entry into the kernel for a syscall; the optimization
1440 is usually turned off if the process is being traced so
1441 that the debugger can get full register state for the
1444 This scheme works well except for two cases:
1446 * Attaching to a process when the process is in the
1447 kernel performing a system call (debugger can't get
1448 full register state for the inferior process since
1449 the process wasn't being traced when it entered the
1452 * Register state is not complete if the system call
1453 causes the process to core dump.
1456 The following heinous code is an attempt to deal with
1457 the lack of register state in a core dump. It will
1458 fail miserably if the function which performs the
1459 system call has a variable sized stack frame. */
1461 if (tmp_frame
!= saved_regs_frame
)
1463 hppa_frame_init_saved_regs (tmp_frame
);
1464 saved_regs
= deprecated_get_frame_saved_regs (tmp_frame
);
1467 /* Abominable hack. */
1468 if (current_target
.to_has_execution
== 0
1469 && ((saved_regs
[FLAGS_REGNUM
]
1470 && (read_memory_integer (saved_regs
[FLAGS_REGNUM
],
1473 || (saved_regs
[FLAGS_REGNUM
] == 0
1474 && read_register (FLAGS_REGNUM
) & 0x2)))
1476 u
= find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame
));
1479 return read_memory_integer (saved_regs
[DEPRECATED_FP_REGNUM
],
1480 TARGET_PTR_BIT
/ 8);
1484 return frame_base
- (u
->Total_frame_size
<< 3);
1488 return read_memory_integer (saved_regs
[DEPRECATED_FP_REGNUM
],
1489 TARGET_PTR_BIT
/ 8);
1494 /* Get the innermost frame. */
1496 while (get_next_frame (tmp_frame
) != NULL
)
1497 tmp_frame
= get_next_frame (tmp_frame
);
1499 if (tmp_frame
!= saved_regs_frame
)
1501 hppa_frame_init_saved_regs (tmp_frame
);
1502 saved_regs
= deprecated_get_frame_saved_regs (tmp_frame
);
1505 /* Abominable hack. See above. */
1506 if (current_target
.to_has_execution
== 0
1507 && ((saved_regs
[FLAGS_REGNUM
]
1508 && (read_memory_integer (saved_regs
[FLAGS_REGNUM
],
1511 || (saved_regs
[FLAGS_REGNUM
] == 0
1512 && read_register (FLAGS_REGNUM
) & 0x2)))
1514 u
= find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame
));
1517 return read_memory_integer (saved_regs
[DEPRECATED_FP_REGNUM
],
1518 TARGET_PTR_BIT
/ 8);
1522 return frame_base
- (u
->Total_frame_size
<< 3);
1526 /* The value in %r3 was never saved into the stack (thus %r3 still
1527 holds the value of the previous frame pointer). */
1528 return deprecated_read_fp ();
1533 /* To see if a frame chain is valid, see if the caller looks like it
1534 was compiled with gcc. */
1537 hppa_frame_chain_valid (CORE_ADDR chain
, struct frame_info
*thisframe
)
1539 struct minimal_symbol
*msym_us
;
1540 struct minimal_symbol
*msym_start
;
1541 struct unwind_table_entry
*u
, *next_u
= NULL
;
1542 struct frame_info
*next
;
1544 u
= find_unwind_entry (get_frame_pc (thisframe
));
1549 /* We can't just check that the same of msym_us is "_start", because
1550 someone idiotically decided that they were going to make a Ltext_end
1551 symbol with the same address. This Ltext_end symbol is totally
1552 indistinguishable (as nearly as I can tell) from the symbol for a function
1553 which is (legitimately, since it is in the user's namespace)
1554 named Ltext_end, so we can't just ignore it. */
1555 msym_us
= lookup_minimal_symbol_by_pc (DEPRECATED_FRAME_SAVED_PC (thisframe
));
1556 msym_start
= lookup_minimal_symbol ("_start", NULL
, NULL
);
1559 && SYMBOL_VALUE_ADDRESS (msym_us
) == SYMBOL_VALUE_ADDRESS (msym_start
))
1562 /* Grrrr. Some new idiot decided that they don't want _start for the
1563 PRO configurations; $START$ calls main directly.... Deal with it. */
1564 msym_start
= lookup_minimal_symbol ("$START$", NULL
, NULL
);
1567 && SYMBOL_VALUE_ADDRESS (msym_us
) == SYMBOL_VALUE_ADDRESS (msym_start
))
1570 next
= get_next_frame (thisframe
);
1572 next_u
= find_unwind_entry (get_frame_pc (next
));
1574 /* If this frame does not save SP, has no stack, isn't a stub,
1575 and doesn't "call" an interrupt routine or signal handler caller,
1576 then its not valid. */
1577 if (u
->Save_SP
|| u
->Total_frame_size
|| u
->stub_unwind
.stub_type
!= 0
1578 || (get_next_frame (thisframe
) && (get_frame_type (get_next_frame (thisframe
)) == SIGTRAMP_FRAME
))
1579 || (next_u
&& next_u
->HP_UX_interrupt_marker
))
1582 if (pc_in_linker_stub (get_frame_pc (thisframe
)))
1588 /* These functions deal with saving and restoring register state
1589 around a function call in the inferior. They keep the stack
1590 double-word aligned; eventually, on an hp700, the stack will have
1591 to be aligned to a 64-byte boundary. */
1594 hppa_push_dummy_frame (void)
1596 CORE_ADDR sp
, pc
, pcspace
;
1598 CORE_ADDR int_buffer
;
1601 pc
= hppa_target_read_pc (inferior_ptid
);
1602 int_buffer
= read_register (FLAGS_REGNUM
);
1603 if (int_buffer
& 0x2)
1605 const unsigned int sid
= (pc
>> 30) & 0x3;
1607 pcspace
= read_register (SR4_REGNUM
);
1609 pcspace
= read_register (SR4_REGNUM
+ 4 + sid
);
1612 pcspace
= read_register (PCSQ_HEAD_REGNUM
);
1614 /* Space for "arguments"; the RP goes in here. */
1615 sp
= read_register (SP_REGNUM
) + 48;
1616 int_buffer
= read_register (RP_REGNUM
) | 0x3;
1618 /* The 32bit and 64bit ABIs save the return pointer into different
1620 if (DEPRECATED_REGISTER_SIZE
== 8)
1621 write_memory (sp
- 16, (char *) &int_buffer
, DEPRECATED_REGISTER_SIZE
);
1623 write_memory (sp
- 20, (char *) &int_buffer
, DEPRECATED_REGISTER_SIZE
);
1625 int_buffer
= deprecated_read_fp ();
1626 write_memory (sp
, (char *) &int_buffer
, DEPRECATED_REGISTER_SIZE
);
1628 write_register (DEPRECATED_FP_REGNUM
, sp
);
1630 sp
+= 2 * DEPRECATED_REGISTER_SIZE
;
1632 for (regnum
= 1; regnum
< 32; regnum
++)
1633 if (regnum
!= RP_REGNUM
&& regnum
!= DEPRECATED_FP_REGNUM
)
1634 sp
= push_word (sp
, read_register (regnum
));
1636 /* This is not necessary for the 64bit ABI. In fact it is dangerous. */
1637 if (DEPRECATED_REGISTER_SIZE
!= 8)
1640 for (regnum
= FP0_REGNUM
; regnum
< NUM_REGS
; regnum
++)
1642 deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (regnum
),
1643 (char *) &freg_buffer
, 8);
1644 sp
= push_bytes (sp
, (char *) &freg_buffer
, 8);
1646 sp
= push_word (sp
, read_register (IPSW_REGNUM
));
1647 sp
= push_word (sp
, read_register (SAR_REGNUM
));
1648 sp
= push_word (sp
, pc
);
1649 sp
= push_word (sp
, pcspace
);
1650 sp
= push_word (sp
, pc
+ 4);
1651 sp
= push_word (sp
, pcspace
);
1652 write_register (SP_REGNUM
, sp
);
1656 find_dummy_frame_regs (struct frame_info
*frame
,
1657 CORE_ADDR frame_saved_regs
[])
1659 CORE_ADDR fp
= get_frame_base (frame
);
1662 /* The 32bit and 64bit ABIs save RP into different locations. */
1663 if (DEPRECATED_REGISTER_SIZE
== 8)
1664 frame_saved_regs
[RP_REGNUM
] = (fp
- 16) & ~0x3;
1666 frame_saved_regs
[RP_REGNUM
] = (fp
- 20) & ~0x3;
1668 frame_saved_regs
[DEPRECATED_FP_REGNUM
] = fp
;
1670 frame_saved_regs
[1] = fp
+ (2 * DEPRECATED_REGISTER_SIZE
);
1672 for (fp
+= 3 * DEPRECATED_REGISTER_SIZE
, i
= 3; i
< 32; i
++)
1674 if (i
!= DEPRECATED_FP_REGNUM
)
1676 frame_saved_regs
[i
] = fp
;
1677 fp
+= DEPRECATED_REGISTER_SIZE
;
1681 /* This is not necessary or desirable for the 64bit ABI. */
1682 if (DEPRECATED_REGISTER_SIZE
!= 8)
1685 for (i
= FP0_REGNUM
; i
< NUM_REGS
; i
++, fp
+= 8)
1686 frame_saved_regs
[i
] = fp
;
1688 frame_saved_regs
[IPSW_REGNUM
] = fp
;
1689 frame_saved_regs
[SAR_REGNUM
] = fp
+ DEPRECATED_REGISTER_SIZE
;
1690 frame_saved_regs
[PCOQ_HEAD_REGNUM
] = fp
+ 2 * DEPRECATED_REGISTER_SIZE
;
1691 frame_saved_regs
[PCSQ_HEAD_REGNUM
] = fp
+ 3 * DEPRECATED_REGISTER_SIZE
;
1692 frame_saved_regs
[PCOQ_TAIL_REGNUM
] = fp
+ 4 * DEPRECATED_REGISTER_SIZE
;
1693 frame_saved_regs
[PCSQ_TAIL_REGNUM
] = fp
+ 5 * DEPRECATED_REGISTER_SIZE
;
1697 hppa_pop_frame (void)
1699 struct frame_info
*frame
= get_current_frame ();
1700 CORE_ADDR fp
, npc
, target_pc
;
1705 fp
= get_frame_base (frame
);
1706 hppa_frame_init_saved_regs (frame
);
1707 fsr
= deprecated_get_frame_saved_regs (frame
);
1709 #ifndef NO_PC_SPACE_QUEUE_RESTORE
1710 if (fsr
[IPSW_REGNUM
]) /* Restoring a call dummy frame */
1711 restore_pc_queue (fsr
);
1714 for (regnum
= 31; regnum
> 0; regnum
--)
1716 write_register (regnum
, read_memory_integer (fsr
[regnum
],
1717 DEPRECATED_REGISTER_SIZE
));
1719 for (regnum
= NUM_REGS
- 1; regnum
>= FP0_REGNUM
; regnum
--)
1722 read_memory (fsr
[regnum
], (char *) &freg_buffer
, 8);
1723 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum
),
1724 (char *) &freg_buffer
, 8);
1727 if (fsr
[IPSW_REGNUM
])
1728 write_register (IPSW_REGNUM
,
1729 read_memory_integer (fsr
[IPSW_REGNUM
],
1730 DEPRECATED_REGISTER_SIZE
));
1732 if (fsr
[SAR_REGNUM
])
1733 write_register (SAR_REGNUM
,
1734 read_memory_integer (fsr
[SAR_REGNUM
],
1735 DEPRECATED_REGISTER_SIZE
));
1737 /* If the PC was explicitly saved, then just restore it. */
1738 if (fsr
[PCOQ_TAIL_REGNUM
])
1740 npc
= read_memory_integer (fsr
[PCOQ_TAIL_REGNUM
],
1741 DEPRECATED_REGISTER_SIZE
);
1742 write_register (PCOQ_TAIL_REGNUM
, npc
);
1744 /* Else use the value in %rp to set the new PC. */
1747 npc
= read_register (RP_REGNUM
);
1751 write_register (DEPRECATED_FP_REGNUM
, read_memory_integer (fp
, DEPRECATED_REGISTER_SIZE
));
1753 if (fsr
[IPSW_REGNUM
]) /* call dummy */
1754 write_register (SP_REGNUM
, fp
- 48);
1756 write_register (SP_REGNUM
, fp
);
1758 /* The PC we just restored may be inside a return trampoline. If so
1759 we want to restart the inferior and run it through the trampoline.
1761 Do this by setting a momentary breakpoint at the location the
1762 trampoline returns to.
1764 Don't skip through the trampoline if we're popping a dummy frame. */
1765 target_pc
= SKIP_TRAMPOLINE_CODE (npc
& ~0x3) & ~0x3;
1766 if (target_pc
&& !fsr
[IPSW_REGNUM
])
1768 struct symtab_and_line sal
;
1769 struct breakpoint
*breakpoint
;
1770 struct cleanup
*old_chain
;
1772 /* Set up our breakpoint. Set it to be silent as the MI code
1773 for "return_command" will print the frame we returned to. */
1774 sal
= find_pc_line (target_pc
, 0);
1776 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_finish
);
1777 breakpoint
->silent
= 1;
1779 /* So we can clean things up. */
1780 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1782 /* Start up the inferior. */
1783 clear_proceed_status ();
1784 proceed_to_finish
= 1;
1785 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1787 /* Perform our cleanups. */
1788 do_cleanups (old_chain
);
1790 flush_cached_frames ();
1793 /* After returning to a dummy on the stack, restore the instruction
1794 queue space registers. */
1797 restore_pc_queue (CORE_ADDR
*fsr
)
1799 CORE_ADDR pc
= read_pc ();
1800 CORE_ADDR new_pc
= read_memory_integer (fsr
[PCOQ_HEAD_REGNUM
],
1801 TARGET_PTR_BIT
/ 8);
1802 struct target_waitstatus w
;
1805 /* Advance past break instruction in the call dummy. */
1806 write_register (PCOQ_HEAD_REGNUM
, pc
+ 4);
1807 write_register (PCOQ_TAIL_REGNUM
, pc
+ 8);
1809 /* HPUX doesn't let us set the space registers or the space
1810 registers of the PC queue through ptrace. Boo, hiss.
1811 Conveniently, the call dummy has this sequence of instructions
1816 So, load up the registers and single step until we are in the
1819 write_register (21, read_memory_integer (fsr
[PCSQ_HEAD_REGNUM
],
1820 DEPRECATED_REGISTER_SIZE
));
1821 write_register (22, new_pc
);
1823 for (insn_count
= 0; insn_count
< 3; insn_count
++)
1825 /* FIXME: What if the inferior gets a signal right now? Want to
1826 merge this into wait_for_inferior (as a special kind of
1827 watchpoint? By setting a breakpoint at the end? Is there
1828 any other choice? Is there *any* way to do this stuff with
1829 ptrace() or some equivalent?). */
1831 target_wait (inferior_ptid
, &w
);
1833 if (w
.kind
== TARGET_WAITKIND_SIGNALLED
)
1835 stop_signal
= w
.value
.sig
;
1836 terminal_ours_for_output ();
1837 printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
1838 target_signal_to_name (stop_signal
),
1839 target_signal_to_string (stop_signal
));
1840 gdb_flush (gdb_stdout
);
1844 target_terminal_ours ();
1845 target_fetch_registers (-1);
1850 #ifdef PA20W_CALLING_CONVENTIONS
1852 /* This function pushes a stack frame with arguments as part of the
1853 inferior function calling mechanism.
1855 This is the version for the PA64, in which later arguments appear
1856 at higher addresses. (The stack always grows towards higher
1859 We simply allocate the appropriate amount of stack space and put
1860 arguments into their proper slots. The call dummy code will copy
1861 arguments into registers as needed by the ABI.
1863 This ABI also requires that the caller provide an argument pointer
1864 to the callee, so we do that too. */
1867 hppa_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1868 int struct_return
, CORE_ADDR struct_addr
)
1870 /* array of arguments' offsets */
1871 int *offset
= (int *) alloca (nargs
* sizeof (int));
1873 /* array of arguments' lengths: real lengths in bytes, not aligned to
1875 int *lengths
= (int *) alloca (nargs
* sizeof (int));
1877 /* The value of SP as it was passed into this function after
1879 CORE_ADDR orig_sp
= DEPRECATED_STACK_ALIGN (sp
);
1881 /* The number of stack bytes occupied by the current argument. */
1884 /* The total number of bytes reserved for the arguments. */
1885 int cum_bytes_reserved
= 0;
1887 /* Similarly, but aligned. */
1888 int cum_bytes_aligned
= 0;
1891 /* Iterate over each argument provided by the user. */
1892 for (i
= 0; i
< nargs
; i
++)
1894 struct type
*arg_type
= VALUE_TYPE (args
[i
]);
1896 /* Integral scalar values smaller than a register are padded on
1897 the left. We do this by promoting them to full-width,
1898 although the ABI says to pad them with garbage. */
1899 if (is_integral_type (arg_type
)
1900 && TYPE_LENGTH (arg_type
) < DEPRECATED_REGISTER_SIZE
)
1902 args
[i
] = value_cast ((TYPE_UNSIGNED (arg_type
)
1903 ? builtin_type_unsigned_long
1904 : builtin_type_long
),
1906 arg_type
= VALUE_TYPE (args
[i
]);
1909 lengths
[i
] = TYPE_LENGTH (arg_type
);
1911 /* Align the size of the argument to the word size for this
1913 bytes_reserved
= (lengths
[i
] + DEPRECATED_REGISTER_SIZE
- 1) & -DEPRECATED_REGISTER_SIZE
;
1915 offset
[i
] = cum_bytes_reserved
;
1917 /* Aggregates larger than eight bytes (the only types larger
1918 than eight bytes we have) are aligned on a 16-byte boundary,
1919 possibly padded on the right with garbage. This may leave an
1920 empty word on the stack, and thus an unused register, as per
1922 if (bytes_reserved
> 8)
1924 /* Round up the offset to a multiple of two slots. */
1925 int new_offset
= ((offset
[i
] + 2*DEPRECATED_REGISTER_SIZE
-1)
1926 & -(2*DEPRECATED_REGISTER_SIZE
));
1928 /* Note the space we've wasted, if any. */
1929 bytes_reserved
+= new_offset
- offset
[i
];
1930 offset
[i
] = new_offset
;
1933 cum_bytes_reserved
+= bytes_reserved
;
1936 /* CUM_BYTES_RESERVED already accounts for all the arguments
1937 passed by the user. However, the ABIs mandate minimum stack space
1938 allocations for outgoing arguments.
1940 The ABIs also mandate minimum stack alignments which we must
1942 cum_bytes_aligned
= DEPRECATED_STACK_ALIGN (cum_bytes_reserved
);
1943 sp
+= max (cum_bytes_aligned
, REG_PARM_STACK_SPACE
);
1945 /* Now write each of the args at the proper offset down the stack. */
1946 for (i
= 0; i
< nargs
; i
++)
1947 write_memory (orig_sp
+ offset
[i
], VALUE_CONTENTS (args
[i
]), lengths
[i
]);
1949 /* If a structure has to be returned, set up register 28 to hold its
1952 write_register (28, struct_addr
);
1954 /* For the PA64 we must pass a pointer to the outgoing argument list.
1955 The ABI mandates that the pointer should point to the first byte of
1956 storage beyond the register flushback area.
1958 However, the call dummy expects the outgoing argument pointer to
1959 be passed in register %r4. */
1960 write_register (4, orig_sp
+ REG_PARM_STACK_SPACE
);
1962 /* ?!? This needs further work. We need to set up the global data
1963 pointer for this procedure. This assumes the same global pointer
1964 for every procedure. The call dummy expects the dp value to
1965 be passed in register %r6. */
1966 write_register (6, read_register (27));
1968 /* The stack will have 64 bytes of additional space for a frame marker. */
1974 /* This function pushes a stack frame with arguments as part of the
1975 inferior function calling mechanism.
1977 This is the version of the function for the 32-bit PA machines, in
1978 which later arguments appear at lower addresses. (The stack always
1979 grows towards higher addresses.)
1981 We simply allocate the appropriate amount of stack space and put
1982 arguments into their proper slots. The call dummy code will copy
1983 arguments into registers as needed by the ABI. */
1986 hppa_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1987 int struct_return
, CORE_ADDR struct_addr
)
1989 /* array of arguments' offsets */
1990 int *offset
= (int *) alloca (nargs
* sizeof (int));
1992 /* array of arguments' lengths: real lengths in bytes, not aligned to
1994 int *lengths
= (int *) alloca (nargs
* sizeof (int));
1996 /* The number of stack bytes occupied by the current argument. */
1999 /* The total number of bytes reserved for the arguments. */
2000 int cum_bytes_reserved
= 0;
2002 /* Similarly, but aligned. */
2003 int cum_bytes_aligned
= 0;
2006 /* Iterate over each argument provided by the user. */
2007 for (i
= 0; i
< nargs
; i
++)
2009 lengths
[i
] = TYPE_LENGTH (VALUE_TYPE (args
[i
]));
2011 /* Align the size of the argument to the word size for this
2013 bytes_reserved
= (lengths
[i
] + DEPRECATED_REGISTER_SIZE
- 1) & -DEPRECATED_REGISTER_SIZE
;
2015 offset
[i
] = (cum_bytes_reserved
2016 + (lengths
[i
] > 4 ? bytes_reserved
: lengths
[i
]));
2018 /* If the argument is a double word argument, then it needs to be
2019 double word aligned. */
2020 if ((bytes_reserved
== 2 * DEPRECATED_REGISTER_SIZE
)
2021 && (offset
[i
] % 2 * DEPRECATED_REGISTER_SIZE
))
2024 /* BYTES_RESERVED is already aligned to the word, so we put
2025 the argument at one word more down the stack.
2027 This will leave one empty word on the stack, and one unused
2028 register as mandated by the ABI. */
2029 new_offset
= ((offset
[i
] + 2 * DEPRECATED_REGISTER_SIZE
- 1)
2030 & -(2 * DEPRECATED_REGISTER_SIZE
));
2032 if ((new_offset
- offset
[i
]) >= 2 * DEPRECATED_REGISTER_SIZE
)
2034 bytes_reserved
+= DEPRECATED_REGISTER_SIZE
;
2035 offset
[i
] += DEPRECATED_REGISTER_SIZE
;
2039 cum_bytes_reserved
+= bytes_reserved
;
2043 /* CUM_BYTES_RESERVED already accounts for all the arguments passed
2044 by the user. However, the ABI mandates minimum stack space
2045 allocations for outgoing arguments.
2047 The ABI also mandates minimum stack alignments which we must
2049 cum_bytes_aligned
= DEPRECATED_STACK_ALIGN (cum_bytes_reserved
);
2050 sp
+= max (cum_bytes_aligned
, REG_PARM_STACK_SPACE
);
2052 /* Now write each of the args at the proper offset down the stack.
2053 ?!? We need to promote values to a full register instead of skipping
2054 words in the stack. */
2055 for (i
= 0; i
< nargs
; i
++)
2056 write_memory (sp
- offset
[i
], VALUE_CONTENTS (args
[i
]), lengths
[i
]);
2058 /* If a structure has to be returned, set up register 28 to hold its
2061 write_register (28, struct_addr
);
2063 /* The stack will have 32 bytes of additional space for a frame marker. */
2069 /* elz: Used to lookup a symbol in the shared libraries.
2070 This function calls shl_findsym, indirectly through a
2071 call to __d_shl_get. __d_shl_get is in end.c, which is always
2072 linked in by the hp compilers/linkers.
2073 The call to shl_findsym cannot be made directly because it needs
2074 to be active in target address space.
2075 inputs: - minimal symbol pointer for the function we want to look up
2076 - address in target space of the descriptor for the library
2077 where we want to look the symbol up.
2078 This address is retrieved using the
2079 som_solib_get_solib_by_pc function (somsolib.c).
2080 output: - real address in the library of the function.
2081 note: the handle can be null, in which case shl_findsym will look for
2082 the symbol in all the loaded shared libraries.
2083 files to look at if you need reference on this stuff:
2084 dld.c, dld_shl_findsym.c
2086 man entry for shl_findsym */
2089 find_stub_with_shl_get (struct minimal_symbol
*function
, CORE_ADDR handle
)
2091 struct symbol
*get_sym
, *symbol2
;
2092 struct minimal_symbol
*buff_minsym
, *msymbol
;
2094 struct value
**args
;
2095 struct value
*funcval
;
2098 int x
, namelen
, err_value
, tmp
= -1;
2099 CORE_ADDR endo_buff_addr
, value_return_addr
, errno_return_addr
;
2100 CORE_ADDR stub_addr
;
2103 args
= alloca (sizeof (struct value
*) * 8); /* 6 for the arguments and one null one??? */
2104 funcval
= find_function_in_inferior ("__d_shl_get");
2105 get_sym
= lookup_symbol ("__d_shl_get", NULL
, VAR_DOMAIN
, NULL
, NULL
);
2106 buff_minsym
= lookup_minimal_symbol ("__buffer", NULL
, NULL
);
2107 msymbol
= lookup_minimal_symbol ("__shldp", NULL
, NULL
);
2108 symbol2
= lookup_symbol ("__shldp", NULL
, VAR_DOMAIN
, NULL
, NULL
);
2109 endo_buff_addr
= SYMBOL_VALUE_ADDRESS (buff_minsym
);
2110 namelen
= strlen (DEPRECATED_SYMBOL_NAME (function
));
2111 value_return_addr
= endo_buff_addr
+ namelen
;
2112 ftype
= check_typedef (SYMBOL_TYPE (get_sym
));
2115 if ((x
= value_return_addr
% 64) != 0)
2116 value_return_addr
= value_return_addr
+ 64 - x
;
2118 errno_return_addr
= value_return_addr
+ 64;
2121 /* set up stuff needed by __d_shl_get in buffer in end.o */
2123 target_write_memory (endo_buff_addr
, DEPRECATED_SYMBOL_NAME (function
), namelen
);
2125 target_write_memory (value_return_addr
, (char *) &tmp
, 4);
2127 target_write_memory (errno_return_addr
, (char *) &tmp
, 4);
2129 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol
),
2130 (char *) &handle
, 4);
2132 /* now prepare the arguments for the call */
2134 args
[0] = value_from_longest (TYPE_FIELD_TYPE (ftype
, 0), 12);
2135 args
[1] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 1), SYMBOL_VALUE_ADDRESS (msymbol
));
2136 args
[2] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 2), endo_buff_addr
);
2137 args
[3] = value_from_longest (TYPE_FIELD_TYPE (ftype
, 3), TYPE_PROCEDURE
);
2138 args
[4] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 4), value_return_addr
);
2139 args
[5] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 5), errno_return_addr
);
2141 /* now call the function */
2143 val
= call_function_by_hand (funcval
, 6, args
);
2145 /* now get the results */
2147 target_read_memory (errno_return_addr
, (char *) &err_value
, sizeof (err_value
));
2149 target_read_memory (value_return_addr
, (char *) &stub_addr
, sizeof (stub_addr
));
2151 error ("call to __d_shl_get failed, error code is %d", err_value
);
2156 /* Cover routine for find_stub_with_shl_get to pass to catch_errors */
2158 cover_find_stub_with_shl_get (void *args_untyped
)
2160 args_for_find_stub
*args
= args_untyped
;
2161 args
->return_val
= find_stub_with_shl_get (args
->msym
, args
->solib_handle
);
2165 /* Insert the specified number of args and function address
2166 into a call sequence of the above form stored at DUMMYNAME.
2168 On the hppa we need to call the stack dummy through $$dyncall.
2169 Therefore our version of DEPRECATED_FIX_CALL_DUMMY takes an extra
2170 argument, real_pc, which is the location where gdb should start up
2171 the inferior to do the function call.
2173 This has to work across several versions of hpux, bsd, osf1. It has to
2174 work regardless of what compiler was used to build the inferior program.
2175 It should work regardless of whether or not end.o is available. It has
2176 to work even if gdb can not call into the dynamic loader in the inferior
2177 to query it for symbol names and addresses.
2179 Yes, all those cases should work. Luckily code exists to handle most
2180 of them. The complexity is in selecting exactly what scheme should
2181 be used to perform the inferior call.
2183 At the current time this routine is known not to handle cases where
2184 the program was linked with HP's compiler without including end.o.
2186 Please contact Jeff Law (law@cygnus.com) before changing this code. */
2189 hppa_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
2190 struct value
**args
, struct type
*type
, int gcc_p
)
2192 CORE_ADDR dyncall_addr
;
2193 struct minimal_symbol
*msymbol
;
2194 struct minimal_symbol
*trampoline
;
2195 int flags
= read_register (FLAGS_REGNUM
);
2196 struct unwind_table_entry
*u
= NULL
;
2197 CORE_ADDR new_stub
= 0;
2198 CORE_ADDR solib_handle
= 0;
2200 /* Nonzero if we will use GCC's PLT call routine. This routine must be
2201 passed an import stub, not a PLABEL. It is also necessary to set %r19
2202 (the PIC register) before performing the call.
2204 If zero, then we are using __d_plt_call (HP's PLT call routine) or we
2205 are calling the target directly. When using __d_plt_call we want to
2206 use a PLABEL instead of an import stub. */
2207 int using_gcc_plt_call
= 1;
2209 #ifdef GDB_TARGET_IS_HPPA_20W
2210 /* We currently use completely different code for the PA2.0W inferior
2211 function call sequences. This needs to be cleaned up. */
2213 CORE_ADDR pcsqh
, pcsqt
, pcoqh
, pcoqt
, sr5
;
2214 struct target_waitstatus w
;
2218 struct objfile
*objfile
;
2220 /* We can not modify the PC space queues directly, so we start
2221 up the inferior and execute a couple instructions to set the
2222 space queues so that they point to the call dummy in the stack. */
2223 pcsqh
= read_register (PCSQ_HEAD_REGNUM
);
2224 sr5
= read_register (SR5_REGNUM
);
2227 pcoqh
= read_register (PCOQ_HEAD_REGNUM
);
2228 pcoqt
= read_register (PCOQ_TAIL_REGNUM
);
2229 if (target_read_memory (pcoqh
, buf
, 4) != 0)
2230 error ("Couldn't modify space queue\n");
2231 inst1
= extract_unsigned_integer (buf
, 4);
2233 if (target_read_memory (pcoqt
, buf
, 4) != 0)
2234 error ("Couldn't modify space queue\n");
2235 inst2
= extract_unsigned_integer (buf
, 4);
2238 *((int *) buf
) = 0xe820d000;
2239 if (target_write_memory (pcoqh
, buf
, 4) != 0)
2240 error ("Couldn't modify space queue\n");
2243 *((int *) buf
) = 0x08000240;
2244 if (target_write_memory (pcoqt
, buf
, 4) != 0)
2246 *((int *) buf
) = inst1
;
2247 target_write_memory (pcoqh
, buf
, 4);
2248 error ("Couldn't modify space queue\n");
2251 write_register (1, pc
);
2253 /* Single step twice, the BVE instruction will set the space queue
2254 such that it points to the PC value written immediately above
2255 (ie the call dummy). */
2257 target_wait (inferior_ptid
, &w
);
2259 target_wait (inferior_ptid
, &w
);
2261 /* Restore the two instructions at the old PC locations. */
2262 *((int *) buf
) = inst1
;
2263 target_write_memory (pcoqh
, buf
, 4);
2264 *((int *) buf
) = inst2
;
2265 target_write_memory (pcoqt
, buf
, 4);
2268 /* The call dummy wants the ultimate destination address initially
2270 write_register (5, fun
);
2272 /* We need to see if this objfile has a different DP value than our
2273 own (it could be a shared library for example). */
2274 ALL_OBJFILES (objfile
)
2276 struct obj_section
*s
;
2277 obj_private_data_t
*obj_private
;
2279 /* See if FUN is in any section within this shared library. */
2280 for (s
= objfile
->sections
; s
< objfile
->sections_end
; s
++)
2281 if (s
->addr
<= fun
&& fun
< s
->endaddr
)
2284 if (s
>= objfile
->sections_end
)
2287 obj_private
= (obj_private_data_t
*) objfile
->obj_private
;
2289 /* The DP value may be different for each objfile. But within an
2290 objfile each function uses the same dp value. Thus we do not need
2291 to grope around the opd section looking for dp values.
2293 ?!? This is not strictly correct since we may be in a shared library
2294 and want to call back into the main program. To make that case
2295 work correctly we need to set obj_private->dp for the main program's
2296 objfile, then remove this conditional. */
2297 if (obj_private
->dp
)
2298 write_register (27, obj_private
->dp
);
2305 #ifndef GDB_TARGET_IS_HPPA_20W
2306 /* Prefer __gcc_plt_call over the HP supplied routine because
2307 __gcc_plt_call works for any number of arguments. */
2309 if (lookup_minimal_symbol ("__gcc_plt_call", NULL
, NULL
) == NULL
)
2310 using_gcc_plt_call
= 0;
2312 msymbol
= lookup_minimal_symbol ("$$dyncall", NULL
, NULL
);
2313 if (msymbol
== NULL
)
2314 error ("Can't find an address for $$dyncall trampoline");
2316 dyncall_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
2318 /* FUN could be a procedure label, in which case we have to get
2319 its real address and the value of its GOT/DP if we plan to
2320 call the routine via gcc_plt_call. */
2321 if ((fun
& 0x2) && using_gcc_plt_call
)
2323 /* Get the GOT/DP value for the target function. It's
2324 at *(fun+4). Note the call dummy is *NOT* allowed to
2325 trash %r19 before calling the target function. */
2326 write_register (19, read_memory_integer ((fun
& ~0x3) + 4,
2327 DEPRECATED_REGISTER_SIZE
));
2329 /* Now get the real address for the function we are calling, it's
2331 fun
= (CORE_ADDR
) read_memory_integer (fun
& ~0x3,
2332 TARGET_PTR_BIT
/ 8);
2337 #ifndef GDB_TARGET_IS_PA_ELF
2338 /* FUN could be an export stub, the real address of a function, or
2339 a PLABEL. When using gcc's PLT call routine we must call an import
2340 stub rather than the export stub or real function for lazy binding
2343 If we are using the gcc PLT call routine, then we need to
2344 get the import stub for the target function. */
2345 if (using_gcc_plt_call
&& som_solib_get_got_by_pc (fun
))
2347 struct objfile
*objfile
;
2348 struct minimal_symbol
*funsymbol
, *stub_symbol
;
2349 CORE_ADDR newfun
= 0;
2351 funsymbol
= lookup_minimal_symbol_by_pc (fun
);
2353 error ("Unable to find minimal symbol for target function.\n");
2355 /* Search all the object files for an import symbol with the
2357 ALL_OBJFILES (objfile
)
2360 = lookup_minimal_symbol_solib_trampoline
2361 (DEPRECATED_SYMBOL_NAME (funsymbol
), objfile
);
2364 stub_symbol
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (funsymbol
),
2367 /* Found a symbol with the right name. */
2370 struct unwind_table_entry
*u
;
2371 /* It must be a shared library trampoline. */
2372 if (MSYMBOL_TYPE (stub_symbol
) != mst_solib_trampoline
)
2375 /* It must also be an import stub. */
2376 u
= find_unwind_entry (SYMBOL_VALUE (stub_symbol
));
2378 || (u
->stub_unwind
.stub_type
!= IMPORT
2379 #ifdef GDB_NATIVE_HPUX_11
2380 /* Sigh. The hpux 10.20 dynamic linker will blow
2381 chunks if we perform a call to an unbound function
2382 via the IMPORT_SHLIB stub. The hpux 11.00 dynamic
2383 linker will blow chunks if we do not call the
2384 unbound function via the IMPORT_SHLIB stub.
2386 We currently have no way to select bevahior on just
2387 the target. However, we only support HPUX/SOM in
2388 native mode. So we conditinalize on a native
2389 #ifdef. Ugly. Ugly. Ugly */
2390 && u
->stub_unwind
.stub_type
!= IMPORT_SHLIB
2395 /* OK. Looks like the correct import stub. */
2396 newfun
= SYMBOL_VALUE (stub_symbol
);
2399 /* If we found an IMPORT stub, then we want to stop
2400 searching now. If we found an IMPORT_SHLIB, we want
2401 to continue the search in the hopes that we will find
2403 if (u
->stub_unwind
.stub_type
== IMPORT
)
2408 /* Ouch. We did not find an import stub. Make an attempt to
2409 do the right thing instead of just croaking. Most of the
2410 time this will actually work. */
2412 write_register (19, som_solib_get_got_by_pc (fun
));
2414 u
= find_unwind_entry (fun
);
2416 && (u
->stub_unwind
.stub_type
== IMPORT
2417 || u
->stub_unwind
.stub_type
== IMPORT_SHLIB
))
2418 trampoline
= lookup_minimal_symbol ("__gcc_plt_call", NULL
, NULL
);
2420 /* If we found the import stub in the shared library, then we have
2421 to set %r19 before we call the stub. */
2422 if (u
&& u
->stub_unwind
.stub_type
== IMPORT_SHLIB
)
2423 write_register (19, som_solib_get_got_by_pc (fun
));
2428 /* If we are calling into another load module then have sr4export call the
2429 magic __d_plt_call routine which is linked in from end.o.
2431 You can't use _sr4export to make the call as the value in sp-24 will get
2432 fried and you end up returning to the wrong location. You can't call the
2433 target as the code to bind the PLT entry to a function can't return to a
2436 Also, query the dynamic linker in the inferior to provide a suitable
2437 PLABEL for the target function. */
2438 if (!using_gcc_plt_call
)
2442 /* Get a handle for the shared library containing FUN. Given the
2443 handle we can query the shared library for a PLABEL. */
2444 solib_handle
= som_solib_get_solib_by_pc (fun
);
2448 struct minimal_symbol
*fmsymbol
= lookup_minimal_symbol_by_pc (fun
);
2450 trampoline
= lookup_minimal_symbol ("__d_plt_call", NULL
, NULL
);
2452 if (trampoline
== NULL
)
2454 error ("Can't find an address for __d_plt_call or __gcc_plt_call trampoline\nSuggest linking executable with -g or compiling with gcc.");
2457 /* This is where sr4export will jump to. */
2458 new_fun
= SYMBOL_VALUE_ADDRESS (trampoline
);
2460 /* If the function is in a shared library, then call __d_shl_get to
2461 get a PLABEL for the target function. */
2462 new_stub
= find_stub_with_shl_get (fmsymbol
, solib_handle
);
2465 error ("Can't find an import stub for %s", DEPRECATED_SYMBOL_NAME (fmsymbol
));
2467 /* We have to store the address of the stub in __shlib_funcptr. */
2468 msymbol
= lookup_minimal_symbol ("__shlib_funcptr", NULL
,
2469 (struct objfile
*) NULL
);
2471 if (msymbol
== NULL
)
2472 error ("Can't find an address for __shlib_funcptr");
2473 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol
),
2474 (char *) &new_stub
, 4);
2476 /* We want sr4export to call __d_plt_call, so we claim it is
2477 the final target. Clear trampoline. */
2483 /* Store upper 21 bits of function address into ldil. fun will either be
2484 the final target (most cases) or __d_plt_call when calling into a shared
2485 library and __gcc_plt_call is not available. */
2486 store_unsigned_integer
2487 (&dummy
[FUNC_LDIL_OFFSET
],
2489 deposit_21 (fun
>> 11,
2490 extract_unsigned_integer (&dummy
[FUNC_LDIL_OFFSET
],
2491 INSTRUCTION_SIZE
)));
2493 /* Store lower 11 bits of function address into ldo */
2494 store_unsigned_integer
2495 (&dummy
[FUNC_LDO_OFFSET
],
2497 deposit_14 (fun
& MASK_11
,
2498 extract_unsigned_integer (&dummy
[FUNC_LDO_OFFSET
],
2499 INSTRUCTION_SIZE
)));
2500 #ifdef SR4EXPORT_LDIL_OFFSET
2503 CORE_ADDR trampoline_addr
;
2505 /* We may still need sr4export's address too. */
2507 if (trampoline
== NULL
)
2509 msymbol
= lookup_minimal_symbol ("_sr4export", NULL
, NULL
);
2510 if (msymbol
== NULL
)
2511 error ("Can't find an address for _sr4export trampoline");
2513 trampoline_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
2516 trampoline_addr
= SYMBOL_VALUE_ADDRESS (trampoline
);
2519 /* Store upper 21 bits of trampoline's address into ldil */
2520 store_unsigned_integer
2521 (&dummy
[SR4EXPORT_LDIL_OFFSET
],
2523 deposit_21 (trampoline_addr
>> 11,
2524 extract_unsigned_integer (&dummy
[SR4EXPORT_LDIL_OFFSET
],
2525 INSTRUCTION_SIZE
)));
2527 /* Store lower 11 bits of trampoline's address into ldo */
2528 store_unsigned_integer
2529 (&dummy
[SR4EXPORT_LDO_OFFSET
],
2531 deposit_14 (trampoline_addr
& MASK_11
,
2532 extract_unsigned_integer (&dummy
[SR4EXPORT_LDO_OFFSET
],
2533 INSTRUCTION_SIZE
)));
2537 write_register (22, pc
);
2539 /* If we are in a syscall, then we should call the stack dummy
2540 directly. $$dyncall is not needed as the kernel sets up the
2541 space id registers properly based on the value in %r31. In
2542 fact calling $$dyncall will not work because the value in %r22
2543 will be clobbered on the syscall exit path.
2545 Similarly if the current PC is in a shared library. Note however,
2546 this scheme won't work if the shared library isn't mapped into
2547 the same space as the stack. */
2550 #ifndef GDB_TARGET_IS_PA_ELF
2551 else if (som_solib_get_got_by_pc (hppa_target_read_pc (inferior_ptid
)))
2555 return dyncall_addr
;
2559 /* If the pid is in a syscall, then the FP register is not readable.
2560 We'll return zero in that case, rather than attempting to read it
2561 and cause a warning. */
2564 hppa_read_fp (int pid
)
2566 int flags
= read_register (FLAGS_REGNUM
);
2570 return (CORE_ADDR
) 0;
2573 /* This is the only site that may directly read_register () the FP
2574 register. All others must use deprecated_read_fp (). */
2575 return read_register (DEPRECATED_FP_REGNUM
);
2579 hppa_target_read_fp (void)
2581 return hppa_read_fp (PIDGET (inferior_ptid
));
2584 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
2588 hppa_target_read_pc (ptid_t ptid
)
2590 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
2592 /* The following test does not belong here. It is OS-specific, and belongs
2594 /* Test SS_INSYSCALL */
2596 return read_register_pid (31, ptid
) & ~0x3;
2598 return read_register_pid (PC_REGNUM
, ptid
) & ~0x3;
2601 /* Write out the PC. If currently in a syscall, then also write the new
2602 PC value into %r31. */
2605 hppa_target_write_pc (CORE_ADDR v
, ptid_t ptid
)
2607 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
2609 /* The following test does not belong here. It is OS-specific, and belongs
2611 /* If in a syscall, then set %r31. Also make sure to get the
2612 privilege bits set correctly. */
2613 /* Test SS_INSYSCALL */
2615 write_register_pid (31, v
| 0x3, ptid
);
2617 write_register_pid (PC_REGNUM
, v
, ptid
);
2618 write_register_pid (PCOQ_TAIL_REGNUM
, v
+ 4, ptid
);
2621 /* return the alignment of a type in bytes. Structures have the maximum
2622 alignment required by their fields. */
2625 hppa_alignof (struct type
*type
)
2627 int max_align
, align
, i
;
2628 CHECK_TYPEDEF (type
);
2629 switch (TYPE_CODE (type
))
2634 return TYPE_LENGTH (type
);
2635 case TYPE_CODE_ARRAY
:
2636 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
2637 case TYPE_CODE_STRUCT
:
2638 case TYPE_CODE_UNION
:
2640 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
2642 /* Bit fields have no real alignment. */
2643 /* if (!TYPE_FIELD_BITPOS (type, i)) */
2644 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
2646 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
2647 max_align
= max (max_align
, align
);
2656 /* Print the register regnum, or all registers if regnum is -1 */
2659 pa_do_registers_info (int regnum
, int fpregs
)
2661 char *raw_regs
= alloca (DEPRECATED_REGISTER_BYTES
);
2664 /* Make a copy of gdb's save area (may cause actual
2665 reads from the target). */
2666 for (i
= 0; i
< NUM_REGS
; i
++)
2667 frame_register_read (deprecated_selected_frame
, i
,
2668 raw_regs
+ DEPRECATED_REGISTER_BYTE (i
));
2671 pa_print_registers (raw_regs
, regnum
, fpregs
);
2672 else if (regnum
< FP4_REGNUM
)
2676 /* Why is the value not passed through "extract_signed_integer"
2677 as in "pa_print_registers" below? */
2678 pa_register_look_aside (raw_regs
, regnum
, ®_val
[0]);
2682 printf_unfiltered ("%s %lx\n", REGISTER_NAME (regnum
), reg_val
[1]);
2686 /* Fancy % formats to prevent leading zeros. */
2687 if (reg_val
[0] == 0)
2688 printf_unfiltered ("%s %lx\n", REGISTER_NAME (regnum
), reg_val
[1]);
2690 printf_unfiltered ("%s %lx%8.8lx\n", REGISTER_NAME (regnum
),
2691 reg_val
[0], reg_val
[1]);
2695 /* Note that real floating point values only start at
2696 FP4_REGNUM. FP0 and up are just status and error
2697 registers, which have integral (bit) values. */
2698 pa_print_fp_reg (regnum
);
2701 /********** new function ********************/
2703 pa_do_strcat_registers_info (int regnum
, int fpregs
, struct ui_file
*stream
,
2704 enum precision_type precision
)
2706 char *raw_regs
= alloca (DEPRECATED_REGISTER_BYTES
);
2709 /* Make a copy of gdb's save area (may cause actual
2710 reads from the target). */
2711 for (i
= 0; i
< NUM_REGS
; i
++)
2712 frame_register_read (deprecated_selected_frame
, i
,
2713 raw_regs
+ DEPRECATED_REGISTER_BYTE (i
));
2716 pa_strcat_registers (raw_regs
, regnum
, fpregs
, stream
);
2718 else if (regnum
< FP4_REGNUM
)
2722 /* Why is the value not passed through "extract_signed_integer"
2723 as in "pa_print_registers" below? */
2724 pa_register_look_aside (raw_regs
, regnum
, ®_val
[0]);
2728 fprintf_unfiltered (stream
, "%s %lx", REGISTER_NAME (regnum
), reg_val
[1]);
2732 /* Fancy % formats to prevent leading zeros. */
2733 if (reg_val
[0] == 0)
2734 fprintf_unfiltered (stream
, "%s %lx", REGISTER_NAME (regnum
),
2737 fprintf_unfiltered (stream
, "%s %lx%8.8lx", REGISTER_NAME (regnum
),
2738 reg_val
[0], reg_val
[1]);
2742 /* Note that real floating point values only start at
2743 FP4_REGNUM. FP0 and up are just status and error
2744 registers, which have integral (bit) values. */
2745 pa_strcat_fp_reg (regnum
, stream
, precision
);
2748 /* If this is a PA2.0 machine, fetch the real 64-bit register
2749 value. Otherwise use the info from gdb's saved register area.
2751 Note that reg_val is really expected to be an array of longs,
2752 with two elements. */
2754 pa_register_look_aside (char *raw_regs
, int regnum
, long *raw_val
)
2756 static int know_which
= 0; /* False */
2759 unsigned int offset
;
2764 char buf
[MAX_REGISTER_SIZE
];
2769 if (CPU_PA_RISC2_0
== sysconf (_SC_CPU_VERSION
))
2774 know_which
= 1; /* True */
2782 raw_val
[1] = *(long *) (raw_regs
+ DEPRECATED_REGISTER_BYTE (regnum
));
2786 /* Code below copied from hppah-nat.c, with fixes for wide
2787 registers, using different area of save_state, etc. */
2788 if (regnum
== FLAGS_REGNUM
|| regnum
>= FP0_REGNUM
||
2789 !HAVE_STRUCT_SAVE_STATE_T
|| !HAVE_STRUCT_MEMBER_SS_WIDE
)
2791 /* Use narrow regs area of save_state and default macro. */
2792 offset
= U_REGS_OFFSET
;
2793 regaddr
= register_addr (regnum
, offset
);
2798 /* Use wide regs area, and calculate registers as 8 bytes wide.
2800 We'd like to do this, but current version of "C" doesn't
2803 offset = offsetof(save_state_t, ss_wide);
2805 Note that to avoid "C" doing typed pointer arithmetic, we
2806 have to cast away the type in our offset calculation:
2807 otherwise we get an offset of 1! */
2809 /* NB: save_state_t is not available before HPUX 9.
2810 The ss_wide field is not available previous to HPUX 10.20,
2811 so to avoid compile-time warnings, we only compile this for
2812 PA 2.0 processors. This control path should only be followed
2813 if we're debugging a PA 2.0 processor, so this should not cause
2816 /* #if the following code out so that this file can still be
2817 compiled on older HPUX boxes (< 10.20) which don't have
2818 this structure/structure member. */
2819 #if HAVE_STRUCT_SAVE_STATE_T == 1 && HAVE_STRUCT_MEMBER_SS_WIDE == 1
2822 offset
= ((int) &temp
.ss_wide
) - ((int) &temp
);
2823 regaddr
= offset
+ regnum
* 8;
2828 for (i
= start
; i
< 2; i
++)
2831 raw_val
[i
] = call_ptrace (PT_RUREGS
, PIDGET (inferior_ptid
),
2832 (PTRACE_ARG3_TYPE
) regaddr
, 0);
2835 /* Warning, not error, in case we are attached; sometimes the
2836 kernel doesn't let us at the registers. */
2837 char *err
= safe_strerror (errno
);
2838 char *msg
= alloca (strlen (err
) + 128);
2839 sprintf (msg
, "reading register %s: %s", REGISTER_NAME (regnum
), err
);
2844 regaddr
+= sizeof (long);
2847 if (regnum
== PCOQ_HEAD_REGNUM
|| regnum
== PCOQ_TAIL_REGNUM
)
2848 raw_val
[1] &= ~0x3; /* I think we're masking out space bits */
2854 /* "Info all-reg" command */
2857 pa_print_registers (char *raw_regs
, int regnum
, int fpregs
)
2860 /* Alas, we are compiled so that "long long" is 32 bits */
2863 int rows
= 48, columns
= 2;
2865 for (i
= 0; i
< rows
; i
++)
2867 for (j
= 0; j
< columns
; j
++)
2869 /* We display registers in column-major order. */
2870 int regnum
= i
+ j
* rows
;
2872 /* Q: Why is the value passed through "extract_signed_integer",
2873 while above, in "pa_do_registers_info" it isn't?
2875 pa_register_look_aside (raw_regs
, regnum
, &raw_val
[0]);
2877 /* Even fancier % formats to prevent leading zeros
2878 and still maintain the output in columns. */
2881 /* Being big-endian, on this machine the low bits
2882 (the ones we want to look at) are in the second longword. */
2883 long_val
= extract_signed_integer (&raw_val
[1], 4);
2884 printf_filtered ("%10.10s: %8lx ",
2885 REGISTER_NAME (regnum
), long_val
);
2889 /* raw_val = extract_signed_integer(&raw_val, 8); */
2890 if (raw_val
[0] == 0)
2891 printf_filtered ("%10.10s: %8lx ",
2892 REGISTER_NAME (regnum
), raw_val
[1]);
2894 printf_filtered ("%10.10s: %8lx%8.8lx ",
2895 REGISTER_NAME (regnum
),
2896 raw_val
[0], raw_val
[1]);
2899 printf_unfiltered ("\n");
2903 for (i
= FP4_REGNUM
; i
< NUM_REGS
; i
++) /* FP4_REGNUM == 72 */
2904 pa_print_fp_reg (i
);
2907 /************* new function ******************/
2909 pa_strcat_registers (char *raw_regs
, int regnum
, int fpregs
,
2910 struct ui_file
*stream
)
2913 long raw_val
[2]; /* Alas, we are compiled so that "long long" is 32 bits */
2915 enum precision_type precision
;
2917 precision
= unspecified_precision
;
2919 for (i
= 0; i
< 18; i
++)
2921 for (j
= 0; j
< 4; j
++)
2923 /* Q: Why is the value passed through "extract_signed_integer",
2924 while above, in "pa_do_registers_info" it isn't?
2926 pa_register_look_aside (raw_regs
, i
+ (j
* 18), &raw_val
[0]);
2928 /* Even fancier % formats to prevent leading zeros
2929 and still maintain the output in columns. */
2932 /* Being big-endian, on this machine the low bits
2933 (the ones we want to look at) are in the second longword. */
2934 long_val
= extract_signed_integer (&raw_val
[1], 4);
2935 fprintf_filtered (stream
, "%8.8s: %8lx ",
2936 REGISTER_NAME (i
+ (j
* 18)), long_val
);
2940 /* raw_val = extract_signed_integer(&raw_val, 8); */
2941 if (raw_val
[0] == 0)
2942 fprintf_filtered (stream
, "%8.8s: %8lx ",
2943 REGISTER_NAME (i
+ (j
* 18)), raw_val
[1]);
2945 fprintf_filtered (stream
, "%8.8s: %8lx%8.8lx ",
2946 REGISTER_NAME (i
+ (j
* 18)), raw_val
[0],
2950 fprintf_unfiltered (stream
, "\n");
2954 for (i
= FP4_REGNUM
; i
< NUM_REGS
; i
++) /* FP4_REGNUM == 72 */
2955 pa_strcat_fp_reg (i
, stream
, precision
);
2959 pa_print_fp_reg (int i
)
2961 char raw_buffer
[MAX_REGISTER_SIZE
];
2962 char virtual_buffer
[MAX_REGISTER_SIZE
];
2964 /* Get 32bits of data. */
2965 frame_register_read (deprecated_selected_frame
, i
, raw_buffer
);
2967 /* Put it in the buffer. No conversions are ever necessary. */
2968 memcpy (virtual_buffer
, raw_buffer
, DEPRECATED_REGISTER_RAW_SIZE (i
));
2970 fputs_filtered (REGISTER_NAME (i
), gdb_stdout
);
2971 print_spaces_filtered (8 - strlen (REGISTER_NAME (i
)), gdb_stdout
);
2972 fputs_filtered ("(single precision) ", gdb_stdout
);
2974 val_print (DEPRECATED_REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0, gdb_stdout
, 0,
2975 1, 0, Val_pretty_default
);
2976 printf_filtered ("\n");
2978 /* If "i" is even, then this register can also be a double-precision
2979 FP register. Dump it out as such. */
2982 /* Get the data in raw format for the 2nd half. */
2983 frame_register_read (deprecated_selected_frame
, i
+ 1, raw_buffer
);
2985 /* Copy it into the appropriate part of the virtual buffer. */
2986 memcpy (virtual_buffer
+ DEPRECATED_REGISTER_RAW_SIZE (i
), raw_buffer
,
2987 DEPRECATED_REGISTER_RAW_SIZE (i
));
2989 /* Dump it as a double. */
2990 fputs_filtered (REGISTER_NAME (i
), gdb_stdout
);
2991 print_spaces_filtered (8 - strlen (REGISTER_NAME (i
)), gdb_stdout
);
2992 fputs_filtered ("(double precision) ", gdb_stdout
);
2994 val_print (builtin_type_double
, virtual_buffer
, 0, 0, gdb_stdout
, 0,
2995 1, 0, Val_pretty_default
);
2996 printf_filtered ("\n");
3000 /*************** new function ***********************/
3002 pa_strcat_fp_reg (int i
, struct ui_file
*stream
, enum precision_type precision
)
3004 char raw_buffer
[MAX_REGISTER_SIZE
];
3005 char virtual_buffer
[MAX_REGISTER_SIZE
];
3007 fputs_filtered (REGISTER_NAME (i
), stream
);
3008 print_spaces_filtered (8 - strlen (REGISTER_NAME (i
)), stream
);
3010 /* Get 32bits of data. */
3011 frame_register_read (deprecated_selected_frame
, i
, raw_buffer
);
3013 /* Put it in the buffer. No conversions are ever necessary. */
3014 memcpy (virtual_buffer
, raw_buffer
, DEPRECATED_REGISTER_RAW_SIZE (i
));
3016 if (precision
== double_precision
&& (i
% 2) == 0)
3019 char raw_buf
[MAX_REGISTER_SIZE
];
3021 /* Get the data in raw format for the 2nd half. */
3022 frame_register_read (deprecated_selected_frame
, i
+ 1, raw_buf
);
3024 /* Copy it into the appropriate part of the virtual buffer. */
3025 memcpy (virtual_buffer
+ DEPRECATED_REGISTER_RAW_SIZE (i
), raw_buf
,
3026 DEPRECATED_REGISTER_RAW_SIZE (i
));
3028 val_print (builtin_type_double
, virtual_buffer
, 0, 0, stream
, 0,
3029 1, 0, Val_pretty_default
);
3034 val_print (DEPRECATED_REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0, stream
, 0,
3035 1, 0, Val_pretty_default
);
3040 /* Return one if PC is in the call path of a trampoline, else return zero.
3042 Note we return one for *any* call trampoline (long-call, arg-reloc), not
3043 just shared library trampolines (import, export). */
3046 hppa_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
3048 struct minimal_symbol
*minsym
;
3049 struct unwind_table_entry
*u
;
3050 static CORE_ADDR dyncall
= 0;
3051 static CORE_ADDR sr4export
= 0;
3053 #ifdef GDB_TARGET_IS_HPPA_20W
3054 /* PA64 has a completely different stub/trampoline scheme. Is it
3055 better? Maybe. It's certainly harder to determine with any
3056 certainty that we are in a stub because we can not refer to the
3059 The heuristic is simple. Try to lookup the current PC value in th
3060 minimal symbol table. If that fails, then assume we are not in a
3063 Then see if the PC value falls within the section bounds for the
3064 section containing the minimal symbol we found in the first
3065 step. If it does, then assume we are not in a stub and return.
3067 Finally peek at the instructions to see if they look like a stub. */
3069 struct minimal_symbol
*minsym
;
3074 minsym
= lookup_minimal_symbol_by_pc (pc
);
3078 sec
= SYMBOL_BFD_SECTION (minsym
);
3080 if (bfd_get_section_vma (sec
->owner
, sec
) <= pc
3081 && pc
< (bfd_get_section_vma (sec
->owner
, sec
)
3082 + bfd_section_size (sec
->owner
, sec
)))
3085 /* We might be in a stub. Peek at the instructions. Stubs are 3
3086 instructions long. */
3087 insn
= read_memory_integer (pc
, 4);
3089 /* Find out where we think we are within the stub. */
3090 if ((insn
& 0xffffc00e) == 0x53610000)
3092 else if ((insn
& 0xffffffff) == 0xe820d000)
3094 else if ((insn
& 0xffffc00e) == 0x537b0000)
3099 /* Now verify each insn in the range looks like a stub instruction. */
3100 insn
= read_memory_integer (addr
, 4);
3101 if ((insn
& 0xffffc00e) != 0x53610000)
3104 /* Now verify each insn in the range looks like a stub instruction. */
3105 insn
= read_memory_integer (addr
+ 4, 4);
3106 if ((insn
& 0xffffffff) != 0xe820d000)
3109 /* Now verify each insn in the range looks like a stub instruction. */
3110 insn
= read_memory_integer (addr
+ 8, 4);
3111 if ((insn
& 0xffffc00e) != 0x537b0000)
3114 /* Looks like a stub. */
3119 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
3122 /* First see if PC is in one of the two C-library trampolines. */
3125 minsym
= lookup_minimal_symbol ("$$dyncall", NULL
, NULL
);
3127 dyncall
= SYMBOL_VALUE_ADDRESS (minsym
);
3134 minsym
= lookup_minimal_symbol ("_sr4export", NULL
, NULL
);
3136 sr4export
= SYMBOL_VALUE_ADDRESS (minsym
);
3141 if (pc
== dyncall
|| pc
== sr4export
)
3144 minsym
= lookup_minimal_symbol_by_pc (pc
);
3145 if (minsym
&& strcmp (DEPRECATED_SYMBOL_NAME (minsym
), ".stub") == 0)
3148 /* Get the unwind descriptor corresponding to PC, return zero
3149 if no unwind was found. */
3150 u
= find_unwind_entry (pc
);
3154 /* If this isn't a linker stub, then return now. */
3155 if (u
->stub_unwind
.stub_type
== 0)
3158 /* By definition a long-branch stub is a call stub. */
3159 if (u
->stub_unwind
.stub_type
== LONG_BRANCH
)
3162 /* The call and return path execute the same instructions within
3163 an IMPORT stub! So an IMPORT stub is both a call and return
3165 if (u
->stub_unwind
.stub_type
== IMPORT
)
3168 /* Parameter relocation stubs always have a call path and may have a
3170 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
3171 || u
->stub_unwind
.stub_type
== EXPORT
)
3175 /* Search forward from the current PC until we hit a branch
3176 or the end of the stub. */
3177 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
3181 insn
= read_memory_integer (addr
, 4);
3183 /* Does it look like a bl? If so then it's the call path, if
3184 we find a bv or be first, then we're on the return path. */
3185 if ((insn
& 0xfc00e000) == 0xe8000000)
3187 else if ((insn
& 0xfc00e001) == 0xe800c000
3188 || (insn
& 0xfc000000) == 0xe0000000)
3192 /* Should never happen. */
3193 warning ("Unable to find branch in parameter relocation stub.\n");
3197 /* Unknown stub type. For now, just return zero. */
3201 /* Return one if PC is in the return path of a trampoline, else return zero.
3203 Note we return one for *any* call trampoline (long-call, arg-reloc), not
3204 just shared library trampolines (import, export). */
3207 hppa_in_solib_return_trampoline (CORE_ADDR pc
, char *name
)
3209 struct unwind_table_entry
*u
;
3211 /* Get the unwind descriptor corresponding to PC, return zero
3212 if no unwind was found. */
3213 u
= find_unwind_entry (pc
);
3217 /* If this isn't a linker stub or it's just a long branch stub, then
3219 if (u
->stub_unwind
.stub_type
== 0 || u
->stub_unwind
.stub_type
== LONG_BRANCH
)
3222 /* The call and return path execute the same instructions within
3223 an IMPORT stub! So an IMPORT stub is both a call and return
3225 if (u
->stub_unwind
.stub_type
== IMPORT
)
3228 /* Parameter relocation stubs always have a call path and may have a
3230 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
3231 || u
->stub_unwind
.stub_type
== EXPORT
)
3235 /* Search forward from the current PC until we hit a branch
3236 or the end of the stub. */
3237 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
3241 insn
= read_memory_integer (addr
, 4);
3243 /* Does it look like a bl? If so then it's the call path, if
3244 we find a bv or be first, then we're on the return path. */
3245 if ((insn
& 0xfc00e000) == 0xe8000000)
3247 else if ((insn
& 0xfc00e001) == 0xe800c000
3248 || (insn
& 0xfc000000) == 0xe0000000)
3252 /* Should never happen. */
3253 warning ("Unable to find branch in parameter relocation stub.\n");
3257 /* Unknown stub type. For now, just return zero. */
3262 /* Figure out if PC is in a trampoline, and if so find out where
3263 the trampoline will jump to. If not in a trampoline, return zero.
3265 Simple code examination probably is not a good idea since the code
3266 sequences in trampolines can also appear in user code.
3268 We use unwinds and information from the minimal symbol table to
3269 determine when we're in a trampoline. This won't work for ELF
3270 (yet) since it doesn't create stub unwind entries. Whether or
3271 not ELF will create stub unwinds or normal unwinds for linker
3272 stubs is still being debated.
3274 This should handle simple calls through dyncall or sr4export,
3275 long calls, argument relocation stubs, and dyncall/sr4export
3276 calling an argument relocation stub. It even handles some stubs
3277 used in dynamic executables. */
3280 hppa_skip_trampoline_code (CORE_ADDR pc
)
3283 long prev_inst
, curr_inst
, loc
;
3284 static CORE_ADDR dyncall
= 0;
3285 static CORE_ADDR dyncall_external
= 0;
3286 static CORE_ADDR sr4export
= 0;
3287 struct minimal_symbol
*msym
;
3288 struct unwind_table_entry
*u
;
3290 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
3295 msym
= lookup_minimal_symbol ("$$dyncall", NULL
, NULL
);
3297 dyncall
= SYMBOL_VALUE_ADDRESS (msym
);
3302 if (!dyncall_external
)
3304 msym
= lookup_minimal_symbol ("$$dyncall_external", NULL
, NULL
);
3306 dyncall_external
= SYMBOL_VALUE_ADDRESS (msym
);
3308 dyncall_external
= -1;
3313 msym
= lookup_minimal_symbol ("_sr4export", NULL
, NULL
);
3315 sr4export
= SYMBOL_VALUE_ADDRESS (msym
);
3320 /* Addresses passed to dyncall may *NOT* be the actual address
3321 of the function. So we may have to do something special. */
3324 pc
= (CORE_ADDR
) read_register (22);
3326 /* If bit 30 (counting from the left) is on, then pc is the address of
3327 the PLT entry for this function, not the address of the function
3328 itself. Bit 31 has meaning too, but only for MPE. */
3330 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
3332 if (pc
== dyncall_external
)
3334 pc
= (CORE_ADDR
) read_register (22);
3335 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
3337 else if (pc
== sr4export
)
3338 pc
= (CORE_ADDR
) (read_register (22));
3340 /* Get the unwind descriptor corresponding to PC, return zero
3341 if no unwind was found. */
3342 u
= find_unwind_entry (pc
);
3346 /* If this isn't a linker stub, then return now. */
3347 /* elz: attention here! (FIXME) because of a compiler/linker
3348 error, some stubs which should have a non zero stub_unwind.stub_type
3349 have unfortunately a value of zero. So this function would return here
3350 as if we were not in a trampoline. To fix this, we go look at the partial
3351 symbol information, which reports this guy as a stub.
3352 (FIXME): Unfortunately, we are not that lucky: it turns out that the
3353 partial symbol information is also wrong sometimes. This is because
3354 when it is entered (somread.c::som_symtab_read()) it can happen that
3355 if the type of the symbol (from the som) is Entry, and the symbol is
3356 in a shared library, then it can also be a trampoline. This would
3357 be OK, except that I believe the way they decide if we are ina shared library
3358 does not work. SOOOO..., even if we have a regular function w/o trampolines
3359 its minimal symbol can be assigned type mst_solib_trampoline.
3360 Also, if we find that the symbol is a real stub, then we fix the unwind
3361 descriptor, and define the stub type to be EXPORT.
3362 Hopefully this is correct most of the times. */
3363 if (u
->stub_unwind
.stub_type
== 0)
3366 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
3367 we can delete all the code which appears between the lines */
3368 /*--------------------------------------------------------------------------*/
3369 msym
= lookup_minimal_symbol_by_pc (pc
);
3371 if (msym
== NULL
|| MSYMBOL_TYPE (msym
) != mst_solib_trampoline
)
3372 return orig_pc
== pc
? 0 : pc
& ~0x3;
3374 else if (msym
!= NULL
&& MSYMBOL_TYPE (msym
) == mst_solib_trampoline
)
3376 struct objfile
*objfile
;
3377 struct minimal_symbol
*msymbol
;
3378 int function_found
= 0;
3380 /* go look if there is another minimal symbol with the same name as
3381 this one, but with type mst_text. This would happen if the msym
3382 is an actual trampoline, in which case there would be another
3383 symbol with the same name corresponding to the real function */
3385 ALL_MSYMBOLS (objfile
, msymbol
)
3387 if (MSYMBOL_TYPE (msymbol
) == mst_text
3388 && DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (msymbol
), DEPRECATED_SYMBOL_NAME (msym
)))
3396 /* the type of msym is correct (mst_solib_trampoline), but
3397 the unwind info is wrong, so set it to the correct value */
3398 u
->stub_unwind
.stub_type
= EXPORT
;
3400 /* the stub type info in the unwind is correct (this is not a
3401 trampoline), but the msym type information is wrong, it
3402 should be mst_text. So we need to fix the msym, and also
3403 get out of this function */
3405 MSYMBOL_TYPE (msym
) = mst_text
;
3406 return orig_pc
== pc
? 0 : pc
& ~0x3;
3410 /*--------------------------------------------------------------------------*/
3413 /* It's a stub. Search for a branch and figure out where it goes.
3414 Note we have to handle multi insn branch sequences like ldil;ble.
3415 Most (all?) other branches can be determined by examining the contents
3416 of certain registers and the stack. */
3423 /* Make sure we haven't walked outside the range of this stub. */
3424 if (u
!= find_unwind_entry (loc
))
3426 warning ("Unable to find branch in linker stub");
3427 return orig_pc
== pc
? 0 : pc
& ~0x3;
3430 prev_inst
= curr_inst
;
3431 curr_inst
= read_memory_integer (loc
, 4);
3433 /* Does it look like a branch external using %r1? Then it's the
3434 branch from the stub to the actual function. */
3435 if ((curr_inst
& 0xffe0e000) == 0xe0202000)
3437 /* Yup. See if the previous instruction loaded
3438 a value into %r1. If so compute and return the jump address. */
3439 if ((prev_inst
& 0xffe00000) == 0x20200000)
3440 return (extract_21 (prev_inst
) + extract_17 (curr_inst
)) & ~0x3;
3443 warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
3444 return orig_pc
== pc
? 0 : pc
& ~0x3;
3448 /* Does it look like a be 0(sr0,%r21)? OR
3449 Does it look like a be, n 0(sr0,%r21)? OR
3450 Does it look like a bve (r21)? (this is on PA2.0)
3451 Does it look like a bve, n(r21)? (this is also on PA2.0)
3452 That's the branch from an
3453 import stub to an export stub.
3455 It is impossible to determine the target of the branch via
3456 simple examination of instructions and/or data (consider
3457 that the address in the plabel may be the address of the
3458 bind-on-reference routine in the dynamic loader).
3460 So we have try an alternative approach.
3462 Get the name of the symbol at our current location; it should
3463 be a stub symbol with the same name as the symbol in the
3466 Then lookup a minimal symbol with the same name; we should
3467 get the minimal symbol for the target routine in the shared
3468 library as those take precedence of import/export stubs. */
3469 if ((curr_inst
== 0xe2a00000) ||
3470 (curr_inst
== 0xe2a00002) ||
3471 (curr_inst
== 0xeaa0d000) ||
3472 (curr_inst
== 0xeaa0d002))
3474 struct minimal_symbol
*stubsym
, *libsym
;
3476 stubsym
= lookup_minimal_symbol_by_pc (loc
);
3477 if (stubsym
== NULL
)
3479 warning ("Unable to find symbol for 0x%lx", loc
);
3480 return orig_pc
== pc
? 0 : pc
& ~0x3;
3483 libsym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym
), NULL
, NULL
);
3486 warning ("Unable to find library symbol for %s\n",
3487 DEPRECATED_SYMBOL_NAME (stubsym
));
3488 return orig_pc
== pc
? 0 : pc
& ~0x3;
3491 return SYMBOL_VALUE (libsym
);
3494 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
3495 branch from the stub to the actual function. */
3497 else if ((curr_inst
& 0xffe0e000) == 0xe8400000
3498 || (curr_inst
& 0xffe0e000) == 0xe8000000
3499 || (curr_inst
& 0xffe0e000) == 0xe800A000)
3500 return (loc
+ extract_17 (curr_inst
) + 8) & ~0x3;
3502 /* Does it look like bv (rp)? Note this depends on the
3503 current stack pointer being the same as the stack
3504 pointer in the stub itself! This is a branch on from the
3505 stub back to the original caller. */
3506 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
3507 else if ((curr_inst
& 0xffe0f000) == 0xe840c000)
3509 /* Yup. See if the previous instruction loaded
3511 if (prev_inst
== 0x4bc23ff1)
3512 return (read_memory_integer
3513 (read_register (SP_REGNUM
) - 8, 4)) & ~0x3;
3516 warning ("Unable to find restore of %%rp before bv (%%rp).");
3517 return orig_pc
== pc
? 0 : pc
& ~0x3;
3521 /* elz: added this case to capture the new instruction
3522 at the end of the return part of an export stub used by
3523 the PA2.0: BVE, n (rp) */
3524 else if ((curr_inst
& 0xffe0f000) == 0xe840d000)
3526 return (read_memory_integer
3527 (read_register (SP_REGNUM
) - 24, TARGET_PTR_BIT
/ 8)) & ~0x3;
3530 /* What about be,n 0(sr0,%rp)? It's just another way we return to
3531 the original caller from the stub. Used in dynamic executables. */
3532 else if (curr_inst
== 0xe0400002)
3534 /* The value we jump to is sitting in sp - 24. But that's
3535 loaded several instructions before the be instruction.
3536 I guess we could check for the previous instruction being
3537 mtsp %r1,%sr0 if we want to do sanity checking. */
3538 return (read_memory_integer
3539 (read_register (SP_REGNUM
) - 24, TARGET_PTR_BIT
/ 8)) & ~0x3;
3542 /* Haven't found the branch yet, but we're still in the stub.
3549 /* For the given instruction (INST), return any adjustment it makes
3550 to the stack pointer or zero for no adjustment.
3552 This only handles instructions commonly found in prologues. */
3555 prologue_inst_adjust_sp (unsigned long inst
)
3557 /* This must persist across calls. */
3558 static int save_high21
;
3560 /* The most common way to perform a stack adjustment ldo X(sp),sp */
3561 if ((inst
& 0xffffc000) == 0x37de0000)
3562 return extract_14 (inst
);
3565 if ((inst
& 0xffe00000) == 0x6fc00000)
3566 return extract_14 (inst
);
3568 /* std,ma X,D(sp) */
3569 if ((inst
& 0xffe00008) == 0x73c00008)
3570 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
3572 /* addil high21,%r1; ldo low11,(%r1),%r30)
3573 save high bits in save_high21 for later use. */
3574 if ((inst
& 0xffe00000) == 0x28200000)
3576 save_high21
= extract_21 (inst
);
3580 if ((inst
& 0xffff0000) == 0x343e0000)
3581 return save_high21
+ extract_14 (inst
);
3583 /* fstws as used by the HP compilers. */
3584 if ((inst
& 0xffffffe0) == 0x2fd01220)
3585 return extract_5_load (inst
);
3587 /* No adjustment. */
3591 /* Return nonzero if INST is a branch of some kind, else return zero. */
3594 is_branch (unsigned long inst
)
3623 /* Return the register number for a GR which is saved by INST or
3624 zero it INST does not save a GR. */
3627 inst_saves_gr (unsigned long inst
)
3629 /* Does it look like a stw? */
3630 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
3631 || (inst
>> 26) == 0x1f
3632 || ((inst
>> 26) == 0x1f
3633 && ((inst
>> 6) == 0xa)))
3634 return extract_5R_store (inst
);
3636 /* Does it look like a std? */
3637 if ((inst
>> 26) == 0x1c
3638 || ((inst
>> 26) == 0x03
3639 && ((inst
>> 6) & 0xf) == 0xb))
3640 return extract_5R_store (inst
);
3642 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
3643 if ((inst
>> 26) == 0x1b)
3644 return extract_5R_store (inst
);
3646 /* Does it look like sth or stb? HPC versions 9.0 and later use these
3648 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
3649 || ((inst
>> 26) == 0x3
3650 && (((inst
>> 6) & 0xf) == 0x8
3651 || (inst
>> 6) & 0xf) == 0x9))
3652 return extract_5R_store (inst
);
3657 /* Return the register number for a FR which is saved by INST or
3658 zero it INST does not save a FR.
3660 Note we only care about full 64bit register stores (that's the only
3661 kind of stores the prologue will use).
3663 FIXME: What about argument stores with the HP compiler in ANSI mode? */
3666 inst_saves_fr (unsigned long inst
)
3668 /* is this an FSTD ? */
3669 if ((inst
& 0xfc00dfc0) == 0x2c001200)
3670 return extract_5r_store (inst
);
3671 if ((inst
& 0xfc000002) == 0x70000002)
3672 return extract_5R_store (inst
);
3673 /* is this an FSTW ? */
3674 if ((inst
& 0xfc00df80) == 0x24001200)
3675 return extract_5r_store (inst
);
3676 if ((inst
& 0xfc000002) == 0x7c000000)
3677 return extract_5R_store (inst
);
3681 /* Advance PC across any function entry prologue instructions
3682 to reach some "real" code.
3684 Use information in the unwind table to determine what exactly should
3685 be in the prologue. */
3689 skip_prologue_hard_way (CORE_ADDR pc
)
3692 CORE_ADDR orig_pc
= pc
;
3693 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
3694 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
3695 struct unwind_table_entry
*u
;
3701 u
= find_unwind_entry (pc
);
3705 /* If we are not at the beginning of a function, then return now. */
3706 if ((pc
& ~0x3) != u
->region_start
)
3709 /* This is how much of a frame adjustment we need to account for. */
3710 stack_remaining
= u
->Total_frame_size
<< 3;
3712 /* Magic register saves we want to know about. */
3713 save_rp
= u
->Save_RP
;
3714 save_sp
= u
->Save_SP
;
3716 /* An indication that args may be stored into the stack. Unfortunately
3717 the HPUX compilers tend to set this in cases where no args were
3721 /* Turn the Entry_GR field into a bitmask. */
3723 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
3725 /* Frame pointer gets saved into a special location. */
3726 if (u
->Save_SP
&& i
== DEPRECATED_FP_REGNUM
)
3729 save_gr
|= (1 << i
);
3731 save_gr
&= ~restart_gr
;
3733 /* Turn the Entry_FR field into a bitmask too. */
3735 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
3736 save_fr
|= (1 << i
);
3737 save_fr
&= ~restart_fr
;
3739 /* Loop until we find everything of interest or hit a branch.
3741 For unoptimized GCC code and for any HP CC code this will never ever
3742 examine any user instructions.
3744 For optimzied GCC code we're faced with problems. GCC will schedule
3745 its prologue and make prologue instructions available for delay slot
3746 filling. The end result is user code gets mixed in with the prologue
3747 and a prologue instruction may be in the delay slot of the first branch
3750 Some unexpected things are expected with debugging optimized code, so
3751 we allow this routine to walk past user instructions in optimized
3753 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
3756 unsigned int reg_num
;
3757 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
3758 unsigned long old_save_rp
, old_save_sp
, next_inst
;
3760 /* Save copies of all the triggers so we can compare them later
3762 old_save_gr
= save_gr
;
3763 old_save_fr
= save_fr
;
3764 old_save_rp
= save_rp
;
3765 old_save_sp
= save_sp
;
3766 old_stack_remaining
= stack_remaining
;
3768 status
= target_read_memory (pc
, buf
, 4);
3769 inst
= extract_unsigned_integer (buf
, 4);
3775 /* Note the interesting effects of this instruction. */
3776 stack_remaining
-= prologue_inst_adjust_sp (inst
);
3778 /* There are limited ways to store the return pointer into the
3780 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
3783 /* These are the only ways we save SP into the stack. At this time
3784 the HP compilers never bother to save SP into the stack. */
3785 if ((inst
& 0xffffc000) == 0x6fc10000
3786 || (inst
& 0xffffc00c) == 0x73c10008)
3789 /* Are we loading some register with an offset from the argument
3791 if ((inst
& 0xffe00000) == 0x37a00000
3792 || (inst
& 0xffffffe0) == 0x081d0240)
3798 /* Account for general and floating-point register saves. */
3799 reg_num
= inst_saves_gr (inst
);
3800 save_gr
&= ~(1 << reg_num
);
3802 /* Ugh. Also account for argument stores into the stack.
3803 Unfortunately args_stored only tells us that some arguments
3804 where stored into the stack. Not how many or what kind!
3806 This is a kludge as on the HP compiler sets this bit and it
3807 never does prologue scheduling. So once we see one, skip past
3808 all of them. We have similar code for the fp arg stores below.
3810 FIXME. Can still die if we have a mix of GR and FR argument
3812 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
3814 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
3817 status
= target_read_memory (pc
, buf
, 4);
3818 inst
= extract_unsigned_integer (buf
, 4);
3821 reg_num
= inst_saves_gr (inst
);
3827 reg_num
= inst_saves_fr (inst
);
3828 save_fr
&= ~(1 << reg_num
);
3830 status
= target_read_memory (pc
+ 4, buf
, 4);
3831 next_inst
= extract_unsigned_integer (buf
, 4);
3837 /* We've got to be read to handle the ldo before the fp register
3839 if ((inst
& 0xfc000000) == 0x34000000
3840 && inst_saves_fr (next_inst
) >= 4
3841 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
3843 /* So we drop into the code below in a reasonable state. */
3844 reg_num
= inst_saves_fr (next_inst
);
3848 /* Ugh. Also account for argument stores into the stack.
3849 This is a kludge as on the HP compiler sets this bit and it
3850 never does prologue scheduling. So once we see one, skip past
3852 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
3854 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
3857 status
= target_read_memory (pc
, buf
, 4);
3858 inst
= extract_unsigned_integer (buf
, 4);
3861 if ((inst
& 0xfc000000) != 0x34000000)
3863 status
= target_read_memory (pc
+ 4, buf
, 4);
3864 next_inst
= extract_unsigned_integer (buf
, 4);
3867 reg_num
= inst_saves_fr (next_inst
);
3873 /* Quit if we hit any kind of branch. This can happen if a prologue
3874 instruction is in the delay slot of the first call/branch. */
3875 if (is_branch (inst
))
3878 /* What a crock. The HP compilers set args_stored even if no
3879 arguments were stored into the stack (boo hiss). This could
3880 cause this code to then skip a bunch of user insns (up to the
3883 To combat this we try to identify when args_stored was bogusly
3884 set and clear it. We only do this when args_stored is nonzero,
3885 all other resources are accounted for, and nothing changed on
3888 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
3889 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
3890 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
3891 && old_stack_remaining
== stack_remaining
)
3898 /* We've got a tenative location for the end of the prologue. However
3899 because of limitations in the unwind descriptor mechanism we may
3900 have went too far into user code looking for the save of a register
3901 that does not exist. So, if there registers we expected to be saved
3902 but never were, mask them out and restart.
3904 This should only happen in optimized code, and should be very rare. */
3905 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
3908 restart_gr
= save_gr
;
3909 restart_fr
= save_fr
;
3917 /* Return the address of the PC after the last prologue instruction if
3918 we can determine it from the debug symbols. Else return zero. */
3921 after_prologue (CORE_ADDR pc
)
3923 struct symtab_and_line sal
;
3924 CORE_ADDR func_addr
, func_end
;
3927 /* If we can not find the symbol in the partial symbol table, then
3928 there is no hope we can determine the function's start address
3930 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
3933 /* Get the line associated with FUNC_ADDR. */
3934 sal
= find_pc_line (func_addr
, 0);
3936 /* There are only two cases to consider. First, the end of the source line
3937 is within the function bounds. In that case we return the end of the
3938 source line. Second is the end of the source line extends beyond the
3939 bounds of the current function. We need to use the slow code to
3940 examine instructions in that case.
3942 Anything else is simply a bug elsewhere. Fixing it here is absolutely
3943 the wrong thing to do. In fact, it should be entirely possible for this
3944 function to always return zero since the slow instruction scanning code
3945 is supposed to *always* work. If it does not, then it is a bug. */
3946 if (sal
.end
< func_end
)
3952 /* To skip prologues, I use this predicate. Returns either PC itself
3953 if the code at PC does not look like a function prologue; otherwise
3954 returns an address that (if we're lucky) follows the prologue. If
3955 LENIENT, then we must skip everything which is involved in setting
3956 up the frame (it's OK to skip more, just so long as we don't skip
3957 anything which might clobber the registers which are being saved.
3958 Currently we must not skip more on the alpha, but we might the lenient
3962 hppa_skip_prologue (CORE_ADDR pc
)
3966 CORE_ADDR post_prologue_pc
;
3969 /* See if we can determine the end of the prologue via the symbol table.
3970 If so, then return either PC, or the PC after the prologue, whichever
3973 post_prologue_pc
= after_prologue (pc
);
3975 /* If after_prologue returned a useful address, then use it. Else
3976 fall back on the instruction skipping code.
3978 Some folks have claimed this causes problems because the breakpoint
3979 may be the first instruction of the prologue. If that happens, then
3980 the instruction skipping code has a bug that needs to be fixed. */
3981 if (post_prologue_pc
!= 0)
3982 return max (pc
, post_prologue_pc
);
3984 return (skip_prologue_hard_way (pc
));
3987 /* Put here the code to store, into the SAVED_REGS, the addresses of
3988 the saved registers of frame described by FRAME_INFO. This
3989 includes special registers such as pc and fp saved in special ways
3990 in the stack frame. sp is even more special: the address we return
3991 for it IS the sp for the next frame. */
3994 hppa_frame_find_saved_regs (struct frame_info
*frame_info
,
3995 CORE_ADDR frame_saved_regs
[])
3998 struct unwind_table_entry
*u
;
3999 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
4003 int final_iteration
;
4005 /* Zero out everything. */
4006 memset (frame_saved_regs
, '\0', SIZEOF_FRAME_SAVED_REGS
);
4008 /* Call dummy frames always look the same, so there's no need to
4009 examine the dummy code to determine locations of saved registers;
4010 instead, let find_dummy_frame_regs fill in the correct offsets
4011 for the saved registers. */
4012 if ((get_frame_pc (frame_info
) >= get_frame_base (frame_info
)
4013 && (get_frame_pc (frame_info
)
4014 <= (get_frame_base (frame_info
)
4015 /* A call dummy is sized in words, but it is actually a
4016 series of instructions. Account for that scaling
4018 + ((DEPRECATED_REGISTER_SIZE
/ INSTRUCTION_SIZE
)
4019 * DEPRECATED_CALL_DUMMY_LENGTH
)
4020 /* Similarly we have to account for 64bit wide register
4022 + (32 * DEPRECATED_REGISTER_SIZE
)
4023 /* We always consider FP regs 8 bytes long. */
4024 + (NUM_REGS
- FP0_REGNUM
) * 8
4025 /* Similarly we have to account for 64bit wide register
4027 + (6 * DEPRECATED_REGISTER_SIZE
)))))
4028 find_dummy_frame_regs (frame_info
, frame_saved_regs
);
4030 /* Interrupt handlers are special too. They lay out the register
4031 state in the exact same order as the register numbers in GDB. */
4032 if (pc_in_interrupt_handler (get_frame_pc (frame_info
)))
4034 for (i
= 0; i
< NUM_REGS
; i
++)
4036 /* SP is a little special. */
4038 frame_saved_regs
[SP_REGNUM
]
4039 = read_memory_integer (get_frame_base (frame_info
) + SP_REGNUM
* 4,
4040 TARGET_PTR_BIT
/ 8);
4042 frame_saved_regs
[i
] = get_frame_base (frame_info
) + i
* 4;
4047 #ifdef FRAME_FIND_SAVED_REGS_IN_SIGTRAMP
4048 /* Handle signal handler callers. */
4049 if ((get_frame_type (frame_info
) == SIGTRAMP_FRAME
))
4051 FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info
, frame_saved_regs
);
4056 /* Get the starting address of the function referred to by the PC
4058 pc
= get_frame_func (frame_info
);
4061 u
= find_unwind_entry (pc
);
4065 /* This is how much of a frame adjustment we need to account for. */
4066 stack_remaining
= u
->Total_frame_size
<< 3;
4068 /* Magic register saves we want to know about. */
4069 save_rp
= u
->Save_RP
;
4070 save_sp
= u
->Save_SP
;
4072 /* Turn the Entry_GR field into a bitmask. */
4074 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
4076 /* Frame pointer gets saved into a special location. */
4077 if (u
->Save_SP
&& i
== DEPRECATED_FP_REGNUM
)
4080 save_gr
|= (1 << i
);
4083 /* Turn the Entry_FR field into a bitmask too. */
4085 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
4086 save_fr
|= (1 << i
);
4088 /* The frame always represents the value of %sp at entry to the
4089 current function (and is thus equivalent to the "saved" stack
4091 frame_saved_regs
[SP_REGNUM
] = get_frame_base (frame_info
);
4093 /* Loop until we find everything of interest or hit a branch.
4095 For unoptimized GCC code and for any HP CC code this will never ever
4096 examine any user instructions.
4098 For optimized GCC code we're faced with problems. GCC will schedule
4099 its prologue and make prologue instructions available for delay slot
4100 filling. The end result is user code gets mixed in with the prologue
4101 and a prologue instruction may be in the delay slot of the first branch
4104 Some unexpected things are expected with debugging optimized code, so
4105 we allow this routine to walk past user instructions in optimized
4107 final_iteration
= 0;
4108 while ((save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
4109 && pc
<= get_frame_pc (frame_info
))
4111 status
= target_read_memory (pc
, buf
, 4);
4112 inst
= extract_unsigned_integer (buf
, 4);
4118 /* Note the interesting effects of this instruction. */
4119 stack_remaining
-= prologue_inst_adjust_sp (inst
);
4121 /* There are limited ways to store the return pointer into the
4123 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
4126 frame_saved_regs
[RP_REGNUM
] = get_frame_base (frame_info
) - 20;
4128 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
4131 frame_saved_regs
[RP_REGNUM
] = get_frame_base (frame_info
) - 16;
4134 /* Note if we saved SP into the stack. This also happens to indicate
4135 the location of the saved frame pointer. */
4136 if ( (inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
4137 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
4139 frame_saved_regs
[DEPRECATED_FP_REGNUM
] = get_frame_base (frame_info
);
4143 /* Account for general and floating-point register saves. */
4144 reg
= inst_saves_gr (inst
);
4145 if (reg
>= 3 && reg
<= 18
4146 && (!u
->Save_SP
|| reg
!= DEPRECATED_FP_REGNUM
))
4148 save_gr
&= ~(1 << reg
);
4150 /* stwm with a positive displacement is a *post modify*. */
4151 if ((inst
>> 26) == 0x1b
4152 && extract_14 (inst
) >= 0)
4153 frame_saved_regs
[reg
] = get_frame_base (frame_info
);
4154 /* A std has explicit post_modify forms. */
4155 else if ((inst
& 0xfc00000c) == 0x70000008)
4156 frame_saved_regs
[reg
] = get_frame_base (frame_info
);
4161 if ((inst
>> 26) == 0x1c)
4162 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
4163 else if ((inst
>> 26) == 0x03)
4164 offset
= low_sign_extend (inst
& 0x1f, 5);
4166 offset
= extract_14 (inst
);
4168 /* Handle code with and without frame pointers. */
4170 frame_saved_regs
[reg
]
4171 = get_frame_base (frame_info
) + offset
;
4173 frame_saved_regs
[reg
]
4174 = (get_frame_base (frame_info
) + (u
->Total_frame_size
<< 3)
4180 /* GCC handles callee saved FP regs a little differently.
4182 It emits an instruction to put the value of the start of
4183 the FP store area into %r1. It then uses fstds,ma with
4184 a basereg of %r1 for the stores.
4186 HP CC emits them at the current stack pointer modifying
4187 the stack pointer as it stores each register. */
4189 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
4190 if ((inst
& 0xffffc000) == 0x34610000
4191 || (inst
& 0xffffc000) == 0x37c10000)
4192 fp_loc
= extract_14 (inst
);
4194 reg
= inst_saves_fr (inst
);
4195 if (reg
>= 12 && reg
<= 21)
4197 /* Note +4 braindamage below is necessary because the FP status
4198 registers are internally 8 registers rather than the expected
4200 save_fr
&= ~(1 << reg
);
4203 /* 1st HP CC FP register store. After this instruction
4204 we've set enough state that the GCC and HPCC code are
4205 both handled in the same manner. */
4206 frame_saved_regs
[reg
+ FP4_REGNUM
+ 4] = get_frame_base (frame_info
);
4211 frame_saved_regs
[reg
+ FP0_REGNUM
+ 4]
4212 = get_frame_base (frame_info
) + fp_loc
;
4217 /* Quit if we hit any kind of branch the previous iteration. */
4218 if (final_iteration
)
4221 /* We want to look precisely one instruction beyond the branch
4222 if we have not found everything yet. */
4223 if (is_branch (inst
))
4224 final_iteration
= 1;
4231 /* XXX - deprecated. This is a compatibility function for targets
4232 that do not yet implement DEPRECATED_FRAME_INIT_SAVED_REGS. */
4233 /* Find the addresses in which registers are saved in FRAME. */
4236 hppa_frame_init_saved_regs (struct frame_info
*frame
)
4238 if (deprecated_get_frame_saved_regs (frame
) == NULL
)
4239 frame_saved_regs_zalloc (frame
);
4240 hppa_frame_find_saved_regs (frame
, deprecated_get_frame_saved_regs (frame
));
4243 struct hppa_frame_cache
4246 struct trad_frame_saved_reg
*saved_regs
;
4249 static struct hppa_frame_cache
*
4250 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
4252 struct hppa_frame_cache
*cache
;
4257 struct unwind_table_entry
*u
;
4260 if ((*this_cache
) != NULL
)
4261 return (*this_cache
);
4262 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
4263 (*this_cache
) = cache
;
4264 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
4267 u
= find_unwind_entry (frame_func_unwind (next_frame
));
4271 /* Turn the Entry_GR field into a bitmask. */
4273 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
4275 /* Frame pointer gets saved into a special location. */
4276 if (u
->Save_SP
&& i
== DEPRECATED_FP_REGNUM
)
4279 saved_gr_mask
|= (1 << i
);
4282 /* Turn the Entry_FR field into a bitmask too. */
4284 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
4285 saved_fr_mask
|= (1 << i
);
4287 /* Loop until we find everything of interest or hit a branch.
4289 For unoptimized GCC code and for any HP CC code this will never ever
4290 examine any user instructions.
4292 For optimized GCC code we're faced with problems. GCC will schedule
4293 its prologue and make prologue instructions available for delay slot
4294 filling. The end result is user code gets mixed in with the prologue
4295 and a prologue instruction may be in the delay slot of the first branch
4298 Some unexpected things are expected with debugging optimized code, so
4299 we allow this routine to walk past user instructions in optimized
4302 int final_iteration
= 0;
4304 CORE_ADDR end_pc
= skip_prologue_using_sal (pc
);
4305 int looking_for_sp
= u
->Save_SP
;
4306 int looking_for_rp
= u
->Save_RP
;
4309 end_pc
= frame_pc_unwind (next_frame
);
4311 for (pc
= frame_func_unwind (next_frame
);
4312 ((saved_gr_mask
|| saved_fr_mask
4313 || looking_for_sp
|| looking_for_rp
4314 || frame_size
< (u
->Total_frame_size
<< 3))
4320 long status
= target_read_memory (pc
, buf4
, sizeof buf4
);
4321 long inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
4323 /* Note the interesting effects of this instruction. */
4324 frame_size
+= prologue_inst_adjust_sp (inst
);
4326 /* There are limited ways to store the return pointer into the
4328 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
4331 cache
->saved_regs
[RP_REGNUM
].addr
= -20;
4333 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
4336 cache
->saved_regs
[RP_REGNUM
].addr
= -16;
4339 /* Check to see if we saved SP into the stack. This also
4340 happens to indicate the location of the saved frame
4342 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
4343 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
4346 cache
->saved_regs
[DEPRECATED_FP_REGNUM
].addr
= 0;
4349 /* Account for general and floating-point register saves. */
4350 reg
= inst_saves_gr (inst
);
4351 if (reg
>= 3 && reg
<= 18
4352 && (!u
->Save_SP
|| reg
!= DEPRECATED_FP_REGNUM
))
4354 saved_gr_mask
&= ~(1 << reg
);
4355 if ((inst
>> 26) == 0x1b && extract_14 (inst
) >= 0)
4356 /* stwm with a positive displacement is a _post_
4358 cache
->saved_regs
[reg
].addr
= 0;
4359 else if ((inst
& 0xfc00000c) == 0x70000008)
4360 /* A std has explicit post_modify forms. */
4361 cache
->saved_regs
[reg
].addr
= 0;
4366 if ((inst
>> 26) == 0x1c)
4367 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
4368 else if ((inst
>> 26) == 0x03)
4369 offset
= low_sign_extend (inst
& 0x1f, 5);
4371 offset
= extract_14 (inst
);
4373 /* Handle code with and without frame pointers. */
4375 cache
->saved_regs
[reg
].addr
= offset
;
4377 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
4381 /* GCC handles callee saved FP regs a little differently.
4383 It emits an instruction to put the value of the start of
4384 the FP store area into %r1. It then uses fstds,ma with a
4385 basereg of %r1 for the stores.
4387 HP CC emits them at the current stack pointer modifying the
4388 stack pointer as it stores each register. */
4390 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
4391 if ((inst
& 0xffffc000) == 0x34610000
4392 || (inst
& 0xffffc000) == 0x37c10000)
4393 fp_loc
= extract_14 (inst
);
4395 reg
= inst_saves_fr (inst
);
4396 if (reg
>= 12 && reg
<= 21)
4398 /* Note +4 braindamage below is necessary because the FP
4399 status registers are internally 8 registers rather than
4400 the expected 4 registers. */
4401 saved_fr_mask
&= ~(1 << reg
);
4404 /* 1st HP CC FP register store. After this
4405 instruction we've set enough state that the GCC and
4406 HPCC code are both handled in the same manner. */
4407 cache
->saved_regs
[reg
+ FP4_REGNUM
+ 4].addr
= 0;
4412 cache
->saved_regs
[reg
+ FP0_REGNUM
+ 4].addr
= fp_loc
;
4417 /* Quit if we hit any kind of branch the previous iteration. */
4418 if (final_iteration
)
4420 /* We want to look precisely one instruction beyond the branch
4421 if we have not found everything yet. */
4422 if (is_branch (inst
))
4423 final_iteration
= 1;
4428 /* The frame base always represents the value of %sp at entry to
4429 the current function (and is thus equivalent to the "saved"
4431 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, SP_REGNUM
);
4432 /* FIXME: cagney/2004-02-22: This assumes that the frame has been
4433 created. If it hasn't everything will be out-of-wack. */
4434 if (u
->Save_SP
&& trad_frame_addr_p (cache
->saved_regs
, SP_REGNUM
))
4435 /* Both we're expecting the SP to be saved and the SP has been
4436 saved. The entry SP value is saved at this frame's SP
4438 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
4440 /* The prologue has been slowly allocating stack space. Adjust
4442 cache
->base
= this_sp
- frame_size
;
4443 trad_frame_set_value (cache
->saved_regs
, SP_REGNUM
, cache
->base
);
4446 /* The PC is found in the "return register". */
4448 cache
->saved_regs
[PC_REGNUM
] = cache
->saved_regs
[31];
4450 cache
->saved_regs
[PC_REGNUM
] = cache
->saved_regs
[RP_REGNUM
];
4453 /* Convert all the offsets into addresses. */
4455 for (reg
= 0; reg
< NUM_REGS
; reg
++)
4457 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
4458 cache
->saved_regs
[reg
].addr
+= cache
->base
;
4462 return (*this_cache
);
4466 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
4467 struct frame_id
*this_id
)
4469 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
4470 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
4474 hppa_frame_prev_register (struct frame_info
*next_frame
,
4476 int regnum
, int *optimizedp
,
4477 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
4478 int *realnump
, void *valuep
)
4480 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
4481 trad_frame_prev_register (next_frame
, info
->saved_regs
, regnum
,
4482 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
4485 static const struct frame_unwind hppa_frame_unwind
=
4489 hppa_frame_prev_register
4492 static const struct frame_unwind
*
4493 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
4495 return &hppa_frame_unwind
;
4499 hppa_frame_base_address (struct frame_info
*next_frame
,
4502 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
,
4507 static const struct frame_base hppa_frame_base
= {
4509 hppa_frame_base_address
,
4510 hppa_frame_base_address
,
4511 hppa_frame_base_address
4514 static const struct frame_base
*
4515 hppa_frame_base_sniffer (struct frame_info
*next_frame
)
4517 return &hppa_frame_base
;
4520 static struct frame_id
4521 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
4523 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
4525 frame_pc_unwind (next_frame
));
4529 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
4531 return frame_unwind_register_signed (next_frame
, PC_REGNUM
) & ~3;
4534 /* Exception handling support for the HP-UX ANSI C++ compiler.
4535 The compiler (aCC) provides a callback for exception events;
4536 GDB can set a breakpoint on this callback and find out what
4537 exception event has occurred. */
4539 /* The name of the hook to be set to point to the callback function */
4540 static char HP_ACC_EH_notify_hook
[] = "__eh_notify_hook";
4541 /* The name of the function to be used to set the hook value */
4542 static char HP_ACC_EH_set_hook_value
[] = "__eh_set_hook_value";
4543 /* The name of the callback function in end.o */
4544 static char HP_ACC_EH_notify_callback
[] = "__d_eh_notify_callback";
4545 /* Name of function in end.o on which a break is set (called by above) */
4546 static char HP_ACC_EH_break
[] = "__d_eh_break";
4547 /* Name of flag (in end.o) that enables catching throws */
4548 static char HP_ACC_EH_catch_throw
[] = "__d_eh_catch_throw";
4549 /* Name of flag (in end.o) that enables catching catching */
4550 static char HP_ACC_EH_catch_catch
[] = "__d_eh_catch_catch";
4551 /* The enum used by aCC */
4559 /* Is exception-handling support available with this executable? */
4560 static int hp_cxx_exception_support
= 0;
4561 /* Has the initialize function been run? */
4562 int hp_cxx_exception_support_initialized
= 0;
4563 /* Similar to above, but imported from breakpoint.c -- non-target-specific */
4564 extern int exception_support_initialized
;
4565 /* Address of __eh_notify_hook */
4566 static CORE_ADDR eh_notify_hook_addr
= 0;
4567 /* Address of __d_eh_notify_callback */
4568 static CORE_ADDR eh_notify_callback_addr
= 0;
4569 /* Address of __d_eh_break */
4570 static CORE_ADDR eh_break_addr
= 0;
4571 /* Address of __d_eh_catch_catch */
4572 static CORE_ADDR eh_catch_catch_addr
= 0;
4573 /* Address of __d_eh_catch_throw */
4574 static CORE_ADDR eh_catch_throw_addr
= 0;
4575 /* Sal for __d_eh_break */
4576 static struct symtab_and_line
*break_callback_sal
= 0;
4578 /* Code in end.c expects __d_pid to be set in the inferior,
4579 otherwise __d_eh_notify_callback doesn't bother to call
4580 __d_eh_break! So we poke the pid into this symbol
4585 setup_d_pid_in_inferior (void)
4588 struct minimal_symbol
*msymbol
;
4589 char buf
[4]; /* FIXME 32x64? */
4591 /* Slam the pid of the process into __d_pid; failing is only a warning! */
4592 msymbol
= lookup_minimal_symbol ("__d_pid", NULL
, symfile_objfile
);
4593 if (msymbol
== NULL
)
4595 warning ("Unable to find __d_pid symbol in object file.");
4596 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4600 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
4601 store_unsigned_integer (buf
, 4, PIDGET (inferior_ptid
)); /* FIXME 32x64? */
4602 if (target_write_memory (anaddr
, buf
, 4)) /* FIXME 32x64? */
4604 warning ("Unable to write __d_pid");
4605 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4611 /* Initialize exception catchpoint support by looking for the
4612 necessary hooks/callbacks in end.o, etc., and set the hook value to
4613 point to the required debug function
4619 initialize_hp_cxx_exception_support (void)
4621 struct symtabs_and_lines sals
;
4622 struct cleanup
*old_chain
;
4623 struct cleanup
*canonical_strings_chain
= NULL
;
4626 char *addr_end
= NULL
;
4627 char **canonical
= (char **) NULL
;
4629 struct symbol
*sym
= NULL
;
4630 struct minimal_symbol
*msym
= NULL
;
4631 struct objfile
*objfile
;
4632 asection
*shlib_info
;
4634 /* Detect and disallow recursion. On HP-UX with aCC, infinite
4635 recursion is a possibility because finding the hook for exception
4636 callbacks involves making a call in the inferior, which means
4637 re-inserting breakpoints which can re-invoke this code */
4639 static int recurse
= 0;
4642 hp_cxx_exception_support_initialized
= 0;
4643 exception_support_initialized
= 0;
4647 hp_cxx_exception_support
= 0;
4649 /* First check if we have seen any HP compiled objects; if not,
4650 it is very unlikely that HP's idiosyncratic callback mechanism
4651 for exception handling debug support will be available!
4652 This will percolate back up to breakpoint.c, where our callers
4653 will decide to try the g++ exception-handling support instead. */
4654 if (!hp_som_som_object_present
)
4657 /* We have a SOM executable with SOM debug info; find the hooks */
4659 /* First look for the notify hook provided by aCC runtime libs */
4660 /* If we find this symbol, we conclude that the executable must
4661 have HP aCC exception support built in. If this symbol is not
4662 found, even though we're a HP SOM-SOM file, we may have been
4663 built with some other compiler (not aCC). This results percolates
4664 back up to our callers in breakpoint.c which can decide to
4665 try the g++ style of exception support instead.
4666 If this symbol is found but the other symbols we require are
4667 not found, there is something weird going on, and g++ support
4668 should *not* be tried as an alternative.
4670 ASSUMPTION: Only HP aCC code will have __eh_notify_hook defined.
4671 ASSUMPTION: HP aCC and g++ modules cannot be linked together. */
4673 /* libCsup has this hook; it'll usually be non-debuggable */
4674 msym
= lookup_minimal_symbol (HP_ACC_EH_notify_hook
, NULL
, NULL
);
4677 eh_notify_hook_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4678 hp_cxx_exception_support
= 1;
4682 warning ("Unable to find exception callback hook (%s).", HP_ACC_EH_notify_hook
);
4683 warning ("Executable may not have been compiled debuggable with HP aCC.");
4684 warning ("GDB will be unable to intercept exception events.");
4685 eh_notify_hook_addr
= 0;
4686 hp_cxx_exception_support
= 0;
4690 /* Next look for the notify callback routine in end.o */
4691 /* This is always available in the SOM symbol dictionary if end.o is linked in */
4692 msym
= lookup_minimal_symbol (HP_ACC_EH_notify_callback
, NULL
, NULL
);
4695 eh_notify_callback_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4696 hp_cxx_exception_support
= 1;
4700 warning ("Unable to find exception callback routine (%s).", HP_ACC_EH_notify_callback
);
4701 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4702 warning ("GDB will be unable to intercept exception events.");
4703 eh_notify_callback_addr
= 0;
4707 #ifndef GDB_TARGET_IS_HPPA_20W
4708 /* Check whether the executable is dynamically linked or archive bound */
4709 /* With an archive-bound executable we can use the raw addresses we find
4710 for the callback function, etc. without modification. For an executable
4711 with shared libraries, we have to do more work to find the plabel, which
4712 can be the target of a call through $$dyncall from the aCC runtime support
4713 library (libCsup) which is linked shared by default by aCC. */
4714 /* This test below was copied from somsolib.c/somread.c. It may not be a very
4715 reliable one to test that an executable is linked shared. pai/1997-07-18 */
4716 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
4717 if (shlib_info
&& (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) != 0))
4719 /* The minsym we have has the local code address, but that's not the
4720 plabel that can be used by an inter-load-module call. */
4721 /* Find solib handle for main image (which has end.o), and use that
4722 and the min sym as arguments to __d_shl_get() (which does the equivalent
4723 of shl_findsym()) to find the plabel. */
4725 args_for_find_stub args
;
4726 static char message
[] = "Error while finding exception callback hook:\n";
4728 args
.solib_handle
= som_solib_get_solib_by_pc (eh_notify_callback_addr
);
4730 args
.return_val
= 0;
4733 catch_errors (cover_find_stub_with_shl_get
, &args
, message
,
4735 eh_notify_callback_addr
= args
.return_val
;
4738 exception_catchpoints_are_fragile
= 1;
4740 if (!eh_notify_callback_addr
)
4742 /* We can get here either if there is no plabel in the export list
4743 for the main image, or if something strange happened (?) */
4744 warning ("Couldn't find a plabel (indirect function label) for the exception callback.");
4745 warning ("GDB will not be able to intercept exception events.");
4750 exception_catchpoints_are_fragile
= 0;
4753 /* Now, look for the breakpointable routine in end.o */
4754 /* This should also be available in the SOM symbol dict. if end.o linked in */
4755 msym
= lookup_minimal_symbol (HP_ACC_EH_break
, NULL
, NULL
);
4758 eh_break_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4759 hp_cxx_exception_support
= 1;
4763 warning ("Unable to find exception callback routine to set breakpoint (%s).", HP_ACC_EH_break
);
4764 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4765 warning ("GDB will be unable to intercept exception events.");
4770 /* Next look for the catch enable flag provided in end.o */
4771 sym
= lookup_symbol (HP_ACC_EH_catch_catch
, (struct block
*) NULL
,
4772 VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
4773 if (sym
) /* sometimes present in debug info */
4775 eh_catch_catch_addr
= SYMBOL_VALUE_ADDRESS (sym
);
4776 hp_cxx_exception_support
= 1;
4779 /* otherwise look in SOM symbol dict. */
4781 msym
= lookup_minimal_symbol (HP_ACC_EH_catch_catch
, NULL
, NULL
);
4784 eh_catch_catch_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4785 hp_cxx_exception_support
= 1;
4789 warning ("Unable to enable interception of exception catches.");
4790 warning ("Executable may not have been compiled debuggable with HP aCC.");
4791 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4796 /* Next look for the catch enable flag provided end.o */
4797 sym
= lookup_symbol (HP_ACC_EH_catch_catch
, (struct block
*) NULL
,
4798 VAR_DOMAIN
, 0, (struct symtab
**) NULL
);
4799 if (sym
) /* sometimes present in debug info */
4801 eh_catch_throw_addr
= SYMBOL_VALUE_ADDRESS (sym
);
4802 hp_cxx_exception_support
= 1;
4805 /* otherwise look in SOM symbol dict. */
4807 msym
= lookup_minimal_symbol (HP_ACC_EH_catch_throw
, NULL
, NULL
);
4810 eh_catch_throw_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4811 hp_cxx_exception_support
= 1;
4815 warning ("Unable to enable interception of exception throws.");
4816 warning ("Executable may not have been compiled debuggable with HP aCC.");
4817 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4823 hp_cxx_exception_support
= 2; /* everything worked so far */
4824 hp_cxx_exception_support_initialized
= 1;
4825 exception_support_initialized
= 1;
4830 /* Target operation for enabling or disabling interception of
4832 KIND is either EX_EVENT_THROW or EX_EVENT_CATCH
4833 ENABLE is either 0 (disable) or 1 (enable).
4834 Return value is NULL if no support found;
4835 -1 if something went wrong,
4836 or a pointer to a symtab/line struct if the breakpointable
4837 address was found. */
4839 struct symtab_and_line
*
4840 child_enable_exception_callback (enum exception_event_kind kind
, int enable
)
4844 if (!exception_support_initialized
|| !hp_cxx_exception_support_initialized
)
4845 if (!initialize_hp_cxx_exception_support ())
4848 switch (hp_cxx_exception_support
)
4851 /* Assuming no HP support at all */
4854 /* HP support should be present, but something went wrong */
4855 return (struct symtab_and_line
*) -1; /* yuck! */
4856 /* there may be other cases in the future */
4859 /* Set the EH hook to point to the callback routine */
4860 store_unsigned_integer (buf
, 4, enable
? eh_notify_callback_addr
: 0); /* FIXME 32x64 problem */
4861 /* pai: (temp) FIXME should there be a pack operation first? */
4862 if (target_write_memory (eh_notify_hook_addr
, buf
, 4)) /* FIXME 32x64 problem */
4864 warning ("Could not write to target memory for exception event callback.");
4865 warning ("Interception of exception events may not work.");
4866 return (struct symtab_and_line
*) -1;
4870 /* Ensure that __d_pid is set up correctly -- end.c code checks this. :-( */
4871 if (PIDGET (inferior_ptid
) > 0)
4873 if (setup_d_pid_in_inferior ())
4874 return (struct symtab_and_line
*) -1;
4878 warning ("Internal error: Invalid inferior pid? Cannot intercept exception events.");
4879 return (struct symtab_and_line
*) -1;
4885 case EX_EVENT_THROW
:
4886 store_unsigned_integer (buf
, 4, enable
? 1 : 0);
4887 if (target_write_memory (eh_catch_throw_addr
, buf
, 4)) /* FIXME 32x64? */
4889 warning ("Couldn't enable exception throw interception.");
4890 return (struct symtab_and_line
*) -1;
4893 case EX_EVENT_CATCH
:
4894 store_unsigned_integer (buf
, 4, enable
? 1 : 0);
4895 if (target_write_memory (eh_catch_catch_addr
, buf
, 4)) /* FIXME 32x64? */
4897 warning ("Couldn't enable exception catch interception.");
4898 return (struct symtab_and_line
*) -1;
4902 error ("Request to enable unknown or unsupported exception event.");
4905 /* Copy break address into new sal struct, malloc'ing if needed. */
4906 if (!break_callback_sal
)
4908 break_callback_sal
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
4910 init_sal (break_callback_sal
);
4911 break_callback_sal
->symtab
= NULL
;
4912 break_callback_sal
->pc
= eh_break_addr
;
4913 break_callback_sal
->line
= 0;
4914 break_callback_sal
->end
= eh_break_addr
;
4916 return break_callback_sal
;
4919 /* Record some information about the current exception event */
4920 static struct exception_event_record current_ex_event
;
4921 /* Convenience struct */
4922 static struct symtab_and_line null_symtab_and_line
=
4925 /* Report current exception event. Returns a pointer to a record
4926 that describes the kind of the event, where it was thrown from,
4927 and where it will be caught. More information may be reported
4929 struct exception_event_record
*
4930 child_get_current_exception_event (void)
4932 CORE_ADDR event_kind
;
4933 CORE_ADDR throw_addr
;
4934 CORE_ADDR catch_addr
;
4935 struct frame_info
*fi
, *curr_frame
;
4938 curr_frame
= get_current_frame ();
4940 return (struct exception_event_record
*) NULL
;
4942 /* Go up one frame to __d_eh_notify_callback, because at the
4943 point when this code is executed, there's garbage in the
4944 arguments of __d_eh_break. */
4945 fi
= find_relative_frame (curr_frame
, &level
);
4947 return (struct exception_event_record
*) NULL
;
4951 /* Read in the arguments */
4952 /* __d_eh_notify_callback() is called with 3 arguments:
4953 1. event kind catch or throw
4954 2. the target address if known
4955 3. a flag -- not sure what this is. pai/1997-07-17 */
4956 event_kind
= read_register (ARG0_REGNUM
);
4957 catch_addr
= read_register (ARG1_REGNUM
);
4959 /* Now go down to a user frame */
4960 /* For a throw, __d_eh_break is called by
4961 __d_eh_notify_callback which is called by
4962 __notify_throw which is called
4964 For a catch, __d_eh_break is called by
4965 __d_eh_notify_callback which is called by
4966 <stackwalking stuff> which is called by
4967 __throw__<stuff> or __rethrow_<stuff> which is called
4969 /* FIXME: Don't use such magic numbers; search for the frames */
4970 level
= (event_kind
== EX_EVENT_THROW
) ? 3 : 4;
4971 fi
= find_relative_frame (curr_frame
, &level
);
4973 return (struct exception_event_record
*) NULL
;
4976 throw_addr
= get_frame_pc (fi
);
4978 /* Go back to original (top) frame */
4979 select_frame (curr_frame
);
4981 current_ex_event
.kind
= (enum exception_event_kind
) event_kind
;
4982 current_ex_event
.throw_sal
= find_pc_line (throw_addr
, 1);
4983 current_ex_event
.catch_sal
= find_pc_line (catch_addr
, 1);
4985 return ¤t_ex_event
;
4988 /* Instead of this nasty cast, add a method pvoid() that prints out a
4989 host VOID data type (remember %p isn't portable). */
4992 hppa_pointer_to_address_hack (void *ptr
)
4994 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
4995 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
4999 unwind_command (char *exp
, int from_tty
)
5002 struct unwind_table_entry
*u
;
5004 /* If we have an expression, evaluate it and use it as the address. */
5006 if (exp
!= 0 && *exp
!= 0)
5007 address
= parse_and_eval_address (exp
);
5011 u
= find_unwind_entry (address
);
5015 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
5019 printf_unfiltered ("unwind_table_entry (0x%s):\n",
5020 paddr_nz (hppa_pointer_to_address_hack (u
)));
5022 printf_unfiltered ("\tregion_start = ");
5023 print_address (u
->region_start
, gdb_stdout
);
5025 printf_unfiltered ("\n\tregion_end = ");
5026 print_address (u
->region_end
, gdb_stdout
);
5028 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
5030 printf_unfiltered ("\n\tflags =");
5031 pif (Cannot_unwind
);
5033 pif (Millicode_save_sr0
);
5036 pif (Variable_Frame
);
5037 pif (Separate_Package_Body
);
5038 pif (Frame_Extension_Millicode
);
5039 pif (Stack_Overflow_Check
);
5040 pif (Two_Instruction_SP_Increment
);
5044 pif (Save_MRP_in_frame
);
5045 pif (extn_ptr_defined
);
5046 pif (Cleanup_defined
);
5047 pif (MPE_XL_interrupt_marker
);
5048 pif (HP_UX_interrupt_marker
);
5051 putchar_unfiltered ('\n');
5053 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
5055 pin (Region_description
);
5058 pin (Total_frame_size
);
5062 hppa_skip_permanent_breakpoint (void)
5064 /* To step over a breakpoint instruction on the PA takes some
5065 fiddling with the instruction address queue.
5067 When we stop at a breakpoint, the IA queue front (the instruction
5068 we're executing now) points at the breakpoint instruction, and
5069 the IA queue back (the next instruction to execute) points to
5070 whatever instruction we would execute after the breakpoint, if it
5071 were an ordinary instruction. This is the case even if the
5072 breakpoint is in the delay slot of a branch instruction.
5074 Clearly, to step past the breakpoint, we need to set the queue
5075 front to the back. But what do we put in the back? What
5076 instruction comes after that one? Because of the branch delay
5077 slot, the next insn is always at the back + 4. */
5078 write_register (PCOQ_HEAD_REGNUM
, read_register (PCOQ_TAIL_REGNUM
));
5079 write_register (PCSQ_HEAD_REGNUM
, read_register (PCSQ_TAIL_REGNUM
));
5081 write_register (PCOQ_TAIL_REGNUM
, read_register (PCOQ_TAIL_REGNUM
) + 4);
5082 /* We can leave the tail's space the same, since there's no jump. */
5085 /* Copy the function value from VALBUF into the proper location
5086 for a function return.
5088 Called only in the context of the "return" command. */
5091 hppa32_store_return_value (struct type
*type
, char *valbuf
)
5093 /* For software floating point, the return value goes into the
5094 integer registers. But we do not have any flag to key this on,
5095 so we always store the value into the integer registers.
5097 If its a float value, then we also store it into the floating
5099 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (28)
5100 + (TYPE_LENGTH (type
) > 4
5101 ? (8 - TYPE_LENGTH (type
))
5102 : (4 - TYPE_LENGTH (type
))),
5103 valbuf
, TYPE_LENGTH (type
));
5104 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
5105 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP4_REGNUM
),
5106 valbuf
, TYPE_LENGTH (type
));
5109 /* Same as hppa32_store_return_value(), but for the PA64 ABI. */
5112 hppa64_store_return_value (struct type
*type
, char *valbuf
)
5114 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
5115 deprecated_write_register_bytes
5116 (DEPRECATED_REGISTER_BYTE (FP4_REGNUM
)
5117 + DEPRECATED_REGISTER_SIZE
- TYPE_LENGTH (type
),
5118 valbuf
, TYPE_LENGTH (type
));
5119 else if (is_integral_type(type
))
5120 deprecated_write_register_bytes
5121 (DEPRECATED_REGISTER_BYTE (28)
5122 + DEPRECATED_REGISTER_SIZE
- TYPE_LENGTH (type
),
5123 valbuf
, TYPE_LENGTH (type
));
5124 else if (TYPE_LENGTH (type
) <= 8)
5125 deprecated_write_register_bytes
5126 (DEPRECATED_REGISTER_BYTE (28),valbuf
, TYPE_LENGTH (type
));
5127 else if (TYPE_LENGTH (type
) <= 16)
5129 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (28),valbuf
, 8);
5130 deprecated_write_register_bytes
5131 (DEPRECATED_REGISTER_BYTE (29), valbuf
+ 8, TYPE_LENGTH (type
) - 8);
5135 /* Copy the function's return value into VALBUF.
5137 This function is called only in the context of "target function calls",
5138 ie. when the debugger forces a function to be called in the child, and
5139 when the debugger forces a fucntion to return prematurely via the
5140 "return" command. */
5143 hppa32_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
5145 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
5146 memcpy (valbuf
, regbuf
+ DEPRECATED_REGISTER_BYTE (FP4_REGNUM
), TYPE_LENGTH (type
));
5150 + DEPRECATED_REGISTER_BYTE (28)
5151 + (TYPE_LENGTH (type
) > 4
5152 ? (8 - TYPE_LENGTH (type
))
5153 : (4 - TYPE_LENGTH (type
)))),
5154 TYPE_LENGTH (type
));
5157 /* Same as hppa32_extract_return_value but for the PA64 ABI case. */
5160 hppa64_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
5162 /* RM: Floats are returned in FR4R, doubles in FR4.
5163 Integral values are in r28, padded on the left.
5164 Aggregates less that 65 bits are in r28, right padded.
5165 Aggregates upto 128 bits are in r28 and r29, right padded. */
5166 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
5168 regbuf
+ DEPRECATED_REGISTER_BYTE (FP4_REGNUM
)
5169 + DEPRECATED_REGISTER_SIZE
- TYPE_LENGTH (type
),
5170 TYPE_LENGTH (type
));
5171 else if (is_integral_type(type
))
5173 regbuf
+ DEPRECATED_REGISTER_BYTE (28)
5174 + DEPRECATED_REGISTER_SIZE
- TYPE_LENGTH (type
),
5175 TYPE_LENGTH (type
));
5176 else if (TYPE_LENGTH (type
) <= 8)
5177 memcpy (valbuf
, regbuf
+ DEPRECATED_REGISTER_BYTE (28),
5178 TYPE_LENGTH (type
));
5179 else if (TYPE_LENGTH (type
) <= 16)
5181 memcpy (valbuf
, regbuf
+ DEPRECATED_REGISTER_BYTE (28), 8);
5182 memcpy (valbuf
+ 8, regbuf
+ DEPRECATED_REGISTER_BYTE (29),
5183 TYPE_LENGTH (type
) - 8);
5188 hppa_reg_struct_has_addr (int gcc_p
, struct type
*type
)
5190 /* On the PA, any pass-by-value structure > 8 bytes is actually passed
5191 via a pointer regardless of its type or the compiler used. */
5192 return (TYPE_LENGTH (type
) > 8);
5196 hppa_inner_than (CORE_ADDR lhs
, CORE_ADDR rhs
)
5198 /* Stack grows upward */
5203 hppa32_stack_align (CORE_ADDR sp
)
5205 /* elz: adjust the quantity to the next highest value which is
5206 64-bit aligned. This is used in valops.c, when the sp is adjusted.
5207 On hppa the sp must always be kept 64-bit aligned */
5208 return ((sp
% 8) ? (sp
+ 7) & -8 : sp
);
5212 hppa64_stack_align (CORE_ADDR sp
)
5214 /* The PA64 ABI mandates a 16 byte stack alignment. */
5215 return ((sp
% 16) ? (sp
+ 15) & -16 : sp
);
5219 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
5221 /* Sometimes we may pluck out a minimal symbol that has a negative address.
5223 An example of this occurs when an a.out is linked against a foo.sl.
5224 The foo.sl defines a global bar(), and the a.out declares a signature
5225 for bar(). However, the a.out doesn't directly call bar(), but passes
5226 its address in another call.
5228 If you have this scenario and attempt to "break bar" before running,
5229 gdb will find a minimal symbol for bar() in the a.out. But that
5230 symbol's address will be negative. What this appears to denote is
5231 an index backwards from the base of the procedure linkage table (PLT)
5232 into the data linkage table (DLT), the end of which is contiguous
5233 with the start of the PLT. This is clearly not a valid address for
5234 us to set a breakpoint on.
5236 Note that one must be careful in how one checks for a negative address.
5237 0xc0000000 is a legitimate address of something in a shared text
5238 segment, for example. Since I don't know what the possible range
5239 is of these "really, truly negative" addresses that come from the
5240 minimal symbols, I'm resorting to the gross hack of checking the
5241 top byte of the address for all 1's. Sigh. */
5243 return (!target_has_stack
&& (pc
& 0xFF000000));
5247 hppa_instruction_nullified (void)
5249 /* brobecker 2002/11/07: Couldn't we use a ULONGEST here? It would
5250 avoid the type cast. I'm leaving it as is for now as I'm doing
5251 semi-mechanical multiarching-related changes. */
5252 const int ipsw
= (int) read_register (IPSW_REGNUM
);
5253 const int flags
= (int) read_register (FLAGS_REGNUM
);
5255 return ((ipsw
& 0x00200000) && !(flags
& 0x2));
5259 hppa_register_raw_size (int reg_nr
)
5261 /* All registers have the same size. */
5262 return DEPRECATED_REGISTER_SIZE
;
5265 /* Index within the register vector of the first byte of the space i
5266 used for register REG_NR. */
5269 hppa_register_byte (int reg_nr
)
5271 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
5273 return reg_nr
* tdep
->bytes_per_address
;
5276 /* Return the GDB type object for the "standard" data type of data
5280 hppa32_register_virtual_type (int reg_nr
)
5282 if (reg_nr
< FP4_REGNUM
)
5283 return builtin_type_int
;
5285 return builtin_type_float
;
5288 /* Return the GDB type object for the "standard" data type of data
5289 in register N. hppa64 version. */
5292 hppa64_register_virtual_type (int reg_nr
)
5294 if (reg_nr
< FP4_REGNUM
)
5295 return builtin_type_unsigned_long_long
;
5297 return builtin_type_double
;
5300 /* Store the address of the place in which to copy the structure the
5301 subroutine will return. This is called from call_function. */
5304 hppa_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
5306 write_register (28, addr
);
5308 /* Return True if REGNUM is not a register available to the user
5309 through ptrace(). */
5312 hppa_cannot_store_register (int regnum
)
5315 || regnum
== PCSQ_HEAD_REGNUM
5316 || (regnum
>= PCSQ_TAIL_REGNUM
&& regnum
< IPSW_REGNUM
)
5317 || (regnum
> IPSW_REGNUM
&& regnum
< FP4_REGNUM
));
5322 hppa_smash_text_address (CORE_ADDR addr
)
5324 /* The low two bits of the PC on the PA contain the privilege level.
5325 Some genius implementing a (non-GCC) compiler apparently decided
5326 this means that "addresses" in a text section therefore include a
5327 privilege level, and thus symbol tables should contain these bits.
5328 This seems like a bonehead thing to do--anyway, it seems to work
5329 for our purposes to just ignore those bits. */
5331 return (addr
&= ~0x3);
5334 /* Get the ith function argument for the current function. */
5336 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
5340 get_frame_register (frame
, R0_REGNUM
+ 26 - argi
, &addr
);
5344 /* Here is a table of C type sizes on hppa with various compiles
5345 and options. I measured this on PA 9000/800 with HP-UX 11.11
5346 and these compilers:
5348 /usr/ccs/bin/cc HP92453-01 A.11.01.21
5349 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
5350 /opt/aCC/bin/aCC B3910B A.03.45
5351 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
5353 cc : 1 2 4 4 8 : 4 8 -- : 4 4
5354 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
5355 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
5356 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
5357 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
5358 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
5359 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
5360 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
5364 compiler and options
5365 char, short, int, long, long long
5366 float, double, long double
5369 So all these compilers use either ILP32 or LP64 model.
5370 TODO: gcc has more options so it needs more investigation.
5372 For floating point types, see:
5374 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
5375 HP-UX floating-point guide, hpux 11.00
5377 -- chastain 2003-12-18 */
5379 static struct gdbarch
*
5380 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
5382 struct gdbarch_tdep
*tdep
;
5383 struct gdbarch
*gdbarch
;
5385 /* Try to determine the ABI of the object we are loading. */
5386 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
5388 /* If it's a SOM file, assume it's HP/UX SOM. */
5389 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
5390 info
.osabi
= GDB_OSABI_HPUX_SOM
;
5393 /* find a candidate among the list of pre-declared architectures. */
5394 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
5396 return (arches
->gdbarch
);
5398 /* If none found, then allocate and initialize one. */
5399 tdep
= XMALLOC (struct gdbarch_tdep
);
5400 gdbarch
= gdbarch_alloc (&info
, tdep
);
5402 /* Determine from the bfd_arch_info structure if we are dealing with
5403 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
5404 then default to a 32bit machine. */
5405 if (info
.bfd_arch_info
!= NULL
)
5406 tdep
->bytes_per_address
=
5407 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
5409 tdep
->bytes_per_address
= 4;
5411 /* Some parts of the gdbarch vector depend on whether we are running
5412 on a 32 bits or 64 bits target. */
5413 switch (tdep
->bytes_per_address
)
5416 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
5417 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
5418 set_gdbarch_deprecated_register_virtual_type
5419 (gdbarch
, hppa32_register_virtual_type
);
5422 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
5423 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
5424 set_gdbarch_deprecated_register_virtual_type
5425 (gdbarch
, hppa64_register_virtual_type
);
5428 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
5429 tdep
->bytes_per_address
);
5432 /* The following gdbarch vector elements depend on other parts of this
5433 vector which have been set above, depending on the ABI. */
5434 set_gdbarch_deprecated_register_bytes
5435 (gdbarch
, gdbarch_num_regs (gdbarch
) * tdep
->bytes_per_address
);
5436 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
5437 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
5439 /* The following gdbarch vector elements are the same in both ILP32
5440 and LP64, but might show differences some day. */
5441 set_gdbarch_long_long_bit (gdbarch
, 64);
5442 set_gdbarch_long_double_bit (gdbarch
, 128);
5443 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
5445 /* The following gdbarch vector elements do not depend on the address
5446 size, or in any other gdbarch element previously set. */
5447 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
5448 set_gdbarch_skip_trampoline_code (gdbarch
, hppa_skip_trampoline_code
);
5449 set_gdbarch_in_solib_call_trampoline (gdbarch
, hppa_in_solib_call_trampoline
);
5450 set_gdbarch_in_solib_return_trampoline (gdbarch
,
5451 hppa_in_solib_return_trampoline
);
5452 set_gdbarch_inner_than (gdbarch
, hppa_inner_than
);
5453 set_gdbarch_deprecated_register_size (gdbarch
, tdep
->bytes_per_address
);
5454 set_gdbarch_deprecated_fp_regnum (gdbarch
, 3);
5455 set_gdbarch_sp_regnum (gdbarch
, 30);
5456 set_gdbarch_fp0_regnum (gdbarch
, 64);
5457 set_gdbarch_pc_regnum (gdbarch
, PCOQ_HEAD_REGNUM
);
5458 set_gdbarch_deprecated_register_raw_size (gdbarch
, hppa_register_raw_size
);
5459 set_gdbarch_deprecated_register_byte (gdbarch
, hppa_register_byte
);
5460 set_gdbarch_deprecated_register_virtual_size (gdbarch
, hppa_register_raw_size
);
5461 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, tdep
->bytes_per_address
);
5462 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 8);
5463 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
5464 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
5465 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
5466 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
5467 set_gdbarch_read_pc (gdbarch
, hppa_target_read_pc
);
5468 set_gdbarch_write_pc (gdbarch
, hppa_target_write_pc
);
5469 set_gdbarch_deprecated_target_read_fp (gdbarch
, hppa_target_read_fp
);
5471 /* Helper for function argument information. */
5472 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
5474 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
5476 /* When a hardware watchpoint triggers, we'll move the inferior past
5477 it by removing all eventpoints; stepping past the instruction
5478 that caused the trigger; reinserting eventpoints; and checking
5479 whether any watched location changed. */
5480 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
5482 /* Inferior function call methods. */
5488 switch (tdep
->bytes_per_address
)
5491 set_gdbarch_deprecated_call_dummy_length (gdbarch
, hppa32_call_dummy_length
);
5492 set_gdbarch_deprecated_stack_align (gdbarch
, hppa32_stack_align
);
5493 set_gdbarch_deprecated_reg_struct_has_addr (gdbarch
, hppa_reg_struct_has_addr
);
5494 set_gdbarch_deprecated_extract_return_value (gdbarch
, hppa32_extract_return_value
);
5495 set_gdbarch_use_struct_convention (gdbarch
, hppa32_use_struct_convention
);
5496 set_gdbarch_deprecated_store_return_value (gdbarch
, hppa32_store_return_value
);
5499 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch
, hppa64_call_dummy_breakpoint_offset
);
5500 set_gdbarch_deprecated_call_dummy_length (gdbarch
, hppa64_call_dummy_length
);
5501 set_gdbarch_deprecated_stack_align (gdbarch
, hppa64_stack_align
);
5502 set_gdbarch_deprecated_extract_return_value (gdbarch
, hppa64_extract_return_value
);
5503 set_gdbarch_use_struct_convention (gdbarch
, hppa64_use_struct_convention
);
5504 set_gdbarch_deprecated_store_return_value (gdbarch
, hppa64_store_return_value
);
5507 set_gdbarch_deprecated_store_struct_return (gdbarch
, hppa_store_struct_return
);
5508 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, hppa_push_dummy_frame
);
5509 /* set_gdbarch_deprecated_fix_call_dummy (gdbarch, hppa_fix_call_dummy); */
5510 set_gdbarch_deprecated_push_arguments (gdbarch
, hppa_push_arguments
);
5513 /* Frame unwind methods. */
5516 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
5517 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
5518 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
5519 frame_base_append_sniffer (gdbarch
, hppa_frame_base_sniffer
);
5523 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, hppa_saved_pc_after_call
);
5524 set_gdbarch_deprecated_init_frame_pc (gdbarch
, deprecated_init_frame_pc_default
);
5525 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, hppa_frame_init_saved_regs
);
5526 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, hppa_init_extra_frame_info
);
5527 set_gdbarch_deprecated_frame_chain (gdbarch
, hppa_frame_chain
);
5528 set_gdbarch_deprecated_frame_chain_valid (gdbarch
, hppa_frame_chain_valid
);
5529 set_gdbarch_deprecated_frameless_function_invocation (gdbarch
, hppa_frameless_function_invocation
);
5530 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, hppa_frame_saved_pc
);
5531 set_gdbarch_deprecated_pop_frame (gdbarch
, hppa_pop_frame
);
5534 /* Hook in ABI-specific overrides, if they have been registered. */
5535 gdbarch_init_osabi (info
, gdbarch
);
5541 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
5543 /* Nothing to print for the moment. */
5547 _initialize_hppa_tdep (void)
5549 struct cmd_list_element
*c
;
5550 void break_at_finish_command (char *arg
, int from_tty
);
5551 void tbreak_at_finish_command (char *arg
, int from_tty
);
5552 void break_at_finish_at_depth_command (char *arg
, int from_tty
);
5554 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
5556 add_cmd ("unwind", class_maintenance
, unwind_command
,
5557 "Print unwind table entry at given address.",
5558 &maintenanceprintlist
);
5560 deprecate_cmd (add_com ("xbreak", class_breakpoint
,
5561 break_at_finish_command
,
5562 concat ("Set breakpoint at procedure exit. \n\
5563 Argument may be function name, or \"*\" and an address.\n\
5564 If function is specified, break at end of code for that function.\n\
5565 If an address is specified, break at the end of the function that contains \n\
5566 that exact address.\n",
5567 "With no arg, uses current execution address of selected stack frame.\n\
5568 This is useful for breaking on return to a stack frame.\n\
5570 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
5572 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
)), NULL
);
5573 deprecate_cmd (add_com_alias ("xb", "xbreak", class_breakpoint
, 1), NULL
);
5574 deprecate_cmd (add_com_alias ("xbr", "xbreak", class_breakpoint
, 1), NULL
);
5575 deprecate_cmd (add_com_alias ("xbre", "xbreak", class_breakpoint
, 1), NULL
);
5576 deprecate_cmd (add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1), NULL
);
5578 deprecate_cmd (c
= add_com ("txbreak", class_breakpoint
,
5579 tbreak_at_finish_command
,
5580 "Set temporary breakpoint at procedure exit. Either there should\n\
5581 be no argument or the argument must be a depth.\n"), NULL
);
5582 set_cmd_completer (c
, location_completer
);
5585 deprecate_cmd (add_com ("bx", class_breakpoint
,
5586 break_at_finish_at_depth_command
,
5587 "Set breakpoint at procedure exit. Either there should\n\
5588 be no argument or the argument must be a depth.\n"), NULL
);