1 /* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
25 #include "frame-unwind.h"
26 #include "frame-base.h"
35 #include "gdb_string.h"
38 #include "reggroups.h"
39 #include "arch-utils.h"
45 #include "alpha-tdep.h"
49 alpha_register_name (int regno
)
51 static const char * const register_names
[] =
53 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
54 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
55 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
56 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
57 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
58 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
59 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
60 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
66 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
68 return register_names
[regno
];
72 alpha_cannot_fetch_register (int regno
)
74 return regno
== ALPHA_ZERO_REGNUM
;
78 alpha_cannot_store_register (int regno
)
80 return regno
== ALPHA_ZERO_REGNUM
;
84 alpha_register_convertible (int regno
)
86 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
90 alpha_register_virtual_type (int regno
)
92 if (regno
== ALPHA_SP_REGNUM
|| regno
== ALPHA_GP_REGNUM
)
93 return builtin_type_void_data_ptr
;
94 if (regno
== ALPHA_PC_REGNUM
)
95 return builtin_type_void_func_ptr
;
97 /* Don't need to worry about little vs big endian until
98 some jerk tries to port to alpha-unicosmk. */
99 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 31)
100 return builtin_type_ieee_double_little
;
102 return builtin_type_int64
;
105 /* Is REGNUM a member of REGGROUP? */
108 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
109 struct reggroup
*group
)
111 /* Filter out any registers eliminated, but whose regnum is
112 reserved for backward compatibility, e.g. the vfp. */
113 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
116 /* Since we implement no pseudo registers, save/restore is equal to all. */
117 if (group
== all_reggroup
118 || group
== save_reggroup
119 || group
== restore_reggroup
)
122 /* All other groups are non-overlapping. */
124 /* Since this is really a PALcode memory slot... */
125 if (regnum
== ALPHA_UNIQUE_REGNUM
)
126 return group
== system_reggroup
;
128 /* Force the FPCR to be considered part of the floating point state. */
129 if (regnum
== ALPHA_FPCR_REGNUM
)
130 return group
== float_reggroup
;
132 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
133 return group
== float_reggroup
;
135 return group
== general_reggroup
;
139 alpha_register_byte (int regno
)
145 alpha_register_raw_size (int regno
)
151 alpha_register_virtual_size (int regno
)
156 /* The alpha needs a conversion between register and memory format if the
157 register is a floating point register and memory format is float, as the
158 register format must be double or memory format is an integer with 4
159 bytes or less, as the representation of integers in floating point
160 registers is different. */
163 alpha_convert_flt_dbl (void *out
, const void *in
)
165 DOUBLEST d
= extract_typed_floating (in
, builtin_type_ieee_single_little
);
166 store_typed_floating (out
, builtin_type_ieee_double_little
, d
);
170 alpha_convert_dbl_flt (void *out
, const void *in
)
172 DOUBLEST d
= extract_typed_floating (in
, builtin_type_ieee_double_little
);
173 store_typed_floating (out
, builtin_type_ieee_single_little
, d
);
177 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
178 char *raw_buffer
, char *virtual_buffer
)
180 if (TYPE_LENGTH (valtype
) >= ALPHA_REGISTER_SIZE
)
182 memcpy (virtual_buffer
, raw_buffer
, ALPHA_REGISTER_SIZE
);
186 /* Note that everything below is less than 8 bytes long. */
188 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
189 alpha_convert_dbl_flt (virtual_buffer
, raw_buffer
);
190 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
)
193 l
= extract_unsigned_integer (raw_buffer
, ALPHA_REGISTER_SIZE
);
194 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
195 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
198 error ("Cannot retrieve value from floating point register");
202 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
203 char *virtual_buffer
, char *raw_buffer
)
205 if (TYPE_LENGTH (valtype
) >= ALPHA_REGISTER_SIZE
)
207 memcpy (raw_buffer
, virtual_buffer
, ALPHA_REGISTER_SIZE
);
211 /* Note that everything below is less than 8 bytes long. */
213 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
214 alpha_convert_flt_dbl (raw_buffer
, virtual_buffer
);
215 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
)
217 ULONGEST l
= unpack_long (valtype
, virtual_buffer
);
218 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
219 store_unsigned_integer (raw_buffer
, ALPHA_REGISTER_SIZE
, l
);
222 error ("Cannot store value in floating point register");
226 /* The alpha passes the first six arguments in the registers, the rest on
227 the stack. The register arguments are stored in ARG_REG_BUFFER, and
228 then moved into the register file; this simplifies the passing of a
229 large struct which extends from the registers to the stack, plus avoids
230 three ptrace invocations per word.
232 We don't bother tracking which register values should go in integer
233 regs or fp regs; we load the same values into both.
235 If the called function is returning a structure, the address of the
236 structure to be returned is passed as a hidden first argument. */
239 alpha_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
240 struct regcache
*regcache
, CORE_ADDR bp_addr
,
241 int nargs
, struct value
**args
, CORE_ADDR sp
,
242 int struct_return
, CORE_ADDR struct_addr
)
245 int accumulate_size
= struct_return
? 8 : 0;
252 struct alpha_arg
*alpha_args
253 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
254 register struct alpha_arg
*m_arg
;
255 char arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
256 int required_arg_regs
;
258 /* The ABI places the address of the called function in T12. */
259 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
261 /* Set the return address register to point to the entry point
262 of the program, where a breakpoint lies in wait. */
263 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
265 /* Lay out the arguments in memory. */
266 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
268 struct value
*arg
= args
[i
];
269 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
271 /* Cast argument to long if necessary as the compiler does it too. */
272 switch (TYPE_CODE (arg_type
))
277 case TYPE_CODE_RANGE
:
279 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
281 arg_type
= builtin_type_long
;
282 arg
= value_cast (arg_type
, arg
);
287 /* "float" arguments loaded in registers must be passed in
288 register format, aka "double". */
289 if (accumulate_size
< sizeof (arg_reg_buffer
)
290 && TYPE_LENGTH (arg_type
) == 4)
292 arg_type
= builtin_type_double
;
293 arg
= value_cast (arg_type
, arg
);
295 /* Tru64 5.1 has a 128-bit long double, and passes this by
296 invisible reference. No one else uses this data type. */
297 else if (TYPE_LENGTH (arg_type
) == 16)
299 /* Allocate aligned storage. */
300 sp
= (sp
& -16) - 16;
302 /* Write the real data into the stack. */
303 write_memory (sp
, VALUE_CONTENTS (arg
), 16);
305 /* Construct the indirection. */
306 arg_type
= lookup_pointer_type (arg_type
);
307 arg
= value_from_pointer (arg_type
, sp
);
311 case TYPE_CODE_COMPLEX
:
312 /* ??? The ABI says that complex values are passed as two
313 separate scalar values. This distinction only matters
314 for complex float. However, GCC does not implement this. */
316 /* Tru64 5.1 has a 128-bit long double, and passes this by
317 invisible reference. */
318 if (TYPE_LENGTH (arg_type
) == 32)
320 /* Allocate aligned storage. */
321 sp
= (sp
& -16) - 16;
323 /* Write the real data into the stack. */
324 write_memory (sp
, VALUE_CONTENTS (arg
), 32);
326 /* Construct the indirection. */
327 arg_type
= lookup_pointer_type (arg_type
);
328 arg
= value_from_pointer (arg_type
, sp
);
335 m_arg
->len
= TYPE_LENGTH (arg_type
);
336 m_arg
->offset
= accumulate_size
;
337 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
338 m_arg
->contents
= VALUE_CONTENTS (arg
);
341 /* Determine required argument register loads, loading an argument register
342 is expensive as it uses three ptrace calls. */
343 required_arg_regs
= accumulate_size
/ 8;
344 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
345 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
347 /* Make room for the arguments on the stack. */
348 if (accumulate_size
< sizeof(arg_reg_buffer
))
351 accumulate_size
-= sizeof(arg_reg_buffer
);
352 sp
-= accumulate_size
;
354 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
357 /* `Push' arguments on the stack. */
358 for (i
= nargs
; m_arg
--, --i
>= 0;)
360 char *contents
= m_arg
->contents
;
361 int offset
= m_arg
->offset
;
362 int len
= m_arg
->len
;
364 /* Copy the bytes destined for registers into arg_reg_buffer. */
365 if (offset
< sizeof(arg_reg_buffer
))
367 if (offset
+ len
<= sizeof(arg_reg_buffer
))
369 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
374 int tlen
= sizeof(arg_reg_buffer
) - offset
;
375 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
382 /* Everything else goes to the stack. */
383 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
386 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
388 /* Load the argument registers. */
389 for (i
= 0; i
< required_arg_regs
; i
++)
391 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
392 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
393 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
394 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
397 /* Finally, update the stack pointer. */
398 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
403 /* Extract from REGCACHE the value about to be returned from a function
404 and copy it into VALBUF. */
407 alpha_extract_return_value (struct type
*valtype
, struct regcache
*regcache
,
410 int length
= TYPE_LENGTH (valtype
);
411 char raw_buffer
[ALPHA_REGISTER_SIZE
];
414 switch (TYPE_CODE (valtype
))
420 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
421 alpha_convert_dbl_flt (valbuf
, raw_buffer
);
425 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
429 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
430 read_memory (l
, valbuf
, 16);
438 case TYPE_CODE_COMPLEX
:
442 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
443 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
447 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
448 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
+1,
453 regcache_cooked_read_signed (regcache
, ALPHA_V0_REGNUM
, &l
);
454 read_memory (l
, valbuf
, 32);
463 /* Assume everything else degenerates to an integer. */
464 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
465 store_unsigned_integer (valbuf
, length
, l
);
470 /* Extract from REGCACHE the address of a structure about to be returned
474 alpha_extract_struct_value_address (struct regcache
*regcache
)
477 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
481 /* Insert the given value into REGCACHE as if it was being
482 returned by a function. */
485 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
488 int length
= TYPE_LENGTH (valtype
);
489 char raw_buffer
[ALPHA_REGISTER_SIZE
];
492 switch (TYPE_CODE (valtype
))
498 alpha_convert_flt_dbl (raw_buffer
, valbuf
);
503 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
507 /* FIXME: 128-bit long doubles are returned like structures:
508 by writing into indirect storage provided by the caller
509 as the first argument. */
510 error ("Cannot set a 128-bit long double return value.");
517 case TYPE_CODE_COMPLEX
:
521 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
522 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
526 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
527 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
+1,
528 (const char *)valbuf
+ 8);
532 /* FIXME: 128-bit long doubles are returned like structures:
533 by writing into indirect storage provided by the caller
534 as the first argument. */
535 error ("Cannot set a 128-bit long double return value.");
543 /* Assume everything else degenerates to an integer. */
544 l
= unpack_long (valtype
, valbuf
);
545 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
551 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
553 /* Structures are returned by ref in extra arg0. */
558 static const unsigned char *
559 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
561 static const unsigned char alpha_breakpoint
[] =
562 { 0x80, 0, 0, 0 }; /* call_pal bpt */
564 *lenptr
= sizeof(alpha_breakpoint
);
565 return (alpha_breakpoint
);
569 /* This returns the PC of the first insn after the prologue.
570 If we can't find the prologue, then return 0. */
573 alpha_after_prologue (CORE_ADDR pc
)
575 struct symtab_and_line sal
;
576 CORE_ADDR func_addr
, func_end
;
578 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
581 sal
= find_pc_line (func_addr
, 0);
582 if (sal
.end
< func_end
)
585 /* The line after the prologue is after the end of the function. In this
586 case, tell the caller to find the prologue the hard way. */
590 /* Read an instruction from memory at PC, looking through breakpoints. */
593 alpha_read_insn (CORE_ADDR pc
)
598 status
= read_memory_nobpt (pc
, buf
, 4);
600 memory_error (status
, pc
);
601 return extract_unsigned_integer (buf
, 4);
604 /* To skip prologues, I use this predicate. Returns either PC itself
605 if the code at PC does not look like a function prologue; otherwise
606 returns an address that (if we're lucky) follows the prologue. If
607 LENIENT, then we must skip everything which is involved in setting
608 up the frame (it's OK to skip more, just so long as we don't skip
609 anything which might clobber the registers which are being saved. */
612 alpha_skip_prologue (CORE_ADDR pc
)
616 CORE_ADDR post_prologue_pc
;
619 /* Silently return the unaltered pc upon memory errors.
620 This could happen on OSF/1 if decode_line_1 tries to skip the
621 prologue for quickstarted shared library functions when the
622 shared library is not yet mapped in.
623 Reading target memory is slow over serial lines, so we perform
624 this check only if the target has shared libraries (which all
625 Alpha targets do). */
626 if (target_read_memory (pc
, buf
, 4))
629 /* See if we can determine the end of the prologue via the symbol table.
630 If so, then return either PC, or the PC after the prologue, whichever
633 post_prologue_pc
= alpha_after_prologue (pc
);
634 if (post_prologue_pc
!= 0)
635 return max (pc
, post_prologue_pc
);
637 /* Can't determine prologue from the symbol table, need to examine
640 /* Skip the typical prologue instructions. These are the stack adjustment
641 instruction and the instructions that save registers on the stack
642 or in the gcc frame. */
643 for (offset
= 0; offset
< 100; offset
+= 4)
645 inst
= alpha_read_insn (pc
+ offset
);
647 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
649 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
651 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
653 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
656 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
657 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
658 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
661 if (inst
== 0x47de040f) /* bis sp,sp,fp */
663 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
672 /* Figure out where the longjmp will land.
673 We expect the first arg to be a pointer to the jmp_buf structure from
674 which we extract the PC (JB_PC) that we will land at. The PC is copied
675 into the "pc". This routine returns true on success. */
678 alpha_get_longjmp_target (CORE_ADDR
*pc
)
680 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
682 char raw_buffer
[ALPHA_REGISTER_SIZE
];
684 jb_addr
= read_register (ALPHA_A0_REGNUM
);
686 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
687 raw_buffer
, tdep
->jb_elt_size
))
690 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
695 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
696 describe the location and shape of the sigcontext structure. After
697 that, all registers are in memory, so it's easy. */
698 /* ??? Shouldn't we be able to do this generically, rather than with
699 OSABI data specific to Alpha? */
701 struct alpha_sigtramp_unwind_cache
703 CORE_ADDR sigcontext_addr
;
706 static struct alpha_sigtramp_unwind_cache
*
707 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
708 void **this_prologue_cache
)
710 struct alpha_sigtramp_unwind_cache
*info
;
711 struct gdbarch_tdep
*tdep
;
713 if (*this_prologue_cache
)
714 return *this_prologue_cache
;
716 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
717 *this_prologue_cache
= info
;
719 tdep
= gdbarch_tdep (current_gdbarch
);
720 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
725 /* Return the address of REGNO in a sigtramp frame. Since this is all
726 arithmetic, it doesn't seem worthwhile to cache it. */
728 #ifndef SIGFRAME_PC_OFF
729 #define SIGFRAME_PC_OFF (2 * 8)
730 #define SIGFRAME_REGSAVE_OFF (4 * 8)
731 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
735 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, unsigned int regno
)
738 return sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ regno
* 8;
739 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
740 return sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ regno
* 8;
741 if (regno
== PC_REGNUM
)
742 return sigcontext_addr
+ SIGFRAME_PC_OFF
;
747 /* Given a GDB frame, determine the address of the calling function's
748 frame. This will be used to create a new GDB frame struct. */
751 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
752 void **this_prologue_cache
,
753 struct frame_id
*this_id
)
755 struct alpha_sigtramp_unwind_cache
*info
756 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
757 struct gdbarch_tdep
*tdep
;
758 CORE_ADDR stack_addr
, code_addr
;
760 /* If the OSABI couldn't locate the sigcontext, give up. */
761 if (info
->sigcontext_addr
== 0)
764 /* If we have dynamic signal trampolines, find their start.
765 If we do not, then we must assume there is a symbol record
766 that can provide the start address. */
767 tdep
= gdbarch_tdep (current_gdbarch
);
768 if (tdep
->dynamic_sigtramp_offset
)
771 code_addr
= frame_pc_unwind (next_frame
);
772 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
779 code_addr
= frame_func_unwind (next_frame
);
781 /* The stack address is trivially read from the sigcontext. */
782 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
784 stack_addr
= read_memory_unsigned_integer (stack_addr
, ALPHA_REGISTER_SIZE
);
786 *this_id
= frame_id_build (stack_addr
, code_addr
);
789 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
792 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
793 void **this_prologue_cache
,
794 int regnum
, int *optimizedp
,
795 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
796 int *realnump
, void *bufferp
)
798 struct alpha_sigtramp_unwind_cache
*info
799 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
802 if (info
->sigcontext_addr
!= 0)
804 /* All integer and fp registers are stored in memory. */
805 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
809 *lvalp
= lval_memory
;
813 read_memory (addr
, bufferp
, ALPHA_REGISTER_SIZE
);
818 /* This extra register may actually be in the sigcontext, but our
819 current description of it in alpha_sigtramp_frame_unwind_cache
820 doesn't include it. Too bad. Fall back on whatever's in the
822 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
826 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
828 alpha_sigtramp_frame_this_id
,
829 alpha_sigtramp_frame_prev_register
832 static const struct frame_unwind
*
833 alpha_sigtramp_frame_p (CORE_ADDR pc
)
837 /* We shouldn't even bother to try if the OSABI didn't register
838 a sigcontext_addr handler. */
839 if (!gdbarch_tdep (current_gdbarch
)->sigcontext_addr
)
842 /* Otherwise we should be in a signal frame. */
843 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
844 if (PC_IN_SIGTRAMP (pc
, name
))
845 return &alpha_sigtramp_frame_unwind
;
850 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
851 something about the traditional layout of alpha stack frames. */
853 struct alpha_heuristic_unwind_cache
855 CORE_ADDR
*saved_regs
;
861 /* Heuristic_proc_start may hunt through the text section for a long
862 time across a 2400 baud serial line. Allows the user to limit this
864 static unsigned int heuristic_fence_post
= 0;
866 /* Attempt to locate the start of the function containing PC. We assume that
867 the previous function ends with an about_to_return insn. Not foolproof by
868 any means, since gcc is happy to put the epilogue in the middle of a
869 function. But we're guessing anyway... */
872 alpha_heuristic_proc_start (CORE_ADDR pc
)
874 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
875 CORE_ADDR last_non_nop
= pc
;
876 CORE_ADDR fence
= pc
- heuristic_fence_post
;
877 CORE_ADDR orig_pc
= pc
;
883 /* First see if we can find the start of the function from minimal
884 symbol information. This can succeed with a binary that doesn't
885 have debug info, but hasn't been stripped. */
886 func
= get_pc_function_start (pc
);
890 if (heuristic_fence_post
== UINT_MAX
891 || fence
< tdep
->vm_min_address
)
892 fence
= tdep
->vm_min_address
;
894 /* Search back for previous return; also stop at a 0, which might be
895 seen for instance before the start of a code section. Don't include
896 nops, since this usually indicates padding between functions. */
897 for (pc
-= 4; pc
>= fence
; pc
-= 4)
899 unsigned int insn
= alpha_read_insn (pc
);
902 case 0: /* invalid insn */
903 case 0x6bfa8001: /* ret $31,($26),1 */
906 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
907 case 0x47ff041f: /* nop: bis $31,$31,$31 */
916 /* It's not clear to me why we reach this point when stopping quietly,
917 but with this test, at least we don't print out warnings for every
918 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
919 if (stop_soon
== NO_STOP_QUIETLY
)
921 static int blurb_printed
= 0;
923 if (fence
== tdep
->vm_min_address
)
924 warning ("Hit beginning of text section without finding");
926 warning ("Hit heuristic-fence-post without finding");
927 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
932 This warning occurs if you are debugging a function without any symbols\n\
933 (for example, in a stripped executable). In that case, you may wish to\n\
934 increase the size of the search with the `set heuristic-fence-post' command.\n\
936 Otherwise, you told GDB there was a function where there isn't one, or\n\
937 (more likely) you have encountered a bug in GDB.\n");
945 static struct alpha_heuristic_unwind_cache
*
946 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
947 void **this_prologue_cache
,
950 struct alpha_heuristic_unwind_cache
*info
;
952 CORE_ADDR limit_pc
, cur_pc
;
953 int frame_reg
, frame_size
, return_reg
, reg
;
955 if (*this_prologue_cache
)
956 return *this_prologue_cache
;
958 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
959 *this_prologue_cache
= info
;
960 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
962 limit_pc
= frame_pc_unwind (next_frame
);
964 start_pc
= alpha_heuristic_proc_start (limit_pc
);
965 info
->start_pc
= start_pc
;
967 frame_reg
= ALPHA_SP_REGNUM
;
971 /* If we've identified a likely place to start, do code scanning. */
974 /* Limit the forward search to 50 instructions. */
975 if (start_pc
+ 200 < limit_pc
)
976 limit_pc
= start_pc
+ 200;
978 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
980 unsigned int word
= alpha_read_insn (cur_pc
);
982 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
986 /* Consider only the first stack allocation instruction
987 to contain the static size of the frame. */
989 frame_size
= (-word
) & 0xffff;
993 /* Exit loop if a positive stack adjustment is found, which
994 usually means that the stack cleanup code in the function
995 epilogue is reached. */
999 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1001 reg
= (word
& 0x03e00000) >> 21;
1006 /* Do not compute the address where the register was saved yet,
1007 because we don't know yet if the offset will need to be
1008 relative to $sp or $fp (we can not compute the address
1009 relative to $sp if $sp is updated during the execution of
1010 the current subroutine, for instance when doing some alloca).
1011 So just store the offset for the moment, and compute the
1012 address later when we know whether this frame has a frame
1014 /* Hack: temporarily add one, so that the offset is non-zero
1015 and we can tell which registers have save offsets below. */
1016 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
1018 /* Starting with OSF/1-3.2C, the system libraries are shipped
1019 without local symbols, but they still contain procedure
1020 descriptors without a symbol reference. GDB is currently
1021 unable to find these procedure descriptors and uses
1022 heuristic_proc_desc instead.
1023 As some low level compiler support routines (__div*, __add*)
1024 use a non-standard return address register, we have to
1025 add some heuristics to determine the return address register,
1026 or stepping over these routines will fail.
1027 Usually the return address register is the first register
1028 saved on the stack, but assembler optimization might
1029 rearrange the register saves.
1030 So we recognize only a few registers (t7, t9, ra) within
1031 the procedure prologue as valid return address registers.
1032 If we encounter a return instruction, we extract the
1033 the return address register from it.
1035 FIXME: Rewriting GDB to access the procedure descriptors,
1036 e.g. via the minimal symbol table, might obviate this hack. */
1037 if (return_reg
== -1
1038 && cur_pc
< (start_pc
+ 80)
1039 && (reg
== ALPHA_T7_REGNUM
1040 || reg
== ALPHA_T9_REGNUM
1041 || reg
== ALPHA_RA_REGNUM
))
1044 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1045 return_reg
= (word
>> 16) & 0x1f;
1046 else if (word
== 0x47de040f) /* bis sp,sp,fp */
1047 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1048 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
1049 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1052 /* If we haven't found a valid return address register yet, keep
1053 searching in the procedure prologue. */
1054 if (return_reg
== -1)
1056 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
1058 unsigned int word
= alpha_read_insn (cur_pc
);
1060 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1062 reg
= (word
& 0x03e00000) >> 21;
1063 if (reg
== ALPHA_T7_REGNUM
1064 || reg
== ALPHA_T9_REGNUM
1065 || reg
== ALPHA_RA_REGNUM
)
1071 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1073 return_reg
= (word
>> 16) & 0x1f;
1082 /* Failing that, do default to the customary RA. */
1083 if (return_reg
== -1)
1084 return_reg
= ALPHA_RA_REGNUM
;
1085 info
->return_reg
= return_reg
;
1087 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
1088 info
->vfp
= val
+ frame_size
;
1090 /* Convert offsets to absolute addresses. See above about adding
1091 one to the offsets to make all detected offsets non-zero. */
1092 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1093 if (info
->saved_regs
[reg
])
1094 info
->saved_regs
[reg
] += val
- 1;
1099 /* Given a GDB frame, determine the address of the calling function's
1100 frame. This will be used to create a new GDB frame struct. */
1103 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
1104 void **this_prologue_cache
,
1105 struct frame_id
*this_id
)
1107 struct alpha_heuristic_unwind_cache
*info
1108 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1110 /* This is meant to halt the backtrace at "_start". Make sure we
1111 don't halt it at a generic dummy frame. */
1112 if (inside_entry_file (info
->start_pc
))
1115 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1118 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1121 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
1122 void **this_prologue_cache
,
1123 int regnum
, int *optimizedp
,
1124 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1125 int *realnump
, void *bufferp
)
1127 struct alpha_heuristic_unwind_cache
*info
1128 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1130 /* The PC of the previous frame is stored in the link register of
1131 the current frame. Frob regnum so that we pull the value from
1132 the correct place. */
1133 if (regnum
== ALPHA_PC_REGNUM
)
1134 regnum
= info
->return_reg
;
1136 /* For all registers known to be saved in the current frame,
1137 do the obvious and pull the value out. */
1138 if (info
->saved_regs
[regnum
])
1141 *lvalp
= lval_memory
;
1142 *addrp
= info
->saved_regs
[regnum
];
1144 if (bufferp
!= NULL
)
1145 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1149 /* The stack pointer of the previous frame is computed by popping
1150 the current stack frame. */
1151 if (regnum
== ALPHA_SP_REGNUM
)
1157 if (bufferp
!= NULL
)
1158 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1162 /* Otherwise assume the next frame has the same register value. */
1163 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1167 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1169 alpha_heuristic_frame_this_id
,
1170 alpha_heuristic_frame_prev_register
1173 static const struct frame_unwind
*
1174 alpha_heuristic_frame_p (CORE_ADDR pc
)
1176 return &alpha_heuristic_frame_unwind
;
1180 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1181 void **this_prologue_cache
)
1183 struct alpha_heuristic_unwind_cache
*info
1184 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1189 static const struct frame_base alpha_heuristic_frame_base
= {
1190 &alpha_heuristic_frame_unwind
,
1191 alpha_heuristic_frame_base_address
,
1192 alpha_heuristic_frame_base_address
,
1193 alpha_heuristic_frame_base_address
1196 /* Just like reinit_frame_cache, but with the right arguments to be
1197 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1200 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1202 reinit_frame_cache ();
1206 /* ALPHA stack frames are almost impenetrable. When execution stops,
1207 we basically have to look at symbol information for the function
1208 that we stopped in, which tells us *which* register (if any) is
1209 the base of the frame pointer, and what offset from that register
1210 the frame itself is at.
1212 This presents a problem when trying to examine a stack in memory
1213 (that isn't executing at the moment), using the "frame" command. We
1214 don't have a PC, nor do we have any registers except SP.
1216 This routine takes two arguments, SP and PC, and tries to make the
1217 cached frames look as if these two arguments defined a frame on the
1218 cache. This allows the rest of info frame to extract the important
1219 arguments without difficulty. */
1222 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1225 error ("ALPHA frame specifications require two arguments: sp and pc");
1227 return create_new_frame (argv
[0], argv
[1]);
1230 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1231 dummy frame. The frame ID's base needs to match the TOS value
1232 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1235 static struct frame_id
1236 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1239 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1240 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1244 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1247 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1252 /* alpha_software_single_step() is called just before we want to resume
1253 the inferior, if we want to single-step it but there is no hardware
1254 or kernel single-step support (NetBSD on Alpha, for example). We find
1255 the target of the coming instruction and breakpoint it.
1257 single_step is also called just after the inferior stops. If we had
1258 set up a simulated single-step, we undo our damage. */
1261 alpha_next_pc (CORE_ADDR pc
)
1268 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1270 /* Opcode is top 6 bits. */
1271 op
= (insn
>> 26) & 0x3f;
1275 /* Jump format: target PC is:
1277 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1280 if ((op
& 0x30) == 0x30)
1282 /* Branch format: target PC is:
1283 (new PC) + (4 * sext(displacement)) */
1284 if (op
== 0x30 || /* BR */
1285 op
== 0x34) /* BSR */
1288 offset
= (insn
& 0x001fffff);
1289 if (offset
& 0x00100000)
1290 offset
|= 0xffe00000;
1292 return (pc
+ 4 + offset
);
1295 /* Need to determine if branch is taken; read RA. */
1296 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1299 case 0x38: /* BLBC */
1303 case 0x3c: /* BLBS */
1307 case 0x39: /* BEQ */
1311 case 0x3d: /* BNE */
1315 case 0x3a: /* BLT */
1319 case 0x3b: /* BLE */
1323 case 0x3f: /* BGT */
1327 case 0x3e: /* BGE */
1332 /* ??? Missing floating-point branches. */
1336 /* Not a branch or branch not taken; target PC is:
1342 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1344 static CORE_ADDR next_pc
;
1345 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1346 static binsn_quantum break_mem
;
1349 if (insert_breakpoints_p
)
1352 next_pc
= alpha_next_pc (pc
);
1354 target_insert_breakpoint (next_pc
, break_mem
);
1358 target_remove_breakpoint (next_pc
, break_mem
);
1364 /* Initialize the current architecture based on INFO. If possible, re-use an
1365 architecture from ARCHES, which is a list of architectures already created
1366 during this debugging session.
1368 Called e.g. at program startup, when reading a core file, and when reading
1371 static struct gdbarch
*
1372 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1374 struct gdbarch_tdep
*tdep
;
1375 struct gdbarch
*gdbarch
;
1377 /* Try to determine the ABI of the object we are loading. */
1378 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1380 /* If it's an ECOFF file, assume it's OSF/1. */
1381 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1382 info
.osabi
= GDB_OSABI_OSF1
;
1385 /* Find a candidate among extant architectures. */
1386 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1388 return arches
->gdbarch
;
1390 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1391 gdbarch
= gdbarch_alloc (&info
, tdep
);
1393 /* Lowest text address. This is used by heuristic_proc_start()
1394 to decide when to stop looking. */
1395 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1397 tdep
->dynamic_sigtramp_offset
= NULL
;
1398 tdep
->sigcontext_addr
= NULL
;
1400 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1403 set_gdbarch_short_bit (gdbarch
, 16);
1404 set_gdbarch_int_bit (gdbarch
, 32);
1405 set_gdbarch_long_bit (gdbarch
, 64);
1406 set_gdbarch_long_long_bit (gdbarch
, 64);
1407 set_gdbarch_float_bit (gdbarch
, 32);
1408 set_gdbarch_double_bit (gdbarch
, 64);
1409 set_gdbarch_long_double_bit (gdbarch
, 64);
1410 set_gdbarch_ptr_bit (gdbarch
, 64);
1413 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1414 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1415 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1416 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1418 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1419 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1420 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1421 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1422 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1424 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1425 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1427 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1428 set_gdbarch_register_convert_to_virtual (gdbarch
,
1429 alpha_register_convert_to_virtual
);
1430 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1432 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1434 /* Prologue heuristics. */
1435 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1438 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1441 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1442 set_gdbarch_frameless_function_invocation (gdbarch
,
1443 generic_frameless_function_invocation_not
);
1445 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1446 set_gdbarch_extract_return_value (gdbarch
, alpha_extract_return_value
);
1447 set_gdbarch_store_return_value (gdbarch
, alpha_store_return_value
);
1448 set_gdbarch_extract_struct_value_address (gdbarch
,
1449 alpha_extract_struct_value_address
);
1451 /* Settings for calling functions in the inferior. */
1452 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1454 /* Methods for saving / extracting a dummy frame's ID. */
1455 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1456 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1458 /* Return the unwound PC value. */
1459 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1461 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1462 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1464 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1465 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1467 set_gdbarch_function_start_offset (gdbarch
, 0);
1468 set_gdbarch_frame_args_skip (gdbarch
, 0);
1470 /* Hook in ABI-specific overrides, if they have been registered. */
1471 gdbarch_init_osabi (info
, gdbarch
);
1473 /* Now that we have tuned the configuration, set a few final things
1474 based on what the OS ABI has told us. */
1476 if (tdep
->jb_pc
>= 0)
1477 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1479 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1480 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1482 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1488 _initialize_alpha_tdep (void)
1490 struct cmd_list_element
*c
;
1492 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1494 /* Let the user set the fence post for heuristic_proc_start. */
1496 /* We really would like to have both "0" and "unlimited" work, but
1497 command.c doesn't deal with that. So make it a var_zinteger
1498 because the user can always use "999999" or some such for unlimited. */
1499 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1500 (char *) &heuristic_fence_post
,
1502 Set the distance searched for the start of a function.\n\
1503 If you are debugging a stripped executable, GDB needs to search through the\n\
1504 program for the start of a function. This command sets the distance of the\n\
1505 search. The only need to set it is when debugging a stripped executable.",
1507 /* We need to throw away the frame cache when we set this, since it
1508 might change our ability to get backtraces. */
1509 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1510 add_show_from_set (c
, &showlist
);