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 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"
43 #include "trad-frame.h"
47 #include "alpha-tdep.h"
50 /* Return the name of the REGNO register.
52 An empty name corresponds to a register number that used to
53 be used for a virtual register. That virtual register has
54 been removed, but the index is still reserved to maintain
55 compatibility with existing remote alpha targets. */
58 alpha_register_name (struct gdbarch *gdbarch, int regno)
60 static const char * const register_names[] =
62 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
63 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
64 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
65 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
66 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
67 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
68 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
69 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
75 if (regno >= ARRAY_SIZE(register_names))
77 return register_names[regno];
81 alpha_cannot_fetch_register (struct gdbarch *gdbarch, int regno)
83 return (regno == ALPHA_ZERO_REGNUM
84 || strlen (alpha_register_name (gdbarch, regno)) == 0);
88 alpha_cannot_store_register (struct gdbarch *gdbarch, int regno)
90 return (regno == ALPHA_ZERO_REGNUM
91 || strlen (alpha_register_name (gdbarch, regno)) == 0);
95 alpha_register_type (struct gdbarch *gdbarch, int regno)
97 if (regno == ALPHA_SP_REGNUM || regno == ALPHA_GP_REGNUM)
98 return builtin_type (gdbarch)->builtin_data_ptr;
99 if (regno == ALPHA_PC_REGNUM)
100 return builtin_type (gdbarch)->builtin_func_ptr;
102 /* Don't need to worry about little vs big endian until
103 some jerk tries to port to alpha-unicosmk. */
104 if (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31)
105 return builtin_type (gdbarch)->builtin_double;
107 return builtin_type (gdbarch)->builtin_int64;
110 /* Is REGNUM a member of REGGROUP? */
113 alpha_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
114 struct reggroup *group)
116 /* Filter out any registers eliminated, but whose regnum is
117 reserved for backward compatibility, e.g. the vfp. */
118 if (gdbarch_register_name (gdbarch, regnum) == NULL
119 || *gdbarch_register_name (gdbarch, regnum) == '\0')
122 if (group == all_reggroup)
125 /* Zero should not be saved or restored. Technically it is a general
126 register (just as $f31 would be a float if we represented it), but
127 there's no point displaying it during "info regs", so leave it out
128 of all groups except for "all". */
129 if (regnum == ALPHA_ZERO_REGNUM)
132 /* All other registers are saved and restored. */
133 if (group == save_reggroup || group == restore_reggroup)
136 /* All other groups are non-overlapping. */
138 /* Since this is really a PALcode memory slot... */
139 if (regnum == ALPHA_UNIQUE_REGNUM)
140 return group == system_reggroup;
142 /* Force the FPCR to be considered part of the floating point state. */
143 if (regnum == ALPHA_FPCR_REGNUM)
144 return group == float_reggroup;
146 if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 31)
147 return group == float_reggroup;
149 return group == general_reggroup;
152 /* The following represents exactly the conversion performed by
153 the LDS instruction. This applies to both single-precision
154 floating point and 32-bit integers. */
157 alpha_lds (void *out, const void *in)
159 ULONGEST mem = extract_unsigned_integer (in, 4);
160 ULONGEST frac = (mem >> 0) & 0x7fffff;
161 ULONGEST sign = (mem >> 31) & 1;
162 ULONGEST exp_msb = (mem >> 30) & 1;
163 ULONGEST exp_low = (mem >> 23) & 0x7f;
166 exp = (exp_msb << 10) | exp_low;
178 reg = (sign << 63) | (exp << 52) | (frac << 29);
179 store_unsigned_integer (out, 8, reg);
182 /* Similarly, this represents exactly the conversion performed by
183 the STS instruction. */
186 alpha_sts (void *out, const void *in)
190 reg = extract_unsigned_integer (in, 8);
191 mem = ((reg >> 32) & 0xc0000000) | ((reg >> 29) & 0x3fffffff);
192 store_unsigned_integer (out, 4, mem);
195 /* The alpha needs a conversion between register and memory format if the
196 register is a floating point register and memory format is float, as the
197 register format must be double or memory format is an integer with 4
198 bytes or less, as the representation of integers in floating point
199 registers is different. */
202 alpha_convert_register_p (struct gdbarch *gdbarch, int regno, struct type *type)
204 return (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31
205 && TYPE_LENGTH (type) != 8);
209 alpha_register_to_value (struct frame_info *frame, int regnum,
210 struct type *valtype, gdb_byte *out)
212 gdb_byte in[MAX_REGISTER_SIZE];
214 frame_register_read (frame, regnum, in);
215 switch (TYPE_LENGTH (valtype))
221 error (_("Cannot retrieve value from floating point register"));
226 alpha_value_to_register (struct frame_info *frame, int regnum,
227 struct type *valtype, const gdb_byte *in)
229 gdb_byte out[MAX_REGISTER_SIZE];
231 switch (TYPE_LENGTH (valtype))
237 error (_("Cannot store value in floating point register"));
239 put_frame_register (frame, regnum, out);
243 /* The alpha passes the first six arguments in the registers, the rest on
244 the stack. The register arguments are stored in ARG_REG_BUFFER, and
245 then moved into the register file; this simplifies the passing of a
246 large struct which extends from the registers to the stack, plus avoids
247 three ptrace invocations per word.
249 We don't bother tracking which register values should go in integer
250 regs or fp regs; we load the same values into both.
252 If the called function is returning a structure, the address of the
253 structure to be returned is passed as a hidden first argument. */
256 alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
257 struct regcache *regcache, CORE_ADDR bp_addr,
258 int nargs, struct value **args, CORE_ADDR sp,
259 int struct_return, CORE_ADDR struct_addr)
262 int accumulate_size = struct_return ? 8 : 0;
269 struct alpha_arg *alpha_args
270 = (struct alpha_arg *) alloca (nargs * sizeof (struct alpha_arg));
271 struct alpha_arg *m_arg;
272 gdb_byte arg_reg_buffer[ALPHA_REGISTER_SIZE * ALPHA_NUM_ARG_REGS];
273 int required_arg_regs;
274 CORE_ADDR func_addr = find_function_addr (function, NULL);
276 /* The ABI places the address of the called function in T12. */
277 regcache_cooked_write_signed (regcache, ALPHA_T12_REGNUM, func_addr);
279 /* Set the return address register to point to the entry point
280 of the program, where a breakpoint lies in wait. */
281 regcache_cooked_write_signed (regcache, ALPHA_RA_REGNUM, bp_addr);
283 /* Lay out the arguments in memory. */
284 for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
286 struct value *arg = args[i];
287 struct type *arg_type = check_typedef (value_type (arg));
289 /* Cast argument to long if necessary as the compiler does it too. */
290 switch (TYPE_CODE (arg_type))
295 case TYPE_CODE_RANGE:
297 if (TYPE_LENGTH (arg_type) == 4)
299 /* 32-bit values must be sign-extended to 64 bits
300 even if the base data type is unsigned. */
301 arg_type = builtin_type (gdbarch)->builtin_int32;
302 arg = value_cast (arg_type, arg);
304 if (TYPE_LENGTH (arg_type) < ALPHA_REGISTER_SIZE)
306 arg_type = builtin_type (gdbarch)->builtin_int64;
307 arg = value_cast (arg_type, arg);
312 /* "float" arguments loaded in registers must be passed in
313 register format, aka "double". */
314 if (accumulate_size < sizeof (arg_reg_buffer)
315 && TYPE_LENGTH (arg_type) == 4)
317 arg_type = builtin_type (gdbarch)->builtin_double;
318 arg = value_cast (arg_type, arg);
320 /* Tru64 5.1 has a 128-bit long double, and passes this by
321 invisible reference. No one else uses this data type. */
322 else if (TYPE_LENGTH (arg_type) == 16)
324 /* Allocate aligned storage. */
325 sp = (sp & -16) - 16;
327 /* Write the real data into the stack. */
328 write_memory (sp, value_contents (arg), 16);
330 /* Construct the indirection. */
331 arg_type = lookup_pointer_type (arg_type);
332 arg = value_from_pointer (arg_type, sp);
336 case TYPE_CODE_COMPLEX:
337 /* ??? The ABI says that complex values are passed as two
338 separate scalar values. This distinction only matters
339 for complex float. However, GCC does not implement this. */
341 /* Tru64 5.1 has a 128-bit long double, and passes this by
342 invisible reference. */
343 if (TYPE_LENGTH (arg_type) == 32)
345 /* Allocate aligned storage. */
346 sp = (sp & -16) - 16;
348 /* Write the real data into the stack. */
349 write_memory (sp, value_contents (arg), 32);
351 /* Construct the indirection. */
352 arg_type = lookup_pointer_type (arg_type);
353 arg = value_from_pointer (arg_type, sp);
360 m_arg->len = TYPE_LENGTH (arg_type);
361 m_arg->offset = accumulate_size;
362 accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
363 m_arg->contents = value_contents_writeable (arg);
366 /* Determine required argument register loads, loading an argument register
367 is expensive as it uses three ptrace calls. */
368 required_arg_regs = accumulate_size / 8;
369 if (required_arg_regs > ALPHA_NUM_ARG_REGS)
370 required_arg_regs = ALPHA_NUM_ARG_REGS;
372 /* Make room for the arguments on the stack. */
373 if (accumulate_size < sizeof(arg_reg_buffer))
376 accumulate_size -= sizeof(arg_reg_buffer);
377 sp -= accumulate_size;
379 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
382 /* `Push' arguments on the stack. */
383 for (i = nargs; m_arg--, --i >= 0;)
385 gdb_byte *contents = m_arg->contents;
386 int offset = m_arg->offset;
387 int len = m_arg->len;
389 /* Copy the bytes destined for registers into arg_reg_buffer. */
390 if (offset < sizeof(arg_reg_buffer))
392 if (offset + len <= sizeof(arg_reg_buffer))
394 memcpy (arg_reg_buffer + offset, contents, len);
399 int tlen = sizeof(arg_reg_buffer) - offset;
400 memcpy (arg_reg_buffer + offset, contents, tlen);
407 /* Everything else goes to the stack. */
408 write_memory (sp + offset - sizeof(arg_reg_buffer), contents, len);
411 store_unsigned_integer (arg_reg_buffer, ALPHA_REGISTER_SIZE, struct_addr);
413 /* Load the argument registers. */
414 for (i = 0; i < required_arg_regs; i++)
416 regcache_cooked_write (regcache, ALPHA_A0_REGNUM + i,
417 arg_reg_buffer + i*ALPHA_REGISTER_SIZE);
418 regcache_cooked_write (regcache, ALPHA_FPA0_REGNUM + i,
419 arg_reg_buffer + i*ALPHA_REGISTER_SIZE);
422 /* Finally, update the stack pointer. */
423 regcache_cooked_write_signed (regcache, ALPHA_SP_REGNUM, sp);
428 /* Extract from REGCACHE the value about to be returned from a function
429 and copy it into VALBUF. */
432 alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
435 int length = TYPE_LENGTH (valtype);
436 gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
439 switch (TYPE_CODE (valtype))
445 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, raw_buffer);
446 alpha_sts (valbuf, raw_buffer);
450 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
454 regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l);
455 read_memory (l, valbuf, 16);
459 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
463 case TYPE_CODE_COMPLEX:
467 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
468 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
472 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
473 regcache_cooked_read (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8);
477 regcache_cooked_read_signed (regcache, ALPHA_V0_REGNUM, &l);
478 read_memory (l, valbuf, 32);
482 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
487 /* Assume everything else degenerates to an integer. */
488 regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l);
489 store_unsigned_integer (valbuf, length, l);
494 /* Insert the given value into REGCACHE as if it was being
495 returned by a function. */
498 alpha_store_return_value (struct type *valtype, struct regcache *regcache,
499 const gdb_byte *valbuf)
501 struct gdbarch *gdbarch = get_regcache_arch (regcache);
502 int length = TYPE_LENGTH (valtype);
503 gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
506 switch (TYPE_CODE (valtype))
512 alpha_lds (raw_buffer, valbuf);
513 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, raw_buffer);
517 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
521 /* FIXME: 128-bit long doubles are returned like structures:
522 by writing into indirect storage provided by the caller
523 as the first argument. */
524 error (_("Cannot set a 128-bit long double return value."));
527 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
531 case TYPE_CODE_COMPLEX:
535 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
536 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
540 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
541 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8);
545 /* FIXME: 128-bit long doubles are returned like structures:
546 by writing into indirect storage provided by the caller
547 as the first argument. */
548 error (_("Cannot set a 128-bit long double return value."));
551 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
556 /* Assume everything else degenerates to an integer. */
557 /* 32-bit values must be sign-extended to 64 bits
558 even if the base data type is unsigned. */
560 valtype = builtin_type (gdbarch)->builtin_int32;
561 l = unpack_long (valtype, valbuf);
562 regcache_cooked_write_unsigned (regcache, ALPHA_V0_REGNUM, l);
567 static enum return_value_convention
568 alpha_return_value (struct gdbarch *gdbarch, struct type *func_type,
569 struct type *type, struct regcache *regcache,
570 gdb_byte *readbuf, const gdb_byte *writebuf)
572 enum type_code code = TYPE_CODE (type);
574 if ((code == TYPE_CODE_STRUCT
575 || code == TYPE_CODE_UNION
576 || code == TYPE_CODE_ARRAY)
577 && gdbarch_tdep (gdbarch)->return_in_memory (type))
582 regcache_raw_read_unsigned (regcache, ALPHA_V0_REGNUM, &addr);
583 read_memory (addr, readbuf, TYPE_LENGTH (type));
586 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
590 alpha_extract_return_value (type, regcache, readbuf);
592 alpha_store_return_value (type, regcache, writebuf);
594 return RETURN_VALUE_REGISTER_CONVENTION;
598 alpha_return_in_memory_always (struct type *type)
603 static const gdb_byte *
604 alpha_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
606 static const gdb_byte break_insn[] = { 0x80, 0, 0, 0 }; /* call_pal bpt */
608 *len = sizeof(break_insn);
613 /* This returns the PC of the first insn after the prologue.
614 If we can't find the prologue, then return 0. */
617 alpha_after_prologue (CORE_ADDR pc)
619 struct symtab_and_line sal;
620 CORE_ADDR func_addr, func_end;
622 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
625 sal = find_pc_line (func_addr, 0);
626 if (sal.end < func_end)
629 /* The line after the prologue is after the end of the function. In this
630 case, tell the caller to find the prologue the hard way. */
634 /* Read an instruction from memory at PC, looking through breakpoints. */
637 alpha_read_insn (CORE_ADDR pc)
639 gdb_byte buf[ALPHA_INSN_SIZE];
642 status = target_read_memory (pc, buf, sizeof (buf));
644 memory_error (status, pc);
645 return extract_unsigned_integer (buf, sizeof (buf));
648 /* To skip prologues, I use this predicate. Returns either PC itself
649 if the code at PC does not look like a function prologue; otherwise
650 returns an address that (if we're lucky) follows the prologue. If
651 LENIENT, then we must skip everything which is involved in setting
652 up the frame (it's OK to skip more, just so long as we don't skip
653 anything which might clobber the registers which are being saved. */
656 alpha_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
660 CORE_ADDR post_prologue_pc;
661 gdb_byte buf[ALPHA_INSN_SIZE];
663 /* Silently return the unaltered pc upon memory errors.
664 This could happen on OSF/1 if decode_line_1 tries to skip the
665 prologue for quickstarted shared library functions when the
666 shared library is not yet mapped in.
667 Reading target memory is slow over serial lines, so we perform
668 this check only if the target has shared libraries (which all
669 Alpha targets do). */
670 if (target_read_memory (pc, buf, sizeof (buf)))
673 /* See if we can determine the end of the prologue via the symbol table.
674 If so, then return either PC, or the PC after the prologue, whichever
677 post_prologue_pc = alpha_after_prologue (pc);
678 if (post_prologue_pc != 0)
679 return max (pc, post_prologue_pc);
681 /* Can't determine prologue from the symbol table, need to examine
684 /* Skip the typical prologue instructions. These are the stack adjustment
685 instruction and the instructions that save registers on the stack
686 or in the gcc frame. */
687 for (offset = 0; offset < 100; offset += ALPHA_INSN_SIZE)
689 inst = alpha_read_insn (pc + offset);
691 if ((inst & 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
693 if ((inst & 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
695 if ((inst & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
697 if ((inst & 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
700 if (((inst & 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
701 || (inst & 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
702 && (inst & 0x03e00000) != 0x03e00000) /* reg != $zero */
705 if (inst == 0x47de040f) /* bis sp,sp,fp */
707 if (inst == 0x47fe040f) /* bis zero,sp,fp */
716 /* Figure out where the longjmp will land.
717 We expect the first arg to be a pointer to the jmp_buf structure from
718 which we extract the PC (JB_PC) that we will land at. The PC is copied
719 into the "pc". This routine returns true on success. */
722 alpha_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
724 struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
726 gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
728 jb_addr = get_frame_register_unsigned (frame, ALPHA_A0_REGNUM);
730 if (target_read_memory (jb_addr + (tdep->jb_pc * tdep->jb_elt_size),
731 raw_buffer, tdep->jb_elt_size))
734 *pc = extract_unsigned_integer (raw_buffer, tdep->jb_elt_size);
739 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
740 describe the location and shape of the sigcontext structure. After
741 that, all registers are in memory, so it's easy. */
742 /* ??? Shouldn't we be able to do this generically, rather than with
743 OSABI data specific to Alpha? */
745 struct alpha_sigtramp_unwind_cache
747 CORE_ADDR sigcontext_addr;
750 static struct alpha_sigtramp_unwind_cache *
751 alpha_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
752 void **this_prologue_cache)
754 struct alpha_sigtramp_unwind_cache *info;
755 struct gdbarch_tdep *tdep;
757 if (*this_prologue_cache)
758 return *this_prologue_cache;
760 info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache);
761 *this_prologue_cache = info;
763 tdep = gdbarch_tdep (get_frame_arch (this_frame));
764 info->sigcontext_addr = tdep->sigcontext_addr (this_frame);
769 /* Return the address of REGNUM in a sigtramp frame. Since this is
770 all arithmetic, it doesn't seem worthwhile to cache it. */
773 alpha_sigtramp_register_address (struct gdbarch *gdbarch,
774 CORE_ADDR sigcontext_addr, int regnum)
776 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
778 if (regnum >= 0 && regnum < 32)
779 return sigcontext_addr + tdep->sc_regs_offset + regnum * 8;
780 else if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 32)
781 return sigcontext_addr + tdep->sc_fpregs_offset + regnum * 8;
782 else if (regnum == ALPHA_PC_REGNUM)
783 return sigcontext_addr + tdep->sc_pc_offset;
788 /* Given a GDB frame, determine the address of the calling function's
789 frame. This will be used to create a new GDB frame struct. */
792 alpha_sigtramp_frame_this_id (struct frame_info *this_frame,
793 void **this_prologue_cache,
794 struct frame_id *this_id)
796 struct gdbarch *gdbarch = get_frame_arch (this_frame);
797 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
798 struct alpha_sigtramp_unwind_cache *info
799 = alpha_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
800 CORE_ADDR stack_addr, code_addr;
802 /* If the OSABI couldn't locate the sigcontext, give up. */
803 if (info->sigcontext_addr == 0)
806 /* If we have dynamic signal trampolines, find their start.
807 If we do not, then we must assume there is a symbol record
808 that can provide the start address. */
809 if (tdep->dynamic_sigtramp_offset)
812 code_addr = get_frame_pc (this_frame);
813 offset = tdep->dynamic_sigtramp_offset (code_addr);
820 code_addr = get_frame_func (this_frame);
822 /* The stack address is trivially read from the sigcontext. */
823 stack_addr = alpha_sigtramp_register_address (gdbarch, info->sigcontext_addr,
825 stack_addr = get_frame_memory_unsigned (this_frame, stack_addr,
826 ALPHA_REGISTER_SIZE);
828 *this_id = frame_id_build (stack_addr, code_addr);
831 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
833 static struct value *
834 alpha_sigtramp_frame_prev_register (struct frame_info *this_frame,
835 void **this_prologue_cache, int regnum)
837 struct alpha_sigtramp_unwind_cache *info
838 = alpha_sigtramp_frame_unwind_cache (this_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 (get_frame_arch (this_frame),
845 info->sigcontext_addr, regnum);
847 return frame_unwind_got_memory (this_frame, regnum, addr);
850 /* This extra register may actually be in the sigcontext, but our
851 current description of it in alpha_sigtramp_frame_unwind_cache
852 doesn't include it. Too bad. Fall back on whatever's in the
854 return frame_unwind_got_register (this_frame, regnum, regnum);
858 alpha_sigtramp_frame_sniffer (const struct frame_unwind *self,
859 struct frame_info *this_frame,
860 void **this_prologue_cache)
862 struct gdbarch *gdbarch = get_frame_arch (this_frame);
863 CORE_ADDR pc = get_frame_pc (this_frame);
866 /* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
867 look at tramp-frame.h and other simplier per-architecture
868 sigtramp unwinders. */
870 /* We shouldn't even bother to try if the OSABI didn't register a
871 sigcontext_addr handler or pc_in_sigtramp hander. */
872 if (gdbarch_tdep (gdbarch)->sigcontext_addr == NULL)
874 if (gdbarch_tdep (gdbarch)->pc_in_sigtramp == NULL)
877 /* Otherwise we should be in a signal frame. */
878 find_pc_partial_function (pc, &name, NULL, NULL);
879 if (gdbarch_tdep (gdbarch)->pc_in_sigtramp (pc, name))
885 static const struct frame_unwind alpha_sigtramp_frame_unwind = {
887 alpha_sigtramp_frame_this_id,
888 alpha_sigtramp_frame_prev_register,
890 alpha_sigtramp_frame_sniffer
895 /* Heuristic_proc_start may hunt through the text section for a long
896 time across a 2400 baud serial line. Allows the user to limit this
898 static unsigned int heuristic_fence_post = 0;
900 /* Attempt to locate the start of the function containing PC. We assume that
901 the previous function ends with an about_to_return insn. Not foolproof by
902 any means, since gcc is happy to put the epilogue in the middle of a
903 function. But we're guessing anyway... */
906 alpha_heuristic_proc_start (struct gdbarch *gdbarch, CORE_ADDR pc)
908 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
909 CORE_ADDR last_non_nop = pc;
910 CORE_ADDR fence = pc - heuristic_fence_post;
911 CORE_ADDR orig_pc = pc;
913 struct inferior *inf;
918 /* First see if we can find the start of the function from minimal
919 symbol information. This can succeed with a binary that doesn't
920 have debug info, but hasn't been stripped. */
921 func = get_pc_function_start (pc);
925 if (heuristic_fence_post == UINT_MAX
926 || fence < tdep->vm_min_address)
927 fence = tdep->vm_min_address;
929 /* Search back for previous return; also stop at a 0, which might be
930 seen for instance before the start of a code section. Don't include
931 nops, since this usually indicates padding between functions. */
932 for (pc -= ALPHA_INSN_SIZE; pc >= fence; pc -= ALPHA_INSN_SIZE)
934 unsigned int insn = alpha_read_insn (pc);
937 case 0: /* invalid insn */
938 case 0x6bfa8001: /* ret $31,($26),1 */
941 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
942 case 0x47ff041f: /* nop: bis $31,$31,$31 */
951 inf = current_inferior ();
953 /* It's not clear to me why we reach this point when stopping quietly,
954 but with this test, at least we don't print out warnings for every
955 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
956 if (inf->stop_soon == NO_STOP_QUIETLY)
958 static int blurb_printed = 0;
960 if (fence == tdep->vm_min_address)
961 warning (_("Hit beginning of text section without finding \
962 enclosing function for address 0x%s"), paddr_nz (orig_pc));
964 warning (_("Hit heuristic-fence-post without finding \
965 enclosing function for address 0x%s"), paddr_nz (orig_pc));
969 printf_filtered (_("\
970 This warning occurs if you are debugging a function without any symbols\n\
971 (for example, in a stripped executable). In that case, you may wish to\n\
972 increase the size of the search with the `set heuristic-fence-post' command.\n\
974 Otherwise, you told GDB there was a function where there isn't one, or\n\
975 (more likely) you have encountered a bug in GDB.\n"));
983 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
984 something about the traditional layout of alpha stack frames. */
986 struct alpha_heuristic_unwind_cache
990 struct trad_frame_saved_reg *saved_regs;
994 static struct alpha_heuristic_unwind_cache *
995 alpha_heuristic_frame_unwind_cache (struct frame_info *this_frame,
996 void **this_prologue_cache,
999 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1000 struct alpha_heuristic_unwind_cache *info;
1002 CORE_ADDR limit_pc, cur_pc;
1003 int frame_reg, frame_size, return_reg, reg;
1005 if (*this_prologue_cache)
1006 return *this_prologue_cache;
1008 info = FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache);
1009 *this_prologue_cache = info;
1010 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1012 limit_pc = get_frame_pc (this_frame);
1014 start_pc = alpha_heuristic_proc_start (gdbarch, limit_pc);
1015 info->start_pc = start_pc;
1017 frame_reg = ALPHA_SP_REGNUM;
1021 /* If we've identified a likely place to start, do code scanning. */
1024 /* Limit the forward search to 50 instructions. */
1025 if (start_pc + 200 < limit_pc)
1026 limit_pc = start_pc + 200;
1028 for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += ALPHA_INSN_SIZE)
1030 unsigned int word = alpha_read_insn (cur_pc);
1032 if ((word & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1036 /* Consider only the first stack allocation instruction
1037 to contain the static size of the frame. */
1038 if (frame_size == 0)
1039 frame_size = (-word) & 0xffff;
1043 /* Exit loop if a positive stack adjustment is found, which
1044 usually means that the stack cleanup code in the function
1045 epilogue is reached. */
1049 else if ((word & 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1051 reg = (word & 0x03e00000) >> 21;
1053 /* Ignore this instruction if we have already encountered
1054 an instruction saving the same register earlier in the
1055 function code. The current instruction does not tell
1056 us where the original value upon function entry is saved.
1057 All it says is that the function we are scanning reused
1058 that register for some computation of its own, and is now
1059 saving its result. */
1060 if (trad_frame_addr_p(info->saved_regs, reg))
1066 /* Do not compute the address where the register was saved yet,
1067 because we don't know yet if the offset will need to be
1068 relative to $sp or $fp (we can not compute the address
1069 relative to $sp if $sp is updated during the execution of
1070 the current subroutine, for instance when doing some alloca).
1071 So just store the offset for the moment, and compute the
1072 address later when we know whether this frame has a frame
1074 /* Hack: temporarily add one, so that the offset is non-zero
1075 and we can tell which registers have save offsets below. */
1076 info->saved_regs[reg].addr = (word & 0xffff) + 1;
1078 /* Starting with OSF/1-3.2C, the system libraries are shipped
1079 without local symbols, but they still contain procedure
1080 descriptors without a symbol reference. GDB is currently
1081 unable to find these procedure descriptors and uses
1082 heuristic_proc_desc instead.
1083 As some low level compiler support routines (__div*, __add*)
1084 use a non-standard return address register, we have to
1085 add some heuristics to determine the return address register,
1086 or stepping over these routines will fail.
1087 Usually the return address register is the first register
1088 saved on the stack, but assembler optimization might
1089 rearrange the register saves.
1090 So we recognize only a few registers (t7, t9, ra) within
1091 the procedure prologue as valid return address registers.
1092 If we encounter a return instruction, we extract the
1093 the return address register from it.
1095 FIXME: Rewriting GDB to access the procedure descriptors,
1096 e.g. via the minimal symbol table, might obviate this hack. */
1097 if (return_reg == -1
1098 && cur_pc < (start_pc + 80)
1099 && (reg == ALPHA_T7_REGNUM
1100 || reg == ALPHA_T9_REGNUM
1101 || reg == ALPHA_RA_REGNUM))
1104 else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1105 return_reg = (word >> 16) & 0x1f;
1106 else if (word == 0x47de040f) /* bis sp,sp,fp */
1107 frame_reg = ALPHA_GCC_FP_REGNUM;
1108 else if (word == 0x47fe040f) /* bis zero,sp,fp */
1109 frame_reg = ALPHA_GCC_FP_REGNUM;
1112 /* If we haven't found a valid return address register yet, keep
1113 searching in the procedure prologue. */
1114 if (return_reg == -1)
1116 while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80))
1118 unsigned int word = alpha_read_insn (cur_pc);
1120 if ((word & 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1122 reg = (word & 0x03e00000) >> 21;
1123 if (reg == ALPHA_T7_REGNUM
1124 || reg == ALPHA_T9_REGNUM
1125 || reg == ALPHA_RA_REGNUM)
1131 else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1133 return_reg = (word >> 16) & 0x1f;
1137 cur_pc += ALPHA_INSN_SIZE;
1142 /* Failing that, do default to the customary RA. */
1143 if (return_reg == -1)
1144 return_reg = ALPHA_RA_REGNUM;
1145 info->return_reg = return_reg;
1147 val = get_frame_register_unsigned (this_frame, frame_reg);
1148 info->vfp = val + frame_size;
1150 /* Convert offsets to absolute addresses. See above about adding
1151 one to the offsets to make all detected offsets non-zero. */
1152 for (reg = 0; reg < ALPHA_NUM_REGS; ++reg)
1153 if (trad_frame_addr_p(info->saved_regs, reg))
1154 info->saved_regs[reg].addr += val - 1;
1156 /* The stack pointer of the previous frame is computed by popping
1157 the current stack frame. */
1158 if (!trad_frame_addr_p (info->saved_regs, ALPHA_SP_REGNUM))
1159 trad_frame_set_value (info->saved_regs, ALPHA_SP_REGNUM, info->vfp);
1164 /* Given a GDB frame, determine the address of the calling function's
1165 frame. This will be used to create a new GDB frame struct. */
1168 alpha_heuristic_frame_this_id (struct frame_info *this_frame,
1169 void **this_prologue_cache,
1170 struct frame_id *this_id)
1172 struct alpha_heuristic_unwind_cache *info
1173 = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
1175 *this_id = frame_id_build (info->vfp, info->start_pc);
1178 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1180 static struct value *
1181 alpha_heuristic_frame_prev_register (struct frame_info *this_frame,
1182 void **this_prologue_cache, int regnum)
1184 struct alpha_heuristic_unwind_cache *info
1185 = alpha_heuristic_frame_unwind_cache (this_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 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1196 static const struct frame_unwind alpha_heuristic_frame_unwind = {
1198 alpha_heuristic_frame_this_id,
1199 alpha_heuristic_frame_prev_register,
1201 default_frame_sniffer
1205 alpha_heuristic_frame_base_address (struct frame_info *this_frame,
1206 void **this_prologue_cache)
1208 struct alpha_heuristic_unwind_cache *info
1209 = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
1214 static const struct frame_base alpha_heuristic_frame_base = {
1215 &alpha_heuristic_frame_unwind,
1216 alpha_heuristic_frame_base_address,
1217 alpha_heuristic_frame_base_address,
1218 alpha_heuristic_frame_base_address
1221 /* Just like reinit_frame_cache, but with the right arguments to be
1222 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1225 reinit_frame_cache_sfunc (char *args, int from_tty, struct cmd_list_element *c)
1227 reinit_frame_cache ();
1231 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1232 dummy frame. The frame ID's base needs to match the TOS value
1233 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1236 static struct frame_id
1237 alpha_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1240 base = get_frame_register_unsigned (this_frame, ALPHA_SP_REGNUM);
1241 return frame_id_build (base, get_frame_pc (this_frame));
1245 alpha_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1248 pc = frame_unwind_register_unsigned (next_frame, ALPHA_PC_REGNUM);
1253 /* Helper routines for alpha*-nat.c files to move register sets to and
1254 from core files. The UNIQUE pointer is allowed to be NULL, as most
1255 targets don't supply this value in their core files. */
1258 alpha_supply_int_regs (struct regcache *regcache, int regno,
1259 const void *r0_r30, const void *pc, const void *unique)
1261 const gdb_byte *regs = r0_r30;
1264 for (i = 0; i < 31; ++i)
1265 if (regno == i || regno == -1)
1266 regcache_raw_supply (regcache, i, regs + i * 8);
1268 if (regno == ALPHA_ZERO_REGNUM || regno == -1)
1269 regcache_raw_supply (regcache, ALPHA_ZERO_REGNUM, NULL);
1271 if (regno == ALPHA_PC_REGNUM || regno == -1)
1272 regcache_raw_supply (regcache, ALPHA_PC_REGNUM, pc);
1274 if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
1275 regcache_raw_supply (regcache, ALPHA_UNIQUE_REGNUM, unique);
1279 alpha_fill_int_regs (const struct regcache *regcache,
1280 int regno, void *r0_r30, void *pc, void *unique)
1282 gdb_byte *regs = r0_r30;
1285 for (i = 0; i < 31; ++i)
1286 if (regno == i || regno == -1)
1287 regcache_raw_collect (regcache, i, regs + i * 8);
1289 if (regno == ALPHA_PC_REGNUM || regno == -1)
1290 regcache_raw_collect (regcache, ALPHA_PC_REGNUM, pc);
1292 if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1))
1293 regcache_raw_collect (regcache, ALPHA_UNIQUE_REGNUM, unique);
1297 alpha_supply_fp_regs (struct regcache *regcache, int regno,
1298 const void *f0_f30, const void *fpcr)
1300 const gdb_byte *regs = f0_f30;
1303 for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1304 if (regno == i || regno == -1)
1305 regcache_raw_supply (regcache, i,
1306 regs + (i - ALPHA_FP0_REGNUM) * 8);
1308 if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1309 regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, fpcr);
1313 alpha_fill_fp_regs (const struct regcache *regcache,
1314 int regno, void *f0_f30, void *fpcr)
1316 gdb_byte *regs = f0_f30;
1319 for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1320 if (regno == i || regno == -1)
1321 regcache_raw_collect (regcache, i,
1322 regs + (i - ALPHA_FP0_REGNUM) * 8);
1324 if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1325 regcache_raw_collect (regcache, ALPHA_FPCR_REGNUM, fpcr);
1330 /* Return nonzero if the G_floating register value in REG is equal to
1331 zero for FP control instructions. */
1334 fp_register_zero_p (LONGEST reg)
1336 /* Check that all bits except the sign bit are zero. */
1337 const LONGEST zero_mask = ((LONGEST) 1 << 63) ^ -1;
1339 return ((reg & zero_mask) == 0);
1342 /* Return the value of the sign bit for the G_floating register
1343 value held in REG. */
1346 fp_register_sign_bit (LONGEST reg)
1348 const LONGEST sign_mask = (LONGEST) 1 << 63;
1350 return ((reg & sign_mask) != 0);
1353 /* alpha_software_single_step() is called just before we want to resume
1354 the inferior, if we want to single-step it but there is no hardware
1355 or kernel single-step support (NetBSD on Alpha, for example). We find
1356 the target of the coming instruction and breakpoint it. */
1359 alpha_next_pc (struct frame_info *frame, CORE_ADDR pc)
1367 insn = alpha_read_insn (pc);
1369 /* Opcode is top 6 bits. */
1370 op = (insn >> 26) & 0x3f;
1374 /* Jump format: target PC is:
1376 return (get_frame_register_unsigned (frame, (insn >> 16) & 0x1f) & ~3);
1379 if ((op & 0x30) == 0x30)
1381 /* Branch format: target PC is:
1382 (new PC) + (4 * sext(displacement)) */
1383 if (op == 0x30 || /* BR */
1384 op == 0x34) /* BSR */
1387 offset = (insn & 0x001fffff);
1388 if (offset & 0x00100000)
1389 offset |= 0xffe00000;
1390 offset *= ALPHA_INSN_SIZE;
1391 return (pc + ALPHA_INSN_SIZE + offset);
1394 /* Need to determine if branch is taken; read RA. */
1395 regno = (insn >> 21) & 0x1f;
1398 case 0x31: /* FBEQ */
1399 case 0x36: /* FBGE */
1400 case 0x37: /* FBGT */
1401 case 0x33: /* FBLE */
1402 case 0x32: /* FBLT */
1403 case 0x35: /* FBNE */
1404 regno += gdbarch_fp0_regnum (get_frame_arch (frame));
1407 rav = get_frame_register_signed (frame, regno);
1411 case 0x38: /* BLBC */
1415 case 0x3c: /* BLBS */
1419 case 0x39: /* BEQ */
1423 case 0x3d: /* BNE */
1427 case 0x3a: /* BLT */
1431 case 0x3b: /* BLE */
1435 case 0x3f: /* BGT */
1439 case 0x3e: /* BGE */
1444 /* Floating point branches. */
1446 case 0x31: /* FBEQ */
1447 if (fp_register_zero_p (rav))
1450 case 0x36: /* FBGE */
1451 if (fp_register_sign_bit (rav) == 0 || fp_register_zero_p (rav))
1454 case 0x37: /* FBGT */
1455 if (fp_register_sign_bit (rav) == 0 && ! fp_register_zero_p (rav))
1458 case 0x33: /* FBLE */
1459 if (fp_register_sign_bit (rav) == 1 || fp_register_zero_p (rav))
1462 case 0x32: /* FBLT */
1463 if (fp_register_sign_bit (rav) == 1 && ! fp_register_zero_p (rav))
1466 case 0x35: /* FBNE */
1467 if (! fp_register_zero_p (rav))
1473 /* Not a branch or branch not taken; target PC is:
1475 return (pc + ALPHA_INSN_SIZE);
1479 alpha_software_single_step (struct frame_info *frame)
1481 struct gdbarch *gdbarch = get_frame_arch (frame);
1482 CORE_ADDR pc, next_pc;
1484 pc = get_frame_pc (frame);
1485 next_pc = alpha_next_pc (frame, pc);
1487 insert_single_step_breakpoint (gdbarch, next_pc);
1492 /* Initialize the current architecture based on INFO. If possible, re-use an
1493 architecture from ARCHES, which is a list of architectures already created
1494 during this debugging session.
1496 Called e.g. at program startup, when reading a core file, and when reading
1499 static struct gdbarch *
1500 alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1502 struct gdbarch_tdep *tdep;
1503 struct gdbarch *gdbarch;
1505 /* Try to determine the ABI of the object we are loading. */
1506 if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
1508 /* If it's an ECOFF file, assume it's OSF/1. */
1509 if (bfd_get_flavour (info.abfd) == bfd_target_ecoff_flavour)
1510 info.osabi = GDB_OSABI_OSF1;
1513 /* Find a candidate among extant architectures. */
1514 arches = gdbarch_list_lookup_by_info (arches, &info);
1516 return arches->gdbarch;
1518 tdep = xmalloc (sizeof (struct gdbarch_tdep));
1519 gdbarch = gdbarch_alloc (&info, tdep);
1521 /* Lowest text address. This is used by heuristic_proc_start()
1522 to decide when to stop looking. */
1523 tdep->vm_min_address = (CORE_ADDR) 0x120000000LL;
1525 tdep->dynamic_sigtramp_offset = NULL;
1526 tdep->sigcontext_addr = NULL;
1527 tdep->sc_pc_offset = 2 * 8;
1528 tdep->sc_regs_offset = 4 * 8;
1529 tdep->sc_fpregs_offset = tdep->sc_regs_offset + 32 * 8 + 8;
1531 tdep->jb_pc = -1; /* longjmp support not enabled by default */
1533 tdep->return_in_memory = alpha_return_in_memory_always;
1536 set_gdbarch_short_bit (gdbarch, 16);
1537 set_gdbarch_int_bit (gdbarch, 32);
1538 set_gdbarch_long_bit (gdbarch, 64);
1539 set_gdbarch_long_long_bit (gdbarch, 64);
1540 set_gdbarch_float_bit (gdbarch, 32);
1541 set_gdbarch_double_bit (gdbarch, 64);
1542 set_gdbarch_long_double_bit (gdbarch, 64);
1543 set_gdbarch_ptr_bit (gdbarch, 64);
1546 set_gdbarch_num_regs (gdbarch, ALPHA_NUM_REGS);
1547 set_gdbarch_sp_regnum (gdbarch, ALPHA_SP_REGNUM);
1548 set_gdbarch_pc_regnum (gdbarch, ALPHA_PC_REGNUM);
1549 set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM);
1551 set_gdbarch_register_name (gdbarch, alpha_register_name);
1552 set_gdbarch_register_type (gdbarch, alpha_register_type);
1554 set_gdbarch_cannot_fetch_register (gdbarch, alpha_cannot_fetch_register);
1555 set_gdbarch_cannot_store_register (gdbarch, alpha_cannot_store_register);
1557 set_gdbarch_convert_register_p (gdbarch, alpha_convert_register_p);
1558 set_gdbarch_register_to_value (gdbarch, alpha_register_to_value);
1559 set_gdbarch_value_to_register (gdbarch, alpha_value_to_register);
1561 set_gdbarch_register_reggroup_p (gdbarch, alpha_register_reggroup_p);
1563 /* Prologue heuristics. */
1564 set_gdbarch_skip_prologue (gdbarch, alpha_skip_prologue);
1567 set_gdbarch_print_insn (gdbarch, print_insn_alpha);
1571 set_gdbarch_return_value (gdbarch, alpha_return_value);
1573 /* Settings for calling functions in the inferior. */
1574 set_gdbarch_push_dummy_call (gdbarch, alpha_push_dummy_call);
1576 /* Methods for saving / extracting a dummy frame's ID. */
1577 set_gdbarch_dummy_id (gdbarch, alpha_dummy_id);
1579 /* Return the unwound PC value. */
1580 set_gdbarch_unwind_pc (gdbarch, alpha_unwind_pc);
1582 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1583 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1585 set_gdbarch_breakpoint_from_pc (gdbarch, alpha_breakpoint_from_pc);
1586 set_gdbarch_decr_pc_after_break (gdbarch, ALPHA_INSN_SIZE);
1587 set_gdbarch_cannot_step_breakpoint (gdbarch, 1);
1589 /* Hook in ABI-specific overrides, if they have been registered. */
1590 gdbarch_init_osabi (info, gdbarch);
1592 /* Now that we have tuned the configuration, set a few final things
1593 based on what the OS ABI has told us. */
1595 if (tdep->jb_pc >= 0)
1596 set_gdbarch_get_longjmp_target (gdbarch, alpha_get_longjmp_target);
1598 frame_unwind_append_unwinder (gdbarch, &alpha_sigtramp_frame_unwind);
1599 frame_unwind_append_unwinder (gdbarch, &alpha_heuristic_frame_unwind);
1601 frame_base_set_default (gdbarch, &alpha_heuristic_frame_base);
1607 alpha_dwarf2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1609 dwarf2_append_unwinders (gdbarch);
1610 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
1613 extern initialize_file_ftype _initialize_alpha_tdep; /* -Wmissing-prototypes */
1616 _initialize_alpha_tdep (void)
1618 struct cmd_list_element *c;
1620 gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, NULL);
1622 /* Let the user set the fence post for heuristic_proc_start. */
1624 /* We really would like to have both "0" and "unlimited" work, but
1625 command.c doesn't deal with that. So make it a var_zinteger
1626 because the user can always use "999999" or some such for unlimited. */
1627 /* We need to throw away the frame cache when we set this, since it
1628 might change our ability to get backtraces. */
1629 add_setshow_zinteger_cmd ("heuristic-fence-post", class_support,
1630 &heuristic_fence_post, _("\
1631 Set the distance searched for the start of a function."), _("\
1632 Show the distance searched for the start of a function."), _("\
1633 If you are debugging a stripped executable, GDB needs to search through the\n\
1634 program for the start of a function. This command sets the distance of the\n\
1635 search. The only need to set it is when debugging a stripped executable."),
1636 reinit_frame_cache_sfunc,
1637 NULL, /* FIXME: i18n: The distance searched for the start of a function is \"%d\". */
1638 &setlist, &showlist);