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, 2002,
4 2003, 2005, 2006, 2007 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 3 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, see <http://www.gnu.org/licenses/>. */
24 #include "frame-unwind.h"
25 #include "frame-base.h"
26 #include "dwarf2-frame.h"
35 #include "gdb_string.h"
38 #include "reggroups.h"
39 #include "arch-utils.h"
46 #include "alpha-tdep.h"
49 /* Return the name of the REGNO register.
51 An empty name corresponds to a register number that used to
52 be used for a virtual register. That virtual register has
53 been removed, but the index is still reserved to maintain
54 compatibility with existing remote alpha targets. */
57 alpha_register_name (int regno
)
59 static const char * const register_names
[] =
61 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
62 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
63 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
64 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
65 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
66 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
67 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
68 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
74 if (regno
>= ARRAY_SIZE(register_names
))
76 return register_names
[regno
];
80 alpha_cannot_fetch_register (int regno
)
82 return (regno
== ALPHA_ZERO_REGNUM
83 || strlen (alpha_register_name (regno
)) == 0);
87 alpha_cannot_store_register (int regno
)
89 return (regno
== ALPHA_ZERO_REGNUM
90 || strlen (alpha_register_name (regno
)) == 0);
94 alpha_register_type (struct gdbarch
*gdbarch
, int regno
)
96 if (regno
== ALPHA_SP_REGNUM
|| regno
== ALPHA_GP_REGNUM
)
97 return builtin_type_void_data_ptr
;
98 if (regno
== ALPHA_PC_REGNUM
)
99 return builtin_type_void_func_ptr
;
101 /* Don't need to worry about little vs big endian until
102 some jerk tries to port to alpha-unicosmk. */
103 if (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31)
104 return builtin_type_ieee_double
;
106 return builtin_type_int64
;
109 /* Is REGNUM a member of REGGROUP? */
112 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
113 struct reggroup
*group
)
115 /* Filter out any registers eliminated, but whose regnum is
116 reserved for backward compatibility, e.g. the vfp. */
117 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
118 || *gdbarch_register_name (gdbarch
, regnum
) == '\0')
121 if (group
== all_reggroup
)
124 /* Zero should not be saved or restored. Technically it is a general
125 register (just as $f31 would be a float if we represented it), but
126 there's no point displaying it during "info regs", so leave it out
127 of all groups except for "all". */
128 if (regnum
== ALPHA_ZERO_REGNUM
)
131 /* All other registers are saved and restored. */
132 if (group
== save_reggroup
|| group
== restore_reggroup
)
135 /* All other groups are non-overlapping. */
137 /* Since this is really a PALcode memory slot... */
138 if (regnum
== ALPHA_UNIQUE_REGNUM
)
139 return group
== system_reggroup
;
141 /* Force the FPCR to be considered part of the floating point state. */
142 if (regnum
== ALPHA_FPCR_REGNUM
)
143 return group
== float_reggroup
;
145 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
146 return group
== float_reggroup
;
148 return group
== general_reggroup
;
151 /* The following represents exactly the conversion performed by
152 the LDS instruction. This applies to both single-precision
153 floating point and 32-bit integers. */
156 alpha_lds (void *out
, const void *in
)
158 ULONGEST mem
= extract_unsigned_integer (in
, 4);
159 ULONGEST frac
= (mem
>> 0) & 0x7fffff;
160 ULONGEST sign
= (mem
>> 31) & 1;
161 ULONGEST exp_msb
= (mem
>> 30) & 1;
162 ULONGEST exp_low
= (mem
>> 23) & 0x7f;
165 exp
= (exp_msb
<< 10) | exp_low
;
177 reg
= (sign
<< 63) | (exp
<< 52) | (frac
<< 29);
178 store_unsigned_integer (out
, 8, reg
);
181 /* Similarly, this represents exactly the conversion performed by
182 the STS instruction. */
185 alpha_sts (void *out
, const void *in
)
189 reg
= extract_unsigned_integer (in
, 8);
190 mem
= ((reg
>> 32) & 0xc0000000) | ((reg
>> 29) & 0x3fffffff);
191 store_unsigned_integer (out
, 4, mem
);
194 /* The alpha needs a conversion between register and memory format if the
195 register is a floating point register and memory format is float, as the
196 register format must be double or memory format is an integer with 4
197 bytes or less, as the representation of integers in floating point
198 registers is different. */
201 alpha_convert_register_p (int regno
, struct type
*type
)
203 return (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31);
207 alpha_register_to_value (struct frame_info
*frame
, int regnum
,
208 struct type
*valtype
, gdb_byte
*out
)
210 gdb_byte in
[MAX_REGISTER_SIZE
];
212 frame_register_read (frame
, regnum
, in
);
213 switch (TYPE_LENGTH (valtype
))
222 error (_("Cannot retrieve value from floating point register"));
227 alpha_value_to_register (struct frame_info
*frame
, int regnum
,
228 struct type
*valtype
, const gdb_byte
*in
)
230 gdb_byte out
[MAX_REGISTER_SIZE
];
232 switch (TYPE_LENGTH (valtype
))
241 error (_("Cannot store value in floating point register"));
243 put_frame_register (frame
, regnum
, out
);
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
, struct value
*function
,
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 struct alpha_arg
*m_arg
;
276 gdb_byte arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
277 int required_arg_regs
;
278 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
280 /* The ABI places the address of the called function in T12. */
281 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
283 /* Set the return address register to point to the entry point
284 of the program, where a breakpoint lies in wait. */
285 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
287 /* Lay out the arguments in memory. */
288 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
290 struct value
*arg
= args
[i
];
291 struct type
*arg_type
= check_typedef (value_type (arg
));
293 /* Cast argument to long if necessary as the compiler does it too. */
294 switch (TYPE_CODE (arg_type
))
299 case TYPE_CODE_RANGE
:
301 if (TYPE_LENGTH (arg_type
) == 4)
303 /* 32-bit values must be sign-extended to 64 bits
304 even if the base data type is unsigned. */
305 arg_type
= builtin_type_int32
;
306 arg
= value_cast (arg_type
, arg
);
308 if (TYPE_LENGTH (arg_type
) < ALPHA_REGISTER_SIZE
)
310 arg_type
= builtin_type_int64
;
311 arg
= value_cast (arg_type
, arg
);
316 /* "float" arguments loaded in registers must be passed in
317 register format, aka "double". */
318 if (accumulate_size
< sizeof (arg_reg_buffer
)
319 && TYPE_LENGTH (arg_type
) == 4)
321 arg_type
= builtin_type_ieee_double
;
322 arg
= value_cast (arg_type
, arg
);
324 /* Tru64 5.1 has a 128-bit long double, and passes this by
325 invisible reference. No one else uses this data type. */
326 else if (TYPE_LENGTH (arg_type
) == 16)
328 /* Allocate aligned storage. */
329 sp
= (sp
& -16) - 16;
331 /* Write the real data into the stack. */
332 write_memory (sp
, value_contents (arg
), 16);
334 /* Construct the indirection. */
335 arg_type
= lookup_pointer_type (arg_type
);
336 arg
= value_from_pointer (arg_type
, sp
);
340 case TYPE_CODE_COMPLEX
:
341 /* ??? The ABI says that complex values are passed as two
342 separate scalar values. This distinction only matters
343 for complex float. However, GCC does not implement this. */
345 /* Tru64 5.1 has a 128-bit long double, and passes this by
346 invisible reference. */
347 if (TYPE_LENGTH (arg_type
) == 32)
349 /* Allocate aligned storage. */
350 sp
= (sp
& -16) - 16;
352 /* Write the real data into the stack. */
353 write_memory (sp
, value_contents (arg
), 32);
355 /* Construct the indirection. */
356 arg_type
= lookup_pointer_type (arg_type
);
357 arg
= value_from_pointer (arg_type
, sp
);
364 m_arg
->len
= TYPE_LENGTH (arg_type
);
365 m_arg
->offset
= accumulate_size
;
366 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
367 m_arg
->contents
= value_contents_writeable (arg
);
370 /* Determine required argument register loads, loading an argument register
371 is expensive as it uses three ptrace calls. */
372 required_arg_regs
= accumulate_size
/ 8;
373 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
374 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
376 /* Make room for the arguments on the stack. */
377 if (accumulate_size
< sizeof(arg_reg_buffer
))
380 accumulate_size
-= sizeof(arg_reg_buffer
);
381 sp
-= accumulate_size
;
383 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
386 /* `Push' arguments on the stack. */
387 for (i
= nargs
; m_arg
--, --i
>= 0;)
389 gdb_byte
*contents
= m_arg
->contents
;
390 int offset
= m_arg
->offset
;
391 int len
= m_arg
->len
;
393 /* Copy the bytes destined for registers into arg_reg_buffer. */
394 if (offset
< sizeof(arg_reg_buffer
))
396 if (offset
+ len
<= sizeof(arg_reg_buffer
))
398 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
403 int tlen
= sizeof(arg_reg_buffer
) - offset
;
404 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
411 /* Everything else goes to the stack. */
412 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
415 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
417 /* Load the argument registers. */
418 for (i
= 0; i
< required_arg_regs
; i
++)
420 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
421 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
422 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
423 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
426 /* Finally, update the stack pointer. */
427 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
432 /* Extract from REGCACHE the value about to be returned from a function
433 and copy it into VALBUF. */
436 alpha_extract_return_value (struct type
*valtype
, struct regcache
*regcache
,
439 int length
= TYPE_LENGTH (valtype
);
440 gdb_byte raw_buffer
[ALPHA_REGISTER_SIZE
];
443 switch (TYPE_CODE (valtype
))
449 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
450 alpha_sts (valbuf
, raw_buffer
);
454 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
458 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
459 read_memory (l
, valbuf
, 16);
463 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
467 case TYPE_CODE_COMPLEX
:
471 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
472 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
476 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
477 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
+ 1, valbuf
+ 8);
481 regcache_cooked_read_signed (regcache
, ALPHA_V0_REGNUM
, &l
);
482 read_memory (l
, valbuf
, 32);
486 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
491 /* Assume everything else degenerates to an integer. */
492 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
493 store_unsigned_integer (valbuf
, length
, l
);
498 /* Insert the given value into REGCACHE as if it was being
499 returned by a function. */
502 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
503 const gdb_byte
*valbuf
)
505 int length
= TYPE_LENGTH (valtype
);
506 gdb_byte raw_buffer
[ALPHA_REGISTER_SIZE
];
509 switch (TYPE_CODE (valtype
))
515 alpha_lds (raw_buffer
, valbuf
);
516 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
520 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
524 /* FIXME: 128-bit long doubles are returned like structures:
525 by writing into indirect storage provided by the caller
526 as the first argument. */
527 error (_("Cannot set a 128-bit long double return value."));
530 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
534 case TYPE_CODE_COMPLEX
:
538 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
539 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
543 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
544 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
+ 1, valbuf
+ 8);
548 /* FIXME: 128-bit long doubles are returned like structures:
549 by writing into indirect storage provided by the caller
550 as the first argument. */
551 error (_("Cannot set a 128-bit long double return value."));
554 internal_error (__FILE__
, __LINE__
, _("unknown floating point width"));
559 /* Assume everything else degenerates to an integer. */
560 /* 32-bit values must be sign-extended to 64 bits
561 even if the base data type is unsigned. */
563 valtype
= builtin_type_int32
;
564 l
= unpack_long (valtype
, valbuf
);
565 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
570 static enum return_value_convention
571 alpha_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
572 struct regcache
*regcache
, gdb_byte
*readbuf
,
573 const gdb_byte
*writebuf
)
575 enum type_code code
= TYPE_CODE (type
);
577 if ((code
== TYPE_CODE_STRUCT
578 || code
== TYPE_CODE_UNION
579 || code
== TYPE_CODE_ARRAY
)
580 && gdbarch_tdep (gdbarch
)->return_in_memory (type
))
585 regcache_raw_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
586 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
589 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
593 alpha_extract_return_value (type
, regcache
, readbuf
);
595 alpha_store_return_value (type
, regcache
, writebuf
);
597 return RETURN_VALUE_REGISTER_CONVENTION
;
601 alpha_return_in_memory_always (struct type
*type
)
606 static const gdb_byte
*
607 alpha_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
609 static const gdb_byte break_insn
[] = { 0x80, 0, 0, 0 }; /* call_pal bpt */
611 *len
= sizeof(break_insn
);
616 /* This returns the PC of the first insn after the prologue.
617 If we can't find the prologue, then return 0. */
620 alpha_after_prologue (CORE_ADDR pc
)
622 struct symtab_and_line sal
;
623 CORE_ADDR func_addr
, func_end
;
625 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
628 sal
= find_pc_line (func_addr
, 0);
629 if (sal
.end
< func_end
)
632 /* The line after the prologue is after the end of the function. In this
633 case, tell the caller to find the prologue the hard way. */
637 /* Read an instruction from memory at PC, looking through breakpoints. */
640 alpha_read_insn (CORE_ADDR pc
)
642 gdb_byte buf
[ALPHA_INSN_SIZE
];
645 status
= read_memory_nobpt (pc
, buf
, sizeof (buf
));
647 memory_error (status
, pc
);
648 return extract_unsigned_integer (buf
, sizeof (buf
));
651 /* To skip prologues, I use this predicate. Returns either PC itself
652 if the code at PC does not look like a function prologue; otherwise
653 returns an address that (if we're lucky) follows the prologue. If
654 LENIENT, then we must skip everything which is involved in setting
655 up the frame (it's OK to skip more, just so long as we don't skip
656 anything which might clobber the registers which are being saved. */
659 alpha_skip_prologue (CORE_ADDR pc
)
663 CORE_ADDR post_prologue_pc
;
664 gdb_byte buf
[ALPHA_INSN_SIZE
];
666 /* Silently return the unaltered pc upon memory errors.
667 This could happen on OSF/1 if decode_line_1 tries to skip the
668 prologue for quickstarted shared library functions when the
669 shared library is not yet mapped in.
670 Reading target memory is slow over serial lines, so we perform
671 this check only if the target has shared libraries (which all
672 Alpha targets do). */
673 if (target_read_memory (pc
, buf
, sizeof (buf
)))
676 /* See if we can determine the end of the prologue via the symbol table.
677 If so, then return either PC, or the PC after the prologue, whichever
680 post_prologue_pc
= alpha_after_prologue (pc
);
681 if (post_prologue_pc
!= 0)
682 return max (pc
, post_prologue_pc
);
684 /* Can't determine prologue from the symbol table, need to examine
687 /* Skip the typical prologue instructions. These are the stack adjustment
688 instruction and the instructions that save registers on the stack
689 or in the gcc frame. */
690 for (offset
= 0; offset
< 100; offset
+= ALPHA_INSN_SIZE
)
692 inst
= alpha_read_insn (pc
+ offset
);
694 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
696 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
698 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
700 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
703 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
704 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
705 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
708 if (inst
== 0x47de040f) /* bis sp,sp,fp */
710 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
719 /* Figure out where the longjmp will land.
720 We expect the first arg to be a pointer to the jmp_buf structure from
721 which we extract the PC (JB_PC) that we will land at. The PC is copied
722 into the "pc". This routine returns true on success. */
725 alpha_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
727 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
729 gdb_byte raw_buffer
[ALPHA_REGISTER_SIZE
];
731 jb_addr
= get_frame_register_unsigned (frame
, ALPHA_A0_REGNUM
);
733 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
734 raw_buffer
, tdep
->jb_elt_size
))
737 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
742 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
743 describe the location and shape of the sigcontext structure. After
744 that, all registers are in memory, so it's easy. */
745 /* ??? Shouldn't we be able to do this generically, rather than with
746 OSABI data specific to Alpha? */
748 struct alpha_sigtramp_unwind_cache
750 CORE_ADDR sigcontext_addr
;
753 static struct alpha_sigtramp_unwind_cache
*
754 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
755 void **this_prologue_cache
)
757 struct alpha_sigtramp_unwind_cache
*info
;
758 struct gdbarch_tdep
*tdep
;
760 if (*this_prologue_cache
)
761 return *this_prologue_cache
;
763 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
764 *this_prologue_cache
= info
;
766 tdep
= gdbarch_tdep (get_frame_arch (next_frame
));
767 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
772 /* Return the address of REGNUM in a sigtramp frame. Since this is
773 all arithmetic, it doesn't seem worthwhile to cache it. */
776 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, int regnum
)
778 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
780 if (regnum
>= 0 && regnum
< 32)
781 return sigcontext_addr
+ tdep
->sc_regs_offset
+ regnum
* 8;
782 else if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 32)
783 return sigcontext_addr
+ tdep
->sc_fpregs_offset
+ regnum
* 8;
784 else if (regnum
== ALPHA_PC_REGNUM
)
785 return sigcontext_addr
+ tdep
->sc_pc_offset
;
790 /* Given a GDB frame, determine the address of the calling function's
791 frame. This will be used to create a new GDB frame struct. */
794 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
795 void **this_prologue_cache
,
796 struct frame_id
*this_id
)
798 struct alpha_sigtramp_unwind_cache
*info
799 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
800 struct gdbarch_tdep
*tdep
;
801 CORE_ADDR stack_addr
, code_addr
;
803 /* If the OSABI couldn't locate the sigcontext, give up. */
804 if (info
->sigcontext_addr
== 0)
807 /* If we have dynamic signal trampolines, find their start.
808 If we do not, then we must assume there is a symbol record
809 that can provide the start address. */
810 tdep
= gdbarch_tdep (get_frame_arch (next_frame
));
811 if (tdep
->dynamic_sigtramp_offset
)
814 code_addr
= frame_pc_unwind (next_frame
);
815 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
822 code_addr
= frame_func_unwind (next_frame
, SIGTRAMP_FRAME
);
824 /* The stack address is trivially read from the sigcontext. */
825 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
827 stack_addr
= get_frame_memory_unsigned (next_frame
, stack_addr
,
828 ALPHA_REGISTER_SIZE
);
830 *this_id
= frame_id_build (stack_addr
, code_addr
);
833 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
836 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
837 void **this_prologue_cache
,
838 int regnum
, int *optimizedp
,
839 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
840 int *realnump
, gdb_byte
*bufferp
)
842 struct alpha_sigtramp_unwind_cache
*info
843 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
846 if (info
->sigcontext_addr
!= 0)
848 /* All integer and fp registers are stored in memory. */
849 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
853 *lvalp
= lval_memory
;
857 get_frame_memory (next_frame
, addr
, bufferp
, ALPHA_REGISTER_SIZE
);
862 /* This extra register may actually be in the sigcontext, but our
863 current description of it in alpha_sigtramp_frame_unwind_cache
864 doesn't include it. Too bad. Fall back on whatever's in the
867 *lvalp
= lval_register
;
871 frame_unwind_register (next_frame
, *realnump
, bufferp
);
874 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
876 alpha_sigtramp_frame_this_id
,
877 alpha_sigtramp_frame_prev_register
880 static const struct frame_unwind
*
881 alpha_sigtramp_frame_sniffer (struct frame_info
*next_frame
)
883 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
884 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
887 /* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
888 look at tramp-frame.h and other simplier per-architecture
889 sigtramp unwinders. */
891 /* We shouldn't even bother to try if the OSABI didn't register a
892 sigcontext_addr handler or pc_in_sigtramp hander. */
893 if (gdbarch_tdep (gdbarch
)->sigcontext_addr
== NULL
)
895 if (gdbarch_tdep (gdbarch
)->pc_in_sigtramp
== NULL
)
898 /* Otherwise we should be in a signal frame. */
899 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
900 if (gdbarch_tdep (gdbarch
)->pc_in_sigtramp (pc
, name
))
901 return &alpha_sigtramp_frame_unwind
;
906 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
907 something about the traditional layout of alpha stack frames. */
909 struct alpha_heuristic_unwind_cache
911 CORE_ADDR
*saved_regs
;
917 /* Heuristic_proc_start may hunt through the text section for a long
918 time across a 2400 baud serial line. Allows the user to limit this
920 static unsigned int heuristic_fence_post
= 0;
922 /* Attempt to locate the start of the function containing PC. We assume that
923 the previous function ends with an about_to_return insn. Not foolproof by
924 any means, since gcc is happy to put the epilogue in the middle of a
925 function. But we're guessing anyway... */
928 alpha_heuristic_proc_start (CORE_ADDR pc
)
930 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
931 CORE_ADDR last_non_nop
= pc
;
932 CORE_ADDR fence
= pc
- heuristic_fence_post
;
933 CORE_ADDR orig_pc
= pc
;
939 /* First see if we can find the start of the function from minimal
940 symbol information. This can succeed with a binary that doesn't
941 have debug info, but hasn't been stripped. */
942 func
= get_pc_function_start (pc
);
946 if (heuristic_fence_post
== UINT_MAX
947 || fence
< tdep
->vm_min_address
)
948 fence
= tdep
->vm_min_address
;
950 /* Search back for previous return; also stop at a 0, which might be
951 seen for instance before the start of a code section. Don't include
952 nops, since this usually indicates padding between functions. */
953 for (pc
-= ALPHA_INSN_SIZE
; pc
>= fence
; pc
-= ALPHA_INSN_SIZE
)
955 unsigned int insn
= alpha_read_insn (pc
);
958 case 0: /* invalid insn */
959 case 0x6bfa8001: /* ret $31,($26),1 */
962 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
963 case 0x47ff041f: /* nop: bis $31,$31,$31 */
972 /* It's not clear to me why we reach this point when stopping quietly,
973 but with this test, at least we don't print out warnings for every
974 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
975 if (stop_soon
== NO_STOP_QUIETLY
)
977 static int blurb_printed
= 0;
979 if (fence
== tdep
->vm_min_address
)
980 warning (_("Hit beginning of text section without finding \
981 enclosing function for address 0x%s"), paddr_nz (orig_pc
));
983 warning (_("Hit heuristic-fence-post without finding \
984 enclosing function for address 0x%s"), paddr_nz (orig_pc
));
988 printf_filtered (_("\
989 This warning occurs if you are debugging a function without any symbols\n\
990 (for example, in a stripped executable). In that case, you may wish to\n\
991 increase the size of the search with the `set heuristic-fence-post' command.\n\
993 Otherwise, you told GDB there was a function where there isn't one, or\n\
994 (more likely) you have encountered a bug in GDB.\n"));
1002 static struct alpha_heuristic_unwind_cache
*
1003 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
1004 void **this_prologue_cache
,
1007 struct alpha_heuristic_unwind_cache
*info
;
1009 CORE_ADDR limit_pc
, cur_pc
;
1010 int frame_reg
, frame_size
, return_reg
, reg
;
1012 if (*this_prologue_cache
)
1013 return *this_prologue_cache
;
1015 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
1016 *this_prologue_cache
= info
;
1017 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
1019 limit_pc
= frame_pc_unwind (next_frame
);
1021 start_pc
= alpha_heuristic_proc_start (limit_pc
);
1022 info
->start_pc
= start_pc
;
1024 frame_reg
= ALPHA_SP_REGNUM
;
1028 /* If we've identified a likely place to start, do code scanning. */
1031 /* Limit the forward search to 50 instructions. */
1032 if (start_pc
+ 200 < limit_pc
)
1033 limit_pc
= start_pc
+ 200;
1035 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= ALPHA_INSN_SIZE
)
1037 unsigned int word
= alpha_read_insn (cur_pc
);
1039 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1043 /* Consider only the first stack allocation instruction
1044 to contain the static size of the frame. */
1045 if (frame_size
== 0)
1046 frame_size
= (-word
) & 0xffff;
1050 /* Exit loop if a positive stack adjustment is found, which
1051 usually means that the stack cleanup code in the function
1052 epilogue is reached. */
1056 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1058 reg
= (word
& 0x03e00000) >> 21;
1060 /* Ignore this instruction if we have already encountered
1061 an instruction saving the same register earlier in the
1062 function code. The current instruction does not tell
1063 us where the original value upon function entry is saved.
1064 All it says is that the function we are scanning reused
1065 that register for some computation of its own, and is now
1066 saving its result. */
1067 if (info
->saved_regs
[reg
])
1073 /* Do not compute the address where the register was saved yet,
1074 because we don't know yet if the offset will need to be
1075 relative to $sp or $fp (we can not compute the address
1076 relative to $sp if $sp is updated during the execution of
1077 the current subroutine, for instance when doing some alloca).
1078 So just store the offset for the moment, and compute the
1079 address later when we know whether this frame has a frame
1081 /* Hack: temporarily add one, so that the offset is non-zero
1082 and we can tell which registers have save offsets below. */
1083 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
1085 /* Starting with OSF/1-3.2C, the system libraries are shipped
1086 without local symbols, but they still contain procedure
1087 descriptors without a symbol reference. GDB is currently
1088 unable to find these procedure descriptors and uses
1089 heuristic_proc_desc instead.
1090 As some low level compiler support routines (__div*, __add*)
1091 use a non-standard return address register, we have to
1092 add some heuristics to determine the return address register,
1093 or stepping over these routines will fail.
1094 Usually the return address register is the first register
1095 saved on the stack, but assembler optimization might
1096 rearrange the register saves.
1097 So we recognize only a few registers (t7, t9, ra) within
1098 the procedure prologue as valid return address registers.
1099 If we encounter a return instruction, we extract the
1100 the return address register from it.
1102 FIXME: Rewriting GDB to access the procedure descriptors,
1103 e.g. via the minimal symbol table, might obviate this hack. */
1104 if (return_reg
== -1
1105 && cur_pc
< (start_pc
+ 80)
1106 && (reg
== ALPHA_T7_REGNUM
1107 || reg
== ALPHA_T9_REGNUM
1108 || reg
== ALPHA_RA_REGNUM
))
1111 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1112 return_reg
= (word
>> 16) & 0x1f;
1113 else if (word
== 0x47de040f) /* bis sp,sp,fp */
1114 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1115 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
1116 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1119 /* If we haven't found a valid return address register yet, keep
1120 searching in the procedure prologue. */
1121 if (return_reg
== -1)
1123 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
1125 unsigned int word
= alpha_read_insn (cur_pc
);
1127 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1129 reg
= (word
& 0x03e00000) >> 21;
1130 if (reg
== ALPHA_T7_REGNUM
1131 || reg
== ALPHA_T9_REGNUM
1132 || reg
== ALPHA_RA_REGNUM
)
1138 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1140 return_reg
= (word
>> 16) & 0x1f;
1144 cur_pc
+= ALPHA_INSN_SIZE
;
1149 /* Failing that, do default to the customary RA. */
1150 if (return_reg
== -1)
1151 return_reg
= ALPHA_RA_REGNUM
;
1152 info
->return_reg
= return_reg
;
1154 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
1155 info
->vfp
= val
+ frame_size
;
1157 /* Convert offsets to absolute addresses. See above about adding
1158 one to the offsets to make all detected offsets non-zero. */
1159 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1160 if (info
->saved_regs
[reg
])
1161 info
->saved_regs
[reg
] += val
- 1;
1166 /* Given a GDB frame, determine the address of the calling function's
1167 frame. This will be used to create a new GDB frame struct. */
1170 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
1171 void **this_prologue_cache
,
1172 struct frame_id
*this_id
)
1174 struct alpha_heuristic_unwind_cache
*info
1175 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1177 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1180 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1183 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
1184 void **this_prologue_cache
,
1185 int regnum
, int *optimizedp
,
1186 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1187 int *realnump
, gdb_byte
*bufferp
)
1189 struct alpha_heuristic_unwind_cache
*info
1190 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1192 /* The PC of the previous frame is stored in the link register of
1193 the current frame. Frob regnum so that we pull the value from
1194 the correct place. */
1195 if (regnum
== ALPHA_PC_REGNUM
)
1196 regnum
= info
->return_reg
;
1198 /* For all registers known to be saved in the current frame,
1199 do the obvious and pull the value out. */
1200 if (info
->saved_regs
[regnum
])
1203 *lvalp
= lval_memory
;
1204 *addrp
= info
->saved_regs
[regnum
];
1206 if (bufferp
!= NULL
)
1207 get_frame_memory (next_frame
, *addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1211 /* The stack pointer of the previous frame is computed by popping
1212 the current stack frame. */
1213 if (regnum
== ALPHA_SP_REGNUM
)
1219 if (bufferp
!= NULL
)
1220 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1224 /* Otherwise assume the next frame has the same register value. */
1226 *lvalp
= lval_register
;
1230 frame_unwind_register (next_frame
, *realnump
, bufferp
);
1233 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1235 alpha_heuristic_frame_this_id
,
1236 alpha_heuristic_frame_prev_register
1239 static const struct frame_unwind
*
1240 alpha_heuristic_frame_sniffer (struct frame_info
*next_frame
)
1242 return &alpha_heuristic_frame_unwind
;
1246 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1247 void **this_prologue_cache
)
1249 struct alpha_heuristic_unwind_cache
*info
1250 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1255 static const struct frame_base alpha_heuristic_frame_base
= {
1256 &alpha_heuristic_frame_unwind
,
1257 alpha_heuristic_frame_base_address
,
1258 alpha_heuristic_frame_base_address
,
1259 alpha_heuristic_frame_base_address
1262 /* Just like reinit_frame_cache, but with the right arguments to be
1263 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1266 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1268 reinit_frame_cache ();
1272 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1273 dummy frame. The frame ID's base needs to match the TOS value
1274 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1277 static struct frame_id
1278 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1281 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1282 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1286 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1289 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1294 /* Helper routines for alpha*-nat.c files to move register sets to and
1295 from core files. The UNIQUE pointer is allowed to be NULL, as most
1296 targets don't supply this value in their core files. */
1299 alpha_supply_int_regs (struct regcache
*regcache
, int regno
,
1300 const void *r0_r30
, const void *pc
, const void *unique
)
1302 const gdb_byte
*regs
= r0_r30
;
1305 for (i
= 0; i
< 31; ++i
)
1306 if (regno
== i
|| regno
== -1)
1307 regcache_raw_supply (regcache
, i
, regs
+ i
* 8);
1309 if (regno
== ALPHA_ZERO_REGNUM
|| regno
== -1)
1310 regcache_raw_supply (regcache
, ALPHA_ZERO_REGNUM
, NULL
);
1312 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1313 regcache_raw_supply (regcache
, ALPHA_PC_REGNUM
, pc
);
1315 if (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1)
1316 regcache_raw_supply (regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1320 alpha_fill_int_regs (const struct regcache
*regcache
,
1321 int regno
, void *r0_r30
, void *pc
, void *unique
)
1323 gdb_byte
*regs
= r0_r30
;
1326 for (i
= 0; i
< 31; ++i
)
1327 if (regno
== i
|| regno
== -1)
1328 regcache_raw_collect (regcache
, i
, regs
+ i
* 8);
1330 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1331 regcache_raw_collect (regcache
, ALPHA_PC_REGNUM
, pc
);
1333 if (unique
&& (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1))
1334 regcache_raw_collect (regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1338 alpha_supply_fp_regs (struct regcache
*regcache
, int regno
,
1339 const void *f0_f30
, const void *fpcr
)
1341 const gdb_byte
*regs
= f0_f30
;
1344 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1345 if (regno
== i
|| regno
== -1)
1346 regcache_raw_supply (regcache
, i
,
1347 regs
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1349 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1350 regcache_raw_supply (regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1354 alpha_fill_fp_regs (const struct regcache
*regcache
,
1355 int regno
, void *f0_f30
, void *fpcr
)
1357 gdb_byte
*regs
= f0_f30
;
1360 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1361 if (regno
== i
|| regno
== -1)
1362 regcache_raw_collect (regcache
, i
,
1363 regs
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1365 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1366 regcache_raw_collect (regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1371 /* Return nonzero if the G_floating register value in REG is equal to
1372 zero for FP control instructions. */
1375 fp_register_zero_p (LONGEST reg
)
1377 /* Check that all bits except the sign bit are zero. */
1378 const LONGEST zero_mask
= ((LONGEST
) 1 << 63) ^ -1;
1380 return ((reg
& zero_mask
) == 0);
1383 /* Return the value of the sign bit for the G_floating register
1384 value held in REG. */
1387 fp_register_sign_bit (LONGEST reg
)
1389 const LONGEST sign_mask
= (LONGEST
) 1 << 63;
1391 return ((reg
& sign_mask
) != 0);
1394 /* alpha_software_single_step() is called just before we want to resume
1395 the inferior, if we want to single-step it but there is no hardware
1396 or kernel single-step support (NetBSD on Alpha, for example). We find
1397 the target of the coming instruction and breakpoint it. */
1400 alpha_next_pc (struct frame_info
*frame
, CORE_ADDR pc
)
1408 insn
= alpha_read_insn (pc
);
1410 /* Opcode is top 6 bits. */
1411 op
= (insn
>> 26) & 0x3f;
1415 /* Jump format: target PC is:
1417 return (get_frame_register_unsigned (frame
, (insn
>> 16) & 0x1f) & ~3);
1420 if ((op
& 0x30) == 0x30)
1422 /* Branch format: target PC is:
1423 (new PC) + (4 * sext(displacement)) */
1424 if (op
== 0x30 || /* BR */
1425 op
== 0x34) /* BSR */
1428 offset
= (insn
& 0x001fffff);
1429 if (offset
& 0x00100000)
1430 offset
|= 0xffe00000;
1431 offset
*= ALPHA_INSN_SIZE
;
1432 return (pc
+ ALPHA_INSN_SIZE
+ offset
);
1435 /* Need to determine if branch is taken; read RA. */
1436 regno
= (insn
>> 21) & 0x1f;
1439 case 0x31: /* FBEQ */
1440 case 0x36: /* FBGE */
1441 case 0x37: /* FBGT */
1442 case 0x33: /* FBLE */
1443 case 0x32: /* FBLT */
1444 case 0x35: /* FBNE */
1445 regno
+= gdbarch_fp0_regnum (get_frame_arch (frame
));
1448 rav
= get_frame_register_signed (frame
, regno
);
1452 case 0x38: /* BLBC */
1456 case 0x3c: /* BLBS */
1460 case 0x39: /* BEQ */
1464 case 0x3d: /* BNE */
1468 case 0x3a: /* BLT */
1472 case 0x3b: /* BLE */
1476 case 0x3f: /* BGT */
1480 case 0x3e: /* BGE */
1485 /* Floating point branches. */
1487 case 0x31: /* FBEQ */
1488 if (fp_register_zero_p (rav
))
1491 case 0x36: /* FBGE */
1492 if (fp_register_sign_bit (rav
) == 0 || fp_register_zero_p (rav
))
1495 case 0x37: /* FBGT */
1496 if (fp_register_sign_bit (rav
) == 0 && ! fp_register_zero_p (rav
))
1499 case 0x33: /* FBLE */
1500 if (fp_register_sign_bit (rav
) == 1 || fp_register_zero_p (rav
))
1503 case 0x32: /* FBLT */
1504 if (fp_register_sign_bit (rav
) == 1 && ! fp_register_zero_p (rav
))
1507 case 0x35: /* FBNE */
1508 if (! fp_register_zero_p (rav
))
1514 /* Not a branch or branch not taken; target PC is:
1516 return (pc
+ ALPHA_INSN_SIZE
);
1520 alpha_software_single_step (struct frame_info
*frame
)
1522 CORE_ADDR pc
, next_pc
;
1524 pc
= get_frame_pc (frame
);
1525 next_pc
= alpha_next_pc (frame
, pc
);
1527 insert_single_step_breakpoint (next_pc
);
1532 /* Initialize the current architecture based on INFO. If possible, re-use an
1533 architecture from ARCHES, which is a list of architectures already created
1534 during this debugging session.
1536 Called e.g. at program startup, when reading a core file, and when reading
1539 static struct gdbarch
*
1540 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1542 struct gdbarch_tdep
*tdep
;
1543 struct gdbarch
*gdbarch
;
1545 /* Try to determine the ABI of the object we are loading. */
1546 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1548 /* If it's an ECOFF file, assume it's OSF/1. */
1549 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1550 info
.osabi
= GDB_OSABI_OSF1
;
1553 /* Find a candidate among extant architectures. */
1554 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1556 return arches
->gdbarch
;
1558 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1559 gdbarch
= gdbarch_alloc (&info
, tdep
);
1561 /* Lowest text address. This is used by heuristic_proc_start()
1562 to decide when to stop looking. */
1563 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000LL
;
1565 tdep
->dynamic_sigtramp_offset
= NULL
;
1566 tdep
->sigcontext_addr
= NULL
;
1567 tdep
->sc_pc_offset
= 2 * 8;
1568 tdep
->sc_regs_offset
= 4 * 8;
1569 tdep
->sc_fpregs_offset
= tdep
->sc_regs_offset
+ 32 * 8 + 8;
1571 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1573 tdep
->return_in_memory
= alpha_return_in_memory_always
;
1576 set_gdbarch_short_bit (gdbarch
, 16);
1577 set_gdbarch_int_bit (gdbarch
, 32);
1578 set_gdbarch_long_bit (gdbarch
, 64);
1579 set_gdbarch_long_long_bit (gdbarch
, 64);
1580 set_gdbarch_float_bit (gdbarch
, 32);
1581 set_gdbarch_double_bit (gdbarch
, 64);
1582 set_gdbarch_long_double_bit (gdbarch
, 64);
1583 set_gdbarch_ptr_bit (gdbarch
, 64);
1586 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1587 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1588 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1589 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1591 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1592 set_gdbarch_register_type (gdbarch
, alpha_register_type
);
1594 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1595 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1597 set_gdbarch_convert_register_p (gdbarch
, alpha_convert_register_p
);
1598 set_gdbarch_register_to_value (gdbarch
, alpha_register_to_value
);
1599 set_gdbarch_value_to_register (gdbarch
, alpha_value_to_register
);
1601 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1603 /* Prologue heuristics. */
1604 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1607 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1611 set_gdbarch_return_value (gdbarch
, alpha_return_value
);
1613 /* Settings for calling functions in the inferior. */
1614 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1616 /* Methods for saving / extracting a dummy frame's ID. */
1617 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1619 /* Return the unwound PC value. */
1620 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1622 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1623 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1625 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1626 set_gdbarch_decr_pc_after_break (gdbarch
, ALPHA_INSN_SIZE
);
1627 set_gdbarch_cannot_step_breakpoint (gdbarch
, 1);
1629 /* Hook in ABI-specific overrides, if they have been registered. */
1630 gdbarch_init_osabi (info
, gdbarch
);
1632 /* Now that we have tuned the configuration, set a few final things
1633 based on what the OS ABI has told us. */
1635 if (tdep
->jb_pc
>= 0)
1636 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1638 frame_unwind_append_sniffer (gdbarch
, alpha_sigtramp_frame_sniffer
);
1639 frame_unwind_append_sniffer (gdbarch
, alpha_heuristic_frame_sniffer
);
1641 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1647 alpha_dwarf2_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1649 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1650 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
1653 extern initialize_file_ftype _initialize_alpha_tdep
; /* -Wmissing-prototypes */
1656 _initialize_alpha_tdep (void)
1658 struct cmd_list_element
*c
;
1660 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1662 /* Let the user set the fence post for heuristic_proc_start. */
1664 /* We really would like to have both "0" and "unlimited" work, but
1665 command.c doesn't deal with that. So make it a var_zinteger
1666 because the user can always use "999999" or some such for unlimited. */
1667 /* We need to throw away the frame cache when we set this, since it
1668 might change our ability to get backtraces. */
1669 add_setshow_zinteger_cmd ("heuristic-fence-post", class_support
,
1670 &heuristic_fence_post
, _("\
1671 Set the distance searched for the start of a function."), _("\
1672 Show the distance searched for the start of a function."), _("\
1673 If you are debugging a stripped executable, GDB needs to search through the\n\
1674 program for the start of a function. This command sets the distance of the\n\
1675 search. The only need to set it is when debugging a stripped executable."),
1676 reinit_frame_cache_sfunc
,
1677 NULL
, /* FIXME: i18n: The distance searched for the start of a function is \"%d\". */
1678 &setlist
, &showlist
);