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 /* start-sanitize-hpread */
512 /* Return the adjustment necessary to make for addresses on the stack
513 as presented by hpread.c.
515 This is necessary because of the stack direction on the PA and the
516 bizarre way in which someone (?) decided they wanted to handle
517 frame pointerless code in GDB. */
519 hpread_adjust_stack_address (func_addr
)
522 struct unwind_table_entry
*u
;
524 u
= find_unwind_entry (func_addr
);
528 return u
->Total_frame_size
<< 3;
530 /* end-sanitize-hpread */
532 /* Called to determine if PC is in an interrupt handler of some
536 pc_in_interrupt_handler (pc
)
539 struct unwind_table_entry
*u
;
540 struct minimal_symbol
*msym_us
;
542 u
= find_unwind_entry (pc
);
546 /* Oh joys. HPUX sets the interrupt bit for _sigreturn even though
547 its frame isn't a pure interrupt frame. Deal with this. */
548 msym_us
= lookup_minimal_symbol_by_pc (pc
);
550 return u
->HP_UX_interrupt_marker
&& !IN_SIGTRAMP (pc
, SYMBOL_NAME (msym_us
));
553 /* Called when no unwind descriptor was found for PC. Returns 1 if it
554 appears that PC is in a linker stub. */
557 pc_in_linker_stub (pc
)
560 int found_magic_instruction
= 0;
564 /* If unable to read memory, assume pc is not in a linker stub. */
565 if (target_read_memory (pc
, buf
, 4) != 0)
568 /* We are looking for something like
570 ; $$dyncall jams RP into this special spot in the frame (RP')
571 ; before calling the "call stub"
574 ldsid (rp),r1 ; Get space associated with RP into r1
575 mtsp r1,sp ; Move it into space register 0
576 be,n 0(sr0),rp) ; back to your regularly scheduled program
579 /* Maximum known linker stub size is 4 instructions. Search forward
580 from the given PC, then backward. */
581 for (i
= 0; i
< 4; i
++)
583 /* If we hit something with an unwind, stop searching this direction. */
585 if (find_unwind_entry (pc
+ i
* 4) != 0)
588 /* Check for ldsid (rp),r1 which is the magic instruction for a
589 return from a cross-space function call. */
590 if (read_memory_integer (pc
+ i
* 4, 4) == 0x004010a1)
592 found_magic_instruction
= 1;
595 /* Add code to handle long call/branch and argument relocation stubs
599 if (found_magic_instruction
!= 0)
602 /* Now look backward. */
603 for (i
= 0; i
< 4; i
++)
605 /* If we hit something with an unwind, stop searching this direction. */
607 if (find_unwind_entry (pc
- i
* 4) != 0)
610 /* Check for ldsid (rp),r1 which is the magic instruction for a
611 return from a cross-space function call. */
612 if (read_memory_integer (pc
- i
* 4, 4) == 0x004010a1)
614 found_magic_instruction
= 1;
617 /* Add code to handle long call/branch and argument relocation stubs
620 return found_magic_instruction
;
624 find_return_regnum(pc
)
627 struct unwind_table_entry
*u
;
629 u
= find_unwind_entry (pc
);
640 /* Return size of frame, or -1 if we should use a frame pointer. */
642 find_proc_framesize (pc
)
645 struct unwind_table_entry
*u
;
646 struct minimal_symbol
*msym_us
;
648 u
= find_unwind_entry (pc
);
652 if (pc_in_linker_stub (pc
))
653 /* Linker stubs have a zero size frame. */
659 msym_us
= lookup_minimal_symbol_by_pc (pc
);
661 /* If Save_SP is set, and we're not in an interrupt or signal caller,
662 then we have a frame pointer. Use it. */
663 if (u
->Save_SP
&& !pc_in_interrupt_handler (pc
)
664 && !IN_SIGTRAMP (pc
, SYMBOL_NAME (msym_us
)))
667 return u
->Total_frame_size
<< 3;
670 /* Return offset from sp at which rp is saved, or 0 if not saved. */
671 static int rp_saved
PARAMS ((CORE_ADDR
));
677 struct unwind_table_entry
*u
;
679 u
= find_unwind_entry (pc
);
683 if (pc_in_linker_stub (pc
))
684 /* This is the so-called RP'. */
692 else if (u
->stub_type
!= 0)
694 switch (u
->stub_type
)
698 case PARAMETER_RELOCATION
:
709 frameless_function_invocation (frame
)
712 struct unwind_table_entry
*u
;
714 u
= find_unwind_entry (frame
->pc
);
719 return (u
->Total_frame_size
== 0 && u
->stub_type
== 0);
723 saved_pc_after_call (frame
)
728 struct unwind_table_entry
*u
;
730 ret_regnum
= find_return_regnum (get_frame_pc (frame
));
731 pc
= read_register (ret_regnum
) & ~0x3;
733 /* If PC is in a linker stub, then we need to dig the address
734 the stub will return to out of the stack. */
735 u
= find_unwind_entry (pc
);
736 if (u
&& u
->stub_type
!= 0)
737 return frame_saved_pc (frame
);
743 frame_saved_pc (frame
)
746 CORE_ADDR pc
= get_frame_pc (frame
);
747 struct unwind_table_entry
*u
;
749 /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
750 at the base of the frame in an interrupt handler. Registers within
751 are saved in the exact same order as GDB numbers registers. How
753 if (pc_in_interrupt_handler (pc
))
754 return read_memory_integer (frame
->frame
+ PC_REGNUM
* 4, 4) & ~0x3;
756 /* Deal with signal handler caller frames too. */
757 if (frame
->signal_handler_caller
)
760 FRAME_SAVED_PC_IN_SIGTRAMP (frame
, &rp
);
764 if (frameless_function_invocation (frame
))
768 ret_regnum
= find_return_regnum (pc
);
770 /* If the next frame is an interrupt frame or a signal
771 handler caller, then we need to look in the saved
772 register area to get the return pointer (the values
773 in the registers may not correspond to anything useful). */
775 && (frame
->next
->signal_handler_caller
776 || pc_in_interrupt_handler (frame
->next
->pc
)))
778 struct frame_info
*fi
;
779 struct frame_saved_regs saved_regs
;
781 fi
= get_frame_info (frame
->next
);
782 get_frame_saved_regs (fi
, &saved_regs
);
783 if (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
], 4) & 0x2)
784 pc
= read_memory_integer (saved_regs
.regs
[31], 4) & ~0x3;
786 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
], 4) & ~0x3;
789 pc
= read_register (ret_regnum
) & ~0x3;
796 rp_offset
= rp_saved (pc
);
797 /* Similar to code in frameless function case. If the next
798 frame is a signal or interrupt handler, then dig the right
799 information out of the saved register info. */
802 && (frame
->next
->signal_handler_caller
803 || pc_in_interrupt_handler (frame
->next
->pc
)))
805 struct frame_info
*fi
;
806 struct frame_saved_regs saved_regs
;
808 fi
= get_frame_info (frame
->next
);
809 get_frame_saved_regs (fi
, &saved_regs
);
810 if (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
], 4) & 0x2)
811 pc
= read_memory_integer (saved_regs
.regs
[31], 4) & ~0x3;
813 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
], 4) & ~0x3;
815 else if (rp_offset
== 0)
816 pc
= read_register (RP_REGNUM
) & ~0x3;
818 pc
= read_memory_integer (frame
->frame
+ rp_offset
, 4) & ~0x3;
821 /* If PC is inside a linker stub, then dig out the address the stub
823 u
= find_unwind_entry (pc
);
824 if (u
&& u
->stub_type
!= 0)
830 /* We need to correct the PC and the FP for the outermost frame when we are
834 init_extra_frame_info (fromleaf
, frame
)
836 struct frame_info
*frame
;
841 if (frame
->next
&& !fromleaf
)
844 /* If the next frame represents a frameless function invocation
845 then we have to do some adjustments that are normally done by
846 FRAME_CHAIN. (FRAME_CHAIN is not called in this case.) */
849 /* Find the framesize of *this* frame without peeking at the PC
850 in the current frame structure (it isn't set yet). */
851 framesize
= find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame
)));
853 /* Now adjust our base frame accordingly. If we have a frame pointer
854 use it, else subtract the size of this frame from the current
855 frame. (we always want frame->frame to point at the lowest address
858 frame
->frame
= read_register (FP_REGNUM
);
860 frame
->frame
-= framesize
;
864 flags
= read_register (FLAGS_REGNUM
);
865 if (flags
& 2) /* In system call? */
866 frame
->pc
= read_register (31) & ~0x3;
868 /* The outermost frame is always derived from PC-framesize
870 One might think frameless innermost frames should have
871 a frame->frame that is the same as the parent's frame->frame.
872 That is wrong; frame->frame in that case should be the *high*
873 address of the parent's frame. It's complicated as hell to
874 explain, but the parent *always* creates some stack space for
875 the child. So the child actually does have a frame of some
876 sorts, and its base is the high address in its parent's frame. */
877 framesize
= find_proc_framesize(frame
->pc
);
879 frame
->frame
= read_register (FP_REGNUM
);
881 frame
->frame
= read_register (SP_REGNUM
) - framesize
;
884 /* Given a GDB frame, determine the address of the calling function's frame.
885 This will be used to create a new GDB frame struct, and then
886 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
888 This may involve searching through prologues for several functions
889 at boundaries where GCC calls HP C code, or where code which has
890 a frame pointer calls code without a frame pointer. */
895 struct frame_info
*frame
;
897 int my_framesize
, caller_framesize
;
898 struct unwind_table_entry
*u
;
899 CORE_ADDR frame_base
;
901 /* Handle HPUX, BSD, and OSF1 style interrupt frames first. These
902 are easy; at *sp we have a full save state strucutre which we can
903 pull the old stack pointer from. Also see frame_saved_pc for
904 code to dig a saved PC out of the save state structure. */
905 if (pc_in_interrupt_handler (frame
->pc
))
906 frame_base
= read_memory_integer (frame
->frame
+ SP_REGNUM
* 4, 4);
907 else if (frame
->signal_handler_caller
)
909 FRAME_BASE_BEFORE_SIGTRAMP (frame
, &frame_base
);
912 frame_base
= frame
->frame
;
914 /* Get frame sizes for the current frame and the frame of the
916 my_framesize
= find_proc_framesize (frame
->pc
);
917 caller_framesize
= find_proc_framesize (FRAME_SAVED_PC(frame
));
919 /* If caller does not have a frame pointer, then its frame
920 can be found at current_frame - caller_framesize. */
921 if (caller_framesize
!= -1)
922 return frame_base
- caller_framesize
;
924 /* Both caller and callee have frame pointers and are GCC compiled
925 (SAVE_SP bit in unwind descriptor is on for both functions.
926 The previous frame pointer is found at the top of the current frame. */
927 if (caller_framesize
== -1 && my_framesize
== -1)
928 return read_memory_integer (frame_base
, 4);
930 /* Caller has a frame pointer, but callee does not. This is a little
931 more difficult as GCC and HP C lay out locals and callee register save
932 areas very differently.
934 The previous frame pointer could be in a register, or in one of
935 several areas on the stack.
937 Walk from the current frame to the innermost frame examining
938 unwind descriptors to determine if %r3 ever gets saved into the
939 stack. If so return whatever value got saved into the stack.
940 If it was never saved in the stack, then the value in %r3 is still
943 We use information from unwind descriptors to determine if %r3
944 is saved into the stack (Entry_GR field has this information). */
948 u
= find_unwind_entry (frame
->pc
);
952 /* We could find this information by examining prologues. I don't
953 think anyone has actually written any tools (not even "strip")
954 which leave them out of an executable, so maybe this is a moot
956 warning ("Unable to find unwind for PC 0x%x -- Help!", frame
->pc
);
960 /* Entry_GR specifies the number of callee-saved general registers
961 saved in the stack. It starts at %r3, so %r3 would be 1. */
962 if (u
->Entry_GR
>= 1 || u
->Save_SP
963 || frame
->signal_handler_caller
964 || pc_in_interrupt_handler (frame
->pc
))
972 /* We may have walked down the chain into a function with a frame
975 && !frame
->signal_handler_caller
976 && !pc_in_interrupt_handler (frame
->pc
))
977 return read_memory_integer (frame
->frame
, 4);
978 /* %r3 was saved somewhere in the stack. Dig it out. */
981 struct frame_info
*fi
;
982 struct frame_saved_regs saved_regs
;
984 fi
= get_frame_info (frame
);
985 get_frame_saved_regs (fi
, &saved_regs
);
986 return read_memory_integer (saved_regs
.regs
[FP_REGNUM
], 4);
991 /* The value in %r3 was never saved into the stack (thus %r3 still
992 holds the value of the previous frame pointer). */
993 return read_register (FP_REGNUM
);
998 /* To see if a frame chain is valid, see if the caller looks like it
999 was compiled with gcc. */
1002 frame_chain_valid (chain
, thisframe
)
1006 struct minimal_symbol
*msym_us
;
1007 struct minimal_symbol
*msym_start
;
1008 struct unwind_table_entry
*u
, *next_u
= NULL
;
1014 u
= find_unwind_entry (thisframe
->pc
);
1019 /* We can't just check that the same of msym_us is "_start", because
1020 someone idiotically decided that they were going to make a Ltext_end
1021 symbol with the same address. This Ltext_end symbol is totally
1022 indistinguishable (as nearly as I can tell) from the symbol for a function
1023 which is (legitimately, since it is in the user's namespace)
1024 named Ltext_end, so we can't just ignore it. */
1025 msym_us
= lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe
));
1026 msym_start
= lookup_minimal_symbol ("_start", NULL
);
1029 && SYMBOL_VALUE_ADDRESS (msym_us
) == SYMBOL_VALUE_ADDRESS (msym_start
))
1032 next
= get_next_frame (thisframe
);
1034 next_u
= find_unwind_entry (next
->pc
);
1036 /* If this frame does not save SP, has no stack, isn't a stub,
1037 and doesn't "call" an interrupt routine or signal handler caller,
1038 then its not valid. */
1039 if (u
->Save_SP
|| u
->Total_frame_size
|| u
->stub_type
!= 0
1040 || (thisframe
->next
&& thisframe
->next
->signal_handler_caller
)
1041 || (next_u
&& next_u
->HP_UX_interrupt_marker
))
1044 if (pc_in_linker_stub (thisframe
->pc
))
1051 * These functions deal with saving and restoring register state
1052 * around a function call in the inferior. They keep the stack
1053 * double-word aligned; eventually, on an hp700, the stack will have
1054 * to be aligned to a 64-byte boundary.
1060 register CORE_ADDR sp
;
1061 register int regnum
;
1065 /* Space for "arguments"; the RP goes in here. */
1066 sp
= read_register (SP_REGNUM
) + 48;
1067 int_buffer
= read_register (RP_REGNUM
) | 0x3;
1068 write_memory (sp
- 20, (char *)&int_buffer
, 4);
1070 int_buffer
= read_register (FP_REGNUM
);
1071 write_memory (sp
, (char *)&int_buffer
, 4);
1073 write_register (FP_REGNUM
, sp
);
1077 for (regnum
= 1; regnum
< 32; regnum
++)
1078 if (regnum
!= RP_REGNUM
&& regnum
!= FP_REGNUM
)
1079 sp
= push_word (sp
, read_register (regnum
));
1083 for (regnum
= FP0_REGNUM
; regnum
< NUM_REGS
; regnum
++)
1085 read_register_bytes (REGISTER_BYTE (regnum
), (char *)&freg_buffer
, 8);
1086 sp
= push_bytes (sp
, (char *)&freg_buffer
, 8);
1088 sp
= push_word (sp
, read_register (IPSW_REGNUM
));
1089 sp
= push_word (sp
, read_register (SAR_REGNUM
));
1090 sp
= push_word (sp
, read_register (PCOQ_HEAD_REGNUM
));
1091 sp
= push_word (sp
, read_register (PCSQ_HEAD_REGNUM
));
1092 sp
= push_word (sp
, read_register (PCOQ_TAIL_REGNUM
));
1093 sp
= push_word (sp
, read_register (PCSQ_TAIL_REGNUM
));
1094 write_register (SP_REGNUM
, sp
);
1097 find_dummy_frame_regs (frame
, frame_saved_regs
)
1098 struct frame_info
*frame
;
1099 struct frame_saved_regs
*frame_saved_regs
;
1101 CORE_ADDR fp
= frame
->frame
;
1104 frame_saved_regs
->regs
[RP_REGNUM
] = fp
- 20 & ~0x3;
1105 frame_saved_regs
->regs
[FP_REGNUM
] = fp
;
1106 frame_saved_regs
->regs
[1] = fp
+ 8;
1108 for (fp
+= 12, i
= 3; i
< 32; i
++)
1112 frame_saved_regs
->regs
[i
] = fp
;
1118 for (i
= FP0_REGNUM
; i
< NUM_REGS
; i
++, fp
+= 8)
1119 frame_saved_regs
->regs
[i
] = fp
;
1121 frame_saved_regs
->regs
[IPSW_REGNUM
] = fp
;
1122 frame_saved_regs
->regs
[SAR_REGNUM
] = fp
+ 4;
1123 frame_saved_regs
->regs
[PCOQ_HEAD_REGNUM
] = fp
+ 8;
1124 frame_saved_regs
->regs
[PCSQ_HEAD_REGNUM
] = fp
+ 12;
1125 frame_saved_regs
->regs
[PCOQ_TAIL_REGNUM
] = fp
+ 16;
1126 frame_saved_regs
->regs
[PCSQ_TAIL_REGNUM
] = fp
+ 20;
1132 register FRAME frame
= get_current_frame ();
1133 register CORE_ADDR fp
;
1134 register int regnum
;
1135 struct frame_saved_regs fsr
;
1136 struct frame_info
*fi
;
1139 fi
= get_frame_info (frame
);
1141 get_frame_saved_regs (fi
, &fsr
);
1143 #ifndef NO_PC_SPACE_QUEUE_RESTORE
1144 if (fsr
.regs
[IPSW_REGNUM
]) /* Restoring a call dummy frame */
1145 restore_pc_queue (&fsr
);
1148 for (regnum
= 31; regnum
> 0; regnum
--)
1149 if (fsr
.regs
[regnum
])
1150 write_register (regnum
, read_memory_integer (fsr
.regs
[regnum
], 4));
1152 for (regnum
= NUM_REGS
- 1; regnum
>= FP0_REGNUM
; regnum
--)
1153 if (fsr
.regs
[regnum
])
1155 read_memory (fsr
.regs
[regnum
], (char *)&freg_buffer
, 8);
1156 write_register_bytes (REGISTER_BYTE (regnum
), (char *)&freg_buffer
, 8);
1159 if (fsr
.regs
[IPSW_REGNUM
])
1160 write_register (IPSW_REGNUM
,
1161 read_memory_integer (fsr
.regs
[IPSW_REGNUM
], 4));
1163 if (fsr
.regs
[SAR_REGNUM
])
1164 write_register (SAR_REGNUM
,
1165 read_memory_integer (fsr
.regs
[SAR_REGNUM
], 4));
1167 /* If the PC was explicitly saved, then just restore it. */
1168 if (fsr
.regs
[PCOQ_TAIL_REGNUM
])
1169 write_register (PCOQ_TAIL_REGNUM
,
1170 read_memory_integer (fsr
.regs
[PCOQ_TAIL_REGNUM
], 4));
1172 /* Else use the value in %rp to set the new PC. */
1174 target_write_pc (read_register (RP_REGNUM
), 0);
1176 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
1178 if (fsr
.regs
[IPSW_REGNUM
]) /* call dummy */
1179 write_register (SP_REGNUM
, fp
- 48);
1181 write_register (SP_REGNUM
, fp
);
1183 flush_cached_frames ();
1187 * After returning to a dummy on the stack, restore the instruction
1188 * queue space registers. */
1191 restore_pc_queue (fsr
)
1192 struct frame_saved_regs
*fsr
;
1194 CORE_ADDR pc
= read_pc ();
1195 CORE_ADDR new_pc
= read_memory_integer (fsr
->regs
[PCOQ_HEAD_REGNUM
], 4);
1197 struct target_waitstatus w
;
1200 /* Advance past break instruction in the call dummy. */
1201 write_register (PCOQ_HEAD_REGNUM
, pc
+ 4);
1202 write_register (PCOQ_TAIL_REGNUM
, pc
+ 8);
1205 * HPUX doesn't let us set the space registers or the space
1206 * registers of the PC queue through ptrace. Boo, hiss.
1207 * Conveniently, the call dummy has this sequence of instructions
1212 * So, load up the registers and single step until we are in the
1216 write_register (21, read_memory_integer (fsr
->regs
[PCSQ_HEAD_REGNUM
], 4));
1217 write_register (22, new_pc
);
1219 for (insn_count
= 0; insn_count
< 3; insn_count
++)
1221 /* FIXME: What if the inferior gets a signal right now? Want to
1222 merge this into wait_for_inferior (as a special kind of
1223 watchpoint? By setting a breakpoint at the end? Is there
1224 any other choice? Is there *any* way to do this stuff with
1225 ptrace() or some equivalent?). */
1227 target_wait (inferior_pid
, &w
);
1229 if (w
.kind
== TARGET_WAITKIND_SIGNALLED
)
1231 stop_signal
= w
.value
.sig
;
1232 terminal_ours_for_output ();
1233 printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
1234 target_signal_to_name (stop_signal
),
1235 target_signal_to_string (stop_signal
));
1236 gdb_flush (gdb_stdout
);
1240 target_terminal_ours ();
1241 target_fetch_registers (-1);
1246 hppa_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
1251 CORE_ADDR struct_addr
;
1253 /* array of arguments' offsets */
1254 int *offset
= (int *)alloca(nargs
* sizeof (int));
1258 for (i
= 0; i
< nargs
; i
++)
1260 /* Coerce chars to int & float to double if necessary */
1261 args
[i
] = value_arg_coerce (args
[i
]);
1263 cum
+= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1265 /* value must go at proper alignment. Assume alignment is a
1267 alignment
= hppa_alignof (VALUE_TYPE (args
[i
]));
1268 if (cum
% alignment
)
1269 cum
= (cum
+ alignment
) & -alignment
;
1272 sp
+= max ((cum
+ 7) & -8, 16);
1274 for (i
= 0; i
< nargs
; i
++)
1275 write_memory (sp
+ offset
[i
], VALUE_CONTENTS (args
[i
]),
1276 TYPE_LENGTH (VALUE_TYPE (args
[i
])));
1279 write_register (28, struct_addr
);
1284 * Insert the specified number of args and function address
1285 * into a call sequence of the above form stored at DUMMYNAME.
1287 * On the hppa we need to call the stack dummy through $$dyncall.
1288 * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
1289 * real_pc, which is the location where gdb should start up the
1290 * inferior to do the function call.
1294 hppa_fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)
1303 CORE_ADDR dyncall_addr
, sr4export_addr
;
1304 struct minimal_symbol
*msymbol
;
1305 int flags
= read_register (FLAGS_REGNUM
);
1306 struct unwind_table_entry
*u
;
1308 msymbol
= lookup_minimal_symbol ("$$dyncall", (struct objfile
*) NULL
);
1309 if (msymbol
== NULL
)
1310 error ("Can't find an address for $$dyncall trampoline");
1312 dyncall_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1314 /* FUN could be a procedure label, in which case we have to get
1315 its real address and the value of its GOT/DP. */
1318 /* Get the GOT/DP value for the target function. It's
1319 at *(fun+4). Note the call dummy is *NOT* allowed to
1320 trash %r19 before calling the target function. */
1321 write_register (19, read_memory_integer ((fun
& ~0x3) + 4, 4));
1323 /* Now get the real address for the function we are calling, it's
1325 fun
= (CORE_ADDR
) read_memory_integer (fun
& ~0x3, 4);
1328 /* If we are calling an import stub (eg calling into a dynamic library)
1329 then have sr4export call the magic __d_plt_call routine which is linked
1330 in from end.o. (You can't use _sr4export to call the import stub as
1331 the value in sp-24 will get fried and you end up returning to the
1332 wrong location. You can't call the import stub directly as the code
1333 to bind the PLT entry to a function can't return to a stack address.) */
1334 u
= find_unwind_entry (fun
);
1335 if (u
&& u
->stub_type
== IMPORT
)
1338 msymbol
= lookup_minimal_symbol ("__d_plt_call", (struct objfile
*) NULL
);
1339 if (msymbol
== NULL
)
1340 error ("Can't find an address for __d_plt_call trampoline");
1342 /* This is where sr4export will jump to. */
1343 new_fun
= SYMBOL_VALUE_ADDRESS (msymbol
);
1345 /* We have to store the address of the stub in __shlib_funcptr. */
1346 msymbol
= lookup_minimal_symbol ("__shlib_funcptr",
1347 (struct objfile
*)NULL
);
1348 if (msymbol
== NULL
)
1349 error ("Can't find an address for __shlib_funcptr");
1351 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol
), (char *)&fun
, 4);
1356 /* We still need sr4export's address too. */
1357 msymbol
= lookup_minimal_symbol ("_sr4export", (struct objfile
*) NULL
);
1358 if (msymbol
== NULL
)
1359 error ("Can't find an address for _sr4export trampoline");
1361 sr4export_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1363 store_unsigned_integer
1364 (&dummy
[9*REGISTER_SIZE
],
1366 deposit_21 (fun
>> 11,
1367 extract_unsigned_integer (&dummy
[9*REGISTER_SIZE
],
1369 store_unsigned_integer
1370 (&dummy
[10*REGISTER_SIZE
],
1372 deposit_14 (fun
& MASK_11
,
1373 extract_unsigned_integer (&dummy
[10*REGISTER_SIZE
],
1375 store_unsigned_integer
1376 (&dummy
[12*REGISTER_SIZE
],
1378 deposit_21 (sr4export_addr
>> 11,
1379 extract_unsigned_integer (&dummy
[12*REGISTER_SIZE
],
1381 store_unsigned_integer
1382 (&dummy
[13*REGISTER_SIZE
],
1384 deposit_14 (sr4export_addr
& MASK_11
,
1385 extract_unsigned_integer (&dummy
[13*REGISTER_SIZE
],
1388 write_register (22, pc
);
1390 /* If we are in a syscall, then we should call the stack dummy
1391 directly. $$dyncall is not needed as the kernel sets up the
1392 space id registers properly based on the value in %r31. In
1393 fact calling $$dyncall will not work because the value in %r22
1394 will be clobbered on the syscall exit path. */
1398 return dyncall_addr
;
1402 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1405 target_read_pc (pid
)
1408 int flags
= read_register (FLAGS_REGNUM
);
1411 return read_register (31) & ~0x3;
1412 return read_register (PC_REGNUM
) & ~0x3;
1415 /* Write out the PC. If currently in a syscall, then also write the new
1416 PC value into %r31. */
1418 target_write_pc (v
, pid
)
1422 int flags
= read_register (FLAGS_REGNUM
);
1424 /* If in a syscall, then set %r31. Also make sure to get the
1425 privilege bits set correctly. */
1427 write_register (31, (long) (v
| 0x3));
1429 write_register (PC_REGNUM
, (long) v
);
1430 write_register (NPC_REGNUM
, (long) v
+ 4);
1433 /* return the alignment of a type in bytes. Structures have the maximum
1434 alignment required by their fields. */
1440 int max_align
, align
, i
;
1441 switch (TYPE_CODE (arg
))
1446 return TYPE_LENGTH (arg
);
1447 case TYPE_CODE_ARRAY
:
1448 return hppa_alignof (TYPE_FIELD_TYPE (arg
, 0));
1449 case TYPE_CODE_STRUCT
:
1450 case TYPE_CODE_UNION
:
1452 for (i
= 0; i
< TYPE_NFIELDS (arg
); i
++)
1454 /* Bit fields have no real alignment. */
1455 if (!TYPE_FIELD_BITPOS (arg
, i
))
1457 align
= hppa_alignof (TYPE_FIELD_TYPE (arg
, i
));
1458 max_align
= max (max_align
, align
);
1467 /* Print the register regnum, or all registers if regnum is -1 */
1469 pa_do_registers_info (regnum
, fpregs
)
1473 char raw_regs
[REGISTER_BYTES
];
1476 for (i
= 0; i
< NUM_REGS
; i
++)
1477 read_relative_register_raw_bytes (i
, raw_regs
+ REGISTER_BYTE (i
));
1479 pa_print_registers (raw_regs
, regnum
, fpregs
);
1480 else if (regnum
< FP0_REGNUM
)
1481 printf_unfiltered ("%s %x\n", reg_names
[regnum
], *(long *)(raw_regs
+
1482 REGISTER_BYTE (regnum
)));
1484 pa_print_fp_reg (regnum
);
1487 pa_print_registers (raw_regs
, regnum
, fpregs
)
1494 for (i
= 0; i
< 18; i
++)
1495 printf_unfiltered ("%8.8s: %8x %8.8s: %8x %8.8s: %8x %8.8s: %8x\n",
1497 *(int *)(raw_regs
+ REGISTER_BYTE (i
)),
1499 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 18)),
1501 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 36)),
1503 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 54)));
1506 for (i
= 72; i
< NUM_REGS
; i
++)
1507 pa_print_fp_reg (i
);
1513 unsigned char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1514 unsigned char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
1516 /* Get 32bits of data. */
1517 read_relative_register_raw_bytes (i
, raw_buffer
);
1519 /* Put it in the buffer. No conversions are ever necessary. */
1520 memcpy (virtual_buffer
, raw_buffer
, REGISTER_RAW_SIZE (i
));
1522 fputs_filtered (reg_names
[i
], gdb_stdout
);
1523 print_spaces_filtered (8 - strlen (reg_names
[i
]), gdb_stdout
);
1524 fputs_filtered ("(single precision) ", gdb_stdout
);
1526 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, gdb_stdout
, 0,
1527 1, 0, Val_pretty_default
);
1528 printf_filtered ("\n");
1530 /* If "i" is even, then this register can also be a double-precision
1531 FP register. Dump it out as such. */
1534 /* Get the data in raw format for the 2nd half. */
1535 read_relative_register_raw_bytes (i
+ 1, raw_buffer
);
1537 /* Copy it into the appropriate part of the virtual buffer. */
1538 memcpy (virtual_buffer
+ REGISTER_RAW_SIZE (i
), raw_buffer
,
1539 REGISTER_RAW_SIZE (i
));
1541 /* Dump it as a double. */
1542 fputs_filtered (reg_names
[i
], gdb_stdout
);
1543 print_spaces_filtered (8 - strlen (reg_names
[i
]), gdb_stdout
);
1544 fputs_filtered ("(double precision) ", gdb_stdout
);
1546 val_print (builtin_type_double
, virtual_buffer
, 0, gdb_stdout
, 0,
1547 1, 0, Val_pretty_default
);
1548 printf_filtered ("\n");
1552 /* Figure out if PC is in a trampoline, and if so find out where
1553 the trampoline will jump to. If not in a trampoline, return zero.
1555 Simple code examination probably is not a good idea since the code
1556 sequences in trampolines can also appear in user code.
1558 We use unwinds and information from the minimal symbol table to
1559 determine when we're in a trampoline. This won't work for ELF
1560 (yet) since it doesn't create stub unwind entries. Whether or
1561 not ELF will create stub unwinds or normal unwinds for linker
1562 stubs is still being debated.
1564 This should handle simple calls through dyncall or sr4export,
1565 long calls, argument relocation stubs, and dyncall/sr4export
1566 calling an argument relocation stub. It even handles some stubs
1567 used in dynamic executables. */
1570 skip_trampoline_code (pc
, name
)
1575 long prev_inst
, curr_inst
, loc
;
1576 static CORE_ADDR dyncall
= 0;
1577 static CORE_ADDR sr4export
= 0;
1578 struct minimal_symbol
*msym
;
1579 struct unwind_table_entry
*u
;
1581 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
1586 msym
= lookup_minimal_symbol ("$$dyncall", NULL
);
1588 dyncall
= SYMBOL_VALUE_ADDRESS (msym
);
1595 msym
= lookup_minimal_symbol ("_sr4export", NULL
);
1597 sr4export
= SYMBOL_VALUE_ADDRESS (msym
);
1602 /* Addresses passed to dyncall may *NOT* be the actual address
1603 of the funtion. So we may have to do something special. */
1606 pc
= (CORE_ADDR
) read_register (22);
1608 /* If bit 30 (counting from the left) is on, then pc is the address of
1609 the PLT entry for this function, not the address of the function
1610 itself. Bit 31 has meaning too, but only for MPE. */
1612 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, 4);
1614 else if (pc
== sr4export
)
1615 pc
= (CORE_ADDR
) (read_register (22));
1617 /* Get the unwind descriptor corresponding to PC, return zero
1618 if no unwind was found. */
1619 u
= find_unwind_entry (pc
);
1623 /* If this isn't a linker stub, then return now. */
1624 if (u
->stub_type
== 0)
1625 return orig_pc
== pc
? 0 : pc
& ~0x3;
1627 /* It's a stub. Search for a branch and figure out where it goes.
1628 Note we have to handle multi insn branch sequences like ldil;ble.
1629 Most (all?) other branches can be determined by examining the contents
1630 of certain registers and the stack. */
1636 /* Make sure we haven't walked outside the range of this stub. */
1637 if (u
!= find_unwind_entry (loc
))
1639 warning ("Unable to find branch in linker stub");
1640 return orig_pc
== pc
? 0 : pc
& ~0x3;
1643 prev_inst
= curr_inst
;
1644 curr_inst
= read_memory_integer (loc
, 4);
1646 /* Does it look like a branch external using %r1? Then it's the
1647 branch from the stub to the actual function. */
1648 if ((curr_inst
& 0xffe0e000) == 0xe0202000)
1650 /* Yup. See if the previous instruction loaded
1651 a value into %r1. If so compute and return the jump address. */
1652 if ((prev_inst
& 0xffe00000) == 0x20200000)
1653 return (extract_21 (prev_inst
) + extract_17 (curr_inst
)) & ~0x3;
1656 warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
1657 return orig_pc
== pc
? 0 : pc
& ~0x3;
1661 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
1662 branch from the stub to the actual function. */
1663 else if ((curr_inst
& 0xffe0e000) == 0xe8400000
1664 || (curr_inst
& 0xffe0e000) == 0xe8000000)
1665 return (loc
+ extract_17 (curr_inst
) + 8) & ~0x3;
1667 /* Does it look like bv (rp)? Note this depends on the
1668 current stack pointer being the same as the stack
1669 pointer in the stub itself! This is a branch on from the
1670 stub back to the original caller. */
1671 else if ((curr_inst
& 0xffe0e000) == 0xe840c000)
1673 /* Yup. See if the previous instruction loaded
1675 if (prev_inst
== 0x4bc23ff1)
1676 return (read_memory_integer
1677 (read_register (SP_REGNUM
) - 8, 4)) & ~0x3;
1680 warning ("Unable to find restore of %%rp before bv (%%rp).");
1681 return orig_pc
== pc
? 0 : pc
& ~0x3;
1685 /* What about be,n 0(sr0,%rp)? It's just another way we return to
1686 the original caller from the stub. Used in dynamic executables. */
1687 else if (curr_inst
== 0xe0400002)
1689 /* The value we jump to is sitting in sp - 24. But that's
1690 loaded several instructions before the be instruction.
1691 I guess we could check for the previous instruction being
1692 mtsp %r1,%sr0 if we want to do sanity checking. */
1693 return (read_memory_integer
1694 (read_register (SP_REGNUM
) - 24, 4)) & ~0x3;
1697 /* Haven't found the branch yet, but we're still in the stub.
1703 /* For the given instruction (INST), return any adjustment it makes
1704 to the stack pointer or zero for no adjustment.
1706 This only handles instructions commonly found in prologues. */
1709 prologue_inst_adjust_sp (inst
)
1712 /* This must persist across calls. */
1713 static int save_high21
;
1715 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1716 if ((inst
& 0xffffc000) == 0x37de0000)
1717 return extract_14 (inst
);
1720 if ((inst
& 0xffe00000) == 0x6fc00000)
1721 return extract_14 (inst
);
1723 /* addil high21,%r1; ldo low11,(%r1),%r30)
1724 save high bits in save_high21 for later use. */
1725 if ((inst
& 0xffe00000) == 0x28200000)
1727 save_high21
= extract_21 (inst
);
1731 if ((inst
& 0xffff0000) == 0x343e0000)
1732 return save_high21
+ extract_14 (inst
);
1734 /* fstws as used by the HP compilers. */
1735 if ((inst
& 0xffffffe0) == 0x2fd01220)
1736 return extract_5_load (inst
);
1738 /* No adjustment. */
1742 /* Return nonzero if INST is a branch of some kind, else return zero. */
1772 /* Return the register number for a GR which is saved by INST or
1773 zero it INST does not save a GR. */
1776 inst_saves_gr (inst
)
1779 /* Does it look like a stw? */
1780 if ((inst
>> 26) == 0x1a)
1781 return extract_5R_store (inst
);
1783 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1784 if ((inst
>> 26) == 0x1b)
1785 return extract_5R_store (inst
);
1787 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1789 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18)
1790 return extract_5R_store (inst
);
1795 /* Return the register number for a FR which is saved by INST or
1796 zero it INST does not save a FR.
1798 Note we only care about full 64bit register stores (that's the only
1799 kind of stores the prologue will use).
1801 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1804 inst_saves_fr (inst
)
1807 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1808 return extract_5r_store (inst
);
1812 /* Advance PC across any function entry prologue instructions
1813 to reach some "real" code.
1815 Use information in the unwind table to determine what exactly should
1816 be in the prologue. */
1823 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1824 unsigned long args_stored
, status
, i
;
1825 struct unwind_table_entry
*u
;
1827 u
= find_unwind_entry (pc
);
1831 /* If we are not at the beginning of a function, then return now. */
1832 if ((pc
& ~0x3) != u
->region_start
)
1835 /* This is how much of a frame adjustment we need to account for. */
1836 stack_remaining
= u
->Total_frame_size
<< 3;
1838 /* Magic register saves we want to know about. */
1839 save_rp
= u
->Save_RP
;
1840 save_sp
= u
->Save_SP
;
1842 /* An indication that args may be stored into the stack. Unfortunately
1843 the HPUX compilers tend to set this in cases where no args were
1845 args_stored
= u
->Args_stored
;
1847 /* Turn the Entry_GR field into a bitmask. */
1849 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1851 /* Frame pointer gets saved into a special location. */
1852 if (u
->Save_SP
&& i
== FP_REGNUM
)
1855 save_gr
|= (1 << i
);
1858 /* Turn the Entry_FR field into a bitmask too. */
1860 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1861 save_fr
|= (1 << i
);
1863 /* Loop until we find everything of interest or hit a branch.
1865 For unoptimized GCC code and for any HP CC code this will never ever
1866 examine any user instructions.
1868 For optimzied GCC code we're faced with problems. GCC will schedule
1869 its prologue and make prologue instructions available for delay slot
1870 filling. The end result is user code gets mixed in with the prologue
1871 and a prologue instruction may be in the delay slot of the first branch
1874 Some unexpected things are expected with debugging optimized code, so
1875 we allow this routine to walk past user instructions in optimized
1877 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1880 unsigned int reg_num
;
1881 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1882 unsigned long old_save_rp
, old_save_sp
, old_args_stored
, next_inst
;
1884 /* Save copies of all the triggers so we can compare them later
1886 old_save_gr
= save_gr
;
1887 old_save_fr
= save_fr
;
1888 old_save_rp
= save_rp
;
1889 old_save_sp
= save_sp
;
1890 old_stack_remaining
= stack_remaining
;
1892 status
= target_read_memory (pc
, buf
, 4);
1893 inst
= extract_unsigned_integer (buf
, 4);
1899 /* Note the interesting effects of this instruction. */
1900 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1902 /* There is only one instruction used for saving RP into the stack. */
1903 if (inst
== 0x6bc23fd9)
1906 /* This is the only way we save SP into the stack. At this time
1907 the HP compilers never bother to save SP into the stack. */
1908 if ((inst
& 0xffffc000) == 0x6fc10000)
1911 /* Account for general and floating-point register saves. */
1912 reg_num
= inst_saves_gr (inst
);
1913 save_gr
&= ~(1 << reg_num
);
1915 /* Ugh. Also account for argument stores into the stack.
1916 Unfortunately args_stored only tells us that some arguments
1917 where stored into the stack. Not how many or what kind!
1919 This is a kludge as on the HP compiler sets this bit and it
1920 never does prologue scheduling. So once we see one, skip past
1921 all of them. We have similar code for the fp arg stores below.
1923 FIXME. Can still die if we have a mix of GR and FR argument
1925 if (reg_num
>= 23 && reg_num
<= 26)
1927 while (reg_num
>= 23 && reg_num
<= 26)
1930 status
= target_read_memory (pc
, buf
, 4);
1931 inst
= extract_unsigned_integer (buf
, 4);
1934 reg_num
= inst_saves_gr (inst
);
1940 reg_num
= inst_saves_fr (inst
);
1941 save_fr
&= ~(1 << reg_num
);
1943 status
= target_read_memory (pc
+ 4, buf
, 4);
1944 next_inst
= extract_unsigned_integer (buf
, 4);
1950 /* We've got to be read to handle the ldo before the fp register
1952 if ((inst
& 0xfc000000) == 0x34000000
1953 && inst_saves_fr (next_inst
) >= 4
1954 && inst_saves_fr (next_inst
) <= 7)
1956 /* So we drop into the code below in a reasonable state. */
1957 reg_num
= inst_saves_fr (next_inst
);
1961 /* Ugh. Also account for argument stores into the stack.
1962 This is a kludge as on the HP compiler sets this bit and it
1963 never does prologue scheduling. So once we see one, skip past
1965 if (reg_num
>= 4 && reg_num
<= 7)
1967 while (reg_num
>= 4 && reg_num
<= 7)
1970 status
= target_read_memory (pc
, buf
, 4);
1971 inst
= extract_unsigned_integer (buf
, 4);
1974 if ((inst
& 0xfc000000) != 0x34000000)
1976 status
= target_read_memory (pc
+ 4, buf
, 4);
1977 next_inst
= extract_unsigned_integer (buf
, 4);
1980 reg_num
= inst_saves_fr (next_inst
);
1986 /* Quit if we hit any kind of branch. This can happen if a prologue
1987 instruction is in the delay slot of the first call/branch. */
1988 if (is_branch (inst
))
1991 /* What a crock. The HP compilers set args_stored even if no
1992 arguments were stored into the stack (boo hiss). This could
1993 cause this code to then skip a bunch of user insns (up to the
1996 To combat this we try to identify when args_stored was bogusly
1997 set and clear it. We only do this when args_stored is nonzero,
1998 all other resources are accounted for, and nothing changed on
2001 && ! (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
2002 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
2003 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
2004 && old_stack_remaining
== stack_remaining
)
2014 /* Put here the code to store, into a struct frame_saved_regs,
2015 the addresses of the saved registers of frame described by FRAME_INFO.
2016 This includes special registers such as pc and fp saved in special
2017 ways in the stack frame. sp is even more special:
2018 the address we return for it IS the sp for the next frame. */
2021 hppa_frame_find_saved_regs (frame_info
, frame_saved_regs
)
2022 struct frame_info
*frame_info
;
2023 struct frame_saved_regs
*frame_saved_regs
;
2026 struct unwind_table_entry
*u
;
2027 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
2032 /* Zero out everything. */
2033 memset (frame_saved_regs
, '\0', sizeof (struct frame_saved_regs
));
2035 /* Call dummy frames always look the same, so there's no need to
2036 examine the dummy code to determine locations of saved registers;
2037 instead, let find_dummy_frame_regs fill in the correct offsets
2038 for the saved registers. */
2039 if ((frame_info
->pc
>= frame_info
->frame
2040 && frame_info
->pc
<= (frame_info
->frame
+ CALL_DUMMY_LENGTH
2041 + 32 * 4 + (NUM_REGS
- FP0_REGNUM
) * 8
2043 find_dummy_frame_regs (frame_info
, frame_saved_regs
);
2045 /* Interrupt handlers are special too. They lay out the register
2046 state in the exact same order as the register numbers in GDB. */
2047 if (pc_in_interrupt_handler (frame_info
->pc
))
2049 for (i
= 0; i
< NUM_REGS
; i
++)
2051 /* SP is a little special. */
2053 frame_saved_regs
->regs
[SP_REGNUM
]
2054 = read_memory_integer (frame_info
->frame
+ SP_REGNUM
* 4, 4);
2056 frame_saved_regs
->regs
[i
] = frame_info
->frame
+ i
* 4;
2061 /* Handle signal handler callers. */
2062 if (frame_info
->signal_handler_caller
)
2064 FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info
, frame_saved_regs
);
2068 /* Get the starting address of the function referred to by the PC
2069 saved in frame_info. */
2070 pc
= get_pc_function_start (frame_info
->pc
);
2073 u
= find_unwind_entry (pc
);
2077 /* This is how much of a frame adjustment we need to account for. */
2078 stack_remaining
= u
->Total_frame_size
<< 3;
2080 /* Magic register saves we want to know about. */
2081 save_rp
= u
->Save_RP
;
2082 save_sp
= u
->Save_SP
;
2084 /* Turn the Entry_GR field into a bitmask. */
2086 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
2088 /* Frame pointer gets saved into a special location. */
2089 if (u
->Save_SP
&& i
== FP_REGNUM
)
2092 save_gr
|= (1 << i
);
2095 /* Turn the Entry_FR field into a bitmask too. */
2097 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
2098 save_fr
|= (1 << i
);
2100 /* The frame always represents the value of %sp at entry to the
2101 current function (and is thus equivalent to the "saved" stack
2103 frame_saved_regs
->regs
[SP_REGNUM
] = frame_info
->frame
;
2105 /* Loop until we find everything of interest or hit a branch.
2107 For unoptimized GCC code and for any HP CC code this will never ever
2108 examine any user instructions.
2110 For optimzied GCC code we're faced with problems. GCC will schedule
2111 its prologue and make prologue instructions available for delay slot
2112 filling. The end result is user code gets mixed in with the prologue
2113 and a prologue instruction may be in the delay slot of the first branch
2116 Some unexpected things are expected with debugging optimized code, so
2117 we allow this routine to walk past user instructions in optimized
2119 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
2121 status
= target_read_memory (pc
, buf
, 4);
2122 inst
= extract_unsigned_integer (buf
, 4);
2128 /* Note the interesting effects of this instruction. */
2129 stack_remaining
-= prologue_inst_adjust_sp (inst
);
2131 /* There is only one instruction used for saving RP into the stack. */
2132 if (inst
== 0x6bc23fd9)
2135 frame_saved_regs
->regs
[RP_REGNUM
] = frame_info
->frame
- 20;
2138 /* Just note that we found the save of SP into the stack. The
2139 value for frame_saved_regs was computed above. */
2140 if ((inst
& 0xffffc000) == 0x6fc10000)
2143 /* Account for general and floating-point register saves. */
2144 reg
= inst_saves_gr (inst
);
2145 if (reg
>= 3 && reg
<= 18
2146 && (!u
->Save_SP
|| reg
!= FP_REGNUM
))
2148 save_gr
&= ~(1 << reg
);
2150 /* stwm with a positive displacement is a *post modify*. */
2151 if ((inst
>> 26) == 0x1b
2152 && extract_14 (inst
) >= 0)
2153 frame_saved_regs
->regs
[reg
] = frame_info
->frame
;
2156 /* Handle code with and without frame pointers. */
2158 frame_saved_regs
->regs
[reg
]
2159 = frame_info
->frame
+ extract_14 (inst
);
2161 frame_saved_regs
->regs
[reg
]
2162 = frame_info
->frame
+ (u
->Total_frame_size
<< 3)
2163 + extract_14 (inst
);
2168 /* GCC handles callee saved FP regs a little differently.
2170 It emits an instruction to put the value of the start of
2171 the FP store area into %r1. It then uses fstds,ma with
2172 a basereg of %r1 for the stores.
2174 HP CC emits them at the current stack pointer modifying
2175 the stack pointer as it stores each register. */
2177 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2178 if ((inst
& 0xffffc000) == 0x34610000
2179 || (inst
& 0xffffc000) == 0x37c10000)
2180 fp_loc
= extract_14 (inst
);
2182 reg
= inst_saves_fr (inst
);
2183 if (reg
>= 12 && reg
<= 21)
2185 /* Note +4 braindamage below is necessary because the FP status
2186 registers are internally 8 registers rather than the expected
2188 save_fr
&= ~(1 << reg
);
2191 /* 1st HP CC FP register store. After this instruction
2192 we've set enough state that the GCC and HPCC code are
2193 both handled in the same manner. */
2194 frame_saved_regs
->regs
[reg
+ FP4_REGNUM
+ 4] = frame_info
->frame
;
2199 frame_saved_regs
->regs
[reg
+ FP0_REGNUM
+ 4]
2200 = frame_info
->frame
+ fp_loc
;
2205 /* Quit if we hit any kind of branch. This can happen if a prologue
2206 instruction is in the delay slot of the first call/branch. */
2207 if (is_branch (inst
))
2215 #ifdef MAINTENANCE_CMDS
2218 unwind_command (exp
, from_tty
)
2226 struct unwind_table_entry
*u
;
2229 /* If we have an expression, evaluate it and use it as the address. */
2231 if (exp
!= 0 && *exp
!= 0)
2232 address
= parse_and_eval_address (exp
);
2236 xxx
.u
= find_unwind_entry (address
);
2240 printf_unfiltered ("Can't find unwind table entry for PC 0x%x\n", address
);
2244 printf_unfiltered ("%08x\n%08X\n%08X\n%08X\n", xxx
.foo
[0], xxx
.foo
[1], xxx
.foo
[2],
2247 #endif /* MAINTENANCE_CMDS */
2250 _initialize_hppa_tdep ()
2252 #ifdef MAINTENANCE_CMDS
2253 add_cmd ("unwind", class_maintenance
, unwind_command
,
2254 "Print unwind table entry at given address.",
2255 &maintenanceprintlist
);
2256 #endif /* MAINTENANCE_CMDS */