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 (struct gdbarch *gdbarch, 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 (struct gdbarch *gdbarch, int regno)
82 return (regno == ALPHA_ZERO_REGNUM
83 || strlen (alpha_register_name (gdbarch, regno)) == 0);
87 alpha_cannot_store_register (struct gdbarch *gdbarch, int regno)
89 return (regno == ALPHA_ZERO_REGNUM
90 || strlen (alpha_register_name (gdbarch, 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 (struct gdbarch *gdbarch, int regno, struct type *type)
203 return (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31
204 && TYPE_LENGTH (type) != 8);
208 alpha_register_to_value (struct frame_info *frame, int regnum,
209 struct type *valtype, gdb_byte *out)
211 gdb_byte in[MAX_REGISTER_SIZE];
213 frame_register_read (frame, regnum, in);
214 switch (TYPE_LENGTH (valtype))
220 error (_("Cannot retrieve value from floating point register"));
225 alpha_value_to_register (struct frame_info *frame, int regnum,
226 struct type *valtype, const gdb_byte *in)
228 gdb_byte out[MAX_REGISTER_SIZE];
230 switch (TYPE_LENGTH (valtype))
236 error (_("Cannot store value in floating point register"));
238 put_frame_register (frame, regnum, out);
242 /* The alpha passes the first six arguments in the registers, the rest on
243 the stack. The register arguments are stored in ARG_REG_BUFFER, and
244 then moved into the register file; this simplifies the passing of a
245 large struct which extends from the registers to the stack, plus avoids
246 three ptrace invocations per word.
248 We don't bother tracking which register values should go in integer
249 regs or fp regs; we load the same values into both.
251 If the called function is returning a structure, the address of the
252 structure to be returned is passed as a hidden first argument. */
255 alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
256 struct regcache *regcache, CORE_ADDR bp_addr,
257 int nargs, struct value **args, CORE_ADDR sp,
258 int struct_return, CORE_ADDR struct_addr)
261 int accumulate_size = struct_return ? 8 : 0;
268 struct alpha_arg *alpha_args
269 = (struct alpha_arg *) alloca (nargs * sizeof (struct alpha_arg));
270 struct alpha_arg *m_arg;
271 gdb_byte arg_reg_buffer[ALPHA_REGISTER_SIZE * ALPHA_NUM_ARG_REGS];
272 int required_arg_regs;
273 CORE_ADDR func_addr = find_function_addr (function, NULL);
275 /* The ABI places the address of the called function in T12. */
276 regcache_cooked_write_signed (regcache, ALPHA_T12_REGNUM, func_addr);
278 /* Set the return address register to point to the entry point
279 of the program, where a breakpoint lies in wait. */
280 regcache_cooked_write_signed (regcache, ALPHA_RA_REGNUM, bp_addr);
282 /* Lay out the arguments in memory. */
283 for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
285 struct value *arg = args[i];
286 struct type *arg_type = check_typedef (value_type (arg));
288 /* Cast argument to long if necessary as the compiler does it too. */
289 switch (TYPE_CODE (arg_type))
294 case TYPE_CODE_RANGE:
296 if (TYPE_LENGTH (arg_type) == 4)
298 /* 32-bit values must be sign-extended to 64 bits
299 even if the base data type is unsigned. */
300 arg_type = builtin_type_int32;
301 arg = value_cast (arg_type, arg);
303 if (TYPE_LENGTH (arg_type) < ALPHA_REGISTER_SIZE)
305 arg_type = builtin_type_int64;
306 arg = value_cast (arg_type, arg);
311 /* "float" arguments loaded in registers must be passed in
312 register format, aka "double". */
313 if (accumulate_size < sizeof (arg_reg_buffer)
314 && TYPE_LENGTH (arg_type) == 4)
316 arg_type = builtin_type_ieee_double;
317 arg = value_cast (arg_type, arg);
319 /* Tru64 5.1 has a 128-bit long double, and passes this by
320 invisible reference. No one else uses this data type. */
321 else if (TYPE_LENGTH (arg_type) == 16)
323 /* Allocate aligned storage. */
324 sp = (sp & -16) - 16;
326 /* Write the real data into the stack. */
327 write_memory (sp, value_contents (arg), 16);
329 /* Construct the indirection. */
330 arg_type = lookup_pointer_type (arg_type);
331 arg = value_from_pointer (arg_type, sp);
335 case TYPE_CODE_COMPLEX:
336 /* ??? The ABI says that complex values are passed as two
337 separate scalar values. This distinction only matters
338 for complex float. However, GCC does not implement this. */
340 /* Tru64 5.1 has a 128-bit long double, and passes this by
341 invisible reference. */
342 if (TYPE_LENGTH (arg_type) == 32)
344 /* Allocate aligned storage. */
345 sp = (sp & -16) - 16;
347 /* Write the real data into the stack. */
348 write_memory (sp, value_contents (arg), 32);
350 /* Construct the indirection. */
351 arg_type = lookup_pointer_type (arg_type);
352 arg = value_from_pointer (arg_type, sp);
359 m_arg->len = TYPE_LENGTH (arg_type);
360 m_arg->offset = accumulate_size;
361 accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
362 m_arg->contents = value_contents_writeable (arg);
365 /* Determine required argument register loads, loading an argument register
366 is expensive as it uses three ptrace calls. */
367 required_arg_regs = accumulate_size / 8;
368 if (required_arg_regs > ALPHA_NUM_ARG_REGS)
369 required_arg_regs = ALPHA_NUM_ARG_REGS;
371 /* Make room for the arguments on the stack. */
372 if (accumulate_size < sizeof(arg_reg_buffer))
375 accumulate_size -= sizeof(arg_reg_buffer);
376 sp -= accumulate_size;
378 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
381 /* `Push' arguments on the stack. */
382 for (i = nargs; m_arg--, --i >= 0;)
384 gdb_byte *contents = m_arg->contents;
385 int offset = m_arg->offset;
386 int len = m_arg->len;
388 /* Copy the bytes destined for registers into arg_reg_buffer. */
389 if (offset < sizeof(arg_reg_buffer))
391 if (offset + len <= sizeof(arg_reg_buffer))
393 memcpy (arg_reg_buffer + offset, contents, len);
398 int tlen = sizeof(arg_reg_buffer) - offset;
399 memcpy (arg_reg_buffer + offset, contents, tlen);
406 /* Everything else goes to the stack. */
407 write_memory (sp + offset - sizeof(arg_reg_buffer), contents, len);
410 store_unsigned_integer (arg_reg_buffer, ALPHA_REGISTER_SIZE, struct_addr);
412 /* Load the argument registers. */
413 for (i = 0; i < required_arg_regs; i++)
415 regcache_cooked_write (regcache, ALPHA_A0_REGNUM + i,
416 arg_reg_buffer + i*ALPHA_REGISTER_SIZE);
417 regcache_cooked_write (regcache, ALPHA_FPA0_REGNUM + i,
418 arg_reg_buffer + i*ALPHA_REGISTER_SIZE);
421 /* Finally, update the stack pointer. */
422 regcache_cooked_write_signed (regcache, ALPHA_SP_REGNUM, sp);
427 /* Extract from REGCACHE the value about to be returned from a function
428 and copy it into VALBUF. */
431 alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
434 int length = TYPE_LENGTH (valtype);
435 gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
438 switch (TYPE_CODE (valtype))
444 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, raw_buffer);
445 alpha_sts (valbuf, raw_buffer);
449 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
453 regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l);
454 read_memory (l, valbuf, 16);
458 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
462 case TYPE_CODE_COMPLEX:
466 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
467 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
471 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
472 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8);
476 regcache_cooked_read_signed (regcache, ALPHA_V0_REGNUM, &l);
477 read_memory (l, valbuf, 32);
481 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
486 /* Assume everything else degenerates to an integer. */
487 regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l);
488 store_unsigned_integer (valbuf, length, l);
493 /* Insert the given value into REGCACHE as if it was being
494 returned by a function. */
497 alpha_store_return_value (struct type *valtype, struct regcache *regcache,
498 const gdb_byte *valbuf)
500 int length = TYPE_LENGTH (valtype);
501 gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
504 switch (TYPE_CODE (valtype))
510 alpha_lds (raw_buffer, valbuf);
511 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, raw_buffer);
515 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
519 /* FIXME: 128-bit long doubles are returned like structures:
520 by writing into indirect storage provided by the caller
521 as the first argument. */
522 error (_("Cannot set a 128-bit long double return value."));
525 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
529 case TYPE_CODE_COMPLEX:
533 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
534 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
538 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
539 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8);
543 /* FIXME: 128-bit long doubles are returned like structures:
544 by writing into indirect storage provided by the caller
545 as the first argument. */
546 error (_("Cannot set a 128-bit long double return value."));
549 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
554 /* Assume everything else degenerates to an integer. */
555 /* 32-bit values must be sign-extended to 64 bits
556 even if the base data type is unsigned. */
558 valtype = builtin_type_int32;
559 l = unpack_long (valtype, valbuf);
560 regcache_cooked_write_unsigned (regcache, ALPHA_V0_REGNUM, l);
565 static enum return_value_convention
566 alpha_return_value (struct gdbarch *gdbarch, struct type *type,
567 struct regcache *regcache, gdb_byte *readbuf,
568 const gdb_byte *writebuf)
570 enum type_code code = TYPE_CODE (type);
572 if ((code == TYPE_CODE_STRUCT
573 || code == TYPE_CODE_UNION
574 || code == TYPE_CODE_ARRAY)
575 && gdbarch_tdep (gdbarch)->return_in_memory (type))
580 regcache_raw_read_unsigned (regcache, ALPHA_V0_REGNUM, &addr);
581 read_memory (addr, readbuf, TYPE_LENGTH (type));
584 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
588 alpha_extract_return_value (type, regcache, readbuf);
590 alpha_store_return_value (type, regcache, writebuf);
592 return RETURN_VALUE_REGISTER_CONVENTION;
596 alpha_return_in_memory_always (struct type *type)
601 static const gdb_byte *
602 alpha_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
604 static const gdb_byte break_insn[] = { 0x80, 0, 0, 0 }; /* call_pal bpt */
606 *len = sizeof(break_insn);
611 /* This returns the PC of the first insn after the prologue.
612 If we can't find the prologue, then return 0. */
615 alpha_after_prologue (CORE_ADDR pc)
617 struct symtab_and_line sal;
618 CORE_ADDR func_addr, func_end;
620 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
623 sal = find_pc_line (func_addr, 0);
624 if (sal.end < func_end)
627 /* The line after the prologue is after the end of the function. In this
628 case, tell the caller to find the prologue the hard way. */
632 /* Read an instruction from memory at PC, looking through breakpoints. */
635 alpha_read_insn (CORE_ADDR pc)
637 gdb_byte buf[ALPHA_INSN_SIZE];
640 status = read_memory_nobpt (pc, buf, sizeof (buf));
642 memory_error (status, pc);
643 return extract_unsigned_integer (buf, sizeof (buf));
646 /* To skip prologues, I use this predicate. Returns either PC itself
647 if the code at PC does not look like a function prologue; otherwise
648 returns an address that (if we're lucky) follows the prologue. If
649 LENIENT, then we must skip everything which is involved in setting
650 up the frame (it's OK to skip more, just so long as we don't skip
651 anything which might clobber the registers which are being saved. */
654 alpha_skip_prologue (CORE_ADDR pc)
658 CORE_ADDR post_prologue_pc;
659 gdb_byte buf[ALPHA_INSN_SIZE];
661 /* Silently return the unaltered pc upon memory errors.
662 This could happen on OSF/1 if decode_line_1 tries to skip the
663 prologue for quickstarted shared library functions when the
664 shared library is not yet mapped in.
665 Reading target memory is slow over serial lines, so we perform
666 this check only if the target has shared libraries (which all
667 Alpha targets do). */
668 if (target_read_memory (pc, buf, sizeof (buf)))
671 /* See if we can determine the end of the prologue via the symbol table.
672 If so, then return either PC, or the PC after the prologue, whichever
675 post_prologue_pc = alpha_after_prologue (pc);
676 if (post_prologue_pc != 0)
677 return max (pc, post_prologue_pc);
679 /* Can't determine prologue from the symbol table, need to examine
682 /* Skip the typical prologue instructions. These are the stack adjustment
683 instruction and the instructions that save registers on the stack
684 or in the gcc frame. */
685 for (offset = 0; offset < 100; offset += ALPHA_INSN_SIZE)
687 inst = alpha_read_insn (pc + offset);
689 if ((inst & 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
691 if ((inst & 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
693 if ((inst & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
695 if ((inst & 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
698 if (((inst & 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
699 || (inst & 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
700 && (inst & 0x03e00000) != 0x03e00000) /* reg != $zero */
703 if (inst == 0x47de040f) /* bis sp,sp,fp */
705 if (inst == 0x47fe040f) /* bis zero,sp,fp */
714 /* Figure out where the longjmp will land.
715 We expect the first arg to be a pointer to the jmp_buf structure from
716 which we extract the PC (JB_PC) that we will land at. The PC is copied
717 into the "pc". This routine returns true on success. */
720 alpha_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
722 struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
724 gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
726 jb_addr = get_frame_register_unsigned (frame, ALPHA_A0_REGNUM);
728 if (target_read_memory (jb_addr + (tdep->jb_pc * tdep->jb_elt_size),
729 raw_buffer, tdep->jb_elt_size))
732 *pc = extract_unsigned_integer (raw_buffer, tdep->jb_elt_size);
737 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
738 describe the location and shape of the sigcontext structure. After
739 that, all registers are in memory, so it's easy. */
740 /* ??? Shouldn't we be able to do this generically, rather than with
741 OSABI data specific to Alpha? */
743 struct alpha_sigtramp_unwind_cache
745 CORE_ADDR sigcontext_addr;
748 static struct alpha_sigtramp_unwind_cache *
749 alpha_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
750 void **this_prologue_cache)
752 struct alpha_sigtramp_unwind_cache *info;
753 struct gdbarch_tdep *tdep;
755 if (*this_prologue_cache)
756 return *this_prologue_cache;
758 info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache);
759 *this_prologue_cache = info;
761 tdep = gdbarch_tdep (get_frame_arch (next_frame));
762 info->sigcontext_addr = tdep->sigcontext_addr (next_frame);
767 /* Return the address of REGNUM in a sigtramp frame. Since this is
768 all arithmetic, it doesn't seem worthwhile to cache it. */
771 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr, int regnum)
773 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
775 if (regnum >= 0 && regnum < 32)
776 return sigcontext_addr + tdep->sc_regs_offset + regnum * 8;
777 else if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 32)
778 return sigcontext_addr + tdep->sc_fpregs_offset + regnum * 8;
779 else if (regnum == ALPHA_PC_REGNUM)
780 return sigcontext_addr + tdep->sc_pc_offset;
785 /* Given a GDB frame, determine the address of the calling function's
786 frame. This will be used to create a new GDB frame struct. */
789 alpha_sigtramp_frame_this_id (struct frame_info *next_frame,
790 void **this_prologue_cache,
791 struct frame_id *this_id)
793 struct alpha_sigtramp_unwind_cache *info
794 = alpha_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
795 struct gdbarch_tdep *tdep;
796 CORE_ADDR stack_addr, code_addr;
798 /* If the OSABI couldn't locate the sigcontext, give up. */
799 if (info->sigcontext_addr == 0)
802 /* If we have dynamic signal trampolines, find their start.
803 If we do not, then we must assume there is a symbol record
804 that can provide the start address. */
805 tdep = gdbarch_tdep (get_frame_arch (next_frame));
806 if (tdep->dynamic_sigtramp_offset)
809 code_addr = frame_pc_unwind (next_frame);
810 offset = tdep->dynamic_sigtramp_offset (code_addr);
817 code_addr = frame_func_unwind (next_frame, SIGTRAMP_FRAME);
819 /* The stack address is trivially read from the sigcontext. */
820 stack_addr = alpha_sigtramp_register_address (info->sigcontext_addr,
822 stack_addr = get_frame_memory_unsigned (next_frame, stack_addr,
823 ALPHA_REGISTER_SIZE);
825 *this_id = frame_id_build (stack_addr, code_addr);
828 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
831 alpha_sigtramp_frame_prev_register (struct frame_info *next_frame,
832 void **this_prologue_cache,
833 int regnum, int *optimizedp,
834 enum lval_type *lvalp, CORE_ADDR *addrp,
835 int *realnump, gdb_byte *bufferp)
837 struct alpha_sigtramp_unwind_cache *info
838 = alpha_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
841 if (info->sigcontext_addr != 0)
843 /* All integer and fp registers are stored in memory. */
844 addr = alpha_sigtramp_register_address (info->sigcontext_addr, regnum);
848 *lvalp = lval_memory;
852 get_frame_memory (next_frame, addr, bufferp, ALPHA_REGISTER_SIZE);
857 /* This extra register may actually be in the sigcontext, but our
858 current description of it in alpha_sigtramp_frame_unwind_cache
859 doesn't include it. Too bad. Fall back on whatever's in the
862 *lvalp = lval_register;
866 frame_unwind_register (next_frame, *realnump, bufferp);
869 static const struct frame_unwind alpha_sigtramp_frame_unwind = {
871 alpha_sigtramp_frame_this_id,
872 alpha_sigtramp_frame_prev_register
875 static const struct frame_unwind *
876 alpha_sigtramp_frame_sniffer (struct frame_info *next_frame)
878 struct gdbarch *gdbarch = get_frame_arch (next_frame);
879 CORE_ADDR pc = frame_pc_unwind (next_frame);
882 /* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
883 look at tramp-frame.h and other simplier per-architecture
884 sigtramp unwinders. */
886 /* We shouldn't even bother to try if the OSABI didn't register a
887 sigcontext_addr handler or pc_in_sigtramp hander. */
888 if (gdbarch_tdep (gdbarch)->sigcontext_addr == NULL)
890 if (gdbarch_tdep (gdbarch)->pc_in_sigtramp == NULL)
893 /* Otherwise we should be in a signal frame. */
894 find_pc_partial_function (pc, &name, NULL, NULL);
895 if (gdbarch_tdep (gdbarch)->pc_in_sigtramp (pc, name))
896 return &alpha_sigtramp_frame_unwind;
901 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
902 something about the traditional layout of alpha stack frames. */
904 struct alpha_heuristic_unwind_cache
906 CORE_ADDR *saved_regs;
912 /* Heuristic_proc_start may hunt through the text section for a long
913 time across a 2400 baud serial line. Allows the user to limit this
915 static unsigned int heuristic_fence_post = 0;
917 /* Attempt to locate the start of the function containing PC. We assume that
918 the previous function ends with an about_to_return insn. Not foolproof by
919 any means, since gcc is happy to put the epilogue in the middle of a
920 function. But we're guessing anyway... */
923 alpha_heuristic_proc_start (CORE_ADDR pc)
925 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
926 CORE_ADDR last_non_nop = pc;
927 CORE_ADDR fence = pc - heuristic_fence_post;
928 CORE_ADDR orig_pc = pc;
934 /* First see if we can find the start of the function from minimal
935 symbol information. This can succeed with a binary that doesn't
936 have debug info, but hasn't been stripped. */
937 func = get_pc_function_start (pc);
941 if (heuristic_fence_post == UINT_MAX
942 || fence < tdep->vm_min_address)
943 fence = tdep->vm_min_address;
945 /* Search back for previous return; also stop at a 0, which might be
946 seen for instance before the start of a code section. Don't include
947 nops, since this usually indicates padding between functions. */
948 for (pc -= ALPHA_INSN_SIZE; pc >= fence; pc -= ALPHA_INSN_SIZE)
950 unsigned int insn = alpha_read_insn (pc);
953 case 0: /* invalid insn */
954 case 0x6bfa8001: /* ret $31,($26),1 */
957 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
958 case 0x47ff041f: /* nop: bis $31,$31,$31 */
967 /* It's not clear to me why we reach this point when stopping quietly,
968 but with this test, at least we don't print out warnings for every
969 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
970 if (stop_soon == NO_STOP_QUIETLY)
972 static int blurb_printed = 0;
974 if (fence == tdep->vm_min_address)
975 warning (_("Hit beginning of text section without finding \
976 enclosing function for address 0x%s"), paddr_nz (orig_pc));
978 warning (_("Hit heuristic-fence-post without finding \
979 enclosing function for address 0x%s"), paddr_nz (orig_pc));
983 printf_filtered (_("\
984 This warning occurs if you are debugging a function without any symbols\n\
985 (for example, in a stripped executable). In that case, you may wish to\n\
986 increase the size of the search with the `set heuristic-fence-post' command.\n\
988 Otherwise, you told GDB there was a function where there isn't one, or\n\
989 (more likely) you have encountered a bug in GDB.\n"));
997 static struct alpha_heuristic_unwind_cache *
998 alpha_heuristic_frame_unwind_cache (struct frame_info *next_frame,
999 void **this_prologue_cache,
1002 struct alpha_heuristic_unwind_cache *info;
1004 CORE_ADDR limit_pc, cur_pc;
1005 int frame_reg, frame_size, return_reg, reg;
1007 if (*this_prologue_cache)
1008 return *this_prologue_cache;
1010 info = FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache);
1011 *this_prologue_cache = info;
1012 info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
1014 limit_pc = frame_pc_unwind (next_frame);
1016 start_pc = alpha_heuristic_proc_start (limit_pc);
1017 info->start_pc = start_pc;
1019 frame_reg = ALPHA_SP_REGNUM;
1023 /* If we've identified a likely place to start, do code scanning. */
1026 /* Limit the forward search to 50 instructions. */
1027 if (start_pc + 200 < limit_pc)
1028 limit_pc = start_pc + 200;
1030 for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += ALPHA_INSN_SIZE)
1032 unsigned int word = alpha_read_insn (cur_pc);
1034 if ((word & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1038 /* Consider only the first stack allocation instruction
1039 to contain the static size of the frame. */
1040 if (frame_size == 0)
1041 frame_size = (-word) & 0xffff;
1045 /* Exit loop if a positive stack adjustment is found, which
1046 usually means that the stack cleanup code in the function
1047 epilogue is reached. */
1051 else if ((word & 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1053 reg = (word & 0x03e00000) >> 21;
1055 /* Ignore this instruction if we have already encountered
1056 an instruction saving the same register earlier in the
1057 function code. The current instruction does not tell
1058 us where the original value upon function entry is saved.
1059 All it says is that the function we are scanning reused
1060 that register for some computation of its own, and is now
1061 saving its result. */
1062 if (info->saved_regs[reg])
1068 /* Do not compute the address where the register was saved yet,
1069 because we don't know yet if the offset will need to be
1070 relative to $sp or $fp (we can not compute the address
1071 relative to $sp if $sp is updated during the execution of
1072 the current subroutine, for instance when doing some alloca).
1073 So just store the offset for the moment, and compute the
1074 address later when we know whether this frame has a frame
1076 /* Hack: temporarily add one, so that the offset is non-zero
1077 and we can tell which registers have save offsets below. */
1078 info->saved_regs[reg] = (word & 0xffff) + 1;
1080 /* Starting with OSF/1-3.2C, the system libraries are shipped
1081 without local symbols, but they still contain procedure
1082 descriptors without a symbol reference. GDB is currently
1083 unable to find these procedure descriptors and uses
1084 heuristic_proc_desc instead.
1085 As some low level compiler support routines (__div*, __add*)
1086 use a non-standard return address register, we have to
1087 add some heuristics to determine the return address register,
1088 or stepping over these routines will fail.
1089 Usually the return address register is the first register
1090 saved on the stack, but assembler optimization might
1091 rearrange the register saves.
1092 So we recognize only a few registers (t7, t9, ra) within
1093 the procedure prologue as valid return address registers.
1094 If we encounter a return instruction, we extract the
1095 the return address register from it.
1097 FIXME: Rewriting GDB to access the procedure descriptors,
1098 e.g. via the minimal symbol table, might obviate this hack. */
1099 if (return_reg == -1
1100 && cur_pc < (start_pc + 80)
1101 && (reg == ALPHA_T7_REGNUM
1102 || reg == ALPHA_T9_REGNUM
1103 || reg == ALPHA_RA_REGNUM))
1106 else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1107 return_reg = (word >> 16) & 0x1f;
1108 else if (word == 0x47de040f) /* bis sp,sp,fp */
1109 frame_reg = ALPHA_GCC_FP_REGNUM;
1110 else if (word == 0x47fe040f) /* bis zero,sp,fp */
1111 frame_reg = ALPHA_GCC_FP_REGNUM;
1114 /* If we haven't found a valid return address register yet, keep
1115 searching in the procedure prologue. */
1116 if (return_reg == -1)
1118 while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80))
1120 unsigned int word = alpha_read_insn (cur_pc);
1122 if ((word & 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1124 reg = (word & 0x03e00000) >> 21;
1125 if (reg == ALPHA_T7_REGNUM
1126 || reg == ALPHA_T9_REGNUM
1127 || reg == ALPHA_RA_REGNUM)
1133 else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1135 return_reg = (word >> 16) & 0x1f;
1139 cur_pc += ALPHA_INSN_SIZE;
1144 /* Failing that, do default to the customary RA. */
1145 if (return_reg == -1)
1146 return_reg = ALPHA_RA_REGNUM;
1147 info->return_reg = return_reg;
1149 val = frame_unwind_register_unsigned (next_frame, frame_reg);
1150 info->vfp = val + frame_size;
1152 /* Convert offsets to absolute addresses. See above about adding
1153 one to the offsets to make all detected offsets non-zero. */
1154 for (reg = 0; reg < ALPHA_NUM_REGS; ++reg)
1155 if (info->saved_regs[reg])
1156 info->saved_regs[reg] += val - 1;
1161 /* Given a GDB frame, determine the address of the calling function's
1162 frame. This will be used to create a new GDB frame struct. */
1165 alpha_heuristic_frame_this_id (struct frame_info *next_frame,
1166 void **this_prologue_cache,
1167 struct frame_id *this_id)
1169 struct alpha_heuristic_unwind_cache *info
1170 = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
1172 *this_id = frame_id_build (info->vfp, info->start_pc);
1175 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1178 alpha_heuristic_frame_prev_register (struct frame_info *next_frame,
1179 void **this_prologue_cache,
1180 int regnum, int *optimizedp,
1181 enum lval_type *lvalp, CORE_ADDR *addrp,
1182 int *realnump, gdb_byte *bufferp)
1184 struct alpha_heuristic_unwind_cache *info
1185 = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
1187 /* The PC of the previous frame is stored in the link register of
1188 the current frame. Frob regnum so that we pull the value from
1189 the correct place. */
1190 if (regnum == ALPHA_PC_REGNUM)
1191 regnum = info->return_reg;
1193 /* For all registers known to be saved in the current frame,
1194 do the obvious and pull the value out. */
1195 if (info->saved_regs[regnum])
1198 *lvalp = lval_memory;
1199 *addrp = info->saved_regs[regnum];
1201 if (bufferp != NULL)
1202 get_frame_memory (next_frame, *addrp, bufferp, ALPHA_REGISTER_SIZE);
1206 /* The stack pointer of the previous frame is computed by popping
1207 the current stack frame. */
1208 if (regnum == ALPHA_SP_REGNUM)
1214 if (bufferp != NULL)
1215 store_unsigned_integer (bufferp, ALPHA_REGISTER_SIZE, info->vfp);
1219 /* Otherwise assume the next frame has the same register value. */
1221 *lvalp = lval_register;
1225 frame_unwind_register (next_frame, *realnump, bufferp);
1228 static const struct frame_unwind alpha_heuristic_frame_unwind = {
1230 alpha_heuristic_frame_this_id,
1231 alpha_heuristic_frame_prev_register
1234 static const struct frame_unwind *
1235 alpha_heuristic_frame_sniffer (struct frame_info *next_frame)
1237 return &alpha_heuristic_frame_unwind;
1241 alpha_heuristic_frame_base_address (struct frame_info *next_frame,
1242 void **this_prologue_cache)
1244 struct alpha_heuristic_unwind_cache *info
1245 = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
1250 static const struct frame_base alpha_heuristic_frame_base = {
1251 &alpha_heuristic_frame_unwind,
1252 alpha_heuristic_frame_base_address,
1253 alpha_heuristic_frame_base_address,
1254 alpha_heuristic_frame_base_address
1257 /* Just like reinit_frame_cache, but with the right arguments to be
1258 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1261 reinit_frame_cache_sfunc (char *args, int from_tty, struct cmd_list_element *c)
1263 reinit_frame_cache ();
1267 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1268 dummy frame. The frame ID's base needs to match the TOS value
1269 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1272 static struct frame_id
1273 alpha_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
1276 base = frame_unwind_register_unsigned (next_frame, ALPHA_SP_REGNUM);
1277 return frame_id_build (base, frame_pc_unwind (next_frame));
1281 alpha_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1284 pc = frame_unwind_register_unsigned (next_frame, ALPHA_PC_REGNUM);
1289 /* Helper routines for alpha*-nat.c files to move register sets to and
1290 from core files. The UNIQUE pointer is allowed to be NULL, as most
1291 targets don't supply this value in their core files. */
1294 alpha_supply_int_regs (struct regcache *regcache, int regno,
1295 const void *r0_r30, const void *pc, const void *unique)
1297 const gdb_byte *regs = r0_r30;
1300 for (i = 0; i < 31; ++i)
1301 if (regno == i || regno == -1)
1302 regcache_raw_supply (regcache, i, regs + i * 8);
1304 if (regno == ALPHA_ZERO_REGNUM || regno == -1)
1305 regcache_raw_supply (regcache, ALPHA_ZERO_REGNUM, NULL);
1307 if (regno == ALPHA_PC_REGNUM || regno == -1)
1308 regcache_raw_supply (regcache, ALPHA_PC_REGNUM, pc);
1310 if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
1311 regcache_raw_supply (regcache, ALPHA_UNIQUE_REGNUM, unique);
1315 alpha_fill_int_regs (const struct regcache *regcache,
1316 int regno, void *r0_r30, void *pc, void *unique)
1318 gdb_byte *regs = r0_r30;
1321 for (i = 0; i < 31; ++i)
1322 if (regno == i || regno == -1)
1323 regcache_raw_collect (regcache, i, regs + i * 8);
1325 if (regno == ALPHA_PC_REGNUM || regno == -1)
1326 regcache_raw_collect (regcache, ALPHA_PC_REGNUM, pc);
1328 if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1))
1329 regcache_raw_collect (regcache, ALPHA_UNIQUE_REGNUM, unique);
1333 alpha_supply_fp_regs (struct regcache *regcache, int regno,
1334 const void *f0_f30, const void *fpcr)
1336 const gdb_byte *regs = f0_f30;
1339 for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1340 if (regno == i || regno == -1)
1341 regcache_raw_supply (regcache, i,
1342 regs + (i - ALPHA_FP0_REGNUM) * 8);
1344 if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1345 regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, fpcr);
1349 alpha_fill_fp_regs (const struct regcache *regcache,
1350 int regno, void *f0_f30, void *fpcr)
1352 gdb_byte *regs = f0_f30;
1355 for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1356 if (regno == i || regno == -1)
1357 regcache_raw_collect (regcache, i,
1358 regs + (i - ALPHA_FP0_REGNUM) * 8);
1360 if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1361 regcache_raw_collect (regcache, ALPHA_FPCR_REGNUM, fpcr);
1366 /* Return nonzero if the G_floating register value in REG is equal to
1367 zero for FP control instructions. */
1370 fp_register_zero_p (LONGEST reg)
1372 /* Check that all bits except the sign bit are zero. */
1373 const LONGEST zero_mask = ((LONGEST) 1 << 63) ^ -1;
1375 return ((reg & zero_mask) == 0);
1378 /* Return the value of the sign bit for the G_floating register
1379 value held in REG. */
1382 fp_register_sign_bit (LONGEST reg)
1384 const LONGEST sign_mask = (LONGEST) 1 << 63;
1386 return ((reg & sign_mask) != 0);
1389 /* alpha_software_single_step() is called just before we want to resume
1390 the inferior, if we want to single-step it but there is no hardware
1391 or kernel single-step support (NetBSD on Alpha, for example). We find
1392 the target of the coming instruction and breakpoint it. */
1395 alpha_next_pc (struct frame_info *frame, CORE_ADDR pc)
1403 insn = alpha_read_insn (pc);
1405 /* Opcode is top 6 bits. */
1406 op = (insn >> 26) & 0x3f;
1410 /* Jump format: target PC is:
1412 return (get_frame_register_unsigned (frame, (insn >> 16) & 0x1f) & ~3);
1415 if ((op & 0x30) == 0x30)
1417 /* Branch format: target PC is:
1418 (new PC) + (4 * sext(displacement)) */
1419 if (op == 0x30 || /* BR */
1420 op == 0x34) /* BSR */
1423 offset = (insn & 0x001fffff);
1424 if (offset & 0x00100000)
1425 offset |= 0xffe00000;
1426 offset *= ALPHA_INSN_SIZE;
1427 return (pc + ALPHA_INSN_SIZE + offset);
1430 /* Need to determine if branch is taken; read RA. */
1431 regno = (insn >> 21) & 0x1f;
1434 case 0x31: /* FBEQ */
1435 case 0x36: /* FBGE */
1436 case 0x37: /* FBGT */
1437 case 0x33: /* FBLE */
1438 case 0x32: /* FBLT */
1439 case 0x35: /* FBNE */
1440 regno += gdbarch_fp0_regnum (get_frame_arch (frame));
1443 rav = get_frame_register_signed (frame, regno);
1447 case 0x38: /* BLBC */
1451 case 0x3c: /* BLBS */
1455 case 0x39: /* BEQ */
1459 case 0x3d: /* BNE */
1463 case 0x3a: /* BLT */
1467 case 0x3b: /* BLE */
1471 case 0x3f: /* BGT */
1475 case 0x3e: /* BGE */
1480 /* Floating point branches. */
1482 case 0x31: /* FBEQ */
1483 if (fp_register_zero_p (rav))
1486 case 0x36: /* FBGE */
1487 if (fp_register_sign_bit (rav) == 0 || fp_register_zero_p (rav))
1490 case 0x37: /* FBGT */
1491 if (fp_register_sign_bit (rav) == 0 && ! fp_register_zero_p (rav))
1494 case 0x33: /* FBLE */
1495 if (fp_register_sign_bit (rav) == 1 || fp_register_zero_p (rav))
1498 case 0x32: /* FBLT */
1499 if (fp_register_sign_bit (rav) == 1 && ! fp_register_zero_p (rav))
1502 case 0x35: /* FBNE */
1503 if (! fp_register_zero_p (rav))
1509 /* Not a branch or branch not taken; target PC is:
1511 return (pc + ALPHA_INSN_SIZE);
1515 alpha_software_single_step (struct frame_info *frame)
1517 CORE_ADDR pc, next_pc;
1519 pc = get_frame_pc (frame);
1520 next_pc = alpha_next_pc (frame, pc);
1522 insert_single_step_breakpoint (next_pc);
1527 /* Initialize the current architecture based on INFO. If possible, re-use an
1528 architecture from ARCHES, which is a list of architectures already created
1529 during this debugging session.
1531 Called e.g. at program startup, when reading a core file, and when reading
1534 static struct gdbarch *
1535 alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1537 struct gdbarch_tdep *tdep;
1538 struct gdbarch *gdbarch;
1540 /* Try to determine the ABI of the object we are loading. */
1541 if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
1543 /* If it's an ECOFF file, assume it's OSF/1. */
1544 if (bfd_get_flavour (info.abfd) == bfd_target_ecoff_flavour)
1545 info.osabi = GDB_OSABI_OSF1;
1548 /* Find a candidate among extant architectures. */
1549 arches = gdbarch_list_lookup_by_info (arches, &info);
1551 return arches->gdbarch;
1553 tdep = xmalloc (sizeof (struct gdbarch_tdep));
1554 gdbarch = gdbarch_alloc (&info, tdep);
1556 /* Lowest text address. This is used by heuristic_proc_start()
1557 to decide when to stop looking. */
1558 tdep->vm_min_address = (CORE_ADDR) 0x120000000LL;
1560 tdep->dynamic_sigtramp_offset = NULL;
1561 tdep->sigcontext_addr = NULL;
1562 tdep->sc_pc_offset = 2 * 8;
1563 tdep->sc_regs_offset = 4 * 8;
1564 tdep->sc_fpregs_offset = tdep->sc_regs_offset + 32 * 8 + 8;
1566 tdep->jb_pc = -1; /* longjmp support not enabled by default */
1568 tdep->return_in_memory = alpha_return_in_memory_always;
1571 set_gdbarch_short_bit (gdbarch, 16);
1572 set_gdbarch_int_bit (gdbarch, 32);
1573 set_gdbarch_long_bit (gdbarch, 64);
1574 set_gdbarch_long_long_bit (gdbarch, 64);
1575 set_gdbarch_float_bit (gdbarch, 32);
1576 set_gdbarch_double_bit (gdbarch, 64);
1577 set_gdbarch_long_double_bit (gdbarch, 64);
1578 set_gdbarch_ptr_bit (gdbarch, 64);
1581 set_gdbarch_num_regs (gdbarch, ALPHA_NUM_REGS);
1582 set_gdbarch_sp_regnum (gdbarch, ALPHA_SP_REGNUM);
1583 set_gdbarch_pc_regnum (gdbarch, ALPHA_PC_REGNUM);
1584 set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM);
1586 set_gdbarch_register_name (gdbarch, alpha_register_name);
1587 set_gdbarch_register_type (gdbarch, alpha_register_type);
1589 set_gdbarch_cannot_fetch_register (gdbarch, alpha_cannot_fetch_register);
1590 set_gdbarch_cannot_store_register (gdbarch, alpha_cannot_store_register);
1592 set_gdbarch_convert_register_p (gdbarch, alpha_convert_register_p);
1593 set_gdbarch_register_to_value (gdbarch, alpha_register_to_value);
1594 set_gdbarch_value_to_register (gdbarch, alpha_value_to_register);
1596 set_gdbarch_register_reggroup_p (gdbarch, alpha_register_reggroup_p);
1598 /* Prologue heuristics. */
1599 set_gdbarch_skip_prologue (gdbarch, alpha_skip_prologue);
1602 set_gdbarch_print_insn (gdbarch, print_insn_alpha);
1606 set_gdbarch_return_value (gdbarch, alpha_return_value);
1608 /* Settings for calling functions in the inferior. */
1609 set_gdbarch_push_dummy_call (gdbarch, alpha_push_dummy_call);
1611 /* Methods for saving / extracting a dummy frame's ID. */
1612 set_gdbarch_unwind_dummy_id (gdbarch, alpha_unwind_dummy_id);
1614 /* Return the unwound PC value. */
1615 set_gdbarch_unwind_pc (gdbarch, alpha_unwind_pc);
1617 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1618 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1620 set_gdbarch_breakpoint_from_pc (gdbarch, alpha_breakpoint_from_pc);
1621 set_gdbarch_decr_pc_after_break (gdbarch, ALPHA_INSN_SIZE);
1622 set_gdbarch_cannot_step_breakpoint (gdbarch, 1);
1624 /* Hook in ABI-specific overrides, if they have been registered. */
1625 gdbarch_init_osabi (info, gdbarch);
1627 /* Now that we have tuned the configuration, set a few final things
1628 based on what the OS ABI has told us. */
1630 if (tdep->jb_pc >= 0)
1631 set_gdbarch_get_longjmp_target (gdbarch, alpha_get_longjmp_target);
1633 frame_unwind_append_sniffer (gdbarch, alpha_sigtramp_frame_sniffer);
1634 frame_unwind_append_sniffer (gdbarch, alpha_heuristic_frame_sniffer);
1636 frame_base_set_default (gdbarch, &alpha_heuristic_frame_base);
1642 alpha_dwarf2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1644 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
1645 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
1648 extern initialize_file_ftype _initialize_alpha_tdep; /* -Wmissing-prototypes */
1651 _initialize_alpha_tdep (void)
1653 struct cmd_list_element *c;
1655 gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, NULL);
1657 /* Let the user set the fence post for heuristic_proc_start. */
1659 /* We really would like to have both "0" and "unlimited" work, but
1660 command.c doesn't deal with that. So make it a var_zinteger
1661 because the user can always use "999999" or some such for unlimited. */
1662 /* We need to throw away the frame cache when we set this, since it
1663 might change our ability to get backtraces. */
1664 add_setshow_zinteger_cmd ("heuristic-fence-post", class_support,
1665 &heuristic_fence_post, _("\
1666 Set the distance searched for the start of a function."), _("\
1667 Show the distance searched for the start of a function."), _("\
1668 If you are debugging a stripped executable, GDB needs to search through the\n\
1669 program for the start of a function. This command sets the distance of the\n\
1670 search. The only need to set it is when debugging a stripped executable."),
1671 reinit_frame_cache_sfunc,
1672 NULL, /* FIXME: i18n: The distance searched for the start of a function is \"%d\". */
1673 &setlist, &showlist);