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 Free Software Foundation, Inc.
6 Contributed by the Center for Software Science at the
7 University of Utah (pa-gdb-bugs@cs.utah.edu).
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
32 #include "completer.h"
36 /* For argument passing to the inferior */
40 #include <sys/types.h>
44 #include <sys/param.h>
47 #include <sys/ptrace.h>
48 #include <machine/save_state.h>
50 #ifdef COFF_ENCAPSULATE
51 #include "a.out.encap.h"
55 /*#include <sys/user.h> After a.out.h */
66 /* To support detection of the pseudo-initial frame
68 #define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
69 #define THREAD_INITIAL_FRAME_SYM_LEN sizeof(THREAD_INITIAL_FRAME_SYMBOL)
71 static int extract_5_load (unsigned int);
73 static unsigned extract_5R_store (unsigned int);
75 static unsigned extract_5r_store (unsigned int);
77 static void find_dummy_frame_regs (struct frame_info
*,
78 struct frame_saved_regs
*);
80 static int find_proc_framesize (CORE_ADDR
);
82 static int find_return_regnum (CORE_ADDR
);
84 struct unwind_table_entry
*find_unwind_entry (CORE_ADDR
);
86 static int extract_17 (unsigned int);
88 static unsigned deposit_21 (unsigned int, unsigned int);
90 static int extract_21 (unsigned);
92 static unsigned deposit_14 (int, unsigned int);
94 static int extract_14 (unsigned);
96 static void unwind_command (char *, int);
98 static int low_sign_extend (unsigned int, unsigned int);
100 static int sign_extend (unsigned int, unsigned int);
102 static int restore_pc_queue (struct frame_saved_regs
*);
104 static int hppa_alignof (struct type
*);
106 /* To support multi-threading and stepping. */
107 int hppa_prepare_to_proceed ();
109 static int prologue_inst_adjust_sp (unsigned long);
111 static int is_branch (unsigned long);
113 static int inst_saves_gr (unsigned long);
115 static int inst_saves_fr (unsigned long);
117 static int pc_in_interrupt_handler (CORE_ADDR
);
119 static int pc_in_linker_stub (CORE_ADDR
);
121 static int compare_unwind_entries (const void *, const void *);
123 static void read_unwind_info (struct objfile
*);
125 static void internalize_unwinds (struct objfile
*,
126 struct unwind_table_entry
*,
127 asection
*, unsigned int,
128 unsigned int, CORE_ADDR
);
129 static void pa_print_registers (char *, int, int);
130 static void pa_strcat_registers (char *, int, int, struct ui_file
*);
131 static void pa_register_look_aside (char *, int, long *);
132 static void pa_print_fp_reg (int);
133 static void pa_strcat_fp_reg (int, struct ui_file
*, enum precision_type
);
134 static void record_text_segment_lowaddr (bfd
*, asection
*, void *);
135 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
136 following functions static, once we hppa is partially multiarched. */
137 int hppa_reg_struct_has_addr (int gcc_p
, struct type
*type
);
138 int hppa_inner_than (CORE_ADDR lhs
, CORE_ADDR rhs
);
139 CORE_ADDR
hppa_stack_align (CORE_ADDR sp
);
140 int hppa_pc_requires_run_before_use (CORE_ADDR pc
);
141 int hppa_instruction_nullified (void);
142 int hppa_register_byte (int reg_nr
);
143 struct type
* hppa_register_virtual_type (int reg_nr
);
144 void hppa_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
);
145 int hppa_cannot_store_register (int regnum
);
146 CORE_ADDR
hppa_frame_args_address (struct frame_info
*fi
);
147 CORE_ADDR
hppa_frame_locals_address (struct frame_info
*fi
);
148 CORE_ADDR
hppa_smash_text_address (CORE_ADDR addr
);
149 int hppa_coerce_float_to_double (struct type
*formal
, struct type
*actual
);
153 struct minimal_symbol
*msym
;
154 CORE_ADDR solib_handle
;
155 CORE_ADDR return_val
;
159 static int cover_find_stub_with_shl_get (PTR
);
161 static int is_pa_2
= 0; /* False */
163 /* This is declared in symtab.c; set to 1 in hp-symtab-read.c */
164 extern int hp_som_som_object_present
;
166 /* In breakpoint.c */
167 extern int exception_catchpoints_are_fragile
;
169 /* Should call_function allocate stack space for a struct return? */
172 hppa_use_struct_convention (int gcc_p
, struct type
*type
)
174 return (TYPE_LENGTH (type
) > 2 * REGISTER_SIZE
);
178 /* Routines to extract various sized constants out of hppa
181 /* This assumes that no garbage lies outside of the lower bits of
185 sign_extend (unsigned val
, unsigned bits
)
187 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
190 /* For many immediate values the sign bit is the low bit! */
193 low_sign_extend (unsigned val
, unsigned bits
)
195 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
198 /* extract the immediate field from a ld{bhw}s instruction */
201 extract_5_load (unsigned word
)
203 return low_sign_extend (word
>> 16 & MASK_5
, 5);
206 /* extract the immediate field from a break instruction */
209 extract_5r_store (unsigned word
)
211 return (word
& MASK_5
);
214 /* extract the immediate field from a {sr}sm instruction */
217 extract_5R_store (unsigned word
)
219 return (word
>> 16 & MASK_5
);
222 /* extract a 14 bit immediate field */
225 extract_14 (unsigned word
)
227 return low_sign_extend (word
& MASK_14
, 14);
230 /* deposit a 14 bit constant in a word */
233 deposit_14 (int opnd
, unsigned word
)
235 unsigned sign
= (opnd
< 0 ? 1 : 0);
237 return word
| ((unsigned) opnd
<< 1 & MASK_14
) | sign
;
240 /* extract a 21 bit constant */
243 extract_21 (unsigned word
)
249 val
= GET_FIELD (word
, 20, 20);
251 val
|= GET_FIELD (word
, 9, 19);
253 val
|= GET_FIELD (word
, 5, 6);
255 val
|= GET_FIELD (word
, 0, 4);
257 val
|= GET_FIELD (word
, 7, 8);
258 return sign_extend (val
, 21) << 11;
261 /* deposit a 21 bit constant in a word. Although 21 bit constants are
262 usually the top 21 bits of a 32 bit constant, we assume that only
263 the low 21 bits of opnd are relevant */
266 deposit_21 (unsigned opnd
, unsigned word
)
270 val
|= GET_FIELD (opnd
, 11 + 14, 11 + 18);
272 val
|= GET_FIELD (opnd
, 11 + 12, 11 + 13);
274 val
|= GET_FIELD (opnd
, 11 + 19, 11 + 20);
276 val
|= GET_FIELD (opnd
, 11 + 1, 11 + 11);
278 val
|= GET_FIELD (opnd
, 11 + 0, 11 + 0);
282 /* extract a 17 bit constant from branch instructions, returning the
283 19 bit signed value. */
286 extract_17 (unsigned word
)
288 return sign_extend (GET_FIELD (word
, 19, 28) |
289 GET_FIELD (word
, 29, 29) << 10 |
290 GET_FIELD (word
, 11, 15) << 11 |
291 (word
& 0x1) << 16, 17) << 2;
295 /* Compare the start address for two unwind entries returning 1 if
296 the first address is larger than the second, -1 if the second is
297 larger than the first, and zero if they are equal. */
300 compare_unwind_entries (const void *arg1
, const void *arg2
)
302 const struct unwind_table_entry
*a
= arg1
;
303 const struct unwind_table_entry
*b
= arg2
;
305 if (a
->region_start
> b
->region_start
)
307 else if (a
->region_start
< b
->region_start
)
313 static CORE_ADDR low_text_segment_address
;
316 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *ignored
)
318 if (((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
319 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
320 && section
->vma
< low_text_segment_address
)
321 low_text_segment_address
= section
->vma
;
325 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
326 asection
*section
, unsigned int entries
, unsigned int size
,
327 CORE_ADDR text_offset
)
329 /* We will read the unwind entries into temporary memory, then
330 fill in the actual unwind table. */
335 char *buf
= alloca (size
);
337 low_text_segment_address
= -1;
339 /* If addresses are 64 bits wide, then unwinds are supposed to
340 be segment relative offsets instead of absolute addresses.
342 Note that when loading a shared library (text_offset != 0) the
343 unwinds are already relative to the text_offset that will be
345 if (TARGET_PTR_BIT
== 64 && text_offset
== 0)
347 bfd_map_over_sections (objfile
->obfd
,
348 record_text_segment_lowaddr
, (PTR
) NULL
);
350 /* ?!? Mask off some low bits. Should this instead subtract
351 out the lowest section's filepos or something like that?
352 This looks very hokey to me. */
353 low_text_segment_address
&= ~0xfff;
354 text_offset
+= low_text_segment_address
;
357 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
359 /* Now internalize the information being careful to handle host/target
361 for (i
= 0; i
< entries
; i
++)
363 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
365 table
[i
].region_start
+= text_offset
;
367 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
368 table
[i
].region_end
+= text_offset
;
370 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
372 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
373 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
374 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
375 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
376 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
377 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
378 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
379 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
380 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
381 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
382 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
383 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
384 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
385 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
386 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
387 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
388 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
389 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
390 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
391 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
392 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
393 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
394 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
395 table
[i
].Cleanup_defined
= tmp
& 0x1;
396 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
398 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
399 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
400 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
401 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
402 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
403 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
405 /* Stub unwinds are handled elsewhere. */
406 table
[i
].stub_unwind
.stub_type
= 0;
407 table
[i
].stub_unwind
.padding
= 0;
412 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
413 the object file. This info is used mainly by find_unwind_entry() to find
414 out the stack frame size and frame pointer used by procedures. We put
415 everything on the psymbol obstack in the objfile so that it automatically
416 gets freed when the objfile is destroyed. */
419 read_unwind_info (struct objfile
*objfile
)
421 asection
*unwind_sec
, *stub_unwind_sec
;
422 unsigned unwind_size
, stub_unwind_size
, total_size
;
423 unsigned index
, unwind_entries
;
424 unsigned stub_entries
, total_entries
;
425 CORE_ADDR text_offset
;
426 struct obj_unwind_info
*ui
;
427 obj_private_data_t
*obj_private
;
429 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
430 ui
= (struct obj_unwind_info
*) obstack_alloc (&objfile
->psymbol_obstack
,
431 sizeof (struct obj_unwind_info
));
437 /* For reasons unknown the HP PA64 tools generate multiple unwinder
438 sections in a single executable. So we just iterate over every
439 section in the BFD looking for unwinder sections intead of trying
440 to do a lookup with bfd_get_section_by_name.
442 First determine the total size of the unwind tables so that we
443 can allocate memory in a nice big hunk. */
445 for (unwind_sec
= objfile
->obfd
->sections
;
447 unwind_sec
= unwind_sec
->next
)
449 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
450 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
452 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
453 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
455 total_entries
+= unwind_entries
;
459 /* Now compute the size of the stub unwinds. Note the ELF tools do not
460 use stub unwinds at the curren time. */
461 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
465 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
466 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
470 stub_unwind_size
= 0;
474 /* Compute total number of unwind entries and their total size. */
475 total_entries
+= stub_entries
;
476 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
478 /* Allocate memory for the unwind table. */
479 ui
->table
= (struct unwind_table_entry
*)
480 obstack_alloc (&objfile
->psymbol_obstack
, total_size
);
481 ui
->last
= total_entries
- 1;
483 /* Now read in each unwind section and internalize the standard unwind
486 for (unwind_sec
= objfile
->obfd
->sections
;
488 unwind_sec
= unwind_sec
->next
)
490 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
491 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
493 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
494 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
496 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
497 unwind_entries
, unwind_size
, text_offset
);
498 index
+= unwind_entries
;
502 /* Now read in and internalize the stub unwind entries. */
503 if (stub_unwind_size
> 0)
506 char *buf
= alloca (stub_unwind_size
);
508 /* Read in the stub unwind entries. */
509 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
510 0, stub_unwind_size
);
512 /* Now convert them into regular unwind entries. */
513 for (i
= 0; i
< stub_entries
; i
++, index
++)
515 /* Clear out the next unwind entry. */
516 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
518 /* Convert offset & size into region_start and region_end.
519 Stuff away the stub type into "reserved" fields. */
520 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
522 ui
->table
[index
].region_start
+= text_offset
;
524 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
527 ui
->table
[index
].region_end
528 = ui
->table
[index
].region_start
+ 4 *
529 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
535 /* Unwind table needs to be kept sorted. */
536 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
537 compare_unwind_entries
);
539 /* Keep a pointer to the unwind information. */
540 if (objfile
->obj_private
== NULL
)
542 obj_private
= (obj_private_data_t
*)
543 obstack_alloc (&objfile
->psymbol_obstack
,
544 sizeof (obj_private_data_t
));
545 obj_private
->unwind_info
= NULL
;
546 obj_private
->so_info
= NULL
;
549 objfile
->obj_private
= (PTR
) obj_private
;
551 obj_private
= (obj_private_data_t
*) objfile
->obj_private
;
552 obj_private
->unwind_info
= ui
;
555 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
556 of the objfiles seeking the unwind table entry for this PC. Each objfile
557 contains a sorted list of struct unwind_table_entry. Since we do a binary
558 search of the unwind tables, we depend upon them to be sorted. */
560 struct unwind_table_entry
*
561 find_unwind_entry (CORE_ADDR pc
)
563 int first
, middle
, last
;
564 struct objfile
*objfile
;
566 /* A function at address 0? Not in HP-UX! */
567 if (pc
== (CORE_ADDR
) 0)
570 ALL_OBJFILES (objfile
)
572 struct obj_unwind_info
*ui
;
574 if (objfile
->obj_private
)
575 ui
= ((obj_private_data_t
*) (objfile
->obj_private
))->unwind_info
;
579 read_unwind_info (objfile
);
580 if (objfile
->obj_private
== NULL
)
581 error ("Internal error reading unwind information.");
582 ui
= ((obj_private_data_t
*) (objfile
->obj_private
))->unwind_info
;
585 /* First, check the cache */
588 && pc
>= ui
->cache
->region_start
589 && pc
<= ui
->cache
->region_end
)
592 /* Not in the cache, do a binary search */
597 while (first
<= last
)
599 middle
= (first
+ last
) / 2;
600 if (pc
>= ui
->table
[middle
].region_start
601 && pc
<= ui
->table
[middle
].region_end
)
603 ui
->cache
= &ui
->table
[middle
];
604 return &ui
->table
[middle
];
607 if (pc
< ui
->table
[middle
].region_start
)
612 } /* ALL_OBJFILES() */
616 /* Return the adjustment necessary to make for addresses on the stack
617 as presented by hpread.c.
619 This is necessary because of the stack direction on the PA and the
620 bizarre way in which someone (?) decided they wanted to handle
621 frame pointerless code in GDB. */
623 hpread_adjust_stack_address (CORE_ADDR func_addr
)
625 struct unwind_table_entry
*u
;
627 u
= find_unwind_entry (func_addr
);
631 return u
->Total_frame_size
<< 3;
634 /* Called to determine if PC is in an interrupt handler of some
638 pc_in_interrupt_handler (CORE_ADDR pc
)
640 struct unwind_table_entry
*u
;
641 struct minimal_symbol
*msym_us
;
643 u
= find_unwind_entry (pc
);
647 /* Oh joys. HPUX sets the interrupt bit for _sigreturn even though
648 its frame isn't a pure interrupt frame. Deal with this. */
649 msym_us
= lookup_minimal_symbol_by_pc (pc
);
651 return (u
->HP_UX_interrupt_marker
652 && !PC_IN_SIGTRAMP (pc
, SYMBOL_NAME (msym_us
)));
655 /* Called when no unwind descriptor was found for PC. Returns 1 if it
656 appears that PC is in a linker stub.
658 ?!? Need to handle stubs which appear in PA64 code. */
661 pc_in_linker_stub (CORE_ADDR pc
)
663 int found_magic_instruction
= 0;
667 /* If unable to read memory, assume pc is not in a linker stub. */
668 if (target_read_memory (pc
, buf
, 4) != 0)
671 /* We are looking for something like
673 ; $$dyncall jams RP into this special spot in the frame (RP')
674 ; before calling the "call stub"
677 ldsid (rp),r1 ; Get space associated with RP into r1
678 mtsp r1,sp ; Move it into space register 0
679 be,n 0(sr0),rp) ; back to your regularly scheduled program */
681 /* Maximum known linker stub size is 4 instructions. Search forward
682 from the given PC, then backward. */
683 for (i
= 0; i
< 4; i
++)
685 /* If we hit something with an unwind, stop searching this direction. */
687 if (find_unwind_entry (pc
+ i
* 4) != 0)
690 /* Check for ldsid (rp),r1 which is the magic instruction for a
691 return from a cross-space function call. */
692 if (read_memory_integer (pc
+ i
* 4, 4) == 0x004010a1)
694 found_magic_instruction
= 1;
697 /* Add code to handle long call/branch and argument relocation stubs
701 if (found_magic_instruction
!= 0)
704 /* Now look backward. */
705 for (i
= 0; i
< 4; i
++)
707 /* If we hit something with an unwind, stop searching this direction. */
709 if (find_unwind_entry (pc
- i
* 4) != 0)
712 /* Check for ldsid (rp),r1 which is the magic instruction for a
713 return from a cross-space function call. */
714 if (read_memory_integer (pc
- i
* 4, 4) == 0x004010a1)
716 found_magic_instruction
= 1;
719 /* Add code to handle long call/branch and argument relocation stubs
722 return found_magic_instruction
;
726 find_return_regnum (CORE_ADDR pc
)
728 struct unwind_table_entry
*u
;
730 u
= find_unwind_entry (pc
);
741 /* Return size of frame, or -1 if we should use a frame pointer. */
743 find_proc_framesize (CORE_ADDR pc
)
745 struct unwind_table_entry
*u
;
746 struct minimal_symbol
*msym_us
;
748 /* This may indicate a bug in our callers... */
749 if (pc
== (CORE_ADDR
) 0)
752 u
= find_unwind_entry (pc
);
756 if (pc_in_linker_stub (pc
))
757 /* Linker stubs have a zero size frame. */
763 msym_us
= lookup_minimal_symbol_by_pc (pc
);
765 /* If Save_SP is set, and we're not in an interrupt or signal caller,
766 then we have a frame pointer. Use it. */
768 && !pc_in_interrupt_handler (pc
)
770 && !PC_IN_SIGTRAMP (pc
, SYMBOL_NAME (msym_us
)))
773 return u
->Total_frame_size
<< 3;
776 /* Return offset from sp at which rp is saved, or 0 if not saved. */
777 static int rp_saved (CORE_ADDR
);
780 rp_saved (CORE_ADDR pc
)
782 struct unwind_table_entry
*u
;
784 /* A function at, and thus a return PC from, address 0? Not in HP-UX! */
785 if (pc
== (CORE_ADDR
) 0)
788 u
= find_unwind_entry (pc
);
792 if (pc_in_linker_stub (pc
))
793 /* This is the so-called RP'. */
800 return (TARGET_PTR_BIT
== 64 ? -16 : -20);
801 else if (u
->stub_unwind
.stub_type
!= 0)
803 switch (u
->stub_unwind
.stub_type
)
808 case PARAMETER_RELOCATION
:
819 frameless_function_invocation (struct frame_info
*frame
)
821 struct unwind_table_entry
*u
;
823 u
= find_unwind_entry (frame
->pc
);
828 return (u
->Total_frame_size
== 0 && u
->stub_unwind
.stub_type
== 0);
831 /* Immediately after a function call, return the saved pc.
832 Can't go through the frames for this because on some machines
833 the new frame is not set up until the new function executes
834 some instructions. */
837 saved_pc_after_call (struct frame_info
*frame
)
841 struct unwind_table_entry
*u
;
843 ret_regnum
= find_return_regnum (get_frame_pc (frame
));
844 pc
= read_register (ret_regnum
) & ~0x3;
846 /* If PC is in a linker stub, then we need to dig the address
847 the stub will return to out of the stack. */
848 u
= find_unwind_entry (pc
);
849 if (u
&& u
->stub_unwind
.stub_type
!= 0)
850 return FRAME_SAVED_PC (frame
);
856 hppa_frame_saved_pc (struct frame_info
*frame
)
858 CORE_ADDR pc
= get_frame_pc (frame
);
859 struct unwind_table_entry
*u
;
861 int spun_around_loop
= 0;
864 /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
865 at the base of the frame in an interrupt handler. Registers within
866 are saved in the exact same order as GDB numbers registers. How
868 if (pc_in_interrupt_handler (pc
))
869 return read_memory_integer (frame
->frame
+ PC_REGNUM
* 4,
870 TARGET_PTR_BIT
/ 8) & ~0x3;
872 if ((frame
->pc
>= frame
->frame
873 && frame
->pc
<= (frame
->frame
874 /* A call dummy is sized in words, but it is
875 actually a series of instructions. Account
876 for that scaling factor. */
877 + ((REGISTER_SIZE
/ INSTRUCTION_SIZE
)
879 /* Similarly we have to account for 64bit
880 wide register saves. */
881 + (32 * REGISTER_SIZE
)
882 /* We always consider FP regs 8 bytes long. */
883 + (NUM_REGS
- FP0_REGNUM
) * 8
884 /* Similarly we have to account for 64bit
885 wide register saves. */
886 + (6 * REGISTER_SIZE
))))
888 return read_memory_integer ((frame
->frame
889 + (TARGET_PTR_BIT
== 64 ? -16 : -20)),
890 TARGET_PTR_BIT
/ 8) & ~0x3;
893 #ifdef FRAME_SAVED_PC_IN_SIGTRAMP
894 /* Deal with signal handler caller frames too. */
895 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
898 FRAME_SAVED_PC_IN_SIGTRAMP (frame
, &rp
);
903 if (frameless_function_invocation (frame
))
907 ret_regnum
= find_return_regnum (pc
);
909 /* If the next frame is an interrupt frame or a signal
910 handler caller, then we need to look in the saved
911 register area to get the return pointer (the values
912 in the registers may not correspond to anything useful). */
914 && ((get_frame_type (frame
->next
) == SIGTRAMP_FRAME
)
915 || pc_in_interrupt_handler (frame
->next
->pc
)))
917 struct frame_saved_regs saved_regs
;
919 get_frame_saved_regs (frame
->next
, &saved_regs
);
920 if (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
],
921 TARGET_PTR_BIT
/ 8) & 0x2)
923 pc
= read_memory_integer (saved_regs
.regs
[31],
924 TARGET_PTR_BIT
/ 8) & ~0x3;
926 /* Syscalls are really two frames. The syscall stub itself
927 with a return pointer in %rp and the kernel call with
928 a return pointer in %r31. We return the %rp variant
929 if %r31 is the same as frame->pc. */
931 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
],
932 TARGET_PTR_BIT
/ 8) & ~0x3;
935 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
],
936 TARGET_PTR_BIT
/ 8) & ~0x3;
939 pc
= read_register (ret_regnum
) & ~0x3;
943 spun_around_loop
= 0;
947 rp_offset
= rp_saved (pc
);
949 /* Similar to code in frameless function case. If the next
950 frame is a signal or interrupt handler, then dig the right
951 information out of the saved register info. */
954 && ((get_frame_type (frame
->next
) == SIGTRAMP_FRAME
)
955 || pc_in_interrupt_handler (frame
->next
->pc
)))
957 struct frame_saved_regs saved_regs
;
959 get_frame_saved_regs (frame
->next
, &saved_regs
);
960 if (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
],
961 TARGET_PTR_BIT
/ 8) & 0x2)
963 pc
= read_memory_integer (saved_regs
.regs
[31],
964 TARGET_PTR_BIT
/ 8) & ~0x3;
966 /* Syscalls are really two frames. The syscall stub itself
967 with a return pointer in %rp and the kernel call with
968 a return pointer in %r31. We return the %rp variant
969 if %r31 is the same as frame->pc. */
971 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
],
972 TARGET_PTR_BIT
/ 8) & ~0x3;
975 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
],
976 TARGET_PTR_BIT
/ 8) & ~0x3;
978 else if (rp_offset
== 0)
981 pc
= read_register (RP_REGNUM
) & ~0x3;
986 pc
= read_memory_integer (frame
->frame
+ rp_offset
,
987 TARGET_PTR_BIT
/ 8) & ~0x3;
991 /* If PC is inside a linker stub, then dig out the address the stub
994 Don't do this for long branch stubs. Why? For some unknown reason
995 _start is marked as a long branch stub in hpux10. */
996 u
= find_unwind_entry (pc
);
997 if (u
&& u
->stub_unwind
.stub_type
!= 0
998 && u
->stub_unwind
.stub_type
!= LONG_BRANCH
)
1002 /* If this is a dynamic executable, and we're in a signal handler,
1003 then the call chain will eventually point us into the stub for
1004 _sigreturn. Unlike most cases, we'll be pointed to the branch
1005 to the real sigreturn rather than the code after the real branch!.
1007 Else, try to dig the address the stub will return to in the normal
1009 insn
= read_memory_integer (pc
, 4);
1010 if ((insn
& 0xfc00e000) == 0xe8000000)
1011 return (pc
+ extract_17 (insn
) + 8) & ~0x3;
1017 if (spun_around_loop
> 1)
1019 /* We're just about to go around the loop again with
1020 no more hope of success. Die. */
1021 error ("Unable to find return pc for this frame");
1031 /* We need to correct the PC and the FP for the outermost frame when we are
1032 in a system call. */
1035 init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
1040 if (frame
->next
&& !fromleaf
)
1043 /* If the next frame represents a frameless function invocation
1044 then we have to do some adjustments that are normally done by
1045 FRAME_CHAIN. (FRAME_CHAIN is not called in this case.) */
1048 /* Find the framesize of *this* frame without peeking at the PC
1049 in the current frame structure (it isn't set yet). */
1050 framesize
= find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame
)));
1052 /* Now adjust our base frame accordingly. If we have a frame pointer
1053 use it, else subtract the size of this frame from the current
1054 frame. (we always want frame->frame to point at the lowest address
1056 if (framesize
== -1)
1057 frame
->frame
= TARGET_READ_FP ();
1059 frame
->frame
-= framesize
;
1063 flags
= read_register (FLAGS_REGNUM
);
1064 if (flags
& 2) /* In system call? */
1065 frame
->pc
= read_register (31) & ~0x3;
1067 /* The outermost frame is always derived from PC-framesize
1069 One might think frameless innermost frames should have
1070 a frame->frame that is the same as the parent's frame->frame.
1071 That is wrong; frame->frame in that case should be the *high*
1072 address of the parent's frame. It's complicated as hell to
1073 explain, but the parent *always* creates some stack space for
1074 the child. So the child actually does have a frame of some
1075 sorts, and its base is the high address in its parent's frame. */
1076 framesize
= find_proc_framesize (frame
->pc
);
1077 if (framesize
== -1)
1078 frame
->frame
= TARGET_READ_FP ();
1080 frame
->frame
= read_register (SP_REGNUM
) - framesize
;
1083 /* Given a GDB frame, determine the address of the calling function's
1084 frame. This will be used to create a new GDB frame struct, and
1085 then INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC will be
1086 called for the new frame.
1088 This may involve searching through prologues for several functions
1089 at boundaries where GCC calls HP C code, or where code which has
1090 a frame pointer calls code without a frame pointer. */
1093 frame_chain (struct frame_info
*frame
)
1095 int my_framesize
, caller_framesize
;
1096 struct unwind_table_entry
*u
;
1097 CORE_ADDR frame_base
;
1098 struct frame_info
*tmp_frame
;
1100 /* A frame in the current frame list, or zero. */
1101 struct frame_info
*saved_regs_frame
= 0;
1102 /* Where the registers were saved in saved_regs_frame.
1103 If saved_regs_frame is zero, this is garbage. */
1104 struct frame_saved_regs saved_regs
;
1106 CORE_ADDR caller_pc
;
1108 struct minimal_symbol
*min_frame_symbol
;
1109 struct symbol
*frame_symbol
;
1110 char *frame_symbol_name
;
1112 /* If this is a threaded application, and we see the
1113 routine "__pthread_exit", treat it as the stack root
1115 min_frame_symbol
= lookup_minimal_symbol_by_pc (frame
->pc
);
1116 frame_symbol
= find_pc_function (frame
->pc
);
1118 if ((min_frame_symbol
!= 0) /* && (frame_symbol == 0) */ )
1120 /* The test above for "no user function name" would defend
1121 against the slim likelihood that a user might define a
1122 routine named "__pthread_exit" and then try to debug it.
1124 If it weren't commented out, and you tried to debug the
1125 pthread library itself, you'd get errors.
1127 So for today, we don't make that check. */
1128 frame_symbol_name
= SYMBOL_NAME (min_frame_symbol
);
1129 if (frame_symbol_name
!= 0)
1131 if (0 == strncmp (frame_symbol_name
,
1132 THREAD_INITIAL_FRAME_SYMBOL
,
1133 THREAD_INITIAL_FRAME_SYM_LEN
))
1135 /* Pretend we've reached the bottom of the stack. */
1136 return (CORE_ADDR
) 0;
1139 } /* End of hacky code for threads. */
1141 /* Handle HPUX, BSD, and OSF1 style interrupt frames first. These
1142 are easy; at *sp we have a full save state strucutre which we can
1143 pull the old stack pointer from. Also see frame_saved_pc for
1144 code to dig a saved PC out of the save state structure. */
1145 if (pc_in_interrupt_handler (frame
->pc
))
1146 frame_base
= read_memory_integer (frame
->frame
+ SP_REGNUM
* 4,
1147 TARGET_PTR_BIT
/ 8);
1148 #ifdef FRAME_BASE_BEFORE_SIGTRAMP
1149 else if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
1151 FRAME_BASE_BEFORE_SIGTRAMP (frame
, &frame_base
);
1155 frame_base
= frame
->frame
;
1157 /* Get frame sizes for the current frame and the frame of the
1159 my_framesize
= find_proc_framesize (frame
->pc
);
1160 caller_pc
= FRAME_SAVED_PC (frame
);
1162 /* If we can't determine the caller's PC, then it's not likely we can
1163 really determine anything meaningful about its frame. We'll consider
1164 this to be stack bottom. */
1165 if (caller_pc
== (CORE_ADDR
) 0)
1166 return (CORE_ADDR
) 0;
1168 caller_framesize
= find_proc_framesize (FRAME_SAVED_PC (frame
));
1170 /* If caller does not have a frame pointer, then its frame
1171 can be found at current_frame - caller_framesize. */
1172 if (caller_framesize
!= -1)
1174 return frame_base
- caller_framesize
;
1176 /* Both caller and callee have frame pointers and are GCC compiled
1177 (SAVE_SP bit in unwind descriptor is on for both functions.
1178 The previous frame pointer is found at the top of the current frame. */
1179 if (caller_framesize
== -1 && my_framesize
== -1)
1181 return read_memory_integer (frame_base
, TARGET_PTR_BIT
/ 8);
1183 /* Caller has a frame pointer, but callee does not. This is a little
1184 more difficult as GCC and HP C lay out locals and callee register save
1185 areas very differently.
1187 The previous frame pointer could be in a register, or in one of
1188 several areas on the stack.
1190 Walk from the current frame to the innermost frame examining
1191 unwind descriptors to determine if %r3 ever gets saved into the
1192 stack. If so return whatever value got saved into the stack.
1193 If it was never saved in the stack, then the value in %r3 is still
1196 We use information from unwind descriptors to determine if %r3
1197 is saved into the stack (Entry_GR field has this information). */
1199 for (tmp_frame
= frame
; tmp_frame
; tmp_frame
= tmp_frame
->next
)
1201 u
= find_unwind_entry (tmp_frame
->pc
);
1205 /* We could find this information by examining prologues. I don't
1206 think anyone has actually written any tools (not even "strip")
1207 which leave them out of an executable, so maybe this is a moot
1209 /* ??rehrauer: Actually, it's quite possible to stepi your way into
1210 code that doesn't have unwind entries. For example, stepping into
1211 the dynamic linker will give you a PC that has none. Thus, I've
1212 disabled this warning. */
1214 warning ("Unable to find unwind for PC 0x%x -- Help!", tmp_frame
->pc
);
1216 return (CORE_ADDR
) 0;
1220 || (get_frame_type (tmp_frame
) == SIGTRAMP_FRAME
)
1221 || pc_in_interrupt_handler (tmp_frame
->pc
))
1224 /* Entry_GR specifies the number of callee-saved general registers
1225 saved in the stack. It starts at %r3, so %r3 would be 1. */
1226 if (u
->Entry_GR
>= 1)
1228 /* The unwind entry claims that r3 is saved here. However,
1229 in optimized code, GCC often doesn't actually save r3.
1230 We'll discover this if we look at the prologue. */
1231 get_frame_saved_regs (tmp_frame
, &saved_regs
);
1232 saved_regs_frame
= tmp_frame
;
1234 /* If we have an address for r3, that's good. */
1235 if (saved_regs
.regs
[FP_REGNUM
])
1242 /* We may have walked down the chain into a function with a frame
1245 && !(get_frame_type (tmp_frame
) == SIGTRAMP_FRAME
)
1246 && !pc_in_interrupt_handler (tmp_frame
->pc
))
1248 return read_memory_integer (tmp_frame
->frame
, TARGET_PTR_BIT
/ 8);
1250 /* %r3 was saved somewhere in the stack. Dig it out. */
1255 For optimization purposes many kernels don't have the
1256 callee saved registers into the save_state structure upon
1257 entry into the kernel for a syscall; the optimization
1258 is usually turned off if the process is being traced so
1259 that the debugger can get full register state for the
1262 This scheme works well except for two cases:
1264 * Attaching to a process when the process is in the
1265 kernel performing a system call (debugger can't get
1266 full register state for the inferior process since
1267 the process wasn't being traced when it entered the
1270 * Register state is not complete if the system call
1271 causes the process to core dump.
1274 The following heinous code is an attempt to deal with
1275 the lack of register state in a core dump. It will
1276 fail miserably if the function which performs the
1277 system call has a variable sized stack frame. */
1279 if (tmp_frame
!= saved_regs_frame
)
1280 get_frame_saved_regs (tmp_frame
, &saved_regs
);
1282 /* Abominable hack. */
1283 if (current_target
.to_has_execution
== 0
1284 && ((saved_regs
.regs
[FLAGS_REGNUM
]
1285 && (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
],
1288 || (saved_regs
.regs
[FLAGS_REGNUM
] == 0
1289 && read_register (FLAGS_REGNUM
) & 0x2)))
1291 u
= find_unwind_entry (FRAME_SAVED_PC (frame
));
1294 return read_memory_integer (saved_regs
.regs
[FP_REGNUM
],
1295 TARGET_PTR_BIT
/ 8);
1299 return frame_base
- (u
->Total_frame_size
<< 3);
1303 return read_memory_integer (saved_regs
.regs
[FP_REGNUM
],
1304 TARGET_PTR_BIT
/ 8);
1309 /* Get the innermost frame. */
1311 while (tmp_frame
->next
!= NULL
)
1312 tmp_frame
= tmp_frame
->next
;
1314 if (tmp_frame
!= saved_regs_frame
)
1315 get_frame_saved_regs (tmp_frame
, &saved_regs
);
1317 /* Abominable hack. See above. */
1318 if (current_target
.to_has_execution
== 0
1319 && ((saved_regs
.regs
[FLAGS_REGNUM
]
1320 && (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
],
1323 || (saved_regs
.regs
[FLAGS_REGNUM
] == 0
1324 && read_register (FLAGS_REGNUM
) & 0x2)))
1326 u
= find_unwind_entry (FRAME_SAVED_PC (frame
));
1329 return read_memory_integer (saved_regs
.regs
[FP_REGNUM
],
1330 TARGET_PTR_BIT
/ 8);
1334 return frame_base
- (u
->Total_frame_size
<< 3);
1338 /* The value in %r3 was never saved into the stack (thus %r3 still
1339 holds the value of the previous frame pointer). */
1340 return TARGET_READ_FP ();
1345 /* To see if a frame chain is valid, see if the caller looks like it
1346 was compiled with gcc. */
1349 hppa_frame_chain_valid (CORE_ADDR chain
, struct frame_info
*thisframe
)
1351 struct minimal_symbol
*msym_us
;
1352 struct minimal_symbol
*msym_start
;
1353 struct unwind_table_entry
*u
, *next_u
= NULL
;
1354 struct frame_info
*next
;
1359 u
= find_unwind_entry (thisframe
->pc
);
1364 /* We can't just check that the same of msym_us is "_start", because
1365 someone idiotically decided that they were going to make a Ltext_end
1366 symbol with the same address. This Ltext_end symbol is totally
1367 indistinguishable (as nearly as I can tell) from the symbol for a function
1368 which is (legitimately, since it is in the user's namespace)
1369 named Ltext_end, so we can't just ignore it. */
1370 msym_us
= lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe
));
1371 msym_start
= lookup_minimal_symbol ("_start", NULL
, NULL
);
1374 && SYMBOL_VALUE_ADDRESS (msym_us
) == SYMBOL_VALUE_ADDRESS (msym_start
))
1377 /* Grrrr. Some new idiot decided that they don't want _start for the
1378 PRO configurations; $START$ calls main directly.... Deal with it. */
1379 msym_start
= lookup_minimal_symbol ("$START$", NULL
, NULL
);
1382 && SYMBOL_VALUE_ADDRESS (msym_us
) == SYMBOL_VALUE_ADDRESS (msym_start
))
1385 next
= get_next_frame (thisframe
);
1387 next_u
= find_unwind_entry (next
->pc
);
1389 /* If this frame does not save SP, has no stack, isn't a stub,
1390 and doesn't "call" an interrupt routine or signal handler caller,
1391 then its not valid. */
1392 if (u
->Save_SP
|| u
->Total_frame_size
|| u
->stub_unwind
.stub_type
!= 0
1393 || (thisframe
->next
&& (get_frame_type (thisframe
->next
) == SIGTRAMP_FRAME
))
1394 || (next_u
&& next_u
->HP_UX_interrupt_marker
))
1397 if (pc_in_linker_stub (thisframe
->pc
))
1404 These functions deal with saving and restoring register state
1405 around a function call in the inferior. They keep the stack
1406 double-word aligned; eventually, on an hp700, the stack will have
1407 to be aligned to a 64-byte boundary. */
1410 push_dummy_frame (struct inferior_status
*inf_status
)
1412 CORE_ADDR sp
, pc
, pcspace
;
1413 register int regnum
;
1414 CORE_ADDR int_buffer
;
1417 /* Oh, what a hack. If we're trying to perform an inferior call
1418 while the inferior is asleep, we have to make sure to clear
1419 the "in system call" bit in the flag register (the call will
1420 start after the syscall returns, so we're no longer in the system
1421 call!) This state is kept in "inf_status", change it there.
1423 We also need a number of horrid hacks to deal with lossage in the
1424 PC queue registers (apparently they're not valid when the in syscall
1426 pc
= target_read_pc (inferior_ptid
);
1427 int_buffer
= read_register (FLAGS_REGNUM
);
1428 if (int_buffer
& 0x2)
1432 write_inferior_status_register (inf_status
, 0, int_buffer
);
1433 write_inferior_status_register (inf_status
, PCOQ_HEAD_REGNUM
, pc
+ 0);
1434 write_inferior_status_register (inf_status
, PCOQ_TAIL_REGNUM
, pc
+ 4);
1435 sid
= (pc
>> 30) & 0x3;
1437 pcspace
= read_register (SR4_REGNUM
);
1439 pcspace
= read_register (SR4_REGNUM
+ 4 + sid
);
1440 write_inferior_status_register (inf_status
, PCSQ_HEAD_REGNUM
, pcspace
);
1441 write_inferior_status_register (inf_status
, PCSQ_TAIL_REGNUM
, pcspace
);
1444 pcspace
= read_register (PCSQ_HEAD_REGNUM
);
1446 /* Space for "arguments"; the RP goes in here. */
1447 sp
= read_register (SP_REGNUM
) + 48;
1448 int_buffer
= read_register (RP_REGNUM
) | 0x3;
1450 /* The 32bit and 64bit ABIs save the return pointer into different
1452 if (REGISTER_SIZE
== 8)
1453 write_memory (sp
- 16, (char *) &int_buffer
, REGISTER_SIZE
);
1455 write_memory (sp
- 20, (char *) &int_buffer
, REGISTER_SIZE
);
1457 int_buffer
= TARGET_READ_FP ();
1458 write_memory (sp
, (char *) &int_buffer
, REGISTER_SIZE
);
1460 write_register (FP_REGNUM
, sp
);
1462 sp
+= 2 * REGISTER_SIZE
;
1464 for (regnum
= 1; regnum
< 32; regnum
++)
1465 if (regnum
!= RP_REGNUM
&& regnum
!= FP_REGNUM
)
1466 sp
= push_word (sp
, read_register (regnum
));
1468 /* This is not necessary for the 64bit ABI. In fact it is dangerous. */
1469 if (REGISTER_SIZE
!= 8)
1472 for (regnum
= FP0_REGNUM
; regnum
< NUM_REGS
; regnum
++)
1474 deprecated_read_register_bytes (REGISTER_BYTE (regnum
),
1475 (char *) &freg_buffer
, 8);
1476 sp
= push_bytes (sp
, (char *) &freg_buffer
, 8);
1478 sp
= push_word (sp
, read_register (IPSW_REGNUM
));
1479 sp
= push_word (sp
, read_register (SAR_REGNUM
));
1480 sp
= push_word (sp
, pc
);
1481 sp
= push_word (sp
, pcspace
);
1482 sp
= push_word (sp
, pc
+ 4);
1483 sp
= push_word (sp
, pcspace
);
1484 write_register (SP_REGNUM
, sp
);
1488 find_dummy_frame_regs (struct frame_info
*frame
,
1489 struct frame_saved_regs
*frame_saved_regs
)
1491 CORE_ADDR fp
= frame
->frame
;
1494 /* The 32bit and 64bit ABIs save RP into different locations. */
1495 if (REGISTER_SIZE
== 8)
1496 frame_saved_regs
->regs
[RP_REGNUM
] = (fp
- 16) & ~0x3;
1498 frame_saved_regs
->regs
[RP_REGNUM
] = (fp
- 20) & ~0x3;
1500 frame_saved_regs
->regs
[FP_REGNUM
] = fp
;
1502 frame_saved_regs
->regs
[1] = fp
+ (2 * REGISTER_SIZE
);
1504 for (fp
+= 3 * REGISTER_SIZE
, i
= 3; i
< 32; i
++)
1508 frame_saved_regs
->regs
[i
] = fp
;
1509 fp
+= REGISTER_SIZE
;
1513 /* This is not necessary or desirable for the 64bit ABI. */
1514 if (REGISTER_SIZE
!= 8)
1517 for (i
= FP0_REGNUM
; i
< NUM_REGS
; i
++, fp
+= 8)
1518 frame_saved_regs
->regs
[i
] = fp
;
1520 frame_saved_regs
->regs
[IPSW_REGNUM
] = fp
;
1521 frame_saved_regs
->regs
[SAR_REGNUM
] = fp
+ REGISTER_SIZE
;
1522 frame_saved_regs
->regs
[PCOQ_HEAD_REGNUM
] = fp
+ 2 * REGISTER_SIZE
;
1523 frame_saved_regs
->regs
[PCSQ_HEAD_REGNUM
] = fp
+ 3 * REGISTER_SIZE
;
1524 frame_saved_regs
->regs
[PCOQ_TAIL_REGNUM
] = fp
+ 4 * REGISTER_SIZE
;
1525 frame_saved_regs
->regs
[PCSQ_TAIL_REGNUM
] = fp
+ 5 * REGISTER_SIZE
;
1529 hppa_pop_frame (void)
1531 register struct frame_info
*frame
= get_current_frame ();
1532 register CORE_ADDR fp
, npc
, target_pc
;
1533 register int regnum
;
1534 struct frame_saved_regs fsr
;
1537 fp
= get_frame_base (frame
);
1538 get_frame_saved_regs (frame
, &fsr
);
1540 #ifndef NO_PC_SPACE_QUEUE_RESTORE
1541 if (fsr
.regs
[IPSW_REGNUM
]) /* Restoring a call dummy frame */
1542 restore_pc_queue (&fsr
);
1545 for (regnum
= 31; regnum
> 0; regnum
--)
1546 if (fsr
.regs
[regnum
])
1547 write_register (regnum
, read_memory_integer (fsr
.regs
[regnum
],
1550 for (regnum
= NUM_REGS
- 1; regnum
>= FP0_REGNUM
; regnum
--)
1551 if (fsr
.regs
[regnum
])
1553 read_memory (fsr
.regs
[regnum
], (char *) &freg_buffer
, 8);
1554 deprecated_write_register_bytes (REGISTER_BYTE (regnum
),
1555 (char *) &freg_buffer
, 8);
1558 if (fsr
.regs
[IPSW_REGNUM
])
1559 write_register (IPSW_REGNUM
,
1560 read_memory_integer (fsr
.regs
[IPSW_REGNUM
],
1563 if (fsr
.regs
[SAR_REGNUM
])
1564 write_register (SAR_REGNUM
,
1565 read_memory_integer (fsr
.regs
[SAR_REGNUM
],
1568 /* If the PC was explicitly saved, then just restore it. */
1569 if (fsr
.regs
[PCOQ_TAIL_REGNUM
])
1571 npc
= read_memory_integer (fsr
.regs
[PCOQ_TAIL_REGNUM
],
1573 write_register (PCOQ_TAIL_REGNUM
, npc
);
1575 /* Else use the value in %rp to set the new PC. */
1578 npc
= read_register (RP_REGNUM
);
1582 write_register (FP_REGNUM
, read_memory_integer (fp
, REGISTER_SIZE
));
1584 if (fsr
.regs
[IPSW_REGNUM
]) /* call dummy */
1585 write_register (SP_REGNUM
, fp
- 48);
1587 write_register (SP_REGNUM
, fp
);
1589 /* The PC we just restored may be inside a return trampoline. If so
1590 we want to restart the inferior and run it through the trampoline.
1592 Do this by setting a momentary breakpoint at the location the
1593 trampoline returns to.
1595 Don't skip through the trampoline if we're popping a dummy frame. */
1596 target_pc
= SKIP_TRAMPOLINE_CODE (npc
& ~0x3) & ~0x3;
1597 if (target_pc
&& !fsr
.regs
[IPSW_REGNUM
])
1599 struct symtab_and_line sal
;
1600 struct breakpoint
*breakpoint
;
1601 struct cleanup
*old_chain
;
1603 /* Set up our breakpoint. Set it to be silent as the MI code
1604 for "return_command" will print the frame we returned to. */
1605 sal
= find_pc_line (target_pc
, 0);
1607 breakpoint
= set_momentary_breakpoint (sal
, NULL
, bp_finish
);
1608 breakpoint
->silent
= 1;
1610 /* So we can clean things up. */
1611 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1613 /* Start up the inferior. */
1614 clear_proceed_status ();
1615 proceed_to_finish
= 1;
1616 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1618 /* Perform our cleanups. */
1619 do_cleanups (old_chain
);
1621 flush_cached_frames ();
1624 /* After returning to a dummy on the stack, restore the instruction
1625 queue space registers. */
1628 restore_pc_queue (struct frame_saved_regs
*fsr
)
1630 CORE_ADDR pc
= read_pc ();
1631 CORE_ADDR new_pc
= read_memory_integer (fsr
->regs
[PCOQ_HEAD_REGNUM
],
1632 TARGET_PTR_BIT
/ 8);
1633 struct target_waitstatus w
;
1636 /* Advance past break instruction in the call dummy. */
1637 write_register (PCOQ_HEAD_REGNUM
, pc
+ 4);
1638 write_register (PCOQ_TAIL_REGNUM
, pc
+ 8);
1640 /* HPUX doesn't let us set the space registers or the space
1641 registers of the PC queue through ptrace. Boo, hiss.
1642 Conveniently, the call dummy has this sequence of instructions
1647 So, load up the registers and single step until we are in the
1650 write_register (21, read_memory_integer (fsr
->regs
[PCSQ_HEAD_REGNUM
],
1652 write_register (22, new_pc
);
1654 for (insn_count
= 0; insn_count
< 3; insn_count
++)
1656 /* FIXME: What if the inferior gets a signal right now? Want to
1657 merge this into wait_for_inferior (as a special kind of
1658 watchpoint? By setting a breakpoint at the end? Is there
1659 any other choice? Is there *any* way to do this stuff with
1660 ptrace() or some equivalent?). */
1662 target_wait (inferior_ptid
, &w
);
1664 if (w
.kind
== TARGET_WAITKIND_SIGNALLED
)
1666 stop_signal
= w
.value
.sig
;
1667 terminal_ours_for_output ();
1668 printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
1669 target_signal_to_name (stop_signal
),
1670 target_signal_to_string (stop_signal
));
1671 gdb_flush (gdb_stdout
);
1675 target_terminal_ours ();
1676 target_fetch_registers (-1);
1681 #ifdef PA20W_CALLING_CONVENTIONS
1683 /* This function pushes a stack frame with arguments as part of the
1684 inferior function calling mechanism.
1686 This is the version for the PA64, in which later arguments appear
1687 at higher addresses. (The stack always grows towards higher
1690 We simply allocate the appropriate amount of stack space and put
1691 arguments into their proper slots. The call dummy code will copy
1692 arguments into registers as needed by the ABI.
1694 This ABI also requires that the caller provide an argument pointer
1695 to the callee, so we do that too. */
1698 hppa_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1699 int struct_return
, CORE_ADDR struct_addr
)
1701 /* array of arguments' offsets */
1702 int *offset
= (int *) alloca (nargs
* sizeof (int));
1704 /* array of arguments' lengths: real lengths in bytes, not aligned to
1706 int *lengths
= (int *) alloca (nargs
* sizeof (int));
1708 /* The value of SP as it was passed into this function after
1710 CORE_ADDR orig_sp
= STACK_ALIGN (sp
);
1712 /* The number of stack bytes occupied by the current argument. */
1715 /* The total number of bytes reserved for the arguments. */
1716 int cum_bytes_reserved
= 0;
1718 /* Similarly, but aligned. */
1719 int cum_bytes_aligned
= 0;
1722 /* Iterate over each argument provided by the user. */
1723 for (i
= 0; i
< nargs
; i
++)
1725 struct type
*arg_type
= VALUE_TYPE (args
[i
]);
1727 /* Integral scalar values smaller than a register are padded on
1728 the left. We do this by promoting them to full-width,
1729 although the ABI says to pad them with garbage. */
1730 if (is_integral_type (arg_type
)
1731 && TYPE_LENGTH (arg_type
) < REGISTER_SIZE
)
1733 args
[i
] = value_cast ((TYPE_UNSIGNED (arg_type
)
1734 ? builtin_type_unsigned_long
1735 : builtin_type_long
),
1737 arg_type
= VALUE_TYPE (args
[i
]);
1740 lengths
[i
] = TYPE_LENGTH (arg_type
);
1742 /* Align the size of the argument to the word size for this
1744 bytes_reserved
= (lengths
[i
] + REGISTER_SIZE
- 1) & -REGISTER_SIZE
;
1746 offset
[i
] = cum_bytes_reserved
;
1748 /* Aggregates larger than eight bytes (the only types larger
1749 than eight bytes we have) are aligned on a 16-byte boundary,
1750 possibly padded on the right with garbage. This may leave an
1751 empty word on the stack, and thus an unused register, as per
1753 if (bytes_reserved
> 8)
1755 /* Round up the offset to a multiple of two slots. */
1756 int new_offset
= ((offset
[i
] + 2*REGISTER_SIZE
-1)
1757 & -(2*REGISTER_SIZE
));
1759 /* Note the space we've wasted, if any. */
1760 bytes_reserved
+= new_offset
- offset
[i
];
1761 offset
[i
] = new_offset
;
1764 cum_bytes_reserved
+= bytes_reserved
;
1767 /* CUM_BYTES_RESERVED already accounts for all the arguments
1768 passed by the user. However, the ABIs mandate minimum stack space
1769 allocations for outgoing arguments.
1771 The ABIs also mandate minimum stack alignments which we must
1773 cum_bytes_aligned
= STACK_ALIGN (cum_bytes_reserved
);
1774 sp
+= max (cum_bytes_aligned
, REG_PARM_STACK_SPACE
);
1776 /* Now write each of the args at the proper offset down the stack. */
1777 for (i
= 0; i
< nargs
; i
++)
1778 write_memory (orig_sp
+ offset
[i
], VALUE_CONTENTS (args
[i
]), lengths
[i
]);
1780 /* If a structure has to be returned, set up register 28 to hold its
1783 write_register (28, struct_addr
);
1785 /* For the PA64 we must pass a pointer to the outgoing argument list.
1786 The ABI mandates that the pointer should point to the first byte of
1787 storage beyond the register flushback area.
1789 However, the call dummy expects the outgoing argument pointer to
1790 be passed in register %r4. */
1791 write_register (4, orig_sp
+ REG_PARM_STACK_SPACE
);
1793 /* ?!? This needs further work. We need to set up the global data
1794 pointer for this procedure. This assumes the same global pointer
1795 for every procedure. The call dummy expects the dp value to
1796 be passed in register %r6. */
1797 write_register (6, read_register (27));
1799 /* The stack will have 64 bytes of additional space for a frame marker. */
1805 /* This function pushes a stack frame with arguments as part of the
1806 inferior function calling mechanism.
1808 This is the version of the function for the 32-bit PA machines, in
1809 which later arguments appear at lower addresses. (The stack always
1810 grows towards higher addresses.)
1812 We simply allocate the appropriate amount of stack space and put
1813 arguments into their proper slots. The call dummy code will copy
1814 arguments into registers as needed by the ABI. */
1817 hppa_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1818 int struct_return
, CORE_ADDR struct_addr
)
1820 /* array of arguments' offsets */
1821 int *offset
= (int *) alloca (nargs
* sizeof (int));
1823 /* array of arguments' lengths: real lengths in bytes, not aligned to
1825 int *lengths
= (int *) alloca (nargs
* sizeof (int));
1827 /* The number of stack bytes occupied by the current argument. */
1830 /* The total number of bytes reserved for the arguments. */
1831 int cum_bytes_reserved
= 0;
1833 /* Similarly, but aligned. */
1834 int cum_bytes_aligned
= 0;
1837 /* Iterate over each argument provided by the user. */
1838 for (i
= 0; i
< nargs
; i
++)
1840 lengths
[i
] = TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1842 /* Align the size of the argument to the word size for this
1844 bytes_reserved
= (lengths
[i
] + REGISTER_SIZE
- 1) & -REGISTER_SIZE
;
1846 offset
[i
] = (cum_bytes_reserved
1847 + (lengths
[i
] > 4 ? bytes_reserved
: lengths
[i
]));
1849 /* If the argument is a double word argument, then it needs to be
1850 double word aligned. */
1851 if ((bytes_reserved
== 2 * REGISTER_SIZE
)
1852 && (offset
[i
] % 2 * REGISTER_SIZE
))
1855 /* BYTES_RESERVED is already aligned to the word, so we put
1856 the argument at one word more down the stack.
1858 This will leave one empty word on the stack, and one unused
1859 register as mandated by the ABI. */
1860 new_offset
= ((offset
[i
] + 2 * REGISTER_SIZE
- 1)
1861 & -(2 * REGISTER_SIZE
));
1863 if ((new_offset
- offset
[i
]) >= 2 * REGISTER_SIZE
)
1865 bytes_reserved
+= REGISTER_SIZE
;
1866 offset
[i
] += REGISTER_SIZE
;
1870 cum_bytes_reserved
+= bytes_reserved
;
1874 /* CUM_BYTES_RESERVED already accounts for all the arguments passed
1875 by the user. However, the ABI mandates minimum stack space
1876 allocations for outgoing arguments.
1878 The ABI also mandates minimum stack alignments which we must
1880 cum_bytes_aligned
= STACK_ALIGN (cum_bytes_reserved
);
1881 sp
+= max (cum_bytes_aligned
, REG_PARM_STACK_SPACE
);
1883 /* Now write each of the args at the proper offset down the stack.
1884 ?!? We need to promote values to a full register instead of skipping
1885 words in the stack. */
1886 for (i
= 0; i
< nargs
; i
++)
1887 write_memory (sp
- offset
[i
], VALUE_CONTENTS (args
[i
]), lengths
[i
]);
1889 /* If a structure has to be returned, set up register 28 to hold its
1892 write_register (28, struct_addr
);
1894 /* The stack will have 32 bytes of additional space for a frame marker. */
1900 /* elz: this function returns a value which is built looking at the given address.
1901 It is called from call_function_by_hand, in case we need to return a
1902 value which is larger than 64 bits, and it is stored in the stack rather than
1903 in the registers r28 and r29 or fr4.
1904 This function does the same stuff as value_being_returned in values.c, but
1905 gets the value from the stack rather than from the buffer where all the
1906 registers were saved when the function called completed. */
1908 hppa_value_returned_from_stack (register struct type
*valtype
, CORE_ADDR addr
)
1910 register struct value
*val
;
1912 val
= allocate_value (valtype
);
1913 CHECK_TYPEDEF (valtype
);
1914 target_read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (valtype
));
1921 /* elz: Used to lookup a symbol in the shared libraries.
1922 This function calls shl_findsym, indirectly through a
1923 call to __d_shl_get. __d_shl_get is in end.c, which is always
1924 linked in by the hp compilers/linkers.
1925 The call to shl_findsym cannot be made directly because it needs
1926 to be active in target address space.
1927 inputs: - minimal symbol pointer for the function we want to look up
1928 - address in target space of the descriptor for the library
1929 where we want to look the symbol up.
1930 This address is retrieved using the
1931 som_solib_get_solib_by_pc function (somsolib.c).
1932 output: - real address in the library of the function.
1933 note: the handle can be null, in which case shl_findsym will look for
1934 the symbol in all the loaded shared libraries.
1935 files to look at if you need reference on this stuff:
1936 dld.c, dld_shl_findsym.c
1938 man entry for shl_findsym */
1941 find_stub_with_shl_get (struct minimal_symbol
*function
, CORE_ADDR handle
)
1943 struct symbol
*get_sym
, *symbol2
;
1944 struct minimal_symbol
*buff_minsym
, *msymbol
;
1946 struct value
**args
;
1947 struct value
*funcval
;
1950 int x
, namelen
, err_value
, tmp
= -1;
1951 CORE_ADDR endo_buff_addr
, value_return_addr
, errno_return_addr
;
1952 CORE_ADDR stub_addr
;
1955 args
= alloca (sizeof (struct value
*) * 8); /* 6 for the arguments and one null one??? */
1956 funcval
= find_function_in_inferior ("__d_shl_get");
1957 get_sym
= lookup_symbol ("__d_shl_get", NULL
, VAR_NAMESPACE
, NULL
, NULL
);
1958 buff_minsym
= lookup_minimal_symbol ("__buffer", NULL
, NULL
);
1959 msymbol
= lookup_minimal_symbol ("__shldp", NULL
, NULL
);
1960 symbol2
= lookup_symbol ("__shldp", NULL
, VAR_NAMESPACE
, NULL
, NULL
);
1961 endo_buff_addr
= SYMBOL_VALUE_ADDRESS (buff_minsym
);
1962 namelen
= strlen (SYMBOL_NAME (function
));
1963 value_return_addr
= endo_buff_addr
+ namelen
;
1964 ftype
= check_typedef (SYMBOL_TYPE (get_sym
));
1967 if ((x
= value_return_addr
% 64) != 0)
1968 value_return_addr
= value_return_addr
+ 64 - x
;
1970 errno_return_addr
= value_return_addr
+ 64;
1973 /* set up stuff needed by __d_shl_get in buffer in end.o */
1975 target_write_memory (endo_buff_addr
, SYMBOL_NAME (function
), namelen
);
1977 target_write_memory (value_return_addr
, (char *) &tmp
, 4);
1979 target_write_memory (errno_return_addr
, (char *) &tmp
, 4);
1981 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol
),
1982 (char *) &handle
, 4);
1984 /* now prepare the arguments for the call */
1986 args
[0] = value_from_longest (TYPE_FIELD_TYPE (ftype
, 0), 12);
1987 args
[1] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 1), SYMBOL_VALUE_ADDRESS (msymbol
));
1988 args
[2] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 2), endo_buff_addr
);
1989 args
[3] = value_from_longest (TYPE_FIELD_TYPE (ftype
, 3), TYPE_PROCEDURE
);
1990 args
[4] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 4), value_return_addr
);
1991 args
[5] = value_from_pointer (TYPE_FIELD_TYPE (ftype
, 5), errno_return_addr
);
1993 /* now call the function */
1995 val
= call_function_by_hand (funcval
, 6, args
);
1997 /* now get the results */
1999 target_read_memory (errno_return_addr
, (char *) &err_value
, sizeof (err_value
));
2001 target_read_memory (value_return_addr
, (char *) &stub_addr
, sizeof (stub_addr
));
2003 error ("call to __d_shl_get failed, error code is %d", err_value
);
2008 /* Cover routine for find_stub_with_shl_get to pass to catch_errors */
2010 cover_find_stub_with_shl_get (PTR args_untyped
)
2012 args_for_find_stub
*args
= args_untyped
;
2013 args
->return_val
= find_stub_with_shl_get (args
->msym
, args
->solib_handle
);
2017 /* Insert the specified number of args and function address
2018 into a call sequence of the above form stored at DUMMYNAME.
2020 On the hppa we need to call the stack dummy through $$dyncall.
2021 Therefore our version of FIX_CALL_DUMMY takes an extra argument,
2022 real_pc, which is the location where gdb should start up the
2023 inferior to do the function call.
2025 This has to work across several versions of hpux, bsd, osf1. It has to
2026 work regardless of what compiler was used to build the inferior program.
2027 It should work regardless of whether or not end.o is available. It has
2028 to work even if gdb can not call into the dynamic loader in the inferior
2029 to query it for symbol names and addresses.
2031 Yes, all those cases should work. Luckily code exists to handle most
2032 of them. The complexity is in selecting exactly what scheme should
2033 be used to perform the inferior call.
2035 At the current time this routine is known not to handle cases where
2036 the program was linked with HP's compiler without including end.o.
2038 Please contact Jeff Law (law@cygnus.com) before changing this code. */
2041 hppa_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
2042 struct value
**args
, struct type
*type
, int gcc_p
)
2044 CORE_ADDR dyncall_addr
;
2045 struct minimal_symbol
*msymbol
;
2046 struct minimal_symbol
*trampoline
;
2047 int flags
= read_register (FLAGS_REGNUM
);
2048 struct unwind_table_entry
*u
= NULL
;
2049 CORE_ADDR new_stub
= 0;
2050 CORE_ADDR solib_handle
= 0;
2052 /* Nonzero if we will use GCC's PLT call routine. This routine must be
2053 passed an import stub, not a PLABEL. It is also necessary to set %r19
2054 (the PIC register) before performing the call.
2056 If zero, then we are using __d_plt_call (HP's PLT call routine) or we
2057 are calling the target directly. When using __d_plt_call we want to
2058 use a PLABEL instead of an import stub. */
2059 int using_gcc_plt_call
= 1;
2061 #ifdef GDB_TARGET_IS_HPPA_20W
2062 /* We currently use completely different code for the PA2.0W inferior
2063 function call sequences. This needs to be cleaned up. */
2065 CORE_ADDR pcsqh
, pcsqt
, pcoqh
, pcoqt
, sr5
;
2066 struct target_waitstatus w
;
2070 struct objfile
*objfile
;
2072 /* We can not modify the PC space queues directly, so we start
2073 up the inferior and execute a couple instructions to set the
2074 space queues so that they point to the call dummy in the stack. */
2075 pcsqh
= read_register (PCSQ_HEAD_REGNUM
);
2076 sr5
= read_register (SR5_REGNUM
);
2079 pcoqh
= read_register (PCOQ_HEAD_REGNUM
);
2080 pcoqt
= read_register (PCOQ_TAIL_REGNUM
);
2081 if (target_read_memory (pcoqh
, buf
, 4) != 0)
2082 error ("Couldn't modify space queue\n");
2083 inst1
= extract_unsigned_integer (buf
, 4);
2085 if (target_read_memory (pcoqt
, buf
, 4) != 0)
2086 error ("Couldn't modify space queue\n");
2087 inst2
= extract_unsigned_integer (buf
, 4);
2090 *((int *) buf
) = 0xe820d000;
2091 if (target_write_memory (pcoqh
, buf
, 4) != 0)
2092 error ("Couldn't modify space queue\n");
2095 *((int *) buf
) = 0x08000240;
2096 if (target_write_memory (pcoqt
, buf
, 4) != 0)
2098 *((int *) buf
) = inst1
;
2099 target_write_memory (pcoqh
, buf
, 4);
2100 error ("Couldn't modify space queue\n");
2103 write_register (1, pc
);
2105 /* Single step twice, the BVE instruction will set the space queue
2106 such that it points to the PC value written immediately above
2107 (ie the call dummy). */
2109 target_wait (inferior_ptid
, &w
);
2111 target_wait (inferior_ptid
, &w
);
2113 /* Restore the two instructions at the old PC locations. */
2114 *((int *) buf
) = inst1
;
2115 target_write_memory (pcoqh
, buf
, 4);
2116 *((int *) buf
) = inst2
;
2117 target_write_memory (pcoqt
, buf
, 4);
2120 /* The call dummy wants the ultimate destination address initially
2122 write_register (5, fun
);
2124 /* We need to see if this objfile has a different DP value than our
2125 own (it could be a shared library for example). */
2126 ALL_OBJFILES (objfile
)
2128 struct obj_section
*s
;
2129 obj_private_data_t
*obj_private
;
2131 /* See if FUN is in any section within this shared library. */
2132 for (s
= objfile
->sections
; s
< objfile
->sections_end
; s
++)
2133 if (s
->addr
<= fun
&& fun
< s
->endaddr
)
2136 if (s
>= objfile
->sections_end
)
2139 obj_private
= (obj_private_data_t
*) objfile
->obj_private
;
2141 /* The DP value may be different for each objfile. But within an
2142 objfile each function uses the same dp value. Thus we do not need
2143 to grope around the opd section looking for dp values.
2145 ?!? This is not strictly correct since we may be in a shared library
2146 and want to call back into the main program. To make that case
2147 work correctly we need to set obj_private->dp for the main program's
2148 objfile, then remove this conditional. */
2149 if (obj_private
->dp
)
2150 write_register (27, obj_private
->dp
);
2157 #ifndef GDB_TARGET_IS_HPPA_20W
2158 /* Prefer __gcc_plt_call over the HP supplied routine because
2159 __gcc_plt_call works for any number of arguments. */
2161 if (lookup_minimal_symbol ("__gcc_plt_call", NULL
, NULL
) == NULL
)
2162 using_gcc_plt_call
= 0;
2164 msymbol
= lookup_minimal_symbol ("$$dyncall", NULL
, NULL
);
2165 if (msymbol
== NULL
)
2166 error ("Can't find an address for $$dyncall trampoline");
2168 dyncall_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
2170 /* FUN could be a procedure label, in which case we have to get
2171 its real address and the value of its GOT/DP if we plan to
2172 call the routine via gcc_plt_call. */
2173 if ((fun
& 0x2) && using_gcc_plt_call
)
2175 /* Get the GOT/DP value for the target function. It's
2176 at *(fun+4). Note the call dummy is *NOT* allowed to
2177 trash %r19 before calling the target function. */
2178 write_register (19, read_memory_integer ((fun
& ~0x3) + 4,
2181 /* Now get the real address for the function we are calling, it's
2183 fun
= (CORE_ADDR
) read_memory_integer (fun
& ~0x3,
2184 TARGET_PTR_BIT
/ 8);
2189 #ifndef GDB_TARGET_IS_PA_ELF
2190 /* FUN could be an export stub, the real address of a function, or
2191 a PLABEL. When using gcc's PLT call routine we must call an import
2192 stub rather than the export stub or real function for lazy binding
2195 If we are using the gcc PLT call routine, then we need to
2196 get the import stub for the target function. */
2197 if (using_gcc_plt_call
&& som_solib_get_got_by_pc (fun
))
2199 struct objfile
*objfile
;
2200 struct minimal_symbol
*funsymbol
, *stub_symbol
;
2201 CORE_ADDR newfun
= 0;
2203 funsymbol
= lookup_minimal_symbol_by_pc (fun
);
2205 error ("Unable to find minimal symbol for target function.\n");
2207 /* Search all the object files for an import symbol with the
2209 ALL_OBJFILES (objfile
)
2212 = lookup_minimal_symbol_solib_trampoline
2213 (SYMBOL_NAME (funsymbol
), NULL
, objfile
);
2216 stub_symbol
= lookup_minimal_symbol (SYMBOL_NAME (funsymbol
),
2219 /* Found a symbol with the right name. */
2222 struct unwind_table_entry
*u
;
2223 /* It must be a shared library trampoline. */
2224 if (MSYMBOL_TYPE (stub_symbol
) != mst_solib_trampoline
)
2227 /* It must also be an import stub. */
2228 u
= find_unwind_entry (SYMBOL_VALUE (stub_symbol
));
2230 || (u
->stub_unwind
.stub_type
!= IMPORT
2231 #ifdef GDB_NATIVE_HPUX_11
2232 /* Sigh. The hpux 10.20 dynamic linker will blow
2233 chunks if we perform a call to an unbound function
2234 via the IMPORT_SHLIB stub. The hpux 11.00 dynamic
2235 linker will blow chunks if we do not call the
2236 unbound function via the IMPORT_SHLIB stub.
2238 We currently have no way to select bevahior on just
2239 the target. However, we only support HPUX/SOM in
2240 native mode. So we conditinalize on a native
2241 #ifdef. Ugly. Ugly. Ugly */
2242 && u
->stub_unwind
.stub_type
!= IMPORT_SHLIB
2247 /* OK. Looks like the correct import stub. */
2248 newfun
= SYMBOL_VALUE (stub_symbol
);
2251 /* If we found an IMPORT stub, then we want to stop
2252 searching now. If we found an IMPORT_SHLIB, we want
2253 to continue the search in the hopes that we will find
2255 if (u
->stub_unwind
.stub_type
== IMPORT
)
2260 /* Ouch. We did not find an import stub. Make an attempt to
2261 do the right thing instead of just croaking. Most of the
2262 time this will actually work. */
2264 write_register (19, som_solib_get_got_by_pc (fun
));
2266 u
= find_unwind_entry (fun
);
2268 && (u
->stub_unwind
.stub_type
== IMPORT
2269 || u
->stub_unwind
.stub_type
== IMPORT_SHLIB
))
2270 trampoline
= lookup_minimal_symbol ("__gcc_plt_call", NULL
, NULL
);
2272 /* If we found the import stub in the shared library, then we have
2273 to set %r19 before we call the stub. */
2274 if (u
&& u
->stub_unwind
.stub_type
== IMPORT_SHLIB
)
2275 write_register (19, som_solib_get_got_by_pc (fun
));
2280 /* If we are calling into another load module then have sr4export call the
2281 magic __d_plt_call routine which is linked in from end.o.
2283 You can't use _sr4export to make the call as the value in sp-24 will get
2284 fried and you end up returning to the wrong location. You can't call the
2285 target as the code to bind the PLT entry to a function can't return to a
2288 Also, query the dynamic linker in the inferior to provide a suitable
2289 PLABEL for the target function. */
2290 if (!using_gcc_plt_call
)
2294 /* Get a handle for the shared library containing FUN. Given the
2295 handle we can query the shared library for a PLABEL. */
2296 solib_handle
= som_solib_get_solib_by_pc (fun
);
2300 struct minimal_symbol
*fmsymbol
= lookup_minimal_symbol_by_pc (fun
);
2302 trampoline
= lookup_minimal_symbol ("__d_plt_call", NULL
, NULL
);
2304 if (trampoline
== NULL
)
2306 error ("Can't find an address for __d_plt_call or __gcc_plt_call trampoline\nSuggest linking executable with -g or compiling with gcc.");
2309 /* This is where sr4export will jump to. */
2310 new_fun
= SYMBOL_VALUE_ADDRESS (trampoline
);
2312 /* If the function is in a shared library, then call __d_shl_get to
2313 get a PLABEL for the target function. */
2314 new_stub
= find_stub_with_shl_get (fmsymbol
, solib_handle
);
2317 error ("Can't find an import stub for %s", SYMBOL_NAME (fmsymbol
));
2319 /* We have to store the address of the stub in __shlib_funcptr. */
2320 msymbol
= lookup_minimal_symbol ("__shlib_funcptr", NULL
,
2321 (struct objfile
*) NULL
);
2323 if (msymbol
== NULL
)
2324 error ("Can't find an address for __shlib_funcptr");
2325 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol
),
2326 (char *) &new_stub
, 4);
2328 /* We want sr4export to call __d_plt_call, so we claim it is
2329 the final target. Clear trampoline. */
2335 /* Store upper 21 bits of function address into ldil. fun will either be
2336 the final target (most cases) or __d_plt_call when calling into a shared
2337 library and __gcc_plt_call is not available. */
2338 store_unsigned_integer
2339 (&dummy
[FUNC_LDIL_OFFSET
],
2341 deposit_21 (fun
>> 11,
2342 extract_unsigned_integer (&dummy
[FUNC_LDIL_OFFSET
],
2343 INSTRUCTION_SIZE
)));
2345 /* Store lower 11 bits of function address into ldo */
2346 store_unsigned_integer
2347 (&dummy
[FUNC_LDO_OFFSET
],
2349 deposit_14 (fun
& MASK_11
,
2350 extract_unsigned_integer (&dummy
[FUNC_LDO_OFFSET
],
2351 INSTRUCTION_SIZE
)));
2352 #ifdef SR4EXPORT_LDIL_OFFSET
2355 CORE_ADDR trampoline_addr
;
2357 /* We may still need sr4export's address too. */
2359 if (trampoline
== NULL
)
2361 msymbol
= lookup_minimal_symbol ("_sr4export", NULL
, NULL
);
2362 if (msymbol
== NULL
)
2363 error ("Can't find an address for _sr4export trampoline");
2365 trampoline_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
2368 trampoline_addr
= SYMBOL_VALUE_ADDRESS (trampoline
);
2371 /* Store upper 21 bits of trampoline's address into ldil */
2372 store_unsigned_integer
2373 (&dummy
[SR4EXPORT_LDIL_OFFSET
],
2375 deposit_21 (trampoline_addr
>> 11,
2376 extract_unsigned_integer (&dummy
[SR4EXPORT_LDIL_OFFSET
],
2377 INSTRUCTION_SIZE
)));
2379 /* Store lower 11 bits of trampoline's address into ldo */
2380 store_unsigned_integer
2381 (&dummy
[SR4EXPORT_LDO_OFFSET
],
2383 deposit_14 (trampoline_addr
& MASK_11
,
2384 extract_unsigned_integer (&dummy
[SR4EXPORT_LDO_OFFSET
],
2385 INSTRUCTION_SIZE
)));
2389 write_register (22, pc
);
2391 /* If we are in a syscall, then we should call the stack dummy
2392 directly. $$dyncall is not needed as the kernel sets up the
2393 space id registers properly based on the value in %r31. In
2394 fact calling $$dyncall will not work because the value in %r22
2395 will be clobbered on the syscall exit path.
2397 Similarly if the current PC is in a shared library. Note however,
2398 this scheme won't work if the shared library isn't mapped into
2399 the same space as the stack. */
2402 #ifndef GDB_TARGET_IS_PA_ELF
2403 else if (som_solib_get_got_by_pc (target_read_pc (inferior_ptid
)))
2407 return dyncall_addr
;
2414 /* If the pid is in a syscall, then the FP register is not readable.
2415 We'll return zero in that case, rather than attempting to read it
2416 and cause a warning. */
2418 target_read_fp (int pid
)
2420 int flags
= read_register (FLAGS_REGNUM
);
2424 return (CORE_ADDR
) 0;
2427 /* This is the only site that may directly read_register () the FP
2428 register. All others must use TARGET_READ_FP (). */
2429 return read_register (FP_REGNUM
);
2433 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
2437 target_read_pc (ptid_t ptid
)
2439 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
2441 /* The following test does not belong here. It is OS-specific, and belongs
2443 /* Test SS_INSYSCALL */
2445 return read_register_pid (31, ptid
) & ~0x3;
2447 return read_register_pid (PC_REGNUM
, ptid
) & ~0x3;
2450 /* Write out the PC. If currently in a syscall, then also write the new
2451 PC value into %r31. */
2454 target_write_pc (CORE_ADDR v
, ptid_t ptid
)
2456 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
2458 /* The following test does not belong here. It is OS-specific, and belongs
2460 /* If in a syscall, then set %r31. Also make sure to get the
2461 privilege bits set correctly. */
2462 /* Test SS_INSYSCALL */
2464 write_register_pid (31, v
| 0x3, ptid
);
2466 write_register_pid (PC_REGNUM
, v
, ptid
);
2467 write_register_pid (NPC_REGNUM
, v
+ 4, ptid
);
2470 /* return the alignment of a type in bytes. Structures have the maximum
2471 alignment required by their fields. */
2474 hppa_alignof (struct type
*type
)
2476 int max_align
, align
, i
;
2477 CHECK_TYPEDEF (type
);
2478 switch (TYPE_CODE (type
))
2483 return TYPE_LENGTH (type
);
2484 case TYPE_CODE_ARRAY
:
2485 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
2486 case TYPE_CODE_STRUCT
:
2487 case TYPE_CODE_UNION
:
2489 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
2491 /* Bit fields have no real alignment. */
2492 /* if (!TYPE_FIELD_BITPOS (type, i)) */
2493 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
2495 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
2496 max_align
= max (max_align
, align
);
2505 /* Print the register regnum, or all registers if regnum is -1 */
2508 pa_do_registers_info (int regnum
, int fpregs
)
2510 char raw_regs
[REGISTER_BYTES
];
2513 /* Make a copy of gdb's save area (may cause actual
2514 reads from the target). */
2515 for (i
= 0; i
< NUM_REGS
; i
++)
2516 frame_register_read (deprecated_selected_frame
, i
, raw_regs
+ REGISTER_BYTE (i
));
2519 pa_print_registers (raw_regs
, regnum
, fpregs
);
2520 else if (regnum
< FP4_REGNUM
)
2524 /* Why is the value not passed through "extract_signed_integer"
2525 as in "pa_print_registers" below? */
2526 pa_register_look_aside (raw_regs
, regnum
, ®_val
[0]);
2530 printf_unfiltered ("%s %lx\n", REGISTER_NAME (regnum
), reg_val
[1]);
2534 /* Fancy % formats to prevent leading zeros. */
2535 if (reg_val
[0] == 0)
2536 printf_unfiltered ("%s %lx\n", REGISTER_NAME (regnum
), reg_val
[1]);
2538 printf_unfiltered ("%s %lx%8.8lx\n", REGISTER_NAME (regnum
),
2539 reg_val
[0], reg_val
[1]);
2543 /* Note that real floating point values only start at
2544 FP4_REGNUM. FP0 and up are just status and error
2545 registers, which have integral (bit) values. */
2546 pa_print_fp_reg (regnum
);
2549 /********** new function ********************/
2551 pa_do_strcat_registers_info (int regnum
, int fpregs
, struct ui_file
*stream
,
2552 enum precision_type precision
)
2554 char raw_regs
[REGISTER_BYTES
];
2557 /* Make a copy of gdb's save area (may cause actual
2558 reads from the target). */
2559 for (i
= 0; i
< NUM_REGS
; i
++)
2560 frame_register_read (deprecated_selected_frame
, i
, raw_regs
+ REGISTER_BYTE (i
));
2563 pa_strcat_registers (raw_regs
, regnum
, fpregs
, stream
);
2565 else if (regnum
< FP4_REGNUM
)
2569 /* Why is the value not passed through "extract_signed_integer"
2570 as in "pa_print_registers" below? */
2571 pa_register_look_aside (raw_regs
, regnum
, ®_val
[0]);
2575 fprintf_unfiltered (stream
, "%s %lx", REGISTER_NAME (regnum
), reg_val
[1]);
2579 /* Fancy % formats to prevent leading zeros. */
2580 if (reg_val
[0] == 0)
2581 fprintf_unfiltered (stream
, "%s %lx", REGISTER_NAME (regnum
),
2584 fprintf_unfiltered (stream
, "%s %lx%8.8lx", REGISTER_NAME (regnum
),
2585 reg_val
[0], reg_val
[1]);
2589 /* Note that real floating point values only start at
2590 FP4_REGNUM. FP0 and up are just status and error
2591 registers, which have integral (bit) values. */
2592 pa_strcat_fp_reg (regnum
, stream
, precision
);
2595 /* If this is a PA2.0 machine, fetch the real 64-bit register
2596 value. Otherwise use the info from gdb's saved register area.
2598 Note that reg_val is really expected to be an array of longs,
2599 with two elements. */
2601 pa_register_look_aside (char *raw_regs
, int regnum
, long *raw_val
)
2603 static int know_which
= 0; /* False */
2606 unsigned int offset
;
2611 char buf
[MAX_REGISTER_RAW_SIZE
];
2616 if (CPU_PA_RISC2_0
== sysconf (_SC_CPU_VERSION
))
2621 know_which
= 1; /* True */
2629 raw_val
[1] = *(long *) (raw_regs
+ REGISTER_BYTE (regnum
));
2633 /* Code below copied from hppah-nat.c, with fixes for wide
2634 registers, using different area of save_state, etc. */
2635 if (regnum
== FLAGS_REGNUM
|| regnum
>= FP0_REGNUM
||
2636 !HAVE_STRUCT_SAVE_STATE_T
|| !HAVE_STRUCT_MEMBER_SS_WIDE
)
2638 /* Use narrow regs area of save_state and default macro. */
2639 offset
= U_REGS_OFFSET
;
2640 regaddr
= register_addr (regnum
, offset
);
2645 /* Use wide regs area, and calculate registers as 8 bytes wide.
2647 We'd like to do this, but current version of "C" doesn't
2650 offset = offsetof(save_state_t, ss_wide);
2652 Note that to avoid "C" doing typed pointer arithmetic, we
2653 have to cast away the type in our offset calculation:
2654 otherwise we get an offset of 1! */
2656 /* NB: save_state_t is not available before HPUX 9.
2657 The ss_wide field is not available previous to HPUX 10.20,
2658 so to avoid compile-time warnings, we only compile this for
2659 PA 2.0 processors. This control path should only be followed
2660 if we're debugging a PA 2.0 processor, so this should not cause
2663 /* #if the following code out so that this file can still be
2664 compiled on older HPUX boxes (< 10.20) which don't have
2665 this structure/structure member. */
2666 #if HAVE_STRUCT_SAVE_STATE_T == 1 && HAVE_STRUCT_MEMBER_SS_WIDE == 1
2669 offset
= ((int) &temp
.ss_wide
) - ((int) &temp
);
2670 regaddr
= offset
+ regnum
* 8;
2675 for (i
= start
; i
< 2; i
++)
2678 raw_val
[i
] = call_ptrace (PT_RUREGS
, PIDGET (inferior_ptid
),
2679 (PTRACE_ARG3_TYPE
) regaddr
, 0);
2682 /* Warning, not error, in case we are attached; sometimes the
2683 kernel doesn't let us at the registers. */
2684 char *err
= safe_strerror (errno
);
2685 char *msg
= alloca (strlen (err
) + 128);
2686 sprintf (msg
, "reading register %s: %s", REGISTER_NAME (regnum
), err
);
2691 regaddr
+= sizeof (long);
2694 if (regnum
== PCOQ_HEAD_REGNUM
|| regnum
== PCOQ_TAIL_REGNUM
)
2695 raw_val
[1] &= ~0x3; /* I think we're masking out space bits */
2701 /* "Info all-reg" command */
2704 pa_print_registers (char *raw_regs
, int regnum
, int fpregs
)
2707 /* Alas, we are compiled so that "long long" is 32 bits */
2710 int rows
= 48, columns
= 2;
2712 for (i
= 0; i
< rows
; i
++)
2714 for (j
= 0; j
< columns
; j
++)
2716 /* We display registers in column-major order. */
2717 int regnum
= i
+ j
* rows
;
2719 /* Q: Why is the value passed through "extract_signed_integer",
2720 while above, in "pa_do_registers_info" it isn't?
2722 pa_register_look_aside (raw_regs
, regnum
, &raw_val
[0]);
2724 /* Even fancier % formats to prevent leading zeros
2725 and still maintain the output in columns. */
2728 /* Being big-endian, on this machine the low bits
2729 (the ones we want to look at) are in the second longword. */
2730 long_val
= extract_signed_integer (&raw_val
[1], 4);
2731 printf_filtered ("%10.10s: %8lx ",
2732 REGISTER_NAME (regnum
), long_val
);
2736 /* raw_val = extract_signed_integer(&raw_val, 8); */
2737 if (raw_val
[0] == 0)
2738 printf_filtered ("%10.10s: %8lx ",
2739 REGISTER_NAME (regnum
), raw_val
[1]);
2741 printf_filtered ("%10.10s: %8lx%8.8lx ",
2742 REGISTER_NAME (regnum
),
2743 raw_val
[0], raw_val
[1]);
2746 printf_unfiltered ("\n");
2750 for (i
= FP4_REGNUM
; i
< NUM_REGS
; i
++) /* FP4_REGNUM == 72 */
2751 pa_print_fp_reg (i
);
2754 /************* new function ******************/
2756 pa_strcat_registers (char *raw_regs
, int regnum
, int fpregs
,
2757 struct ui_file
*stream
)
2760 long raw_val
[2]; /* Alas, we are compiled so that "long long" is 32 bits */
2762 enum precision_type precision
;
2764 precision
= unspecified_precision
;
2766 for (i
= 0; i
< 18; i
++)
2768 for (j
= 0; j
< 4; j
++)
2770 /* Q: Why is the value passed through "extract_signed_integer",
2771 while above, in "pa_do_registers_info" it isn't?
2773 pa_register_look_aside (raw_regs
, i
+ (j
* 18), &raw_val
[0]);
2775 /* Even fancier % formats to prevent leading zeros
2776 and still maintain the output in columns. */
2779 /* Being big-endian, on this machine the low bits
2780 (the ones we want to look at) are in the second longword. */
2781 long_val
= extract_signed_integer (&raw_val
[1], 4);
2782 fprintf_filtered (stream
, "%8.8s: %8lx ",
2783 REGISTER_NAME (i
+ (j
* 18)), long_val
);
2787 /* raw_val = extract_signed_integer(&raw_val, 8); */
2788 if (raw_val
[0] == 0)
2789 fprintf_filtered (stream
, "%8.8s: %8lx ",
2790 REGISTER_NAME (i
+ (j
* 18)), raw_val
[1]);
2792 fprintf_filtered (stream
, "%8.8s: %8lx%8.8lx ",
2793 REGISTER_NAME (i
+ (j
* 18)), raw_val
[0],
2797 fprintf_unfiltered (stream
, "\n");
2801 for (i
= FP4_REGNUM
; i
< NUM_REGS
; i
++) /* FP4_REGNUM == 72 */
2802 pa_strcat_fp_reg (i
, stream
, precision
);
2806 pa_print_fp_reg (int i
)
2808 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
2809 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
2811 /* Get 32bits of data. */
2812 frame_register_read (deprecated_selected_frame
, i
, raw_buffer
);
2814 /* Put it in the buffer. No conversions are ever necessary. */
2815 memcpy (virtual_buffer
, raw_buffer
, REGISTER_RAW_SIZE (i
));
2817 fputs_filtered (REGISTER_NAME (i
), gdb_stdout
);
2818 print_spaces_filtered (8 - strlen (REGISTER_NAME (i
)), gdb_stdout
);
2819 fputs_filtered ("(single precision) ", gdb_stdout
);
2821 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0, gdb_stdout
, 0,
2822 1, 0, Val_pretty_default
);
2823 printf_filtered ("\n");
2825 /* If "i" is even, then this register can also be a double-precision
2826 FP register. Dump it out as such. */
2829 /* Get the data in raw format for the 2nd half. */
2830 frame_register_read (deprecated_selected_frame
, i
+ 1, raw_buffer
);
2832 /* Copy it into the appropriate part of the virtual buffer. */
2833 memcpy (virtual_buffer
+ REGISTER_RAW_SIZE (i
), raw_buffer
,
2834 REGISTER_RAW_SIZE (i
));
2836 /* Dump it as a double. */
2837 fputs_filtered (REGISTER_NAME (i
), gdb_stdout
);
2838 print_spaces_filtered (8 - strlen (REGISTER_NAME (i
)), gdb_stdout
);
2839 fputs_filtered ("(double precision) ", gdb_stdout
);
2841 val_print (builtin_type_double
, virtual_buffer
, 0, 0, gdb_stdout
, 0,
2842 1, 0, Val_pretty_default
);
2843 printf_filtered ("\n");
2847 /*************** new function ***********************/
2849 pa_strcat_fp_reg (int i
, struct ui_file
*stream
, enum precision_type precision
)
2851 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
2852 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
2854 fputs_filtered (REGISTER_NAME (i
), stream
);
2855 print_spaces_filtered (8 - strlen (REGISTER_NAME (i
)), stream
);
2857 /* Get 32bits of data. */
2858 frame_register_read (deprecated_selected_frame
, i
, raw_buffer
);
2860 /* Put it in the buffer. No conversions are ever necessary. */
2861 memcpy (virtual_buffer
, raw_buffer
, REGISTER_RAW_SIZE (i
));
2863 if (precision
== double_precision
&& (i
% 2) == 0)
2866 char raw_buf
[MAX_REGISTER_RAW_SIZE
];
2868 /* Get the data in raw format for the 2nd half. */
2869 frame_register_read (deprecated_selected_frame
, i
+ 1, raw_buf
);
2871 /* Copy it into the appropriate part of the virtual buffer. */
2872 memcpy (virtual_buffer
+ REGISTER_RAW_SIZE (i
), raw_buf
, REGISTER_RAW_SIZE (i
));
2874 val_print (builtin_type_double
, virtual_buffer
, 0, 0, stream
, 0,
2875 1, 0, Val_pretty_default
);
2880 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0, stream
, 0,
2881 1, 0, Val_pretty_default
);
2886 /* Return one if PC is in the call path of a trampoline, else return zero.
2888 Note we return one for *any* call trampoline (long-call, arg-reloc), not
2889 just shared library trampolines (import, export). */
2892 in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
2894 struct minimal_symbol
*minsym
;
2895 struct unwind_table_entry
*u
;
2896 static CORE_ADDR dyncall
= 0;
2897 static CORE_ADDR sr4export
= 0;
2899 #ifdef GDB_TARGET_IS_HPPA_20W
2900 /* PA64 has a completely different stub/trampoline scheme. Is it
2901 better? Maybe. It's certainly harder to determine with any
2902 certainty that we are in a stub because we can not refer to the
2905 The heuristic is simple. Try to lookup the current PC value in th
2906 minimal symbol table. If that fails, then assume we are not in a
2909 Then see if the PC value falls within the section bounds for the
2910 section containing the minimal symbol we found in the first
2911 step. If it does, then assume we are not in a stub and return.
2913 Finally peek at the instructions to see if they look like a stub. */
2915 struct minimal_symbol
*minsym
;
2920 minsym
= lookup_minimal_symbol_by_pc (pc
);
2924 sec
= SYMBOL_BFD_SECTION (minsym
);
2927 && sec
->vma
+ sec
->_cooked_size
< pc
)
2930 /* We might be in a stub. Peek at the instructions. Stubs are 3
2931 instructions long. */
2932 insn
= read_memory_integer (pc
, 4);
2934 /* Find out where we think we are within the stub. */
2935 if ((insn
& 0xffffc00e) == 0x53610000)
2937 else if ((insn
& 0xffffffff) == 0xe820d000)
2939 else if ((insn
& 0xffffc00e) == 0x537b0000)
2944 /* Now verify each insn in the range looks like a stub instruction. */
2945 insn
= read_memory_integer (addr
, 4);
2946 if ((insn
& 0xffffc00e) != 0x53610000)
2949 /* Now verify each insn in the range looks like a stub instruction. */
2950 insn
= read_memory_integer (addr
+ 4, 4);
2951 if ((insn
& 0xffffffff) != 0xe820d000)
2954 /* Now verify each insn in the range looks like a stub instruction. */
2955 insn
= read_memory_integer (addr
+ 8, 4);
2956 if ((insn
& 0xffffc00e) != 0x537b0000)
2959 /* Looks like a stub. */
2964 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
2967 /* First see if PC is in one of the two C-library trampolines. */
2970 minsym
= lookup_minimal_symbol ("$$dyncall", NULL
, NULL
);
2972 dyncall
= SYMBOL_VALUE_ADDRESS (minsym
);
2979 minsym
= lookup_minimal_symbol ("_sr4export", NULL
, NULL
);
2981 sr4export
= SYMBOL_VALUE_ADDRESS (minsym
);
2986 if (pc
== dyncall
|| pc
== sr4export
)
2989 minsym
= lookup_minimal_symbol_by_pc (pc
);
2990 if (minsym
&& strcmp (SYMBOL_NAME (minsym
), ".stub") == 0)
2993 /* Get the unwind descriptor corresponding to PC, return zero
2994 if no unwind was found. */
2995 u
= find_unwind_entry (pc
);
2999 /* If this isn't a linker stub, then return now. */
3000 if (u
->stub_unwind
.stub_type
== 0)
3003 /* By definition a long-branch stub is a call stub. */
3004 if (u
->stub_unwind
.stub_type
== LONG_BRANCH
)
3007 /* The call and return path execute the same instructions within
3008 an IMPORT stub! So an IMPORT stub is both a call and return
3010 if (u
->stub_unwind
.stub_type
== IMPORT
)
3013 /* Parameter relocation stubs always have a call path and may have a
3015 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
3016 || u
->stub_unwind
.stub_type
== EXPORT
)
3020 /* Search forward from the current PC until we hit a branch
3021 or the end of the stub. */
3022 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
3026 insn
= read_memory_integer (addr
, 4);
3028 /* Does it look like a bl? If so then it's the call path, if
3029 we find a bv or be first, then we're on the return path. */
3030 if ((insn
& 0xfc00e000) == 0xe8000000)
3032 else if ((insn
& 0xfc00e001) == 0xe800c000
3033 || (insn
& 0xfc000000) == 0xe0000000)
3037 /* Should never happen. */
3038 warning ("Unable to find branch in parameter relocation stub.\n");
3042 /* Unknown stub type. For now, just return zero. */
3046 /* Return one if PC is in the return path of a trampoline, else return zero.
3048 Note we return one for *any* call trampoline (long-call, arg-reloc), not
3049 just shared library trampolines (import, export). */
3052 in_solib_return_trampoline (CORE_ADDR pc
, char *name
)
3054 struct unwind_table_entry
*u
;
3056 /* Get the unwind descriptor corresponding to PC, return zero
3057 if no unwind was found. */
3058 u
= find_unwind_entry (pc
);
3062 /* If this isn't a linker stub or it's just a long branch stub, then
3064 if (u
->stub_unwind
.stub_type
== 0 || u
->stub_unwind
.stub_type
== LONG_BRANCH
)
3067 /* The call and return path execute the same instructions within
3068 an IMPORT stub! So an IMPORT stub is both a call and return
3070 if (u
->stub_unwind
.stub_type
== IMPORT
)
3073 /* Parameter relocation stubs always have a call path and may have a
3075 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
3076 || u
->stub_unwind
.stub_type
== EXPORT
)
3080 /* Search forward from the current PC until we hit a branch
3081 or the end of the stub. */
3082 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
3086 insn
= read_memory_integer (addr
, 4);
3088 /* Does it look like a bl? If so then it's the call path, if
3089 we find a bv or be first, then we're on the return path. */
3090 if ((insn
& 0xfc00e000) == 0xe8000000)
3092 else if ((insn
& 0xfc00e001) == 0xe800c000
3093 || (insn
& 0xfc000000) == 0xe0000000)
3097 /* Should never happen. */
3098 warning ("Unable to find branch in parameter relocation stub.\n");
3102 /* Unknown stub type. For now, just return zero. */
3107 /* Figure out if PC is in a trampoline, and if so find out where
3108 the trampoline will jump to. If not in a trampoline, return zero.
3110 Simple code examination probably is not a good idea since the code
3111 sequences in trampolines can also appear in user code.
3113 We use unwinds and information from the minimal symbol table to
3114 determine when we're in a trampoline. This won't work for ELF
3115 (yet) since it doesn't create stub unwind entries. Whether or
3116 not ELF will create stub unwinds or normal unwinds for linker
3117 stubs is still being debated.
3119 This should handle simple calls through dyncall or sr4export,
3120 long calls, argument relocation stubs, and dyncall/sr4export
3121 calling an argument relocation stub. It even handles some stubs
3122 used in dynamic executables. */
3125 skip_trampoline_code (CORE_ADDR pc
, char *name
)
3128 long prev_inst
, curr_inst
, loc
;
3129 static CORE_ADDR dyncall
= 0;
3130 static CORE_ADDR dyncall_external
= 0;
3131 static CORE_ADDR sr4export
= 0;
3132 struct minimal_symbol
*msym
;
3133 struct unwind_table_entry
*u
;
3135 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
3140 msym
= lookup_minimal_symbol ("$$dyncall", NULL
, NULL
);
3142 dyncall
= SYMBOL_VALUE_ADDRESS (msym
);
3147 if (!dyncall_external
)
3149 msym
= lookup_minimal_symbol ("$$dyncall_external", NULL
, NULL
);
3151 dyncall_external
= SYMBOL_VALUE_ADDRESS (msym
);
3153 dyncall_external
= -1;
3158 msym
= lookup_minimal_symbol ("_sr4export", NULL
, NULL
);
3160 sr4export
= SYMBOL_VALUE_ADDRESS (msym
);
3165 /* Addresses passed to dyncall may *NOT* be the actual address
3166 of the function. So we may have to do something special. */
3169 pc
= (CORE_ADDR
) read_register (22);
3171 /* If bit 30 (counting from the left) is on, then pc is the address of
3172 the PLT entry for this function, not the address of the function
3173 itself. Bit 31 has meaning too, but only for MPE. */
3175 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
3177 if (pc
== dyncall_external
)
3179 pc
= (CORE_ADDR
) read_register (22);
3180 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
3182 else if (pc
== sr4export
)
3183 pc
= (CORE_ADDR
) (read_register (22));
3185 /* Get the unwind descriptor corresponding to PC, return zero
3186 if no unwind was found. */
3187 u
= find_unwind_entry (pc
);
3191 /* If this isn't a linker stub, then return now. */
3192 /* elz: attention here! (FIXME) because of a compiler/linker
3193 error, some stubs which should have a non zero stub_unwind.stub_type
3194 have unfortunately a value of zero. So this function would return here
3195 as if we were not in a trampoline. To fix this, we go look at the partial
3196 symbol information, which reports this guy as a stub.
3197 (FIXME): Unfortunately, we are not that lucky: it turns out that the
3198 partial symbol information is also wrong sometimes. This is because
3199 when it is entered (somread.c::som_symtab_read()) it can happen that
3200 if the type of the symbol (from the som) is Entry, and the symbol is
3201 in a shared library, then it can also be a trampoline. This would
3202 be OK, except that I believe the way they decide if we are ina shared library
3203 does not work. SOOOO..., even if we have a regular function w/o trampolines
3204 its minimal symbol can be assigned type mst_solib_trampoline.
3205 Also, if we find that the symbol is a real stub, then we fix the unwind
3206 descriptor, and define the stub type to be EXPORT.
3207 Hopefully this is correct most of the times. */
3208 if (u
->stub_unwind
.stub_type
== 0)
3211 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
3212 we can delete all the code which appears between the lines */
3213 /*--------------------------------------------------------------------------*/
3214 msym
= lookup_minimal_symbol_by_pc (pc
);
3216 if (msym
== NULL
|| MSYMBOL_TYPE (msym
) != mst_solib_trampoline
)
3217 return orig_pc
== pc
? 0 : pc
& ~0x3;
3219 else if (msym
!= NULL
&& MSYMBOL_TYPE (msym
) == mst_solib_trampoline
)
3221 struct objfile
*objfile
;
3222 struct minimal_symbol
*msymbol
;
3223 int function_found
= 0;
3225 /* go look if there is another minimal symbol with the same name as
3226 this one, but with type mst_text. This would happen if the msym
3227 is an actual trampoline, in which case there would be another
3228 symbol with the same name corresponding to the real function */
3230 ALL_MSYMBOLS (objfile
, msymbol
)
3232 if (MSYMBOL_TYPE (msymbol
) == mst_text
3233 && STREQ (SYMBOL_NAME (msymbol
), SYMBOL_NAME (msym
)))
3241 /* the type of msym is correct (mst_solib_trampoline), but
3242 the unwind info is wrong, so set it to the correct value */
3243 u
->stub_unwind
.stub_type
= EXPORT
;
3245 /* the stub type info in the unwind is correct (this is not a
3246 trampoline), but the msym type information is wrong, it
3247 should be mst_text. So we need to fix the msym, and also
3248 get out of this function */
3250 MSYMBOL_TYPE (msym
) = mst_text
;
3251 return orig_pc
== pc
? 0 : pc
& ~0x3;
3255 /*--------------------------------------------------------------------------*/
3258 /* It's a stub. Search for a branch and figure out where it goes.
3259 Note we have to handle multi insn branch sequences like ldil;ble.
3260 Most (all?) other branches can be determined by examining the contents
3261 of certain registers and the stack. */
3268 /* Make sure we haven't walked outside the range of this stub. */
3269 if (u
!= find_unwind_entry (loc
))
3271 warning ("Unable to find branch in linker stub");
3272 return orig_pc
== pc
? 0 : pc
& ~0x3;
3275 prev_inst
= curr_inst
;
3276 curr_inst
= read_memory_integer (loc
, 4);
3278 /* Does it look like a branch external using %r1? Then it's the
3279 branch from the stub to the actual function. */
3280 if ((curr_inst
& 0xffe0e000) == 0xe0202000)
3282 /* Yup. See if the previous instruction loaded
3283 a value into %r1. If so compute and return the jump address. */
3284 if ((prev_inst
& 0xffe00000) == 0x20200000)
3285 return (extract_21 (prev_inst
) + extract_17 (curr_inst
)) & ~0x3;
3288 warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
3289 return orig_pc
== pc
? 0 : pc
& ~0x3;
3293 /* Does it look like a be 0(sr0,%r21)? OR
3294 Does it look like a be, n 0(sr0,%r21)? OR
3295 Does it look like a bve (r21)? (this is on PA2.0)
3296 Does it look like a bve, n(r21)? (this is also on PA2.0)
3297 That's the branch from an
3298 import stub to an export stub.
3300 It is impossible to determine the target of the branch via
3301 simple examination of instructions and/or data (consider
3302 that the address in the plabel may be the address of the
3303 bind-on-reference routine in the dynamic loader).
3305 So we have try an alternative approach.
3307 Get the name of the symbol at our current location; it should
3308 be a stub symbol with the same name as the symbol in the
3311 Then lookup a minimal symbol with the same name; we should
3312 get the minimal symbol for the target routine in the shared
3313 library as those take precedence of import/export stubs. */
3314 if ((curr_inst
== 0xe2a00000) ||
3315 (curr_inst
== 0xe2a00002) ||
3316 (curr_inst
== 0xeaa0d000) ||
3317 (curr_inst
== 0xeaa0d002))
3319 struct minimal_symbol
*stubsym
, *libsym
;
3321 stubsym
= lookup_minimal_symbol_by_pc (loc
);
3322 if (stubsym
== NULL
)
3324 warning ("Unable to find symbol for 0x%lx", loc
);
3325 return orig_pc
== pc
? 0 : pc
& ~0x3;
3328 libsym
= lookup_minimal_symbol (SYMBOL_NAME (stubsym
), NULL
, NULL
);
3331 warning ("Unable to find library symbol for %s\n",
3332 SYMBOL_NAME (stubsym
));
3333 return orig_pc
== pc
? 0 : pc
& ~0x3;
3336 return SYMBOL_VALUE (libsym
);
3339 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
3340 branch from the stub to the actual function. */
3342 else if ((curr_inst
& 0xffe0e000) == 0xe8400000
3343 || (curr_inst
& 0xffe0e000) == 0xe8000000
3344 || (curr_inst
& 0xffe0e000) == 0xe800A000)
3345 return (loc
+ extract_17 (curr_inst
) + 8) & ~0x3;
3347 /* Does it look like bv (rp)? Note this depends on the
3348 current stack pointer being the same as the stack
3349 pointer in the stub itself! This is a branch on from the
3350 stub back to the original caller. */
3351 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
3352 else if ((curr_inst
& 0xffe0f000) == 0xe840c000)
3354 /* Yup. See if the previous instruction loaded
3356 if (prev_inst
== 0x4bc23ff1)
3357 return (read_memory_integer
3358 (read_register (SP_REGNUM
) - 8, 4)) & ~0x3;
3361 warning ("Unable to find restore of %%rp before bv (%%rp).");
3362 return orig_pc
== pc
? 0 : pc
& ~0x3;
3366 /* elz: added this case to capture the new instruction
3367 at the end of the return part of an export stub used by
3368 the PA2.0: BVE, n (rp) */
3369 else if ((curr_inst
& 0xffe0f000) == 0xe840d000)
3371 return (read_memory_integer
3372 (read_register (SP_REGNUM
) - 24, TARGET_PTR_BIT
/ 8)) & ~0x3;
3375 /* What about be,n 0(sr0,%rp)? It's just another way we return to
3376 the original caller from the stub. Used in dynamic executables. */
3377 else if (curr_inst
== 0xe0400002)
3379 /* The value we jump to is sitting in sp - 24. But that's
3380 loaded several instructions before the be instruction.
3381 I guess we could check for the previous instruction being
3382 mtsp %r1,%sr0 if we want to do sanity checking. */
3383 return (read_memory_integer
3384 (read_register (SP_REGNUM
) - 24, TARGET_PTR_BIT
/ 8)) & ~0x3;
3387 /* Haven't found the branch yet, but we're still in the stub.
3394 /* For the given instruction (INST), return any adjustment it makes
3395 to the stack pointer or zero for no adjustment.
3397 This only handles instructions commonly found in prologues. */
3400 prologue_inst_adjust_sp (unsigned long inst
)
3402 /* This must persist across calls. */
3403 static int save_high21
;
3405 /* The most common way to perform a stack adjustment ldo X(sp),sp */
3406 if ((inst
& 0xffffc000) == 0x37de0000)
3407 return extract_14 (inst
);
3410 if ((inst
& 0xffe00000) == 0x6fc00000)
3411 return extract_14 (inst
);
3413 /* std,ma X,D(sp) */
3414 if ((inst
& 0xffe00008) == 0x73c00008)
3415 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
3417 /* addil high21,%r1; ldo low11,(%r1),%r30)
3418 save high bits in save_high21 for later use. */
3419 if ((inst
& 0xffe00000) == 0x28200000)
3421 save_high21
= extract_21 (inst
);
3425 if ((inst
& 0xffff0000) == 0x343e0000)
3426 return save_high21
+ extract_14 (inst
);
3428 /* fstws as used by the HP compilers. */
3429 if ((inst
& 0xffffffe0) == 0x2fd01220)
3430 return extract_5_load (inst
);
3432 /* No adjustment. */
3436 /* Return nonzero if INST is a branch of some kind, else return zero. */
3439 is_branch (unsigned long inst
)
3468 /* Return the register number for a GR which is saved by INST or
3469 zero it INST does not save a GR. */
3472 inst_saves_gr (unsigned long inst
)
3474 /* Does it look like a stw? */
3475 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
3476 || (inst
>> 26) == 0x1f
3477 || ((inst
>> 26) == 0x1f
3478 && ((inst
>> 6) == 0xa)))
3479 return extract_5R_store (inst
);
3481 /* Does it look like a std? */
3482 if ((inst
>> 26) == 0x1c
3483 || ((inst
>> 26) == 0x03
3484 && ((inst
>> 6) & 0xf) == 0xb))
3485 return extract_5R_store (inst
);
3487 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
3488 if ((inst
>> 26) == 0x1b)
3489 return extract_5R_store (inst
);
3491 /* Does it look like sth or stb? HPC versions 9.0 and later use these
3493 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
3494 || ((inst
>> 26) == 0x3
3495 && (((inst
>> 6) & 0xf) == 0x8
3496 || (inst
>> 6) & 0xf) == 0x9))
3497 return extract_5R_store (inst
);
3502 /* Return the register number for a FR which is saved by INST or
3503 zero it INST does not save a FR.
3505 Note we only care about full 64bit register stores (that's the only
3506 kind of stores the prologue will use).
3508 FIXME: What about argument stores with the HP compiler in ANSI mode? */
3511 inst_saves_fr (unsigned long inst
)
3513 /* is this an FSTD ? */
3514 if ((inst
& 0xfc00dfc0) == 0x2c001200)
3515 return extract_5r_store (inst
);
3516 if ((inst
& 0xfc000002) == 0x70000002)
3517 return extract_5R_store (inst
);
3518 /* is this an FSTW ? */
3519 if ((inst
& 0xfc00df80) == 0x24001200)
3520 return extract_5r_store (inst
);
3521 if ((inst
& 0xfc000002) == 0x7c000000)
3522 return extract_5R_store (inst
);
3526 /* Advance PC across any function entry prologue instructions
3527 to reach some "real" code.
3529 Use information in the unwind table to determine what exactly should
3530 be in the prologue. */
3534 skip_prologue_hard_way (CORE_ADDR pc
)
3537 CORE_ADDR orig_pc
= pc
;
3538 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
3539 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
3540 struct unwind_table_entry
*u
;
3546 u
= find_unwind_entry (pc
);
3550 /* If we are not at the beginning of a function, then return now. */
3551 if ((pc
& ~0x3) != u
->region_start
)
3554 /* This is how much of a frame adjustment we need to account for. */
3555 stack_remaining
= u
->Total_frame_size
<< 3;
3557 /* Magic register saves we want to know about. */
3558 save_rp
= u
->Save_RP
;
3559 save_sp
= u
->Save_SP
;
3561 /* An indication that args may be stored into the stack. Unfortunately
3562 the HPUX compilers tend to set this in cases where no args were
3566 /* Turn the Entry_GR field into a bitmask. */
3568 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
3570 /* Frame pointer gets saved into a special location. */
3571 if (u
->Save_SP
&& i
== FP_REGNUM
)
3574 save_gr
|= (1 << i
);
3576 save_gr
&= ~restart_gr
;
3578 /* Turn the Entry_FR field into a bitmask too. */
3580 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
3581 save_fr
|= (1 << i
);
3582 save_fr
&= ~restart_fr
;
3584 /* Loop until we find everything of interest or hit a branch.
3586 For unoptimized GCC code and for any HP CC code this will never ever
3587 examine any user instructions.
3589 For optimzied GCC code we're faced with problems. GCC will schedule
3590 its prologue and make prologue instructions available for delay slot
3591 filling. The end result is user code gets mixed in with the prologue
3592 and a prologue instruction may be in the delay slot of the first branch
3595 Some unexpected things are expected with debugging optimized code, so
3596 we allow this routine to walk past user instructions in optimized
3598 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
3601 unsigned int reg_num
;
3602 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
3603 unsigned long old_save_rp
, old_save_sp
, next_inst
;
3605 /* Save copies of all the triggers so we can compare them later
3607 old_save_gr
= save_gr
;
3608 old_save_fr
= save_fr
;
3609 old_save_rp
= save_rp
;
3610 old_save_sp
= save_sp
;
3611 old_stack_remaining
= stack_remaining
;
3613 status
= target_read_memory (pc
, buf
, 4);
3614 inst
= extract_unsigned_integer (buf
, 4);
3620 /* Note the interesting effects of this instruction. */
3621 stack_remaining
-= prologue_inst_adjust_sp (inst
);
3623 /* There are limited ways to store the return pointer into the
3625 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
3628 /* These are the only ways we save SP into the stack. At this time
3629 the HP compilers never bother to save SP into the stack. */
3630 if ((inst
& 0xffffc000) == 0x6fc10000
3631 || (inst
& 0xffffc00c) == 0x73c10008)
3634 /* Are we loading some register with an offset from the argument
3636 if ((inst
& 0xffe00000) == 0x37a00000
3637 || (inst
& 0xffffffe0) == 0x081d0240)
3643 /* Account for general and floating-point register saves. */
3644 reg_num
= inst_saves_gr (inst
);
3645 save_gr
&= ~(1 << reg_num
);
3647 /* Ugh. Also account for argument stores into the stack.
3648 Unfortunately args_stored only tells us that some arguments
3649 where stored into the stack. Not how many or what kind!
3651 This is a kludge as on the HP compiler sets this bit and it
3652 never does prologue scheduling. So once we see one, skip past
3653 all of them. We have similar code for the fp arg stores below.
3655 FIXME. Can still die if we have a mix of GR and FR argument
3657 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
3659 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
3662 status
= target_read_memory (pc
, buf
, 4);
3663 inst
= extract_unsigned_integer (buf
, 4);
3666 reg_num
= inst_saves_gr (inst
);
3672 reg_num
= inst_saves_fr (inst
);
3673 save_fr
&= ~(1 << reg_num
);
3675 status
= target_read_memory (pc
+ 4, buf
, 4);
3676 next_inst
= extract_unsigned_integer (buf
, 4);
3682 /* We've got to be read to handle the ldo before the fp register
3684 if ((inst
& 0xfc000000) == 0x34000000
3685 && inst_saves_fr (next_inst
) >= 4
3686 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
3688 /* So we drop into the code below in a reasonable state. */
3689 reg_num
= inst_saves_fr (next_inst
);
3693 /* Ugh. Also account for argument stores into the stack.
3694 This is a kludge as on the HP compiler sets this bit and it
3695 never does prologue scheduling. So once we see one, skip past
3697 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
3699 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
3702 status
= target_read_memory (pc
, buf
, 4);
3703 inst
= extract_unsigned_integer (buf
, 4);
3706 if ((inst
& 0xfc000000) != 0x34000000)
3708 status
= target_read_memory (pc
+ 4, buf
, 4);
3709 next_inst
= extract_unsigned_integer (buf
, 4);
3712 reg_num
= inst_saves_fr (next_inst
);
3718 /* Quit if we hit any kind of branch. This can happen if a prologue
3719 instruction is in the delay slot of the first call/branch. */
3720 if (is_branch (inst
))
3723 /* What a crock. The HP compilers set args_stored even if no
3724 arguments were stored into the stack (boo hiss). This could
3725 cause this code to then skip a bunch of user insns (up to the
3728 To combat this we try to identify when args_stored was bogusly
3729 set and clear it. We only do this when args_stored is nonzero,
3730 all other resources are accounted for, and nothing changed on
3733 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
3734 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
3735 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
3736 && old_stack_remaining
== stack_remaining
)
3743 /* We've got a tenative location for the end of the prologue. However
3744 because of limitations in the unwind descriptor mechanism we may
3745 have went too far into user code looking for the save of a register
3746 that does not exist. So, if there registers we expected to be saved
3747 but never were, mask them out and restart.
3749 This should only happen in optimized code, and should be very rare. */
3750 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
3753 restart_gr
= save_gr
;
3754 restart_fr
= save_fr
;
3762 /* Return the address of the PC after the last prologue instruction if
3763 we can determine it from the debug symbols. Else return zero. */
3766 after_prologue (CORE_ADDR pc
)
3768 struct symtab_and_line sal
;
3769 CORE_ADDR func_addr
, func_end
;
3772 /* If we can not find the symbol in the partial symbol table, then
3773 there is no hope we can determine the function's start address
3775 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
3778 /* Get the line associated with FUNC_ADDR. */
3779 sal
= find_pc_line (func_addr
, 0);
3781 /* There are only two cases to consider. First, the end of the source line
3782 is within the function bounds. In that case we return the end of the
3783 source line. Second is the end of the source line extends beyond the
3784 bounds of the current function. We need to use the slow code to
3785 examine instructions in that case.
3787 Anything else is simply a bug elsewhere. Fixing it here is absolutely
3788 the wrong thing to do. In fact, it should be entirely possible for this
3789 function to always return zero since the slow instruction scanning code
3790 is supposed to *always* work. If it does not, then it is a bug. */
3791 if (sal
.end
< func_end
)
3797 /* To skip prologues, I use this predicate. Returns either PC itself
3798 if the code at PC does not look like a function prologue; otherwise
3799 returns an address that (if we're lucky) follows the prologue. If
3800 LENIENT, then we must skip everything which is involved in setting
3801 up the frame (it's OK to skip more, just so long as we don't skip
3802 anything which might clobber the registers which are being saved.
3803 Currently we must not skip more on the alpha, but we might the lenient
3807 hppa_skip_prologue (CORE_ADDR pc
)
3811 CORE_ADDR post_prologue_pc
;
3814 /* See if we can determine the end of the prologue via the symbol table.
3815 If so, then return either PC, or the PC after the prologue, whichever
3818 post_prologue_pc
= after_prologue (pc
);
3820 /* If after_prologue returned a useful address, then use it. Else
3821 fall back on the instruction skipping code.
3823 Some folks have claimed this causes problems because the breakpoint
3824 may be the first instruction of the prologue. If that happens, then
3825 the instruction skipping code has a bug that needs to be fixed. */
3826 if (post_prologue_pc
!= 0)
3827 return max (pc
, post_prologue_pc
);
3829 return (skip_prologue_hard_way (pc
));
3832 /* Put here the code to store, into a struct frame_saved_regs,
3833 the addresses of the saved registers of frame described by FRAME_INFO.
3834 This includes special registers such as pc and fp saved in special
3835 ways in the stack frame. sp is even more special:
3836 the address we return for it IS the sp for the next frame. */
3839 hppa_frame_find_saved_regs (struct frame_info
*frame_info
,
3840 struct frame_saved_regs
*frame_saved_regs
)
3843 struct unwind_table_entry
*u
;
3844 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
3848 int final_iteration
;
3850 /* Zero out everything. */
3851 memset (frame_saved_regs
, '\0', sizeof (struct frame_saved_regs
));
3853 /* Call dummy frames always look the same, so there's no need to
3854 examine the dummy code to determine locations of saved registers;
3855 instead, let find_dummy_frame_regs fill in the correct offsets
3856 for the saved registers. */
3857 if ((frame_info
->pc
>= frame_info
->frame
3858 && frame_info
->pc
<= (frame_info
->frame
3859 /* A call dummy is sized in words, but it is
3860 actually a series of instructions. Account
3861 for that scaling factor. */
3862 + ((REGISTER_SIZE
/ INSTRUCTION_SIZE
)
3863 * CALL_DUMMY_LENGTH
)
3864 /* Similarly we have to account for 64bit
3865 wide register saves. */
3866 + (32 * REGISTER_SIZE
)
3867 /* We always consider FP regs 8 bytes long. */
3868 + (NUM_REGS
- FP0_REGNUM
) * 8
3869 /* Similarly we have to account for 64bit
3870 wide register saves. */
3871 + (6 * REGISTER_SIZE
))))
3872 find_dummy_frame_regs (frame_info
, frame_saved_regs
);
3874 /* Interrupt handlers are special too. They lay out the register
3875 state in the exact same order as the register numbers in GDB. */
3876 if (pc_in_interrupt_handler (frame_info
->pc
))
3878 for (i
= 0; i
< NUM_REGS
; i
++)
3880 /* SP is a little special. */
3882 frame_saved_regs
->regs
[SP_REGNUM
]
3883 = read_memory_integer (frame_info
->frame
+ SP_REGNUM
* 4,
3884 TARGET_PTR_BIT
/ 8);
3886 frame_saved_regs
->regs
[i
] = frame_info
->frame
+ i
* 4;
3891 #ifdef FRAME_FIND_SAVED_REGS_IN_SIGTRAMP
3892 /* Handle signal handler callers. */
3893 if ((get_frame_type (frame_info
) == SIGTRAMP_FRAME
))
3895 FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info
, frame_saved_regs
);
3900 /* Get the starting address of the function referred to by the PC
3902 pc
= get_pc_function_start (frame_info
->pc
);
3905 u
= find_unwind_entry (pc
);
3909 /* This is how much of a frame adjustment we need to account for. */
3910 stack_remaining
= u
->Total_frame_size
<< 3;
3912 /* Magic register saves we want to know about. */
3913 save_rp
= u
->Save_RP
;
3914 save_sp
= u
->Save_SP
;
3916 /* Turn the Entry_GR field into a bitmask. */
3918 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
3920 /* Frame pointer gets saved into a special location. */
3921 if (u
->Save_SP
&& i
== FP_REGNUM
)
3924 save_gr
|= (1 << i
);
3927 /* Turn the Entry_FR field into a bitmask too. */
3929 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
3930 save_fr
|= (1 << i
);
3932 /* The frame always represents the value of %sp at entry to the
3933 current function (and is thus equivalent to the "saved" stack
3935 frame_saved_regs
->regs
[SP_REGNUM
] = frame_info
->frame
;
3937 /* Loop until we find everything of interest or hit a branch.
3939 For unoptimized GCC code and for any HP CC code this will never ever
3940 examine any user instructions.
3942 For optimized GCC code we're faced with problems. GCC will schedule
3943 its prologue and make prologue instructions available for delay slot
3944 filling. The end result is user code gets mixed in with the prologue
3945 and a prologue instruction may be in the delay slot of the first branch
3948 Some unexpected things are expected with debugging optimized code, so
3949 we allow this routine to walk past user instructions in optimized
3951 final_iteration
= 0;
3952 while ((save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
3953 && pc
<= frame_info
->pc
)
3955 status
= target_read_memory (pc
, buf
, 4);
3956 inst
= extract_unsigned_integer (buf
, 4);
3962 /* Note the interesting effects of this instruction. */
3963 stack_remaining
-= prologue_inst_adjust_sp (inst
);
3965 /* There are limited ways to store the return pointer into the
3967 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
3970 frame_saved_regs
->regs
[RP_REGNUM
] = frame_info
->frame
- 20;
3972 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
3975 frame_saved_regs
->regs
[RP_REGNUM
] = frame_info
->frame
- 16;
3978 /* Note if we saved SP into the stack. This also happens to indicate
3979 the location of the saved frame pointer. */
3980 if ( (inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
3981 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
3983 frame_saved_regs
->regs
[FP_REGNUM
] = frame_info
->frame
;
3987 /* Account for general and floating-point register saves. */
3988 reg
= inst_saves_gr (inst
);
3989 if (reg
>= 3 && reg
<= 18
3990 && (!u
->Save_SP
|| reg
!= FP_REGNUM
))
3992 save_gr
&= ~(1 << reg
);
3994 /* stwm with a positive displacement is a *post modify*. */
3995 if ((inst
>> 26) == 0x1b
3996 && extract_14 (inst
) >= 0)
3997 frame_saved_regs
->regs
[reg
] = frame_info
->frame
;
3998 /* A std has explicit post_modify forms. */
3999 else if ((inst
& 0xfc00000c0) == 0x70000008)
4000 frame_saved_regs
->regs
[reg
] = frame_info
->frame
;
4005 if ((inst
>> 26) == 0x1c)
4006 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
4007 else if ((inst
>> 26) == 0x03)
4008 offset
= low_sign_extend (inst
& 0x1f, 5);
4010 offset
= extract_14 (inst
);
4012 /* Handle code with and without frame pointers. */
4014 frame_saved_regs
->regs
[reg
]
4015 = frame_info
->frame
+ offset
;
4017 frame_saved_regs
->regs
[reg
]
4018 = (frame_info
->frame
+ (u
->Total_frame_size
<< 3)
4024 /* GCC handles callee saved FP regs a little differently.
4026 It emits an instruction to put the value of the start of
4027 the FP store area into %r1. It then uses fstds,ma with
4028 a basereg of %r1 for the stores.
4030 HP CC emits them at the current stack pointer modifying
4031 the stack pointer as it stores each register. */
4033 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
4034 if ((inst
& 0xffffc000) == 0x34610000
4035 || (inst
& 0xffffc000) == 0x37c10000)
4036 fp_loc
= extract_14 (inst
);
4038 reg
= inst_saves_fr (inst
);
4039 if (reg
>= 12 && reg
<= 21)
4041 /* Note +4 braindamage below is necessary because the FP status
4042 registers are internally 8 registers rather than the expected
4044 save_fr
&= ~(1 << reg
);
4047 /* 1st HP CC FP register store. After this instruction
4048 we've set enough state that the GCC and HPCC code are
4049 both handled in the same manner. */
4050 frame_saved_regs
->regs
[reg
+ FP4_REGNUM
+ 4] = frame_info
->frame
;
4055 frame_saved_regs
->regs
[reg
+ FP0_REGNUM
+ 4]
4056 = frame_info
->frame
+ fp_loc
;
4061 /* Quit if we hit any kind of branch the previous iteration. */
4062 if (final_iteration
)
4065 /* We want to look precisely one instruction beyond the branch
4066 if we have not found everything yet. */
4067 if (is_branch (inst
))
4068 final_iteration
= 1;
4076 /* Exception handling support for the HP-UX ANSI C++ compiler.
4077 The compiler (aCC) provides a callback for exception events;
4078 GDB can set a breakpoint on this callback and find out what
4079 exception event has occurred. */
4081 /* The name of the hook to be set to point to the callback function */
4082 static char HP_ACC_EH_notify_hook
[] = "__eh_notify_hook";
4083 /* The name of the function to be used to set the hook value */
4084 static char HP_ACC_EH_set_hook_value
[] = "__eh_set_hook_value";
4085 /* The name of the callback function in end.o */
4086 static char HP_ACC_EH_notify_callback
[] = "__d_eh_notify_callback";
4087 /* Name of function in end.o on which a break is set (called by above) */
4088 static char HP_ACC_EH_break
[] = "__d_eh_break";
4089 /* Name of flag (in end.o) that enables catching throws */
4090 static char HP_ACC_EH_catch_throw
[] = "__d_eh_catch_throw";
4091 /* Name of flag (in end.o) that enables catching catching */
4092 static char HP_ACC_EH_catch_catch
[] = "__d_eh_catch_catch";
4093 /* The enum used by aCC */
4101 /* Is exception-handling support available with this executable? */
4102 static int hp_cxx_exception_support
= 0;
4103 /* Has the initialize function been run? */
4104 int hp_cxx_exception_support_initialized
= 0;
4105 /* Similar to above, but imported from breakpoint.c -- non-target-specific */
4106 extern int exception_support_initialized
;
4107 /* Address of __eh_notify_hook */
4108 static CORE_ADDR eh_notify_hook_addr
= 0;
4109 /* Address of __d_eh_notify_callback */
4110 static CORE_ADDR eh_notify_callback_addr
= 0;
4111 /* Address of __d_eh_break */
4112 static CORE_ADDR eh_break_addr
= 0;
4113 /* Address of __d_eh_catch_catch */
4114 static CORE_ADDR eh_catch_catch_addr
= 0;
4115 /* Address of __d_eh_catch_throw */
4116 static CORE_ADDR eh_catch_throw_addr
= 0;
4117 /* Sal for __d_eh_break */
4118 static struct symtab_and_line
*break_callback_sal
= 0;
4120 /* Code in end.c expects __d_pid to be set in the inferior,
4121 otherwise __d_eh_notify_callback doesn't bother to call
4122 __d_eh_break! So we poke the pid into this symbol
4127 setup_d_pid_in_inferior (void)
4130 struct minimal_symbol
*msymbol
;
4131 char buf
[4]; /* FIXME 32x64? */
4133 /* Slam the pid of the process into __d_pid; failing is only a warning! */
4134 msymbol
= lookup_minimal_symbol ("__d_pid", NULL
, symfile_objfile
);
4135 if (msymbol
== NULL
)
4137 warning ("Unable to find __d_pid symbol in object file.");
4138 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4142 anaddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
4143 store_unsigned_integer (buf
, 4, PIDGET (inferior_ptid
)); /* FIXME 32x64? */
4144 if (target_write_memory (anaddr
, buf
, 4)) /* FIXME 32x64? */
4146 warning ("Unable to write __d_pid");
4147 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4153 /* Initialize exception catchpoint support by looking for the
4154 necessary hooks/callbacks in end.o, etc., and set the hook value to
4155 point to the required debug function
4161 initialize_hp_cxx_exception_support (void)
4163 struct symtabs_and_lines sals
;
4164 struct cleanup
*old_chain
;
4165 struct cleanup
*canonical_strings_chain
= NULL
;
4168 char *addr_end
= NULL
;
4169 char **canonical
= (char **) NULL
;
4171 struct symbol
*sym
= NULL
;
4172 struct minimal_symbol
*msym
= NULL
;
4173 struct objfile
*objfile
;
4174 asection
*shlib_info
;
4176 /* Detect and disallow recursion. On HP-UX with aCC, infinite
4177 recursion is a possibility because finding the hook for exception
4178 callbacks involves making a call in the inferior, which means
4179 re-inserting breakpoints which can re-invoke this code */
4181 static int recurse
= 0;
4184 hp_cxx_exception_support_initialized
= 0;
4185 exception_support_initialized
= 0;
4189 hp_cxx_exception_support
= 0;
4191 /* First check if we have seen any HP compiled objects; if not,
4192 it is very unlikely that HP's idiosyncratic callback mechanism
4193 for exception handling debug support will be available!
4194 This will percolate back up to breakpoint.c, where our callers
4195 will decide to try the g++ exception-handling support instead. */
4196 if (!hp_som_som_object_present
)
4199 /* We have a SOM executable with SOM debug info; find the hooks */
4201 /* First look for the notify hook provided by aCC runtime libs */
4202 /* If we find this symbol, we conclude that the executable must
4203 have HP aCC exception support built in. If this symbol is not
4204 found, even though we're a HP SOM-SOM file, we may have been
4205 built with some other compiler (not aCC). This results percolates
4206 back up to our callers in breakpoint.c which can decide to
4207 try the g++ style of exception support instead.
4208 If this symbol is found but the other symbols we require are
4209 not found, there is something weird going on, and g++ support
4210 should *not* be tried as an alternative.
4212 ASSUMPTION: Only HP aCC code will have __eh_notify_hook defined.
4213 ASSUMPTION: HP aCC and g++ modules cannot be linked together. */
4215 /* libCsup has this hook; it'll usually be non-debuggable */
4216 msym
= lookup_minimal_symbol (HP_ACC_EH_notify_hook
, NULL
, NULL
);
4219 eh_notify_hook_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4220 hp_cxx_exception_support
= 1;
4224 warning ("Unable to find exception callback hook (%s).", HP_ACC_EH_notify_hook
);
4225 warning ("Executable may not have been compiled debuggable with HP aCC.");
4226 warning ("GDB will be unable to intercept exception events.");
4227 eh_notify_hook_addr
= 0;
4228 hp_cxx_exception_support
= 0;
4232 /* Next look for the notify callback routine in end.o */
4233 /* This is always available in the SOM symbol dictionary if end.o is linked in */
4234 msym
= lookup_minimal_symbol (HP_ACC_EH_notify_callback
, NULL
, NULL
);
4237 eh_notify_callback_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4238 hp_cxx_exception_support
= 1;
4242 warning ("Unable to find exception callback routine (%s).", HP_ACC_EH_notify_callback
);
4243 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4244 warning ("GDB will be unable to intercept exception events.");
4245 eh_notify_callback_addr
= 0;
4249 #ifndef GDB_TARGET_IS_HPPA_20W
4250 /* Check whether the executable is dynamically linked or archive bound */
4251 /* With an archive-bound executable we can use the raw addresses we find
4252 for the callback function, etc. without modification. For an executable
4253 with shared libraries, we have to do more work to find the plabel, which
4254 can be the target of a call through $$dyncall from the aCC runtime support
4255 library (libCsup) which is linked shared by default by aCC. */
4256 /* This test below was copied from somsolib.c/somread.c. It may not be a very
4257 reliable one to test that an executable is linked shared. pai/1997-07-18 */
4258 shlib_info
= bfd_get_section_by_name (symfile_objfile
->obfd
, "$SHLIB_INFO$");
4259 if (shlib_info
&& (bfd_section_size (symfile_objfile
->obfd
, shlib_info
) != 0))
4261 /* The minsym we have has the local code address, but that's not the
4262 plabel that can be used by an inter-load-module call. */
4263 /* Find solib handle for main image (which has end.o), and use that
4264 and the min sym as arguments to __d_shl_get() (which does the equivalent
4265 of shl_findsym()) to find the plabel. */
4267 args_for_find_stub args
;
4268 static char message
[] = "Error while finding exception callback hook:\n";
4270 args
.solib_handle
= som_solib_get_solib_by_pc (eh_notify_callback_addr
);
4272 args
.return_val
= 0;
4275 catch_errors (cover_find_stub_with_shl_get
, (PTR
) &args
, message
,
4277 eh_notify_callback_addr
= args
.return_val
;
4280 exception_catchpoints_are_fragile
= 1;
4282 if (!eh_notify_callback_addr
)
4284 /* We can get here either if there is no plabel in the export list
4285 for the main image, or if something strange happened (?) */
4286 warning ("Couldn't find a plabel (indirect function label) for the exception callback.");
4287 warning ("GDB will not be able to intercept exception events.");
4292 exception_catchpoints_are_fragile
= 0;
4295 /* Now, look for the breakpointable routine in end.o */
4296 /* This should also be available in the SOM symbol dict. if end.o linked in */
4297 msym
= lookup_minimal_symbol (HP_ACC_EH_break
, NULL
, NULL
);
4300 eh_break_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4301 hp_cxx_exception_support
= 1;
4305 warning ("Unable to find exception callback routine to set breakpoint (%s).", HP_ACC_EH_break
);
4306 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4307 warning ("GDB will be unable to intercept exception events.");
4312 /* Next look for the catch enable flag provided in end.o */
4313 sym
= lookup_symbol (HP_ACC_EH_catch_catch
, (struct block
*) NULL
,
4314 VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
4315 if (sym
) /* sometimes present in debug info */
4317 eh_catch_catch_addr
= SYMBOL_VALUE_ADDRESS (sym
);
4318 hp_cxx_exception_support
= 1;
4321 /* otherwise look in SOM symbol dict. */
4323 msym
= lookup_minimal_symbol (HP_ACC_EH_catch_catch
, NULL
, NULL
);
4326 eh_catch_catch_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4327 hp_cxx_exception_support
= 1;
4331 warning ("Unable to enable interception of exception catches.");
4332 warning ("Executable may not have been compiled debuggable with HP aCC.");
4333 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4338 /* Next look for the catch enable flag provided end.o */
4339 sym
= lookup_symbol (HP_ACC_EH_catch_catch
, (struct block
*) NULL
,
4340 VAR_NAMESPACE
, 0, (struct symtab
**) NULL
);
4341 if (sym
) /* sometimes present in debug info */
4343 eh_catch_throw_addr
= SYMBOL_VALUE_ADDRESS (sym
);
4344 hp_cxx_exception_support
= 1;
4347 /* otherwise look in SOM symbol dict. */
4349 msym
= lookup_minimal_symbol (HP_ACC_EH_catch_throw
, NULL
, NULL
);
4352 eh_catch_throw_addr
= SYMBOL_VALUE_ADDRESS (msym
);
4353 hp_cxx_exception_support
= 1;
4357 warning ("Unable to enable interception of exception throws.");
4358 warning ("Executable may not have been compiled debuggable with HP aCC.");
4359 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4365 hp_cxx_exception_support
= 2; /* everything worked so far */
4366 hp_cxx_exception_support_initialized
= 1;
4367 exception_support_initialized
= 1;
4372 /* Target operation for enabling or disabling interception of
4374 KIND is either EX_EVENT_THROW or EX_EVENT_CATCH
4375 ENABLE is either 0 (disable) or 1 (enable).
4376 Return value is NULL if no support found;
4377 -1 if something went wrong,
4378 or a pointer to a symtab/line struct if the breakpointable
4379 address was found. */
4381 struct symtab_and_line
*
4382 child_enable_exception_callback (enum exception_event_kind kind
, int enable
)
4386 if (!exception_support_initialized
|| !hp_cxx_exception_support_initialized
)
4387 if (!initialize_hp_cxx_exception_support ())
4390 switch (hp_cxx_exception_support
)
4393 /* Assuming no HP support at all */
4396 /* HP support should be present, but something went wrong */
4397 return (struct symtab_and_line
*) -1; /* yuck! */
4398 /* there may be other cases in the future */
4401 /* Set the EH hook to point to the callback routine */
4402 store_unsigned_integer (buf
, 4, enable
? eh_notify_callback_addr
: 0); /* FIXME 32x64 problem */
4403 /* pai: (temp) FIXME should there be a pack operation first? */
4404 if (target_write_memory (eh_notify_hook_addr
, buf
, 4)) /* FIXME 32x64 problem */
4406 warning ("Could not write to target memory for exception event callback.");
4407 warning ("Interception of exception events may not work.");
4408 return (struct symtab_and_line
*) -1;
4412 /* Ensure that __d_pid is set up correctly -- end.c code checks this. :-( */
4413 if (PIDGET (inferior_ptid
) > 0)
4415 if (setup_d_pid_in_inferior ())
4416 return (struct symtab_and_line
*) -1;
4420 warning ("Internal error: Invalid inferior pid? Cannot intercept exception events.");
4421 return (struct symtab_and_line
*) -1;
4427 case EX_EVENT_THROW
:
4428 store_unsigned_integer (buf
, 4, enable
? 1 : 0);
4429 if (target_write_memory (eh_catch_throw_addr
, buf
, 4)) /* FIXME 32x64? */
4431 warning ("Couldn't enable exception throw interception.");
4432 return (struct symtab_and_line
*) -1;
4435 case EX_EVENT_CATCH
:
4436 store_unsigned_integer (buf
, 4, enable
? 1 : 0);
4437 if (target_write_memory (eh_catch_catch_addr
, buf
, 4)) /* FIXME 32x64? */
4439 warning ("Couldn't enable exception catch interception.");
4440 return (struct symtab_and_line
*) -1;
4444 error ("Request to enable unknown or unsupported exception event.");
4447 /* Copy break address into new sal struct, malloc'ing if needed. */
4448 if (!break_callback_sal
)
4450 break_callback_sal
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
4452 init_sal (break_callback_sal
);
4453 break_callback_sal
->symtab
= NULL
;
4454 break_callback_sal
->pc
= eh_break_addr
;
4455 break_callback_sal
->line
= 0;
4456 break_callback_sal
->end
= eh_break_addr
;
4458 return break_callback_sal
;
4461 /* Record some information about the current exception event */
4462 static struct exception_event_record current_ex_event
;
4463 /* Convenience struct */
4464 static struct symtab_and_line null_symtab_and_line
=
4467 /* Report current exception event. Returns a pointer to a record
4468 that describes the kind of the event, where it was thrown from,
4469 and where it will be caught. More information may be reported
4471 struct exception_event_record
*
4472 child_get_current_exception_event (void)
4474 CORE_ADDR event_kind
;
4475 CORE_ADDR throw_addr
;
4476 CORE_ADDR catch_addr
;
4477 struct frame_info
*fi
, *curr_frame
;
4480 curr_frame
= get_current_frame ();
4482 return (struct exception_event_record
*) NULL
;
4484 /* Go up one frame to __d_eh_notify_callback, because at the
4485 point when this code is executed, there's garbage in the
4486 arguments of __d_eh_break. */
4487 fi
= find_relative_frame (curr_frame
, &level
);
4489 return (struct exception_event_record
*) NULL
;
4493 /* Read in the arguments */
4494 /* __d_eh_notify_callback() is called with 3 arguments:
4495 1. event kind catch or throw
4496 2. the target address if known
4497 3. a flag -- not sure what this is. pai/1997-07-17 */
4498 event_kind
= read_register (ARG0_REGNUM
);
4499 catch_addr
= read_register (ARG1_REGNUM
);
4501 /* Now go down to a user frame */
4502 /* For a throw, __d_eh_break is called by
4503 __d_eh_notify_callback which is called by
4504 __notify_throw which is called
4506 For a catch, __d_eh_break is called by
4507 __d_eh_notify_callback which is called by
4508 <stackwalking stuff> which is called by
4509 __throw__<stuff> or __rethrow_<stuff> which is called
4511 /* FIXME: Don't use such magic numbers; search for the frames */
4512 level
= (event_kind
== EX_EVENT_THROW
) ? 3 : 4;
4513 fi
= find_relative_frame (curr_frame
, &level
);
4515 return (struct exception_event_record
*) NULL
;
4518 throw_addr
= fi
->pc
;
4520 /* Go back to original (top) frame */
4521 select_frame (curr_frame
);
4523 current_ex_event
.kind
= (enum exception_event_kind
) event_kind
;
4524 current_ex_event
.throw_sal
= find_pc_line (throw_addr
, 1);
4525 current_ex_event
.catch_sal
= find_pc_line (catch_addr
, 1);
4527 return ¤t_ex_event
;
4531 unwind_command (char *exp
, int from_tty
)
4534 struct unwind_table_entry
*u
;
4536 /* If we have an expression, evaluate it and use it as the address. */
4538 if (exp
!= 0 && *exp
!= 0)
4539 address
= parse_and_eval_address (exp
);
4543 u
= find_unwind_entry (address
);
4547 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
4551 printf_unfiltered ("unwind_table_entry (0x%s):\n",
4552 paddr_nz (host_pointer_to_address (u
)));
4554 printf_unfiltered ("\tregion_start = ");
4555 print_address (u
->region_start
, gdb_stdout
);
4557 printf_unfiltered ("\n\tregion_end = ");
4558 print_address (u
->region_end
, gdb_stdout
);
4560 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
4562 printf_unfiltered ("\n\tflags =");
4563 pif (Cannot_unwind
);
4565 pif (Millicode_save_sr0
);
4568 pif (Variable_Frame
);
4569 pif (Separate_Package_Body
);
4570 pif (Frame_Extension_Millicode
);
4571 pif (Stack_Overflow_Check
);
4572 pif (Two_Instruction_SP_Increment
);
4576 pif (Save_MRP_in_frame
);
4577 pif (extn_ptr_defined
);
4578 pif (Cleanup_defined
);
4579 pif (MPE_XL_interrupt_marker
);
4580 pif (HP_UX_interrupt_marker
);
4583 putchar_unfiltered ('\n');
4585 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
4587 pin (Region_description
);
4590 pin (Total_frame_size
);
4593 #ifdef PREPARE_TO_PROCEED
4595 /* If the user has switched threads, and there is a breakpoint
4596 at the old thread's pc location, then switch to that thread
4597 and return TRUE, else return FALSE and don't do a thread
4598 switch (or rather, don't seem to have done a thread switch).
4600 Ptrace-based gdb will always return FALSE to the thread-switch
4601 query, and thus also to PREPARE_TO_PROCEED.
4603 The important thing is whether there is a BPT instruction,
4604 not how many user breakpoints there are. So we have to worry
4605 about things like these:
4609 o User hits bp, no switch -- NO
4611 o User hits bp, switches threads -- YES
4613 o User hits bp, deletes bp, switches threads -- NO
4615 o User hits bp, deletes one of two or more bps
4616 at that PC, user switches threads -- YES
4618 o Plus, since we're buffering events, the user may have hit a
4619 breakpoint, deleted the breakpoint and then gotten another
4620 hit on that same breakpoint on another thread which
4621 actually hit before the delete. (FIXME in breakpoint.c
4622 so that "dead" breakpoints are ignored?) -- NO
4624 For these reasons, we have to violate information hiding and
4625 call "breakpoint_here_p". If core gdb thinks there is a bpt
4626 here, that's what counts, as core gdb is the one which is
4627 putting the BPT instruction in and taking it out.
4629 Note that this implementation is potentially redundant now that
4630 default_prepare_to_proceed() has been added.
4632 FIXME This may not support switching threads after Ctrl-C
4633 correctly. The default implementation does support this. */
4635 hppa_prepare_to_proceed (void)
4638 pid_t current_thread
;
4640 old_thread
= hppa_switched_threads (PIDGET (inferior_ptid
));
4641 if (old_thread
!= 0)
4643 /* Switched over from "old_thread". Try to do
4644 as little work as possible, 'cause mostly
4645 we're going to switch back. */
4647 CORE_ADDR old_pc
= read_pc ();
4649 /* Yuk, shouldn't use global to specify current
4650 thread. But that's how gdb does it. */
4651 current_thread
= PIDGET (inferior_ptid
);
4652 inferior_ptid
= pid_to_ptid (old_thread
);
4654 new_pc
= read_pc ();
4655 if (new_pc
!= old_pc
/* If at same pc, no need */
4656 && breakpoint_here_p (new_pc
))
4658 /* User hasn't deleted the BP.
4659 Return TRUE, finishing switch to "old_thread". */
4660 flush_cached_frames ();
4661 registers_changed ();
4663 printf ("---> PREPARE_TO_PROCEED (was %d, now %d)!\n",
4664 current_thread
, PIDGET (inferior_ptid
));
4670 /* Otherwise switch back to the user-chosen thread. */
4671 inferior_ptid
= pid_to_ptid (current_thread
);
4672 new_pc
= read_pc (); /* Re-prime register cache */
4677 #endif /* PREPARE_TO_PROCEED */
4680 hppa_skip_permanent_breakpoint (void)
4682 /* To step over a breakpoint instruction on the PA takes some
4683 fiddling with the instruction address queue.
4685 When we stop at a breakpoint, the IA queue front (the instruction
4686 we're executing now) points at the breakpoint instruction, and
4687 the IA queue back (the next instruction to execute) points to
4688 whatever instruction we would execute after the breakpoint, if it
4689 were an ordinary instruction. This is the case even if the
4690 breakpoint is in the delay slot of a branch instruction.
4692 Clearly, to step past the breakpoint, we need to set the queue
4693 front to the back. But what do we put in the back? What
4694 instruction comes after that one? Because of the branch delay
4695 slot, the next insn is always at the back + 4. */
4696 write_register (PCOQ_HEAD_REGNUM
, read_register (PCOQ_TAIL_REGNUM
));
4697 write_register (PCSQ_HEAD_REGNUM
, read_register (PCSQ_TAIL_REGNUM
));
4699 write_register (PCOQ_TAIL_REGNUM
, read_register (PCOQ_TAIL_REGNUM
) + 4);
4700 /* We can leave the tail's space the same, since there's no jump. */
4703 /* Copy the function value from VALBUF into the proper location
4704 for a function return.
4706 Called only in the context of the "return" command. */
4709 hppa_store_return_value (struct type
*type
, char *valbuf
)
4711 /* For software floating point, the return value goes into the
4712 integer registers. But we do not have any flag to key this on,
4713 so we always store the value into the integer registers.
4715 If its a float value, then we also store it into the floating
4717 deprecated_write_register_bytes (REGISTER_BYTE (28)
4718 + (TYPE_LENGTH (type
) > 4
4719 ? (8 - TYPE_LENGTH (type
))
4720 : (4 - TYPE_LENGTH (type
))),
4721 valbuf
, TYPE_LENGTH (type
));
4722 if (! SOFT_FLOAT
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
4723 deprecated_write_register_bytes (REGISTER_BYTE (FP4_REGNUM
),
4724 valbuf
, TYPE_LENGTH (type
));
4727 /* Copy the function's return value into VALBUF.
4729 This function is called only in the context of "target function calls",
4730 ie. when the debugger forces a function to be called in the child, and
4731 when the debugger forces a fucntion to return prematurely via the
4732 "return" command. */
4735 hppa_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
4737 if (! SOFT_FLOAT
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
4739 (char *)regbuf
+ REGISTER_BYTE (FP4_REGNUM
),
4740 TYPE_LENGTH (type
));
4744 + REGISTER_BYTE (28)
4745 + (TYPE_LENGTH (type
) > 4
4746 ? (8 - TYPE_LENGTH (type
))
4747 : (4 - TYPE_LENGTH (type
)))),
4748 TYPE_LENGTH (type
));
4752 hppa_reg_struct_has_addr (int gcc_p
, struct type
*type
)
4754 /* On the PA, any pass-by-value structure > 8 bytes is actually passed
4755 via a pointer regardless of its type or the compiler used. */
4756 return (TYPE_LENGTH (type
) > 8);
4760 hppa_inner_than (CORE_ADDR lhs
, CORE_ADDR rhs
)
4762 /* Stack grows upward */
4767 hppa_stack_align (CORE_ADDR sp
)
4769 /* elz: adjust the quantity to the next highest value which is
4770 64-bit aligned. This is used in valops.c, when the sp is adjusted.
4771 On hppa the sp must always be kept 64-bit aligned */
4772 return ((sp
% 8) ? (sp
+ 7) & -8 : sp
);
4776 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
4778 /* Sometimes we may pluck out a minimal symbol that has a negative address.
4780 An example of this occurs when an a.out is linked against a foo.sl.
4781 The foo.sl defines a global bar(), and the a.out declares a signature
4782 for bar(). However, the a.out doesn't directly call bar(), but passes
4783 its address in another call.
4785 If you have this scenario and attempt to "break bar" before running,
4786 gdb will find a minimal symbol for bar() in the a.out. But that
4787 symbol's address will be negative. What this appears to denote is
4788 an index backwards from the base of the procedure linkage table (PLT)
4789 into the data linkage table (DLT), the end of which is contiguous
4790 with the start of the PLT. This is clearly not a valid address for
4791 us to set a breakpoint on.
4793 Note that one must be careful in how one checks for a negative address.
4794 0xc0000000 is a legitimate address of something in a shared text
4795 segment, for example. Since I don't know what the possible range
4796 is of these "really, truly negative" addresses that come from the
4797 minimal symbols, I'm resorting to the gross hack of checking the
4798 top byte of the address for all 1's. Sigh. */
4800 return (!target_has_stack
&& (pc
& 0xFF000000));
4804 hppa_instruction_nullified (void)
4806 /* brobecker 2002/11/07: Couldn't we use a ULONGEST here? It would
4807 avoid the type cast. I'm leaving it as is for now as I'm doing
4808 semi-mechanical multiarching-related changes. */
4809 const int ipsw
= (int) read_register (IPSW_REGNUM
);
4810 const int flags
= (int) read_register (FLAGS_REGNUM
);
4812 return ((ipsw
& 0x00200000) && !(flags
& 0x2));
4815 /* Index within the register vector of the first byte of the space i
4816 used for register REG_NR. */
4819 hppa_register_byte (int reg_nr
)
4824 /* Return the GDB type object for the "standard" data type of data
4828 hppa_register_virtual_type (int reg_nr
)
4830 if (reg_nr
< FP4_REGNUM
)
4831 return builtin_type_int
;
4833 return builtin_type_float
;
4836 /* Store the address of the place in which to copy the structure the
4837 subroutine will return. This is called from call_function. */
4840 hppa_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
4842 write_register (28, addr
);
4845 /* Return True if REGNUM is not a register available to the user
4846 through ptrace(). */
4849 hppa_cannot_store_register (int regnum
)
4852 || regnum
== PCSQ_HEAD_REGNUM
4853 || (regnum
>= PCSQ_TAIL_REGNUM
&& regnum
< IPSW_REGNUM
)
4854 || (regnum
> IPSW_REGNUM
&& regnum
< FP4_REGNUM
));
4859 hppa_frame_args_address (struct frame_info
*fi
)
4865 hppa_frame_locals_address (struct frame_info
*fi
)
4871 hppa_smash_text_address (CORE_ADDR addr
)
4873 /* The low two bits of the PC on the PA contain the privilege level.
4874 Some genius implementing a (non-GCC) compiler apparently decided
4875 this means that "addresses" in a text section therefore include a
4876 privilege level, and thus symbol tables should contain these bits.
4877 This seems like a bonehead thing to do--anyway, it seems to work
4878 for our purposes to just ignore those bits. */
4880 return (addr
&= ~0x3);
4884 hppa_coerce_float_to_double (struct type
*formal
, struct type
*actual
)
4886 /* FIXME: For the pa, it appears that the debug info marks the
4887 parameters as floats regardless of whether the function is
4888 prototyped, but the actual values are passed as doubles for the
4889 non-prototyped case and floats for the prototyped case. Thus we
4890 choose to make the non-prototyped case work for C and break the
4891 prototyped case, since the non-prototyped case is probably much
4893 return (current_language
-> la_language
== language_c
);
4896 static struct gdbarch
*
4897 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
4899 struct gdbarch
*gdbarch
;
4900 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
4902 /* Try to determine the ABI of the object we are loading. */
4904 if (info
.abfd
!= NULL
)
4906 osabi
= gdbarch_lookup_osabi (info
.abfd
);
4907 if (osabi
== GDB_OSABI_UNKNOWN
)
4909 /* If it's a SOM file, assume it's HP/UX SOM. */
4910 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
4911 osabi
= GDB_OSABI_HPUX_SOM
;
4915 /* find a candidate among the list of pre-declared architectures. */
4916 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
4918 return (arches
->gdbarch
);
4920 /* If none found, then allocate and initialize one. */
4921 gdbarch
= gdbarch_alloc (&info
, NULL
);
4927 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
4929 /* Nothing to print for the moment. */
4933 _initialize_hppa_tdep (void)
4935 struct cmd_list_element
*c
;
4936 void break_at_finish_command (char *arg
, int from_tty
);
4937 void tbreak_at_finish_command (char *arg
, int from_tty
);
4938 void break_at_finish_at_depth_command (char *arg
, int from_tty
);
4940 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
4941 tm_print_insn
= print_insn_hppa
;
4943 add_cmd ("unwind", class_maintenance
, unwind_command
,
4944 "Print unwind table entry at given address.",
4945 &maintenanceprintlist
);
4947 deprecate_cmd (add_com ("xbreak", class_breakpoint
,
4948 break_at_finish_command
,
4949 concat ("Set breakpoint at procedure exit. \n\
4950 Argument may be function name, or \"*\" and an address.\n\
4951 If function is specified, break at end of code for that function.\n\
4952 If an address is specified, break at the end of the function that contains \n\
4953 that exact address.\n",
4954 "With no arg, uses current execution address of selected stack frame.\n\
4955 This is useful for breaking on return to a stack frame.\n\
4957 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
4959 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
)), NULL
);
4960 deprecate_cmd (add_com_alias ("xb", "xbreak", class_breakpoint
, 1), NULL
);
4961 deprecate_cmd (add_com_alias ("xbr", "xbreak", class_breakpoint
, 1), NULL
);
4962 deprecate_cmd (add_com_alias ("xbre", "xbreak", class_breakpoint
, 1), NULL
);
4963 deprecate_cmd (add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1), NULL
);
4965 deprecate_cmd (c
= add_com ("txbreak", class_breakpoint
,
4966 tbreak_at_finish_command
,
4967 "Set temporary breakpoint at procedure exit. Either there should\n\
4968 be no argument or the argument must be a depth.\n"), NULL
);
4969 set_cmd_completer (c
, location_completer
);
4972 deprecate_cmd (add_com ("bx", class_breakpoint
,
4973 break_at_finish_at_depth_command
,
4974 "Set breakpoint at procedure exit. Either there should\n\
4975 be no argument or the argument must be a depth.\n"), NULL
);