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>
40 #ifdef COFF_ENCAPSULATE
41 #include "a.out.encap.h"
45 #define N_SET_MAGIC(exec, val) ((exec).a_magic = (val))
48 /*#include <sys/user.h> After a.out.h */
59 static int restore_pc_queue
PARAMS ((struct frame_saved_regs
*fsr
));
60 static int hppa_alignof
PARAMS ((struct type
*arg
));
61 CORE_ADDR frame_saved_pc
PARAMS ((FRAME frame
));
62 static int prologue_inst_adjust_sp
PARAMS ((unsigned long));
63 static int is_branch
PARAMS ((unsigned long));
64 static int inst_saves_gr
PARAMS ((unsigned long));
65 static int inst_saves_fr
PARAMS ((unsigned long));
66 static int pc_in_interrupt_handler
PARAMS ((CORE_ADDR
));
67 static int pc_in_linker_stub
PARAMS ((CORE_ADDR
));
68 static int compare_unwind_entries
PARAMS ((const struct unwind_table_entry
*,
69 const struct unwind_table_entry
*));
70 static void read_unwind_info
PARAMS ((struct objfile
*));
71 static void internalize_unwinds
PARAMS ((struct objfile
*,
72 struct unwind_table_entry
*,
73 asection
*, unsigned int,
77 /* Routines to extract various sized constants out of hppa
80 /* This assumes that no garbage lies outside of the lower bits of
84 sign_extend (val
, bits
)
87 return (int)(val
>> bits
- 1 ? (-1 << bits
) | val
: val
);
90 /* For many immediate values the sign bit is the low bit! */
93 low_sign_extend (val
, bits
)
96 return (int)((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
98 /* extract the immediate field from a ld{bhw}s instruction */
101 get_field (val
, from
, to
)
102 unsigned val
, from
, to
;
104 val
= val
>> 31 - to
;
105 return val
& ((1 << 32 - from
) - 1);
109 set_field (val
, from
, to
, new_val
)
110 unsigned *val
, from
, to
;
112 unsigned mask
= ~((1 << (to
- from
+ 1)) << (31 - from
));
113 return *val
= *val
& mask
| (new_val
<< (31 - from
));
116 /* extract a 3-bit space register number from a be, ble, mtsp or mfsp */
121 return GET_FIELD (word
, 18, 18) << 2 | GET_FIELD (word
, 16, 17);
124 extract_5_load (word
)
127 return low_sign_extend (word
>> 16 & MASK_5
, 5);
130 /* extract the immediate field from a st{bhw}s instruction */
133 extract_5_store (word
)
136 return low_sign_extend (word
& MASK_5
, 5);
139 /* extract the immediate field from a break instruction */
142 extract_5r_store (word
)
145 return (word
& MASK_5
);
148 /* extract the immediate field from a {sr}sm instruction */
151 extract_5R_store (word
)
154 return (word
>> 16 & MASK_5
);
157 /* extract an 11 bit immediate field */
163 return low_sign_extend (word
& MASK_11
, 11);
166 /* extract a 14 bit immediate field */
172 return low_sign_extend (word
& MASK_14
, 14);
175 /* deposit a 14 bit constant in a word */
178 deposit_14 (opnd
, word
)
182 unsigned sign
= (opnd
< 0 ? 1 : 0);
184 return word
| ((unsigned)opnd
<< 1 & MASK_14
) | sign
;
187 /* extract a 21 bit constant */
197 val
= GET_FIELD (word
, 20, 20);
199 val
|= GET_FIELD (word
, 9, 19);
201 val
|= GET_FIELD (word
, 5, 6);
203 val
|= GET_FIELD (word
, 0, 4);
205 val
|= GET_FIELD (word
, 7, 8);
206 return sign_extend (val
, 21) << 11;
209 /* deposit a 21 bit constant in a word. Although 21 bit constants are
210 usually the top 21 bits of a 32 bit constant, we assume that only
211 the low 21 bits of opnd are relevant */
214 deposit_21 (opnd
, word
)
219 val
|= GET_FIELD (opnd
, 11 + 14, 11 + 18);
221 val
|= GET_FIELD (opnd
, 11 + 12, 11 + 13);
223 val
|= GET_FIELD (opnd
, 11 + 19, 11 + 20);
225 val
|= GET_FIELD (opnd
, 11 + 1, 11 + 11);
227 val
|= GET_FIELD (opnd
, 11 + 0, 11 + 0);
231 /* extract a 12 bit constant from branch instructions */
237 return sign_extend (GET_FIELD (word
, 19, 28) |
238 GET_FIELD (word
, 29, 29) << 10 |
239 (word
& 0x1) << 11, 12) << 2;
242 /* extract a 17 bit constant from branch instructions, returning the
243 19 bit signed value. */
249 return sign_extend (GET_FIELD (word
, 19, 28) |
250 GET_FIELD (word
, 29, 29) << 10 |
251 GET_FIELD (word
, 11, 15) << 11 |
252 (word
& 0x1) << 16, 17) << 2;
256 /* Compare the start address for two unwind entries returning 1 if
257 the first address is larger than the second, -1 if the second is
258 larger than the first, and zero if they are equal. */
261 compare_unwind_entries (a
, b
)
262 const struct unwind_table_entry
*a
;
263 const struct unwind_table_entry
*b
;
265 if (a
->region_start
> b
->region_start
)
267 else if (a
->region_start
< b
->region_start
)
274 internalize_unwinds (objfile
, table
, section
, entries
, size
)
275 struct objfile
*objfile
;
276 struct unwind_table_entry
*table
;
278 unsigned int entries
, size
;
280 /* We will read the unwind entries into temporary memory, then
281 fill in the actual unwind table. */
286 char *buf
= alloca (size
);
288 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
290 /* Now internalize the information being careful to handle host/target
292 for (i
= 0; i
< entries
; i
++)
294 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
297 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*)buf
);
299 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*)buf
);
301 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;;
302 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
303 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
304 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
305 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
306 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
307 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
308 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
309 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
310 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
311 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
312 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12 ) & 0x1;
313 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
314 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
315 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
316 table
[i
].reserved2
= (tmp
>> 5) & 0xf;
317 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
318 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
319 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
320 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
321 table
[i
].Cleanup_defined
= tmp
& 0x1;
322 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*)buf
);
324 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
325 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
326 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
327 table
[i
].reserved4
= (tmp
>> 27) & 0x3;
328 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
333 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
334 the object file. This info is used mainly by find_unwind_entry() to find
335 out the stack frame size and frame pointer used by procedures. We put
336 everything on the psymbol obstack in the objfile so that it automatically
337 gets freed when the objfile is destroyed. */
340 read_unwind_info (objfile
)
341 struct objfile
*objfile
;
343 asection
*unwind_sec
, *elf_unwind_sec
, *stub_unwind_sec
;
344 unsigned unwind_size
, elf_unwind_size
, stub_unwind_size
, total_size
;
345 unsigned index
, unwind_entries
, elf_unwind_entries
;
346 unsigned stub_entries
, total_entries
;
347 struct obj_unwind_info
*ui
;
349 ui
= obstack_alloc (&objfile
->psymbol_obstack
,
350 sizeof (struct obj_unwind_info
));
356 /* Get hooks to all unwind sections. Note there is no linker-stub unwind
357 section in ELF at the moment. */
358 unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_START$");
359 elf_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, ".PARISC.unwind");
360 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
362 /* Get sizes and unwind counts for all sections. */
365 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
366 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
376 elf_unwind_size
= bfd_section_size (objfile
->obfd
, elf_unwind_sec
);
377 elf_unwind_entries
= elf_unwind_size
/ UNWIND_ENTRY_SIZE
;
382 elf_unwind_entries
= 0;
387 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
388 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
392 stub_unwind_size
= 0;
396 /* Compute total number of unwind entries and their total size. */
397 total_entries
= unwind_entries
+ elf_unwind_entries
+ stub_entries
;
398 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
400 /* Allocate memory for the unwind table. */
401 ui
->table
= obstack_alloc (&objfile
->psymbol_obstack
, total_size
);
402 ui
->last
= total_entries
- 1;
404 /* Internalize the standard unwind entries. */
406 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
407 unwind_entries
, unwind_size
);
408 index
+= unwind_entries
;
409 internalize_unwinds (objfile
, &ui
->table
[index
], elf_unwind_sec
,
410 elf_unwind_entries
, elf_unwind_size
);
411 index
+= elf_unwind_entries
;
413 /* Now internalize the stub unwind entries. */
414 if (stub_unwind_size
> 0)
417 char *buf
= alloca (stub_unwind_size
);
419 /* Read in the stub unwind entries. */
420 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
421 0, stub_unwind_size
);
423 /* Now convert them into regular unwind entries. */
424 for (i
= 0; i
< stub_entries
; i
++, index
++)
426 /* Clear out the next unwind entry. */
427 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
429 /* Convert offset & size into region_start and region_end.
430 Stuff away the stub type into "reserved" fields. */
431 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
434 ui
->table
[index
].stub_type
= bfd_get_8 (objfile
->obfd
,
437 ui
->table
[index
].region_end
438 = ui
->table
[index
].region_start
+ 4 *
439 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
445 /* Unwind table needs to be kept sorted. */
446 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
447 compare_unwind_entries
);
449 /* Keep a pointer to the unwind information. */
450 objfile
->obj_private
= (PTR
) ui
;
453 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
454 of the objfiles seeking the unwind table entry for this PC. Each objfile
455 contains a sorted list of struct unwind_table_entry. Since we do a binary
456 search of the unwind tables, we depend upon them to be sorted. */
458 static struct unwind_table_entry
*
459 find_unwind_entry(pc
)
462 int first
, middle
, last
;
463 struct objfile
*objfile
;
465 ALL_OBJFILES (objfile
)
467 struct obj_unwind_info
*ui
;
469 ui
= OBJ_UNWIND_INFO (objfile
);
473 read_unwind_info (objfile
);
474 ui
= OBJ_UNWIND_INFO (objfile
);
477 /* First, check the cache */
480 && pc
>= ui
->cache
->region_start
481 && pc
<= ui
->cache
->region_end
)
484 /* Not in the cache, do a binary search */
489 while (first
<= last
)
491 middle
= (first
+ last
) / 2;
492 if (pc
>= ui
->table
[middle
].region_start
493 && pc
<= ui
->table
[middle
].region_end
)
495 ui
->cache
= &ui
->table
[middle
];
496 return &ui
->table
[middle
];
499 if (pc
< ui
->table
[middle
].region_start
)
504 } /* ALL_OBJFILES() */
508 /* start-sanitize-hpread */
509 /* Return the adjustment necessary to make for addresses on the stack
510 as presented by hpread.c.
512 This is necessary because of the stack direction on the PA and the
513 bizarre way in which someone (?) decided they wanted to handle
514 frame pointerless code in GDB. */
516 hpread_adjust_stack_address (func_addr
)
519 struct unwind_table_entry
*u
;
521 u
= find_unwind_entry (func_addr
);
525 return u
->Total_frame_size
<< 3;
527 /* end-sanitize-hpread */
529 /* Called to determine if PC is in an interrupt handler of some
533 pc_in_interrupt_handler (pc
)
536 struct unwind_table_entry
*u
;
537 struct minimal_symbol
*msym_us
;
539 u
= find_unwind_entry (pc
);
543 /* Oh joys. HPUX sets the interrupt bit for _sigreturn even though
544 its frame isn't a pure interrupt frame. Deal with this. */
545 msym_us
= lookup_minimal_symbol_by_pc (pc
);
547 return u
->HP_UX_interrupt_marker
&& !IN_SIGTRAMP (pc
, SYMBOL_NAME (msym_us
));
550 /* Called when no unwind descriptor was found for PC. Returns 1 if it
551 appears that PC is in a linker stub. */
554 pc_in_linker_stub (pc
)
557 int found_magic_instruction
= 0;
561 /* If unable to read memory, assume pc is not in a linker stub. */
562 if (target_read_memory (pc
, buf
, 4) != 0)
565 /* We are looking for something like
567 ; $$dyncall jams RP into this special spot in the frame (RP')
568 ; before calling the "call stub"
571 ldsid (rp),r1 ; Get space associated with RP into r1
572 mtsp r1,sp ; Move it into space register 0
573 be,n 0(sr0),rp) ; back to your regularly scheduled program
576 /* Maximum known linker stub size is 4 instructions. Search forward
577 from the given PC, then backward. */
578 for (i
= 0; i
< 4; i
++)
580 /* If we hit something with an unwind, stop searching this direction. */
582 if (find_unwind_entry (pc
+ i
* 4) != 0)
585 /* Check for ldsid (rp),r1 which is the magic instruction for a
586 return from a cross-space function call. */
587 if (read_memory_integer (pc
+ i
* 4, 4) == 0x004010a1)
589 found_magic_instruction
= 1;
592 /* Add code to handle long call/branch and argument relocation stubs
596 if (found_magic_instruction
!= 0)
599 /* Now look backward. */
600 for (i
= 0; i
< 4; i
++)
602 /* If we hit something with an unwind, stop searching this direction. */
604 if (find_unwind_entry (pc
- i
* 4) != 0)
607 /* Check for ldsid (rp),r1 which is the magic instruction for a
608 return from a cross-space function call. */
609 if (read_memory_integer (pc
- i
* 4, 4) == 0x004010a1)
611 found_magic_instruction
= 1;
614 /* Add code to handle long call/branch and argument relocation stubs
617 return found_magic_instruction
;
621 find_return_regnum(pc
)
624 struct unwind_table_entry
*u
;
626 u
= find_unwind_entry (pc
);
637 /* Return size of frame, or -1 if we should use a frame pointer. */
639 find_proc_framesize (pc
)
642 struct unwind_table_entry
*u
;
643 struct minimal_symbol
*msym_us
;
645 u
= find_unwind_entry (pc
);
649 if (pc_in_linker_stub (pc
))
650 /* Linker stubs have a zero size frame. */
656 msym_us
= lookup_minimal_symbol_by_pc (pc
);
658 /* If Save_SP is set, and we're not in an interrupt or signal caller,
659 then we have a frame pointer. Use it. */
660 if (u
->Save_SP
&& !pc_in_interrupt_handler (pc
)
661 && !IN_SIGTRAMP (pc
, SYMBOL_NAME (msym_us
)))
664 return u
->Total_frame_size
<< 3;
667 /* Return offset from sp at which rp is saved, or 0 if not saved. */
668 static int rp_saved
PARAMS ((CORE_ADDR
));
674 struct unwind_table_entry
*u
;
676 u
= find_unwind_entry (pc
);
680 if (pc_in_linker_stub (pc
))
681 /* This is the so-called RP'. */
689 else if (u
->stub_type
!= 0)
691 switch (u
->stub_type
)
695 case PARAMETER_RELOCATION
:
706 frameless_function_invocation (frame
)
709 struct unwind_table_entry
*u
;
711 u
= find_unwind_entry (frame
->pc
);
716 return (u
->Total_frame_size
== 0 && u
->stub_type
== 0);
720 saved_pc_after_call (frame
)
725 struct unwind_table_entry
*u
;
727 ret_regnum
= find_return_regnum (get_frame_pc (frame
));
728 pc
= read_register (ret_regnum
) & ~0x3;
730 /* If PC is in a linker stub, then we need to dig the address
731 the stub will return to out of the stack. */
732 u
= find_unwind_entry (pc
);
733 if (u
&& u
->stub_type
!= 0)
734 return frame_saved_pc (frame
);
740 frame_saved_pc (frame
)
743 CORE_ADDR pc
= get_frame_pc (frame
);
744 struct unwind_table_entry
*u
;
746 /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
747 at the base of the frame in an interrupt handler. Registers within
748 are saved in the exact same order as GDB numbers registers. How
750 if (pc_in_interrupt_handler (pc
))
751 return read_memory_integer (frame
->frame
+ PC_REGNUM
* 4, 4) & ~0x3;
753 /* Deal with signal handler caller frames too. */
754 if (frame
->signal_handler_caller
)
757 FRAME_SAVED_PC_IN_SIGTRAMP (frame
, &rp
);
761 if (frameless_function_invocation (frame
))
765 ret_regnum
= find_return_regnum (pc
);
767 /* If the next frame is an interrupt frame or a signal
768 handler caller, then we need to look in the saved
769 register area to get the return pointer (the values
770 in the registers may not correspond to anything useful). */
772 && (frame
->next
->signal_handler_caller
773 || pc_in_interrupt_handler (frame
->next
->pc
)))
775 struct frame_info
*fi
;
776 struct frame_saved_regs saved_regs
;
778 fi
= get_frame_info (frame
->next
);
779 get_frame_saved_regs (fi
, &saved_regs
);
780 if (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
], 4) & 0x2)
781 pc
= read_memory_integer (saved_regs
.regs
[31], 4) & ~0x3;
783 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
], 4) & ~0x3;
786 pc
= read_register (ret_regnum
) & ~0x3;
793 rp_offset
= rp_saved (pc
);
794 /* Similar to code in frameless function case. If the next
795 frame is a signal or interrupt handler, then dig the right
796 information out of the saved register info. */
799 && (frame
->next
->signal_handler_caller
800 || pc_in_interrupt_handler (frame
->next
->pc
)))
802 struct frame_info
*fi
;
803 struct frame_saved_regs saved_regs
;
805 fi
= get_frame_info (frame
->next
);
806 get_frame_saved_regs (fi
, &saved_regs
);
807 if (read_memory_integer (saved_regs
.regs
[FLAGS_REGNUM
], 4) & 0x2)
808 pc
= read_memory_integer (saved_regs
.regs
[31], 4) & ~0x3;
810 pc
= read_memory_integer (saved_regs
.regs
[RP_REGNUM
], 4) & ~0x3;
812 else if (rp_offset
== 0)
813 pc
= read_register (RP_REGNUM
) & ~0x3;
815 pc
= read_memory_integer (frame
->frame
+ rp_offset
, 4) & ~0x3;
818 /* If PC is inside a linker stub, then dig out the address the stub
820 u
= find_unwind_entry (pc
);
821 if (u
&& u
->stub_type
!= 0)
827 /* We need to correct the PC and the FP for the outermost frame when we are
831 init_extra_frame_info (fromleaf
, frame
)
833 struct frame_info
*frame
;
838 if (frame
->next
&& !fromleaf
)
841 /* If the next frame represents a frameless function invocation
842 then we have to do some adjustments that are normally done by
843 FRAME_CHAIN. (FRAME_CHAIN is not called in this case.) */
846 /* Find the framesize of *this* frame without peeking at the PC
847 in the current frame structure (it isn't set yet). */
848 framesize
= find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame
)));
850 /* Now adjust our base frame accordingly. If we have a frame pointer
851 use it, else subtract the size of this frame from the current
852 frame. (we always want frame->frame to point at the lowest address
855 frame
->frame
= read_register (FP_REGNUM
);
857 frame
->frame
-= framesize
;
861 flags
= read_register (FLAGS_REGNUM
);
862 if (flags
& 2) /* In system call? */
863 frame
->pc
= read_register (31) & ~0x3;
865 /* The outermost frame is always derived from PC-framesize
867 One might think frameless innermost frames should have
868 a frame->frame that is the same as the parent's frame->frame.
869 That is wrong; frame->frame in that case should be the *high*
870 address of the parent's frame. It's complicated as hell to
871 explain, but the parent *always* creates some stack space for
872 the child. So the child actually does have a frame of some
873 sorts, and its base is the high address in its parent's frame. */
874 framesize
= find_proc_framesize(frame
->pc
);
876 frame
->frame
= read_register (FP_REGNUM
);
878 frame
->frame
= read_register (SP_REGNUM
) - framesize
;
881 /* Given a GDB frame, determine the address of the calling function's frame.
882 This will be used to create a new GDB frame struct, and then
883 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
885 This may involve searching through prologues for several functions
886 at boundaries where GCC calls HP C code, or where code which has
887 a frame pointer calls code without a frame pointer. */
892 struct frame_info
*frame
;
894 int my_framesize
, caller_framesize
;
895 struct unwind_table_entry
*u
;
896 CORE_ADDR frame_base
;
898 /* Handle HPUX, BSD, and OSF1 style interrupt frames first. These
899 are easy; at *sp we have a full save state strucutre which we can
900 pull the old stack pointer from. Also see frame_saved_pc for
901 code to dig a saved PC out of the save state structure. */
902 if (pc_in_interrupt_handler (frame
->pc
))
903 frame_base
= read_memory_integer (frame
->frame
+ SP_REGNUM
* 4, 4);
904 else if (frame
->signal_handler_caller
)
906 FRAME_BASE_BEFORE_SIGTRAMP (frame
, &frame_base
);
909 frame_base
= frame
->frame
;
911 /* Get frame sizes for the current frame and the frame of the
913 my_framesize
= find_proc_framesize (frame
->pc
);
914 caller_framesize
= find_proc_framesize (FRAME_SAVED_PC(frame
));
916 /* If caller does not have a frame pointer, then its frame
917 can be found at current_frame - caller_framesize. */
918 if (caller_framesize
!= -1)
919 return frame_base
- caller_framesize
;
921 /* Both caller and callee have frame pointers and are GCC compiled
922 (SAVE_SP bit in unwind descriptor is on for both functions.
923 The previous frame pointer is found at the top of the current frame. */
924 if (caller_framesize
== -1 && my_framesize
== -1)
925 return read_memory_integer (frame_base
, 4);
927 /* Caller has a frame pointer, but callee does not. This is a little
928 more difficult as GCC and HP C lay out locals and callee register save
929 areas very differently.
931 The previous frame pointer could be in a register, or in one of
932 several areas on the stack.
934 Walk from the current frame to the innermost frame examining
935 unwind descriptors to determine if %r3 ever gets saved into the
936 stack. If so return whatever value got saved into the stack.
937 If it was never saved in the stack, then the value in %r3 is still
940 We use information from unwind descriptors to determine if %r3
941 is saved into the stack (Entry_GR field has this information). */
945 u
= find_unwind_entry (frame
->pc
);
949 /* We could find this information by examining prologues. I don't
950 think anyone has actually written any tools (not even "strip")
951 which leave them out of an executable, so maybe this is a moot
953 warning ("Unable to find unwind for PC 0x%x -- Help!", frame
->pc
);
957 /* Entry_GR specifies the number of callee-saved general registers
958 saved in the stack. It starts at %r3, so %r3 would be 1. */
959 if (u
->Entry_GR
>= 1 || u
->Save_SP
960 || frame
->signal_handler_caller
961 || pc_in_interrupt_handler (frame
->pc
))
969 /* We may have walked down the chain into a function with a frame
972 && !frame
->signal_handler_caller
973 && !pc_in_interrupt_handler (frame
->pc
))
974 return read_memory_integer (frame
->frame
, 4);
975 /* %r3 was saved somewhere in the stack. Dig it out. */
978 struct frame_info
*fi
;
979 struct frame_saved_regs saved_regs
;
981 fi
= get_frame_info (frame
);
982 get_frame_saved_regs (fi
, &saved_regs
);
983 return read_memory_integer (saved_regs
.regs
[FP_REGNUM
], 4);
988 /* The value in %r3 was never saved into the stack (thus %r3 still
989 holds the value of the previous frame pointer). */
990 return read_register (FP_REGNUM
);
995 /* To see if a frame chain is valid, see if the caller looks like it
996 was compiled with gcc. */
999 frame_chain_valid (chain
, thisframe
)
1003 struct minimal_symbol
*msym_us
;
1004 struct minimal_symbol
*msym_start
;
1005 struct unwind_table_entry
*u
, *next_u
= NULL
;
1011 u
= find_unwind_entry (thisframe
->pc
);
1016 /* We can't just check that the same of msym_us is "_start", because
1017 someone idiotically decided that they were going to make a Ltext_end
1018 symbol with the same address. This Ltext_end symbol is totally
1019 indistinguishable (as nearly as I can tell) from the symbol for a function
1020 which is (legitimately, since it is in the user's namespace)
1021 named Ltext_end, so we can't just ignore it. */
1022 msym_us
= lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe
));
1023 msym_start
= lookup_minimal_symbol ("_start", NULL
);
1026 && SYMBOL_VALUE_ADDRESS (msym_us
) == SYMBOL_VALUE_ADDRESS (msym_start
))
1029 next
= get_next_frame (thisframe
);
1031 next_u
= find_unwind_entry (next
->pc
);
1033 /* If this frame does not save SP, has no stack, isn't a stub,
1034 and doesn't "call" an interrupt routine or signal handler caller,
1035 then its not valid. */
1036 if (u
->Save_SP
|| u
->Total_frame_size
|| u
->stub_type
!= 0
1037 || (thisframe
->next
&& thisframe
->next
->signal_handler_caller
)
1038 || (next_u
&& next_u
->HP_UX_interrupt_marker
))
1041 if (pc_in_linker_stub (thisframe
->pc
))
1048 * These functions deal with saving and restoring register state
1049 * around a function call in the inferior. They keep the stack
1050 * double-word aligned; eventually, on an hp700, the stack will have
1051 * to be aligned to a 64-byte boundary.
1057 register CORE_ADDR sp
;
1058 register int regnum
;
1062 /* Space for "arguments"; the RP goes in here. */
1063 sp
= read_register (SP_REGNUM
) + 48;
1064 int_buffer
= read_register (RP_REGNUM
) | 0x3;
1065 write_memory (sp
- 20, (char *)&int_buffer
, 4);
1067 int_buffer
= read_register (FP_REGNUM
);
1068 write_memory (sp
, (char *)&int_buffer
, 4);
1070 write_register (FP_REGNUM
, sp
);
1074 for (regnum
= 1; regnum
< 32; regnum
++)
1075 if (regnum
!= RP_REGNUM
&& regnum
!= FP_REGNUM
)
1076 sp
= push_word (sp
, read_register (regnum
));
1080 for (regnum
= FP0_REGNUM
; regnum
< NUM_REGS
; regnum
++)
1082 read_register_bytes (REGISTER_BYTE (regnum
), (char *)&freg_buffer
, 8);
1083 sp
= push_bytes (sp
, (char *)&freg_buffer
, 8);
1085 sp
= push_word (sp
, read_register (IPSW_REGNUM
));
1086 sp
= push_word (sp
, read_register (SAR_REGNUM
));
1087 sp
= push_word (sp
, read_register (PCOQ_HEAD_REGNUM
));
1088 sp
= push_word (sp
, read_register (PCSQ_HEAD_REGNUM
));
1089 sp
= push_word (sp
, read_register (PCOQ_TAIL_REGNUM
));
1090 sp
= push_word (sp
, read_register (PCSQ_TAIL_REGNUM
));
1091 write_register (SP_REGNUM
, sp
);
1094 find_dummy_frame_regs (frame
, frame_saved_regs
)
1095 struct frame_info
*frame
;
1096 struct frame_saved_regs
*frame_saved_regs
;
1098 CORE_ADDR fp
= frame
->frame
;
1101 frame_saved_regs
->regs
[RP_REGNUM
] = fp
- 20 & ~0x3;
1102 frame_saved_regs
->regs
[FP_REGNUM
] = fp
;
1103 frame_saved_regs
->regs
[1] = fp
+ 8;
1105 for (fp
+= 12, i
= 3; i
< 32; i
++)
1109 frame_saved_regs
->regs
[i
] = fp
;
1115 for (i
= FP0_REGNUM
; i
< NUM_REGS
; i
++, fp
+= 8)
1116 frame_saved_regs
->regs
[i
] = fp
;
1118 frame_saved_regs
->regs
[IPSW_REGNUM
] = fp
;
1119 frame_saved_regs
->regs
[SAR_REGNUM
] = fp
+ 4;
1120 frame_saved_regs
->regs
[PCOQ_HEAD_REGNUM
] = fp
+ 8;
1121 frame_saved_regs
->regs
[PCSQ_HEAD_REGNUM
] = fp
+ 12;
1122 frame_saved_regs
->regs
[PCOQ_TAIL_REGNUM
] = fp
+ 16;
1123 frame_saved_regs
->regs
[PCSQ_TAIL_REGNUM
] = fp
+ 20;
1129 register FRAME frame
= get_current_frame ();
1130 register CORE_ADDR fp
;
1131 register int regnum
;
1132 struct frame_saved_regs fsr
;
1133 struct frame_info
*fi
;
1136 fi
= get_frame_info (frame
);
1138 get_frame_saved_regs (fi
, &fsr
);
1140 #ifndef NO_PC_SPACE_QUEUE_RESTORE
1141 if (fsr
.regs
[IPSW_REGNUM
]) /* Restoring a call dummy frame */
1142 restore_pc_queue (&fsr
);
1145 for (regnum
= 31; regnum
> 0; regnum
--)
1146 if (fsr
.regs
[regnum
])
1147 write_register (regnum
, read_memory_integer (fsr
.regs
[regnum
], 4));
1149 for (regnum
= NUM_REGS
- 1; regnum
>= FP0_REGNUM
; regnum
--)
1150 if (fsr
.regs
[regnum
])
1152 read_memory (fsr
.regs
[regnum
], (char *)&freg_buffer
, 8);
1153 write_register_bytes (REGISTER_BYTE (regnum
), (char *)&freg_buffer
, 8);
1156 if (fsr
.regs
[IPSW_REGNUM
])
1157 write_register (IPSW_REGNUM
,
1158 read_memory_integer (fsr
.regs
[IPSW_REGNUM
], 4));
1160 if (fsr
.regs
[SAR_REGNUM
])
1161 write_register (SAR_REGNUM
,
1162 read_memory_integer (fsr
.regs
[SAR_REGNUM
], 4));
1164 /* If the PC was explicitly saved, then just restore it. */
1165 if (fsr
.regs
[PCOQ_TAIL_REGNUM
])
1166 write_register (PCOQ_TAIL_REGNUM
,
1167 read_memory_integer (fsr
.regs
[PCOQ_TAIL_REGNUM
], 4));
1169 /* Else use the value in %rp to set the new PC. */
1171 target_write_pc (read_register (RP_REGNUM
), 0);
1173 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
1175 if (fsr
.regs
[IPSW_REGNUM
]) /* call dummy */
1176 write_register (SP_REGNUM
, fp
- 48);
1178 write_register (SP_REGNUM
, fp
);
1180 flush_cached_frames ();
1184 * After returning to a dummy on the stack, restore the instruction
1185 * queue space registers. */
1188 restore_pc_queue (fsr
)
1189 struct frame_saved_regs
*fsr
;
1191 CORE_ADDR pc
= read_pc ();
1192 CORE_ADDR new_pc
= read_memory_integer (fsr
->regs
[PCOQ_HEAD_REGNUM
], 4);
1194 struct target_waitstatus w
;
1197 /* Advance past break instruction in the call dummy. */
1198 write_register (PCOQ_HEAD_REGNUM
, pc
+ 4);
1199 write_register (PCOQ_TAIL_REGNUM
, pc
+ 8);
1202 * HPUX doesn't let us set the space registers or the space
1203 * registers of the PC queue through ptrace. Boo, hiss.
1204 * Conveniently, the call dummy has this sequence of instructions
1209 * So, load up the registers and single step until we are in the
1213 write_register (21, read_memory_integer (fsr
->regs
[PCSQ_HEAD_REGNUM
], 4));
1214 write_register (22, new_pc
);
1216 for (insn_count
= 0; insn_count
< 3; insn_count
++)
1218 /* FIXME: What if the inferior gets a signal right now? Want to
1219 merge this into wait_for_inferior (as a special kind of
1220 watchpoint? By setting a breakpoint at the end? Is there
1221 any other choice? Is there *any* way to do this stuff with
1222 ptrace() or some equivalent?). */
1224 target_wait (inferior_pid
, &w
);
1226 if (w
.kind
== TARGET_WAITKIND_SIGNALLED
)
1228 stop_signal
= w
.value
.sig
;
1229 terminal_ours_for_output ();
1230 printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
1231 target_signal_to_name (stop_signal
),
1232 target_signal_to_string (stop_signal
));
1233 gdb_flush (gdb_stdout
);
1237 target_terminal_ours ();
1238 target_fetch_registers (-1);
1243 hppa_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
1248 CORE_ADDR struct_addr
;
1250 /* array of arguments' offsets */
1251 int *offset
= (int *)alloca(nargs
* sizeof (int));
1255 for (i
= 0; i
< nargs
; i
++)
1257 /* Coerce chars to int & float to double if necessary */
1258 args
[i
] = value_arg_coerce (args
[i
]);
1260 cum
+= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1262 /* value must go at proper alignment. Assume alignment is a
1264 alignment
= hppa_alignof (VALUE_TYPE (args
[i
]));
1265 if (cum
% alignment
)
1266 cum
= (cum
+ alignment
) & -alignment
;
1269 sp
+= max ((cum
+ 7) & -8, 16);
1271 for (i
= 0; i
< nargs
; i
++)
1272 write_memory (sp
+ offset
[i
], VALUE_CONTENTS (args
[i
]),
1273 TYPE_LENGTH (VALUE_TYPE (args
[i
])));
1276 write_register (28, struct_addr
);
1281 * Insert the specified number of args and function address
1282 * into a call sequence of the above form stored at DUMMYNAME.
1284 * On the hppa we need to call the stack dummy through $$dyncall.
1285 * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
1286 * real_pc, which is the location where gdb should start up the
1287 * inferior to do the function call.
1291 hppa_fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)
1300 CORE_ADDR dyncall_addr
, sr4export_addr
;
1301 struct minimal_symbol
*msymbol
;
1302 int flags
= read_register (FLAGS_REGNUM
);
1303 struct unwind_table_entry
*u
;
1305 msymbol
= lookup_minimal_symbol ("$$dyncall", (struct objfile
*) NULL
);
1306 if (msymbol
== NULL
)
1307 error ("Can't find an address for $$dyncall trampoline");
1309 dyncall_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1311 /* FUN could be a procedure label, in which case we have to get
1312 its real address and the value of its GOT/DP. */
1315 /* Get the GOT/DP value for the target function. It's
1316 at *(fun+4). Note the call dummy is *NOT* allowed to
1317 trash %r19 before calling the target function. */
1318 write_register (19, read_memory_integer ((fun
& ~0x3) + 4, 4));
1320 /* Now get the real address for the function we are calling, it's
1322 fun
= (CORE_ADDR
) read_memory_integer (fun
& ~0x3, 4);
1325 /* If we are calling an import stub (eg calling into a dynamic library)
1326 then have sr4export call the magic __d_plt_call routine which is linked
1327 in from end.o. (You can't use _sr4export to call the import stub as
1328 the value in sp-24 will get fried and you end up returning to the
1329 wrong location. You can't call the import stub directly as the code
1330 to bind the PLT entry to a function can't return to a stack address.) */
1331 u
= find_unwind_entry (fun
);
1332 if (u
&& u
->stub_type
== IMPORT
)
1335 msymbol
= lookup_minimal_symbol ("__d_plt_call", (struct objfile
*) NULL
);
1336 if (msymbol
== NULL
)
1337 error ("Can't find an address for __d_plt_call trampoline");
1339 /* This is where sr4export will jump to. */
1340 new_fun
= SYMBOL_VALUE_ADDRESS (msymbol
);
1342 /* We have to store the address of the stub in __shlib_funcptr. */
1343 msymbol
= lookup_minimal_symbol ("__shlib_funcptr",
1344 (struct objfile
*)NULL
);
1345 if (msymbol
== NULL
)
1346 error ("Can't find an address for __shlib_funcptr");
1348 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol
), (char *)&fun
, 4);
1353 /* We still need sr4export's address too. */
1354 msymbol
= lookup_minimal_symbol ("_sr4export", (struct objfile
*) NULL
);
1355 if (msymbol
== NULL
)
1356 error ("Can't find an address for _sr4export trampoline");
1358 sr4export_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1360 store_unsigned_integer
1361 (&dummy
[9*REGISTER_SIZE
],
1363 deposit_21 (fun
>> 11,
1364 extract_unsigned_integer (&dummy
[9*REGISTER_SIZE
],
1366 store_unsigned_integer
1367 (&dummy
[10*REGISTER_SIZE
],
1369 deposit_14 (fun
& MASK_11
,
1370 extract_unsigned_integer (&dummy
[10*REGISTER_SIZE
],
1372 store_unsigned_integer
1373 (&dummy
[12*REGISTER_SIZE
],
1375 deposit_21 (sr4export_addr
>> 11,
1376 extract_unsigned_integer (&dummy
[12*REGISTER_SIZE
],
1378 store_unsigned_integer
1379 (&dummy
[13*REGISTER_SIZE
],
1381 deposit_14 (sr4export_addr
& MASK_11
,
1382 extract_unsigned_integer (&dummy
[13*REGISTER_SIZE
],
1385 write_register (22, pc
);
1387 /* If we are in a syscall, then we should call the stack dummy
1388 directly. $$dyncall is not needed as the kernel sets up the
1389 space id registers properly based on the value in %r31. In
1390 fact calling $$dyncall will not work because the value in %r22
1391 will be clobbered on the syscall exit path. */
1395 return dyncall_addr
;
1399 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1402 target_read_pc (pid
)
1405 int flags
= read_register (FLAGS_REGNUM
);
1408 return read_register (31) & ~0x3;
1409 return read_register (PC_REGNUM
) & ~0x3;
1412 /* Write out the PC. If currently in a syscall, then also write the new
1413 PC value into %r31. */
1415 target_write_pc (v
, pid
)
1419 int flags
= read_register (FLAGS_REGNUM
);
1421 /* If in a syscall, then set %r31. Also make sure to get the
1422 privilege bits set correctly. */
1424 write_register (31, (long) (v
| 0x3));
1426 write_register (PC_REGNUM
, (long) v
);
1427 write_register (NPC_REGNUM
, (long) v
+ 4);
1430 /* return the alignment of a type in bytes. Structures have the maximum
1431 alignment required by their fields. */
1437 int max_align
, align
, i
;
1438 switch (TYPE_CODE (arg
))
1443 return TYPE_LENGTH (arg
);
1444 case TYPE_CODE_ARRAY
:
1445 return hppa_alignof (TYPE_FIELD_TYPE (arg
, 0));
1446 case TYPE_CODE_STRUCT
:
1447 case TYPE_CODE_UNION
:
1449 for (i
= 0; i
< TYPE_NFIELDS (arg
); i
++)
1451 /* Bit fields have no real alignment. */
1452 if (!TYPE_FIELD_BITPOS (arg
, i
))
1454 align
= hppa_alignof (TYPE_FIELD_TYPE (arg
, i
));
1455 max_align
= max (max_align
, align
);
1464 /* Print the register regnum, or all registers if regnum is -1 */
1466 pa_do_registers_info (regnum
, fpregs
)
1470 char raw_regs
[REGISTER_BYTES
];
1473 for (i
= 0; i
< NUM_REGS
; i
++)
1474 read_relative_register_raw_bytes (i
, raw_regs
+ REGISTER_BYTE (i
));
1476 pa_print_registers (raw_regs
, regnum
, fpregs
);
1477 else if (regnum
< FP0_REGNUM
)
1478 printf_unfiltered ("%s %x\n", reg_names
[regnum
], *(long *)(raw_regs
+
1479 REGISTER_BYTE (regnum
)));
1481 pa_print_fp_reg (regnum
);
1484 pa_print_registers (raw_regs
, regnum
, fpregs
)
1491 for (i
= 0; i
< 18; i
++)
1492 printf_unfiltered ("%8.8s: %8x %8.8s: %8x %8.8s: %8x %8.8s: %8x\n",
1494 *(int *)(raw_regs
+ REGISTER_BYTE (i
)),
1496 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 18)),
1498 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 36)),
1500 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 54)));
1503 for (i
= 72; i
< NUM_REGS
; i
++)
1504 pa_print_fp_reg (i
);
1510 unsigned char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1511 unsigned char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
1513 /* Get 32bits of data. */
1514 read_relative_register_raw_bytes (i
, raw_buffer
);
1516 /* Put it in the buffer. No conversions are ever necessary. */
1517 memcpy (virtual_buffer
, raw_buffer
, REGISTER_RAW_SIZE (i
));
1519 fputs_filtered (reg_names
[i
], gdb_stdout
);
1520 print_spaces_filtered (8 - strlen (reg_names
[i
]), gdb_stdout
);
1521 fputs_filtered ("(single precision) ", gdb_stdout
);
1523 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, gdb_stdout
, 0,
1524 1, 0, Val_pretty_default
);
1525 printf_filtered ("\n");
1527 /* If "i" is even, then this register can also be a double-precision
1528 FP register. Dump it out as such. */
1531 /* Get the data in raw format for the 2nd half. */
1532 read_relative_register_raw_bytes (i
+ 1, raw_buffer
);
1534 /* Copy it into the appropriate part of the virtual buffer. */
1535 memcpy (virtual_buffer
+ REGISTER_RAW_SIZE (i
), raw_buffer
,
1536 REGISTER_RAW_SIZE (i
));
1538 /* Dump it as a double. */
1539 fputs_filtered (reg_names
[i
], gdb_stdout
);
1540 print_spaces_filtered (8 - strlen (reg_names
[i
]), gdb_stdout
);
1541 fputs_filtered ("(double precision) ", gdb_stdout
);
1543 val_print (builtin_type_double
, virtual_buffer
, 0, gdb_stdout
, 0,
1544 1, 0, Val_pretty_default
);
1545 printf_filtered ("\n");
1549 /* Figure out if PC is in a trampoline, and if so find out where
1550 the trampoline will jump to. If not in a trampoline, return zero.
1552 Simple code examination probably is not a good idea since the code
1553 sequences in trampolines can also appear in user code.
1555 We use unwinds and information from the minimal symbol table to
1556 determine when we're in a trampoline. This won't work for ELF
1557 (yet) since it doesn't create stub unwind entries. Whether or
1558 not ELF will create stub unwinds or normal unwinds for linker
1559 stubs is still being debated.
1561 This should handle simple calls through dyncall or sr4export,
1562 long calls, argument relocation stubs, and dyncall/sr4export
1563 calling an argument relocation stub. It even handles some stubs
1564 used in dynamic executables. */
1567 skip_trampoline_code (pc
, name
)
1572 long prev_inst
, curr_inst
, loc
;
1573 static CORE_ADDR dyncall
= 0;
1574 static CORE_ADDR sr4export
= 0;
1575 struct minimal_symbol
*msym
;
1576 struct unwind_table_entry
*u
;
1578 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
1583 msym
= lookup_minimal_symbol ("$$dyncall", NULL
);
1585 dyncall
= SYMBOL_VALUE_ADDRESS (msym
);
1592 msym
= lookup_minimal_symbol ("_sr4export", NULL
);
1594 sr4export
= SYMBOL_VALUE_ADDRESS (msym
);
1599 /* Addresses passed to dyncall may *NOT* be the actual address
1600 of the funtion. So we may have to do something special. */
1603 pc
= (CORE_ADDR
) read_register (22);
1605 /* If bit 30 (counting from the left) is on, then pc is the address of
1606 the PLT entry for this function, not the address of the function
1607 itself. Bit 31 has meaning too, but only for MPE. */
1609 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, 4);
1611 else if (pc
== sr4export
)
1612 pc
= (CORE_ADDR
) (read_register (22));
1614 /* Get the unwind descriptor corresponding to PC, return zero
1615 if no unwind was found. */
1616 u
= find_unwind_entry (pc
);
1620 /* If this isn't a linker stub, then return now. */
1621 if (u
->stub_type
== 0)
1622 return orig_pc
== pc
? 0 : pc
& ~0x3;
1624 /* It's a stub. Search for a branch and figure out where it goes.
1625 Note we have to handle multi insn branch sequences like ldil;ble.
1626 Most (all?) other branches can be determined by examining the contents
1627 of certain registers and the stack. */
1633 /* Make sure we haven't walked outside the range of this stub. */
1634 if (u
!= find_unwind_entry (loc
))
1636 warning ("Unable to find branch in linker stub");
1637 return orig_pc
== pc
? 0 : pc
& ~0x3;
1640 prev_inst
= curr_inst
;
1641 curr_inst
= read_memory_integer (loc
, 4);
1643 /* Does it look like a branch external using %r1? Then it's the
1644 branch from the stub to the actual function. */
1645 if ((curr_inst
& 0xffe0e000) == 0xe0202000)
1647 /* Yup. See if the previous instruction loaded
1648 a value into %r1. If so compute and return the jump address. */
1649 if ((prev_inst
& 0xffe00000) == 0x20200000)
1650 return (extract_21 (prev_inst
) + extract_17 (curr_inst
)) & ~0x3;
1653 warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
1654 return orig_pc
== pc
? 0 : pc
& ~0x3;
1658 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
1659 branch from the stub to the actual function. */
1660 else if ((curr_inst
& 0xffe0e000) == 0xe8400000
1661 || (curr_inst
& 0xffe0e000) == 0xe8000000)
1662 return (loc
+ extract_17 (curr_inst
) + 8) & ~0x3;
1664 /* Does it look like bv (rp)? Note this depends on the
1665 current stack pointer being the same as the stack
1666 pointer in the stub itself! This is a branch on from the
1667 stub back to the original caller. */
1668 else if ((curr_inst
& 0xffe0e000) == 0xe840c000)
1670 /* Yup. See if the previous instruction loaded
1672 if (prev_inst
== 0x4bc23ff1)
1673 return (read_memory_integer
1674 (read_register (SP_REGNUM
) - 8, 4)) & ~0x3;
1677 warning ("Unable to find restore of %%rp before bv (%%rp).");
1678 return orig_pc
== pc
? 0 : pc
& ~0x3;
1682 /* What about be,n 0(sr0,%rp)? It's just another way we return to
1683 the original caller from the stub. Used in dynamic executables. */
1684 else if (curr_inst
== 0xe0400002)
1686 /* The value we jump to is sitting in sp - 24. But that's
1687 loaded several instructions before the be instruction.
1688 I guess we could check for the previous instruction being
1689 mtsp %r1,%sr0 if we want to do sanity checking. */
1690 return (read_memory_integer
1691 (read_register (SP_REGNUM
) - 24, 4)) & ~0x3;
1694 /* Haven't found the branch yet, but we're still in the stub.
1700 /* For the given instruction (INST), return any adjustment it makes
1701 to the stack pointer or zero for no adjustment.
1703 This only handles instructions commonly found in prologues. */
1706 prologue_inst_adjust_sp (inst
)
1709 /* This must persist across calls. */
1710 static int save_high21
;
1712 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1713 if ((inst
& 0xffffc000) == 0x37de0000)
1714 return extract_14 (inst
);
1717 if ((inst
& 0xffe00000) == 0x6fc00000)
1718 return extract_14 (inst
);
1720 /* addil high21,%r1; ldo low11,(%r1),%r30)
1721 save high bits in save_high21 for later use. */
1722 if ((inst
& 0xffe00000) == 0x28200000)
1724 save_high21
= extract_21 (inst
);
1728 if ((inst
& 0xffff0000) == 0x343e0000)
1729 return save_high21
+ extract_14 (inst
);
1731 /* fstws as used by the HP compilers. */
1732 if ((inst
& 0xffffffe0) == 0x2fd01220)
1733 return extract_5_load (inst
);
1735 /* No adjustment. */
1739 /* Return nonzero if INST is a branch of some kind, else return zero. */
1769 /* Return the register number for a GR which is saved by INST or
1770 zero it INST does not save a GR. */
1773 inst_saves_gr (inst
)
1776 /* Does it look like a stw? */
1777 if ((inst
>> 26) == 0x1a)
1778 return extract_5R_store (inst
);
1780 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1781 if ((inst
>> 26) == 0x1b)
1782 return extract_5R_store (inst
);
1784 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1786 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18)
1787 return extract_5R_store (inst
);
1792 /* Return the register number for a FR which is saved by INST or
1793 zero it INST does not save a FR.
1795 Note we only care about full 64bit register stores (that's the only
1796 kind of stores the prologue will use).
1798 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1801 inst_saves_fr (inst
)
1804 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1805 return extract_5r_store (inst
);
1809 /* Advance PC across any function entry prologue instructions
1810 to reach some "real" code.
1812 Use information in the unwind table to determine what exactly should
1813 be in the prologue. */
1820 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1821 unsigned long args_stored
, status
, i
;
1822 struct unwind_table_entry
*u
;
1824 u
= find_unwind_entry (pc
);
1828 /* If we are not at the beginning of a function, then return now. */
1829 if ((pc
& ~0x3) != u
->region_start
)
1832 /* This is how much of a frame adjustment we need to account for. */
1833 stack_remaining
= u
->Total_frame_size
<< 3;
1835 /* Magic register saves we want to know about. */
1836 save_rp
= u
->Save_RP
;
1837 save_sp
= u
->Save_SP
;
1839 /* An indication that args may be stored into the stack. Unfortunately
1840 the HPUX compilers tend to set this in cases where no args were
1842 args_stored
= u
->Args_stored
;
1844 /* Turn the Entry_GR field into a bitmask. */
1846 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1848 /* Frame pointer gets saved into a special location. */
1849 if (u
->Save_SP
&& i
== FP_REGNUM
)
1852 save_gr
|= (1 << i
);
1855 /* Turn the Entry_FR field into a bitmask too. */
1857 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1858 save_fr
|= (1 << i
);
1860 /* Loop until we find everything of interest or hit a branch.
1862 For unoptimized GCC code and for any HP CC code this will never ever
1863 examine any user instructions.
1865 For optimzied GCC code we're faced with problems. GCC will schedule
1866 its prologue and make prologue instructions available for delay slot
1867 filling. The end result is user code gets mixed in with the prologue
1868 and a prologue instruction may be in the delay slot of the first branch
1871 Some unexpected things are expected with debugging optimized code, so
1872 we allow this routine to walk past user instructions in optimized
1874 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1877 unsigned int reg_num
;
1878 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1879 unsigned long old_save_rp
, old_save_sp
, old_args_stored
, next_inst
;
1881 /* Save copies of all the triggers so we can compare them later
1883 old_save_gr
= save_gr
;
1884 old_save_fr
= save_fr
;
1885 old_save_rp
= save_rp
;
1886 old_save_sp
= save_sp
;
1887 old_stack_remaining
= stack_remaining
;
1889 status
= target_read_memory (pc
, buf
, 4);
1890 inst
= extract_unsigned_integer (buf
, 4);
1896 /* Note the interesting effects of this instruction. */
1897 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1899 /* There is only one instruction used for saving RP into the stack. */
1900 if (inst
== 0x6bc23fd9)
1903 /* This is the only way we save SP into the stack. At this time
1904 the HP compilers never bother to save SP into the stack. */
1905 if ((inst
& 0xffffc000) == 0x6fc10000)
1908 /* Account for general and floating-point register saves. */
1909 reg_num
= inst_saves_gr (inst
);
1910 save_gr
&= ~(1 << reg_num
);
1912 /* Ugh. Also account for argument stores into the stack.
1913 Unfortunately args_stored only tells us that some arguments
1914 where stored into the stack. Not how many or what kind!
1916 This is a kludge as on the HP compiler sets this bit and it
1917 never does prologue scheduling. So once we see one, skip past
1918 all of them. We have similar code for the fp arg stores below.
1920 FIXME. Can still die if we have a mix of GR and FR argument
1922 if (reg_num
>= 23 && reg_num
<= 26)
1924 while (reg_num
>= 23 && reg_num
<= 26)
1927 status
= target_read_memory (pc
, buf
, 4);
1928 inst
= extract_unsigned_integer (buf
, 4);
1931 reg_num
= inst_saves_gr (inst
);
1937 reg_num
= inst_saves_fr (inst
);
1938 save_fr
&= ~(1 << reg_num
);
1940 status
= target_read_memory (pc
+ 4, buf
, 4);
1941 next_inst
= extract_unsigned_integer (buf
, 4);
1947 /* We've got to be read to handle the ldo before the fp register
1949 if ((inst
& 0xfc000000) == 0x34000000
1950 && inst_saves_fr (next_inst
) >= 4
1951 && inst_saves_fr (next_inst
) <= 7)
1953 /* So we drop into the code below in a reasonable state. */
1954 reg_num
= inst_saves_fr (next_inst
);
1958 /* Ugh. Also account for argument stores into the stack.
1959 This is a kludge as on the HP compiler sets this bit and it
1960 never does prologue scheduling. So once we see one, skip past
1962 if (reg_num
>= 4 && reg_num
<= 7)
1964 while (reg_num
>= 4 && reg_num
<= 7)
1967 status
= target_read_memory (pc
, buf
, 4);
1968 inst
= extract_unsigned_integer (buf
, 4);
1971 if ((inst
& 0xfc000000) != 0x34000000)
1973 status
= target_read_memory (pc
+ 4, buf
, 4);
1974 next_inst
= extract_unsigned_integer (buf
, 4);
1977 reg_num
= inst_saves_fr (next_inst
);
1983 /* Quit if we hit any kind of branch. This can happen if a prologue
1984 instruction is in the delay slot of the first call/branch. */
1985 if (is_branch (inst
))
1988 /* What a crock. The HP compilers set args_stored even if no
1989 arguments were stored into the stack (boo hiss). This could
1990 cause this code to then skip a bunch of user insns (up to the
1993 To combat this we try to identify when args_stored was bogusly
1994 set and clear it. We only do this when args_stored is nonzero,
1995 all other resources are accounted for, and nothing changed on
1998 && ! (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1999 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
2000 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
2001 && old_stack_remaining
== stack_remaining
)
2011 /* Put here the code to store, into a struct frame_saved_regs,
2012 the addresses of the saved registers of frame described by FRAME_INFO.
2013 This includes special registers such as pc and fp saved in special
2014 ways in the stack frame. sp is even more special:
2015 the address we return for it IS the sp for the next frame. */
2018 hppa_frame_find_saved_regs (frame_info
, frame_saved_regs
)
2019 struct frame_info
*frame_info
;
2020 struct frame_saved_regs
*frame_saved_regs
;
2023 struct unwind_table_entry
*u
;
2024 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
2029 /* Zero out everything. */
2030 memset (frame_saved_regs
, '\0', sizeof (struct frame_saved_regs
));
2032 /* Call dummy frames always look the same, so there's no need to
2033 examine the dummy code to determine locations of saved registers;
2034 instead, let find_dummy_frame_regs fill in the correct offsets
2035 for the saved registers. */
2036 if ((frame_info
->pc
>= frame_info
->frame
2037 && frame_info
->pc
<= (frame_info
->frame
+ CALL_DUMMY_LENGTH
2038 + 32 * 4 + (NUM_REGS
- FP0_REGNUM
) * 8
2040 find_dummy_frame_regs (frame_info
, frame_saved_regs
);
2042 /* Interrupt handlers are special too. They lay out the register
2043 state in the exact same order as the register numbers in GDB. */
2044 if (pc_in_interrupt_handler (frame_info
->pc
))
2046 for (i
= 0; i
< NUM_REGS
; i
++)
2048 /* SP is a little special. */
2050 frame_saved_regs
->regs
[SP_REGNUM
]
2051 = read_memory_integer (frame_info
->frame
+ SP_REGNUM
* 4, 4);
2053 frame_saved_regs
->regs
[i
] = frame_info
->frame
+ i
* 4;
2058 /* Handle signal handler callers. */
2059 if (frame_info
->signal_handler_caller
)
2061 FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info
, frame_saved_regs
);
2065 /* Get the starting address of the function referred to by the PC
2066 saved in frame_info. */
2067 pc
= get_pc_function_start (frame_info
->pc
);
2070 u
= find_unwind_entry (pc
);
2074 /* This is how much of a frame adjustment we need to account for. */
2075 stack_remaining
= u
->Total_frame_size
<< 3;
2077 /* Magic register saves we want to know about. */
2078 save_rp
= u
->Save_RP
;
2079 save_sp
= u
->Save_SP
;
2081 /* Turn the Entry_GR field into a bitmask. */
2083 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
2085 /* Frame pointer gets saved into a special location. */
2086 if (u
->Save_SP
&& i
== FP_REGNUM
)
2089 save_gr
|= (1 << i
);
2092 /* Turn the Entry_FR field into a bitmask too. */
2094 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
2095 save_fr
|= (1 << i
);
2097 /* The frame always represents the value of %sp at entry to the
2098 current function (and is thus equivalent to the "saved" stack
2100 frame_saved_regs
->regs
[SP_REGNUM
] = frame_info
->frame
;
2102 /* Loop until we find everything of interest or hit a branch.
2104 For unoptimized GCC code and for any HP CC code this will never ever
2105 examine any user instructions.
2107 For optimzied GCC code we're faced with problems. GCC will schedule
2108 its prologue and make prologue instructions available for delay slot
2109 filling. The end result is user code gets mixed in with the prologue
2110 and a prologue instruction may be in the delay slot of the first branch
2113 Some unexpected things are expected with debugging optimized code, so
2114 we allow this routine to walk past user instructions in optimized
2116 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
2118 status
= target_read_memory (pc
, buf
, 4);
2119 inst
= extract_unsigned_integer (buf
, 4);
2125 /* Note the interesting effects of this instruction. */
2126 stack_remaining
-= prologue_inst_adjust_sp (inst
);
2128 /* There is only one instruction used for saving RP into the stack. */
2129 if (inst
== 0x6bc23fd9)
2132 frame_saved_regs
->regs
[RP_REGNUM
] = frame_info
->frame
- 20;
2135 /* Just note that we found the save of SP into the stack. The
2136 value for frame_saved_regs was computed above. */
2137 if ((inst
& 0xffffc000) == 0x6fc10000)
2140 /* Account for general and floating-point register saves. */
2141 reg
= inst_saves_gr (inst
);
2142 if (reg
>= 3 && reg
<= 18
2143 && (!u
->Save_SP
|| reg
!= FP_REGNUM
))
2145 save_gr
&= ~(1 << reg
);
2147 /* stwm with a positive displacement is a *post modify*. */
2148 if ((inst
>> 26) == 0x1b
2149 && extract_14 (inst
) >= 0)
2150 frame_saved_regs
->regs
[reg
] = frame_info
->frame
;
2153 /* Handle code with and without frame pointers. */
2155 frame_saved_regs
->regs
[reg
]
2156 = frame_info
->frame
+ extract_14 (inst
);
2158 frame_saved_regs
->regs
[reg
]
2159 = frame_info
->frame
+ (u
->Total_frame_size
<< 3)
2160 + extract_14 (inst
);
2165 /* GCC handles callee saved FP regs a little differently.
2167 It emits an instruction to put the value of the start of
2168 the FP store area into %r1. It then uses fstds,ma with
2169 a basereg of %r1 for the stores.
2171 HP CC emits them at the current stack pointer modifying
2172 the stack pointer as it stores each register. */
2174 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2175 if ((inst
& 0xffffc000) == 0x34610000
2176 || (inst
& 0xffffc000) == 0x37c10000)
2177 fp_loc
= extract_14 (inst
);
2179 reg
= inst_saves_fr (inst
);
2180 if (reg
>= 12 && reg
<= 21)
2182 /* Note +4 braindamage below is necessary because the FP status
2183 registers are internally 8 registers rather than the expected
2185 save_fr
&= ~(1 << reg
);
2188 /* 1st HP CC FP register store. After this instruction
2189 we've set enough state that the GCC and HPCC code are
2190 both handled in the same manner. */
2191 frame_saved_regs
->regs
[reg
+ FP4_REGNUM
+ 4] = frame_info
->frame
;
2196 frame_saved_regs
->regs
[reg
+ FP0_REGNUM
+ 4]
2197 = frame_info
->frame
+ fp_loc
;
2202 /* Quit if we hit any kind of branch. This can happen if a prologue
2203 instruction is in the delay slot of the first call/branch. */
2204 if (is_branch (inst
))
2212 #ifdef MAINTENANCE_CMDS
2215 unwind_command (exp
, from_tty
)
2223 struct unwind_table_entry
*u
;
2226 /* If we have an expression, evaluate it and use it as the address. */
2228 if (exp
!= 0 && *exp
!= 0)
2229 address
= parse_and_eval_address (exp
);
2233 xxx
.u
= find_unwind_entry (address
);
2237 printf_unfiltered ("Can't find unwind table entry for PC 0x%x\n", address
);
2241 printf_unfiltered ("%08x\n%08X\n%08X\n%08X\n", xxx
.foo
[0], xxx
.foo
[1], xxx
.foo
[2],
2244 #endif /* MAINTENANCE_CMDS */
2247 _initialize_hppa_tdep ()
2249 #ifdef MAINTENANCE_CMDS
2250 add_cmd ("unwind", class_maintenance
, unwind_command
,
2251 "Print unwind table entry at given address.",
2252 &maintenanceprintlist
);
2253 #endif /* MAINTENANCE_CMDS */