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 static FRAME_ADDR dig_fp_from_stack
PARAMS ((FRAME frame
,
65 struct unwind_table_entry
*u
));
66 CORE_ADDR frame_saved_pc
PARAMS ((FRAME frame
));
69 /* Routines to extract various sized constants out of hppa
72 /* This assumes that no garbage lies outside of the lower bits of
76 sign_extend (val
, bits
)
79 return (int)(val
>> bits
- 1 ? (-1 << bits
) | val
: val
);
82 /* For many immediate values the sign bit is the low bit! */
85 low_sign_extend (val
, bits
)
88 return (int)((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
90 /* extract the immediate field from a ld{bhw}s instruction */
93 get_field (val
, from
, to
)
94 unsigned val
, from
, to
;
97 return val
& ((1 << 32 - from
) - 1);
101 set_field (val
, from
, to
, new_val
)
102 unsigned *val
, from
, to
;
104 unsigned mask
= ~((1 << (to
- from
+ 1)) << (31 - from
));
105 return *val
= *val
& mask
| (new_val
<< (31 - from
));
108 /* extract a 3-bit space register number from a be, ble, mtsp or mfsp */
113 return GET_FIELD (word
, 18, 18) << 2 | GET_FIELD (word
, 16, 17);
116 extract_5_load (word
)
119 return low_sign_extend (word
>> 16 & MASK_5
, 5);
122 /* extract the immediate field from a st{bhw}s instruction */
125 extract_5_store (word
)
128 return low_sign_extend (word
& MASK_5
, 5);
131 /* extract the immediate field from a break instruction */
134 extract_5r_store (word
)
137 return (word
& MASK_5
);
140 /* extract the immediate field from a {sr}sm instruction */
143 extract_5R_store (word
)
146 return (word
>> 16 & MASK_5
);
149 /* extract an 11 bit immediate field */
155 return low_sign_extend (word
& MASK_11
, 11);
158 /* extract a 14 bit immediate field */
164 return low_sign_extend (word
& MASK_14
, 14);
167 /* deposit a 14 bit constant in a word */
170 deposit_14 (opnd
, word
)
174 unsigned sign
= (opnd
< 0 ? 1 : 0);
176 return word
| ((unsigned)opnd
<< 1 & MASK_14
) | sign
;
179 /* extract a 21 bit constant */
189 val
= GET_FIELD (word
, 20, 20);
191 val
|= GET_FIELD (word
, 9, 19);
193 val
|= GET_FIELD (word
, 5, 6);
195 val
|= GET_FIELD (word
, 0, 4);
197 val
|= GET_FIELD (word
, 7, 8);
198 return sign_extend (val
, 21) << 11;
201 /* deposit a 21 bit constant in a word. Although 21 bit constants are
202 usually the top 21 bits of a 32 bit constant, we assume that only
203 the low 21 bits of opnd are relevant */
206 deposit_21 (opnd
, word
)
211 val
|= GET_FIELD (opnd
, 11 + 14, 11 + 18);
213 val
|= GET_FIELD (opnd
, 11 + 12, 11 + 13);
215 val
|= GET_FIELD (opnd
, 11 + 19, 11 + 20);
217 val
|= GET_FIELD (opnd
, 11 + 1, 11 + 11);
219 val
|= GET_FIELD (opnd
, 11 + 0, 11 + 0);
223 /* extract a 12 bit constant from branch instructions */
229 return sign_extend (GET_FIELD (word
, 19, 28) |
230 GET_FIELD (word
, 29, 29) << 10 |
231 (word
& 0x1) << 11, 12) << 2;
234 /* extract a 17 bit constant from branch instructions, returning the
235 19 bit signed value. */
241 return sign_extend (GET_FIELD (word
, 19, 28) |
242 GET_FIELD (word
, 29, 29) << 10 |
243 GET_FIELD (word
, 11, 15) << 11 |
244 (word
& 0x1) << 16, 17) << 2;
247 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
248 of the objfiles seeking the unwind table entry for this PC. Each objfile
249 contains a sorted list of struct unwind_table_entry. Since we do a binary
250 search of the unwind tables, we depend upon them to be sorted. */
252 static struct unwind_table_entry
*
253 find_unwind_entry(pc
)
256 int first
, middle
, last
;
257 struct objfile
*objfile
;
259 ALL_OBJFILES (objfile
)
261 struct obj_unwind_info
*ui
;
263 ui
= OBJ_UNWIND_INFO (objfile
);
268 /* First, check the cache */
271 && pc
>= ui
->cache
->region_start
272 && pc
<= ui
->cache
->region_end
)
275 /* Not in the cache, do a binary search */
280 while (first
<= last
)
282 middle
= (first
+ last
) / 2;
283 if (pc
>= ui
->table
[middle
].region_start
284 && pc
<= ui
->table
[middle
].region_end
)
286 ui
->cache
= &ui
->table
[middle
];
287 return &ui
->table
[middle
];
290 if (pc
< ui
->table
[middle
].region_start
)
295 } /* ALL_OBJFILES() */
299 /* Called when no unwind descriptor was found for PC. Returns 1 if it
300 appears that PC is in a linker stub. */
301 static int pc_in_linker_stub
PARAMS ((CORE_ADDR
));
304 pc_in_linker_stub (pc
)
307 int found_magic_instruction
= 0;
311 /* If unable to read memory, assume pc is not in a linker stub. */
312 if (target_read_memory (pc
, buf
, 4) != 0)
315 /* We are looking for something like
317 ; $$dyncall jams RP into this special spot in the frame (RP')
318 ; before calling the "call stub"
321 ldsid (rp),r1 ; Get space associated with RP into r1
322 mtsp r1,sp ; Move it into space register 0
323 be,n 0(sr0),rp) ; back to your regularly scheduled program
326 /* Maximum known linker stub size is 4 instructions. Search forward
327 from the given PC, then backward. */
328 for (i
= 0; i
< 4; i
++)
330 /* If we hit something with an unwind, stop searching this direction. */
332 if (find_unwind_entry (pc
+ i
* 4) != 0)
335 /* Check for ldsid (rp),r1 which is the magic instruction for a
336 return from a cross-space function call. */
337 if (read_memory_integer (pc
+ i
* 4, 4) == 0x004010a1)
339 found_magic_instruction
= 1;
342 /* Add code to handle long call/branch and argument relocation stubs
346 if (found_magic_instruction
!= 0)
349 /* Now look backward. */
350 for (i
= 0; i
< 4; i
++)
352 /* If we hit something with an unwind, stop searching this direction. */
354 if (find_unwind_entry (pc
- i
* 4) != 0)
357 /* Check for ldsid (rp),r1 which is the magic instruction for a
358 return from a cross-space function call. */
359 if (read_memory_integer (pc
- i
* 4, 4) == 0x004010a1)
361 found_magic_instruction
= 1;
364 /* Add code to handle long call/branch and argument relocation stubs
367 return found_magic_instruction
;
371 find_return_regnum(pc
)
374 struct unwind_table_entry
*u
;
376 u
= find_unwind_entry (pc
);
387 /* Return size of frame, or -1 if we should use a frame pointer. */
389 find_proc_framesize(pc
)
392 struct unwind_table_entry
*u
;
394 u
= find_unwind_entry (pc
);
398 if (pc_in_linker_stub (pc
))
399 /* Linker stubs have a zero size frame. */
406 /* If this bit is set, it means there is a frame pointer and we should
410 return u
->Total_frame_size
<< 3;
413 /* Return offset from sp at which rp is saved, or 0 if not saved. */
414 static int rp_saved
PARAMS ((CORE_ADDR
));
420 struct unwind_table_entry
*u
;
422 u
= find_unwind_entry (pc
);
426 if (pc_in_linker_stub (pc
))
427 /* This is the so-called RP'. */
440 frameless_function_invocation (frame
)
443 struct unwind_table_entry
*u
;
445 u
= find_unwind_entry (frame
->pc
);
448 return frameless_look_for_prologue (frame
);
450 return (u
->Total_frame_size
== 0);
454 saved_pc_after_call (frame
)
459 ret_regnum
= find_return_regnum (get_frame_pc (frame
));
461 return read_register (ret_regnum
) & ~0x3;
465 frame_saved_pc (frame
)
468 CORE_ADDR pc
= get_frame_pc (frame
);
470 if (frameless_function_invocation (frame
))
474 ret_regnum
= find_return_regnum (pc
);
476 return read_register (ret_regnum
) & ~0x3;
480 int rp_offset
= rp_saved (pc
);
483 return read_register (RP_REGNUM
) & ~0x3;
485 return read_memory_integer (frame
->frame
+ rp_offset
, 4) & ~0x3;
489 /* We need to correct the PC and the FP for the outermost frame when we are
493 init_extra_frame_info (fromleaf
, frame
)
495 struct frame_info
*frame
;
500 if (frame
->next
&& !fromleaf
)
503 /* If the next frame represents a frameless function invocation
504 then we have to do some adjustments that are normally done by
505 FRAME_CHAIN. (FRAME_CHAIN is not called in this case.) */
508 /* Find the framesize of *this* frame without peeking at the PC
509 in the current frame structure (it isn't set yet). */
510 framesize
= find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame
)));
512 /* Now adjust our base frame accordingly. If we have a frame pointer
513 use it, else subtract the size of this frame from the current
514 frame. (we always want frame->frame to point at the lowest address
517 frame
->frame
= read_register (FP_REGNUM
);
519 frame
->frame
-= framesize
;
523 flags
= read_register (FLAGS_REGNUM
);
524 if (flags
& 2) /* In system call? */
525 frame
->pc
= read_register (31) & ~0x3;
527 /* The outermost frame is always derived from PC-framesize
529 One might think frameless innermost frames should have
530 a frame->frame that is the same as the parent's frame->frame.
531 That is wrong; frame->frame in that case should be the *high*
532 address of the parent's frame. It's complicated as hell to
533 explain, but the parent *always* creates some stack space for
534 the child. So the child actually does have a frame of some
535 sorts, and its base is the high address in its parent's frame. */
536 framesize
= find_proc_framesize(frame
->pc
);
538 frame
->frame
= read_register (FP_REGNUM
);
540 frame
->frame
= read_register (SP_REGNUM
) - framesize
;
543 /* Given a GDB frame, determine the address of the calling function's frame.
544 This will be used to create a new GDB frame struct, and then
545 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
547 This may involve searching through prologues for several functions
548 at boundaries where GCC calls HP C code, or where code which has
549 a frame pointer calls code without a frame pointer. */
554 struct frame_info
*frame
;
556 int my_framesize
, caller_framesize
;
557 struct unwind_table_entry
*u
;
559 /* Get frame sizes for the current frame and the frame of the
561 my_framesize
= find_proc_framesize (frame
->pc
);
562 caller_framesize
= find_proc_framesize (FRAME_SAVED_PC(frame
));
564 /* If caller does not have a frame pointer, then its frame
565 can be found at current_frame - caller_framesize. */
566 if (caller_framesize
!= -1)
567 return frame
->frame
- caller_framesize
;
569 /* Both caller and callee have frame pointers and are GCC compiled
570 (SAVE_SP bit in unwind descriptor is on for both functions.
571 The previous frame pointer is found at the top of the current frame. */
572 if (caller_framesize
== -1 && my_framesize
== -1)
573 return read_memory_integer (frame
->frame
, 4);
575 /* Caller has a frame pointer, but callee does not. This is a little
576 more difficult as GCC and HP C lay out locals and callee register save
577 areas very differently.
579 The previous frame pointer could be in a register, or in one of
580 several areas on the stack.
582 Walk from the current frame to the innermost frame examining
583 unwind descriptors to determine if %r3 ever gets saved into the
584 stack. If so return whatever value got saved into the stack.
585 If it was never saved in the stack, then the value in %r3 is still
588 We use information from unwind descriptors to determine if %r3
589 is saved into the stack (Entry_GR field has this information). */
593 u
= find_unwind_entry (frame
->pc
);
597 /* We could find this information by examining prologues. I don't
598 think anyone has actually written any tools (not even "strip")
599 which leave them out of an executable, so maybe this is a moot
601 warning ("Unable to find unwind for PC 0x%x -- Help!", frame
->pc
);
605 /* Entry_GR specifies the number of callee-saved general registers
606 saved in the stack. It starts at %r3, so %r3 would be 1. */
607 if (u
->Entry_GR
>= 1 || u
->Save_SP
)
615 /* We may have walked down the chain into a function with a frame
618 return read_memory_integer (frame
->frame
, 4);
619 /* %r3 was saved somewhere in the stack. Dig it out. */
621 return dig_fp_from_stack (frame
, u
);
625 /* The value in %r3 was never saved into the stack (thus %r3 still
626 holds the value of the previous frame pointer). */
627 return read_register (FP_REGNUM
);
631 /* Given a frame and an unwind descriptor return the value for %fr (aka fp)
632 which was saved into the stack. FIXME: Why can't we just use the standard
636 dig_fp_from_stack (frame
, u
)
638 struct unwind_table_entry
*u
;
640 CORE_ADDR pc
= u
->region_start
;
642 /* Search the function for the save of %r3. */
643 while (pc
!= u
->region_end
)
649 /* We need only look for the standard stw %r3,X(%sp) instruction,
650 the other variants (eg stwm) are only used on the first register
652 status
= target_read_memory (pc
, buf
, 4);
653 inst
= extract_unsigned_integer (buf
, 4);
656 memory_error (status
, pc
);
658 /* Check for stw %r3,X(%sp). */
659 if ((inst
& 0xffffc000) == 0x6bc30000)
661 /* Found the instruction which saves %r3. The offset (relative
662 to this frame) is framesize + immed14 (derived from the
663 store instruction). */
664 int offset
= (u
->Total_frame_size
<< 3) + extract_14 (inst
);
666 return read_memory_integer (frame
->frame
+ offset
, 4);
673 warning ("Unable to find %%r3 in stack.\n");
678 /* To see if a frame chain is valid, see if the caller looks like it
679 was compiled with gcc. */
682 frame_chain_valid (chain
, thisframe
)
686 struct minimal_symbol
*msym_us
;
687 struct minimal_symbol
*msym_start
;
688 struct unwind_table_entry
*u
;
693 u
= find_unwind_entry (thisframe
->pc
);
695 /* We can't just check that the same of msym_us is "_start", because
696 someone idiotically decided that they were going to make a Ltext_end
697 symbol with the same address. This Ltext_end symbol is totally
698 indistinguishable (as nearly as I can tell) from the symbol for a function
699 which is (legitimately, since it is in the user's namespace)
700 named Ltext_end, so we can't just ignore it. */
701 msym_us
= lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe
));
702 msym_start
= lookup_minimal_symbol ("_start", NULL
);
705 && SYMBOL_VALUE_ADDRESS (msym_us
) == SYMBOL_VALUE_ADDRESS (msym_start
))
711 if (u
->Save_SP
|| u
->Total_frame_size
)
714 if (pc_in_linker_stub (thisframe
->pc
))
721 * These functions deal with saving and restoring register state
722 * around a function call in the inferior. They keep the stack
723 * double-word aligned; eventually, on an hp700, the stack will have
724 * to be aligned to a 64-byte boundary.
730 register CORE_ADDR sp
;
735 /* Space for "arguments"; the RP goes in here. */
736 sp
= read_register (SP_REGNUM
) + 48;
737 int_buffer
= read_register (RP_REGNUM
) | 0x3;
738 write_memory (sp
- 20, (char *)&int_buffer
, 4);
740 int_buffer
= read_register (FP_REGNUM
);
741 write_memory (sp
, (char *)&int_buffer
, 4);
743 write_register (FP_REGNUM
, sp
);
747 for (regnum
= 1; regnum
< 32; regnum
++)
748 if (regnum
!= RP_REGNUM
&& regnum
!= FP_REGNUM
)
749 sp
= push_word (sp
, read_register (regnum
));
753 for (regnum
= FP0_REGNUM
; regnum
< NUM_REGS
; regnum
++)
755 read_register_bytes (REGISTER_BYTE (regnum
), (char *)&freg_buffer
, 8);
756 sp
= push_bytes (sp
, (char *)&freg_buffer
, 8);
758 sp
= push_word (sp
, read_register (IPSW_REGNUM
));
759 sp
= push_word (sp
, read_register (SAR_REGNUM
));
760 sp
= push_word (sp
, read_register (PCOQ_HEAD_REGNUM
));
761 sp
= push_word (sp
, read_register (PCSQ_HEAD_REGNUM
));
762 sp
= push_word (sp
, read_register (PCOQ_TAIL_REGNUM
));
763 sp
= push_word (sp
, read_register (PCSQ_TAIL_REGNUM
));
764 write_register (SP_REGNUM
, sp
);
767 find_dummy_frame_regs (frame
, frame_saved_regs
)
768 struct frame_info
*frame
;
769 struct frame_saved_regs
*frame_saved_regs
;
771 CORE_ADDR fp
= frame
->frame
;
774 frame_saved_regs
->regs
[RP_REGNUM
] = fp
- 20 & ~0x3;
775 frame_saved_regs
->regs
[FP_REGNUM
] = fp
;
776 frame_saved_regs
->regs
[1] = fp
+ 8;
778 for (fp
+= 12, i
= 3; i
< 32; i
++)
782 frame_saved_regs
->regs
[i
] = fp
;
788 for (i
= FP0_REGNUM
; i
< NUM_REGS
; i
++, fp
+= 8)
789 frame_saved_regs
->regs
[i
] = fp
;
791 frame_saved_regs
->regs
[IPSW_REGNUM
] = fp
;
792 frame_saved_regs
->regs
[SAR_REGNUM
] = fp
+ 4;
793 frame_saved_regs
->regs
[PCOQ_HEAD_REGNUM
] = fp
+ 8;
794 frame_saved_regs
->regs
[PCSQ_HEAD_REGNUM
] = fp
+ 12;
795 frame_saved_regs
->regs
[PCOQ_TAIL_REGNUM
] = fp
+ 16;
796 frame_saved_regs
->regs
[PCSQ_TAIL_REGNUM
] = fp
+ 20;
802 register FRAME frame
= get_current_frame ();
803 register CORE_ADDR fp
;
805 struct frame_saved_regs fsr
;
806 struct frame_info
*fi
;
809 fi
= get_frame_info (frame
);
811 get_frame_saved_regs (fi
, &fsr
);
813 if (fsr
.regs
[IPSW_REGNUM
]) /* Restoring a call dummy frame */
814 restore_pc_queue (&fsr
);
816 for (regnum
= 31; regnum
> 0; regnum
--)
817 if (fsr
.regs
[regnum
])
818 write_register (regnum
, read_memory_integer (fsr
.regs
[regnum
], 4));
820 for (regnum
= NUM_REGS
- 1; regnum
>= FP0_REGNUM
; regnum
--)
821 if (fsr
.regs
[regnum
])
823 read_memory (fsr
.regs
[regnum
], (char *)&freg_buffer
, 8);
824 write_register_bytes (REGISTER_BYTE (regnum
), (char *)&freg_buffer
, 8);
827 if (fsr
.regs
[IPSW_REGNUM
])
828 write_register (IPSW_REGNUM
,
829 read_memory_integer (fsr
.regs
[IPSW_REGNUM
], 4));
831 if (fsr
.regs
[SAR_REGNUM
])
832 write_register (SAR_REGNUM
,
833 read_memory_integer (fsr
.regs
[SAR_REGNUM
], 4));
835 /* If the PC was explicitly saved, then just restore it. */
836 if (fsr
.regs
[PCOQ_TAIL_REGNUM
])
837 write_register (PCOQ_TAIL_REGNUM
,
838 read_memory_integer (fsr
.regs
[PCOQ_TAIL_REGNUM
], 4));
840 /* Else use the value in %rp to set the new PC. */
842 target_write_pc (read_register (RP_REGNUM
));
844 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
846 if (fsr
.regs
[IPSW_REGNUM
]) /* call dummy */
847 write_register (SP_REGNUM
, fp
- 48);
849 write_register (SP_REGNUM
, fp
);
851 flush_cached_frames ();
852 set_current_frame (create_new_frame (read_register (FP_REGNUM
),
857 * After returning to a dummy on the stack, restore the instruction
858 * queue space registers. */
861 restore_pc_queue (fsr
)
862 struct frame_saved_regs
*fsr
;
864 CORE_ADDR pc
= read_pc ();
865 CORE_ADDR new_pc
= read_memory_integer (fsr
->regs
[PCOQ_HEAD_REGNUM
], 4);
867 struct target_waitstatus w
;
870 /* Advance past break instruction in the call dummy. */
871 write_register (PCOQ_HEAD_REGNUM
, pc
+ 4);
872 write_register (PCOQ_TAIL_REGNUM
, pc
+ 8);
875 * HPUX doesn't let us set the space registers or the space
876 * registers of the PC queue through ptrace. Boo, hiss.
877 * Conveniently, the call dummy has this sequence of instructions
882 * So, load up the registers and single step until we are in the
886 write_register (21, read_memory_integer (fsr
->regs
[PCSQ_HEAD_REGNUM
], 4));
887 write_register (22, new_pc
);
889 for (insn_count
= 0; insn_count
< 3; insn_count
++)
891 /* FIXME: What if the inferior gets a signal right now? Want to
892 merge this into wait_for_inferior (as a special kind of
893 watchpoint? By setting a breakpoint at the end? Is there
894 any other choice? Is there *any* way to do this stuff with
895 ptrace() or some equivalent?). */
897 target_wait (inferior_pid
, &w
);
899 if (w
.kind
== TARGET_WAITKIND_SIGNALLED
)
901 stop_signal
= w
.value
.sig
;
902 terminal_ours_for_output ();
903 printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
904 target_signal_to_name (stop_signal
),
905 target_signal_to_string (stop_signal
));
906 gdb_flush (gdb_stdout
);
910 target_terminal_ours ();
911 fetch_inferior_registers (-1);
916 hppa_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
921 CORE_ADDR struct_addr
;
923 /* array of arguments' offsets */
924 int *offset
= (int *)alloca(nargs
* sizeof (int));
928 for (i
= 0; i
< nargs
; i
++)
930 /* Coerce chars to int & float to double if necessary */
931 args
[i
] = value_arg_coerce (args
[i
]);
933 cum
+= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
935 /* value must go at proper alignment. Assume alignment is a
937 alignment
= hppa_alignof (VALUE_TYPE (args
[i
]));
939 cum
= (cum
+ alignment
) & -alignment
;
942 sp
+= max ((cum
+ 7) & -8, 16);
944 for (i
= 0; i
< nargs
; i
++)
945 write_memory (sp
+ offset
[i
], VALUE_CONTENTS (args
[i
]),
946 TYPE_LENGTH (VALUE_TYPE (args
[i
])));
949 write_register (28, struct_addr
);
954 * Insert the specified number of args and function address
955 * into a call sequence of the above form stored at DUMMYNAME.
957 * On the hppa we need to call the stack dummy through $$dyncall.
958 * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
959 * real_pc, which is the location where gdb should start up the
960 * inferior to do the function call.
964 hppa_fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)
973 CORE_ADDR dyncall_addr
, sr4export_addr
;
974 struct minimal_symbol
*msymbol
;
975 int flags
= read_register (FLAGS_REGNUM
);
977 msymbol
= lookup_minimal_symbol ("$$dyncall", (struct objfile
*) NULL
);
979 error ("Can't find an address for $$dyncall trampoline");
981 dyncall_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
983 msymbol
= lookup_minimal_symbol ("_sr4export", (struct objfile
*) NULL
);
985 error ("Can't find an address for _sr4export trampoline");
987 sr4export_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
989 store_unsigned_integer
990 (&dummy
[9*REGISTER_SIZE
],
992 deposit_21 (fun
>> 11,
993 extract_unsigned_integer (&dummy
[9*REGISTER_SIZE
],
995 store_unsigned_integer
996 (&dummy
[10*REGISTER_SIZE
],
998 deposit_14 (fun
& MASK_11
,
999 extract_unsigned_integer (&dummy
[10*REGISTER_SIZE
],
1001 store_unsigned_integer
1002 (&dummy
[12*REGISTER_SIZE
],
1004 deposit_21 (sr4export_addr
>> 11,
1005 extract_unsigned_integer (&dummy
[12*REGISTER_SIZE
],
1007 store_unsigned_integer
1008 (&dummy
[13*REGISTER_SIZE
],
1010 deposit_14 (sr4export_addr
& MASK_11
,
1011 extract_unsigned_integer (&dummy
[13*REGISTER_SIZE
],
1014 write_register (22, pc
);
1016 /* If we are in a syscall, then we should call the stack dummy
1017 directly. $$dyncall is not needed as the kernel sets up the
1018 space id registers properly based on the value in %r31. In
1019 fact calling $$dyncall will not work because the value in %r22
1020 will be clobbered on the syscall exit path. */
1024 return dyncall_addr
;
1028 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1033 int flags
= read_register (FLAGS_REGNUM
);
1036 return read_register (31) & ~0x3;
1037 return read_register (PC_REGNUM
) & ~0x3;
1040 /* Write out the PC. If currently in a syscall, then also write the new
1041 PC value into %r31. */
1046 int flags
= read_register (FLAGS_REGNUM
);
1048 /* If in a syscall, then set %r31. Also make sure to get the
1049 privilege bits set correctly. */
1051 write_register (31, (long) (v
| 0x3));
1053 write_register (PC_REGNUM
, (long) v
);
1054 write_register (NPC_REGNUM
, (long) v
+ 4);
1057 /* return the alignment of a type in bytes. Structures have the maximum
1058 alignment required by their fields. */
1064 int max_align
, align
, i
;
1065 switch (TYPE_CODE (arg
))
1070 return TYPE_LENGTH (arg
);
1071 case TYPE_CODE_ARRAY
:
1072 return hppa_alignof (TYPE_FIELD_TYPE (arg
, 0));
1073 case TYPE_CODE_STRUCT
:
1074 case TYPE_CODE_UNION
:
1076 for (i
= 0; i
< TYPE_NFIELDS (arg
); i
++)
1078 /* Bit fields have no real alignment. */
1079 if (!TYPE_FIELD_BITPOS (arg
, i
))
1081 align
= hppa_alignof (TYPE_FIELD_TYPE (arg
, i
));
1082 max_align
= max (max_align
, align
);
1091 /* Print the register regnum, or all registers if regnum is -1 */
1093 pa_do_registers_info (regnum
, fpregs
)
1097 char raw_regs
[REGISTER_BYTES
];
1100 for (i
= 0; i
< NUM_REGS
; i
++)
1101 read_relative_register_raw_bytes (i
, raw_regs
+ REGISTER_BYTE (i
));
1103 pa_print_registers (raw_regs
, regnum
, fpregs
);
1104 else if (regnum
< FP0_REGNUM
)
1105 printf_unfiltered ("%s %x\n", reg_names
[regnum
], *(long *)(raw_regs
+
1106 REGISTER_BYTE (regnum
)));
1108 pa_print_fp_reg (regnum
);
1111 pa_print_registers (raw_regs
, regnum
, fpregs
)
1118 for (i
= 0; i
< 18; i
++)
1119 printf_unfiltered ("%8.8s: %8x %8.8s: %8x %8.8s: %8x %8.8s: %8x\n",
1121 *(int *)(raw_regs
+ REGISTER_BYTE (i
)),
1123 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 18)),
1125 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 36)),
1127 *(int *)(raw_regs
+ REGISTER_BYTE (i
+ 54)));
1130 for (i
= 72; i
< NUM_REGS
; i
++)
1131 pa_print_fp_reg (i
);
1137 unsigned char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1138 unsigned char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
1140 /* Get the data in raw format. */
1141 read_relative_register_raw_bytes (i
, raw_buffer
);
1143 /* Convert raw data to virtual format if necessary. */
1144 #ifdef REGISTER_CONVERTIBLE
1145 if (REGISTER_CONVERTIBLE (i
))
1147 REGISTER_CONVERT_TO_VIRTUAL (i
, REGISTER_VIRTUAL_TYPE (i
),
1148 raw_buffer
, virtual_buffer
);
1152 memcpy (virtual_buffer
, raw_buffer
,
1153 REGISTER_VIRTUAL_SIZE (i
));
1155 fputs_filtered (reg_names
[i
], gdb_stdout
);
1156 print_spaces_filtered (15 - strlen (reg_names
[i
]), gdb_stdout
);
1158 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, gdb_stdout
, 0,
1159 1, 0, Val_pretty_default
);
1160 printf_filtered ("\n");
1163 /* Function calls that pass into a new compilation unit must pass through a
1164 small piece of code that does long format (`external' in HPPA parlance)
1165 jumps. We figure out where the trampoline is going to end up, and return
1166 the PC of the final destination. If we aren't in a trampoline, we just
1169 For computed calls, we just extract the new PC from r22. */
1172 skip_trampoline_code (pc
, name
)
1177 static CORE_ADDR dyncall
= 0;
1178 struct minimal_symbol
*msym
;
1180 /* FIXME XXX - dyncall must be initialized whenever we get a new exec file */
1184 msym
= lookup_minimal_symbol ("$$dyncall", NULL
);
1186 dyncall
= SYMBOL_VALUE_ADDRESS (msym
);
1192 return (CORE_ADDR
)(read_register (22) & ~0x3);
1194 inst0
= read_memory_integer (pc
, 4);
1195 inst1
= read_memory_integer (pc
+4, 4);
1197 if ( (inst0
& 0xffe00000) == 0x20200000 /* ldil xxx, r1 */
1198 && (inst1
& 0xffe0e002) == 0xe0202002) /* be,n yyy(sr4, r1) */
1199 pc
= extract_21 (inst0
) + extract_17 (inst1
);
1201 pc
= (CORE_ADDR
)NULL
;
1206 /* Advance PC across any function entry prologue instructions
1207 to reach some "real" code. */
1209 /* skip (stw rp, -20(0,sp)); copy 4,1; copy sp, 4; stwm 1,framesize(sp)
1210 for gcc, or (stw rp, -20(0,sp); stwm 1, framesize(sp) for hcc */
1220 status
= target_read_memory (pc
, buf
, 4);
1221 inst
= extract_unsigned_integer (buf
, 4);
1225 if (inst
== 0x6BC23FD9) /* stw rp,-20(sp) */
1227 if (read_memory_integer (pc
+ 4, 4) == 0x8030241) /* copy r3,r1 */
1229 else if ((read_memory_integer (pc
+ 4, 4) & ~MASK_14
) == 0x68710000) /* stw r1,(r3) */
1232 else if (read_memory_integer (pc
, 4) == 0x8030241) /* copy r3,r1 */
1234 else if ((read_memory_integer (pc
, 4) & ~MASK_14
) == 0x68710000) /* stw r1,(r3) */
1240 #ifdef MAINTENANCE_CMDS
1243 unwind_command (exp
, from_tty
)
1251 struct unwind_table_entry
*u
;
1254 /* If we have an expression, evaluate it and use it as the address. */
1256 if (exp
!= 0 && *exp
!= 0)
1257 address
= parse_and_eval_address (exp
);
1261 xxx
.u
= find_unwind_entry (address
);
1265 printf_unfiltered ("Can't find unwind table entry for PC 0x%x\n", address
);
1269 printf_unfiltered ("%08x\n%08X\n%08X\n%08X\n", xxx
.foo
[0], xxx
.foo
[1], xxx
.foo
[2],
1272 #endif /* MAINTENANCE_CMDS */
1275 _initialize_hppa_tdep ()
1277 #ifdef MAINTENANCE_CMDS
1278 add_cmd ("unwind", class_maintenance
, unwind_command
,
1279 "Print unwind table entry at given address.",
1280 &maintenanceprintlist
);
1281 #endif /* MAINTENANCE_CMDS */