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"
27 #include "dwarf2-frame.h"
36 #include "gdb_string.h"
39 #include "reggroups.h"
40 #include "arch-utils.h"
47 #include "alpha-tdep.h"
50 /* Return the name of the REGNO register.
52 An empty name corresponds to a register number that used to
53 be used for a virtual register. That virtual register has
54 been removed, but the index is still reserved to maintain
55 compatibility with existing remote alpha targets. */
58 alpha_register_name (int regno
)
60 static const char * const register_names
[] =
62 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
63 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
64 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
65 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
66 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
67 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
68 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
69 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
75 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
77 return register_names
[regno
];
81 alpha_cannot_fetch_register (int regno
)
83 return (regno
== ALPHA_ZERO_REGNUM
84 || strlen (alpha_register_name (regno
)) == 0);
88 alpha_cannot_store_register (int regno
)
90 return (regno
== ALPHA_ZERO_REGNUM
91 || strlen (alpha_register_name (regno
)) == 0);
95 alpha_register_type (struct gdbarch
*gdbarch
, int regno
)
97 if (regno
== ALPHA_SP_REGNUM
|| regno
== ALPHA_GP_REGNUM
)
98 return builtin_type_void_data_ptr
;
99 if (regno
== ALPHA_PC_REGNUM
)
100 return builtin_type_void_func_ptr
;
102 /* Don't need to worry about little vs big endian until
103 some jerk tries to port to alpha-unicosmk. */
104 if (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31)
105 return builtin_type_ieee_double_little
;
107 return builtin_type_int64
;
110 /* Is REGNUM a member of REGGROUP? */
113 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
114 struct reggroup
*group
)
116 /* Filter out any registers eliminated, but whose regnum is
117 reserved for backward compatibility, e.g. the vfp. */
118 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
121 if (group
== all_reggroup
)
124 /* Zero should not be saved or restored. Technically it is a general
125 register (just as $f31 would be a float if we represented it), but
126 there's no point displaying it during "info regs", so leave it out
127 of all groups except for "all". */
128 if (regnum
== ALPHA_ZERO_REGNUM
)
131 /* All other registers are saved and restored. */
132 if (group
== save_reggroup
|| group
== restore_reggroup
)
135 /* All other groups are non-overlapping. */
137 /* Since this is really a PALcode memory slot... */
138 if (regnum
== ALPHA_UNIQUE_REGNUM
)
139 return group
== system_reggroup
;
141 /* Force the FPCR to be considered part of the floating point state. */
142 if (regnum
== ALPHA_FPCR_REGNUM
)
143 return group
== float_reggroup
;
145 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
146 return group
== float_reggroup
;
148 return group
== general_reggroup
;
152 alpha_register_byte (int regno
)
157 /* The following represents exactly the conversion performed by
158 the LDS instruction. This applies to both single-precision
159 floating point and 32-bit integers. */
162 alpha_lds (void *out
, const void *in
)
164 ULONGEST mem
= extract_unsigned_integer (in
, 4);
165 ULONGEST frac
= (mem
>> 0) & 0x7fffff;
166 ULONGEST sign
= (mem
>> 31) & 1;
167 ULONGEST exp_msb
= (mem
>> 30) & 1;
168 ULONGEST exp_low
= (mem
>> 23) & 0x7f;
171 exp
= (exp_msb
<< 10) | exp_low
;
183 reg
= (sign
<< 63) | (exp
<< 52) | (frac
<< 29);
184 store_unsigned_integer (out
, 8, reg
);
187 /* Similarly, this represents exactly the conversion performed by
188 the STS instruction. */
191 alpha_sts (void *out
, const void *in
)
195 reg
= extract_unsigned_integer (in
, 8);
196 mem
= ((reg
>> 32) & 0xc0000000) | ((reg
>> 29) & 0x3fffffff);
197 store_unsigned_integer (out
, 4, mem
);
200 /* The alpha needs a conversion between register and memory format if the
201 register is a floating point register and memory format is float, as the
202 register format must be double or memory format is an integer with 4
203 bytes or less, as the representation of integers in floating point
204 registers is different. */
207 alpha_convert_register_p (int regno
, struct type
*type
)
209 return (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31);
213 alpha_register_to_value (struct frame_info
*frame
, int regnum
,
214 struct type
*valtype
, void *out
)
216 char in
[MAX_REGISTER_SIZE
];
217 frame_register_read (frame
, regnum
, in
);
218 switch (TYPE_LENGTH (valtype
))
227 error (_("Cannot retrieve value from floating point register"));
232 alpha_value_to_register (struct frame_info
*frame
, int regnum
,
233 struct type
*valtype
, const void *in
)
235 char out
[MAX_REGISTER_SIZE
];
236 switch (TYPE_LENGTH (valtype
))
245 error (_("Cannot store value in floating point register"));
247 put_frame_register (frame
, regnum
, out
);
251 /* The alpha passes the first six arguments in the registers, the rest on
252 the stack. The register arguments are stored in ARG_REG_BUFFER, and
253 then moved into the register file; this simplifies the passing of a
254 large struct which extends from the registers to the stack, plus avoids
255 three ptrace invocations per word.
257 We don't bother tracking which register values should go in integer
258 regs or fp regs; we load the same values into both.
260 If the called function is returning a structure, the address of the
261 structure to be returned is passed as a hidden first argument. */
264 alpha_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
265 struct regcache
*regcache
, CORE_ADDR bp_addr
,
266 int nargs
, struct value
**args
, CORE_ADDR sp
,
267 int struct_return
, CORE_ADDR struct_addr
)
270 int accumulate_size
= struct_return
? 8 : 0;
277 struct alpha_arg
*alpha_args
278 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
279 struct alpha_arg
*m_arg
;
280 char arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
281 int required_arg_regs
;
282 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
284 /* The ABI places the address of the called function in T12. */
285 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
287 /* Set the return address register to point to the entry point
288 of the program, where a breakpoint lies in wait. */
289 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
291 /* Lay out the arguments in memory. */
292 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
294 struct value
*arg
= args
[i
];
295 struct type
*arg_type
= check_typedef (value_type (arg
));
297 /* Cast argument to long if necessary as the compiler does it too. */
298 switch (TYPE_CODE (arg_type
))
303 case TYPE_CODE_RANGE
:
305 if (TYPE_LENGTH (arg_type
) == 4)
307 /* 32-bit values must be sign-extended to 64 bits
308 even if the base data type is unsigned. */
309 arg_type
= builtin_type_int32
;
310 arg
= value_cast (arg_type
, arg
);
312 if (TYPE_LENGTH (arg_type
) < ALPHA_REGISTER_SIZE
)
314 arg_type
= builtin_type_int64
;
315 arg
= value_cast (arg_type
, arg
);
320 /* "float" arguments loaded in registers must be passed in
321 register format, aka "double". */
322 if (accumulate_size
< sizeof (arg_reg_buffer
)
323 && TYPE_LENGTH (arg_type
) == 4)
325 arg_type
= builtin_type_ieee_double_little
;
326 arg
= value_cast (arg_type
, arg
);
328 /* Tru64 5.1 has a 128-bit long double, and passes this by
329 invisible reference. No one else uses this data type. */
330 else if (TYPE_LENGTH (arg_type
) == 16)
332 /* Allocate aligned storage. */
333 sp
= (sp
& -16) - 16;
335 /* Write the real data into the stack. */
336 write_memory (sp
, VALUE_CONTENTS (arg
), 16);
338 /* Construct the indirection. */
339 arg_type
= lookup_pointer_type (arg_type
);
340 arg
= value_from_pointer (arg_type
, sp
);
344 case TYPE_CODE_COMPLEX
:
345 /* ??? The ABI says that complex values are passed as two
346 separate scalar values. This distinction only matters
347 for complex float. However, GCC does not implement this. */
349 /* Tru64 5.1 has a 128-bit long double, and passes this by
350 invisible reference. */
351 if (TYPE_LENGTH (arg_type
) == 32)
353 /* Allocate aligned storage. */
354 sp
= (sp
& -16) - 16;
356 /* Write the real data into the stack. */
357 write_memory (sp
, VALUE_CONTENTS (arg
), 32);
359 /* Construct the indirection. */
360 arg_type
= lookup_pointer_type (arg_type
);
361 arg
= value_from_pointer (arg_type
, sp
);
368 m_arg
->len
= TYPE_LENGTH (arg_type
);
369 m_arg
->offset
= accumulate_size
;
370 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
371 m_arg
->contents
= VALUE_CONTENTS (arg
);
374 /* Determine required argument register loads, loading an argument register
375 is expensive as it uses three ptrace calls. */
376 required_arg_regs
= accumulate_size
/ 8;
377 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
378 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
380 /* Make room for the arguments on the stack. */
381 if (accumulate_size
< sizeof(arg_reg_buffer
))
384 accumulate_size
-= sizeof(arg_reg_buffer
);
385 sp
-= accumulate_size
;
387 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
390 /* `Push' arguments on the stack. */
391 for (i
= nargs
; m_arg
--, --i
>= 0;)
393 char *contents
= m_arg
->contents
;
394 int offset
= m_arg
->offset
;
395 int len
= m_arg
->len
;
397 /* Copy the bytes destined for registers into arg_reg_buffer. */
398 if (offset
< sizeof(arg_reg_buffer
))
400 if (offset
+ len
<= sizeof(arg_reg_buffer
))
402 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
407 int tlen
= sizeof(arg_reg_buffer
) - offset
;
408 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
415 /* Everything else goes to the stack. */
416 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
419 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
421 /* Load the argument registers. */
422 for (i
= 0; i
< required_arg_regs
; i
++)
424 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
425 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
426 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
427 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
430 /* Finally, update the stack pointer. */
431 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
436 /* Extract from REGCACHE the value about to be returned from a function
437 and copy it into VALBUF. */
440 alpha_extract_return_value (struct type
*valtype
, struct regcache
*regcache
,
443 int length
= TYPE_LENGTH (valtype
);
444 char raw_buffer
[ALPHA_REGISTER_SIZE
];
447 switch (TYPE_CODE (valtype
))
453 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
454 alpha_sts (valbuf
, raw_buffer
);
458 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
462 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
463 read_memory (l
, valbuf
, 16);
467 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
471 case TYPE_CODE_COMPLEX
:
475 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
476 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
480 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
481 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
+1,
486 regcache_cooked_read_signed (regcache
, ALPHA_V0_REGNUM
, &l
);
487 read_memory (l
, valbuf
, 32);
491 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
496 /* Assume everything else degenerates to an integer. */
497 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
498 store_unsigned_integer (valbuf
, length
, l
);
503 /* Extract from REGCACHE the address of a structure about to be returned
507 alpha_extract_struct_value_address (struct regcache
*regcache
)
510 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
514 /* Insert the given value into REGCACHE as if it was being
515 returned by a function. */
518 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
521 int length
= TYPE_LENGTH (valtype
);
522 char raw_buffer
[ALPHA_REGISTER_SIZE
];
525 switch (TYPE_CODE (valtype
))
531 alpha_lds (raw_buffer
, valbuf
);
532 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
536 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
540 /* FIXME: 128-bit long doubles are returned like structures:
541 by writing into indirect storage provided by the caller
542 as the first argument. */
543 error (_("Cannot set a 128-bit long double return value."));
546 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
550 case TYPE_CODE_COMPLEX
:
554 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
555 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
559 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
560 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
+1,
561 (const char *)valbuf
+ 8);
565 /* FIXME: 128-bit long doubles are returned like structures:
566 by writing into indirect storage provided by the caller
567 as the first argument. */
568 error (_("Cannot set a 128-bit long double return value."));
571 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
576 /* Assume everything else degenerates to an integer. */
577 /* 32-bit values must be sign-extended to 64 bits
578 even if the base data type is unsigned. */
580 valtype
= builtin_type_int32
;
581 l
= unpack_long (valtype
, valbuf
);
582 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
588 static const unsigned char *
589 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
591 static const unsigned char alpha_breakpoint
[] =
592 { 0x80, 0, 0, 0 }; /* call_pal bpt */
594 *lenptr
= sizeof(alpha_breakpoint
);
595 return (alpha_breakpoint
);
599 /* This returns the PC of the first insn after the prologue.
600 If we can't find the prologue, then return 0. */
603 alpha_after_prologue (CORE_ADDR pc
)
605 struct symtab_and_line sal
;
606 CORE_ADDR func_addr
, func_end
;
608 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
611 sal
= find_pc_line (func_addr
, 0);
612 if (sal
.end
< func_end
)
615 /* The line after the prologue is after the end of the function. In this
616 case, tell the caller to find the prologue the hard way. */
620 /* Read an instruction from memory at PC, looking through breakpoints. */
623 alpha_read_insn (CORE_ADDR pc
)
628 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
630 memory_error (status
, pc
);
631 return extract_unsigned_integer (buf
, 4);
634 /* To skip prologues, I use this predicate. Returns either PC itself
635 if the code at PC does not look like a function prologue; otherwise
636 returns an address that (if we're lucky) follows the prologue. If
637 LENIENT, then we must skip everything which is involved in setting
638 up the frame (it's OK to skip more, just so long as we don't skip
639 anything which might clobber the registers which are being saved. */
642 alpha_skip_prologue (CORE_ADDR pc
)
646 CORE_ADDR post_prologue_pc
;
649 /* Silently return the unaltered pc upon memory errors.
650 This could happen on OSF/1 if decode_line_1 tries to skip the
651 prologue for quickstarted shared library functions when the
652 shared library is not yet mapped in.
653 Reading target memory is slow over serial lines, so we perform
654 this check only if the target has shared libraries (which all
655 Alpha targets do). */
656 if (target_read_memory (pc
, buf
, 4))
659 /* See if we can determine the end of the prologue via the symbol table.
660 If so, then return either PC, or the PC after the prologue, whichever
663 post_prologue_pc
= alpha_after_prologue (pc
);
664 if (post_prologue_pc
!= 0)
665 return max (pc
, post_prologue_pc
);
667 /* Can't determine prologue from the symbol table, need to examine
670 /* Skip the typical prologue instructions. These are the stack adjustment
671 instruction and the instructions that save registers on the stack
672 or in the gcc frame. */
673 for (offset
= 0; offset
< 100; offset
+= 4)
675 inst
= alpha_read_insn (pc
+ offset
);
677 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
679 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
681 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
683 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
686 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
687 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
688 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
691 if (inst
== 0x47de040f) /* bis sp,sp,fp */
693 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
702 /* Figure out where the longjmp will land.
703 We expect the first arg to be a pointer to the jmp_buf structure from
704 which we extract the PC (JB_PC) that we will land at. The PC is copied
705 into the "pc". This routine returns true on success. */
708 alpha_get_longjmp_target (CORE_ADDR
*pc
)
710 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
712 char raw_buffer
[ALPHA_REGISTER_SIZE
];
714 jb_addr
= read_register (ALPHA_A0_REGNUM
);
716 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
717 raw_buffer
, tdep
->jb_elt_size
))
720 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
725 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
726 describe the location and shape of the sigcontext structure. After
727 that, all registers are in memory, so it's easy. */
728 /* ??? Shouldn't we be able to do this generically, rather than with
729 OSABI data specific to Alpha? */
731 struct alpha_sigtramp_unwind_cache
733 CORE_ADDR sigcontext_addr
;
736 static struct alpha_sigtramp_unwind_cache
*
737 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
738 void **this_prologue_cache
)
740 struct alpha_sigtramp_unwind_cache
*info
;
741 struct gdbarch_tdep
*tdep
;
743 if (*this_prologue_cache
)
744 return *this_prologue_cache
;
746 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
747 *this_prologue_cache
= info
;
749 tdep
= gdbarch_tdep (current_gdbarch
);
750 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
755 /* Return the address of REGNUM in a sigtramp frame. Since this is
756 all arithmetic, it doesn't seem worthwhile to cache it. */
759 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, int regnum
)
761 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
763 if (regnum
>= 0 && regnum
< 32)
764 return sigcontext_addr
+ tdep
->sc_regs_offset
+ regnum
* 8;
765 else if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 32)
766 return sigcontext_addr
+ tdep
->sc_fpregs_offset
+ regnum
* 8;
767 else if (regnum
== ALPHA_PC_REGNUM
)
768 return sigcontext_addr
+ tdep
->sc_pc_offset
;
773 /* Given a GDB frame, determine the address of the calling function's
774 frame. This will be used to create a new GDB frame struct. */
777 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
778 void **this_prologue_cache
,
779 struct frame_id
*this_id
)
781 struct alpha_sigtramp_unwind_cache
*info
782 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
783 struct gdbarch_tdep
*tdep
;
784 CORE_ADDR stack_addr
, code_addr
;
786 /* If the OSABI couldn't locate the sigcontext, give up. */
787 if (info
->sigcontext_addr
== 0)
790 /* If we have dynamic signal trampolines, find their start.
791 If we do not, then we must assume there is a symbol record
792 that can provide the start address. */
793 tdep
= gdbarch_tdep (current_gdbarch
);
794 if (tdep
->dynamic_sigtramp_offset
)
797 code_addr
= frame_pc_unwind (next_frame
);
798 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
805 code_addr
= frame_func_unwind (next_frame
);
807 /* The stack address is trivially read from the sigcontext. */
808 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
810 stack_addr
= get_frame_memory_unsigned (next_frame
, stack_addr
,
811 ALPHA_REGISTER_SIZE
);
813 *this_id
= frame_id_build (stack_addr
, code_addr
);
816 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
819 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
820 void **this_prologue_cache
,
821 int regnum
, int *optimizedp
,
822 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
823 int *realnump
, void *bufferp
)
825 struct alpha_sigtramp_unwind_cache
*info
826 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
829 if (info
->sigcontext_addr
!= 0)
831 /* All integer and fp registers are stored in memory. */
832 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
836 *lvalp
= lval_memory
;
840 get_frame_memory (next_frame
, addr
, bufferp
, ALPHA_REGISTER_SIZE
);
845 /* This extra register may actually be in the sigcontext, but our
846 current description of it in alpha_sigtramp_frame_unwind_cache
847 doesn't include it. Too bad. Fall back on whatever's in the
849 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
853 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
855 alpha_sigtramp_frame_this_id
,
856 alpha_sigtramp_frame_prev_register
859 static const struct frame_unwind
*
860 alpha_sigtramp_frame_sniffer (struct frame_info
*next_frame
)
862 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
865 /* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
866 look at tramp-frame.h and other simplier per-architecture
867 sigtramp unwinders. */
869 /* We shouldn't even bother to try if the OSABI didn't register a
870 sigcontext_addr handler or pc_in_sigtramp hander. */
871 if (gdbarch_tdep (current_gdbarch
)->sigcontext_addr
== NULL
)
873 if (gdbarch_tdep (current_gdbarch
)->pc_in_sigtramp
== NULL
)
876 /* Otherwise we should be in a signal frame. */
877 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
878 if (gdbarch_tdep (current_gdbarch
)->pc_in_sigtramp (pc
, name
))
879 return &alpha_sigtramp_frame_unwind
;
884 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
885 something about the traditional layout of alpha stack frames. */
887 struct alpha_heuristic_unwind_cache
889 CORE_ADDR
*saved_regs
;
895 /* Heuristic_proc_start may hunt through the text section for a long
896 time across a 2400 baud serial line. Allows the user to limit this
898 static unsigned int heuristic_fence_post
= 0;
900 /* Attempt to locate the start of the function containing PC. We assume that
901 the previous function ends with an about_to_return insn. Not foolproof by
902 any means, since gcc is happy to put the epilogue in the middle of a
903 function. But we're guessing anyway... */
906 alpha_heuristic_proc_start (CORE_ADDR pc
)
908 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
909 CORE_ADDR last_non_nop
= pc
;
910 CORE_ADDR fence
= pc
- heuristic_fence_post
;
911 CORE_ADDR orig_pc
= pc
;
917 /* First see if we can find the start of the function from minimal
918 symbol information. This can succeed with a binary that doesn't
919 have debug info, but hasn't been stripped. */
920 func
= get_pc_function_start (pc
);
924 if (heuristic_fence_post
== UINT_MAX
925 || fence
< tdep
->vm_min_address
)
926 fence
= tdep
->vm_min_address
;
928 /* Search back for previous return; also stop at a 0, which might be
929 seen for instance before the start of a code section. Don't include
930 nops, since this usually indicates padding between functions. */
931 for (pc
-= 4; pc
>= fence
; pc
-= 4)
933 unsigned int insn
= alpha_read_insn (pc
);
936 case 0: /* invalid insn */
937 case 0x6bfa8001: /* ret $31,($26),1 */
940 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
941 case 0x47ff041f: /* nop: bis $31,$31,$31 */
950 /* It's not clear to me why we reach this point when stopping quietly,
951 but with this test, at least we don't print out warnings for every
952 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
953 if (stop_soon
== NO_STOP_QUIETLY
)
955 static int blurb_printed
= 0;
957 if (fence
== tdep
->vm_min_address
)
958 warning (_("Hit beginning of text section without finding \
959 enclosing function for address 0x%s"), paddr_nz (orig_pc
));
961 warning (_("Hit heuristic-fence-post without finding \
962 enclosing function for address 0x%s"), paddr_nz (orig_pc
));
966 printf_filtered (_("\
967 This warning occurs if you are debugging a function without any symbols\n\
968 (for example, in a stripped executable). In that case, you may wish to\n\
969 increase the size of the search with the `set heuristic-fence-post' command.\n\
971 Otherwise, you told GDB there was a function where there isn't one, or\n\
972 (more likely) you have encountered a bug in GDB.\n"));
980 static struct alpha_heuristic_unwind_cache
*
981 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
982 void **this_prologue_cache
,
985 struct alpha_heuristic_unwind_cache
*info
;
987 CORE_ADDR limit_pc
, cur_pc
;
988 int frame_reg
, frame_size
, return_reg
, reg
;
990 if (*this_prologue_cache
)
991 return *this_prologue_cache
;
993 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
994 *this_prologue_cache
= info
;
995 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
997 limit_pc
= frame_pc_unwind (next_frame
);
999 start_pc
= alpha_heuristic_proc_start (limit_pc
);
1000 info
->start_pc
= start_pc
;
1002 frame_reg
= ALPHA_SP_REGNUM
;
1006 /* If we've identified a likely place to start, do code scanning. */
1009 /* Limit the forward search to 50 instructions. */
1010 if (start_pc
+ 200 < limit_pc
)
1011 limit_pc
= start_pc
+ 200;
1013 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
1015 unsigned int word
= alpha_read_insn (cur_pc
);
1017 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1021 /* Consider only the first stack allocation instruction
1022 to contain the static size of the frame. */
1023 if (frame_size
== 0)
1024 frame_size
= (-word
) & 0xffff;
1028 /* Exit loop if a positive stack adjustment is found, which
1029 usually means that the stack cleanup code in the function
1030 epilogue is reached. */
1034 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1036 reg
= (word
& 0x03e00000) >> 21;
1038 /* Ignore this instruction if we have already encountered
1039 an instruction saving the same register earlier in the
1040 function code. The current instruction does not tell
1041 us where the original value upon function entry is saved.
1042 All it says is that the function we are scanning reused
1043 that register for some computation of its own, and is now
1044 saving its result. */
1045 if (info
->saved_regs
[reg
])
1051 /* Do not compute the address where the register was saved yet,
1052 because we don't know yet if the offset will need to be
1053 relative to $sp or $fp (we can not compute the address
1054 relative to $sp if $sp is updated during the execution of
1055 the current subroutine, for instance when doing some alloca).
1056 So just store the offset for the moment, and compute the
1057 address later when we know whether this frame has a frame
1059 /* Hack: temporarily add one, so that the offset is non-zero
1060 and we can tell which registers have save offsets below. */
1061 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
1063 /* Starting with OSF/1-3.2C, the system libraries are shipped
1064 without local symbols, but they still contain procedure
1065 descriptors without a symbol reference. GDB is currently
1066 unable to find these procedure descriptors and uses
1067 heuristic_proc_desc instead.
1068 As some low level compiler support routines (__div*, __add*)
1069 use a non-standard return address register, we have to
1070 add some heuristics to determine the return address register,
1071 or stepping over these routines will fail.
1072 Usually the return address register is the first register
1073 saved on the stack, but assembler optimization might
1074 rearrange the register saves.
1075 So we recognize only a few registers (t7, t9, ra) within
1076 the procedure prologue as valid return address registers.
1077 If we encounter a return instruction, we extract the
1078 the return address register from it.
1080 FIXME: Rewriting GDB to access the procedure descriptors,
1081 e.g. via the minimal symbol table, might obviate this hack. */
1082 if (return_reg
== -1
1083 && cur_pc
< (start_pc
+ 80)
1084 && (reg
== ALPHA_T7_REGNUM
1085 || reg
== ALPHA_T9_REGNUM
1086 || reg
== ALPHA_RA_REGNUM
))
1089 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1090 return_reg
= (word
>> 16) & 0x1f;
1091 else if (word
== 0x47de040f) /* bis sp,sp,fp */
1092 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1093 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
1094 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1097 /* If we haven't found a valid return address register yet, keep
1098 searching in the procedure prologue. */
1099 if (return_reg
== -1)
1101 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
1103 unsigned int word
= alpha_read_insn (cur_pc
);
1105 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1107 reg
= (word
& 0x03e00000) >> 21;
1108 if (reg
== ALPHA_T7_REGNUM
1109 || reg
== ALPHA_T9_REGNUM
1110 || reg
== ALPHA_RA_REGNUM
)
1116 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1118 return_reg
= (word
>> 16) & 0x1f;
1127 /* Failing that, do default to the customary RA. */
1128 if (return_reg
== -1)
1129 return_reg
= ALPHA_RA_REGNUM
;
1130 info
->return_reg
= return_reg
;
1132 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
1133 info
->vfp
= val
+ frame_size
;
1135 /* Convert offsets to absolute addresses. See above about adding
1136 one to the offsets to make all detected offsets non-zero. */
1137 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1138 if (info
->saved_regs
[reg
])
1139 info
->saved_regs
[reg
] += val
- 1;
1144 /* Given a GDB frame, determine the address of the calling function's
1145 frame. This will be used to create a new GDB frame struct. */
1148 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
1149 void **this_prologue_cache
,
1150 struct frame_id
*this_id
)
1152 struct alpha_heuristic_unwind_cache
*info
1153 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1155 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1158 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1161 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
1162 void **this_prologue_cache
,
1163 int regnum
, int *optimizedp
,
1164 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1165 int *realnump
, void *bufferp
)
1167 struct alpha_heuristic_unwind_cache
*info
1168 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1170 /* The PC of the previous frame is stored in the link register of
1171 the current frame. Frob regnum so that we pull the value from
1172 the correct place. */
1173 if (regnum
== ALPHA_PC_REGNUM
)
1174 regnum
= info
->return_reg
;
1176 /* For all registers known to be saved in the current frame,
1177 do the obvious and pull the value out. */
1178 if (info
->saved_regs
[regnum
])
1181 *lvalp
= lval_memory
;
1182 *addrp
= info
->saved_regs
[regnum
];
1184 if (bufferp
!= NULL
)
1185 get_frame_memory (next_frame
, *addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1189 /* The stack pointer of the previous frame is computed by popping
1190 the current stack frame. */
1191 if (regnum
== ALPHA_SP_REGNUM
)
1197 if (bufferp
!= NULL
)
1198 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1202 /* Otherwise assume the next frame has the same register value. */
1203 frame_register_unwind (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1207 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1209 alpha_heuristic_frame_this_id
,
1210 alpha_heuristic_frame_prev_register
1213 static const struct frame_unwind
*
1214 alpha_heuristic_frame_sniffer (struct frame_info
*next_frame
)
1216 return &alpha_heuristic_frame_unwind
;
1220 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1221 void **this_prologue_cache
)
1223 struct alpha_heuristic_unwind_cache
*info
1224 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1229 static const struct frame_base alpha_heuristic_frame_base
= {
1230 &alpha_heuristic_frame_unwind
,
1231 alpha_heuristic_frame_base_address
,
1232 alpha_heuristic_frame_base_address
,
1233 alpha_heuristic_frame_base_address
1236 /* Just like reinit_frame_cache, but with the right arguments to be
1237 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1240 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1242 reinit_frame_cache ();
1246 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1247 dummy frame. The frame ID's base needs to match the TOS value
1248 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1251 static struct frame_id
1252 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1255 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1256 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1260 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1263 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1268 /* Helper routines for alpha*-nat.c files to move register sets to and
1269 from core files. The UNIQUE pointer is allowed to be NULL, as most
1270 targets don't supply this value in their core files. */
1273 alpha_supply_int_regs (int regno
, const void *r0_r30
,
1274 const void *pc
, const void *unique
)
1278 for (i
= 0; i
< 31; ++i
)
1279 if (regno
== i
|| regno
== -1)
1280 regcache_raw_supply (current_regcache
, i
, (const char *)r0_r30
+ i
*8);
1282 if (regno
== ALPHA_ZERO_REGNUM
|| regno
== -1)
1283 regcache_raw_supply (current_regcache
, ALPHA_ZERO_REGNUM
, NULL
);
1285 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1286 regcache_raw_supply (current_regcache
, ALPHA_PC_REGNUM
, pc
);
1288 if (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1)
1289 regcache_raw_supply (current_regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1293 alpha_fill_int_regs (int regno
, void *r0_r30
, void *pc
, void *unique
)
1297 for (i
= 0; i
< 31; ++i
)
1298 if (regno
== i
|| regno
== -1)
1299 regcache_raw_collect (current_regcache
, i
, (char *)r0_r30
+ i
*8);
1301 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1302 regcache_raw_collect (current_regcache
, ALPHA_PC_REGNUM
, pc
);
1304 if (unique
&& (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1))
1305 regcache_raw_collect (current_regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1309 alpha_supply_fp_regs (int regno
, const void *f0_f30
, const void *fpcr
)
1313 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1314 if (regno
== i
|| regno
== -1)
1315 regcache_raw_supply (current_regcache
, i
,
1316 (const char *)f0_f30
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1318 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1319 regcache_raw_supply (current_regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1323 alpha_fill_fp_regs (int regno
, void *f0_f30
, void *fpcr
)
1327 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1328 if (regno
== i
|| regno
== -1)
1329 regcache_raw_collect (current_regcache
, i
,
1330 (char *)f0_f30
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1332 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1333 regcache_raw_collect (current_regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1337 /* alpha_software_single_step() is called just before we want to resume
1338 the inferior, if we want to single-step it but there is no hardware
1339 or kernel single-step support (NetBSD on Alpha, for example). We find
1340 the target of the coming instruction and breakpoint it.
1342 single_step is also called just after the inferior stops. If we had
1343 set up a simulated single-step, we undo our damage. */
1346 alpha_next_pc (CORE_ADDR pc
)
1353 insn
= alpha_read_insn (pc
);
1355 /* Opcode is top 6 bits. */
1356 op
= (insn
>> 26) & 0x3f;
1360 /* Jump format: target PC is:
1362 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1365 if ((op
& 0x30) == 0x30)
1367 /* Branch format: target PC is:
1368 (new PC) + (4 * sext(displacement)) */
1369 if (op
== 0x30 || /* BR */
1370 op
== 0x34) /* BSR */
1373 offset
= (insn
& 0x001fffff);
1374 if (offset
& 0x00100000)
1375 offset
|= 0xffe00000;
1377 return (pc
+ 4 + offset
);
1380 /* Need to determine if branch is taken; read RA. */
1381 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1384 case 0x38: /* BLBC */
1388 case 0x3c: /* BLBS */
1392 case 0x39: /* BEQ */
1396 case 0x3d: /* BNE */
1400 case 0x3a: /* BLT */
1404 case 0x3b: /* BLE */
1408 case 0x3f: /* BGT */
1412 case 0x3e: /* BGE */
1417 /* ??? Missing floating-point branches. */
1421 /* Not a branch or branch not taken; target PC is:
1427 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1429 static CORE_ADDR next_pc
;
1430 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1431 static binsn_quantum break_mem
;
1434 if (insert_breakpoints_p
)
1437 next_pc
= alpha_next_pc (pc
);
1439 target_insert_breakpoint (next_pc
, break_mem
);
1443 target_remove_breakpoint (next_pc
, break_mem
);
1449 /* Initialize the current architecture based on INFO. If possible, re-use an
1450 architecture from ARCHES, which is a list of architectures already created
1451 during this debugging session.
1453 Called e.g. at program startup, when reading a core file, and when reading
1456 static struct gdbarch
*
1457 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1459 struct gdbarch_tdep
*tdep
;
1460 struct gdbarch
*gdbarch
;
1462 /* Try to determine the ABI of the object we are loading. */
1463 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1465 /* If it's an ECOFF file, assume it's OSF/1. */
1466 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1467 info
.osabi
= GDB_OSABI_OSF1
;
1470 /* Find a candidate among extant architectures. */
1471 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1473 return arches
->gdbarch
;
1475 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1476 gdbarch
= gdbarch_alloc (&info
, tdep
);
1478 /* Lowest text address. This is used by heuristic_proc_start()
1479 to decide when to stop looking. */
1480 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000LL
;
1482 tdep
->dynamic_sigtramp_offset
= NULL
;
1483 tdep
->sigcontext_addr
= NULL
;
1484 tdep
->sc_pc_offset
= 2 * 8;
1485 tdep
->sc_regs_offset
= 4 * 8;
1486 tdep
->sc_fpregs_offset
= tdep
->sc_regs_offset
+ 32 * 8 + 8;
1488 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1491 set_gdbarch_short_bit (gdbarch
, 16);
1492 set_gdbarch_int_bit (gdbarch
, 32);
1493 set_gdbarch_long_bit (gdbarch
, 64);
1494 set_gdbarch_long_long_bit (gdbarch
, 64);
1495 set_gdbarch_float_bit (gdbarch
, 32);
1496 set_gdbarch_double_bit (gdbarch
, 64);
1497 set_gdbarch_long_double_bit (gdbarch
, 64);
1498 set_gdbarch_ptr_bit (gdbarch
, 64);
1501 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1502 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1503 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1504 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1506 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1507 set_gdbarch_deprecated_register_byte (gdbarch
, alpha_register_byte
);
1508 set_gdbarch_register_type (gdbarch
, alpha_register_type
);
1510 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1511 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1513 set_gdbarch_convert_register_p (gdbarch
, alpha_convert_register_p
);
1514 set_gdbarch_register_to_value (gdbarch
, alpha_register_to_value
);
1515 set_gdbarch_value_to_register (gdbarch
, alpha_value_to_register
);
1517 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1519 /* Prologue heuristics. */
1520 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1523 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1527 set_gdbarch_deprecated_use_struct_convention (gdbarch
, always_use_struct_convention
);
1528 set_gdbarch_extract_return_value (gdbarch
, alpha_extract_return_value
);
1529 set_gdbarch_store_return_value (gdbarch
, alpha_store_return_value
);
1530 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
, alpha_extract_struct_value_address
);
1532 /* Settings for calling functions in the inferior. */
1533 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1535 /* Methods for saving / extracting a dummy frame's ID. */
1536 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1538 /* Return the unwound PC value. */
1539 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1541 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1542 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1544 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1545 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1547 /* Hook in ABI-specific overrides, if they have been registered. */
1548 gdbarch_init_osabi (info
, gdbarch
);
1550 /* Now that we have tuned the configuration, set a few final things
1551 based on what the OS ABI has told us. */
1553 if (tdep
->jb_pc
>= 0)
1554 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1556 frame_unwind_append_sniffer (gdbarch
, alpha_sigtramp_frame_sniffer
);
1557 frame_unwind_append_sniffer (gdbarch
, alpha_heuristic_frame_sniffer
);
1559 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1565 alpha_dwarf2_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1567 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1568 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
1571 extern initialize_file_ftype _initialize_alpha_tdep
; /* -Wmissing-prototypes */
1574 _initialize_alpha_tdep (void)
1576 struct cmd_list_element
*c
;
1578 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1580 /* Let the user set the fence post for heuristic_proc_start. */
1582 /* We really would like to have both "0" and "unlimited" work, but
1583 command.c doesn't deal with that. So make it a var_zinteger
1584 because the user can always use "999999" or some such for unlimited. */
1585 /* We need to throw away the frame cache when we set this, since it
1586 might change our ability to get backtraces. */
1587 add_setshow_zinteger_cmd ("heuristic-fence-post", class_support
,
1588 &heuristic_fence_post
,
1590 Set the distance searched for the start of a function."),
1592 Show the distance searched for the start of a function."),
1594 If you are debugging a stripped executable, GDB needs to search through the\n\
1595 program for the start of a function. This command sets the distance of the\n\
1596 search. The only need to set it is when debugging a stripped executable."),
1598 The distance searched for the start of a function is \"%d\"."),
1599 reinit_frame_cache_sfunc
, NULL
,
1600 &setlist
, &showlist
);