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"
51 alpha_register_name (int regno
)
53 static const char * const register_names
[] =
55 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
56 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
57 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
58 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
59 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
60 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
61 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
62 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
68 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
70 return register_names
[regno
];
74 alpha_cannot_fetch_register (int regno
)
76 return regno
== ALPHA_ZERO_REGNUM
;
80 alpha_cannot_store_register (int regno
)
82 return regno
== ALPHA_ZERO_REGNUM
;
86 alpha_register_type (struct gdbarch
*gdbarch
, int regno
)
88 if (regno
== ALPHA_SP_REGNUM
|| regno
== ALPHA_GP_REGNUM
)
89 return builtin_type_void_data_ptr
;
90 if (regno
== ALPHA_PC_REGNUM
)
91 return builtin_type_void_func_ptr
;
93 /* Don't need to worry about little vs big endian until
94 some jerk tries to port to alpha-unicosmk. */
95 if (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31)
96 return builtin_type_ieee_double_little
;
98 return builtin_type_int64
;
101 /* Is REGNUM a member of REGGROUP? */
104 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
105 struct reggroup
*group
)
107 /* Filter out any registers eliminated, but whose regnum is
108 reserved for backward compatibility, e.g. the vfp. */
109 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
112 if (group
== all_reggroup
)
115 /* Zero should not be saved or restored. Technically it is a general
116 register (just as $f31 would be a float if we represented it), but
117 there's no point displaying it during "info regs", so leave it out
118 of all groups except for "all". */
119 if (regnum
== ALPHA_ZERO_REGNUM
)
122 /* All other registers are saved and restored. */
123 if (group
== save_reggroup
|| group
== restore_reggroup
)
126 /* All other groups are non-overlapping. */
128 /* Since this is really a PALcode memory slot... */
129 if (regnum
== ALPHA_UNIQUE_REGNUM
)
130 return group
== system_reggroup
;
132 /* Force the FPCR to be considered part of the floating point state. */
133 if (regnum
== ALPHA_FPCR_REGNUM
)
134 return group
== float_reggroup
;
136 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
137 return group
== float_reggroup
;
139 return group
== general_reggroup
;
143 alpha_register_byte (int regno
)
148 /* The following represents exactly the conversion performed by
149 the LDS instruction. This applies to both single-precision
150 floating point and 32-bit integers. */
153 alpha_lds (void *out
, const void *in
)
155 ULONGEST mem
= extract_unsigned_integer (in
, 4);
156 ULONGEST frac
= (mem
>> 0) & 0x7fffff;
157 ULONGEST sign
= (mem
>> 31) & 1;
158 ULONGEST exp_msb
= (mem
>> 30) & 1;
159 ULONGEST exp_low
= (mem
>> 23) & 0x7f;
162 exp
= (exp_msb
<< 10) | exp_low
;
174 reg
= (sign
<< 63) | (exp
<< 52) | (frac
<< 29);
175 store_unsigned_integer (out
, 8, reg
);
178 /* Similarly, this represents exactly the conversion performed by
179 the STS instruction. */
182 alpha_sts (void *out
, const void *in
)
186 reg
= extract_unsigned_integer (in
, 8);
187 mem
= ((reg
>> 32) & 0xc0000000) | ((reg
>> 29) & 0x3fffffff);
188 store_unsigned_integer (out
, 4, mem
);
191 /* The alpha needs a conversion between register and memory format if the
192 register is a floating point register and memory format is float, as the
193 register format must be double or memory format is an integer with 4
194 bytes or less, as the representation of integers in floating point
195 registers is different. */
198 alpha_convert_register_p (int regno
, struct type
*type
)
200 return (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31);
204 alpha_register_to_value (struct frame_info
*frame
, int regnum
,
205 struct type
*valtype
, void *out
)
207 char in
[MAX_REGISTER_SIZE
];
208 frame_register_read (frame
, regnum
, in
);
209 switch (TYPE_LENGTH (valtype
))
218 error ("Cannot retrieve value from floating point register");
223 alpha_value_to_register (struct frame_info
*frame
, int regnum
,
224 struct type
*valtype
, const void *in
)
226 char out
[MAX_REGISTER_SIZE
];
227 switch (TYPE_LENGTH (valtype
))
236 error ("Cannot store value in floating point register");
238 put_frame_register (frame
, regnum
, out
);
242 /* The alpha passes the first six arguments in the registers, the rest on
243 the stack. The register arguments are stored in ARG_REG_BUFFER, and
244 then moved into the register file; this simplifies the passing of a
245 large struct which extends from the registers to the stack, plus avoids
246 three ptrace invocations per word.
248 We don't bother tracking which register values should go in integer
249 regs or fp regs; we load the same values into both.
251 If the called function is returning a structure, the address of the
252 structure to be returned is passed as a hidden first argument. */
255 alpha_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
256 struct regcache
*regcache
, CORE_ADDR bp_addr
,
257 int nargs
, struct value
**args
, CORE_ADDR sp
,
258 int struct_return
, CORE_ADDR struct_addr
)
261 int accumulate_size
= struct_return
? 8 : 0;
268 struct alpha_arg
*alpha_args
269 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
270 struct alpha_arg
*m_arg
;
271 char arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
272 int required_arg_regs
;
273 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
275 /* The ABI places the address of the called function in T12. */
276 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
278 /* Set the return address register to point to the entry point
279 of the program, where a breakpoint lies in wait. */
280 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
282 /* Lay out the arguments in memory. */
283 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
285 struct value
*arg
= args
[i
];
286 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
288 /* Cast argument to long if necessary as the compiler does it too. */
289 switch (TYPE_CODE (arg_type
))
294 case TYPE_CODE_RANGE
:
296 if (TYPE_LENGTH (arg_type
) == 4)
298 /* 32-bit values must be sign-extended to 64 bits
299 even if the base data type is unsigned. */
300 arg_type
= builtin_type_int32
;
301 arg
= value_cast (arg_type
, arg
);
303 if (TYPE_LENGTH (arg_type
) < ALPHA_REGISTER_SIZE
)
305 arg_type
= builtin_type_int64
;
306 arg
= value_cast (arg_type
, arg
);
311 /* "float" arguments loaded in registers must be passed in
312 register format, aka "double". */
313 if (accumulate_size
< sizeof (arg_reg_buffer
)
314 && TYPE_LENGTH (arg_type
) == 4)
316 arg_type
= builtin_type_ieee_double_little
;
317 arg
= value_cast (arg_type
, arg
);
319 /* Tru64 5.1 has a 128-bit long double, and passes this by
320 invisible reference. No one else uses this data type. */
321 else if (TYPE_LENGTH (arg_type
) == 16)
323 /* Allocate aligned storage. */
324 sp
= (sp
& -16) - 16;
326 /* Write the real data into the stack. */
327 write_memory (sp
, VALUE_CONTENTS (arg
), 16);
329 /* Construct the indirection. */
330 arg_type
= lookup_pointer_type (arg_type
);
331 arg
= value_from_pointer (arg_type
, sp
);
335 case TYPE_CODE_COMPLEX
:
336 /* ??? The ABI says that complex values are passed as two
337 separate scalar values. This distinction only matters
338 for complex float. However, GCC does not implement this. */
340 /* Tru64 5.1 has a 128-bit long double, and passes this by
341 invisible reference. */
342 if (TYPE_LENGTH (arg_type
) == 32)
344 /* Allocate aligned storage. */
345 sp
= (sp
& -16) - 16;
347 /* Write the real data into the stack. */
348 write_memory (sp
, VALUE_CONTENTS (arg
), 32);
350 /* Construct the indirection. */
351 arg_type
= lookup_pointer_type (arg_type
);
352 arg
= value_from_pointer (arg_type
, sp
);
359 m_arg
->len
= TYPE_LENGTH (arg_type
);
360 m_arg
->offset
= accumulate_size
;
361 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
362 m_arg
->contents
= VALUE_CONTENTS (arg
);
365 /* Determine required argument register loads, loading an argument register
366 is expensive as it uses three ptrace calls. */
367 required_arg_regs
= accumulate_size
/ 8;
368 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
369 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
371 /* Make room for the arguments on the stack. */
372 if (accumulate_size
< sizeof(arg_reg_buffer
))
375 accumulate_size
-= sizeof(arg_reg_buffer
);
376 sp
-= accumulate_size
;
378 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
381 /* `Push' arguments on the stack. */
382 for (i
= nargs
; m_arg
--, --i
>= 0;)
384 char *contents
= m_arg
->contents
;
385 int offset
= m_arg
->offset
;
386 int len
= m_arg
->len
;
388 /* Copy the bytes destined for registers into arg_reg_buffer. */
389 if (offset
< sizeof(arg_reg_buffer
))
391 if (offset
+ len
<= sizeof(arg_reg_buffer
))
393 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
398 int tlen
= sizeof(arg_reg_buffer
) - offset
;
399 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
406 /* Everything else goes to the stack. */
407 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
410 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
412 /* Load the argument registers. */
413 for (i
= 0; i
< required_arg_regs
; i
++)
415 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
416 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
417 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
418 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
421 /* Finally, update the stack pointer. */
422 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
427 /* Extract from REGCACHE the value about to be returned from a function
428 and copy it into VALBUF. */
431 alpha_extract_return_value (struct type
*valtype
, struct regcache
*regcache
,
434 int length
= TYPE_LENGTH (valtype
);
435 char raw_buffer
[ALPHA_REGISTER_SIZE
];
438 switch (TYPE_CODE (valtype
))
444 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
445 alpha_sts (valbuf
, raw_buffer
);
449 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
453 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
454 read_memory (l
, valbuf
, 16);
458 internal_error (__FILE__
, __LINE__
, "unknown floating point width");
462 case TYPE_CODE_COMPLEX
:
466 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
467 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
471 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
472 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
+1,
477 regcache_cooked_read_signed (regcache
, ALPHA_V0_REGNUM
, &l
);
478 read_memory (l
, valbuf
, 32);
482 internal_error (__FILE__
, __LINE__
, "unknown floating point width");
487 /* Assume everything else degenerates to an integer. */
488 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
489 store_unsigned_integer (valbuf
, length
, l
);
494 /* Extract from REGCACHE the address of a structure about to be returned
498 alpha_extract_struct_value_address (struct regcache
*regcache
)
501 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
505 /* Insert the given value into REGCACHE as if it was being
506 returned by a function. */
509 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
512 int length
= TYPE_LENGTH (valtype
);
513 char raw_buffer
[ALPHA_REGISTER_SIZE
];
516 switch (TYPE_CODE (valtype
))
522 alpha_lds (raw_buffer
, valbuf
);
523 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
527 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
531 /* FIXME: 128-bit long doubles are returned like structures:
532 by writing into indirect storage provided by the caller
533 as the first argument. */
534 error ("Cannot set a 128-bit long double return value.");
537 internal_error (__FILE__
, __LINE__
, "unknown floating point width");
541 case TYPE_CODE_COMPLEX
:
545 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
546 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
550 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
551 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
+1,
552 (const char *)valbuf
+ 8);
556 /* FIXME: 128-bit long doubles are returned like structures:
557 by writing into indirect storage provided by the caller
558 as the first argument. */
559 error ("Cannot set a 128-bit long double return value.");
562 internal_error (__FILE__
, __LINE__
, "unknown floating point width");
567 /* Assume everything else degenerates to an integer. */
568 /* 32-bit values must be sign-extended to 64 bits
569 even if the base data type is unsigned. */
571 valtype
= builtin_type_int32
;
572 l
= unpack_long (valtype
, valbuf
);
573 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
579 static const unsigned char *
580 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
582 static const unsigned char alpha_breakpoint
[] =
583 { 0x80, 0, 0, 0 }; /* call_pal bpt */
585 *lenptr
= sizeof(alpha_breakpoint
);
586 return (alpha_breakpoint
);
590 /* This returns the PC of the first insn after the prologue.
591 If we can't find the prologue, then return 0. */
594 alpha_after_prologue (CORE_ADDR pc
)
596 struct symtab_and_line sal
;
597 CORE_ADDR func_addr
, func_end
;
599 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
602 sal
= find_pc_line (func_addr
, 0);
603 if (sal
.end
< func_end
)
606 /* The line after the prologue is after the end of the function. In this
607 case, tell the caller to find the prologue the hard way. */
611 /* Read an instruction from memory at PC, looking through breakpoints. */
614 alpha_read_insn (CORE_ADDR pc
)
619 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
621 memory_error (status
, pc
);
622 return extract_unsigned_integer (buf
, 4);
625 /* To skip prologues, I use this predicate. Returns either PC itself
626 if the code at PC does not look like a function prologue; otherwise
627 returns an address that (if we're lucky) follows the prologue. If
628 LENIENT, then we must skip everything which is involved in setting
629 up the frame (it's OK to skip more, just so long as we don't skip
630 anything which might clobber the registers which are being saved. */
633 alpha_skip_prologue (CORE_ADDR pc
)
637 CORE_ADDR post_prologue_pc
;
640 /* Silently return the unaltered pc upon memory errors.
641 This could happen on OSF/1 if decode_line_1 tries to skip the
642 prologue for quickstarted shared library functions when the
643 shared library is not yet mapped in.
644 Reading target memory is slow over serial lines, so we perform
645 this check only if the target has shared libraries (which all
646 Alpha targets do). */
647 if (target_read_memory (pc
, buf
, 4))
650 /* See if we can determine the end of the prologue via the symbol table.
651 If so, then return either PC, or the PC after the prologue, whichever
654 post_prologue_pc
= alpha_after_prologue (pc
);
655 if (post_prologue_pc
!= 0)
656 return max (pc
, post_prologue_pc
);
658 /* Can't determine prologue from the symbol table, need to examine
661 /* Skip the typical prologue instructions. These are the stack adjustment
662 instruction and the instructions that save registers on the stack
663 or in the gcc frame. */
664 for (offset
= 0; offset
< 100; offset
+= 4)
666 inst
= alpha_read_insn (pc
+ offset
);
668 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
670 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
672 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
674 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
677 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
678 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
679 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
682 if (inst
== 0x47de040f) /* bis sp,sp,fp */
684 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
693 /* Figure out where the longjmp will land.
694 We expect the first arg to be a pointer to the jmp_buf structure from
695 which we extract the PC (JB_PC) that we will land at. The PC is copied
696 into the "pc". This routine returns true on success. */
699 alpha_get_longjmp_target (CORE_ADDR
*pc
)
701 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
703 char raw_buffer
[ALPHA_REGISTER_SIZE
];
705 jb_addr
= read_register (ALPHA_A0_REGNUM
);
707 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
708 raw_buffer
, tdep
->jb_elt_size
))
711 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
716 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
717 describe the location and shape of the sigcontext structure. After
718 that, all registers are in memory, so it's easy. */
719 /* ??? Shouldn't we be able to do this generically, rather than with
720 OSABI data specific to Alpha? */
722 struct alpha_sigtramp_unwind_cache
724 CORE_ADDR sigcontext_addr
;
727 static struct alpha_sigtramp_unwind_cache
*
728 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
729 void **this_prologue_cache
)
731 struct alpha_sigtramp_unwind_cache
*info
;
732 struct gdbarch_tdep
*tdep
;
734 if (*this_prologue_cache
)
735 return *this_prologue_cache
;
737 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
738 *this_prologue_cache
= info
;
740 tdep
= gdbarch_tdep (current_gdbarch
);
741 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
746 /* Return the address of REGNUM in a sigtramp frame. Since this is
747 all arithmetic, it doesn't seem worthwhile to cache it. */
750 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, int regnum
)
752 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
754 if (regnum
>= 0 && regnum
< 32)
755 return sigcontext_addr
+ tdep
->sc_regs_offset
+ regnum
* 8;
756 else if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 32)
757 return sigcontext_addr
+ tdep
->sc_fpregs_offset
+ regnum
* 8;
758 else if (regnum
== ALPHA_PC_REGNUM
)
759 return sigcontext_addr
+ tdep
->sc_pc_offset
;
764 /* Given a GDB frame, determine the address of the calling function's
765 frame. This will be used to create a new GDB frame struct. */
768 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
769 void **this_prologue_cache
,
770 struct frame_id
*this_id
)
772 struct alpha_sigtramp_unwind_cache
*info
773 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
774 struct gdbarch_tdep
*tdep
;
775 CORE_ADDR stack_addr
, code_addr
;
777 /* If the OSABI couldn't locate the sigcontext, give up. */
778 if (info
->sigcontext_addr
== 0)
781 /* If we have dynamic signal trampolines, find their start.
782 If we do not, then we must assume there is a symbol record
783 that can provide the start address. */
784 tdep
= gdbarch_tdep (current_gdbarch
);
785 if (tdep
->dynamic_sigtramp_offset
)
788 code_addr
= frame_pc_unwind (next_frame
);
789 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
796 code_addr
= frame_func_unwind (next_frame
);
798 /* The stack address is trivially read from the sigcontext. */
799 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
801 stack_addr
= get_frame_memory_unsigned (next_frame
, stack_addr
,
802 ALPHA_REGISTER_SIZE
);
804 *this_id
= frame_id_build (stack_addr
, code_addr
);
807 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
810 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
811 void **this_prologue_cache
,
812 int regnum
, int *optimizedp
,
813 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
814 int *realnump
, void *bufferp
)
816 struct alpha_sigtramp_unwind_cache
*info
817 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
820 if (info
->sigcontext_addr
!= 0)
822 /* All integer and fp registers are stored in memory. */
823 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
827 *lvalp
= lval_memory
;
831 get_frame_memory (next_frame
, addr
, bufferp
, ALPHA_REGISTER_SIZE
);
836 /* This extra register may actually be in the sigcontext, but our
837 current description of it in alpha_sigtramp_frame_unwind_cache
838 doesn't include it. Too bad. Fall back on whatever's in the
840 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
844 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
846 alpha_sigtramp_frame_this_id
,
847 alpha_sigtramp_frame_prev_register
850 static const struct frame_unwind
*
851 alpha_sigtramp_frame_sniffer (struct frame_info
*next_frame
)
853 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
856 /* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
857 look at tramp-frame.h and other simplier per-architecture
858 sigtramp unwinders. */
860 /* We shouldn't even bother to try if the OSABI didn't register a
861 sigcontext_addr handler or pc_in_sigtramp hander. */
862 if (gdbarch_tdep (current_gdbarch
)->sigcontext_addr
== NULL
)
864 if (gdbarch_tdep (current_gdbarch
)->pc_in_sigtramp
== NULL
)
867 /* Otherwise we should be in a signal frame. */
868 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
869 if (gdbarch_tdep (current_gdbarch
)->pc_in_sigtramp (pc
, name
))
870 return &alpha_sigtramp_frame_unwind
;
875 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
876 something about the traditional layout of alpha stack frames. */
878 struct alpha_heuristic_unwind_cache
880 CORE_ADDR
*saved_regs
;
886 /* Heuristic_proc_start may hunt through the text section for a long
887 time across a 2400 baud serial line. Allows the user to limit this
889 static unsigned int heuristic_fence_post
= 0;
891 /* Attempt to locate the start of the function containing PC. We assume that
892 the previous function ends with an about_to_return insn. Not foolproof by
893 any means, since gcc is happy to put the epilogue in the middle of a
894 function. But we're guessing anyway... */
897 alpha_heuristic_proc_start (CORE_ADDR pc
)
899 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
900 CORE_ADDR last_non_nop
= pc
;
901 CORE_ADDR fence
= pc
- heuristic_fence_post
;
902 CORE_ADDR orig_pc
= pc
;
908 /* First see if we can find the start of the function from minimal
909 symbol information. This can succeed with a binary that doesn't
910 have debug info, but hasn't been stripped. */
911 func
= get_pc_function_start (pc
);
915 if (heuristic_fence_post
== UINT_MAX
916 || fence
< tdep
->vm_min_address
)
917 fence
= tdep
->vm_min_address
;
919 /* Search back for previous return; also stop at a 0, which might be
920 seen for instance before the start of a code section. Don't include
921 nops, since this usually indicates padding between functions. */
922 for (pc
-= 4; pc
>= fence
; pc
-= 4)
924 unsigned int insn
= alpha_read_insn (pc
);
927 case 0: /* invalid insn */
928 case 0x6bfa8001: /* ret $31,($26),1 */
931 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
932 case 0x47ff041f: /* nop: bis $31,$31,$31 */
941 /* It's not clear to me why we reach this point when stopping quietly,
942 but with this test, at least we don't print out warnings for every
943 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
944 if (stop_soon
== NO_STOP_QUIETLY
)
946 static int blurb_printed
= 0;
948 if (fence
== tdep
->vm_min_address
)
949 warning ("Hit beginning of text section without finding");
951 warning ("Hit heuristic-fence-post without finding");
952 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
957 This warning occurs if you are debugging a function without any symbols\n\
958 (for example, in a stripped executable). In that case, you may wish to\n\
959 increase the size of the search with the `set heuristic-fence-post' command.\n\
961 Otherwise, you told GDB there was a function where there isn't one, or\n\
962 (more likely) you have encountered a bug in GDB.\n");
970 static struct alpha_heuristic_unwind_cache
*
971 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
972 void **this_prologue_cache
,
975 struct alpha_heuristic_unwind_cache
*info
;
977 CORE_ADDR limit_pc
, cur_pc
;
978 int frame_reg
, frame_size
, return_reg
, reg
;
980 if (*this_prologue_cache
)
981 return *this_prologue_cache
;
983 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
984 *this_prologue_cache
= info
;
985 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
987 limit_pc
= frame_pc_unwind (next_frame
);
989 start_pc
= alpha_heuristic_proc_start (limit_pc
);
990 info
->start_pc
= start_pc
;
992 frame_reg
= ALPHA_SP_REGNUM
;
996 /* If we've identified a likely place to start, do code scanning. */
999 /* Limit the forward search to 50 instructions. */
1000 if (start_pc
+ 200 < limit_pc
)
1001 limit_pc
= start_pc
+ 200;
1003 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
1005 unsigned int word
= alpha_read_insn (cur_pc
);
1007 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1011 /* Consider only the first stack allocation instruction
1012 to contain the static size of the frame. */
1013 if (frame_size
== 0)
1014 frame_size
= (-word
) & 0xffff;
1018 /* Exit loop if a positive stack adjustment is found, which
1019 usually means that the stack cleanup code in the function
1020 epilogue is reached. */
1024 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1026 reg
= (word
& 0x03e00000) >> 21;
1028 /* Ignore this instruction if we have already encountered
1029 an instruction saving the same register earlier in the
1030 function code. The current instruction does not tell
1031 us where the original value upon function entry is saved.
1032 All it says is that the function we are scanning reused
1033 that register for some computation of its own, and is now
1034 saving its result. */
1035 if (info
->saved_regs
[reg
])
1041 /* Do not compute the address where the register was saved yet,
1042 because we don't know yet if the offset will need to be
1043 relative to $sp or $fp (we can not compute the address
1044 relative to $sp if $sp is updated during the execution of
1045 the current subroutine, for instance when doing some alloca).
1046 So just store the offset for the moment, and compute the
1047 address later when we know whether this frame has a frame
1049 /* Hack: temporarily add one, so that the offset is non-zero
1050 and we can tell which registers have save offsets below. */
1051 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
1053 /* Starting with OSF/1-3.2C, the system libraries are shipped
1054 without local symbols, but they still contain procedure
1055 descriptors without a symbol reference. GDB is currently
1056 unable to find these procedure descriptors and uses
1057 heuristic_proc_desc instead.
1058 As some low level compiler support routines (__div*, __add*)
1059 use a non-standard return address register, we have to
1060 add some heuristics to determine the return address register,
1061 or stepping over these routines will fail.
1062 Usually the return address register is the first register
1063 saved on the stack, but assembler optimization might
1064 rearrange the register saves.
1065 So we recognize only a few registers (t7, t9, ra) within
1066 the procedure prologue as valid return address registers.
1067 If we encounter a return instruction, we extract the
1068 the return address register from it.
1070 FIXME: Rewriting GDB to access the procedure descriptors,
1071 e.g. via the minimal symbol table, might obviate this hack. */
1072 if (return_reg
== -1
1073 && cur_pc
< (start_pc
+ 80)
1074 && (reg
== ALPHA_T7_REGNUM
1075 || reg
== ALPHA_T9_REGNUM
1076 || reg
== ALPHA_RA_REGNUM
))
1079 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1080 return_reg
= (word
>> 16) & 0x1f;
1081 else if (word
== 0x47de040f) /* bis sp,sp,fp */
1082 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1083 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
1084 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1087 /* If we haven't found a valid return address register yet, keep
1088 searching in the procedure prologue. */
1089 if (return_reg
== -1)
1091 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
1093 unsigned int word
= alpha_read_insn (cur_pc
);
1095 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1097 reg
= (word
& 0x03e00000) >> 21;
1098 if (reg
== ALPHA_T7_REGNUM
1099 || reg
== ALPHA_T9_REGNUM
1100 || reg
== ALPHA_RA_REGNUM
)
1106 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1108 return_reg
= (word
>> 16) & 0x1f;
1117 /* Failing that, do default to the customary RA. */
1118 if (return_reg
== -1)
1119 return_reg
= ALPHA_RA_REGNUM
;
1120 info
->return_reg
= return_reg
;
1122 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
1123 info
->vfp
= val
+ frame_size
;
1125 /* Convert offsets to absolute addresses. See above about adding
1126 one to the offsets to make all detected offsets non-zero. */
1127 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1128 if (info
->saved_regs
[reg
])
1129 info
->saved_regs
[reg
] += val
- 1;
1134 /* Given a GDB frame, determine the address of the calling function's
1135 frame. This will be used to create a new GDB frame struct. */
1138 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
1139 void **this_prologue_cache
,
1140 struct frame_id
*this_id
)
1142 struct alpha_heuristic_unwind_cache
*info
1143 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1145 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1148 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1151 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
1152 void **this_prologue_cache
,
1153 int regnum
, int *optimizedp
,
1154 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1155 int *realnump
, void *bufferp
)
1157 struct alpha_heuristic_unwind_cache
*info
1158 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1160 /* The PC of the previous frame is stored in the link register of
1161 the current frame. Frob regnum so that we pull the value from
1162 the correct place. */
1163 if (regnum
== ALPHA_PC_REGNUM
)
1164 regnum
= info
->return_reg
;
1166 /* For all registers known to be saved in the current frame,
1167 do the obvious and pull the value out. */
1168 if (info
->saved_regs
[regnum
])
1171 *lvalp
= lval_memory
;
1172 *addrp
= info
->saved_regs
[regnum
];
1174 if (bufferp
!= NULL
)
1175 get_frame_memory (next_frame
, *addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1179 /* The stack pointer of the previous frame is computed by popping
1180 the current stack frame. */
1181 if (regnum
== ALPHA_SP_REGNUM
)
1187 if (bufferp
!= NULL
)
1188 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1192 /* Otherwise assume the next frame has the same register value. */
1193 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1197 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1199 alpha_heuristic_frame_this_id
,
1200 alpha_heuristic_frame_prev_register
1203 static const struct frame_unwind
*
1204 alpha_heuristic_frame_sniffer (struct frame_info
*next_frame
)
1206 return &alpha_heuristic_frame_unwind
;
1210 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1211 void **this_prologue_cache
)
1213 struct alpha_heuristic_unwind_cache
*info
1214 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1219 static const struct frame_base alpha_heuristic_frame_base
= {
1220 &alpha_heuristic_frame_unwind
,
1221 alpha_heuristic_frame_base_address
,
1222 alpha_heuristic_frame_base_address
,
1223 alpha_heuristic_frame_base_address
1226 /* Just like reinit_frame_cache, but with the right arguments to be
1227 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1230 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1232 reinit_frame_cache ();
1236 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1237 dummy frame. The frame ID's base needs to match the TOS value
1238 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1241 static struct frame_id
1242 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1245 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1246 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1250 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1253 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1258 /* Helper routines for alpha*-nat.c files to move register sets to and
1259 from core files. The UNIQUE pointer is allowed to be NULL, as most
1260 targets don't supply this value in their core files. */
1263 alpha_supply_int_regs (int regno
, const void *r0_r30
,
1264 const void *pc
, const void *unique
)
1268 for (i
= 0; i
< 31; ++i
)
1269 if (regno
== i
|| regno
== -1)
1270 regcache_raw_supply (current_regcache
, i
, (const char *)r0_r30
+ i
*8);
1272 if (regno
== ALPHA_ZERO_REGNUM
|| regno
== -1)
1273 regcache_raw_supply (current_regcache
, ALPHA_ZERO_REGNUM
, NULL
);
1275 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1276 regcache_raw_supply (current_regcache
, ALPHA_PC_REGNUM
, pc
);
1278 if (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1)
1279 regcache_raw_supply (current_regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1283 alpha_fill_int_regs (int regno
, void *r0_r30
, void *pc
, void *unique
)
1287 for (i
= 0; i
< 31; ++i
)
1288 if (regno
== i
|| regno
== -1)
1289 regcache_raw_collect (current_regcache
, i
, (char *)r0_r30
+ i
*8);
1291 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1292 regcache_raw_collect (current_regcache
, ALPHA_PC_REGNUM
, pc
);
1294 if (unique
&& (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1))
1295 regcache_raw_collect (current_regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1299 alpha_supply_fp_regs (int regno
, const void *f0_f30
, const void *fpcr
)
1303 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1304 if (regno
== i
|| regno
== -1)
1305 regcache_raw_supply (current_regcache
, i
,
1306 (const char *)f0_f30
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1308 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1309 regcache_raw_supply (current_regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1313 alpha_fill_fp_regs (int regno
, void *f0_f30
, void *fpcr
)
1317 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1318 if (regno
== i
|| regno
== -1)
1319 regcache_raw_collect (current_regcache
, i
,
1320 (char *)f0_f30
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1322 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1323 regcache_raw_collect (current_regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1327 /* alpha_software_single_step() is called just before we want to resume
1328 the inferior, if we want to single-step it but there is no hardware
1329 or kernel single-step support (NetBSD on Alpha, for example). We find
1330 the target of the coming instruction and breakpoint it.
1332 single_step is also called just after the inferior stops. If we had
1333 set up a simulated single-step, we undo our damage. */
1336 alpha_next_pc (CORE_ADDR pc
)
1343 insn
= alpha_read_insn (pc
);
1345 /* Opcode is top 6 bits. */
1346 op
= (insn
>> 26) & 0x3f;
1350 /* Jump format: target PC is:
1352 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1355 if ((op
& 0x30) == 0x30)
1357 /* Branch format: target PC is:
1358 (new PC) + (4 * sext(displacement)) */
1359 if (op
== 0x30 || /* BR */
1360 op
== 0x34) /* BSR */
1363 offset
= (insn
& 0x001fffff);
1364 if (offset
& 0x00100000)
1365 offset
|= 0xffe00000;
1367 return (pc
+ 4 + offset
);
1370 /* Need to determine if branch is taken; read RA. */
1371 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1374 case 0x38: /* BLBC */
1378 case 0x3c: /* BLBS */
1382 case 0x39: /* BEQ */
1386 case 0x3d: /* BNE */
1390 case 0x3a: /* BLT */
1394 case 0x3b: /* BLE */
1398 case 0x3f: /* BGT */
1402 case 0x3e: /* BGE */
1407 /* ??? Missing floating-point branches. */
1411 /* Not a branch or branch not taken; target PC is:
1417 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1419 static CORE_ADDR next_pc
;
1420 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1421 static binsn_quantum break_mem
;
1424 if (insert_breakpoints_p
)
1427 next_pc
= alpha_next_pc (pc
);
1429 target_insert_breakpoint (next_pc
, break_mem
);
1433 target_remove_breakpoint (next_pc
, break_mem
);
1439 /* Initialize the current architecture based on INFO. If possible, re-use an
1440 architecture from ARCHES, which is a list of architectures already created
1441 during this debugging session.
1443 Called e.g. at program startup, when reading a core file, and when reading
1446 static struct gdbarch
*
1447 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1449 struct gdbarch_tdep
*tdep
;
1450 struct gdbarch
*gdbarch
;
1452 /* Try to determine the ABI of the object we are loading. */
1453 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1455 /* If it's an ECOFF file, assume it's OSF/1. */
1456 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1457 info
.osabi
= GDB_OSABI_OSF1
;
1460 /* Find a candidate among extant architectures. */
1461 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1463 return arches
->gdbarch
;
1465 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1466 gdbarch
= gdbarch_alloc (&info
, tdep
);
1468 /* Lowest text address. This is used by heuristic_proc_start()
1469 to decide when to stop looking. */
1470 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000LL
;
1472 tdep
->dynamic_sigtramp_offset
= NULL
;
1473 tdep
->sigcontext_addr
= NULL
;
1474 tdep
->sc_pc_offset
= 2 * 8;
1475 tdep
->sc_regs_offset
= 4 * 8;
1476 tdep
->sc_fpregs_offset
= tdep
->sc_regs_offset
+ 32 * 8 + 8;
1478 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1481 set_gdbarch_short_bit (gdbarch
, 16);
1482 set_gdbarch_int_bit (gdbarch
, 32);
1483 set_gdbarch_long_bit (gdbarch
, 64);
1484 set_gdbarch_long_long_bit (gdbarch
, 64);
1485 set_gdbarch_float_bit (gdbarch
, 32);
1486 set_gdbarch_double_bit (gdbarch
, 64);
1487 set_gdbarch_long_double_bit (gdbarch
, 64);
1488 set_gdbarch_ptr_bit (gdbarch
, 64);
1491 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1492 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1493 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1494 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1496 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1497 set_gdbarch_deprecated_register_byte (gdbarch
, alpha_register_byte
);
1498 set_gdbarch_register_type (gdbarch
, alpha_register_type
);
1500 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1501 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1503 set_gdbarch_convert_register_p (gdbarch
, alpha_convert_register_p
);
1504 set_gdbarch_register_to_value (gdbarch
, alpha_register_to_value
);
1505 set_gdbarch_value_to_register (gdbarch
, alpha_value_to_register
);
1507 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1509 /* Prologue heuristics. */
1510 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1513 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1517 set_gdbarch_deprecated_use_struct_convention (gdbarch
, always_use_struct_convention
);
1518 set_gdbarch_extract_return_value (gdbarch
, alpha_extract_return_value
);
1519 set_gdbarch_store_return_value (gdbarch
, alpha_store_return_value
);
1520 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
, alpha_extract_struct_value_address
);
1522 /* Settings for calling functions in the inferior. */
1523 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1525 /* Methods for saving / extracting a dummy frame's ID. */
1526 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1528 /* Return the unwound PC value. */
1529 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1531 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1532 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1534 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1535 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1537 /* Hook in ABI-specific overrides, if they have been registered. */
1538 gdbarch_init_osabi (info
, gdbarch
);
1540 /* Now that we have tuned the configuration, set a few final things
1541 based on what the OS ABI has told us. */
1543 if (tdep
->jb_pc
>= 0)
1544 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1546 frame_unwind_append_sniffer (gdbarch
, alpha_sigtramp_frame_sniffer
);
1547 frame_unwind_append_sniffer (gdbarch
, alpha_heuristic_frame_sniffer
);
1549 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1555 alpha_dwarf2_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1557 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1558 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
1561 extern initialize_file_ftype _initialize_alpha_tdep
; /* -Wmissing-prototypes */
1564 _initialize_alpha_tdep (void)
1566 struct cmd_list_element
*c
;
1568 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1570 /* Let the user set the fence post for heuristic_proc_start. */
1572 /* We really would like to have both "0" and "unlimited" work, but
1573 command.c doesn't deal with that. So make it a var_zinteger
1574 because the user can always use "999999" or some such for unlimited. */
1575 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1576 (char *) &heuristic_fence_post
,
1578 Set the distance searched for the start of a function.\n\
1579 If you are debugging a stripped executable, GDB needs to search through the\n\
1580 program for the start of a function. This command sets the distance of the\n\
1581 search. The only need to set it is when debugging a stripped executable.",
1583 /* We need to throw away the frame cache when we set this, since it
1584 might change our ability to get backtraces. */
1585 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1586 deprecated_add_show_from_set (c
, &showlist
);