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
) == 4)
281 /* 32-bit values must be sign-extended to 64 bits
282 even if the base data type is unsigned. */
283 arg_type
= builtin_type_int32
;
284 arg
= value_cast (arg_type
, arg
);
286 if (TYPE_LENGTH (arg_type
) < ALPHA_REGISTER_SIZE
)
288 arg_type
= builtin_type_int64
;
289 arg
= value_cast (arg_type
, arg
);
294 /* "float" arguments loaded in registers must be passed in
295 register format, aka "double". */
296 if (accumulate_size
< sizeof (arg_reg_buffer
)
297 && TYPE_LENGTH (arg_type
) == 4)
299 arg_type
= builtin_type_ieee_double_little
;
300 arg
= value_cast (arg_type
, arg
);
302 /* Tru64 5.1 has a 128-bit long double, and passes this by
303 invisible reference. No one else uses this data type. */
304 else if (TYPE_LENGTH (arg_type
) == 16)
306 /* Allocate aligned storage. */
307 sp
= (sp
& -16) - 16;
309 /* Write the real data into the stack. */
310 write_memory (sp
, VALUE_CONTENTS (arg
), 16);
312 /* Construct the indirection. */
313 arg_type
= lookup_pointer_type (arg_type
);
314 arg
= value_from_pointer (arg_type
, sp
);
318 case TYPE_CODE_COMPLEX
:
319 /* ??? The ABI says that complex values are passed as two
320 separate scalar values. This distinction only matters
321 for complex float. However, GCC does not implement this. */
323 /* Tru64 5.1 has a 128-bit long double, and passes this by
324 invisible reference. */
325 if (TYPE_LENGTH (arg_type
) == 32)
327 /* Allocate aligned storage. */
328 sp
= (sp
& -16) - 16;
330 /* Write the real data into the stack. */
331 write_memory (sp
, VALUE_CONTENTS (arg
), 32);
333 /* Construct the indirection. */
334 arg_type
= lookup_pointer_type (arg_type
);
335 arg
= value_from_pointer (arg_type
, sp
);
342 m_arg
->len
= TYPE_LENGTH (arg_type
);
343 m_arg
->offset
= accumulate_size
;
344 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
345 m_arg
->contents
= VALUE_CONTENTS (arg
);
348 /* Determine required argument register loads, loading an argument register
349 is expensive as it uses three ptrace calls. */
350 required_arg_regs
= accumulate_size
/ 8;
351 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
352 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
354 /* Make room for the arguments on the stack. */
355 if (accumulate_size
< sizeof(arg_reg_buffer
))
358 accumulate_size
-= sizeof(arg_reg_buffer
);
359 sp
-= accumulate_size
;
361 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
364 /* `Push' arguments on the stack. */
365 for (i
= nargs
; m_arg
--, --i
>= 0;)
367 char *contents
= m_arg
->contents
;
368 int offset
= m_arg
->offset
;
369 int len
= m_arg
->len
;
371 /* Copy the bytes destined for registers into arg_reg_buffer. */
372 if (offset
< sizeof(arg_reg_buffer
))
374 if (offset
+ len
<= sizeof(arg_reg_buffer
))
376 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
381 int tlen
= sizeof(arg_reg_buffer
) - offset
;
382 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
389 /* Everything else goes to the stack. */
390 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
393 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
395 /* Load the argument registers. */
396 for (i
= 0; i
< required_arg_regs
; i
++)
398 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
399 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
400 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
401 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
404 /* Finally, update the stack pointer. */
405 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
410 /* Extract from REGCACHE the value about to be returned from a function
411 and copy it into VALBUF. */
414 alpha_extract_return_value (struct type
*valtype
, struct regcache
*regcache
,
417 int length
= TYPE_LENGTH (valtype
);
418 char raw_buffer
[ALPHA_REGISTER_SIZE
];
421 switch (TYPE_CODE (valtype
))
427 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
428 alpha_convert_dbl_flt (valbuf
, raw_buffer
);
432 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
436 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
437 read_memory (l
, valbuf
, 16);
445 case TYPE_CODE_COMPLEX
:
449 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
450 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
454 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
455 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
+1,
460 regcache_cooked_read_signed (regcache
, ALPHA_V0_REGNUM
, &l
);
461 read_memory (l
, valbuf
, 32);
470 /* Assume everything else degenerates to an integer. */
471 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
472 store_unsigned_integer (valbuf
, length
, l
);
477 /* Extract from REGCACHE the address of a structure about to be returned
481 alpha_extract_struct_value_address (struct regcache
*regcache
)
484 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
488 /* Insert the given value into REGCACHE as if it was being
489 returned by a function. */
492 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
495 int length
= TYPE_LENGTH (valtype
);
496 char raw_buffer
[ALPHA_REGISTER_SIZE
];
499 switch (TYPE_CODE (valtype
))
505 alpha_convert_flt_dbl (raw_buffer
, valbuf
);
510 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
514 /* FIXME: 128-bit long doubles are returned like structures:
515 by writing into indirect storage provided by the caller
516 as the first argument. */
517 error ("Cannot set a 128-bit long double return value.");
524 case TYPE_CODE_COMPLEX
:
528 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
529 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
533 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
534 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
+1,
535 (const char *)valbuf
+ 8);
539 /* FIXME: 128-bit long doubles are returned like structures:
540 by writing into indirect storage provided by the caller
541 as the first argument. */
542 error ("Cannot set a 128-bit long double return value.");
550 /* Assume everything else degenerates to an integer. */
551 /* 32-bit values must be sign-extended to 64 bits
552 even if the base data type is unsigned. */
554 valtype
= builtin_type_int32
;
555 l
= unpack_long (valtype
, valbuf
);
556 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
562 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
564 /* Structures are returned by ref in extra arg0. */
569 static const unsigned char *
570 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
572 static const unsigned char alpha_breakpoint
[] =
573 { 0x80, 0, 0, 0 }; /* call_pal bpt */
575 *lenptr
= sizeof(alpha_breakpoint
);
576 return (alpha_breakpoint
);
580 /* This returns the PC of the first insn after the prologue.
581 If we can't find the prologue, then return 0. */
584 alpha_after_prologue (CORE_ADDR pc
)
586 struct symtab_and_line sal
;
587 CORE_ADDR func_addr
, func_end
;
589 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
592 sal
= find_pc_line (func_addr
, 0);
593 if (sal
.end
< func_end
)
596 /* The line after the prologue is after the end of the function. In this
597 case, tell the caller to find the prologue the hard way. */
601 /* Read an instruction from memory at PC, looking through breakpoints. */
604 alpha_read_insn (CORE_ADDR pc
)
609 status
= read_memory_nobpt (pc
, buf
, 4);
611 memory_error (status
, pc
);
612 return extract_unsigned_integer (buf
, 4);
615 /* To skip prologues, I use this predicate. Returns either PC itself
616 if the code at PC does not look like a function prologue; otherwise
617 returns an address that (if we're lucky) follows the prologue. If
618 LENIENT, then we must skip everything which is involved in setting
619 up the frame (it's OK to skip more, just so long as we don't skip
620 anything which might clobber the registers which are being saved. */
623 alpha_skip_prologue (CORE_ADDR pc
)
627 CORE_ADDR post_prologue_pc
;
630 /* Silently return the unaltered pc upon memory errors.
631 This could happen on OSF/1 if decode_line_1 tries to skip the
632 prologue for quickstarted shared library functions when the
633 shared library is not yet mapped in.
634 Reading target memory is slow over serial lines, so we perform
635 this check only if the target has shared libraries (which all
636 Alpha targets do). */
637 if (target_read_memory (pc
, buf
, 4))
640 /* See if we can determine the end of the prologue via the symbol table.
641 If so, then return either PC, or the PC after the prologue, whichever
644 post_prologue_pc
= alpha_after_prologue (pc
);
645 if (post_prologue_pc
!= 0)
646 return max (pc
, post_prologue_pc
);
648 /* Can't determine prologue from the symbol table, need to examine
651 /* Skip the typical prologue instructions. These are the stack adjustment
652 instruction and the instructions that save registers on the stack
653 or in the gcc frame. */
654 for (offset
= 0; offset
< 100; offset
+= 4)
656 inst
= alpha_read_insn (pc
+ offset
);
658 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
660 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
662 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
664 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
667 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
668 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
669 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
672 if (inst
== 0x47de040f) /* bis sp,sp,fp */
674 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
683 /* Figure out where the longjmp will land.
684 We expect the first arg to be a pointer to the jmp_buf structure from
685 which we extract the PC (JB_PC) that we will land at. The PC is copied
686 into the "pc". This routine returns true on success. */
689 alpha_get_longjmp_target (CORE_ADDR
*pc
)
691 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
693 char raw_buffer
[ALPHA_REGISTER_SIZE
];
695 jb_addr
= read_register (ALPHA_A0_REGNUM
);
697 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
698 raw_buffer
, tdep
->jb_elt_size
))
701 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
706 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
707 describe the location and shape of the sigcontext structure. After
708 that, all registers are in memory, so it's easy. */
709 /* ??? Shouldn't we be able to do this generically, rather than with
710 OSABI data specific to Alpha? */
712 struct alpha_sigtramp_unwind_cache
714 CORE_ADDR sigcontext_addr
;
717 static struct alpha_sigtramp_unwind_cache
*
718 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
719 void **this_prologue_cache
)
721 struct alpha_sigtramp_unwind_cache
*info
;
722 struct gdbarch_tdep
*tdep
;
724 if (*this_prologue_cache
)
725 return *this_prologue_cache
;
727 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
728 *this_prologue_cache
= info
;
730 tdep
= gdbarch_tdep (current_gdbarch
);
731 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
736 /* Return the address of REGNO in a sigtramp frame. Since this is all
737 arithmetic, it doesn't seem worthwhile to cache it. */
739 #ifndef SIGFRAME_PC_OFF
740 #define SIGFRAME_PC_OFF (2 * 8)
741 #define SIGFRAME_REGSAVE_OFF (4 * 8)
742 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
746 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, unsigned int regno
)
749 return sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ regno
* 8;
750 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
751 return sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ regno
* 8;
752 if (regno
== PC_REGNUM
)
753 return sigcontext_addr
+ SIGFRAME_PC_OFF
;
758 /* Given a GDB frame, determine the address of the calling function's
759 frame. This will be used to create a new GDB frame struct. */
762 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
763 void **this_prologue_cache
,
764 struct frame_id
*this_id
)
766 struct alpha_sigtramp_unwind_cache
*info
767 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
768 struct gdbarch_tdep
*tdep
;
769 CORE_ADDR stack_addr
, code_addr
;
771 /* If the OSABI couldn't locate the sigcontext, give up. */
772 if (info
->sigcontext_addr
== 0)
775 /* If we have dynamic signal trampolines, find their start.
776 If we do not, then we must assume there is a symbol record
777 that can provide the start address. */
778 tdep
= gdbarch_tdep (current_gdbarch
);
779 if (tdep
->dynamic_sigtramp_offset
)
782 code_addr
= frame_pc_unwind (next_frame
);
783 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
790 code_addr
= frame_func_unwind (next_frame
);
792 /* The stack address is trivially read from the sigcontext. */
793 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
795 stack_addr
= read_memory_unsigned_integer (stack_addr
, ALPHA_REGISTER_SIZE
);
797 *this_id
= frame_id_build (stack_addr
, code_addr
);
800 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
803 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
804 void **this_prologue_cache
,
805 int regnum
, int *optimizedp
,
806 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
807 int *realnump
, void *bufferp
)
809 struct alpha_sigtramp_unwind_cache
*info
810 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
813 if (info
->sigcontext_addr
!= 0)
815 /* All integer and fp registers are stored in memory. */
816 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
820 *lvalp
= lval_memory
;
824 read_memory (addr
, bufferp
, ALPHA_REGISTER_SIZE
);
829 /* This extra register may actually be in the sigcontext, but our
830 current description of it in alpha_sigtramp_frame_unwind_cache
831 doesn't include it. Too bad. Fall back on whatever's in the
833 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
837 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
839 alpha_sigtramp_frame_this_id
,
840 alpha_sigtramp_frame_prev_register
843 static const struct frame_unwind
*
844 alpha_sigtramp_frame_p (CORE_ADDR pc
)
848 /* We shouldn't even bother to try if the OSABI didn't register
849 a sigcontext_addr handler. */
850 if (!gdbarch_tdep (current_gdbarch
)->sigcontext_addr
)
853 /* Otherwise we should be in a signal frame. */
854 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
855 if (PC_IN_SIGTRAMP (pc
, name
))
856 return &alpha_sigtramp_frame_unwind
;
861 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
862 something about the traditional layout of alpha stack frames. */
864 struct alpha_heuristic_unwind_cache
866 CORE_ADDR
*saved_regs
;
872 /* Heuristic_proc_start may hunt through the text section for a long
873 time across a 2400 baud serial line. Allows the user to limit this
875 static unsigned int heuristic_fence_post
= 0;
877 /* Attempt to locate the start of the function containing PC. We assume that
878 the previous function ends with an about_to_return insn. Not foolproof by
879 any means, since gcc is happy to put the epilogue in the middle of a
880 function. But we're guessing anyway... */
883 alpha_heuristic_proc_start (CORE_ADDR pc
)
885 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
886 CORE_ADDR last_non_nop
= pc
;
887 CORE_ADDR fence
= pc
- heuristic_fence_post
;
888 CORE_ADDR orig_pc
= pc
;
894 /* First see if we can find the start of the function from minimal
895 symbol information. This can succeed with a binary that doesn't
896 have debug info, but hasn't been stripped. */
897 func
= get_pc_function_start (pc
);
901 if (heuristic_fence_post
== UINT_MAX
902 || fence
< tdep
->vm_min_address
)
903 fence
= tdep
->vm_min_address
;
905 /* Search back for previous return; also stop at a 0, which might be
906 seen for instance before the start of a code section. Don't include
907 nops, since this usually indicates padding between functions. */
908 for (pc
-= 4; pc
>= fence
; pc
-= 4)
910 unsigned int insn
= alpha_read_insn (pc
);
913 case 0: /* invalid insn */
914 case 0x6bfa8001: /* ret $31,($26),1 */
917 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
918 case 0x47ff041f: /* nop: bis $31,$31,$31 */
927 /* It's not clear to me why we reach this point when stopping quietly,
928 but with this test, at least we don't print out warnings for every
929 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
930 if (stop_soon
== NO_STOP_QUIETLY
)
932 static int blurb_printed
= 0;
934 if (fence
== tdep
->vm_min_address
)
935 warning ("Hit beginning of text section without finding");
937 warning ("Hit heuristic-fence-post without finding");
938 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
943 This warning occurs if you are debugging a function without any symbols\n\
944 (for example, in a stripped executable). In that case, you may wish to\n\
945 increase the size of the search with the `set heuristic-fence-post' command.\n\
947 Otherwise, you told GDB there was a function where there isn't one, or\n\
948 (more likely) you have encountered a bug in GDB.\n");
956 static struct alpha_heuristic_unwind_cache
*
957 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
958 void **this_prologue_cache
,
961 struct alpha_heuristic_unwind_cache
*info
;
963 CORE_ADDR limit_pc
, cur_pc
;
964 int frame_reg
, frame_size
, return_reg
, reg
;
966 if (*this_prologue_cache
)
967 return *this_prologue_cache
;
969 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
970 *this_prologue_cache
= info
;
971 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
973 limit_pc
= frame_pc_unwind (next_frame
);
975 start_pc
= alpha_heuristic_proc_start (limit_pc
);
976 info
->start_pc
= start_pc
;
978 frame_reg
= ALPHA_SP_REGNUM
;
982 /* If we've identified a likely place to start, do code scanning. */
985 /* Limit the forward search to 50 instructions. */
986 if (start_pc
+ 200 < limit_pc
)
987 limit_pc
= start_pc
+ 200;
989 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
991 unsigned int word
= alpha_read_insn (cur_pc
);
993 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
997 /* Consider only the first stack allocation instruction
998 to contain the static size of the frame. */
1000 frame_size
= (-word
) & 0xffff;
1004 /* Exit loop if a positive stack adjustment is found, which
1005 usually means that the stack cleanup code in the function
1006 epilogue is reached. */
1010 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1012 reg
= (word
& 0x03e00000) >> 21;
1017 /* Do not compute the address where the register was saved yet,
1018 because we don't know yet if the offset will need to be
1019 relative to $sp or $fp (we can not compute the address
1020 relative to $sp if $sp is updated during the execution of
1021 the current subroutine, for instance when doing some alloca).
1022 So just store the offset for the moment, and compute the
1023 address later when we know whether this frame has a frame
1025 /* Hack: temporarily add one, so that the offset is non-zero
1026 and we can tell which registers have save offsets below. */
1027 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
1029 /* Starting with OSF/1-3.2C, the system libraries are shipped
1030 without local symbols, but they still contain procedure
1031 descriptors without a symbol reference. GDB is currently
1032 unable to find these procedure descriptors and uses
1033 heuristic_proc_desc instead.
1034 As some low level compiler support routines (__div*, __add*)
1035 use a non-standard return address register, we have to
1036 add some heuristics to determine the return address register,
1037 or stepping over these routines will fail.
1038 Usually the return address register is the first register
1039 saved on the stack, but assembler optimization might
1040 rearrange the register saves.
1041 So we recognize only a few registers (t7, t9, ra) within
1042 the procedure prologue as valid return address registers.
1043 If we encounter a return instruction, we extract the
1044 the return address register from it.
1046 FIXME: Rewriting GDB to access the procedure descriptors,
1047 e.g. via the minimal symbol table, might obviate this hack. */
1048 if (return_reg
== -1
1049 && cur_pc
< (start_pc
+ 80)
1050 && (reg
== ALPHA_T7_REGNUM
1051 || reg
== ALPHA_T9_REGNUM
1052 || reg
== ALPHA_RA_REGNUM
))
1055 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1056 return_reg
= (word
>> 16) & 0x1f;
1057 else if (word
== 0x47de040f) /* bis sp,sp,fp */
1058 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1059 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
1060 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1063 /* If we haven't found a valid return address register yet, keep
1064 searching in the procedure prologue. */
1065 if (return_reg
== -1)
1067 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
1069 unsigned int word
= alpha_read_insn (cur_pc
);
1071 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1073 reg
= (word
& 0x03e00000) >> 21;
1074 if (reg
== ALPHA_T7_REGNUM
1075 || reg
== ALPHA_T9_REGNUM
1076 || reg
== ALPHA_RA_REGNUM
)
1082 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1084 return_reg
= (word
>> 16) & 0x1f;
1093 /* Failing that, do default to the customary RA. */
1094 if (return_reg
== -1)
1095 return_reg
= ALPHA_RA_REGNUM
;
1096 info
->return_reg
= return_reg
;
1098 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
1099 info
->vfp
= val
+ frame_size
;
1101 /* Convert offsets to absolute addresses. See above about adding
1102 one to the offsets to make all detected offsets non-zero. */
1103 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1104 if (info
->saved_regs
[reg
])
1105 info
->saved_regs
[reg
] += val
- 1;
1110 /* Given a GDB frame, determine the address of the calling function's
1111 frame. This will be used to create a new GDB frame struct. */
1114 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
1115 void **this_prologue_cache
,
1116 struct frame_id
*this_id
)
1118 struct alpha_heuristic_unwind_cache
*info
1119 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1121 /* This is meant to halt the backtrace at "_start". Make sure we
1122 don't halt it at a generic dummy frame. */
1123 if (inside_entry_file (info
->start_pc
))
1126 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1129 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1132 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
1133 void **this_prologue_cache
,
1134 int regnum
, int *optimizedp
,
1135 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1136 int *realnump
, void *bufferp
)
1138 struct alpha_heuristic_unwind_cache
*info
1139 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1141 /* The PC of the previous frame is stored in the link register of
1142 the current frame. Frob regnum so that we pull the value from
1143 the correct place. */
1144 if (regnum
== ALPHA_PC_REGNUM
)
1145 regnum
= info
->return_reg
;
1147 /* For all registers known to be saved in the current frame,
1148 do the obvious and pull the value out. */
1149 if (info
->saved_regs
[regnum
])
1152 *lvalp
= lval_memory
;
1153 *addrp
= info
->saved_regs
[regnum
];
1155 if (bufferp
!= NULL
)
1156 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1160 /* The stack pointer of the previous frame is computed by popping
1161 the current stack frame. */
1162 if (regnum
== ALPHA_SP_REGNUM
)
1168 if (bufferp
!= NULL
)
1169 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1173 /* Otherwise assume the next frame has the same register value. */
1174 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1178 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1180 alpha_heuristic_frame_this_id
,
1181 alpha_heuristic_frame_prev_register
1184 static const struct frame_unwind
*
1185 alpha_heuristic_frame_p (CORE_ADDR pc
)
1187 return &alpha_heuristic_frame_unwind
;
1191 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1192 void **this_prologue_cache
)
1194 struct alpha_heuristic_unwind_cache
*info
1195 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1200 static const struct frame_base alpha_heuristic_frame_base
= {
1201 &alpha_heuristic_frame_unwind
,
1202 alpha_heuristic_frame_base_address
,
1203 alpha_heuristic_frame_base_address
,
1204 alpha_heuristic_frame_base_address
1207 /* Just like reinit_frame_cache, but with the right arguments to be
1208 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1211 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1213 reinit_frame_cache ();
1217 /* ALPHA stack frames are almost impenetrable. When execution stops,
1218 we basically have to look at symbol information for the function
1219 that we stopped in, which tells us *which* register (if any) is
1220 the base of the frame pointer, and what offset from that register
1221 the frame itself is at.
1223 This presents a problem when trying to examine a stack in memory
1224 (that isn't executing at the moment), using the "frame" command. We
1225 don't have a PC, nor do we have any registers except SP.
1227 This routine takes two arguments, SP and PC, and tries to make the
1228 cached frames look as if these two arguments defined a frame on the
1229 cache. This allows the rest of info frame to extract the important
1230 arguments without difficulty. */
1233 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1236 error ("ALPHA frame specifications require two arguments: sp and pc");
1238 return create_new_frame (argv
[0], argv
[1]);
1241 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1242 dummy frame. The frame ID's base needs to match the TOS value
1243 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1246 static struct frame_id
1247 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1250 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1251 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1255 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1258 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1263 /* alpha_software_single_step() is called just before we want to resume
1264 the inferior, if we want to single-step it but there is no hardware
1265 or kernel single-step support (NetBSD on Alpha, for example). We find
1266 the target of the coming instruction and breakpoint it.
1268 single_step is also called just after the inferior stops. If we had
1269 set up a simulated single-step, we undo our damage. */
1272 alpha_next_pc (CORE_ADDR pc
)
1279 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1281 /* Opcode is top 6 bits. */
1282 op
= (insn
>> 26) & 0x3f;
1286 /* Jump format: target PC is:
1288 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1291 if ((op
& 0x30) == 0x30)
1293 /* Branch format: target PC is:
1294 (new PC) + (4 * sext(displacement)) */
1295 if (op
== 0x30 || /* BR */
1296 op
== 0x34) /* BSR */
1299 offset
= (insn
& 0x001fffff);
1300 if (offset
& 0x00100000)
1301 offset
|= 0xffe00000;
1303 return (pc
+ 4 + offset
);
1306 /* Need to determine if branch is taken; read RA. */
1307 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1310 case 0x38: /* BLBC */
1314 case 0x3c: /* BLBS */
1318 case 0x39: /* BEQ */
1322 case 0x3d: /* BNE */
1326 case 0x3a: /* BLT */
1330 case 0x3b: /* BLE */
1334 case 0x3f: /* BGT */
1338 case 0x3e: /* BGE */
1343 /* ??? Missing floating-point branches. */
1347 /* Not a branch or branch not taken; target PC is:
1353 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1355 static CORE_ADDR next_pc
;
1356 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1357 static binsn_quantum break_mem
;
1360 if (insert_breakpoints_p
)
1363 next_pc
= alpha_next_pc (pc
);
1365 target_insert_breakpoint (next_pc
, break_mem
);
1369 target_remove_breakpoint (next_pc
, break_mem
);
1375 /* Initialize the current architecture based on INFO. If possible, re-use an
1376 architecture from ARCHES, which is a list of architectures already created
1377 during this debugging session.
1379 Called e.g. at program startup, when reading a core file, and when reading
1382 static struct gdbarch
*
1383 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1385 struct gdbarch_tdep
*tdep
;
1386 struct gdbarch
*gdbarch
;
1388 /* Try to determine the ABI of the object we are loading. */
1389 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1391 /* If it's an ECOFF file, assume it's OSF/1. */
1392 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1393 info
.osabi
= GDB_OSABI_OSF1
;
1396 /* Find a candidate among extant architectures. */
1397 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1399 return arches
->gdbarch
;
1401 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1402 gdbarch
= gdbarch_alloc (&info
, tdep
);
1404 /* Lowest text address. This is used by heuristic_proc_start()
1405 to decide when to stop looking. */
1406 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1408 tdep
->dynamic_sigtramp_offset
= NULL
;
1409 tdep
->sigcontext_addr
= NULL
;
1411 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1414 set_gdbarch_short_bit (gdbarch
, 16);
1415 set_gdbarch_int_bit (gdbarch
, 32);
1416 set_gdbarch_long_bit (gdbarch
, 64);
1417 set_gdbarch_long_long_bit (gdbarch
, 64);
1418 set_gdbarch_float_bit (gdbarch
, 32);
1419 set_gdbarch_double_bit (gdbarch
, 64);
1420 set_gdbarch_long_double_bit (gdbarch
, 64);
1421 set_gdbarch_ptr_bit (gdbarch
, 64);
1424 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1425 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1426 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1427 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1429 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1430 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1431 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1432 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1433 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1435 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1436 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1438 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1439 set_gdbarch_register_convert_to_virtual (gdbarch
,
1440 alpha_register_convert_to_virtual
);
1441 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1443 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1445 /* Prologue heuristics. */
1446 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1449 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1452 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1453 set_gdbarch_frameless_function_invocation (gdbarch
,
1454 generic_frameless_function_invocation_not
);
1456 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1457 set_gdbarch_extract_return_value (gdbarch
, alpha_extract_return_value
);
1458 set_gdbarch_store_return_value (gdbarch
, alpha_store_return_value
);
1459 set_gdbarch_extract_struct_value_address (gdbarch
,
1460 alpha_extract_struct_value_address
);
1462 /* Settings for calling functions in the inferior. */
1463 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1465 /* Methods for saving / extracting a dummy frame's ID. */
1466 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1467 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1469 /* Return the unwound PC value. */
1470 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1472 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1473 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1475 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1476 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1478 set_gdbarch_function_start_offset (gdbarch
, 0);
1479 set_gdbarch_frame_args_skip (gdbarch
, 0);
1481 /* Hook in ABI-specific overrides, if they have been registered. */
1482 gdbarch_init_osabi (info
, gdbarch
);
1484 /* Now that we have tuned the configuration, set a few final things
1485 based on what the OS ABI has told us. */
1487 if (tdep
->jb_pc
>= 0)
1488 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1490 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1491 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1493 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1499 _initialize_alpha_tdep (void)
1501 struct cmd_list_element
*c
;
1503 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1505 /* Let the user set the fence post for heuristic_proc_start. */
1507 /* We really would like to have both "0" and "unlimited" work, but
1508 command.c doesn't deal with that. So make it a var_zinteger
1509 because the user can always use "999999" or some such for unlimited. */
1510 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1511 (char *) &heuristic_fence_post
,
1513 Set the distance searched for the start of a function.\n\
1514 If you are debugging a stripped executable, GDB needs to search through the\n\
1515 program for the start of a function. This command sets the distance of the\n\
1516 search. The only need to set it is when debugging a stripped executable.",
1518 /* We need to throw away the frame cache when we set this, since it
1519 might change our ability to get backtraces. */
1520 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1521 add_show_from_set (c
, &showlist
);