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"
46 #include "alpha-tdep.h"
50 alpha_register_name (int regno
)
52 static const char * const register_names
[] =
54 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
55 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
56 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
57 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
58 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
59 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
60 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
61 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
67 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
69 return register_names
[regno
];
73 alpha_cannot_fetch_register (int regno
)
75 return regno
== ALPHA_ZERO_REGNUM
;
79 alpha_cannot_store_register (int regno
)
81 return regno
== ALPHA_ZERO_REGNUM
;
85 alpha_register_type (struct gdbarch
*gdbarch
, int regno
)
87 if (regno
== ALPHA_SP_REGNUM
|| regno
== ALPHA_GP_REGNUM
)
88 return builtin_type_void_data_ptr
;
89 if (regno
== ALPHA_PC_REGNUM
)
90 return builtin_type_void_func_ptr
;
92 /* Don't need to worry about little vs big endian until
93 some jerk tries to port to alpha-unicosmk. */
94 if (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31)
95 return builtin_type_ieee_double_little
;
97 return builtin_type_int64
;
100 /* Is REGNUM a member of REGGROUP? */
103 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
104 struct reggroup
*group
)
106 /* Filter out any registers eliminated, but whose regnum is
107 reserved for backward compatibility, e.g. the vfp. */
108 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
111 if (group
== all_reggroup
)
114 /* Zero should not be saved or restored. Technically it is a general
115 register (just as $f31 would be a float if we represented it), but
116 there's no point displaying it during "info regs", so leave it out
117 of all groups except for "all". */
118 if (regnum
== ALPHA_ZERO_REGNUM
)
121 /* All other registers are saved and restored. */
122 if (group
== save_reggroup
|| group
== restore_reggroup
)
125 /* All other groups are non-overlapping. */
127 /* Since this is really a PALcode memory slot... */
128 if (regnum
== ALPHA_UNIQUE_REGNUM
)
129 return group
== system_reggroup
;
131 /* Force the FPCR to be considered part of the floating point state. */
132 if (regnum
== ALPHA_FPCR_REGNUM
)
133 return group
== float_reggroup
;
135 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
136 return group
== float_reggroup
;
138 return group
== general_reggroup
;
142 alpha_register_byte (int regno
)
148 alpha_register_raw_size (int regno
)
154 alpha_register_virtual_size (int regno
)
159 /* The following represents exactly the conversion performed by
160 the LDS instruction. This applies to both single-precision
161 floating point and 32-bit integers. */
164 alpha_lds (void *out
, const void *in
)
166 ULONGEST mem
= extract_unsigned_integer (in
, 4);
167 ULONGEST frac
= (mem
>> 0) & 0x7fffff;
168 ULONGEST sign
= (mem
>> 31) & 1;
169 ULONGEST exp_msb
= (mem
>> 30) & 1;
170 ULONGEST exp_low
= (mem
>> 23) & 0x7f;
173 exp
= (exp_msb
<< 10) | exp_low
;
185 reg
= (sign
<< 63) | (exp
<< 52) | (frac
<< 29);
186 store_unsigned_integer (out
, 8, reg
);
189 /* Similarly, this represents exactly the conversion performed by
190 the STS instruction. */
193 alpha_sts (void *out
, const void *in
)
197 reg
= extract_unsigned_integer (in
, 8);
198 mem
= ((reg
>> 32) & 0xc0000000) | ((reg
>> 29) & 0x3fffffff);
199 store_unsigned_integer (out
, 4, mem
);
202 /* The alpha needs a conversion between register and memory format if the
203 register is a floating point register and memory format is float, as the
204 register format must be double or memory format is an integer with 4
205 bytes or less, as the representation of integers in floating point
206 registers is different. */
209 alpha_convert_register_p (int regno
)
211 return (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31);
215 alpha_register_to_value (int regnum
, struct type
*valtype
, char *in
, char *out
)
217 switch (TYPE_LENGTH (valtype
))
226 error ("Cannot retrieve value from floating point register");
231 alpha_value_to_register (struct type
*valtype
, int regnum
, char *in
, char *out
)
233 switch (TYPE_LENGTH (valtype
))
242 error ("Cannot store value in floating point register");
247 /* The alpha passes the first six arguments in the registers, the rest on
248 the stack. The register arguments are stored in ARG_REG_BUFFER, and
249 then moved into the register file; this simplifies the passing of a
250 large struct which extends from the registers to the stack, plus avoids
251 three ptrace invocations per word.
253 We don't bother tracking which register values should go in integer
254 regs or fp regs; we load the same values into both.
256 If the called function is returning a structure, the address of the
257 structure to be returned is passed as a hidden first argument. */
260 alpha_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
261 struct regcache
*regcache
, CORE_ADDR bp_addr
,
262 int nargs
, struct value
**args
, CORE_ADDR sp
,
263 int struct_return
, CORE_ADDR struct_addr
)
266 int accumulate_size
= struct_return
? 8 : 0;
273 struct alpha_arg
*alpha_args
274 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
275 register struct alpha_arg
*m_arg
;
276 char arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
277 int required_arg_regs
;
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 (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 /* Extract from REGCACHE the address of a structure about to be returned
502 alpha_extract_struct_value_address (struct regcache
*regcache
)
505 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
509 /* Insert the given value into REGCACHE as if it was being
510 returned by a function. */
513 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
516 int length
= TYPE_LENGTH (valtype
);
517 char raw_buffer
[ALPHA_REGISTER_SIZE
];
520 switch (TYPE_CODE (valtype
))
526 alpha_lds (raw_buffer
, valbuf
);
527 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
531 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
535 /* FIXME: 128-bit long doubles are returned like structures:
536 by writing into indirect storage provided by the caller
537 as the first argument. */
538 error ("Cannot set a 128-bit long double return value.");
541 internal_error (__FILE__
, __LINE__
, "unknown floating point width");
545 case TYPE_CODE_COMPLEX
:
549 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
550 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
554 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
555 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
+1,
556 (const char *)valbuf
+ 8);
560 /* FIXME: 128-bit long doubles are returned like structures:
561 by writing into indirect storage provided by the caller
562 as the first argument. */
563 error ("Cannot set a 128-bit long double return value.");
566 internal_error (__FILE__
, __LINE__
, "unknown floating point width");
571 /* Assume everything else degenerates to an integer. */
572 /* 32-bit values must be sign-extended to 64 bits
573 even if the base data type is unsigned. */
575 valtype
= builtin_type_int32
;
576 l
= unpack_long (valtype
, valbuf
);
577 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
583 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
585 /* Structures are returned by ref in extra arg0. */
590 static const unsigned char *
591 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
593 static const unsigned char alpha_breakpoint
[] =
594 { 0x80, 0, 0, 0 }; /* call_pal bpt */
596 *lenptr
= sizeof(alpha_breakpoint
);
597 return (alpha_breakpoint
);
601 /* This returns the PC of the first insn after the prologue.
602 If we can't find the prologue, then return 0. */
605 alpha_after_prologue (CORE_ADDR pc
)
607 struct symtab_and_line sal
;
608 CORE_ADDR func_addr
, func_end
;
610 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
613 sal
= find_pc_line (func_addr
, 0);
614 if (sal
.end
< func_end
)
617 /* The line after the prologue is after the end of the function. In this
618 case, tell the caller to find the prologue the hard way. */
622 /* Read an instruction from memory at PC, looking through breakpoints. */
625 alpha_read_insn (CORE_ADDR pc
)
630 status
= read_memory_nobpt (pc
, buf
, 4);
632 memory_error (status
, pc
);
633 return extract_unsigned_integer (buf
, 4);
636 /* To skip prologues, I use this predicate. Returns either PC itself
637 if the code at PC does not look like a function prologue; otherwise
638 returns an address that (if we're lucky) follows the prologue. If
639 LENIENT, then we must skip everything which is involved in setting
640 up the frame (it's OK to skip more, just so long as we don't skip
641 anything which might clobber the registers which are being saved. */
644 alpha_skip_prologue (CORE_ADDR pc
)
648 CORE_ADDR post_prologue_pc
;
651 /* Silently return the unaltered pc upon memory errors.
652 This could happen on OSF/1 if decode_line_1 tries to skip the
653 prologue for quickstarted shared library functions when the
654 shared library is not yet mapped in.
655 Reading target memory is slow over serial lines, so we perform
656 this check only if the target has shared libraries (which all
657 Alpha targets do). */
658 if (target_read_memory (pc
, buf
, 4))
661 /* See if we can determine the end of the prologue via the symbol table.
662 If so, then return either PC, or the PC after the prologue, whichever
665 post_prologue_pc
= alpha_after_prologue (pc
);
666 if (post_prologue_pc
!= 0)
667 return max (pc
, post_prologue_pc
);
669 /* Can't determine prologue from the symbol table, need to examine
672 /* Skip the typical prologue instructions. These are the stack adjustment
673 instruction and the instructions that save registers on the stack
674 or in the gcc frame. */
675 for (offset
= 0; offset
< 100; offset
+= 4)
677 inst
= alpha_read_insn (pc
+ offset
);
679 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
681 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
683 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
685 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
688 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
689 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
690 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
693 if (inst
== 0x47de040f) /* bis sp,sp,fp */
695 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
704 /* Figure out where the longjmp will land.
705 We expect the first arg to be a pointer to the jmp_buf structure from
706 which we extract the PC (JB_PC) that we will land at. The PC is copied
707 into the "pc". This routine returns true on success. */
710 alpha_get_longjmp_target (CORE_ADDR
*pc
)
712 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
714 char raw_buffer
[ALPHA_REGISTER_SIZE
];
716 jb_addr
= read_register (ALPHA_A0_REGNUM
);
718 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
719 raw_buffer
, tdep
->jb_elt_size
))
722 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
727 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
728 describe the location and shape of the sigcontext structure. After
729 that, all registers are in memory, so it's easy. */
730 /* ??? Shouldn't we be able to do this generically, rather than with
731 OSABI data specific to Alpha? */
733 struct alpha_sigtramp_unwind_cache
735 CORE_ADDR sigcontext_addr
;
738 static struct alpha_sigtramp_unwind_cache
*
739 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
740 void **this_prologue_cache
)
742 struct alpha_sigtramp_unwind_cache
*info
;
743 struct gdbarch_tdep
*tdep
;
745 if (*this_prologue_cache
)
746 return *this_prologue_cache
;
748 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
749 *this_prologue_cache
= info
;
751 tdep
= gdbarch_tdep (current_gdbarch
);
752 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
757 /* Return the address of REGNO in a sigtramp frame. Since this is all
758 arithmetic, it doesn't seem worthwhile to cache it. */
760 #ifndef SIGFRAME_PC_OFF
761 #define SIGFRAME_PC_OFF (2 * 8)
762 #define SIGFRAME_REGSAVE_OFF (4 * 8)
763 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
767 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, unsigned int regno
)
770 return sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ regno
* 8;
771 if (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 32)
772 return sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ regno
* 8;
773 if (regno
== ALPHA_PC_REGNUM
)
774 return sigcontext_addr
+ SIGFRAME_PC_OFF
;
779 /* Given a GDB frame, determine the address of the calling function's
780 frame. This will be used to create a new GDB frame struct. */
783 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
784 void **this_prologue_cache
,
785 struct frame_id
*this_id
)
787 struct alpha_sigtramp_unwind_cache
*info
788 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
789 struct gdbarch_tdep
*tdep
;
790 CORE_ADDR stack_addr
, code_addr
;
792 /* If the OSABI couldn't locate the sigcontext, give up. */
793 if (info
->sigcontext_addr
== 0)
796 /* If we have dynamic signal trampolines, find their start.
797 If we do not, then we must assume there is a symbol record
798 that can provide the start address. */
799 tdep
= gdbarch_tdep (current_gdbarch
);
800 if (tdep
->dynamic_sigtramp_offset
)
803 code_addr
= frame_pc_unwind (next_frame
);
804 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
811 code_addr
= frame_func_unwind (next_frame
);
813 /* The stack address is trivially read from the sigcontext. */
814 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
816 stack_addr
= read_memory_unsigned_integer (stack_addr
, ALPHA_REGISTER_SIZE
);
818 *this_id
= frame_id_build (stack_addr
, code_addr
);
821 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
824 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
825 void **this_prologue_cache
,
826 int regnum
, int *optimizedp
,
827 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
828 int *realnump
, void *bufferp
)
830 struct alpha_sigtramp_unwind_cache
*info
831 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
834 if (info
->sigcontext_addr
!= 0)
836 /* All integer and fp registers are stored in memory. */
837 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
841 *lvalp
= lval_memory
;
845 read_memory (addr
, bufferp
, ALPHA_REGISTER_SIZE
);
850 /* This extra register may actually be in the sigcontext, but our
851 current description of it in alpha_sigtramp_frame_unwind_cache
852 doesn't include it. Too bad. Fall back on whatever's in the
854 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
858 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
860 alpha_sigtramp_frame_this_id
,
861 alpha_sigtramp_frame_prev_register
864 static const struct frame_unwind
*
865 alpha_sigtramp_frame_p (CORE_ADDR pc
)
869 /* We shouldn't even bother to try if the OSABI didn't register
870 a sigcontext_addr handler. */
871 if (!gdbarch_tdep (current_gdbarch
)->sigcontext_addr
)
874 /* Otherwise we should be in a signal frame. */
875 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
876 if (PC_IN_SIGTRAMP (pc
, name
))
877 return &alpha_sigtramp_frame_unwind
;
882 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
883 something about the traditional layout of alpha stack frames. */
885 struct alpha_heuristic_unwind_cache
887 CORE_ADDR
*saved_regs
;
893 /* Heuristic_proc_start may hunt through the text section for a long
894 time across a 2400 baud serial line. Allows the user to limit this
896 static unsigned int heuristic_fence_post
= 0;
898 /* Attempt to locate the start of the function containing PC. We assume that
899 the previous function ends with an about_to_return insn. Not foolproof by
900 any means, since gcc is happy to put the epilogue in the middle of a
901 function. But we're guessing anyway... */
904 alpha_heuristic_proc_start (CORE_ADDR pc
)
906 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
907 CORE_ADDR last_non_nop
= pc
;
908 CORE_ADDR fence
= pc
- heuristic_fence_post
;
909 CORE_ADDR orig_pc
= pc
;
915 /* First see if we can find the start of the function from minimal
916 symbol information. This can succeed with a binary that doesn't
917 have debug info, but hasn't been stripped. */
918 func
= get_pc_function_start (pc
);
922 if (heuristic_fence_post
== UINT_MAX
923 || fence
< tdep
->vm_min_address
)
924 fence
= tdep
->vm_min_address
;
926 /* Search back for previous return; also stop at a 0, which might be
927 seen for instance before the start of a code section. Don't include
928 nops, since this usually indicates padding between functions. */
929 for (pc
-= 4; pc
>= fence
; pc
-= 4)
931 unsigned int insn
= alpha_read_insn (pc
);
934 case 0: /* invalid insn */
935 case 0x6bfa8001: /* ret $31,($26),1 */
938 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
939 case 0x47ff041f: /* nop: bis $31,$31,$31 */
948 /* It's not clear to me why we reach this point when stopping quietly,
949 but with this test, at least we don't print out warnings for every
950 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
951 if (stop_soon
== NO_STOP_QUIETLY
)
953 static int blurb_printed
= 0;
955 if (fence
== tdep
->vm_min_address
)
956 warning ("Hit beginning of text section without finding");
958 warning ("Hit heuristic-fence-post without finding");
959 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
964 This warning occurs if you are debugging a function without any symbols\n\
965 (for example, in a stripped executable). In that case, you may wish to\n\
966 increase the size of the search with the `set heuristic-fence-post' command.\n\
968 Otherwise, you told GDB there was a function where there isn't one, or\n\
969 (more likely) you have encountered a bug in GDB.\n");
977 static struct alpha_heuristic_unwind_cache
*
978 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
979 void **this_prologue_cache
,
982 struct alpha_heuristic_unwind_cache
*info
;
984 CORE_ADDR limit_pc
, cur_pc
;
985 int frame_reg
, frame_size
, return_reg
, reg
;
987 if (*this_prologue_cache
)
988 return *this_prologue_cache
;
990 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
991 *this_prologue_cache
= info
;
992 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
994 limit_pc
= frame_pc_unwind (next_frame
);
996 start_pc
= alpha_heuristic_proc_start (limit_pc
);
997 info
->start_pc
= start_pc
;
999 frame_reg
= ALPHA_SP_REGNUM
;
1003 /* If we've identified a likely place to start, do code scanning. */
1006 /* Limit the forward search to 50 instructions. */
1007 if (start_pc
+ 200 < limit_pc
)
1008 limit_pc
= start_pc
+ 200;
1010 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
1012 unsigned int word
= alpha_read_insn (cur_pc
);
1014 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1018 /* Consider only the first stack allocation instruction
1019 to contain the static size of the frame. */
1020 if (frame_size
== 0)
1021 frame_size
= (-word
) & 0xffff;
1025 /* Exit loop if a positive stack adjustment is found, which
1026 usually means that the stack cleanup code in the function
1027 epilogue is reached. */
1031 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1033 reg
= (word
& 0x03e00000) >> 21;
1038 /* Do not compute the address where the register was saved yet,
1039 because we don't know yet if the offset will need to be
1040 relative to $sp or $fp (we can not compute the address
1041 relative to $sp if $sp is updated during the execution of
1042 the current subroutine, for instance when doing some alloca).
1043 So just store the offset for the moment, and compute the
1044 address later when we know whether this frame has a frame
1046 /* Hack: temporarily add one, so that the offset is non-zero
1047 and we can tell which registers have save offsets below. */
1048 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
1050 /* Starting with OSF/1-3.2C, the system libraries are shipped
1051 without local symbols, but they still contain procedure
1052 descriptors without a symbol reference. GDB is currently
1053 unable to find these procedure descriptors and uses
1054 heuristic_proc_desc instead.
1055 As some low level compiler support routines (__div*, __add*)
1056 use a non-standard return address register, we have to
1057 add some heuristics to determine the return address register,
1058 or stepping over these routines will fail.
1059 Usually the return address register is the first register
1060 saved on the stack, but assembler optimization might
1061 rearrange the register saves.
1062 So we recognize only a few registers (t7, t9, ra) within
1063 the procedure prologue as valid return address registers.
1064 If we encounter a return instruction, we extract the
1065 the return address register from it.
1067 FIXME: Rewriting GDB to access the procedure descriptors,
1068 e.g. via the minimal symbol table, might obviate this hack. */
1069 if (return_reg
== -1
1070 && cur_pc
< (start_pc
+ 80)
1071 && (reg
== ALPHA_T7_REGNUM
1072 || reg
== ALPHA_T9_REGNUM
1073 || reg
== ALPHA_RA_REGNUM
))
1076 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1077 return_reg
= (word
>> 16) & 0x1f;
1078 else if (word
== 0x47de040f) /* bis sp,sp,fp */
1079 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1080 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
1081 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1084 /* If we haven't found a valid return address register yet, keep
1085 searching in the procedure prologue. */
1086 if (return_reg
== -1)
1088 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
1090 unsigned int word
= alpha_read_insn (cur_pc
);
1092 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1094 reg
= (word
& 0x03e00000) >> 21;
1095 if (reg
== ALPHA_T7_REGNUM
1096 || reg
== ALPHA_T9_REGNUM
1097 || reg
== ALPHA_RA_REGNUM
)
1103 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1105 return_reg
= (word
>> 16) & 0x1f;
1114 /* Failing that, do default to the customary RA. */
1115 if (return_reg
== -1)
1116 return_reg
= ALPHA_RA_REGNUM
;
1117 info
->return_reg
= return_reg
;
1119 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
1120 info
->vfp
= val
+ frame_size
;
1122 /* Convert offsets to absolute addresses. See above about adding
1123 one to the offsets to make all detected offsets non-zero. */
1124 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1125 if (info
->saved_regs
[reg
])
1126 info
->saved_regs
[reg
] += val
- 1;
1131 /* Given a GDB frame, determine the address of the calling function's
1132 frame. This will be used to create a new GDB frame struct. */
1135 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
1136 void **this_prologue_cache
,
1137 struct frame_id
*this_id
)
1139 struct alpha_heuristic_unwind_cache
*info
1140 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1142 /* This is meant to halt the backtrace at "_start". Make sure we
1143 don't halt it at a generic dummy frame. */
1144 if (inside_entry_file (info
->start_pc
))
1147 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1150 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1153 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
1154 void **this_prologue_cache
,
1155 int regnum
, int *optimizedp
,
1156 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1157 int *realnump
, void *bufferp
)
1159 struct alpha_heuristic_unwind_cache
*info
1160 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1162 /* The PC of the previous frame is stored in the link register of
1163 the current frame. Frob regnum so that we pull the value from
1164 the correct place. */
1165 if (regnum
== ALPHA_PC_REGNUM
)
1166 regnum
= info
->return_reg
;
1168 /* For all registers known to be saved in the current frame,
1169 do the obvious and pull the value out. */
1170 if (info
->saved_regs
[regnum
])
1173 *lvalp
= lval_memory
;
1174 *addrp
= info
->saved_regs
[regnum
];
1176 if (bufferp
!= NULL
)
1177 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1181 /* The stack pointer of the previous frame is computed by popping
1182 the current stack frame. */
1183 if (regnum
== ALPHA_SP_REGNUM
)
1189 if (bufferp
!= NULL
)
1190 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1194 /* Otherwise assume the next frame has the same register value. */
1195 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1199 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1201 alpha_heuristic_frame_this_id
,
1202 alpha_heuristic_frame_prev_register
1205 static const struct frame_unwind
*
1206 alpha_heuristic_frame_p (CORE_ADDR pc
)
1208 return &alpha_heuristic_frame_unwind
;
1212 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1213 void **this_prologue_cache
)
1215 struct alpha_heuristic_unwind_cache
*info
1216 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1221 static const struct frame_base alpha_heuristic_frame_base
= {
1222 &alpha_heuristic_frame_unwind
,
1223 alpha_heuristic_frame_base_address
,
1224 alpha_heuristic_frame_base_address
,
1225 alpha_heuristic_frame_base_address
1228 /* Just like reinit_frame_cache, but with the right arguments to be
1229 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1232 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1234 reinit_frame_cache ();
1238 /* ALPHA stack frames are almost impenetrable. When execution stops,
1239 we basically have to look at symbol information for the function
1240 that we stopped in, which tells us *which* register (if any) is
1241 the base of the frame pointer, and what offset from that register
1242 the frame itself is at.
1244 This presents a problem when trying to examine a stack in memory
1245 (that isn't executing at the moment), using the "frame" command. We
1246 don't have a PC, nor do we have any registers except SP.
1248 This routine takes two arguments, SP and PC, and tries to make the
1249 cached frames look as if these two arguments defined a frame on the
1250 cache. This allows the rest of info frame to extract the important
1251 arguments without difficulty. */
1254 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1257 error ("ALPHA frame specifications require two arguments: sp and pc");
1259 return create_new_frame (argv
[0], argv
[1]);
1262 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1263 dummy frame. The frame ID's base needs to match the TOS value
1264 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1267 static struct frame_id
1268 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1271 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1272 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1276 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1279 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1284 /* Helper routines for alpha*-nat.c files to move register sets to and
1285 from core files. The UNIQUE pointer is allowed to be NULL, as most
1286 targets don't supply this value in their core files. */
1289 alpha_supply_int_regs (int regno
, const void *r0_r30
,
1290 const void *pc
, const void *unique
)
1294 for (i
= 0; i
< 31; ++i
)
1295 if (regno
== i
|| regno
== -1)
1296 supply_register (i
, (const char *)r0_r30
+ i
*8);
1298 if (regno
== ALPHA_ZERO_REGNUM
|| regno
== -1)
1299 supply_register (ALPHA_ZERO_REGNUM
, NULL
);
1301 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1302 supply_register (ALPHA_PC_REGNUM
, pc
);
1304 if (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1)
1305 supply_register (ALPHA_UNIQUE_REGNUM
, unique
);
1309 alpha_fill_int_regs (int regno
, void *r0_r30
, void *pc
, void *unique
)
1313 for (i
= 0; i
< 31; ++i
)
1314 if (regno
== i
|| regno
== -1)
1315 regcache_collect (i
, (char *)r0_r30
+ i
*8);
1317 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1318 regcache_collect (ALPHA_PC_REGNUM
, pc
);
1320 if (unique
&& (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1))
1321 regcache_collect (ALPHA_UNIQUE_REGNUM
, unique
);
1325 alpha_supply_fp_regs (int regno
, const void *f0_f30
, const void *fpcr
)
1329 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1330 if (regno
== i
|| regno
== -1)
1331 supply_register (i
, (const char *)f0_f30
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1333 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1334 supply_register (ALPHA_FPCR_REGNUM
, fpcr
);
1338 alpha_fill_fp_regs (int regno
, void *f0_f30
, void *fpcr
)
1342 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1343 if (regno
== i
|| regno
== -1)
1344 regcache_collect (i
, (char *)f0_f30
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1346 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1347 regcache_collect (ALPHA_FPCR_REGNUM
, fpcr
);
1351 /* alpha_software_single_step() is called just before we want to resume
1352 the inferior, if we want to single-step it but there is no hardware
1353 or kernel single-step support (NetBSD on Alpha, for example). We find
1354 the target of the coming instruction and breakpoint it.
1356 single_step is also called just after the inferior stops. If we had
1357 set up a simulated single-step, we undo our damage. */
1360 alpha_next_pc (CORE_ADDR pc
)
1367 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1369 /* Opcode is top 6 bits. */
1370 op
= (insn
>> 26) & 0x3f;
1374 /* Jump format: target PC is:
1376 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1379 if ((op
& 0x30) == 0x30)
1381 /* Branch format: target PC is:
1382 (new PC) + (4 * sext(displacement)) */
1383 if (op
== 0x30 || /* BR */
1384 op
== 0x34) /* BSR */
1387 offset
= (insn
& 0x001fffff);
1388 if (offset
& 0x00100000)
1389 offset
|= 0xffe00000;
1391 return (pc
+ 4 + offset
);
1394 /* Need to determine if branch is taken; read RA. */
1395 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1398 case 0x38: /* BLBC */
1402 case 0x3c: /* BLBS */
1406 case 0x39: /* BEQ */
1410 case 0x3d: /* BNE */
1414 case 0x3a: /* BLT */
1418 case 0x3b: /* BLE */
1422 case 0x3f: /* BGT */
1426 case 0x3e: /* BGE */
1431 /* ??? Missing floating-point branches. */
1435 /* Not a branch or branch not taken; target PC is:
1441 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1443 static CORE_ADDR next_pc
;
1444 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1445 static binsn_quantum break_mem
;
1448 if (insert_breakpoints_p
)
1451 next_pc
= alpha_next_pc (pc
);
1453 target_insert_breakpoint (next_pc
, break_mem
);
1457 target_remove_breakpoint (next_pc
, break_mem
);
1463 /* Initialize the current architecture based on INFO. If possible, re-use an
1464 architecture from ARCHES, which is a list of architectures already created
1465 during this debugging session.
1467 Called e.g. at program startup, when reading a core file, and when reading
1470 static struct gdbarch
*
1471 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1473 struct gdbarch_tdep
*tdep
;
1474 struct gdbarch
*gdbarch
;
1476 /* Try to determine the ABI of the object we are loading. */
1477 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1479 /* If it's an ECOFF file, assume it's OSF/1. */
1480 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1481 info
.osabi
= GDB_OSABI_OSF1
;
1484 /* Find a candidate among extant architectures. */
1485 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1487 return arches
->gdbarch
;
1489 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1490 gdbarch
= gdbarch_alloc (&info
, tdep
);
1492 /* Lowest text address. This is used by heuristic_proc_start()
1493 to decide when to stop looking. */
1494 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1496 tdep
->dynamic_sigtramp_offset
= NULL
;
1497 tdep
->sigcontext_addr
= NULL
;
1499 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1502 set_gdbarch_short_bit (gdbarch
, 16);
1503 set_gdbarch_int_bit (gdbarch
, 32);
1504 set_gdbarch_long_bit (gdbarch
, 64);
1505 set_gdbarch_long_long_bit (gdbarch
, 64);
1506 set_gdbarch_float_bit (gdbarch
, 32);
1507 set_gdbarch_double_bit (gdbarch
, 64);
1508 set_gdbarch_long_double_bit (gdbarch
, 64);
1509 set_gdbarch_ptr_bit (gdbarch
, 64);
1512 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1513 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1514 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1515 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1517 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1518 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1519 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1520 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1521 set_gdbarch_register_type (gdbarch
, alpha_register_type
);
1523 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1524 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1526 set_gdbarch_convert_register_p (gdbarch
, alpha_convert_register_p
);
1527 set_gdbarch_register_to_value (gdbarch
, alpha_register_to_value
);
1528 set_gdbarch_value_to_register (gdbarch
, alpha_value_to_register
);
1530 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1532 /* Prologue heuristics. */
1533 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1536 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1539 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1540 set_gdbarch_frameless_function_invocation (gdbarch
,
1541 generic_frameless_function_invocation_not
);
1543 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1544 set_gdbarch_extract_return_value (gdbarch
, alpha_extract_return_value
);
1545 set_gdbarch_store_return_value (gdbarch
, alpha_store_return_value
);
1546 set_gdbarch_extract_struct_value_address (gdbarch
,
1547 alpha_extract_struct_value_address
);
1549 /* Settings for calling functions in the inferior. */
1550 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1552 /* Methods for saving / extracting a dummy frame's ID. */
1553 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1554 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1556 /* Return the unwound PC value. */
1557 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1559 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1560 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1562 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1563 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1565 set_gdbarch_function_start_offset (gdbarch
, 0);
1566 set_gdbarch_frame_args_skip (gdbarch
, 0);
1568 /* Hook in ABI-specific overrides, if they have been registered. */
1569 gdbarch_init_osabi (info
, gdbarch
);
1571 /* Now that we have tuned the configuration, set a few final things
1572 based on what the OS ABI has told us. */
1574 if (tdep
->jb_pc
>= 0)
1575 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1577 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1578 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1580 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1586 alpha_dwarf2_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1588 frame_unwind_append_predicate (gdbarch
, dwarf2_frame_p
);
1589 frame_base_append_predicate (gdbarch
, dwarf2_frame_base_p
);
1590 set_gdbarch_dwarf2_build_frame_info (gdbarch
, dwarf2_build_frame_info
);
1594 _initialize_alpha_tdep (void)
1596 struct cmd_list_element
*c
;
1598 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1600 /* Let the user set the fence post for heuristic_proc_start. */
1602 /* We really would like to have both "0" and "unlimited" work, but
1603 command.c doesn't deal with that. So make it a var_zinteger
1604 because the user can always use "999999" or some such for unlimited. */
1605 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1606 (char *) &heuristic_fence_post
,
1608 Set the distance searched for the start of a function.\n\
1609 If you are debugging a stripped executable, GDB needs to search through the\n\
1610 program for the start of a function. This command sets the distance of the\n\
1611 search. The only need to set it is when debugging a stripped executable.",
1613 /* We need to throw away the frame cache when we set this, since it
1614 might change our ability to get backtraces. */
1615 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1616 add_show_from_set (c
, &showlist
);