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, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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"
44 #include "trad-frame.h"
48 #include "alpha-tdep.h"
50 /* Instruction decoding. The notations for registers, immediates and
51 opcodes are the same as the one used in Compaq's Alpha architecture
54 #define INSN_OPCODE(insn) ((insn & 0xfc000000) >> 26)
56 /* Memory instruction format */
57 #define MEM_RA(insn) ((insn & 0x03e00000) >> 21)
58 #define MEM_RB(insn) ((insn & 0x001f0000) >> 16)
59 #define MEM_DISP(insn) \
60 (((insn & 0x8000) == 0) ? (insn & 0xffff) : -((-insn) & 0xffff))
62 static const int lda_opcode
= 0x08;
63 static const int stq_opcode
= 0x2d;
65 /* Branch instruction format */
66 #define BR_RA(insn) MEM_RA(insn)
68 static const int bne_opcode
= 0x3d;
70 /* Operate instruction format */
71 #define OPR_FUNCTION(insn) ((insn & 0xfe0) >> 5)
72 #define OPR_HAS_IMMEDIATE(insn) ((insn & 0x1000) == 0x1000)
73 #define OPR_RA(insn) MEM_RA(insn)
74 #define OPR_RC(insn) ((insn & 0x1f))
75 #define OPR_LIT(insn) ((insn & 0x1fe000) >> 13)
77 static const int subq_opcode
= 0x10;
78 static const int subq_function
= 0x29;
81 /* Return the name of the REGNO register.
83 An empty name corresponds to a register number that used to
84 be used for a virtual register. That virtual register has
85 been removed, but the index is still reserved to maintain
86 compatibility with existing remote alpha targets. */
89 alpha_register_name (struct gdbarch
*gdbarch
, int regno
)
91 static const char * const register_names
[] =
93 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
94 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
95 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
96 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
97 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
98 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
99 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
100 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
106 if (regno
>= ARRAY_SIZE(register_names
))
108 return register_names
[regno
];
112 alpha_cannot_fetch_register (struct gdbarch
*gdbarch
, int regno
)
114 return (regno
== ALPHA_ZERO_REGNUM
115 || strlen (alpha_register_name (gdbarch
, regno
)) == 0);
119 alpha_cannot_store_register (struct gdbarch
*gdbarch
, int regno
)
121 return (regno
== ALPHA_ZERO_REGNUM
122 || strlen (alpha_register_name (gdbarch
, regno
)) == 0);
126 alpha_register_type (struct gdbarch
*gdbarch
, int regno
)
128 if (regno
== ALPHA_SP_REGNUM
|| regno
== ALPHA_GP_REGNUM
)
129 return builtin_type (gdbarch
)->builtin_data_ptr
;
130 if (regno
== ALPHA_PC_REGNUM
)
131 return builtin_type (gdbarch
)->builtin_func_ptr
;
133 /* Don't need to worry about little vs big endian until
134 some jerk tries to port to alpha-unicosmk. */
135 if (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31)
136 return builtin_type (gdbarch
)->builtin_double
;
138 return builtin_type (gdbarch
)->builtin_int64
;
141 /* Is REGNUM a member of REGGROUP? */
144 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
145 struct reggroup
*group
)
147 /* Filter out any registers eliminated, but whose regnum is
148 reserved for backward compatibility, e.g. the vfp. */
149 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
150 || *gdbarch_register_name (gdbarch
, regnum
) == '\0')
153 if (group
== all_reggroup
)
156 /* Zero should not be saved or restored. Technically it is a general
157 register (just as $f31 would be a float if we represented it), but
158 there's no point displaying it during "info regs", so leave it out
159 of all groups except for "all". */
160 if (regnum
== ALPHA_ZERO_REGNUM
)
163 /* All other registers are saved and restored. */
164 if (group
== save_reggroup
|| group
== restore_reggroup
)
167 /* All other groups are non-overlapping. */
169 /* Since this is really a PALcode memory slot... */
170 if (regnum
== ALPHA_UNIQUE_REGNUM
)
171 return group
== system_reggroup
;
173 /* Force the FPCR to be considered part of the floating point state. */
174 if (regnum
== ALPHA_FPCR_REGNUM
)
175 return group
== float_reggroup
;
177 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
178 return group
== float_reggroup
;
180 return group
== general_reggroup
;
183 /* The following represents exactly the conversion performed by
184 the LDS instruction. This applies to both single-precision
185 floating point and 32-bit integers. */
188 alpha_lds (struct gdbarch
*gdbarch
, void *out
, const void *in
)
190 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
191 ULONGEST mem
= extract_unsigned_integer (in
, 4, byte_order
);
192 ULONGEST frac
= (mem
>> 0) & 0x7fffff;
193 ULONGEST sign
= (mem
>> 31) & 1;
194 ULONGEST exp_msb
= (mem
>> 30) & 1;
195 ULONGEST exp_low
= (mem
>> 23) & 0x7f;
198 exp
= (exp_msb
<< 10) | exp_low
;
210 reg
= (sign
<< 63) | (exp
<< 52) | (frac
<< 29);
211 store_unsigned_integer (out
, 8, byte_order
, reg
);
214 /* Similarly, this represents exactly the conversion performed by
215 the STS instruction. */
218 alpha_sts (struct gdbarch
*gdbarch
, void *out
, const void *in
)
220 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
223 reg
= extract_unsigned_integer (in
, 8, byte_order
);
224 mem
= ((reg
>> 32) & 0xc0000000) | ((reg
>> 29) & 0x3fffffff);
225 store_unsigned_integer (out
, 4, byte_order
, mem
);
228 /* The alpha needs a conversion between register and memory format if the
229 register is a floating point register and memory format is float, as the
230 register format must be double or memory format is an integer with 4
231 bytes or less, as the representation of integers in floating point
232 registers is different. */
235 alpha_convert_register_p (struct gdbarch
*gdbarch
, int regno
,
238 return (regno
>= ALPHA_FP0_REGNUM
&& regno
< ALPHA_FP0_REGNUM
+ 31
239 && TYPE_LENGTH (type
) != 8);
243 alpha_register_to_value (struct frame_info
*frame
, int regnum
,
244 struct type
*valtype
, gdb_byte
*out
,
245 int *optimizedp
, int *unavailablep
)
247 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
248 gdb_byte in
[MAX_REGISTER_SIZE
];
250 /* Convert to TYPE. */
251 if (!get_frame_register_bytes (frame
, regnum
, 0,
252 register_size (gdbarch
, regnum
),
253 in
, optimizedp
, unavailablep
))
256 if (TYPE_LENGTH (valtype
) == 4)
258 alpha_sts (gdbarch
, out
, in
);
259 *optimizedp
= *unavailablep
= 0;
263 error (_("Cannot retrieve value from floating point register"));
267 alpha_value_to_register (struct frame_info
*frame
, int regnum
,
268 struct type
*valtype
, const gdb_byte
*in
)
270 gdb_byte out
[MAX_REGISTER_SIZE
];
272 switch (TYPE_LENGTH (valtype
))
275 alpha_lds (get_frame_arch (frame
), out
, in
);
278 error (_("Cannot store value in floating point register"));
280 put_frame_register (frame
, regnum
, out
);
284 /* The alpha passes the first six arguments in the registers, the rest on
285 the stack. The register arguments are stored in ARG_REG_BUFFER, and
286 then moved into the register file; this simplifies the passing of a
287 large struct which extends from the registers to the stack, plus avoids
288 three ptrace invocations per word.
290 We don't bother tracking which register values should go in integer
291 regs or fp regs; we load the same values into both.
293 If the called function is returning a structure, the address of the
294 structure to be returned is passed as a hidden first argument. */
297 alpha_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
298 struct regcache
*regcache
, CORE_ADDR bp_addr
,
299 int nargs
, struct value
**args
, CORE_ADDR sp
,
300 int struct_return
, CORE_ADDR struct_addr
)
302 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
304 int accumulate_size
= struct_return
? 8 : 0;
307 const gdb_byte
*contents
;
311 struct alpha_arg
*alpha_args
312 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
313 struct alpha_arg
*m_arg
;
314 gdb_byte arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
315 int required_arg_regs
;
316 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
318 /* The ABI places the address of the called function in T12. */
319 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
321 /* Set the return address register to point to the entry point
322 of the program, where a breakpoint lies in wait. */
323 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
325 /* Lay out the arguments in memory. */
326 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
328 struct value
*arg
= args
[i
];
329 struct type
*arg_type
= check_typedef (value_type (arg
));
331 /* Cast argument to long if necessary as the compiler does it too. */
332 switch (TYPE_CODE (arg_type
))
337 case TYPE_CODE_RANGE
:
339 if (TYPE_LENGTH (arg_type
) == 4)
341 /* 32-bit values must be sign-extended to 64 bits
342 even if the base data type is unsigned. */
343 arg_type
= builtin_type (gdbarch
)->builtin_int32
;
344 arg
= value_cast (arg_type
, arg
);
346 if (TYPE_LENGTH (arg_type
) < ALPHA_REGISTER_SIZE
)
348 arg_type
= builtin_type (gdbarch
)->builtin_int64
;
349 arg
= value_cast (arg_type
, arg
);
354 /* "float" arguments loaded in registers must be passed in
355 register format, aka "double". */
356 if (accumulate_size
< sizeof (arg_reg_buffer
)
357 && TYPE_LENGTH (arg_type
) == 4)
359 arg_type
= builtin_type (gdbarch
)->builtin_double
;
360 arg
= value_cast (arg_type
, arg
);
362 /* Tru64 5.1 has a 128-bit long double, and passes this by
363 invisible reference. No one else uses this data type. */
364 else if (TYPE_LENGTH (arg_type
) == 16)
366 /* Allocate aligned storage. */
367 sp
= (sp
& -16) - 16;
369 /* Write the real data into the stack. */
370 write_memory (sp
, value_contents (arg
), 16);
372 /* Construct the indirection. */
373 arg_type
= lookup_pointer_type (arg_type
);
374 arg
= value_from_pointer (arg_type
, sp
);
378 case TYPE_CODE_COMPLEX
:
379 /* ??? The ABI says that complex values are passed as two
380 separate scalar values. This distinction only matters
381 for complex float. However, GCC does not implement this. */
383 /* Tru64 5.1 has a 128-bit long double, and passes this by
384 invisible reference. */
385 if (TYPE_LENGTH (arg_type
) == 32)
387 /* Allocate aligned storage. */
388 sp
= (sp
& -16) - 16;
390 /* Write the real data into the stack. */
391 write_memory (sp
, value_contents (arg
), 32);
393 /* Construct the indirection. */
394 arg_type
= lookup_pointer_type (arg_type
);
395 arg
= value_from_pointer (arg_type
, sp
);
402 m_arg
->len
= TYPE_LENGTH (arg_type
);
403 m_arg
->offset
= accumulate_size
;
404 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
405 m_arg
->contents
= value_contents (arg
);
408 /* Determine required argument register loads, loading an argument register
409 is expensive as it uses three ptrace calls. */
410 required_arg_regs
= accumulate_size
/ 8;
411 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
412 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
414 /* Make room for the arguments on the stack. */
415 if (accumulate_size
< sizeof(arg_reg_buffer
))
418 accumulate_size
-= sizeof(arg_reg_buffer
);
419 sp
-= accumulate_size
;
421 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
424 /* `Push' arguments on the stack. */
425 for (i
= nargs
; m_arg
--, --i
>= 0;)
427 const gdb_byte
*contents
= m_arg
->contents
;
428 int offset
= m_arg
->offset
;
429 int len
= m_arg
->len
;
431 /* Copy the bytes destined for registers into arg_reg_buffer. */
432 if (offset
< sizeof(arg_reg_buffer
))
434 if (offset
+ len
<= sizeof(arg_reg_buffer
))
436 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
441 int tlen
= sizeof(arg_reg_buffer
) - offset
;
442 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
449 /* Everything else goes to the stack. */
450 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
453 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
,
454 byte_order
, struct_addr
);
456 /* Load the argument registers. */
457 for (i
= 0; i
< required_arg_regs
; i
++)
459 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
460 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
461 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
462 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
465 /* Finally, update the stack pointer. */
466 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
471 /* Extract from REGCACHE the value about to be returned from a function
472 and copy it into VALBUF. */
475 alpha_extract_return_value (struct type
*valtype
, struct regcache
*regcache
,
478 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
479 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
480 int length
= TYPE_LENGTH (valtype
);
481 gdb_byte raw_buffer
[ALPHA_REGISTER_SIZE
];
484 switch (TYPE_CODE (valtype
))
490 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
491 alpha_sts (gdbarch
, valbuf
, raw_buffer
);
495 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
499 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
500 read_memory (l
, valbuf
, 16);
504 internal_error (__FILE__
, __LINE__
,
505 _("unknown floating point width"));
509 case TYPE_CODE_COMPLEX
:
513 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
514 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
518 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
519 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
+ 1, valbuf
+ 8);
523 regcache_cooked_read_signed (regcache
, ALPHA_V0_REGNUM
, &l
);
524 read_memory (l
, valbuf
, 32);
528 internal_error (__FILE__
, __LINE__
,
529 _("unknown floating point width"));
534 /* Assume everything else degenerates to an integer. */
535 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
536 store_unsigned_integer (valbuf
, length
, byte_order
, l
);
541 /* Insert the given value into REGCACHE as if it was being
542 returned by a function. */
545 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
546 const gdb_byte
*valbuf
)
548 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
549 int length
= TYPE_LENGTH (valtype
);
550 gdb_byte raw_buffer
[ALPHA_REGISTER_SIZE
];
553 switch (TYPE_CODE (valtype
))
559 alpha_lds (gdbarch
, raw_buffer
, valbuf
);
560 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
564 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
568 /* FIXME: 128-bit long doubles are returned like structures:
569 by writing into indirect storage provided by the caller
570 as the first argument. */
571 error (_("Cannot set a 128-bit long double return value."));
574 internal_error (__FILE__
, __LINE__
,
575 _("unknown floating point width"));
579 case TYPE_CODE_COMPLEX
:
583 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
584 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
588 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
589 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
+ 1, valbuf
+ 8);
593 /* FIXME: 128-bit long doubles are returned like structures:
594 by writing into indirect storage provided by the caller
595 as the first argument. */
596 error (_("Cannot set a 128-bit long double return value."));
599 internal_error (__FILE__
, __LINE__
,
600 _("unknown floating point width"));
605 /* Assume everything else degenerates to an integer. */
606 /* 32-bit values must be sign-extended to 64 bits
607 even if the base data type is unsigned. */
609 valtype
= builtin_type (gdbarch
)->builtin_int32
;
610 l
= unpack_long (valtype
, valbuf
);
611 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
616 static enum return_value_convention
617 alpha_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
618 struct type
*type
, struct regcache
*regcache
,
619 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
621 enum type_code code
= TYPE_CODE (type
);
623 if ((code
== TYPE_CODE_STRUCT
624 || code
== TYPE_CODE_UNION
625 || code
== TYPE_CODE_ARRAY
)
626 && gdbarch_tdep (gdbarch
)->return_in_memory (type
))
631 regcache_raw_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
632 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
635 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
639 alpha_extract_return_value (type
, regcache
, readbuf
);
641 alpha_store_return_value (type
, regcache
, writebuf
);
643 return RETURN_VALUE_REGISTER_CONVENTION
;
647 alpha_return_in_memory_always (struct type
*type
)
652 static const gdb_byte
*
653 alpha_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
, int *len
)
655 static const gdb_byte break_insn
[] = { 0x80, 0, 0, 0 }; /* call_pal bpt */
657 *len
= sizeof(break_insn
);
662 /* This returns the PC of the first insn after the prologue.
663 If we can't find the prologue, then return 0. */
666 alpha_after_prologue (CORE_ADDR pc
)
668 struct symtab_and_line sal
;
669 CORE_ADDR func_addr
, func_end
;
671 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
674 sal
= find_pc_line (func_addr
, 0);
675 if (sal
.end
< func_end
)
678 /* The line after the prologue is after the end of the function. In this
679 case, tell the caller to find the prologue the hard way. */
683 /* Read an instruction from memory at PC, looking through breakpoints. */
686 alpha_read_insn (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
688 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
689 gdb_byte buf
[ALPHA_INSN_SIZE
];
692 status
= target_read_memory (pc
, buf
, sizeof (buf
));
694 memory_error (status
, pc
);
695 return extract_unsigned_integer (buf
, sizeof (buf
), byte_order
);
698 /* To skip prologues, I use this predicate. Returns either PC itself
699 if the code at PC does not look like a function prologue; otherwise
700 returns an address that (if we're lucky) follows the prologue. If
701 LENIENT, then we must skip everything which is involved in setting
702 up the frame (it's OK to skip more, just so long as we don't skip
703 anything which might clobber the registers which are being saved. */
706 alpha_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
710 CORE_ADDR post_prologue_pc
;
711 gdb_byte buf
[ALPHA_INSN_SIZE
];
713 /* Silently return the unaltered pc upon memory errors.
714 This could happen on OSF/1 if decode_line_1 tries to skip the
715 prologue for quickstarted shared library functions when the
716 shared library is not yet mapped in.
717 Reading target memory is slow over serial lines, so we perform
718 this check only if the target has shared libraries (which all
719 Alpha targets do). */
720 if (target_read_memory (pc
, buf
, sizeof (buf
)))
723 /* See if we can determine the end of the prologue via the symbol table.
724 If so, then return either PC, or the PC after the prologue, whichever
727 post_prologue_pc
= alpha_after_prologue (pc
);
728 if (post_prologue_pc
!= 0)
729 return max (pc
, post_prologue_pc
);
731 /* Can't determine prologue from the symbol table, need to examine
734 /* Skip the typical prologue instructions. These are the stack adjustment
735 instruction and the instructions that save registers on the stack
736 or in the gcc frame. */
737 for (offset
= 0; offset
< 100; offset
+= ALPHA_INSN_SIZE
)
739 inst
= alpha_read_insn (gdbarch
, pc
+ offset
);
741 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
743 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
745 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
747 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
750 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
751 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
752 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
755 if (inst
== 0x47de040f) /* bis sp,sp,fp */
757 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
766 /* Figure out where the longjmp will land.
767 We expect the first arg to be a pointer to the jmp_buf structure from
768 which we extract the PC (JB_PC) that we will land at. The PC is copied
769 into the "pc". This routine returns true on success. */
772 alpha_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
774 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
775 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
776 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
778 gdb_byte raw_buffer
[ALPHA_REGISTER_SIZE
];
780 jb_addr
= get_frame_register_unsigned (frame
, ALPHA_A0_REGNUM
);
782 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
783 raw_buffer
, tdep
->jb_elt_size
))
786 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
, byte_order
);
791 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
792 describe the location and shape of the sigcontext structure. After
793 that, all registers are in memory, so it's easy. */
794 /* ??? Shouldn't we be able to do this generically, rather than with
795 OSABI data specific to Alpha? */
797 struct alpha_sigtramp_unwind_cache
799 CORE_ADDR sigcontext_addr
;
802 static struct alpha_sigtramp_unwind_cache
*
803 alpha_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
804 void **this_prologue_cache
)
806 struct alpha_sigtramp_unwind_cache
*info
;
807 struct gdbarch_tdep
*tdep
;
809 if (*this_prologue_cache
)
810 return *this_prologue_cache
;
812 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
813 *this_prologue_cache
= info
;
815 tdep
= gdbarch_tdep (get_frame_arch (this_frame
));
816 info
->sigcontext_addr
= tdep
->sigcontext_addr (this_frame
);
821 /* Return the address of REGNUM in a sigtramp frame. Since this is
822 all arithmetic, it doesn't seem worthwhile to cache it. */
825 alpha_sigtramp_register_address (struct gdbarch
*gdbarch
,
826 CORE_ADDR sigcontext_addr
, int regnum
)
828 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
830 if (regnum
>= 0 && regnum
< 32)
831 return sigcontext_addr
+ tdep
->sc_regs_offset
+ regnum
* 8;
832 else if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 32)
833 return sigcontext_addr
+ tdep
->sc_fpregs_offset
+ regnum
* 8;
834 else if (regnum
== ALPHA_PC_REGNUM
)
835 return sigcontext_addr
+ tdep
->sc_pc_offset
;
840 /* Given a GDB frame, determine the address of the calling function's
841 frame. This will be used to create a new GDB frame struct. */
844 alpha_sigtramp_frame_this_id (struct frame_info
*this_frame
,
845 void **this_prologue_cache
,
846 struct frame_id
*this_id
)
848 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
849 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
850 struct alpha_sigtramp_unwind_cache
*info
851 = alpha_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
852 CORE_ADDR stack_addr
, code_addr
;
854 /* If the OSABI couldn't locate the sigcontext, give up. */
855 if (info
->sigcontext_addr
== 0)
858 /* If we have dynamic signal trampolines, find their start.
859 If we do not, then we must assume there is a symbol record
860 that can provide the start address. */
861 if (tdep
->dynamic_sigtramp_offset
)
864 code_addr
= get_frame_pc (this_frame
);
865 offset
= tdep
->dynamic_sigtramp_offset (gdbarch
, code_addr
);
872 code_addr
= get_frame_func (this_frame
);
874 /* The stack address is trivially read from the sigcontext. */
875 stack_addr
= alpha_sigtramp_register_address (gdbarch
, info
->sigcontext_addr
,
877 stack_addr
= get_frame_memory_unsigned (this_frame
, stack_addr
,
878 ALPHA_REGISTER_SIZE
);
880 *this_id
= frame_id_build (stack_addr
, code_addr
);
883 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
885 static struct value
*
886 alpha_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
887 void **this_prologue_cache
, int regnum
)
889 struct alpha_sigtramp_unwind_cache
*info
890 = alpha_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
893 if (info
->sigcontext_addr
!= 0)
895 /* All integer and fp registers are stored in memory. */
896 addr
= alpha_sigtramp_register_address (get_frame_arch (this_frame
),
897 info
->sigcontext_addr
, regnum
);
899 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
902 /* This extra register may actually be in the sigcontext, but our
903 current description of it in alpha_sigtramp_frame_unwind_cache
904 doesn't include it. Too bad. Fall back on whatever's in the
906 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
910 alpha_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
911 struct frame_info
*this_frame
,
912 void **this_prologue_cache
)
914 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
915 CORE_ADDR pc
= get_frame_pc (this_frame
);
918 /* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
919 look at tramp-frame.h and other simplier per-architecture
920 sigtramp unwinders. */
922 /* We shouldn't even bother to try if the OSABI didn't register a
923 sigcontext_addr handler or pc_in_sigtramp hander. */
924 if (gdbarch_tdep (gdbarch
)->sigcontext_addr
== NULL
)
926 if (gdbarch_tdep (gdbarch
)->pc_in_sigtramp
== NULL
)
929 /* Otherwise we should be in a signal frame. */
930 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
931 if (gdbarch_tdep (gdbarch
)->pc_in_sigtramp (gdbarch
, pc
, name
))
937 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
939 default_frame_unwind_stop_reason
,
940 alpha_sigtramp_frame_this_id
,
941 alpha_sigtramp_frame_prev_register
,
943 alpha_sigtramp_frame_sniffer
948 /* Heuristic_proc_start may hunt through the text section for a long
949 time across a 2400 baud serial line. Allows the user to limit this
951 static unsigned int heuristic_fence_post
= 0;
953 /* Attempt to locate the start of the function containing PC. We assume that
954 the previous function ends with an about_to_return insn. Not foolproof by
955 any means, since gcc is happy to put the epilogue in the middle of a
956 function. But we're guessing anyway... */
959 alpha_heuristic_proc_start (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
961 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
962 CORE_ADDR last_non_nop
= pc
;
963 CORE_ADDR fence
= pc
- heuristic_fence_post
;
964 CORE_ADDR orig_pc
= pc
;
966 struct inferior
*inf
;
971 /* First see if we can find the start of the function from minimal
972 symbol information. This can succeed with a binary that doesn't
973 have debug info, but hasn't been stripped. */
974 func
= get_pc_function_start (pc
);
978 if (heuristic_fence_post
== UINT_MAX
979 || fence
< tdep
->vm_min_address
)
980 fence
= tdep
->vm_min_address
;
982 /* Search back for previous return; also stop at a 0, which might be
983 seen for instance before the start of a code section. Don't include
984 nops, since this usually indicates padding between functions. */
985 for (pc
-= ALPHA_INSN_SIZE
; pc
>= fence
; pc
-= ALPHA_INSN_SIZE
)
987 unsigned int insn
= alpha_read_insn (gdbarch
, pc
);
990 case 0: /* invalid insn */
991 case 0x6bfa8001: /* ret $31,($26),1 */
994 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
995 case 0x47ff041f: /* nop: bis $31,$31,$31 */
1004 inf
= current_inferior ();
1006 /* It's not clear to me why we reach this point when stopping quietly,
1007 but with this test, at least we don't print out warnings for every
1008 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
1009 if (inf
->control
.stop_soon
== NO_STOP_QUIETLY
)
1011 static int blurb_printed
= 0;
1013 if (fence
== tdep
->vm_min_address
)
1014 warning (_("Hit beginning of text section without finding \
1015 enclosing function for address %s"), paddress (gdbarch
, orig_pc
));
1017 warning (_("Hit heuristic-fence-post without finding \
1018 enclosing function for address %s"), paddress (gdbarch
, orig_pc
));
1022 printf_filtered (_("\
1023 This warning occurs if you are debugging a function without any symbols\n\
1024 (for example, in a stripped executable). In that case, you may wish to\n\
1025 increase the size of the search with the `set heuristic-fence-post' command.\n\
1027 Otherwise, you told GDB there was a function where there isn't one, or\n\
1028 (more likely) you have encountered a bug in GDB.\n"));
1036 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
1037 something about the traditional layout of alpha stack frames. */
1039 struct alpha_heuristic_unwind_cache
1043 struct trad_frame_saved_reg
*saved_regs
;
1047 /* If a probing loop sequence starts at PC, simulate it and compute
1048 FRAME_SIZE and PC after its execution. Otherwise, return with PC and
1049 FRAME_SIZE unchanged. */
1052 alpha_heuristic_analyze_probing_loop (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
,
1055 CORE_ADDR cur_pc
= *pc
;
1056 int cur_frame_size
= *frame_size
;
1057 int nb_of_iterations
, reg_index
, reg_probe
;
1060 /* The following pattern is recognized as a probing loop:
1062 lda REG_INDEX,NB_OF_ITERATIONS
1063 lda REG_PROBE,<immediate>(sp)
1066 stq zero,<immediate>(REG_PROBE)
1067 subq REG_INDEX,0x1,REG_INDEX
1068 lda REG_PROBE,<immediate>(REG_PROBE)
1069 bne REG_INDEX, LOOP_START
1071 lda sp,<immediate>(REG_PROBE)
1073 If anything different is found, the function returns without
1074 changing PC and FRAME_SIZE. Otherwise, PC will point immediately
1075 after this sequence, and FRAME_SIZE will be updated. */
1077 /* lda REG_INDEX,NB_OF_ITERATIONS */
1079 insn
= alpha_read_insn (gdbarch
, cur_pc
);
1080 if (INSN_OPCODE (insn
) != lda_opcode
)
1082 reg_index
= MEM_RA (insn
);
1083 nb_of_iterations
= MEM_DISP (insn
);
1085 /* lda REG_PROBE,<immediate>(sp) */
1087 cur_pc
+= ALPHA_INSN_SIZE
;
1088 insn
= alpha_read_insn (gdbarch
, cur_pc
);
1089 if (INSN_OPCODE (insn
) != lda_opcode
1090 || MEM_RB (insn
) != ALPHA_SP_REGNUM
)
1092 reg_probe
= MEM_RA (insn
);
1093 cur_frame_size
-= MEM_DISP (insn
);
1095 /* stq zero,<immediate>(REG_PROBE) */
1097 cur_pc
+= ALPHA_INSN_SIZE
;
1098 insn
= alpha_read_insn (gdbarch
, cur_pc
);
1099 if (INSN_OPCODE (insn
) != stq_opcode
1100 || MEM_RA (insn
) != 0x1f
1101 || MEM_RB (insn
) != reg_probe
)
1104 /* subq REG_INDEX,0x1,REG_INDEX */
1106 cur_pc
+= ALPHA_INSN_SIZE
;
1107 insn
= alpha_read_insn (gdbarch
, cur_pc
);
1108 if (INSN_OPCODE (insn
) != subq_opcode
1109 || !OPR_HAS_IMMEDIATE (insn
)
1110 || OPR_FUNCTION (insn
) != subq_function
1111 || OPR_LIT(insn
) != 1
1112 || OPR_RA (insn
) != reg_index
1113 || OPR_RC (insn
) != reg_index
)
1116 /* lda REG_PROBE,<immediate>(REG_PROBE) */
1118 cur_pc
+= ALPHA_INSN_SIZE
;
1119 insn
= alpha_read_insn (gdbarch
, cur_pc
);
1120 if (INSN_OPCODE (insn
) != lda_opcode
1121 || MEM_RA (insn
) != reg_probe
1122 || MEM_RB (insn
) != reg_probe
)
1124 cur_frame_size
-= MEM_DISP (insn
) * nb_of_iterations
;
1126 /* bne REG_INDEX, LOOP_START */
1128 cur_pc
+= ALPHA_INSN_SIZE
;
1129 insn
= alpha_read_insn (gdbarch
, cur_pc
);
1130 if (INSN_OPCODE (insn
) != bne_opcode
1131 || MEM_RA (insn
) != reg_index
)
1134 /* lda sp,<immediate>(REG_PROBE) */
1136 cur_pc
+= ALPHA_INSN_SIZE
;
1137 insn
= alpha_read_insn (gdbarch
, cur_pc
);
1138 if (INSN_OPCODE (insn
) != lda_opcode
1139 || MEM_RA (insn
) != ALPHA_SP_REGNUM
1140 || MEM_RB (insn
) != reg_probe
)
1142 cur_frame_size
-= MEM_DISP (insn
);
1145 *frame_size
= cur_frame_size
;
1148 static struct alpha_heuristic_unwind_cache
*
1149 alpha_heuristic_frame_unwind_cache (struct frame_info
*this_frame
,
1150 void **this_prologue_cache
,
1153 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1154 struct alpha_heuristic_unwind_cache
*info
;
1156 CORE_ADDR limit_pc
, cur_pc
;
1157 int frame_reg
, frame_size
, return_reg
, reg
;
1159 if (*this_prologue_cache
)
1160 return *this_prologue_cache
;
1162 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
1163 *this_prologue_cache
= info
;
1164 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1166 limit_pc
= get_frame_pc (this_frame
);
1168 start_pc
= alpha_heuristic_proc_start (gdbarch
, limit_pc
);
1169 info
->start_pc
= start_pc
;
1171 frame_reg
= ALPHA_SP_REGNUM
;
1175 /* If we've identified a likely place to start, do code scanning. */
1178 /* Limit the forward search to 50 instructions. */
1179 if (start_pc
+ 200 < limit_pc
)
1180 limit_pc
= start_pc
+ 200;
1182 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= ALPHA_INSN_SIZE
)
1184 unsigned int word
= alpha_read_insn (gdbarch
, cur_pc
);
1186 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1190 /* Consider only the first stack allocation instruction
1191 to contain the static size of the frame. */
1192 if (frame_size
== 0)
1193 frame_size
= (-word
) & 0xffff;
1197 /* Exit loop if a positive stack adjustment is found, which
1198 usually means that the stack cleanup code in the function
1199 epilogue is reached. */
1203 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1205 reg
= (word
& 0x03e00000) >> 21;
1207 /* Ignore this instruction if we have already encountered
1208 an instruction saving the same register earlier in the
1209 function code. The current instruction does not tell
1210 us where the original value upon function entry is saved.
1211 All it says is that the function we are scanning reused
1212 that register for some computation of its own, and is now
1213 saving its result. */
1214 if (trad_frame_addr_p(info
->saved_regs
, reg
))
1220 /* Do not compute the address where the register was saved yet,
1221 because we don't know yet if the offset will need to be
1222 relative to $sp or $fp (we can not compute the address
1223 relative to $sp if $sp is updated during the execution of
1224 the current subroutine, for instance when doing some alloca).
1225 So just store the offset for the moment, and compute the
1226 address later when we know whether this frame has a frame
1228 /* Hack: temporarily add one, so that the offset is non-zero
1229 and we can tell which registers have save offsets below. */
1230 info
->saved_regs
[reg
].addr
= (word
& 0xffff) + 1;
1232 /* Starting with OSF/1-3.2C, the system libraries are shipped
1233 without local symbols, but they still contain procedure
1234 descriptors without a symbol reference. GDB is currently
1235 unable to find these procedure descriptors and uses
1236 heuristic_proc_desc instead.
1237 As some low level compiler support routines (__div*, __add*)
1238 use a non-standard return address register, we have to
1239 add some heuristics to determine the return address register,
1240 or stepping over these routines will fail.
1241 Usually the return address register is the first register
1242 saved on the stack, but assembler optimization might
1243 rearrange the register saves.
1244 So we recognize only a few registers (t7, t9, ra) within
1245 the procedure prologue as valid return address registers.
1246 If we encounter a return instruction, we extract the
1247 return address register from it.
1249 FIXME: Rewriting GDB to access the procedure descriptors,
1250 e.g. via the minimal symbol table, might obviate this
1252 if (return_reg
== -1
1253 && cur_pc
< (start_pc
+ 80)
1254 && (reg
== ALPHA_T7_REGNUM
1255 || reg
== ALPHA_T9_REGNUM
1256 || reg
== ALPHA_RA_REGNUM
))
1259 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1260 return_reg
= (word
>> 16) & 0x1f;
1261 else if (word
== 0x47de040f) /* bis sp,sp,fp */
1262 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1263 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
1264 frame_reg
= ALPHA_GCC_FP_REGNUM
;
1266 alpha_heuristic_analyze_probing_loop (gdbarch
, &cur_pc
, &frame_size
);
1269 /* If we haven't found a valid return address register yet, keep
1270 searching in the procedure prologue. */
1271 if (return_reg
== -1)
1273 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
1275 unsigned int word
= alpha_read_insn (gdbarch
, cur_pc
);
1277 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1279 reg
= (word
& 0x03e00000) >> 21;
1280 if (reg
== ALPHA_T7_REGNUM
1281 || reg
== ALPHA_T9_REGNUM
1282 || reg
== ALPHA_RA_REGNUM
)
1288 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1290 return_reg
= (word
>> 16) & 0x1f;
1294 cur_pc
+= ALPHA_INSN_SIZE
;
1299 /* Failing that, do default to the customary RA. */
1300 if (return_reg
== -1)
1301 return_reg
= ALPHA_RA_REGNUM
;
1302 info
->return_reg
= return_reg
;
1304 val
= get_frame_register_unsigned (this_frame
, frame_reg
);
1305 info
->vfp
= val
+ frame_size
;
1307 /* Convert offsets to absolute addresses. See above about adding
1308 one to the offsets to make all detected offsets non-zero. */
1309 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1310 if (trad_frame_addr_p(info
->saved_regs
, reg
))
1311 info
->saved_regs
[reg
].addr
+= val
- 1;
1313 /* The stack pointer of the previous frame is computed by popping
1314 the current stack frame. */
1315 if (!trad_frame_addr_p (info
->saved_regs
, ALPHA_SP_REGNUM
))
1316 trad_frame_set_value (info
->saved_regs
, ALPHA_SP_REGNUM
, info
->vfp
);
1321 /* Given a GDB frame, determine the address of the calling function's
1322 frame. This will be used to create a new GDB frame struct. */
1325 alpha_heuristic_frame_this_id (struct frame_info
*this_frame
,
1326 void **this_prologue_cache
,
1327 struct frame_id
*this_id
)
1329 struct alpha_heuristic_unwind_cache
*info
1330 = alpha_heuristic_frame_unwind_cache (this_frame
, this_prologue_cache
, 0);
1332 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1335 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1337 static struct value
*
1338 alpha_heuristic_frame_prev_register (struct frame_info
*this_frame
,
1339 void **this_prologue_cache
, int regnum
)
1341 struct alpha_heuristic_unwind_cache
*info
1342 = alpha_heuristic_frame_unwind_cache (this_frame
, this_prologue_cache
, 0);
1344 /* The PC of the previous frame is stored in the link register of
1345 the current frame. Frob regnum so that we pull the value from
1346 the correct place. */
1347 if (regnum
== ALPHA_PC_REGNUM
)
1348 regnum
= info
->return_reg
;
1350 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1353 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1355 default_frame_unwind_stop_reason
,
1356 alpha_heuristic_frame_this_id
,
1357 alpha_heuristic_frame_prev_register
,
1359 default_frame_sniffer
1363 alpha_heuristic_frame_base_address (struct frame_info
*this_frame
,
1364 void **this_prologue_cache
)
1366 struct alpha_heuristic_unwind_cache
*info
1367 = alpha_heuristic_frame_unwind_cache (this_frame
, this_prologue_cache
, 0);
1372 static const struct frame_base alpha_heuristic_frame_base
= {
1373 &alpha_heuristic_frame_unwind
,
1374 alpha_heuristic_frame_base_address
,
1375 alpha_heuristic_frame_base_address
,
1376 alpha_heuristic_frame_base_address
1379 /* Just like reinit_frame_cache, but with the right arguments to be
1380 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1383 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1385 reinit_frame_cache ();
1389 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1390 dummy frame. The frame ID's base needs to match the TOS value
1391 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1394 static struct frame_id
1395 alpha_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1398 base
= get_frame_register_unsigned (this_frame
, ALPHA_SP_REGNUM
);
1399 return frame_id_build (base
, get_frame_pc (this_frame
));
1403 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1406 pc
= frame_unwind_register_unsigned (next_frame
, ALPHA_PC_REGNUM
);
1411 /* Helper routines for alpha*-nat.c files to move register sets to and
1412 from core files. The UNIQUE pointer is allowed to be NULL, as most
1413 targets don't supply this value in their core files. */
1416 alpha_supply_int_regs (struct regcache
*regcache
, int regno
,
1417 const void *r0_r30
, const void *pc
, const void *unique
)
1419 const gdb_byte
*regs
= r0_r30
;
1422 for (i
= 0; i
< 31; ++i
)
1423 if (regno
== i
|| regno
== -1)
1424 regcache_raw_supply (regcache
, i
, regs
+ i
* 8);
1426 if (regno
== ALPHA_ZERO_REGNUM
|| regno
== -1)
1427 regcache_raw_supply (regcache
, ALPHA_ZERO_REGNUM
, NULL
);
1429 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1430 regcache_raw_supply (regcache
, ALPHA_PC_REGNUM
, pc
);
1432 if (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1)
1433 regcache_raw_supply (regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1437 alpha_fill_int_regs (const struct regcache
*regcache
,
1438 int regno
, void *r0_r30
, void *pc
, void *unique
)
1440 gdb_byte
*regs
= r0_r30
;
1443 for (i
= 0; i
< 31; ++i
)
1444 if (regno
== i
|| regno
== -1)
1445 regcache_raw_collect (regcache
, i
, regs
+ i
* 8);
1447 if (regno
== ALPHA_PC_REGNUM
|| regno
== -1)
1448 regcache_raw_collect (regcache
, ALPHA_PC_REGNUM
, pc
);
1450 if (unique
&& (regno
== ALPHA_UNIQUE_REGNUM
|| regno
== -1))
1451 regcache_raw_collect (regcache
, ALPHA_UNIQUE_REGNUM
, unique
);
1455 alpha_supply_fp_regs (struct regcache
*regcache
, int regno
,
1456 const void *f0_f30
, const void *fpcr
)
1458 const gdb_byte
*regs
= f0_f30
;
1461 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1462 if (regno
== i
|| regno
== -1)
1463 regcache_raw_supply (regcache
, i
,
1464 regs
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1466 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1467 regcache_raw_supply (regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1471 alpha_fill_fp_regs (const struct regcache
*regcache
,
1472 int regno
, void *f0_f30
, void *fpcr
)
1474 gdb_byte
*regs
= f0_f30
;
1477 for (i
= ALPHA_FP0_REGNUM
; i
< ALPHA_FP0_REGNUM
+ 31; ++i
)
1478 if (regno
== i
|| regno
== -1)
1479 regcache_raw_collect (regcache
, i
,
1480 regs
+ (i
- ALPHA_FP0_REGNUM
) * 8);
1482 if (regno
== ALPHA_FPCR_REGNUM
|| regno
== -1)
1483 regcache_raw_collect (regcache
, ALPHA_FPCR_REGNUM
, fpcr
);
1488 /* Return nonzero if the G_floating register value in REG is equal to
1489 zero for FP control instructions. */
1492 fp_register_zero_p (LONGEST reg
)
1494 /* Check that all bits except the sign bit are zero. */
1495 const LONGEST zero_mask
= ((LONGEST
) 1 << 63) ^ -1;
1497 return ((reg
& zero_mask
) == 0);
1500 /* Return the value of the sign bit for the G_floating register
1501 value held in REG. */
1504 fp_register_sign_bit (LONGEST reg
)
1506 const LONGEST sign_mask
= (LONGEST
) 1 << 63;
1508 return ((reg
& sign_mask
) != 0);
1511 /* alpha_software_single_step() is called just before we want to resume
1512 the inferior, if we want to single-step it but there is no hardware
1513 or kernel single-step support (NetBSD on Alpha, for example). We find
1514 the target of the coming instruction and breakpoint it. */
1517 alpha_next_pc (struct frame_info
*frame
, CORE_ADDR pc
)
1519 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1526 insn
= alpha_read_insn (gdbarch
, pc
);
1528 /* Opcode is top 6 bits. */
1529 op
= (insn
>> 26) & 0x3f;
1533 /* Jump format: target PC is:
1535 return (get_frame_register_unsigned (frame
, (insn
>> 16) & 0x1f) & ~3);
1538 if ((op
& 0x30) == 0x30)
1540 /* Branch format: target PC is:
1541 (new PC) + (4 * sext(displacement)) */
1542 if (op
== 0x30 /* BR */
1543 || op
== 0x34) /* BSR */
1546 offset
= (insn
& 0x001fffff);
1547 if (offset
& 0x00100000)
1548 offset
|= 0xffe00000;
1549 offset
*= ALPHA_INSN_SIZE
;
1550 return (pc
+ ALPHA_INSN_SIZE
+ offset
);
1553 /* Need to determine if branch is taken; read RA. */
1554 regno
= (insn
>> 21) & 0x1f;
1557 case 0x31: /* FBEQ */
1558 case 0x36: /* FBGE */
1559 case 0x37: /* FBGT */
1560 case 0x33: /* FBLE */
1561 case 0x32: /* FBLT */
1562 case 0x35: /* FBNE */
1563 regno
+= gdbarch_fp0_regnum (gdbarch
);
1566 rav
= get_frame_register_signed (frame
, regno
);
1570 case 0x38: /* BLBC */
1574 case 0x3c: /* BLBS */
1578 case 0x39: /* BEQ */
1582 case 0x3d: /* BNE */
1586 case 0x3a: /* BLT */
1590 case 0x3b: /* BLE */
1594 case 0x3f: /* BGT */
1598 case 0x3e: /* BGE */
1603 /* Floating point branches. */
1605 case 0x31: /* FBEQ */
1606 if (fp_register_zero_p (rav
))
1609 case 0x36: /* FBGE */
1610 if (fp_register_sign_bit (rav
) == 0 || fp_register_zero_p (rav
))
1613 case 0x37: /* FBGT */
1614 if (fp_register_sign_bit (rav
) == 0 && ! fp_register_zero_p (rav
))
1617 case 0x33: /* FBLE */
1618 if (fp_register_sign_bit (rav
) == 1 || fp_register_zero_p (rav
))
1621 case 0x32: /* FBLT */
1622 if (fp_register_sign_bit (rav
) == 1 && ! fp_register_zero_p (rav
))
1625 case 0x35: /* FBNE */
1626 if (! fp_register_zero_p (rav
))
1632 /* Not a branch or branch not taken; target PC is:
1634 return (pc
+ ALPHA_INSN_SIZE
);
1638 alpha_software_single_step (struct frame_info
*frame
)
1640 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1641 struct address_space
*aspace
= get_frame_address_space (frame
);
1642 CORE_ADDR pc
, next_pc
;
1644 pc
= get_frame_pc (frame
);
1645 next_pc
= alpha_next_pc (frame
, pc
);
1647 insert_single_step_breakpoint (gdbarch
, aspace
, next_pc
);
1652 /* Initialize the current architecture based on INFO. If possible, re-use an
1653 architecture from ARCHES, which is a list of architectures already created
1654 during this debugging session.
1656 Called e.g. at program startup, when reading a core file, and when reading
1659 static struct gdbarch
*
1660 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1662 struct gdbarch_tdep
*tdep
;
1663 struct gdbarch
*gdbarch
;
1665 /* Try to determine the ABI of the object we are loading. */
1666 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1668 /* If it's an ECOFF file, assume it's OSF/1. */
1669 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1670 info
.osabi
= GDB_OSABI_OSF1
;
1673 /* Find a candidate among extant architectures. */
1674 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1676 return arches
->gdbarch
;
1678 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1679 gdbarch
= gdbarch_alloc (&info
, tdep
);
1681 /* Lowest text address. This is used by heuristic_proc_start()
1682 to decide when to stop looking. */
1683 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000LL
;
1685 tdep
->dynamic_sigtramp_offset
= NULL
;
1686 tdep
->sigcontext_addr
= NULL
;
1687 tdep
->sc_pc_offset
= 2 * 8;
1688 tdep
->sc_regs_offset
= 4 * 8;
1689 tdep
->sc_fpregs_offset
= tdep
->sc_regs_offset
+ 32 * 8 + 8;
1691 tdep
->jb_pc
= -1; /* longjmp support not enabled by default. */
1693 tdep
->return_in_memory
= alpha_return_in_memory_always
;
1696 set_gdbarch_short_bit (gdbarch
, 16);
1697 set_gdbarch_int_bit (gdbarch
, 32);
1698 set_gdbarch_long_bit (gdbarch
, 64);
1699 set_gdbarch_long_long_bit (gdbarch
, 64);
1700 set_gdbarch_float_bit (gdbarch
, 32);
1701 set_gdbarch_double_bit (gdbarch
, 64);
1702 set_gdbarch_long_double_bit (gdbarch
, 64);
1703 set_gdbarch_ptr_bit (gdbarch
, 64);
1706 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1707 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1708 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1709 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1711 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1712 set_gdbarch_register_type (gdbarch
, alpha_register_type
);
1714 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1715 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1717 set_gdbarch_convert_register_p (gdbarch
, alpha_convert_register_p
);
1718 set_gdbarch_register_to_value (gdbarch
, alpha_register_to_value
);
1719 set_gdbarch_value_to_register (gdbarch
, alpha_value_to_register
);
1721 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1723 /* Prologue heuristics. */
1724 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1727 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1731 set_gdbarch_return_value (gdbarch
, alpha_return_value
);
1733 /* Settings for calling functions in the inferior. */
1734 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1736 /* Methods for saving / extracting a dummy frame's ID. */
1737 set_gdbarch_dummy_id (gdbarch
, alpha_dummy_id
);
1739 /* Return the unwound PC value. */
1740 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1742 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1743 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1745 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1746 set_gdbarch_decr_pc_after_break (gdbarch
, ALPHA_INSN_SIZE
);
1747 set_gdbarch_cannot_step_breakpoint (gdbarch
, 1);
1749 /* Hook in ABI-specific overrides, if they have been registered. */
1750 gdbarch_init_osabi (info
, gdbarch
);
1752 /* Now that we have tuned the configuration, set a few final things
1753 based on what the OS ABI has told us. */
1755 if (tdep
->jb_pc
>= 0)
1756 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1758 frame_unwind_append_unwinder (gdbarch
, &alpha_sigtramp_frame_unwind
);
1759 frame_unwind_append_unwinder (gdbarch
, &alpha_heuristic_frame_unwind
);
1761 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1767 alpha_dwarf2_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1769 dwarf2_append_unwinders (gdbarch
);
1770 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
1773 extern initialize_file_ftype _initialize_alpha_tdep
; /* -Wmissing-prototypes */
1776 _initialize_alpha_tdep (void)
1778 struct cmd_list_element
*c
;
1780 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1782 /* Let the user set the fence post for heuristic_proc_start. */
1784 /* We really would like to have both "0" and "unlimited" work, but
1785 command.c doesn't deal with that. So make it a var_zinteger
1786 because the user can always use "999999" or some such for unlimited. */
1787 /* We need to throw away the frame cache when we set this, since it
1788 might change our ability to get backtraces. */
1789 add_setshow_zinteger_cmd ("heuristic-fence-post", class_support
,
1790 &heuristic_fence_post
, _("\
1791 Set the distance searched for the start of a function."), _("\
1792 Show the distance searched for the start of a function."), _("\
1793 If you are debugging a stripped executable, GDB needs to search through the\n\
1794 program for the start of a function. This command sets the distance of the\n\
1795 search. The only need to set it is when debugging a stripped executable."),
1796 reinit_frame_cache_sfunc
,
1797 NULL
, /* FIXME: i18n: The distance searched for
1798 the start of a function is \"%d\". */
1799 &setlist
, &showlist
);