1 /* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2005, 2006 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
26 #include "frame-unwind.h"
27 #include "frame-base.h"
28 #include "dwarf2-frame.h"
37 #include "gdb_string.h"
40 #include "reggroups.h"
41 #include "arch-utils.h"
48 #include "alpha-tdep.h"
51 /* Return the name of the REGNO register.
53 An empty name corresponds to a register number that used to
54 be used for a virtual register. That virtual register has
55 been removed, but the index is still reserved to maintain
56 compatibility with existing remote alpha targets. */
59 alpha_register_name (int regno
)
61 static const char * const register_names
[] =
63 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
64 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
65 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
66 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
67 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
68 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
69 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
70 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
76 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
78 return register_names
[regno
];
82 alpha_cannot_fetch_register (int regno
)
84 return (regno
== ALPHA_ZERO_REGNUM
85 || strlen (alpha_register_name (regno
)) == 0);
89 alpha_cannot_store_register (int regno
)
91 return (regno
== ALPHA_ZERO_REGNUM
92 || strlen (alpha_register_name (regno
)) == 0);
96 alpha_register_type (struct gdbarch
*gdbarch
, int regno
)
98 if (regno
== ALPHA_SP_REGNUM
|| regno
== ALPHA_GP_REGNUM
)
99 return builtin_type_void_data_ptr
;
100 if (regno
== ALPHA_PC_REGNUM
)
101 return builtin_type_void_func_ptr
;
103 /* Don't need to worry about little vs big endian until
104 some jerk tries to port to alpha-unicosmk. */
105 if (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31)
106 return builtin_type_ieee_double_little
;
108 return builtin_type_int64
;
111 /* Is REGNUM a member of REGGROUP? */
114 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
115 struct reggroup
*group
)
117 /* Filter out any registers eliminated, but whose regnum is
118 reserved for backward compatibility, e.g. the vfp. */
119 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
122 if (group
== all_reggroup
)
125 /* Zero should not be saved or restored. Technically it is a general
126 register (just as $f31 would be a float if we represented it), but
127 there's no point displaying it during "info regs", so leave it out
128 of all groups except for "all". */
129 if (regnum
== ALPHA_ZERO_REGNUM
)
132 /* All other registers are saved and restored. */
133 if (group
== save_reggroup
|| group
== restore_reggroup
)
136 /* All other groups are non-overlapping. */
138 /* Since this is really a PALcode memory slot... */
139 if (regnum
== ALPHA_UNIQUE_REGNUM
)
140 return group
== system_reggroup
;
142 /* Force the FPCR to be considered part of the floating point state. */
143 if (regnum
== ALPHA_FPCR_REGNUM
)
144 return group
== float_reggroup
;
146 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
147 return group
== float_reggroup
;
149 return group
== general_reggroup
;
152 /* The following represents exactly the conversion performed by
153 the LDS instruction. This applies to both single-precision
154 floating point and 32-bit integers. */
157 alpha_lds (void *out
, const void *in
)
159 ULONGEST mem
= extract_unsigned_integer (in
, 4);
160 ULONGEST frac
= (mem
>> 0) & 0x7fffff;
161 ULONGEST sign
= (mem
>> 31) & 1;
162 ULONGEST exp_msb
= (mem
>> 30) & 1;
163 ULONGEST exp_low
= (mem
>> 23) & 0x7f;
166 exp
= (exp_msb
<< 10) | exp_low
;
178 reg
= (sign
<< 63) | (exp
<< 52) | (frac
<< 29);
179 store_unsigned_integer (out
, 8, reg
);
182 /* Similarly, this represents exactly the conversion performed by
183 the STS instruction. */
186 alpha_sts (void *out
, const void *in
)
190 reg
= extract_unsigned_integer (in
, 8);
191 mem
= ((reg
>> 32) & 0xc0000000) | ((reg
>> 29) & 0x3fffffff);
192 store_unsigned_integer (out
, 4, mem
);
195 /* The alpha needs a conversion between register and memory format if the
196 register is a floating point register and memory format is float, as the
197 register format must be double or memory format is an integer with 4
198 bytes or less, as the representation of integers in floating point
199 registers is different. */
202 alpha_convert_register_p (int regno
, struct type
*type
)
204 return (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31);
208 alpha_register_to_value (struct frame_info
*frame
, int regnum
,
209 struct type
*valtype
, gdb_byte
*out
)
211 gdb_byte in
[MAX_REGISTER_SIZE
];
213 frame_register_read (frame
, regnum
, in
);
214 switch (TYPE_LENGTH (valtype
))
223 error (_("Cannot retrieve value from floating point register"));
228 alpha_value_to_register (struct frame_info
*frame
, int regnum
,
229 struct type
*valtype
, const gdb_byte
*in
)
231 gdb_byte out
[MAX_REGISTER_SIZE
];
233 switch (TYPE_LENGTH (valtype
))
242 error (_("Cannot store value in floating point register"));
244 put_frame_register (frame
, regnum
, out
);
248 /* The alpha passes the first six arguments in the registers, the rest on
249 the stack. The register arguments are stored in ARG_REG_BUFFER, and
250 then moved into the register file; this simplifies the passing of a
251 large struct which extends from the registers to the stack, plus avoids
252 three ptrace invocations per word.
254 We don't bother tracking which register values should go in integer
255 regs or fp regs; we load the same values into both.
257 If the called function is returning a structure, the address of the
258 structure to be returned is passed as a hidden first argument. */
261 alpha_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
262 struct regcache
*regcache
, CORE_ADDR bp_addr
,
263 int nargs
, struct value
**args
, CORE_ADDR sp
,
264 int struct_return
, CORE_ADDR struct_addr
)
267 int accumulate_size
= struct_return
? 8 : 0;
274 struct alpha_arg
*alpha_args
275 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
276 struct alpha_arg
*m_arg
;
277 gdb_byte arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
278 int required_arg_regs
;
279 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
281 /* The ABI places the address of the called function in T12. */
282 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
284 /* Set the return address register to point to the entry point
285 of the program, where a breakpoint lies in wait. */
286 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
288 /* Lay out the arguments in memory. */
289 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
291 struct value
*arg
= args
[i
];
292 struct type
*arg_type
= check_typedef (value_type (arg
));
294 /* Cast argument to long if necessary as the compiler does it too. */
295 switch (TYPE_CODE (arg_type
))
300 case TYPE_CODE_RANGE
:
302 if (TYPE_LENGTH (arg_type
) == 4)
304 /* 32-bit values must be sign-extended to 64 bits
305 even if the base data type is unsigned. */
306 arg_type
= builtin_type_int32
;
307 arg
= value_cast (arg_type
, arg
);
309 if (TYPE_LENGTH (arg_type
) < ALPHA_REGISTER_SIZE
)
311 arg_type
= builtin_type_int64
;
312 arg
= value_cast (arg_type
, arg
);
317 /* "float" arguments loaded in registers must be passed in
318 register format, aka "double". */
319 if (accumulate_size
< sizeof (arg_reg_buffer
)
320 && TYPE_LENGTH (arg_type
) == 4)
322 arg_type
= builtin_type_ieee_double_little
;
323 arg
= value_cast (arg_type
, arg
);
325 /* Tru64 5.1 has a 128-bit long double, and passes this by
326 invisible reference. No one else uses this data type. */
327 else if (TYPE_LENGTH (arg_type
) == 16)
329 /* Allocate aligned storage. */
330 sp
= (sp
& -16) - 16;
332 /* Write the real data into the stack. */
333 write_memory (sp
, value_contents (arg
), 16);
335 /* Construct the indirection. */
336 arg_type
= lookup_pointer_type (arg_type
);
337 arg
= value_from_pointer (arg_type
, sp
);
341 case TYPE_CODE_COMPLEX
:
342 /* ??? The ABI says that complex values are passed as two
343 separate scalar values. This distinction only matters
344 for complex float. However, GCC does not implement this. */
346 /* Tru64 5.1 has a 128-bit long double, and passes this by
347 invisible reference. */
348 if (TYPE_LENGTH (arg_type
) == 32)
350 /* Allocate aligned storage. */
351 sp
= (sp
& -16) - 16;
353 /* Write the real data into the stack. */
354 write_memory (sp
, value_contents (arg
), 32);
356 /* Construct the indirection. */
357 arg_type
= lookup_pointer_type (arg_type
);
358 arg
= value_from_pointer (arg_type
, sp
);
365 m_arg
->len
= TYPE_LENGTH (arg_type
);
366 m_arg
->offset
= accumulate_size
;
367 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
368 m_arg
->contents
= value_contents_writeable (arg
);
371 /* Determine required argument register loads, loading an argument register
372 is expensive as it uses three ptrace calls. */
373 required_arg_regs
= accumulate_size
/ 8;
374 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
375 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
377 /* Make room for the arguments on the stack. */
378 if (accumulate_size
< sizeof(arg_reg_buffer
))
381 accumulate_size
-= sizeof(arg_reg_buffer
);
382 sp
-= accumulate_size
;
384 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
387 /* `Push' arguments on the stack. */
388 for (i
= nargs
; m_arg
--, --i
>= 0;)
390 gdb_byte
*contents
= m_arg
->contents
;
391 int offset
= m_arg
->offset
;
392 int len
= m_arg
->len
;
394 /* Copy the bytes destined for registers into arg_reg_buffer. */
395 if (offset
< sizeof(arg_reg_buffer
))
397 if (offset
+ len
<= sizeof(arg_reg_buffer
))
399 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
404 int tlen
= sizeof(arg_reg_buffer
) - offset
;
405 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
412 /* Everything else goes to the stack. */
413 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
416 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
418 /* Load the argument registers. */
419 for (i
= 0; i
< required_arg_regs
; i
++)
421 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
422 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
423 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
424 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
427 /* Finally, update the stack pointer. */
428 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
433 /* Extract from REGCACHE the value about to be returned from a function
434 and copy it into VALBUF. */
437 alpha_extract_return_value (struct type
*valtype
, struct regcache
*regcache
,
440 int length
= TYPE_LENGTH (valtype
);
441 gdb_byte raw_buffer
[ALPHA_REGISTER_SIZE
];
444 switch (TYPE_CODE (valtype
))
450 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
451 alpha_sts (valbuf
, raw_buffer
);
455 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
459 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
460 read_memory (l
, valbuf
, 16);
464 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
468 case TYPE_CODE_COMPLEX
:
472 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
473 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
477 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
478 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
+ 1, valbuf
+ 8);
482 regcache_cooked_read_signed (regcache
, ALPHA_V0_REGNUM
, &l
);
483 read_memory (l
, valbuf
, 32);
487 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
492 /* Assume everything else degenerates to an integer. */
493 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
494 store_unsigned_integer (valbuf
, length
, l
);
499 /* Insert the given value into REGCACHE as if it was being
500 returned by a function. */
503 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
504 const gdb_byte
*valbuf
)
506 int length
= TYPE_LENGTH (valtype
);
507 gdb_byte raw_buffer
[ALPHA_REGISTER_SIZE
];
510 switch (TYPE_CODE (valtype
))
516 alpha_lds (raw_buffer
, valbuf
);
517 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
521 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
525 /* FIXME: 128-bit long doubles are returned like structures:
526 by writing into indirect storage provided by the caller
527 as the first argument. */
528 error (_("Cannot set a 128-bit long double return value."));
531 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
535 case TYPE_CODE_COMPLEX
:
539 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
540 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
544 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
545 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
+ 1, valbuf
+ 8);
549 /* FIXME: 128-bit long doubles are returned like structures:
550 by writing into indirect storage provided by the caller
551 as the first argument. */
552 error (_("Cannot set a 128-bit long double return value."));
555 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
560 /* Assume everything else degenerates to an integer. */
561 /* 32-bit values must be sign-extended to 64 bits
562 even if the base data type is unsigned. */
564 valtype
= builtin_type_int32
;
565 l
= unpack_long (valtype
, valbuf
);
566 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
571 static enum return_value_convention
572 alpha_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
573 struct regcache
*regcache
, gdb_byte
*readbuf
,
574 const gdb_byte
*writebuf
)
576 enum type_code code
= TYPE_CODE (type
);
578 if ((code
== TYPE_CODE_STRUCT
579 || code
== TYPE_CODE_UNION
580 || code
== TYPE_CODE_ARRAY
)
581 && gdbarch_tdep (gdbarch
)->return_in_memory (type
))
586 regcache_raw_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
587 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
590 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
594 alpha_extract_return_value (type
, regcache
, readbuf
);
596 alpha_store_return_value (type
, regcache
, writebuf
);
598 return RETURN_VALUE_REGISTER_CONVENTION
;
602 alpha_return_in_memory_always (struct type
*type
)
607 static const gdb_byte
*
608 alpha_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
610 static const gdb_byte break_insn
[] = { 0x80, 0, 0, 0 }; /* call_pal bpt */
612 *len
= sizeof(break_insn
);
617 /* This returns the PC of the first insn after the prologue.
618 If we can't find the prologue, then return 0. */
621 alpha_after_prologue (CORE_ADDR pc
)
623 struct symtab_and_line sal
;
624 CORE_ADDR func_addr
, func_end
;
626 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
629 sal
= find_pc_line (func_addr
, 0);
630 if (sal
.end
< func_end
)
633 /* The line after the prologue is after the end of the function. In this
634 case, tell the caller to find the prologue the hard way. */
638 /* Read an instruction from memory at PC, looking through breakpoints. */
641 alpha_read_insn (CORE_ADDR pc
)
646 status
= read_memory_nobpt (pc
, buf
, 4);
648 memory_error (status
, pc
);
649 return extract_unsigned_integer (buf
, 4);
652 /* To skip prologues, I use this predicate. Returns either PC itself
653 if the code at PC does not look like a function prologue; otherwise
654 returns an address that (if we're lucky) follows the prologue. If
655 LENIENT, then we must skip everything which is involved in setting
656 up the frame (it's OK to skip more, just so long as we don't skip
657 anything which might clobber the registers which are being saved. */
660 alpha_skip_prologue (CORE_ADDR pc
)
664 CORE_ADDR post_prologue_pc
;
667 /* Silently return the unaltered pc upon memory errors.
668 This could happen on OSF/1 if decode_line_1 tries to skip the
669 prologue for quickstarted shared library functions when the
670 shared library is not yet mapped in.
671 Reading target memory is slow over serial lines, so we perform
672 this check only if the target has shared libraries (which all
673 Alpha targets do). */
674 if (target_read_memory (pc
, buf
, 4))
677 /* See if we can determine the end of the prologue via the symbol table.
678 If so, then return either PC, or the PC after the prologue, whichever
681 post_prologue_pc
= alpha_after_prologue (pc
);
682 if (post_prologue_pc
!= 0)
683 return max (pc
, post_prologue_pc
);
685 /* Can't determine prologue from the symbol table, need to examine
688 /* Skip the typical prologue instructions. These are the stack adjustment
689 instruction and the instructions that save registers on the stack
690 or in the gcc frame. */
691 for (offset
= 0; offset
< 100; offset
+= 4)
693 inst
= alpha_read_insn (pc
+ offset
);
695 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
697 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
699 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
701 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
704 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
705 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
706 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
709 if (inst
== 0x47de040f) /* bis sp,sp,fp */
711 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
720 /* Figure out where the longjmp will land.
721 We expect the first arg to be a pointer to the jmp_buf structure from
722 which we extract the PC (JB_PC) that we will land at. The PC is copied
723 into the "pc". This routine returns true on success. */
726 alpha_get_longjmp_target (CORE_ADDR
*pc
)
728 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
730 gdb_byte raw_buffer
[ALPHA_REGISTER_SIZE
];
732 jb_addr
= read_register (ALPHA_A0_REGNUM
);
734 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
735 raw_buffer
, tdep
->jb_elt_size
))
738 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
743 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
744 describe the location and shape of the sigcontext structure. After
745 that, all registers are in memory, so it's easy. */
746 /* ??? Shouldn't we be able to do this generically, rather than with
747 OSABI data specific to Alpha? */
749 struct alpha_sigtramp_unwind_cache
751 CORE_ADDR sigcontext_addr
;
754 static struct alpha_sigtramp_unwind_cache
*
755 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
756 void **this_prologue_cache
)
758 struct alpha_sigtramp_unwind_cache
*info
;
759 struct gdbarch_tdep
*tdep
;
761 if (*this_prologue_cache
)
762 return *this_prologue_cache
;
764 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
765 *this_prologue_cache
= info
;
767 tdep
= gdbarch_tdep (current_gdbarch
);
768 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
773 /* Return the address of REGNUM in a sigtramp frame. Since this is
774 all arithmetic, it doesn't seem worthwhile to cache it. */
777 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, int regnum
)
779 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
781 if (regnum
>= 0 && regnum
< 32)
782 return sigcontext_addr
+ tdep
->sc_regs_offset
+ regnum
* 8;
783 else if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 32)
784 return sigcontext_addr
+ tdep
->sc_fpregs_offset
+ regnum
* 8;
785 else if (regnum
== ALPHA_PC_REGNUM
)
786 return sigcontext_addr
+ tdep
->sc_pc_offset
;
791 /* Given a GDB frame, determine the address of the calling function's
792 frame. This will be used to create a new GDB frame struct. */
795 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
796 void **this_prologue_cache
,
797 struct frame_id
*this_id
)
799 struct alpha_sigtramp_unwind_cache
*info
800 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
801 struct gdbarch_tdep
*tdep
;
802 CORE_ADDR stack_addr
, code_addr
;
804 /* If the OSABI couldn't locate the sigcontext, give up. */
805 if (info
->sigcontext_addr
== 0)
808 /* If we have dynamic signal trampolines, find their start.
809 If we do not, then we must assume there is a symbol record
810 that can provide the start address. */
811 tdep
= gdbarch_tdep (current_gdbarch
);
812 if (tdep
->dynamic_sigtramp_offset
)
815 code_addr
= frame_pc_unwind (next_frame
);
816 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
823 code_addr
= frame_func_unwind (next_frame
);
825 /* The stack address is trivially read from the sigcontext. */
826 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
828 stack_addr
= get_frame_memory_unsigned (next_frame
, stack_addr
,
829 ALPHA_REGISTER_SIZE
);
831 *this_id
= frame_id_build (stack_addr
, code_addr
);
834 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
837 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
838 void **this_prologue_cache
,
839 int regnum
, int *optimizedp
,
840 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
841 int *realnump
, gdb_byte
*bufferp
)
843 struct alpha_sigtramp_unwind_cache
*info
844 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
847 if (info
->sigcontext_addr
!= 0)
849 /* All integer and fp registers are stored in memory. */
850 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
854 *lvalp
= lval_memory
;
858 get_frame_memory (next_frame
, addr
, bufferp
, ALPHA_REGISTER_SIZE
);
863 /* This extra register may actually be in the sigcontext, but our
864 current description of it in alpha_sigtramp_frame_unwind_cache
865 doesn't include it. Too bad. Fall back on whatever's in the
867 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
871 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
873 alpha_sigtramp_frame_this_id
,
874 alpha_sigtramp_frame_prev_register
877 static const struct frame_unwind
*
878 alpha_sigtramp_frame_sniffer (struct frame_info
*next_frame
)
880 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
883 /* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
884 look at tramp-frame.h and other simplier per-architecture
885 sigtramp unwinders. */
887 /* We shouldn't even bother to try if the OSABI didn't register a
888 sigcontext_addr handler or pc_in_sigtramp hander. */
889 if (gdbarch_tdep (current_gdbarch
)->sigcontext_addr
== NULL
)
891 if (gdbarch_tdep (current_gdbarch
)->pc_in_sigtramp
== NULL
)
894 /* Otherwise we should be in a signal frame. */
895 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
896 if (gdbarch_tdep (current_gdbarch
)->pc_in_sigtramp (pc
, name
))
897 return &alpha_sigtramp_frame_unwind
;
902 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
903 something about the traditional layout of alpha stack frames. */
905 struct alpha_heuristic_unwind_cache
907 CORE_ADDR
*saved_regs
;
913 /* Heuristic_proc_start may hunt through the text section for a long
914 time across a 2400 baud serial line. Allows the user to limit this
916 static unsigned int heuristic_fence_post
= 0;
918 /* Attempt to locate the start of the function containing PC. We assume that
919 the previous function ends with an about_to_return insn. Not foolproof by
920 any means, since gcc is happy to put the epilogue in the middle of a
921 function. But we're guessing anyway... */
924 alpha_heuristic_proc_start (CORE_ADDR pc
)
926 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
927 CORE_ADDR last_non_nop
= pc
;
928 CORE_ADDR fence
= pc
- heuristic_fence_post
;
929 CORE_ADDR orig_pc
= pc
;
935 /* First see if we can find the start of the function from minimal
936 symbol information. This can succeed with a binary that doesn't
937 have debug info, but hasn't been stripped. */
938 func
= get_pc_function_start (pc
);
942 if (heuristic_fence_post
== UINT_MAX
943 || fence
< tdep
->vm_min_address
)
944 fence
= tdep
->vm_min_address
;
946 /* Search back for previous return; also stop at a 0, which might be
947 seen for instance before the start of a code section. Don't include
948 nops, since this usually indicates padding between functions. */
949 for (pc
-= 4; pc
>= fence
; pc
-= 4)
951 unsigned int insn
= alpha_read_insn (pc
);
954 case 0: /* invalid insn */
955 case 0x6bfa8001: /* ret $31,($26),1 */
958 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
959 case 0x47ff041f: /* nop: bis $31,$31,$31 */
968 /* It's not clear to me why we reach this point when stopping quietly,
969 but with this test, at least we don't print out warnings for every
970 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
971 if (stop_soon
== NO_STOP_QUIETLY
)
973 static int blurb_printed
= 0;
975 if (fence
== tdep
->vm_min_address
)
976 warning (_("Hit beginning of text section without finding \
977 enclosing function for address 0x%s"), paddr_nz (orig_pc
));
979 warning (_("Hit heuristic-fence-post without finding \
980 enclosing function for address 0x%s"), paddr_nz (orig_pc
));
984 printf_filtered (_("\
985 This warning occurs if you are debugging a function without any symbols\n\
986 (for example, in a stripped executable). In that case, you may wish to\n\
987 increase the size of the search with the `set heuristic-fence-post' command.\n\
989 Otherwise, you told GDB there was a function where there isn't one, or\n\
990 (more likely) you have encountered a bug in GDB.\n"));
998 static struct alpha_heuristic_unwind_cache
*
999 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
1000 void **this_prologue_cache
,
1003 struct alpha_heuristic_unwind_cache
*info
;
1005 CORE_ADDR limit_pc
, cur_pc
;
1006 int frame_reg
, frame_size
, return_reg
, reg
;
1008 if (*this_prologue_cache
)
1009 return *this_prologue_cache
;
1011 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
1012 *this_prologue_cache
= info
;
1013 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
1015 limit_pc
= frame_pc_unwind (next_frame
);
1017 start_pc
= alpha_heuristic_proc_start (limit_pc
);
1018 info
->start_pc
= start_pc
;
1020 frame_reg
= ALPHA_SP_REGNUM
;
1024 /* If we've identified a likely place to start, do code scanning. */
1027 /* Limit the forward search to 50 instructions. */
1028 if (start_pc
+ 200 < limit_pc
)
1029 limit_pc
= start_pc
+ 200;
1031 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
1033 unsigned int word
= alpha_read_insn (cur_pc
);
1035 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1039 /* Consider only the first stack allocation instruction
1040 to contain the static size of the frame. */
1041 if (frame_size
== 0)
1042 frame_size
= (-word
) & 0xffff;
1046 /* Exit loop if a positive stack adjustment is found, which
1047 usually means that the stack cleanup code in the function
1048 epilogue is reached. */
1052 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1054 reg
= (word
& 0x03e00000) >> 21;
1056 /* Ignore this instruction if we have already encountered
1057 an instruction saving the same register earlier in the
1058 function code. The current instruction does not tell
1059 us where the original value upon function entry is saved.
1060 All it says is that the function we are scanning reused
1061 that register for some computation of its own, and is now
1062 saving its result. */
1063 if (info
->saved_regs
[reg
])
1069 /* Do not compute the address where the register was saved yet,
1070 because we don't know yet if the offset will need to be
1071 relative to $sp or $fp (we can not compute the address
1072 relative to $sp if $sp is updated during the execution of
1073 the current subroutine, for instance when doing some alloca).
1074 So just store the offset for the moment, and compute the
1075 address later when we know whether this frame has a frame
1077 /* Hack: temporarily add one, so that the offset is non-zero
1078 and we can tell which registers have save offsets below. */
1079 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
1081 /* Starting with OSF/1-3.2C, the system libraries are shipped
1082 without local symbols, but they still contain procedure
1083 descriptors without a symbol reference. GDB is currently
1084 unable to find these procedure descriptors and uses
1085 heuristic_proc_desc instead.
1086 As some low level compiler support routines (__div*, __add*)
1087 use a non-standard return address register, we have to
1088 add some heuristics to determine the return address register,
1089 or stepping over these routines will fail.
1090 Usually the return address register is the first register
1091 saved on the stack, but assembler optimization might
1092 rearrange the register saves.
1093 So we recognize only a few registers (t7, t9, ra) within
1094 the procedure prologue as valid return address registers.
1095 If we encounter a return instruction, we extract the
1096 the return address register from it.
1098 FIXME: Rewriting GDB to access the procedure descriptors,
1099 e.g. via the minimal symbol table, might obviate this hack. */
1100 if (return_reg
== -1
1101 && cur_pc
< (start_pc
+ 80)
1102 && (reg
== ALPHA_T7_REGNUM
1103 || reg
== ALPHA_T9_REGNUM
1104 || reg
== ALPHA_RA_REGNUM
))
1107 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1108 return_reg
= (word
>> 16) & 0x1f;
1109 else if (word
== 0x47de040f) /* bis sp,sp,fp */
1110 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1111 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
1112 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1115 /* If we haven't found a valid return address register yet, keep
1116 searching in the procedure prologue. */
1117 if (return_reg
== -1)
1119 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
1121 unsigned int word
= alpha_read_insn (cur_pc
);
1123 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1125 reg
= (word
& 0x03e00000) >> 21;
1126 if (reg
== ALPHA_T7_REGNUM
1127 || reg
== ALPHA_T9_REGNUM
1128 || reg
== ALPHA_RA_REGNUM
)
1134 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1136 return_reg
= (word
>> 16) & 0x1f;
1145 /* Failing that, do default to the customary RA. */
1146 if (return_reg
== -1)
1147 return_reg
= ALPHA_RA_REGNUM
;
1148 info
->return_reg
= return_reg
;
1150 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
1151 info
->vfp
= val
+ frame_size
;
1153 /* Convert offsets to absolute addresses. See above about adding
1154 one to the offsets to make all detected offsets non-zero. */
1155 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1156 if (info
->saved_regs
[reg
])
1157 info
->saved_regs
[reg
] += val
- 1;
1162 /* Given a GDB frame, determine the address of the calling function's
1163 frame. This will be used to create a new GDB frame struct. */
1166 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
1167 void **this_prologue_cache
,
1168 struct frame_id
*this_id
)
1170 struct alpha_heuristic_unwind_cache
*info
1171 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1173 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1176 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1179 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
1180 void **this_prologue_cache
,
1181 int regnum
, int *optimizedp
,
1182 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1183 int *realnump
, gdb_byte
*bufferp
)
1185 struct alpha_heuristic_unwind_cache
*info
1186 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1188 /* The PC of the previous frame is stored in the link register of
1189 the current frame. Frob regnum so that we pull the value from
1190 the correct place. */
1191 if (regnum
== ALPHA_PC_REGNUM
)
1192 regnum
= info
->return_reg
;
1194 /* For all registers known to be saved in the current frame,
1195 do the obvious and pull the value out. */
1196 if (info
->saved_regs
[regnum
])
1199 *lvalp
= lval_memory
;
1200 *addrp
= info
->saved_regs
[regnum
];
1202 if (bufferp
!= NULL
)
1203 get_frame_memory (next_frame
, *addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1207 /* The stack pointer of the previous frame is computed by popping
1208 the current stack frame. */
1209 if (regnum
== ALPHA_SP_REGNUM
)
1215 if (bufferp
!= NULL
)
1216 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1220 /* Otherwise assume the next frame has the same register value. */
1221 frame_register_unwind (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1225 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1227 alpha_heuristic_frame_this_id
,
1228 alpha_heuristic_frame_prev_register
1231 static const struct frame_unwind
*
1232 alpha_heuristic_frame_sniffer (struct frame_info
*next_frame
)
1234 return &alpha_heuristic_frame_unwind
;
1238 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1239 void **this_prologue_cache
)
1241 struct alpha_heuristic_unwind_cache
*info
1242 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1247 static const struct frame_base alpha_heuristic_frame_base
= {
1248 &alpha_heuristic_frame_unwind
,
1249 alpha_heuristic_frame_base_address
,
1250 alpha_heuristic_frame_base_address
,
1251 alpha_heuristic_frame_base_address
1254 /* Just like reinit_frame_cache, but with the right arguments to be
1255 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1258 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1260 reinit_frame_cache ();
1264 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1265 dummy frame. The frame ID's base needs to match the TOS value
1266 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1269 static struct frame_id
1270 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1273 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1274 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1278 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1281 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1286 /* Helper routines for alpha*-nat.c files to move register sets to and
1287 from core files. The UNIQUE pointer is allowed to be NULL, as most
1288 targets don't supply this value in their core files. */
1291 alpha_supply_int_regs (int regno
, const void *r0_r30
,
1292 const void *pc
, const void *unique
)
1294 const gdb_byte
*regs
= r0_r30
;
1297 for (i
= 0; i
< 31; ++i
)
1298 if (regno
== i
|| regno
== -1)
1299 regcache_raw_supply (current_regcache
, i
, regs
+ i
* 8);
1301 if (regno
== ALPHA_ZERO_REGNUM
|| regno
== -1)
1302 regcache_raw_supply (current_regcache
, ALPHA_ZERO_REGNUM
, NULL
);
1304 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1305 regcache_raw_supply (current_regcache
, ALPHA_PC_REGNUM
, pc
);
1307 if (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1)
1308 regcache_raw_supply (current_regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1312 alpha_fill_int_regs (int regno
, void *r0_r30
, void *pc
, void *unique
)
1314 gdb_byte
*regs
= r0_r30
;
1317 for (i
= 0; i
< 31; ++i
)
1318 if (regno
== i
|| regno
== -1)
1319 regcache_raw_collect (current_regcache
, i
, regs
+ i
* 8);
1321 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1322 regcache_raw_collect (current_regcache
, ALPHA_PC_REGNUM
, pc
);
1324 if (unique
&& (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1))
1325 regcache_raw_collect (current_regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1329 alpha_supply_fp_regs (int regno
, const void *f0_f30
, const void *fpcr
)
1331 const gdb_byte
*regs
= f0_f30
;
1334 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1335 if (regno
== i
|| regno
== -1)
1336 regcache_raw_supply (current_regcache
, i
,
1337 regs
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1339 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1340 regcache_raw_supply (current_regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1344 alpha_fill_fp_regs (int regno
, void *f0_f30
, void *fpcr
)
1346 gdb_byte
*regs
= f0_f30
;
1349 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1350 if (regno
== i
|| regno
== -1)
1351 regcache_raw_collect (current_regcache
, i
,
1352 regs
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1354 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1355 regcache_raw_collect (current_regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1360 /* Return nonzero if the G_floating register value in REG is equal to
1361 zero for FP control instructions. */
1364 fp_register_zero_p (LONGEST reg
)
1366 /* Check that all bits except the sign bit are zero. */
1367 const LONGEST zero_mask
= ((LONGEST
) 1 << 63) ^ -1;
1369 return ((reg
& zero_mask
) == 0);
1372 /* Return the value of the sign bit for the G_floating register
1373 value held in REG. */
1376 fp_register_sign_bit (LONGEST reg
)
1378 const LONGEST sign_mask
= (LONGEST
) 1 << 63;
1380 return ((reg
& sign_mask
) != 0);
1383 /* alpha_software_single_step() is called just before we want to resume
1384 the inferior, if we want to single-step it but there is no hardware
1385 or kernel single-step support (NetBSD on Alpha, for example). We find
1386 the target of the coming instruction and breakpoint it.
1388 single_step is also called just after the inferior stops. If we had
1389 set up a simulated single-step, we undo our damage. */
1392 alpha_next_pc (CORE_ADDR pc
)
1401 insn
= alpha_read_insn (pc
);
1403 /* Opcode is top 6 bits. */
1404 op
= (insn
>> 26) & 0x3f;
1408 /* Jump format: target PC is:
1410 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1413 if ((op
& 0x30) == 0x30)
1415 /* Branch format: target PC is:
1416 (new PC) + (4 * sext(displacement)) */
1417 if (op
== 0x30 || /* BR */
1418 op
== 0x34) /* BSR */
1421 offset
= (insn
& 0x001fffff);
1422 if (offset
& 0x00100000)
1423 offset
|= 0xffe00000;
1425 return (pc
+ 4 + offset
);
1428 /* Need to determine if branch is taken; read RA. */
1429 regno
= (insn
>> 21) & 0x1f;
1432 case 0x31: /* FBEQ */
1433 case 0x36: /* FBGE */
1434 case 0x37: /* FBGT */
1435 case 0x33: /* FBLE */
1436 case 0x32: /* FBLT */
1437 case 0x35: /* FBNE */
1438 regno
+= FP0_REGNUM
;
1441 regcache_cooked_read (current_regcache
, regno
, reg
);
1442 rav
= extract_signed_integer (reg
, 8);
1446 case 0x38: /* BLBC */
1450 case 0x3c: /* BLBS */
1454 case 0x39: /* BEQ */
1458 case 0x3d: /* BNE */
1462 case 0x3a: /* BLT */
1466 case 0x3b: /* BLE */
1470 case 0x3f: /* BGT */
1474 case 0x3e: /* BGE */
1479 /* Floating point branches. */
1481 case 0x31: /* FBEQ */
1482 if (fp_register_zero_p (rav
))
1485 case 0x36: /* FBGE */
1486 if (fp_register_sign_bit (rav
) == 0 || fp_register_zero_p (rav
))
1489 case 0x37: /* FBGT */
1490 if (fp_register_sign_bit (rav
) == 0 && ! fp_register_zero_p (rav
))
1493 case 0x33: /* FBLE */
1494 if (fp_register_sign_bit (rav
) == 1 || fp_register_zero_p (rav
))
1497 case 0x32: /* FBLT */
1498 if (fp_register_sign_bit (rav
) == 1 && ! fp_register_zero_p (rav
))
1501 case 0x35: /* FBNE */
1502 if (! fp_register_zero_p (rav
))
1508 /* Not a branch or branch not taken; target PC is:
1514 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1516 static CORE_ADDR next_pc
;
1519 if (insert_breakpoints_p
)
1522 next_pc
= alpha_next_pc (pc
);
1524 insert_single_step_breakpoint (next_pc
);
1528 remove_single_step_breakpoints ();
1534 /* Initialize the current architecture based on INFO. If possible, re-use an
1535 architecture from ARCHES, which is a list of architectures already created
1536 during this debugging session.
1538 Called e.g. at program startup, when reading a core file, and when reading
1541 static struct gdbarch
*
1542 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1544 struct gdbarch_tdep
*tdep
;
1545 struct gdbarch
*gdbarch
;
1547 /* Try to determine the ABI of the object we are loading. */
1548 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1550 /* If it's an ECOFF file, assume it's OSF/1. */
1551 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1552 info
.osabi
= GDB_OSABI_OSF1
;
1555 /* Find a candidate among extant architectures. */
1556 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1558 return arches
->gdbarch
;
1560 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1561 gdbarch
= gdbarch_alloc (&info
, tdep
);
1563 /* Lowest text address. This is used by heuristic_proc_start()
1564 to decide when to stop looking. */
1565 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000LL
;
1567 tdep
->dynamic_sigtramp_offset
= NULL
;
1568 tdep
->sigcontext_addr
= NULL
;
1569 tdep
->sc_pc_offset
= 2 * 8;
1570 tdep
->sc_regs_offset
= 4 * 8;
1571 tdep
->sc_fpregs_offset
= tdep
->sc_regs_offset
+ 32 * 8 + 8;
1573 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1575 tdep
->return_in_memory
= alpha_return_in_memory_always
;
1578 set_gdbarch_short_bit (gdbarch
, 16);
1579 set_gdbarch_int_bit (gdbarch
, 32);
1580 set_gdbarch_long_bit (gdbarch
, 64);
1581 set_gdbarch_long_long_bit (gdbarch
, 64);
1582 set_gdbarch_float_bit (gdbarch
, 32);
1583 set_gdbarch_double_bit (gdbarch
, 64);
1584 set_gdbarch_long_double_bit (gdbarch
, 64);
1585 set_gdbarch_ptr_bit (gdbarch
, 64);
1588 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1589 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1590 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1591 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1593 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1594 set_gdbarch_register_type (gdbarch
, alpha_register_type
);
1596 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1597 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1599 set_gdbarch_convert_register_p (gdbarch
, alpha_convert_register_p
);
1600 set_gdbarch_register_to_value (gdbarch
, alpha_register_to_value
);
1601 set_gdbarch_value_to_register (gdbarch
, alpha_value_to_register
);
1603 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1605 /* Prologue heuristics. */
1606 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1609 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1613 set_gdbarch_return_value (gdbarch
, alpha_return_value
);
1615 /* Settings for calling functions in the inferior. */
1616 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1618 /* Methods for saving / extracting a dummy frame's ID. */
1619 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1621 /* Return the unwound PC value. */
1622 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1624 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1625 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1627 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1628 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1629 set_gdbarch_cannot_step_breakpoint (gdbarch
, 1);
1631 /* Hook in ABI-specific overrides, if they have been registered. */
1632 gdbarch_init_osabi (info
, gdbarch
);
1634 /* Now that we have tuned the configuration, set a few final things
1635 based on what the OS ABI has told us. */
1637 if (tdep
->jb_pc
>= 0)
1638 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1640 frame_unwind_append_sniffer (gdbarch
, alpha_sigtramp_frame_sniffer
);
1641 frame_unwind_append_sniffer (gdbarch
, alpha_heuristic_frame_sniffer
);
1643 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1649 alpha_dwarf2_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1651 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1652 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
1655 extern initialize_file_ftype _initialize_alpha_tdep
; /* -Wmissing-prototypes */
1658 _initialize_alpha_tdep (void)
1660 struct cmd_list_element
*c
;
1662 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1664 /* Let the user set the fence post for heuristic_proc_start. */
1666 /* We really would like to have both "0" and "unlimited" work, but
1667 command.c doesn't deal with that. So make it a var_zinteger
1668 because the user can always use "999999" or some such for unlimited. */
1669 /* We need to throw away the frame cache when we set this, since it
1670 might change our ability to get backtraces. */
1671 add_setshow_zinteger_cmd ("heuristic-fence-post", class_support
,
1672 &heuristic_fence_post
, _("\
1673 Set the distance searched for the start of a function."), _("\
1674 Show the distance searched for the start of a function."), _("\
1675 If you are debugging a stripped executable, GDB needs to search through the\n\
1676 program for the start of a function. This command sets the distance of the\n\
1677 search. The only need to set it is when debugging a stripped executable."),
1678 reinit_frame_cache_sfunc
,
1679 NULL
, /* FIXME: i18n: The distance searched for the start of a function is \"%d\". */
1680 &setlist
, &showlist
);