1 /* Machine-dependent code which would otherwise be in inflow.c and core.c,
2 for GDB, the GNU debugger. This code is for the HP PA-RISC cpu.
3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
5 Contributed by the Center for Software Science at the
6 University of Utah (pa-gdb-bugs@cs.utah.edu).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 /* For argument passing to the inferior */
33 #include <sys/types.h>
36 #include <sys/param.h>
39 #include <sys/ioctl.h>
41 #ifdef COFF_ENCAPSULATE
42 #include "a.out.encap.h"
47 #define N_SET_MAGIC(exec, val) ((exec).a_magic = (val))
50 /*#include <sys/user.h> After a.out.h */
53 #include <machine/psl.h>
62 static int restore_pc_queue
PARAMS ((struct frame_saved_regs
*fsr
));
63 static int hppa_alignof
PARAMS ((struct type
*arg
));
64 CORE_ADDR frame_saved_pc
PARAMS ((FRAME frame
));
65 static int prologue_inst_adjust_sp
PARAMS ((unsigned long));
66 static int is_branch
PARAMS ((unsigned long));
67 static int inst_saves_gr
PARAMS ((unsigned long));
68 static int inst_saves_fr
PARAMS ((unsigned long));
69 static int pc_in_interrupt_handler
PARAMS ((CORE_ADDR
));
70 static int pc_in_linker_stub
PARAMS ((CORE_ADDR
));
71 static int compare_unwind_entries
PARAMS ((const struct unwind_table_entry
*,
72 const struct unwind_table_entry
*));
73 static void read_unwind_info
PARAMS ((struct objfile
*));
74 static void internalize_unwinds
PARAMS ((struct objfile
*,
75 struct unwind_table_entry
*,
76 asection
*, unsigned int,
80 /* Routines to extract various sized constants out of hppa
83 /* This assumes that no garbage lies outside of the lower bits of
87 sign_extend (val
, bits
)
90 return (int)(val
>> bits
- 1 ? (-1 << bits
) | val
: val
);
93 /* For many immediate values the sign bit is the low bit! */
96 low_sign_extend (val
, bits
)
99 return (int)((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
101 /* extract the immediate field from a ld{bhw}s instruction */
104 get_field (val
, from
, to
)
105 unsigned val
, from
, to
;
107 val
= val
>> 31 - to
;
108 return val
& ((1 << 32 - from
) - 1);
112 set_field (val
, from
, to
, new_val
)
113 unsigned *val
, from
, to
;
115 unsigned mask
= ~((1 << (to
- from
+ 1)) << (31 - from
));
116 return *val
= *val
& mask
| (new_val
<< (31 - from
));
119 /* extract a 3-bit space register number from a be, ble, mtsp or mfsp */
124 return GET_FIELD (word
, 18, 18) << 2 | GET_FIELD (word
, 16, 17);
127 extract_5_load (word
)
130 return low_sign_extend (word
>> 16 & MASK_5
, 5);
133 /* extract the immediate field from a st{bhw}s instruction */
136 extract_5_store (word
)
139 return low_sign_extend (word
& MASK_5
, 5);
142 /* extract the immediate field from a break instruction */
145 extract_5r_store (word
)
148 return (word
& MASK_5
);
151 /* extract the immediate field from a {sr}sm instruction */
154 extract_5R_store (word
)
157 return (word
>> 16 & MASK_5
);
160 /* extract an 11 bit immediate field */
166 return low_sign_extend (word
& MASK_11
, 11);
169 /* extract a 14 bit immediate field */
175 return low_sign_extend (word
& MASK_14
, 14);
178 /* deposit a 14 bit constant in a word */
181 deposit_14 (opnd
, word
)
185 unsigned sign
= (opnd
< 0 ? 1 : 0);
187 return word
| ((unsigned)opnd
<< 1 & MASK_14
) | sign
;
190 /* extract a 21 bit constant */
200 val
= GET_FIELD (word
, 20, 20);
202 val
|= GET_FIELD (word
, 9, 19);
204 val
|= GET_FIELD (word
, 5, 6);
206 val
|= GET_FIELD (word
, 0, 4);
208 val
|= GET_FIELD (word
, 7, 8);
209 return sign_extend (val
, 21) << 11;
212 /* deposit a 21 bit constant in a word. Although 21 bit constants are
213 usually the top 21 bits of a 32 bit constant, we assume that only
214 the low 21 bits of opnd are relevant */
217 deposit_21 (opnd
, word
)
222 val
|= GET_FIELD (opnd
, 11 + 14, 11 + 18);
224 val
|= GET_FIELD (opnd
, 11 + 12, 11 + 13);
226 val
|= GET_FIELD (opnd
, 11 + 19, 11 + 20);
228 val
|= GET_FIELD (opnd
, 11 + 1, 11 + 11);
230 val
|= GET_FIELD (opnd
, 11 + 0, 11 + 0);
234 /* extract a 12 bit constant from branch instructions */
240 return sign_extend (GET_FIELD (word
, 19, 28) |
241 GET_FIELD (word
, 29, 29) << 10 |
242 (word
& 0x1) << 11, 12) << 2;
245 /* extract a 17 bit constant from branch instructions, returning the
246 19 bit signed value. */
252 return sign_extend (GET_FIELD (word
, 19, 28) |
253 GET_FIELD (word
, 29, 29) << 10 |
254 GET_FIELD (word
, 11, 15) << 11 |
255 (word
& 0x1) << 16, 17) << 2;
259 /* Compare the start address for two unwind entries returning 1 if
260 the first address is larger than the second, -1 if the second is
261 larger than the first, and zero if they are equal. */
264 compare_unwind_entries (a
, b
)
265 const struct unwind_table_entry
*a
;
266 const struct unwind_table_entry
*b
;
268 if (a
->region_start
> b
->region_start
)
270 else if (a
->region_start
< b
->region_start
)
277 internalize_unwinds (objfile
, table
, section
, entries
, size
)
278 struct objfile
*objfile
;
279 struct unwind_table_entry
*table
;
281 unsigned int entries
, size
;
283 /* We will read the unwind entries into temporary memory, then
284 fill in the actual unwind table. */
289 char *buf
= alloca (size
);
291 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
293 /* Now internalize the information being careful to handle host/target
295 for (i
= 0; i
< entries
; i
++)
297 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
300 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*)buf
);
302 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*)buf
);
304 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;;
305 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
306 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
307 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
308 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
309 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
310 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
311 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
312 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
313 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
314 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
315 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12 ) & 0x1;
316 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
317 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
318 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
319 table
[i
].reserved2
= (tmp
>> 5) & 0xf;
320 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
321 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
322 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
323 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
324 table
[i
].Cleanup_defined
= tmp
& 0x1;
325 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*)buf
);
327 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
328 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
329 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
330 table
[i
].reserved4
= (tmp
>> 27) & 0x3;
331 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
336 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
337 the object file. This info is used mainly by find_unwind_entry() to find
338 out the stack frame size and frame pointer used by procedures. We put
339 everything on the psymbol obstack in the objfile so that it automatically
340 gets freed when the objfile is destroyed. */
343 read_unwind_info (objfile
)
344 struct objfile
*objfile
;
346 asection
*unwind_sec
, *elf_unwind_sec
, *stub_unwind_sec
;
347 unsigned unwind_size
, elf_unwind_size
, stub_unwind_size
, total_size
;
348 unsigned index
, unwind_entries
, elf_unwind_entries
;
349 unsigned stub_entries
, total_entries
;
350 struct obj_unwind_info
*ui
;
352 ui
= obstack_alloc (&objfile
->psymbol_obstack
,
353 sizeof (struct obj_unwind_info
));
359 /* Get hooks to all unwind sections. Note there is no linker-stub unwind
360 section in ELF at the moment. */
361 unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_START$");
362 elf_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, ".PARISC.unwind");
363 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
365 /* Get sizes and unwind counts for all sections. */
368 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
369 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
379 elf_unwind_size
= bfd_section_size (objfile
->obfd
, elf_unwind_sec
);
380 elf_unwind_entries
= elf_unwind_size
/ UNWIND_ENTRY_SIZE
;
385 elf_unwind_entries
= 0;
390 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
391 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
395 stub_unwind_size
= 0;
399 /* Compute total number of unwind entries and their total size. */
400 total_entries
= unwind_entries
+ elf_unwind_entries
+ stub_entries
;
401 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
403 /* Allocate memory for the unwind table. */
404 ui
->table
= obstack_alloc (&objfile
->psymbol_obstack
, total_size
);
405 ui
->last
= total_entries
- 1;
407 /* Internalize the standard unwind entries. */
409 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
410 unwind_entries
, unwind_size
);
411 index
+= unwind_entries
;
412 internalize_unwinds (objfile
, &ui
->table
[index
], elf_unwind_sec
,
413 elf_unwind_entries
, elf_unwind_size
);
414 index
+= elf_unwind_entries
;
416 /* Now internalize the stub unwind entries. */
417 if (stub_unwind_size
> 0)
420 char *buf
= alloca (stub_unwind_size
);
422 /* Read in the stub unwind entries. */
423 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
424 0, stub_unwind_size
);
426 /* Now convert them into regular unwind entries. */
427 for (i
= 0; i
< stub_entries
; i
++, index
++)
429 /* Clear out the next unwind entry. */
430 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
432 /* Convert offset & size into region_start and region_end.
433 Stuff away the stub type into "reserved" fields. */
434 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
437 ui
->table
[index
].stub_type
= bfd_get_8 (objfile
->obfd
,
440 ui
->table
[index
].region_end
441 = ui
->table
[index
].region_start
+ 4 *
442 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
448 /* Unwind table needs to be kept sorted. */
449 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
450 compare_unwind_entries
);
452 /* Keep a pointer to the unwind information. */
453 objfile
->obj_private
= (PTR
) ui
;
456 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
457 of the objfiles seeking the unwind table entry for this PC. Each objfile
458 contains a sorted list of struct unwind_table_entry. Since we do a binary
459 search of the unwind tables, we depend upon them to be sorted. */
461 static struct unwind_table_entry
*
462 find_unwind_entry(pc
)
465 int first
, middle
, last
;
466 struct objfile
*objfile
;
468 ALL_OBJFILES (objfile
)
470 struct obj_unwind_info
*ui
;
472 ui
= OBJ_UNWIND_INFO (objfile
);
476 read_unwind_info (objfile
);
477 ui
= OBJ_UNWIND_INFO (objfile
);
480 /* First, check the cache */
483 && pc
>= ui
->cache
->region_start
484 && pc
<= ui
->cache
->region_end
)
487 /* Not in the cache, do a binary search */
492 while (first
<= last
)
494 middle
= (first
+ last
) / 2;
495 if (pc
>= ui
->table
[middle
].region_start
496 && pc
<= ui
->table
[middle
].region_end
)
498 ui
->cache
= &ui
->table
[middle
];
499 return &ui
->table
[middle
];
502 if (pc
< ui
->table
[middle
].region_start
)
507 } /* ALL_OBJFILES() */
511 /* Called to determine if PC is in an interrupt handler of some
515 pc_in_interrupt_handler (pc
)
518 struct unwind_table_entry
*u
;
519 struct minimal_symbol
*msym_us
;
521 u
= find_unwind_entry (pc
);
525 /* Oh joys. HPUX sets the interrupt bit for _sigreturn even though
526 its frame isn't a pure interrupt frame. Deal with this. */
527 msym_us
= lookup_minimal_symbol_by_pc (pc
);
529 return u
->HP_UX_interrupt_marker
&& !IN_SIGTRAMP (pc
, SYMBOL_NAME (msym_us
));
532 /* Called when no unwind descriptor was found for PC. Returns 1 if it
533 appears that PC is in a linker stub. */
536 pc_in_linker_stub (pc
)
539 int found_magic_instruction
= 0;
543 /* If unable to read memory, assume pc is not in a linker stub. */
544 if (target_read_memory (pc
, buf
, 4) != 0)
547 /* We are looking for something like
549 ; $$dyncall jams RP into this special spot in the frame (RP')
550 ; before calling the "call stub"
553 ldsid (rp),r1 ; Get space associated with RP into r1
554 mtsp r1,sp ; Move it into space register 0
555 be,n 0(sr0),rp) ; back to your regularly scheduled program
558 /* Maximum known linker stub size is 4 instructions. Search forward
559 from the given PC, then backward. */
560 for (i
= 0; i
< 4; i
++)
562 /* If we hit something with an unwind, stop searching this direction. */
564 if (find_unwind_entry (pc
+ i
* 4) != 0)
567 /* Check for ldsid (rp),r1 which is the magic instruction for a
568 return from a cross-space function call. */
569 if (read_memory_integer (pc
+ i
* 4, 4) == 0x004010a1)
571 found_magic_instruction
= 1;
574 /* Add code to handle long call/branch and argument relocation stubs
578 if (found_magic_instruction
!= 0)
581 /* Now look backward. */
582 for (i
= 0; i
< 4; i
++)
584 /* If we hit something with an unwind, stop searching this direction. */
586 if (find_unwind_entry (pc
- i
* 4) != 0)
589 /* Check for ldsid (rp),r1 which is the magic instruction for a
590 return from a cross-space function call. */
591 if (read_memory_integer (pc
- i
* 4, 4) == 0x004010a1)
593 found_magic_instruction
= 1;
596 /* Add code to handle long call/branch and argument relocation stubs
599 return found_magic_instruction
;
603 find_return_regnum(pc
)
606 struct unwind_table_entry
*u
;
608 u
= find_unwind_entry (pc
);
619 /* Return size of frame, or -1 if we should use a frame pointer. */
621 find_proc_framesize (pc
)
624 struct unwind_table_entry
*u
;
625 struct minimal_symbol
*msym_us
;
627 u
= find_unwind_entry (pc
);
631 if (pc_in_linker_stub (pc
))
632 /* Linker stubs have a zero size frame. */
638 msym_us
= lookup_minimal_symbol_by_pc (pc
);
640 /* If Save_SP is set, and we're not in an interrupt or signal caller,
641 then we have a frame pointer. Use it. */
642 if (u
->Save_SP
&& !pc_in_interrupt_handler (pc
)
643 && !IN_SIGTRAMP (pc
, SYMBOL_NAME (msym_us
)))
646 return u
->Total_frame_size
<< 3;
649 /* Return offset from sp at which rp is saved, or 0 if not saved. */
650 static int rp_saved
PARAMS ((CORE_ADDR
));
656 struct unwind_table_entry
*u
;
658 u
= find_unwind_entry (pc
);
662 if (pc_in_linker_stub (pc
))
663 /* This is the so-called RP'. */
671 else if (u
->stub_type
!= 0)
673 switch (u
->stub_type
)
677 case PARAMETER_RELOCATION
:
688 frameless_function_invocation (frame
)
691 struct unwind_table_entry
*u
;
693 u
= find_unwind_entry (frame
->pc
);
698 return (u
->Total_frame_size
== 0 && u
->stub_type
== 0);
702 saved_pc_after_call (frame
)
707 struct unwind_table_entry
*u
;
709 ret_regnum
= find_return_regnum (get_frame_pc (frame
));
710 pc
= read_register (ret_regnum
) & ~0x3;
712 /* If PC is in a linker stub, then we need to dig the address
713 the stub will return to out of the stack. */
714 u
= find_unwind_entry (pc
);
715 if (u
&& u
->stub_type
!= 0)
716 return frame_saved_pc (frame
);
722 frame_saved_pc (frame
)
725 CORE_ADDR pc
= get_frame_pc (frame
);
726 struct unwind_table_entry
*u
;
728 /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
729 at the base of the frame in an interrupt handler. Registers within
730 are saved in the exact same order as GDB numbers registers. How
732 if (pc_in_interrupt_handler (pc
))
733 return read_memory_integer (frame
->frame
+ PC_REGNUM
* 4, 4) & ~0x3;
735 /* Deal with signal handler caller frames too. */
736 if (frame
->signal_handler_caller
)
739 FRAME_SAVED_PC_IN_SIGTRAMP (frame
, &rp
);
743 if (frameless_function_invocation (frame
))
747 ret_regnum
= find_return_regnum (pc
);
749 /* If the next frame is an interrupt frame or a signal
750 handler caller, then we need to look in the saved
751 register area to get the return pointer (the values
752 in the registers may not correspond to anything useful). */
754 && (frame
->next
->signal_handler_caller
755 || pc_in_interrupt_handler (frame
->next
->pc
)))
757 struct frame_info
*fi
;
758 struct frame_saved_regs saved_regs
;
760 fi
= get_frame_info (frame
->next
);
761 get_frame_saved_regs (fi
, &saved_regs
);
762 if (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
] & 0x2, 4))
763 pc
= read_memory_integer (saved_regs
.regs
[31], 4) & ~0x3;
765 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
], 4) & ~0x3;
768 pc
= read_register (ret_regnum
) & ~0x3;
775 rp_offset
= rp_saved (pc
);
776 /* Similar to code in frameless function case. If the next
777 frame is a signal or interrupt handler, then dig the right
778 information out of the saved register info. */
781 && (frame
->next
->signal_handler_caller
782 || pc_in_interrupt_handler (frame
->next
->pc
)))
784 struct frame_info
*fi
;
785 struct frame_saved_regs saved_regs
;
787 fi
= get_frame_info (frame
->next
);
788 get_frame_saved_regs (fi
, &saved_regs
);
789 if (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
] & 0x2, 4))
790 pc
= read_memory_integer (saved_regs
.regs
[31], 4) & ~0x3;
792 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
], 4) & ~0x3;
794 else if (rp_offset
== 0)
795 pc
= read_register (RP_REGNUM
) & ~0x3;
797 pc
= read_memory_integer (frame
->frame
+ rp_offset
, 4) & ~0x3;
800 /* If PC is inside a linker stub, then dig out the address the stub
802 u
= find_unwind_entry (pc
);
803 if (u
&& u
->stub_type
!= 0)
809 /* We need to correct the PC and the FP for the outermost frame when we are
813 init_extra_frame_info (fromleaf
, frame
)
815 struct frame_info
*frame
;
820 if (frame
->next
&& !fromleaf
)
823 /* If the next frame represents a frameless function invocation
824 then we have to do some adjustments that are normally done by
825 FRAME_CHAIN. (FRAME_CHAIN is not called in this case.) */
828 /* Find the framesize of *this* frame without peeking at the PC
829 in the current frame structure (it isn't set yet). */
830 framesize
= find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame
)));
832 /* Now adjust our base frame accordingly. If we have a frame pointer
833 use it, else subtract the size of this frame from the current
834 frame. (we always want frame->frame to point at the lowest address
837 frame
->frame
= read_register (FP_REGNUM
);
839 frame
->frame
-= framesize
;
843 flags
= read_register (FLAGS_REGNUM
);
844 if (flags
& 2) /* In system call? */
845 frame
->pc
= read_register (31) & ~0x3;
847 /* The outermost frame is always derived from PC-framesize
849 One might think frameless innermost frames should have
850 a frame->frame that is the same as the parent's frame->frame.
851 That is wrong; frame->frame in that case should be the *high*
852 address of the parent's frame. It's complicated as hell to
853 explain, but the parent *always* creates some stack space for
854 the child. So the child actually does have a frame of some
855 sorts, and its base is the high address in its parent's frame. */
856 framesize
= find_proc_framesize(frame
->pc
);
858 frame
->frame
= read_register (FP_REGNUM
);
860 frame
->frame
= read_register (SP_REGNUM
) - framesize
;
863 /* Given a GDB frame, determine the address of the calling function's frame.
864 This will be used to create a new GDB frame struct, and then
865 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
867 This may involve searching through prologues for several functions
868 at boundaries where GCC calls HP C code, or where code which has
869 a frame pointer calls code without a frame pointer. */
874 struct frame_info
*frame
;
876 int my_framesize
, caller_framesize
;
877 struct unwind_table_entry
*u
;
878 CORE_ADDR frame_base
;
880 /* Handle HPUX, BSD, and OSF1 style interrupt frames first. These
881 are easy; at *sp we have a full save state strucutre which we can
882 pull the old stack pointer from. Also see frame_saved_pc for
883 code to dig a saved PC out of the save state structure. */
884 if (pc_in_interrupt_handler (frame
->pc
))
885 frame_base
= read_memory_integer (frame
->frame
+ SP_REGNUM
* 4, 4);
886 else if (frame
->signal_handler_caller
)
888 FRAME_BASE_BEFORE_SIGTRAMP (frame
, &frame_base
);
891 frame_base
= frame
->frame
;
893 /* Get frame sizes for the current frame and the frame of the
895 my_framesize
= find_proc_framesize (frame
->pc
);
896 caller_framesize
= find_proc_framesize (FRAME_SAVED_PC(frame
));
898 /* If caller does not have a frame pointer, then its frame
899 can be found at current_frame - caller_framesize. */
900 if (caller_framesize
!= -1)
901 return frame_base
- caller_framesize
;
903 /* Both caller and callee have frame pointers and are GCC compiled
904 (SAVE_SP bit in unwind descriptor is on for both functions.
905 The previous frame pointer is found at the top of the current frame. */
906 if (caller_framesize
== -1 && my_framesize
== -1)
907 return read_memory_integer (frame_base
, 4);
909 /* Caller has a frame pointer, but callee does not. This is a little
910 more difficult as GCC and HP C lay out locals and callee register save
911 areas very differently.
913 The previous frame pointer could be in a register, or in one of
914 several areas on the stack.
916 Walk from the current frame to the innermost frame examining
917 unwind descriptors to determine if %r3 ever gets saved into the
918 stack. If so return whatever value got saved into the stack.
919 If it was never saved in the stack, then the value in %r3 is still
922 We use information from unwind descriptors to determine if %r3
923 is saved into the stack (Entry_GR field has this information). */
927 u
= find_unwind_entry (frame
->pc
);
931 /* We could find this information by examining prologues. I don't
932 think anyone has actually written any tools (not even "strip")
933 which leave them out of an executable, so maybe this is a moot
935 warning ("Unable to find unwind for PC 0x%x -- Help!", frame
->pc
);
939 /* Entry_GR specifies the number of callee-saved general registers
940 saved in the stack. It starts at %r3, so %r3 would be 1. */
941 if (u
->Entry_GR
>= 1 || u
->Save_SP
942 || frame
->signal_handler_caller
943 || pc_in_interrupt_handler (frame
->pc
))
951 /* We may have walked down the chain into a function with a frame
954 && !frame
->signal_handler_caller
955 && !pc_in_interrupt_handler (frame
->pc
))
956 return read_memory_integer (frame
->frame
, 4);
957 /* %r3 was saved somewhere in the stack. Dig it out. */
960 struct frame_info
*fi
;
961 struct frame_saved_regs saved_regs
;
963 fi
= get_frame_info (frame
);
964 get_frame_saved_regs (fi
, &saved_regs
);
965 return read_memory_integer (saved_regs
.regs
[FP_REGNUM
], 4);
970 /* The value in %r3 was never saved into the stack (thus %r3 still
971 holds the value of the previous frame pointer). */
972 return read_register (FP_REGNUM
);
977 /* To see if a frame chain is valid, see if the caller looks like it
978 was compiled with gcc. */
981 frame_chain_valid (chain
, thisframe
)
985 struct minimal_symbol
*msym_us
;
986 struct minimal_symbol
*msym_start
;
987 struct unwind_table_entry
*u
, *next_u
= NULL
;
993 u
= find_unwind_entry (thisframe
->pc
);
998 /* We can't just check that the same of msym_us is "_start", because
999 someone idiotically decided that they were going to make a Ltext_end
1000 symbol with the same address. This Ltext_end symbol is totally
1001 indistinguishable (as nearly as I can tell) from the symbol for a function
1002 which is (legitimately, since it is in the user's namespace)
1003 named Ltext_end, so we can't just ignore it. */
1004 msym_us
= lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe
));
1005 msym_start
= lookup_minimal_symbol ("_start", NULL
);
1008 && SYMBOL_VALUE_ADDRESS (msym_us
) == SYMBOL_VALUE_ADDRESS (msym_start
))
1011 next
= get_next_frame (thisframe
);
1013 next_u
= find_unwind_entry (next
->pc
);
1015 /* If this frame does not save SP, has no stack, isn't a stub,
1016 and doesn't "call" an interrupt routine or signal handler caller,
1017 then its not valid. */
1018 if (u
->Save_SP
|| u
->Total_frame_size
|| u
->stub_type
!= 0
1019 || (thisframe
->next
&& thisframe
->next
->signal_handler_caller
)
1020 || (next_u
&& next_u
->HP_UX_interrupt_marker
))
1023 if (pc_in_linker_stub (thisframe
->pc
))
1030 * These functions deal with saving and restoring register state
1031 * around a function call in the inferior. They keep the stack
1032 * double-word aligned; eventually, on an hp700, the stack will have
1033 * to be aligned to a 64-byte boundary.
1039 register CORE_ADDR sp
;
1040 register int regnum
;
1044 /* Space for "arguments"; the RP goes in here. */
1045 sp
= read_register (SP_REGNUM
) + 48;
1046 int_buffer
= read_register (RP_REGNUM
) | 0x3;
1047 write_memory (sp
- 20, (char *)&int_buffer
, 4);
1049 int_buffer
= read_register (FP_REGNUM
);
1050 write_memory (sp
, (char *)&int_buffer
, 4);
1052 write_register (FP_REGNUM
, sp
);
1056 for (regnum
= 1; regnum
< 32; regnum
++)
1057 if (regnum
!= RP_REGNUM
&& regnum
!= FP_REGNUM
)
1058 sp
= push_word (sp
, read_register (regnum
));
1062 for (regnum
= FP0_REGNUM
; regnum
< NUM_REGS
; regnum
++)
1064 read_register_bytes (REGISTER_BYTE (regnum
), (char *)&freg_buffer
, 8);
1065 sp
= push_bytes (sp
, (char *)&freg_buffer
, 8);
1067 sp
= push_word (sp
, read_register (IPSW_REGNUM
));
1068 sp
= push_word (sp
, read_register (SAR_REGNUM
));
1069 sp
= push_word (sp
, read_register (PCOQ_HEAD_REGNUM
));
1070 sp
= push_word (sp
, read_register (PCSQ_HEAD_REGNUM
));
1071 sp
= push_word (sp
, read_register (PCOQ_TAIL_REGNUM
));
1072 sp
= push_word (sp
, read_register (PCSQ_TAIL_REGNUM
));
1073 write_register (SP_REGNUM
, sp
);
1076 find_dummy_frame_regs (frame
, frame_saved_regs
)
1077 struct frame_info
*frame
;
1078 struct frame_saved_regs
*frame_saved_regs
;
1080 CORE_ADDR fp
= frame
->frame
;
1083 frame_saved_regs
->regs
[RP_REGNUM
] = fp
- 20 & ~0x3;
1084 frame_saved_regs
->regs
[FP_REGNUM
] = fp
;
1085 frame_saved_regs
->regs
[1] = fp
+ 8;
1087 for (fp
+= 12, i
= 3; i
< 32; i
++)
1091 frame_saved_regs
->regs
[i
] = fp
;
1097 for (i
= FP0_REGNUM
; i
< NUM_REGS
; i
++, fp
+= 8)
1098 frame_saved_regs
->regs
[i
] = fp
;
1100 frame_saved_regs
->regs
[IPSW_REGNUM
] = fp
;
1101 frame_saved_regs
->regs
[SAR_REGNUM
] = fp
+ 4;
1102 frame_saved_regs
->regs
[PCOQ_HEAD_REGNUM
] = fp
+ 8;
1103 frame_saved_regs
->regs
[PCSQ_HEAD_REGNUM
] = fp
+ 12;
1104 frame_saved_regs
->regs
[PCOQ_TAIL_REGNUM
] = fp
+ 16;
1105 frame_saved_regs
->regs
[PCSQ_TAIL_REGNUM
] = fp
+ 20;
1111 register FRAME frame
= get_current_frame ();
1112 register CORE_ADDR fp
;
1113 register int regnum
;
1114 struct frame_saved_regs fsr
;
1115 struct frame_info
*fi
;
1118 fi
= get_frame_info (frame
);
1120 get_frame_saved_regs (fi
, &fsr
);
1122 #ifndef NO_PC_SPACE_QUEUE_RESTORE
1123 if (fsr
.regs
[IPSW_REGNUM
]) /* Restoring a call dummy frame */
1124 restore_pc_queue (&fsr
);
1127 for (regnum
= 31; regnum
> 0; regnum
--)
1128 if (fsr
.regs
[regnum
])
1129 write_register (regnum
, read_memory_integer (fsr
.regs
[regnum
], 4));
1131 for (regnum
= NUM_REGS
- 1; regnum
>= FP0_REGNUM
; regnum
--)
1132 if (fsr
.regs
[regnum
])
1134 read_memory (fsr
.regs
[regnum
], (char *)&freg_buffer
, 8);
1135 write_register_bytes (REGISTER_BYTE (regnum
), (char *)&freg_buffer
, 8);
1138 if (fsr
.regs
[IPSW_REGNUM
])
1139 write_register (IPSW_REGNUM
,
1140 read_memory_integer (fsr
.regs
[IPSW_REGNUM
], 4));
1142 if (fsr
.regs
[SAR_REGNUM
])
1143 write_register (SAR_REGNUM
,
1144 read_memory_integer (fsr
.regs
[SAR_REGNUM
], 4));
1146 /* If the PC was explicitly saved, then just restore it. */
1147 if (fsr
.regs
[PCOQ_TAIL_REGNUM
])
1148 write_register (PCOQ_TAIL_REGNUM
,
1149 read_memory_integer (fsr
.regs
[PCOQ_TAIL_REGNUM
], 4));
1151 /* Else use the value in %rp to set the new PC. */
1153 target_write_pc (read_register (RP_REGNUM
), 0);
1155 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
1157 if (fsr
.regs
[IPSW_REGNUM
]) /* call dummy */
1158 write_register (SP_REGNUM
, fp
- 48);
1160 write_register (SP_REGNUM
, fp
);
1162 flush_cached_frames ();
1163 set_current_frame (create_new_frame (read_register (FP_REGNUM
),
1168 * After returning to a dummy on the stack, restore the instruction
1169 * queue space registers. */
1172 restore_pc_queue (fsr
)
1173 struct frame_saved_regs
*fsr
;
1175 CORE_ADDR pc
= read_pc ();
1176 CORE_ADDR new_pc
= read_memory_integer (fsr
->regs
[PCOQ_HEAD_REGNUM
], 4);
1178 struct target_waitstatus w
;
1181 /* Advance past break instruction in the call dummy. */
1182 write_register (PCOQ_HEAD_REGNUM
, pc
+ 4);
1183 write_register (PCOQ_TAIL_REGNUM
, pc
+ 8);
1186 * HPUX doesn't let us set the space registers or the space
1187 * registers of the PC queue through ptrace. Boo, hiss.
1188 * Conveniently, the call dummy has this sequence of instructions
1193 * So, load up the registers and single step until we are in the
1197 write_register (21, read_memory_integer (fsr
->regs
[PCSQ_HEAD_REGNUM
], 4));
1198 write_register (22, new_pc
);
1200 for (insn_count
= 0; insn_count
< 3; insn_count
++)
1202 /* FIXME: What if the inferior gets a signal right now? Want to
1203 merge this into wait_for_inferior (as a special kind of
1204 watchpoint? By setting a breakpoint at the end? Is there
1205 any other choice? Is there *any* way to do this stuff with
1206 ptrace() or some equivalent?). */
1208 target_wait (inferior_pid
, &w
);
1210 if (w
.kind
== TARGET_WAITKIND_SIGNALLED
)
1212 stop_signal
= w
.value
.sig
;
1213 terminal_ours_for_output ();
1214 printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
1215 target_signal_to_name (stop_signal
),
1216 target_signal_to_string (stop_signal
));
1217 gdb_flush (gdb_stdout
);
1221 target_terminal_ours ();
1222 target_fetch_registers (-1);
1227 hppa_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
1232 CORE_ADDR struct_addr
;
1234 /* array of arguments' offsets */
1235 int *offset
= (int *)alloca(nargs
* sizeof (int));
1239 for (i
= 0; i
< nargs
; i
++)
1241 /* Coerce chars to int & float to double if necessary */
1242 args
[i
] = value_arg_coerce (args
[i
]);
1244 cum
+= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1246 /* value must go at proper alignment. Assume alignment is a
1248 alignment
= hppa_alignof (VALUE_TYPE (args
[i
]));
1249 if (cum
% alignment
)
1250 cum
= (cum
+ alignment
) & -alignment
;
1253 sp
+= max ((cum
+ 7) & -8, 16);
1255 for (i
= 0; i
< nargs
; i
++)
1256 write_memory (sp
+ offset
[i
], VALUE_CONTENTS (args
[i
]),
1257 TYPE_LENGTH (VALUE_TYPE (args
[i
])));
1260 write_register (28, struct_addr
);
1265 * Insert the specified number of args and function address
1266 * into a call sequence of the above form stored at DUMMYNAME.
1268 * On the hppa we need to call the stack dummy through $$dyncall.
1269 * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
1270 * real_pc, which is the location where gdb should start up the
1271 * inferior to do the function call.
1275 hppa_fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)
1284 CORE_ADDR dyncall_addr
, sr4export_addr
;
1285 struct minimal_symbol
*msymbol
;
1286 int flags
= read_register (FLAGS_REGNUM
);
1287 struct unwind_table_entry
*u
;
1289 msymbol
= lookup_minimal_symbol ("$$dyncall", (struct objfile
*) NULL
);
1290 if (msymbol
== NULL
)
1291 error ("Can't find an address for $$dyncall trampoline");
1293 dyncall_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1295 /* FUN could be a procedure label, in which case we have to get
1296 its real address and the value of its GOT/DP. */
1299 /* Get the GOT/DP value for the target function. It's
1300 at *(fun+4). Note the call dummy is *NOT* allowed to
1301 trash %r19 before calling the target function. */
1302 write_register (19, read_memory_integer ((fun
& ~0x3) + 4, 4));
1304 /* Now get the real address for the function we are calling, it's
1306 fun
= (CORE_ADDR
) read_memory_integer (fun
& ~0x3, 4);
1309 /* If we are calling an import stub (eg calling into a dynamic library)
1310 then have sr4export call the magic __d_plt_call routine which is linked
1311 in from end.o. (You can't use _sr4export to call the import stub as
1312 the value in sp-24 will get fried and you end up returning to the
1313 wrong location. You can't call the import stub directly as the code
1314 to bind the PLT entry to a function can't return to a stack address.) */
1315 u
= find_unwind_entry (fun
);
1316 if (u
&& u
->stub_type
== IMPORT
)
1319 msymbol
= lookup_minimal_symbol ("__d_plt_call", (struct objfile
*) NULL
);
1320 if (msymbol
== NULL
)
1321 error ("Can't find an address for __d_plt_call trampoline");
1323 /* This is where sr4export will jump to. */
1324 new_fun
= SYMBOL_VALUE_ADDRESS (msymbol
);
1326 /* We have to store the address of the stub in __shlib_funcptr. */
1327 msymbol
= lookup_minimal_symbol ("__shlib_funcptr",
1328 (struct objfile
*)NULL
);
1329 if (msymbol
== NULL
)
1330 error ("Can't find an address for __shlib_funcptr");
1332 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol
), (char *)&fun
, 4);
1337 /* We still need sr4export's address too. */
1338 msymbol
= lookup_minimal_symbol ("_sr4export", (struct objfile
*) NULL
);
1339 if (msymbol
== NULL
)
1340 error ("Can't find an address for _sr4export trampoline");
1342 sr4export_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1344 store_unsigned_integer
1345 (&dummy
[9*REGISTER_SIZE
],
1347 deposit_21 (fun
>> 11,
1348 extract_unsigned_integer (&dummy
[9*REGISTER_SIZE
],
1350 store_unsigned_integer
1351 (&dummy
[10*REGISTER_SIZE
],
1353 deposit_14 (fun
& MASK_11
,
1354 extract_unsigned_integer (&dummy
[10*REGISTER_SIZE
],
1356 store_unsigned_integer
1357 (&dummy
[12*REGISTER_SIZE
],
1359 deposit_21 (sr4export_addr
>> 11,
1360 extract_unsigned_integer (&dummy
[12*REGISTER_SIZE
],
1362 store_unsigned_integer
1363 (&dummy
[13*REGISTER_SIZE
],
1365 deposit_14 (sr4export_addr
& MASK_11
,
1366 extract_unsigned_integer (&dummy
[13*REGISTER_SIZE
],
1369 write_register (22, pc
);
1371 /* If we are in a syscall, then we should call the stack dummy
1372 directly. $$dyncall is not needed as the kernel sets up the
1373 space id registers properly based on the value in %r31. In
1374 fact calling $$dyncall will not work because the value in %r22
1375 will be clobbered on the syscall exit path. */
1379 return dyncall_addr
;
1383 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1386 target_read_pc (pid
)
1389 int flags
= read_register (FLAGS_REGNUM
);
1392 return read_register (31) & ~0x3;
1393 return read_register (PC_REGNUM
) & ~0x3;
1396 /* Write out the PC. If currently in a syscall, then also write the new
1397 PC value into %r31. */
1399 target_write_pc (v
, pid
)
1403 int flags
= read_register (FLAGS_REGNUM
);
1405 /* If in a syscall, then set %r31. Also make sure to get the
1406 privilege bits set correctly. */
1408 write_register (31, (long) (v
| 0x3));
1410 write_register (PC_REGNUM
, (long) v
);
1411 write_register (NPC_REGNUM
, (long) v
+ 4);
1414 /* return the alignment of a type in bytes. Structures have the maximum
1415 alignment required by their fields. */
1421 int max_align
, align
, i
;
1422 switch (TYPE_CODE (arg
))
1427 return TYPE_LENGTH (arg
);
1428 case TYPE_CODE_ARRAY
:
1429 return hppa_alignof (TYPE_FIELD_TYPE (arg
, 0));
1430 case TYPE_CODE_STRUCT
:
1431 case TYPE_CODE_UNION
:
1433 for (i
= 0; i
< TYPE_NFIELDS (arg
); i
++)
1435 /* Bit fields have no real alignment. */
1436 if (!TYPE_FIELD_BITPOS (arg
, i
))
1438 align
= hppa_alignof (TYPE_FIELD_TYPE (arg
, i
));
1439 max_align
= max (max_align
, align
);
1448 /* Print the register regnum, or all registers if regnum is -1 */
1450 pa_do_registers_info (regnum
, fpregs
)
1454 char raw_regs
[REGISTER_BYTES
];
1457 for (i
= 0; i
< NUM_REGS
; i
++)
1458 read_relative_register_raw_bytes (i
, raw_regs
+ REGISTER_BYTE (i
));
1460 pa_print_registers (raw_regs
, regnum
, fpregs
);
1461 else if (regnum
< FP0_REGNUM
)
1462 printf_unfiltered ("%s %x\n", reg_names
[regnum
], *(long *)(raw_regs
+
1463 REGISTER_BYTE (regnum
)));
1465 pa_print_fp_reg (regnum
);
1468 pa_print_registers (raw_regs
, regnum
, fpregs
)
1475 for (i
= 0; i
< 18; i
++)
1476 printf_unfiltered ("%8.8s: %8x %8.8s: %8x %8.8s: %8x %8.8s: %8x\n",
1478 *(int *)(raw_regs
+ REGISTER_BYTE (i
)),
1480 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 18)),
1482 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 36)),
1484 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 54)));
1487 for (i
= 72; i
< NUM_REGS
; i
++)
1488 pa_print_fp_reg (i
);
1494 unsigned char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1495 unsigned char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
1497 /* Get 32bits of data. */
1498 read_relative_register_raw_bytes (i
, raw_buffer
);
1500 /* Put it in the buffer. No conversions are ever necessary. */
1501 memcpy (virtual_buffer
, raw_buffer
, REGISTER_RAW_SIZE (i
));
1503 fputs_filtered (reg_names
[i
], gdb_stdout
);
1504 print_spaces_filtered (8 - strlen (reg_names
[i
]), gdb_stdout
);
1505 fputs_filtered ("(single precision) ", gdb_stdout
);
1507 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, gdb_stdout
, 0,
1508 1, 0, Val_pretty_default
);
1509 printf_filtered ("\n");
1511 /* If "i" is even, then this register can also be a double-precision
1512 FP register. Dump it out as such. */
1515 /* Get the data in raw format for the 2nd half. */
1516 read_relative_register_raw_bytes (i
+ 1, raw_buffer
);
1518 /* Copy it into the appropriate part of the virtual buffer. */
1519 memcpy (virtual_buffer
+ REGISTER_RAW_SIZE (i
), raw_buffer
,
1520 REGISTER_RAW_SIZE (i
));
1522 /* Dump it as a double. */
1523 fputs_filtered (reg_names
[i
], gdb_stdout
);
1524 print_spaces_filtered (8 - strlen (reg_names
[i
]), gdb_stdout
);
1525 fputs_filtered ("(double precision) ", gdb_stdout
);
1527 val_print (builtin_type_double
, virtual_buffer
, 0, gdb_stdout
, 0,
1528 1, 0, Val_pretty_default
);
1529 printf_filtered ("\n");
1533 /* Figure out if PC is in a trampoline, and if so find out where
1534 the trampoline will jump to. If not in a trampoline, return zero.
1536 Simple code examination probably is not a good idea since the code
1537 sequences in trampolines can also appear in user code.
1539 We use unwinds and information from the minimal symbol table to
1540 determine when we're in a trampoline. This won't work for ELF
1541 (yet) since it doesn't create stub unwind entries. Whether or
1542 not ELF will create stub unwinds or normal unwinds for linker
1543 stubs is still being debated.
1545 This should handle simple calls through dyncall or sr4export,
1546 long calls, argument relocation stubs, and dyncall/sr4export
1547 calling an argument relocation stub. It even handles some stubs
1548 used in dynamic executables. */
1551 skip_trampoline_code (pc
, name
)
1556 long prev_inst
, curr_inst
, loc
;
1557 static CORE_ADDR dyncall
= 0;
1558 static CORE_ADDR sr4export
= 0;
1559 struct minimal_symbol
*msym
;
1560 struct unwind_table_entry
*u
;
1562 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
1567 msym
= lookup_minimal_symbol ("$$dyncall", NULL
);
1569 dyncall
= SYMBOL_VALUE_ADDRESS (msym
);
1576 msym
= lookup_minimal_symbol ("_sr4export", NULL
);
1578 sr4export
= SYMBOL_VALUE_ADDRESS (msym
);
1583 /* Addresses passed to dyncall may *NOT* be the actual address
1584 of the funtion. So we may have to do something special. */
1587 pc
= (CORE_ADDR
) read_register (22);
1589 /* If bit 30 (counting from the left) is on, then pc is the address of
1590 the PLT entry for this function, not the address of the function
1591 itself. Bit 31 has meaning too, but only for MPE. */
1593 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, 4);
1595 else if (pc
== sr4export
)
1596 pc
= (CORE_ADDR
) (read_register (22));
1598 /* Get the unwind descriptor corresponding to PC, return zero
1599 if no unwind was found. */
1600 u
= find_unwind_entry (pc
);
1604 /* If this isn't a linker stub, then return now. */
1605 if (u
->stub_type
== 0)
1606 return orig_pc
== pc
? 0 : pc
& ~0x3;
1608 /* It's a stub. Search for a branch and figure out where it goes.
1609 Note we have to handle multi insn branch sequences like ldil;ble.
1610 Most (all?) other branches can be determined by examining the contents
1611 of certain registers and the stack. */
1617 /* Make sure we haven't walked outside the range of this stub. */
1618 if (u
!= find_unwind_entry (loc
))
1620 warning ("Unable to find branch in linker stub");
1621 return orig_pc
== pc
? 0 : pc
& ~0x3;
1624 prev_inst
= curr_inst
;
1625 curr_inst
= read_memory_integer (loc
, 4);
1627 /* Does it look like a branch external using %r1? Then it's the
1628 branch from the stub to the actual function. */
1629 if ((curr_inst
& 0xffe0e000) == 0xe0202000)
1631 /* Yup. See if the previous instruction loaded
1632 a value into %r1. If so compute and return the jump address. */
1633 if ((prev_inst
& 0xffe00000) == 0x20200000)
1634 return (extract_21 (prev_inst
) + extract_17 (curr_inst
)) & ~0x3;
1637 warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
1638 return orig_pc
== pc
? 0 : pc
& ~0x3;
1642 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
1643 branch from the stub to the actual function. */
1644 else if ((curr_inst
& 0xffe0e000) == 0xe8400000
1645 || (curr_inst
& 0xffe0e000) == 0xe8000000)
1646 return (loc
+ extract_17 (curr_inst
) + 8) & ~0x3;
1648 /* Does it look like bv (rp)? Note this depends on the
1649 current stack pointer being the same as the stack
1650 pointer in the stub itself! This is a branch on from the
1651 stub back to the original caller. */
1652 else if ((curr_inst
& 0xffe0e000) == 0xe840c000)
1654 /* Yup. See if the previous instruction loaded
1656 if (prev_inst
== 0x4bc23ff1)
1657 return (read_memory_integer
1658 (read_register (SP_REGNUM
) - 8, 4)) & ~0x3;
1661 warning ("Unable to find restore of %%rp before bv (%%rp).");
1662 return orig_pc
== pc
? 0 : pc
& ~0x3;
1666 /* What about be,n 0(sr0,%rp)? It's just another way we return to
1667 the original caller from the stub. Used in dynamic executables. */
1668 else if (curr_inst
== 0xe0400002)
1670 /* The value we jump to is sitting in sp - 24. But that's
1671 loaded several instructions before the be instruction.
1672 I guess we could check for the previous instruction being
1673 mtsp %r1,%sr0 if we want to do sanity checking. */
1674 return (read_memory_integer
1675 (read_register (SP_REGNUM
) - 24, 4)) & ~0x3;
1678 /* Haven't found the branch yet, but we're still in the stub.
1684 /* For the given instruction (INST), return any adjustment it makes
1685 to the stack pointer or zero for no adjustment.
1687 This only handles instructions commonly found in prologues. */
1690 prologue_inst_adjust_sp (inst
)
1693 /* This must persist across calls. */
1694 static int save_high21
;
1696 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1697 if ((inst
& 0xffffc000) == 0x37de0000)
1698 return extract_14 (inst
);
1701 if ((inst
& 0xffe00000) == 0x6fc00000)
1702 return extract_14 (inst
);
1704 /* addil high21,%r1; ldo low11,(%r1),%r30)
1705 save high bits in save_high21 for later use. */
1706 if ((inst
& 0xffe00000) == 0x28200000)
1708 save_high21
= extract_21 (inst
);
1712 if ((inst
& 0xffff0000) == 0x343e0000)
1713 return save_high21
+ extract_14 (inst
);
1715 /* fstws as used by the HP compilers. */
1716 if ((inst
& 0xffffffe0) == 0x2fd01220)
1717 return extract_5_load (inst
);
1719 /* No adjustment. */
1723 /* Return nonzero if INST is a branch of some kind, else return zero. */
1753 /* Return the register number for a GR which is saved by INST or
1754 zero it INST does not save a GR. */
1757 inst_saves_gr (inst
)
1760 /* Does it look like a stw? */
1761 if ((inst
>> 26) == 0x1a)
1762 return extract_5R_store (inst
);
1764 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1765 if ((inst
>> 26) == 0x1b)
1766 return extract_5R_store (inst
);
1768 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1770 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18)
1771 return extract_5R_store (inst
);
1776 /* Return the register number for a FR which is saved by INST or
1777 zero it INST does not save a FR.
1779 Note we only care about full 64bit register stores (that's the only
1780 kind of stores the prologue will use).
1782 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1785 inst_saves_fr (inst
)
1788 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1789 return extract_5r_store (inst
);
1793 /* Advance PC across any function entry prologue instructions
1794 to reach some "real" code.
1796 Use information in the unwind table to determine what exactly should
1797 be in the prologue. */
1804 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1805 unsigned long args_stored
, status
, i
;
1806 struct unwind_table_entry
*u
;
1808 u
= find_unwind_entry (pc
);
1812 /* If we are not at the beginning of a function, then return now. */
1813 if ((pc
& ~0x3) != u
->region_start
)
1816 /* This is how much of a frame adjustment we need to account for. */
1817 stack_remaining
= u
->Total_frame_size
<< 3;
1819 /* Magic register saves we want to know about. */
1820 save_rp
= u
->Save_RP
;
1821 save_sp
= u
->Save_SP
;
1823 /* An indication that args may be stored into the stack. Unfortunately
1824 the HPUX compilers tend to set this in cases where no args were
1826 args_stored
= u
->Args_stored
;
1828 /* Turn the Entry_GR field into a bitmask. */
1830 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1832 /* Frame pointer gets saved into a special location. */
1833 if (u
->Save_SP
&& i
== FP_REGNUM
)
1836 save_gr
|= (1 << i
);
1839 /* Turn the Entry_FR field into a bitmask too. */
1841 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1842 save_fr
|= (1 << i
);
1844 /* Loop until we find everything of interest or hit a branch.
1846 For unoptimized GCC code and for any HP CC code this will never ever
1847 examine any user instructions.
1849 For optimzied GCC code we're faced with problems. GCC will schedule
1850 its prologue and make prologue instructions available for delay slot
1851 filling. The end result is user code gets mixed in with the prologue
1852 and a prologue instruction may be in the delay slot of the first branch
1855 Some unexpected things are expected with debugging optimized code, so
1856 we allow this routine to walk past user instructions in optimized
1858 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1861 unsigned int reg_num
;
1862 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1863 unsigned long old_save_rp
, old_save_sp
, old_args_stored
, next_inst
;
1865 /* Save copies of all the triggers so we can compare them later
1867 old_save_gr
= save_gr
;
1868 old_save_fr
= save_fr
;
1869 old_save_rp
= save_rp
;
1870 old_save_sp
= save_sp
;
1871 old_stack_remaining
= stack_remaining
;
1873 status
= target_read_memory (pc
, buf
, 4);
1874 inst
= extract_unsigned_integer (buf
, 4);
1880 /* Note the interesting effects of this instruction. */
1881 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1883 /* There is only one instruction used for saving RP into the stack. */
1884 if (inst
== 0x6bc23fd9)
1887 /* This is the only way we save SP into the stack. At this time
1888 the HP compilers never bother to save SP into the stack. */
1889 if ((inst
& 0xffffc000) == 0x6fc10000)
1892 /* Account for general and floating-point register saves. */
1893 reg_num
= inst_saves_gr (inst
);
1894 save_gr
&= ~(1 << reg_num
);
1896 /* Ugh. Also account for argument stores into the stack.
1897 Unfortunately args_stored only tells us that some arguments
1898 where stored into the stack. Not how many or what kind!
1900 This is a kludge as on the HP compiler sets this bit and it
1901 never does prologue scheduling. So once we see one, skip past
1902 all of them. We have similar code for the fp arg stores below.
1904 FIXME. Can still die if we have a mix of GR and FR argument
1906 if (reg_num
>= 23 && reg_num
<= 26)
1908 while (reg_num
>= 23 && reg_num
<= 26)
1911 status
= target_read_memory (pc
, buf
, 4);
1912 inst
= extract_unsigned_integer (buf
, 4);
1915 reg_num
= inst_saves_gr (inst
);
1921 reg_num
= inst_saves_fr (inst
);
1922 save_fr
&= ~(1 << reg_num
);
1924 status
= target_read_memory (pc
+ 4, buf
, 4);
1925 next_inst
= extract_unsigned_integer (buf
, 4);
1931 /* We've got to be read to handle the ldo before the fp register
1933 if ((inst
& 0xfc000000) == 0x34000000
1934 && inst_saves_fr (next_inst
) >= 4
1935 && inst_saves_fr (next_inst
) <= 7)
1937 /* So we drop into the code below in a reasonable state. */
1938 reg_num
= inst_saves_fr (next_inst
);
1942 /* Ugh. Also account for argument stores into the stack.
1943 This is a kludge as on the HP compiler sets this bit and it
1944 never does prologue scheduling. So once we see one, skip past
1946 if (reg_num
>= 4 && reg_num
<= 7)
1948 while (reg_num
>= 4 && reg_num
<= 7)
1951 status
= target_read_memory (pc
, buf
, 4);
1952 inst
= extract_unsigned_integer (buf
, 4);
1955 if ((inst
& 0xfc000000) != 0x34000000)
1957 status
= target_read_memory (pc
+ 4, buf
, 4);
1958 next_inst
= extract_unsigned_integer (buf
, 4);
1961 reg_num
= inst_saves_fr (next_inst
);
1967 /* Quit if we hit any kind of branch. This can happen if a prologue
1968 instruction is in the delay slot of the first call/branch. */
1969 if (is_branch (inst
))
1972 /* What a crock. The HP compilers set args_stored even if no
1973 arguments were stored into the stack (boo hiss). This could
1974 cause this code to then skip a bunch of user insns (up to the
1977 To combat this we try to identify when args_stored was bogusly
1978 set and clear it. We only do this when args_stored is nonzero,
1979 all other resources are accounted for, and nothing changed on
1982 && ! (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1983 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1984 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1985 && old_stack_remaining
== stack_remaining
)
1995 /* Put here the code to store, into a struct frame_saved_regs,
1996 the addresses of the saved registers of frame described by FRAME_INFO.
1997 This includes special registers such as pc and fp saved in special
1998 ways in the stack frame. sp is even more special:
1999 the address we return for it IS the sp for the next frame. */
2002 hppa_frame_find_saved_regs (frame_info
, frame_saved_regs
)
2003 struct frame_info
*frame_info
;
2004 struct frame_saved_regs
*frame_saved_regs
;
2007 struct unwind_table_entry
*u
;
2008 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
2013 /* Zero out everything. */
2014 memset (frame_saved_regs
, '\0', sizeof (struct frame_saved_regs
));
2016 /* Call dummy frames always look the same, so there's no need to
2017 examine the dummy code to determine locations of saved registers;
2018 instead, let find_dummy_frame_regs fill in the correct offsets
2019 for the saved registers. */
2020 if ((frame_info
->pc
>= frame_info
->frame
2021 && frame_info
->pc
<= (frame_info
->frame
+ CALL_DUMMY_LENGTH
2022 + 32 * 4 + (NUM_REGS
- FP0_REGNUM
) * 8
2024 find_dummy_frame_regs (frame_info
, frame_saved_regs
);
2026 /* Interrupt handlers are special too. They lay out the register
2027 state in the exact same order as the register numbers in GDB. */
2028 if (pc_in_interrupt_handler (frame_info
->pc
))
2030 for (i
= 0; i
< NUM_REGS
; i
++)
2032 /* SP is a little special. */
2034 frame_saved_regs
->regs
[SP_REGNUM
]
2035 = read_memory_integer (frame_info
->frame
+ SP_REGNUM
* 4, 4);
2037 frame_saved_regs
->regs
[i
] = frame_info
->frame
+ i
* 4;
2042 /* Handle signal handler callers. */
2043 if (frame_info
->signal_handler_caller
)
2045 FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info
, frame_saved_regs
);
2049 /* Get the starting address of the function referred to by the PC
2050 saved in frame_info. */
2051 pc
= get_pc_function_start (frame_info
->pc
);
2054 u
= find_unwind_entry (pc
);
2058 /* This is how much of a frame adjustment we need to account for. */
2059 stack_remaining
= u
->Total_frame_size
<< 3;
2061 /* Magic register saves we want to know about. */
2062 save_rp
= u
->Save_RP
;
2063 save_sp
= u
->Save_SP
;
2065 /* Turn the Entry_GR field into a bitmask. */
2067 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
2069 /* Frame pointer gets saved into a special location. */
2070 if (u
->Save_SP
&& i
== FP_REGNUM
)
2073 save_gr
|= (1 << i
);
2076 /* Turn the Entry_FR field into a bitmask too. */
2078 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
2079 save_fr
|= (1 << i
);
2081 /* The frame always represents the value of %sp at entry to the
2082 current function (and is thus equivalent to the "saved" stack
2084 frame_saved_regs
->regs
[SP_REGNUM
] = frame_info
->frame
;
2086 /* Loop until we find everything of interest or hit a branch.
2088 For unoptimized GCC code and for any HP CC code this will never ever
2089 examine any user instructions.
2091 For optimzied GCC code we're faced with problems. GCC will schedule
2092 its prologue and make prologue instructions available for delay slot
2093 filling. The end result is user code gets mixed in with the prologue
2094 and a prologue instruction may be in the delay slot of the first branch
2097 Some unexpected things are expected with debugging optimized code, so
2098 we allow this routine to walk past user instructions in optimized
2100 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
2102 status
= target_read_memory (pc
, buf
, 4);
2103 inst
= extract_unsigned_integer (buf
, 4);
2109 /* Note the interesting effects of this instruction. */
2110 stack_remaining
-= prologue_inst_adjust_sp (inst
);
2112 /* There is only one instruction used for saving RP into the stack. */
2113 if (inst
== 0x6bc23fd9)
2116 frame_saved_regs
->regs
[RP_REGNUM
] = frame_info
->frame
- 20;
2119 /* Just note that we found the save of SP into the stack. The
2120 value for frame_saved_regs was computed above. */
2121 if ((inst
& 0xffffc000) == 0x6fc10000)
2124 /* Account for general and floating-point register saves. */
2125 reg
= inst_saves_gr (inst
);
2126 if (reg
>= 3 && reg
<= 18
2127 && (!u
->Save_SP
|| reg
!= FP_REGNUM
))
2129 save_gr
&= ~(1 << reg
);
2131 /* stwm with a positive displacement is a *post modify*. */
2132 if ((inst
>> 26) == 0x1b
2133 && extract_14 (inst
) >= 0)
2134 frame_saved_regs
->regs
[reg
] = frame_info
->frame
;
2137 /* Handle code with and without frame pointers. */
2139 frame_saved_regs
->regs
[reg
]
2140 = frame_info
->frame
+ extract_14 (inst
);
2142 frame_saved_regs
->regs
[reg
]
2143 = frame_info
->frame
+ (u
->Total_frame_size
<< 3)
2144 + extract_14 (inst
);
2149 /* GCC handles callee saved FP regs a little differently.
2151 It emits an instruction to put the value of the start of
2152 the FP store area into %r1. It then uses fstds,ma with
2153 a basereg of %r1 for the stores.
2155 HP CC emits them at the current stack pointer modifying
2156 the stack pointer as it stores each register. */
2158 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2159 if ((inst
& 0xffffc000) == 0x34610000
2160 || (inst
& 0xffffc000) == 0x37c10000)
2161 fp_loc
= extract_14 (inst
);
2163 reg
= inst_saves_fr (inst
);
2164 if (reg
>= 12 && reg
<= 21)
2166 /* Note +4 braindamage below is necessary because the FP status
2167 registers are internally 8 registers rather than the expected
2169 save_fr
&= ~(1 << reg
);
2172 /* 1st HP CC FP register store. After this instruction
2173 we've set enough state that the GCC and HPCC code are
2174 both handled in the same manner. */
2175 frame_saved_regs
->regs
[reg
+ FP4_REGNUM
+ 4] = frame_info
->frame
;
2180 frame_saved_regs
->regs
[reg
+ FP0_REGNUM
+ 4]
2181 = frame_info
->frame
+ fp_loc
;
2186 /* Quit if we hit any kind of branch. This can happen if a prologue
2187 instruction is in the delay slot of the first call/branch. */
2188 if (is_branch (inst
))
2196 #ifdef MAINTENANCE_CMDS
2199 unwind_command (exp
, from_tty
)
2207 struct unwind_table_entry
*u
;
2210 /* If we have an expression, evaluate it and use it as the address. */
2212 if (exp
!= 0 && *exp
!= 0)
2213 address
= parse_and_eval_address (exp
);
2217 xxx
.u
= find_unwind_entry (address
);
2221 printf_unfiltered ("Can't find unwind table entry for PC 0x%x\n", address
);
2225 printf_unfiltered ("%08x\n%08X\n%08X\n%08X\n", xxx
.foo
[0], xxx
.foo
[1], xxx
.foo
[2],
2228 #endif /* MAINTENANCE_CMDS */
2231 _initialize_hppa_tdep ()
2233 #ifdef MAINTENANCE_CMDS
2234 add_cmd ("unwind", class_maintenance
, unwind_command
,
2235 "Print unwind table entry at given address.",
2236 &maintenanceprintlist
);
2237 #endif /* MAINTENANCE_CMDS */