1 /* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2005 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
26 #include "frame-unwind.h"
27 #include "frame-base.h"
28 #include "dwarf2-frame.h"
37 #include "gdb_string.h"
40 #include "reggroups.h"
41 #include "arch-utils.h"
48 #include "alpha-tdep.h"
51 /* Return the name of the REGNO register.
53 An empty name corresponds to a register number that used to
54 be used for a virtual register. That virtual register has
55 been removed, but the index is still reserved to maintain
56 compatibility with existing remote alpha targets. */
59 alpha_register_name (int regno
)
61 static const char * const register_names
[] =
63 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
64 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
65 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
66 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
67 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
68 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
69 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
70 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
76 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
78 return register_names
[regno
];
82 alpha_cannot_fetch_register (int regno
)
84 return (regno
== ALPHA_ZERO_REGNUM
85 || strlen (alpha_register_name (regno
)) == 0);
89 alpha_cannot_store_register (int regno
)
91 return (regno
== ALPHA_ZERO_REGNUM
92 || strlen (alpha_register_name (regno
)) == 0);
96 alpha_register_type (struct gdbarch
*gdbarch
, int regno
)
98 if (regno
== ALPHA_SP_REGNUM
|| regno
== ALPHA_GP_REGNUM
)
99 return builtin_type_void_data_ptr
;
100 if (regno
== ALPHA_PC_REGNUM
)
101 return builtin_type_void_func_ptr
;
103 /* Don't need to worry about little vs big endian until
104 some jerk tries to port to alpha-unicosmk. */
105 if (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31)
106 return builtin_type_ieee_double_little
;
108 return builtin_type_int64
;
111 /* Is REGNUM a member of REGGROUP? */
114 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
115 struct reggroup
*group
)
117 /* Filter out any registers eliminated, but whose regnum is
118 reserved for backward compatibility, e.g. the vfp. */
119 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
122 if (group
== all_reggroup
)
125 /* Zero should not be saved or restored. Technically it is a general
126 register (just as $f31 would be a float if we represented it), but
127 there's no point displaying it during "info regs", so leave it out
128 of all groups except for "all". */
129 if (regnum
== ALPHA_ZERO_REGNUM
)
132 /* All other registers are saved and restored. */
133 if (group
== save_reggroup
|| group
== restore_reggroup
)
136 /* All other groups are non-overlapping. */
138 /* Since this is really a PALcode memory slot... */
139 if (regnum
== ALPHA_UNIQUE_REGNUM
)
140 return group
== system_reggroup
;
142 /* Force the FPCR to be considered part of the floating point state. */
143 if (regnum
== ALPHA_FPCR_REGNUM
)
144 return group
== float_reggroup
;
146 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
147 return group
== float_reggroup
;
149 return group
== general_reggroup
;
152 /* The following represents exactly the conversion performed by
153 the LDS instruction. This applies to both single-precision
154 floating point and 32-bit integers. */
157 alpha_lds (void *out
, const void *in
)
159 ULONGEST mem
= extract_unsigned_integer (in
, 4);
160 ULONGEST frac
= (mem
>> 0) & 0x7fffff;
161 ULONGEST sign
= (mem
>> 31) & 1;
162 ULONGEST exp_msb
= (mem
>> 30) & 1;
163 ULONGEST exp_low
= (mem
>> 23) & 0x7f;
166 exp
= (exp_msb
<< 10) | exp_low
;
178 reg
= (sign
<< 63) | (exp
<< 52) | (frac
<< 29);
179 store_unsigned_integer (out
, 8, reg
);
182 /* Similarly, this represents exactly the conversion performed by
183 the STS instruction. */
186 alpha_sts (void *out
, const void *in
)
190 reg
= extract_unsigned_integer (in
, 8);
191 mem
= ((reg
>> 32) & 0xc0000000) | ((reg
>> 29) & 0x3fffffff);
192 store_unsigned_integer (out
, 4, mem
);
195 /* The alpha needs a conversion between register and memory format if the
196 register is a floating point register and memory format is float, as the
197 register format must be double or memory format is an integer with 4
198 bytes or less, as the representation of integers in floating point
199 registers is different. */
202 alpha_convert_register_p (int regno
, struct type
*type
)
204 return (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31);
208 alpha_register_to_value (struct frame_info
*frame
, int regnum
,
209 struct type
*valtype
, gdb_byte
*out
)
211 char in
[MAX_REGISTER_SIZE
];
212 frame_register_read (frame
, regnum
, in
);
213 switch (TYPE_LENGTH (valtype
))
222 error (_("Cannot retrieve value from floating point register"));
227 alpha_value_to_register (struct frame_info
*frame
, int regnum
,
228 struct type
*valtype
, const gdb_byte
*in
)
230 char out
[MAX_REGISTER_SIZE
];
231 switch (TYPE_LENGTH (valtype
))
240 error (_("Cannot store value in floating point register"));
242 put_frame_register (frame
, regnum
, out
);
246 /* The alpha passes the first six arguments in the registers, the rest on
247 the stack. The register arguments are stored in ARG_REG_BUFFER, and
248 then moved into the register file; this simplifies the passing of a
249 large struct which extends from the registers to the stack, plus avoids
250 three ptrace invocations per word.
252 We don't bother tracking which register values should go in integer
253 regs or fp regs; we load the same values into both.
255 If the called function is returning a structure, the address of the
256 structure to be returned is passed as a hidden first argument. */
259 alpha_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
260 struct regcache
*regcache
, CORE_ADDR bp_addr
,
261 int nargs
, struct value
**args
, CORE_ADDR sp
,
262 int struct_return
, CORE_ADDR struct_addr
)
265 int accumulate_size
= struct_return
? 8 : 0;
272 struct alpha_arg
*alpha_args
273 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
274 struct alpha_arg
*m_arg
;
275 char arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
276 int required_arg_regs
;
277 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
279 /* The ABI places the address of the called function in T12. */
280 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
282 /* Set the return address register to point to the entry point
283 of the program, where a breakpoint lies in wait. */
284 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
286 /* Lay out the arguments in memory. */
287 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
289 struct value
*arg
= args
[i
];
290 struct type
*arg_type
= check_typedef (value_type (arg
));
292 /* Cast argument to long if necessary as the compiler does it too. */
293 switch (TYPE_CODE (arg_type
))
298 case TYPE_CODE_RANGE
:
300 if (TYPE_LENGTH (arg_type
) == 4)
302 /* 32-bit values must be sign-extended to 64 bits
303 even if the base data type is unsigned. */
304 arg_type
= builtin_type_int32
;
305 arg
= value_cast (arg_type
, arg
);
307 if (TYPE_LENGTH (arg_type
) < ALPHA_REGISTER_SIZE
)
309 arg_type
= builtin_type_int64
;
310 arg
= value_cast (arg_type
, arg
);
315 /* "float" arguments loaded in registers must be passed in
316 register format, aka "double". */
317 if (accumulate_size
< sizeof (arg_reg_buffer
)
318 && TYPE_LENGTH (arg_type
) == 4)
320 arg_type
= builtin_type_ieee_double_little
;
321 arg
= value_cast (arg_type
, arg
);
323 /* Tru64 5.1 has a 128-bit long double, and passes this by
324 invisible reference. No one else uses this data type. */
325 else if (TYPE_LENGTH (arg_type
) == 16)
327 /* Allocate aligned storage. */
328 sp
= (sp
& -16) - 16;
330 /* Write the real data into the stack. */
331 write_memory (sp
, value_contents (arg
), 16);
333 /* Construct the indirection. */
334 arg_type
= lookup_pointer_type (arg_type
);
335 arg
= value_from_pointer (arg_type
, sp
);
339 case TYPE_CODE_COMPLEX
:
340 /* ??? The ABI says that complex values are passed as two
341 separate scalar values. This distinction only matters
342 for complex float. However, GCC does not implement this. */
344 /* Tru64 5.1 has a 128-bit long double, and passes this by
345 invisible reference. */
346 if (TYPE_LENGTH (arg_type
) == 32)
348 /* Allocate aligned storage. */
349 sp
= (sp
& -16) - 16;
351 /* Write the real data into the stack. */
352 write_memory (sp
, value_contents (arg
), 32);
354 /* Construct the indirection. */
355 arg_type
= lookup_pointer_type (arg_type
);
356 arg
= value_from_pointer (arg_type
, sp
);
363 m_arg
->len
= TYPE_LENGTH (arg_type
);
364 m_arg
->offset
= accumulate_size
;
365 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
366 m_arg
->contents
= value_contents_writeable (arg
);
369 /* Determine required argument register loads, loading an argument register
370 is expensive as it uses three ptrace calls. */
371 required_arg_regs
= accumulate_size
/ 8;
372 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
373 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
375 /* Make room for the arguments on the stack. */
376 if (accumulate_size
< sizeof(arg_reg_buffer
))
379 accumulate_size
-= sizeof(arg_reg_buffer
);
380 sp
-= accumulate_size
;
382 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
385 /* `Push' arguments on the stack. */
386 for (i
= nargs
; m_arg
--, --i
>= 0;)
388 char *contents
= m_arg
->contents
;
389 int offset
= m_arg
->offset
;
390 int len
= m_arg
->len
;
392 /* Copy the bytes destined for registers into arg_reg_buffer. */
393 if (offset
< sizeof(arg_reg_buffer
))
395 if (offset
+ len
<= sizeof(arg_reg_buffer
))
397 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
402 int tlen
= sizeof(arg_reg_buffer
) - offset
;
403 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
410 /* Everything else goes to the stack. */
411 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
414 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
416 /* Load the argument registers. */
417 for (i
= 0; i
< required_arg_regs
; i
++)
419 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
420 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
421 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
422 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
425 /* Finally, update the stack pointer. */
426 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
431 /* Extract from REGCACHE the value about to be returned from a function
432 and copy it into VALBUF. */
435 alpha_extract_return_value (struct type
*valtype
, struct regcache
*regcache
,
438 int length
= TYPE_LENGTH (valtype
);
439 char raw_buffer
[ALPHA_REGISTER_SIZE
];
442 switch (TYPE_CODE (valtype
))
448 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
449 alpha_sts (valbuf
, raw_buffer
);
453 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
457 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
458 read_memory (l
, valbuf
, 16);
462 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
466 case TYPE_CODE_COMPLEX
:
470 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
471 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
475 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
476 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
+1,
481 regcache_cooked_read_signed (regcache
, ALPHA_V0_REGNUM
, &l
);
482 read_memory (l
, valbuf
, 32);
486 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
491 /* Assume everything else degenerates to an integer. */
492 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
493 store_unsigned_integer (valbuf
, length
, l
);
498 /* Insert the given value into REGCACHE as if it was being
499 returned by a function. */
502 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
503 const gdb_byte
*valbuf
)
505 int length
= TYPE_LENGTH (valtype
);
506 char raw_buffer
[ALPHA_REGISTER_SIZE
];
509 switch (TYPE_CODE (valtype
))
515 alpha_lds (raw_buffer
, valbuf
);
516 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
520 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
524 /* FIXME: 128-bit long doubles are returned like structures:
525 by writing into indirect storage provided by the caller
526 as the first argument. */
527 error (_("Cannot set a 128-bit long double return value."));
530 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
534 case TYPE_CODE_COMPLEX
:
538 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
539 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
543 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
544 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
+1,
545 (const char *)valbuf
+ 8);
549 /* FIXME: 128-bit long doubles are returned like structures:
550 by writing into indirect storage provided by the caller
551 as the first argument. */
552 error (_("Cannot set a 128-bit long double return value."));
555 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
560 /* Assume everything else degenerates to an integer. */
561 /* 32-bit values must be sign-extended to 64 bits
562 even if the base data type is unsigned. */
564 valtype
= builtin_type_int32
;
565 l
= unpack_long (valtype
, valbuf
);
566 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
571 static enum return_value_convention
572 alpha_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
573 struct regcache
*regcache
, gdb_byte
*readbuf
,
574 const gdb_byte
*writebuf
)
576 enum type_code code
= TYPE_CODE (type
);
578 if ((code
== TYPE_CODE_STRUCT
579 || code
== TYPE_CODE_UNION
580 || code
== TYPE_CODE_ARRAY
)
581 && gdbarch_tdep (gdbarch
)->return_in_memory (type
))
586 regcache_raw_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
587 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
590 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
594 alpha_extract_return_value (type
, regcache
, readbuf
);
596 alpha_store_return_value (type
, regcache
, writebuf
);
598 return RETURN_VALUE_REGISTER_CONVENTION
;
602 alpha_return_in_memory_always (struct type
*type
)
607 static const unsigned char *
608 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
610 static const unsigned char alpha_breakpoint
[] =
611 { 0x80, 0, 0, 0 }; /* call_pal bpt */
613 *lenptr
= sizeof(alpha_breakpoint
);
614 return (alpha_breakpoint
);
618 /* This returns the PC of the first insn after the prologue.
619 If we can't find the prologue, then return 0. */
622 alpha_after_prologue (CORE_ADDR pc
)
624 struct symtab_and_line sal
;
625 CORE_ADDR func_addr
, func_end
;
627 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
630 sal
= find_pc_line (func_addr
, 0);
631 if (sal
.end
< func_end
)
634 /* The line after the prologue is after the end of the function. In this
635 case, tell the caller to find the prologue the hard way. */
639 /* Read an instruction from memory at PC, looking through breakpoints. */
642 alpha_read_insn (CORE_ADDR pc
)
647 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
649 memory_error (status
, pc
);
650 return extract_unsigned_integer (buf
, 4);
653 /* To skip prologues, I use this predicate. Returns either PC itself
654 if the code at PC does not look like a function prologue; otherwise
655 returns an address that (if we're lucky) follows the prologue. If
656 LENIENT, then we must skip everything which is involved in setting
657 up the frame (it's OK to skip more, just so long as we don't skip
658 anything which might clobber the registers which are being saved. */
661 alpha_skip_prologue (CORE_ADDR pc
)
665 CORE_ADDR post_prologue_pc
;
668 /* Silently return the unaltered pc upon memory errors.
669 This could happen on OSF/1 if decode_line_1 tries to skip the
670 prologue for quickstarted shared library functions when the
671 shared library is not yet mapped in.
672 Reading target memory is slow over serial lines, so we perform
673 this check only if the target has shared libraries (which all
674 Alpha targets do). */
675 if (target_read_memory (pc
, buf
, 4))
678 /* See if we can determine the end of the prologue via the symbol table.
679 If so, then return either PC, or the PC after the prologue, whichever
682 post_prologue_pc
= alpha_after_prologue (pc
);
683 if (post_prologue_pc
!= 0)
684 return max (pc
, post_prologue_pc
);
686 /* Can't determine prologue from the symbol table, need to examine
689 /* Skip the typical prologue instructions. These are the stack adjustment
690 instruction and the instructions that save registers on the stack
691 or in the gcc frame. */
692 for (offset
= 0; offset
< 100; offset
+= 4)
694 inst
= alpha_read_insn (pc
+ offset
);
696 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
698 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
700 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
702 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
705 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
706 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
707 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
710 if (inst
== 0x47de040f) /* bis sp,sp,fp */
712 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
721 /* Figure out where the longjmp will land.
722 We expect the first arg to be a pointer to the jmp_buf structure from
723 which we extract the PC (JB_PC) that we will land at. The PC is copied
724 into the "pc". This routine returns true on success. */
727 alpha_get_longjmp_target (CORE_ADDR
*pc
)
729 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
731 char raw_buffer
[ALPHA_REGISTER_SIZE
];
733 jb_addr
= read_register (ALPHA_A0_REGNUM
);
735 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
736 raw_buffer
, tdep
->jb_elt_size
))
739 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
744 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
745 describe the location and shape of the sigcontext structure. After
746 that, all registers are in memory, so it's easy. */
747 /* ??? Shouldn't we be able to do this generically, rather than with
748 OSABI data specific to Alpha? */
750 struct alpha_sigtramp_unwind_cache
752 CORE_ADDR sigcontext_addr
;
755 static struct alpha_sigtramp_unwind_cache
*
756 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
757 void **this_prologue_cache
)
759 struct alpha_sigtramp_unwind_cache
*info
;
760 struct gdbarch_tdep
*tdep
;
762 if (*this_prologue_cache
)
763 return *this_prologue_cache
;
765 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
766 *this_prologue_cache
= info
;
768 tdep
= gdbarch_tdep (current_gdbarch
);
769 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
774 /* Return the address of REGNUM in a sigtramp frame. Since this is
775 all arithmetic, it doesn't seem worthwhile to cache it. */
778 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, int regnum
)
780 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
782 if (regnum
>= 0 && regnum
< 32)
783 return sigcontext_addr
+ tdep
->sc_regs_offset
+ regnum
* 8;
784 else if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 32)
785 return sigcontext_addr
+ tdep
->sc_fpregs_offset
+ regnum
* 8;
786 else if (regnum
== ALPHA_PC_REGNUM
)
787 return sigcontext_addr
+ tdep
->sc_pc_offset
;
792 /* Given a GDB frame, determine the address of the calling function's
793 frame. This will be used to create a new GDB frame struct. */
796 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
797 void **this_prologue_cache
,
798 struct frame_id
*this_id
)
800 struct alpha_sigtramp_unwind_cache
*info
801 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
802 struct gdbarch_tdep
*tdep
;
803 CORE_ADDR stack_addr
, code_addr
;
805 /* If the OSABI couldn't locate the sigcontext, give up. */
806 if (info
->sigcontext_addr
== 0)
809 /* If we have dynamic signal trampolines, find their start.
810 If we do not, then we must assume there is a symbol record
811 that can provide the start address. */
812 tdep
= gdbarch_tdep (current_gdbarch
);
813 if (tdep
->dynamic_sigtramp_offset
)
816 code_addr
= frame_pc_unwind (next_frame
);
817 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
824 code_addr
= frame_func_unwind (next_frame
);
826 /* The stack address is trivially read from the sigcontext. */
827 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
829 stack_addr
= get_frame_memory_unsigned (next_frame
, stack_addr
,
830 ALPHA_REGISTER_SIZE
);
832 *this_id
= frame_id_build (stack_addr
, code_addr
);
835 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
838 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
839 void **this_prologue_cache
,
840 int regnum
, int *optimizedp
,
841 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
842 int *realnump
, gdb_byte
*bufferp
)
844 struct alpha_sigtramp_unwind_cache
*info
845 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
848 if (info
->sigcontext_addr
!= 0)
850 /* All integer and fp registers are stored in memory. */
851 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
855 *lvalp
= lval_memory
;
859 get_frame_memory (next_frame
, addr
, bufferp
, ALPHA_REGISTER_SIZE
);
864 /* This extra register may actually be in the sigcontext, but our
865 current description of it in alpha_sigtramp_frame_unwind_cache
866 doesn't include it. Too bad. Fall back on whatever's in the
868 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
872 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
874 alpha_sigtramp_frame_this_id
,
875 alpha_sigtramp_frame_prev_register
878 static const struct frame_unwind
*
879 alpha_sigtramp_frame_sniffer (struct frame_info
*next_frame
)
881 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
884 /* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
885 look at tramp-frame.h and other simplier per-architecture
886 sigtramp unwinders. */
888 /* We shouldn't even bother to try if the OSABI didn't register a
889 sigcontext_addr handler or pc_in_sigtramp hander. */
890 if (gdbarch_tdep (current_gdbarch
)->sigcontext_addr
== NULL
)
892 if (gdbarch_tdep (current_gdbarch
)->pc_in_sigtramp
== NULL
)
895 /* Otherwise we should be in a signal frame. */
896 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
897 if (gdbarch_tdep (current_gdbarch
)->pc_in_sigtramp (pc
, name
))
898 return &alpha_sigtramp_frame_unwind
;
903 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
904 something about the traditional layout of alpha stack frames. */
906 struct alpha_heuristic_unwind_cache
908 CORE_ADDR
*saved_regs
;
914 /* Heuristic_proc_start may hunt through the text section for a long
915 time across a 2400 baud serial line. Allows the user to limit this
917 static unsigned int heuristic_fence_post
= 0;
919 /* Attempt to locate the start of the function containing PC. We assume that
920 the previous function ends with an about_to_return insn. Not foolproof by
921 any means, since gcc is happy to put the epilogue in the middle of a
922 function. But we're guessing anyway... */
925 alpha_heuristic_proc_start (CORE_ADDR pc
)
927 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
928 CORE_ADDR last_non_nop
= pc
;
929 CORE_ADDR fence
= pc
- heuristic_fence_post
;
930 CORE_ADDR orig_pc
= pc
;
936 /* First see if we can find the start of the function from minimal
937 symbol information. This can succeed with a binary that doesn't
938 have debug info, but hasn't been stripped. */
939 func
= get_pc_function_start (pc
);
943 if (heuristic_fence_post
== UINT_MAX
944 || fence
< tdep
->vm_min_address
)
945 fence
= tdep
->vm_min_address
;
947 /* Search back for previous return; also stop at a 0, which might be
948 seen for instance before the start of a code section. Don't include
949 nops, since this usually indicates padding between functions. */
950 for (pc
-= 4; pc
>= fence
; pc
-= 4)
952 unsigned int insn
= alpha_read_insn (pc
);
955 case 0: /* invalid insn */
956 case 0x6bfa8001: /* ret $31,($26),1 */
959 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
960 case 0x47ff041f: /* nop: bis $31,$31,$31 */
969 /* It's not clear to me why we reach this point when stopping quietly,
970 but with this test, at least we don't print out warnings for every
971 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
972 if (stop_soon
== NO_STOP_QUIETLY
)
974 static int blurb_printed
= 0;
976 if (fence
== tdep
->vm_min_address
)
977 warning (_("Hit beginning of text section without finding \
978 enclosing function for address 0x%s"), paddr_nz (orig_pc
));
980 warning (_("Hit heuristic-fence-post without finding \
981 enclosing function for address 0x%s"), paddr_nz (orig_pc
));
985 printf_filtered (_("\
986 This warning occurs if you are debugging a function without any symbols\n\
987 (for example, in a stripped executable). In that case, you may wish to\n\
988 increase the size of the search with the `set heuristic-fence-post' command.\n\
990 Otherwise, you told GDB there was a function where there isn't one, or\n\
991 (more likely) you have encountered a bug in GDB.\n"));
999 static struct alpha_heuristic_unwind_cache
*
1000 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
1001 void **this_prologue_cache
,
1004 struct alpha_heuristic_unwind_cache
*info
;
1006 CORE_ADDR limit_pc
, cur_pc
;
1007 int frame_reg
, frame_size
, return_reg
, reg
;
1009 if (*this_prologue_cache
)
1010 return *this_prologue_cache
;
1012 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
1013 *this_prologue_cache
= info
;
1014 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
1016 limit_pc
= frame_pc_unwind (next_frame
);
1018 start_pc
= alpha_heuristic_proc_start (limit_pc
);
1019 info
->start_pc
= start_pc
;
1021 frame_reg
= ALPHA_SP_REGNUM
;
1025 /* If we've identified a likely place to start, do code scanning. */
1028 /* Limit the forward search to 50 instructions. */
1029 if (start_pc
+ 200 < limit_pc
)
1030 limit_pc
= start_pc
+ 200;
1032 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
1034 unsigned int word
= alpha_read_insn (cur_pc
);
1036 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1040 /* Consider only the first stack allocation instruction
1041 to contain the static size of the frame. */
1042 if (frame_size
== 0)
1043 frame_size
= (-word
) & 0xffff;
1047 /* Exit loop if a positive stack adjustment is found, which
1048 usually means that the stack cleanup code in the function
1049 epilogue is reached. */
1053 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1055 reg
= (word
& 0x03e00000) >> 21;
1057 /* Ignore this instruction if we have already encountered
1058 an instruction saving the same register earlier in the
1059 function code. The current instruction does not tell
1060 us where the original value upon function entry is saved.
1061 All it says is that the function we are scanning reused
1062 that register for some computation of its own, and is now
1063 saving its result. */
1064 if (info
->saved_regs
[reg
])
1070 /* Do not compute the address where the register was saved yet,
1071 because we don't know yet if the offset will need to be
1072 relative to $sp or $fp (we can not compute the address
1073 relative to $sp if $sp is updated during the execution of
1074 the current subroutine, for instance when doing some alloca).
1075 So just store the offset for the moment, and compute the
1076 address later when we know whether this frame has a frame
1078 /* Hack: temporarily add one, so that the offset is non-zero
1079 and we can tell which registers have save offsets below. */
1080 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
1082 /* Starting with OSF/1-3.2C, the system libraries are shipped
1083 without local symbols, but they still contain procedure
1084 descriptors without a symbol reference. GDB is currently
1085 unable to find these procedure descriptors and uses
1086 heuristic_proc_desc instead.
1087 As some low level compiler support routines (__div*, __add*)
1088 use a non-standard return address register, we have to
1089 add some heuristics to determine the return address register,
1090 or stepping over these routines will fail.
1091 Usually the return address register is the first register
1092 saved on the stack, but assembler optimization might
1093 rearrange the register saves.
1094 So we recognize only a few registers (t7, t9, ra) within
1095 the procedure prologue as valid return address registers.
1096 If we encounter a return instruction, we extract the
1097 the return address register from it.
1099 FIXME: Rewriting GDB to access the procedure descriptors,
1100 e.g. via the minimal symbol table, might obviate this hack. */
1101 if (return_reg
== -1
1102 && cur_pc
< (start_pc
+ 80)
1103 && (reg
== ALPHA_T7_REGNUM
1104 || reg
== ALPHA_T9_REGNUM
1105 || reg
== ALPHA_RA_REGNUM
))
1108 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1109 return_reg
= (word
>> 16) & 0x1f;
1110 else if (word
== 0x47de040f) /* bis sp,sp,fp */
1111 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1112 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
1113 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1116 /* If we haven't found a valid return address register yet, keep
1117 searching in the procedure prologue. */
1118 if (return_reg
== -1)
1120 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
1122 unsigned int word
= alpha_read_insn (cur_pc
);
1124 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1126 reg
= (word
& 0x03e00000) >> 21;
1127 if (reg
== ALPHA_T7_REGNUM
1128 || reg
== ALPHA_T9_REGNUM
1129 || reg
== ALPHA_RA_REGNUM
)
1135 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1137 return_reg
= (word
>> 16) & 0x1f;
1146 /* Failing that, do default to the customary RA. */
1147 if (return_reg
== -1)
1148 return_reg
= ALPHA_RA_REGNUM
;
1149 info
->return_reg
= return_reg
;
1151 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
1152 info
->vfp
= val
+ frame_size
;
1154 /* Convert offsets to absolute addresses. See above about adding
1155 one to the offsets to make all detected offsets non-zero. */
1156 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1157 if (info
->saved_regs
[reg
])
1158 info
->saved_regs
[reg
] += val
- 1;
1163 /* Given a GDB frame, determine the address of the calling function's
1164 frame. This will be used to create a new GDB frame struct. */
1167 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
1168 void **this_prologue_cache
,
1169 struct frame_id
*this_id
)
1171 struct alpha_heuristic_unwind_cache
*info
1172 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1174 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1177 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1180 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
1181 void **this_prologue_cache
,
1182 int regnum
, int *optimizedp
,
1183 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1184 int *realnump
, gdb_byte
*bufferp
)
1186 struct alpha_heuristic_unwind_cache
*info
1187 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1189 /* The PC of the previous frame is stored in the link register of
1190 the current frame. Frob regnum so that we pull the value from
1191 the correct place. */
1192 if (regnum
== ALPHA_PC_REGNUM
)
1193 regnum
= info
->return_reg
;
1195 /* For all registers known to be saved in the current frame,
1196 do the obvious and pull the value out. */
1197 if (info
->saved_regs
[regnum
])
1200 *lvalp
= lval_memory
;
1201 *addrp
= info
->saved_regs
[regnum
];
1203 if (bufferp
!= NULL
)
1204 get_frame_memory (next_frame
, *addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1208 /* The stack pointer of the previous frame is computed by popping
1209 the current stack frame. */
1210 if (regnum
== ALPHA_SP_REGNUM
)
1216 if (bufferp
!= NULL
)
1217 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1221 /* Otherwise assume the next frame has the same register value. */
1222 frame_register_unwind (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1226 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1228 alpha_heuristic_frame_this_id
,
1229 alpha_heuristic_frame_prev_register
1232 static const struct frame_unwind
*
1233 alpha_heuristic_frame_sniffer (struct frame_info
*next_frame
)
1235 return &alpha_heuristic_frame_unwind
;
1239 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1240 void **this_prologue_cache
)
1242 struct alpha_heuristic_unwind_cache
*info
1243 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1248 static const struct frame_base alpha_heuristic_frame_base
= {
1249 &alpha_heuristic_frame_unwind
,
1250 alpha_heuristic_frame_base_address
,
1251 alpha_heuristic_frame_base_address
,
1252 alpha_heuristic_frame_base_address
1255 /* Just like reinit_frame_cache, but with the right arguments to be
1256 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1259 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1261 reinit_frame_cache ();
1265 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1266 dummy frame. The frame ID's base needs to match the TOS value
1267 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1270 static struct frame_id
1271 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1274 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1275 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1279 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1282 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1287 /* Helper routines for alpha*-nat.c files to move register sets to and
1288 from core files. The UNIQUE pointer is allowed to be NULL, as most
1289 targets don't supply this value in their core files. */
1292 alpha_supply_int_regs (int regno
, const void *r0_r30
,
1293 const void *pc
, const void *unique
)
1297 for (i
= 0; i
< 31; ++i
)
1298 if (regno
== i
|| regno
== -1)
1299 regcache_raw_supply (current_regcache
, i
, (const char *)r0_r30
+ i
*8);
1301 if (regno
== ALPHA_ZERO_REGNUM
|| regno
== -1)
1302 regcache_raw_supply (current_regcache
, ALPHA_ZERO_REGNUM
, NULL
);
1304 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1305 regcache_raw_supply (current_regcache
, ALPHA_PC_REGNUM
, pc
);
1307 if (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1)
1308 regcache_raw_supply (current_regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1312 alpha_fill_int_regs (int regno
, void *r0_r30
, void *pc
, void *unique
)
1316 for (i
= 0; i
< 31; ++i
)
1317 if (regno
== i
|| regno
== -1)
1318 regcache_raw_collect (current_regcache
, i
, (char *)r0_r30
+ i
*8);
1320 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1321 regcache_raw_collect (current_regcache
, ALPHA_PC_REGNUM
, pc
);
1323 if (unique
&& (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1))
1324 regcache_raw_collect (current_regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1328 alpha_supply_fp_regs (int regno
, const void *f0_f30
, const void *fpcr
)
1332 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1333 if (regno
== i
|| regno
== -1)
1334 regcache_raw_supply (current_regcache
, i
,
1335 (const char *)f0_f30
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1337 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1338 regcache_raw_supply (current_regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1342 alpha_fill_fp_regs (int regno
, void *f0_f30
, void *fpcr
)
1346 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1347 if (regno
== i
|| regno
== -1)
1348 regcache_raw_collect (current_regcache
, i
,
1349 (char *)f0_f30
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1351 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1352 regcache_raw_collect (current_regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1357 /* Return nonzero if the G_floating register value in REG is equal to
1358 zero for FP control instructions. */
1361 fp_register_zero_p (LONGEST reg
)
1363 /* Check that all bits except the sign bit are zero. */
1364 const LONGEST zero_mask
= ((LONGEST
) 1 << 63) ^ -1;
1366 return ((reg
& zero_mask
) == 0);
1369 /* Return the value of the sign bit for the G_floating register
1370 value held in REG. */
1373 fp_register_sign_bit (LONGEST reg
)
1375 const LONGEST sign_mask
= (LONGEST
) 1 << 63;
1377 return ((reg
& sign_mask
) != 0);
1380 /* alpha_software_single_step() is called just before we want to resume
1381 the inferior, if we want to single-step it but there is no hardware
1382 or kernel single-step support (NetBSD on Alpha, for example). We find
1383 the target of the coming instruction and breakpoint it.
1385 single_step is also called just after the inferior stops. If we had
1386 set up a simulated single-step, we undo our damage. */
1389 alpha_next_pc (CORE_ADDR pc
)
1398 insn
= alpha_read_insn (pc
);
1400 /* Opcode is top 6 bits. */
1401 op
= (insn
>> 26) & 0x3f;
1405 /* Jump format: target PC is:
1407 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1410 if ((op
& 0x30) == 0x30)
1412 /* Branch format: target PC is:
1413 (new PC) + (4 * sext(displacement)) */
1414 if (op
== 0x30 || /* BR */
1415 op
== 0x34) /* BSR */
1418 offset
= (insn
& 0x001fffff);
1419 if (offset
& 0x00100000)
1420 offset
|= 0xffe00000;
1422 return (pc
+ 4 + offset
);
1425 /* Need to determine if branch is taken; read RA. */
1426 regno
= (insn
>> 21) & 0x1f;
1429 case 0x31: /* FBEQ */
1430 case 0x36: /* FBGE */
1431 case 0x37: /* FBGT */
1432 case 0x33: /* FBLE */
1433 case 0x32: /* FBLT */
1434 case 0x35: /* FBNE */
1435 regno
+= FP0_REGNUM
;
1438 regcache_cooked_read (current_regcache
, regno
, reg
);
1439 rav
= extract_signed_integer (reg
, 8);
1443 case 0x38: /* BLBC */
1447 case 0x3c: /* BLBS */
1451 case 0x39: /* BEQ */
1455 case 0x3d: /* BNE */
1459 case 0x3a: /* BLT */
1463 case 0x3b: /* BLE */
1467 case 0x3f: /* BGT */
1471 case 0x3e: /* BGE */
1476 /* Floating point branches. */
1478 case 0x31: /* FBEQ */
1479 if (fp_register_zero_p (rav
))
1482 case 0x36: /* FBGE */
1483 if (fp_register_sign_bit (rav
) == 0 || fp_register_zero_p (rav
))
1486 case 0x37: /* FBGT */
1487 if (fp_register_sign_bit (rav
) == 0 && ! fp_register_zero_p (rav
))
1490 case 0x33: /* FBLE */
1491 if (fp_register_sign_bit (rav
) == 1 || fp_register_zero_p (rav
))
1494 case 0x32: /* FBLT */
1495 if (fp_register_sign_bit (rav
) == 1 && ! fp_register_zero_p (rav
))
1498 case 0x35: /* FBNE */
1499 if (! fp_register_zero_p (rav
))
1505 /* Not a branch or branch not taken; target PC is:
1511 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1513 static CORE_ADDR next_pc
;
1516 if (insert_breakpoints_p
)
1519 next_pc
= alpha_next_pc (pc
);
1521 insert_single_step_breakpoint (next_pc
);
1525 remove_single_step_breakpoints ();
1531 /* Initialize the current architecture based on INFO. If possible, re-use an
1532 architecture from ARCHES, which is a list of architectures already created
1533 during this debugging session.
1535 Called e.g. at program startup, when reading a core file, and when reading
1538 static struct gdbarch
*
1539 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1541 struct gdbarch_tdep
*tdep
;
1542 struct gdbarch
*gdbarch
;
1544 /* Try to determine the ABI of the object we are loading. */
1545 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1547 /* If it's an ECOFF file, assume it's OSF/1. */
1548 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1549 info
.osabi
= GDB_OSABI_OSF1
;
1552 /* Find a candidate among extant architectures. */
1553 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1555 return arches
->gdbarch
;
1557 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1558 gdbarch
= gdbarch_alloc (&info
, tdep
);
1560 /* Lowest text address. This is used by heuristic_proc_start()
1561 to decide when to stop looking. */
1562 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000LL
;
1564 tdep
->dynamic_sigtramp_offset
= NULL
;
1565 tdep
->sigcontext_addr
= NULL
;
1566 tdep
->sc_pc_offset
= 2 * 8;
1567 tdep
->sc_regs_offset
= 4 * 8;
1568 tdep
->sc_fpregs_offset
= tdep
->sc_regs_offset
+ 32 * 8 + 8;
1570 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1572 tdep
->return_in_memory
= alpha_return_in_memory_always
;
1575 set_gdbarch_short_bit (gdbarch
, 16);
1576 set_gdbarch_int_bit (gdbarch
, 32);
1577 set_gdbarch_long_bit (gdbarch
, 64);
1578 set_gdbarch_long_long_bit (gdbarch
, 64);
1579 set_gdbarch_float_bit (gdbarch
, 32);
1580 set_gdbarch_double_bit (gdbarch
, 64);
1581 set_gdbarch_long_double_bit (gdbarch
, 64);
1582 set_gdbarch_ptr_bit (gdbarch
, 64);
1585 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1586 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1587 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1588 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1590 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1591 set_gdbarch_register_type (gdbarch
, alpha_register_type
);
1593 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1594 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1596 set_gdbarch_convert_register_p (gdbarch
, alpha_convert_register_p
);
1597 set_gdbarch_register_to_value (gdbarch
, alpha_register_to_value
);
1598 set_gdbarch_value_to_register (gdbarch
, alpha_value_to_register
);
1600 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1602 /* Prologue heuristics. */
1603 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1606 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1610 set_gdbarch_return_value (gdbarch
, alpha_return_value
);
1612 /* Settings for calling functions in the inferior. */
1613 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1615 /* Methods for saving / extracting a dummy frame's ID. */
1616 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1618 /* Return the unwound PC value. */
1619 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1621 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1622 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1624 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1625 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1626 set_gdbarch_cannot_step_breakpoint (gdbarch
, 1);
1628 /* Hook in ABI-specific overrides, if they have been registered. */
1629 gdbarch_init_osabi (info
, gdbarch
);
1631 /* Now that we have tuned the configuration, set a few final things
1632 based on what the OS ABI has told us. */
1634 if (tdep
->jb_pc
>= 0)
1635 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1637 frame_unwind_append_sniffer (gdbarch
, alpha_sigtramp_frame_sniffer
);
1638 frame_unwind_append_sniffer (gdbarch
, alpha_heuristic_frame_sniffer
);
1640 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1646 alpha_dwarf2_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1648 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1649 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
1652 extern initialize_file_ftype _initialize_alpha_tdep
; /* -Wmissing-prototypes */
1655 _initialize_alpha_tdep (void)
1657 struct cmd_list_element
*c
;
1659 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1661 /* Let the user set the fence post for heuristic_proc_start. */
1663 /* We really would like to have both "0" and "unlimited" work, but
1664 command.c doesn't deal with that. So make it a var_zinteger
1665 because the user can always use "999999" or some such for unlimited. */
1666 /* We need to throw away the frame cache when we set this, since it
1667 might change our ability to get backtraces. */
1668 add_setshow_zinteger_cmd ("heuristic-fence-post", class_support
,
1669 &heuristic_fence_post
, _("\
1670 Set the distance searched for the start of a function."), _("\
1671 Show the distance searched for the start of a function."), _("\
1672 If you are debugging a stripped executable, GDB needs to search through the\n\
1673 program for the start of a function. This command sets the distance of the\n\
1674 search. The only need to set it is when debugging a stripped executable."),
1675 reinit_frame_cache_sfunc
,
1676 NULL
, /* FIXME: i18n: The distance searched for the start of a function is \"%d\". */
1677 &setlist
, &showlist
);