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 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_void_data_ptr;
99 if (regno == ALPHA_PC_REGNUM)
100 return builtin_type_void_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_ieee_double;
107 return builtin_type_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_int32;
302 arg = value_cast (arg_type, arg);
304 if (TYPE_LENGTH (arg_type) < ALPHA_REGISTER_SIZE)
306 arg_type = builtin_type_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_ieee_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 int length = TYPE_LENGTH (valtype);
502 gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
505 switch (TYPE_CODE (valtype))
511 alpha_lds (raw_buffer, valbuf);
512 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, raw_buffer);
516 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
520 /* FIXME: 128-bit long doubles are returned like structures:
521 by writing into indirect storage provided by the caller
522 as the first argument. */
523 error (_("Cannot set a 128-bit long double return value."));
526 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
530 case TYPE_CODE_COMPLEX:
534 /* ??? This isn't correct wrt the ABI, but it's what GCC does. */
535 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
539 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
540 regcache_cooked_write (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8);
544 /* FIXME: 128-bit long doubles are returned like structures:
545 by writing into indirect storage provided by the caller
546 as the first argument. */
547 error (_("Cannot set a 128-bit long double return value."));
550 internal_error (__FILE__, __LINE__, _("unknown floating point width"));
555 /* Assume everything else degenerates to an integer. */
556 /* 32-bit values must be sign-extended to 64 bits
557 even if the base data type is unsigned. */
559 valtype = builtin_type_int32;
560 l = unpack_long (valtype, valbuf);
561 regcache_cooked_write_unsigned (regcache, ALPHA_V0_REGNUM, l);
566 static enum return_value_convention
567 alpha_return_value (struct gdbarch *gdbarch, struct type *func_type,
568 struct type *type, struct regcache *regcache,
569 gdb_byte *readbuf, const gdb_byte *writebuf)
571 enum type_code code = TYPE_CODE (type);
573 if ((code == TYPE_CODE_STRUCT
574 || code == TYPE_CODE_UNION
575 || code == TYPE_CODE_ARRAY)
576 && gdbarch_tdep (gdbarch)->return_in_memory (type))
581 regcache_raw_read_unsigned (regcache, ALPHA_V0_REGNUM, &addr);
582 read_memory (addr, readbuf, TYPE_LENGTH (type));
585 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
589 alpha_extract_return_value (type, regcache, readbuf);
591 alpha_store_return_value (type, regcache, writebuf);
593 return RETURN_VALUE_REGISTER_CONVENTION;
597 alpha_return_in_memory_always (struct type *type)
602 static const gdb_byte *
603 alpha_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
605 static const gdb_byte break_insn[] = { 0x80, 0, 0, 0 }; /* call_pal bpt */
607 *len = sizeof(break_insn);
612 /* This returns the PC of the first insn after the prologue.
613 If we can't find the prologue, then return 0. */
616 alpha_after_prologue (CORE_ADDR pc)
618 struct symtab_and_line sal;
619 CORE_ADDR func_addr, func_end;
621 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
624 sal = find_pc_line (func_addr, 0);
625 if (sal.end < func_end)
628 /* The line after the prologue is after the end of the function. In this
629 case, tell the caller to find the prologue the hard way. */
633 /* Read an instruction from memory at PC, looking through breakpoints. */
636 alpha_read_insn (CORE_ADDR pc)
638 gdb_byte buf[ALPHA_INSN_SIZE];
641 status = target_read_memory (pc, buf, sizeof (buf));
643 memory_error (status, pc);
644 return extract_unsigned_integer (buf, sizeof (buf));
647 /* To skip prologues, I use this predicate. Returns either PC itself
648 if the code at PC does not look like a function prologue; otherwise
649 returns an address that (if we're lucky) follows the prologue. If
650 LENIENT, then we must skip everything which is involved in setting
651 up the frame (it's OK to skip more, just so long as we don't skip
652 anything which might clobber the registers which are being saved. */
655 alpha_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
659 CORE_ADDR post_prologue_pc;
660 gdb_byte buf[ALPHA_INSN_SIZE];
662 /* Silently return the unaltered pc upon memory errors.
663 This could happen on OSF/1 if decode_line_1 tries to skip the
664 prologue for quickstarted shared library functions when the
665 shared library is not yet mapped in.
666 Reading target memory is slow over serial lines, so we perform
667 this check only if the target has shared libraries (which all
668 Alpha targets do). */
669 if (target_read_memory (pc, buf, sizeof (buf)))
672 /* See if we can determine the end of the prologue via the symbol table.
673 If so, then return either PC, or the PC after the prologue, whichever
676 post_prologue_pc = alpha_after_prologue (pc);
677 if (post_prologue_pc != 0)
678 return max (pc, post_prologue_pc);
680 /* Can't determine prologue from the symbol table, need to examine
683 /* Skip the typical prologue instructions. These are the stack adjustment
684 instruction and the instructions that save registers on the stack
685 or in the gcc frame. */
686 for (offset = 0; offset < 100; offset += ALPHA_INSN_SIZE)
688 inst = alpha_read_insn (pc + offset);
690 if ((inst & 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
692 if ((inst & 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
694 if ((inst & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
696 if ((inst & 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
699 if (((inst & 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
700 || (inst & 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
701 && (inst & 0x03e00000) != 0x03e00000) /* reg != $zero */
704 if (inst == 0x47de040f) /* bis sp,sp,fp */
706 if (inst == 0x47fe040f) /* bis zero,sp,fp */
715 /* Figure out where the longjmp will land.
716 We expect the first arg to be a pointer to the jmp_buf structure from
717 which we extract the PC (JB_PC) that we will land at. The PC is copied
718 into the "pc". This routine returns true on success. */
721 alpha_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
723 struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
725 gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
727 jb_addr = get_frame_register_unsigned (frame, ALPHA_A0_REGNUM);
729 if (target_read_memory (jb_addr + (tdep->jb_pc * tdep->jb_elt_size),
730 raw_buffer, tdep->jb_elt_size))
733 *pc = extract_unsigned_integer (raw_buffer, tdep->jb_elt_size);
738 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
739 describe the location and shape of the sigcontext structure. After
740 that, all registers are in memory, so it's easy. */
741 /* ??? Shouldn't we be able to do this generically, rather than with
742 OSABI data specific to Alpha? */
744 struct alpha_sigtramp_unwind_cache
746 CORE_ADDR sigcontext_addr;
749 static struct alpha_sigtramp_unwind_cache *
750 alpha_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
751 void **this_prologue_cache)
753 struct alpha_sigtramp_unwind_cache *info;
754 struct gdbarch_tdep *tdep;
756 if (*this_prologue_cache)
757 return *this_prologue_cache;
759 info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache);
760 *this_prologue_cache = info;
762 tdep = gdbarch_tdep (get_frame_arch (next_frame));
763 info->sigcontext_addr = tdep->sigcontext_addr (next_frame);
768 /* Return the address of REGNUM in a sigtramp frame. Since this is
769 all arithmetic, it doesn't seem worthwhile to cache it. */
772 alpha_sigtramp_register_address (struct gdbarch *gdbarch,
773 CORE_ADDR sigcontext_addr, int regnum)
775 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
777 if (regnum >= 0 && regnum < 32)
778 return sigcontext_addr + tdep->sc_regs_offset + regnum * 8;
779 else if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 32)
780 return sigcontext_addr + tdep->sc_fpregs_offset + regnum * 8;
781 else if (regnum == ALPHA_PC_REGNUM)
782 return sigcontext_addr + tdep->sc_pc_offset;
787 /* Given a GDB frame, determine the address of the calling function's
788 frame. This will be used to create a new GDB frame struct. */
791 alpha_sigtramp_frame_this_id (struct frame_info *next_frame,
792 void **this_prologue_cache,
793 struct frame_id *this_id)
795 struct gdbarch *gdbarch = get_frame_arch (next_frame);
796 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
797 struct alpha_sigtramp_unwind_cache *info
798 = alpha_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
799 CORE_ADDR stack_addr, code_addr;
801 /* If the OSABI couldn't locate the sigcontext, give up. */
802 if (info->sigcontext_addr == 0)
805 /* If we have dynamic signal trampolines, find their start.
806 If we do not, then we must assume there is a symbol record
807 that can provide the start address. */
808 if (tdep->dynamic_sigtramp_offset)
811 code_addr = frame_pc_unwind (next_frame);
812 offset = tdep->dynamic_sigtramp_offset (code_addr);
819 code_addr = frame_func_unwind (next_frame, SIGTRAMP_FRAME);
821 /* The stack address is trivially read from the sigcontext. */
822 stack_addr = alpha_sigtramp_register_address (gdbarch, info->sigcontext_addr,
824 stack_addr = get_frame_memory_unsigned (next_frame, stack_addr,
825 ALPHA_REGISTER_SIZE);
827 *this_id = frame_id_build (stack_addr, code_addr);
830 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
833 alpha_sigtramp_frame_prev_register (struct frame_info *next_frame,
834 void **this_prologue_cache,
835 int regnum, int *optimizedp,
836 enum lval_type *lvalp, CORE_ADDR *addrp,
837 int *realnump, gdb_byte *bufferp)
839 struct alpha_sigtramp_unwind_cache *info
840 = alpha_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
843 if (info->sigcontext_addr != 0)
845 /* All integer and fp registers are stored in memory. */
846 addr = alpha_sigtramp_register_address (get_frame_arch (next_frame),
847 info->sigcontext_addr, regnum);
851 *lvalp = lval_memory;
855 get_frame_memory (next_frame, addr, bufferp, ALPHA_REGISTER_SIZE);
860 /* This extra register may actually be in the sigcontext, but our
861 current description of it in alpha_sigtramp_frame_unwind_cache
862 doesn't include it. Too bad. Fall back on whatever's in the
865 *lvalp = lval_register;
869 frame_unwind_register (next_frame, *realnump, bufferp);
872 static const struct frame_unwind alpha_sigtramp_frame_unwind = {
874 alpha_sigtramp_frame_this_id,
875 alpha_sigtramp_frame_prev_register
878 static const struct frame_unwind *
879 alpha_sigtramp_frame_sniffer (struct frame_info *next_frame)
881 struct gdbarch *gdbarch = get_frame_arch (next_frame);
882 CORE_ADDR pc = frame_pc_unwind (next_frame);
885 /* NOTE: cagney/2004-04-30: Do not copy/clone this code. Instead
886 look at tramp-frame.h and other simplier per-architecture
887 sigtramp unwinders. */
889 /* We shouldn't even bother to try if the OSABI didn't register a
890 sigcontext_addr handler or pc_in_sigtramp hander. */
891 if (gdbarch_tdep (gdbarch)->sigcontext_addr == NULL)
893 if (gdbarch_tdep (gdbarch)->pc_in_sigtramp == NULL)
896 /* Otherwise we should be in a signal frame. */
897 find_pc_partial_function (pc, &name, NULL, NULL);
898 if (gdbarch_tdep (gdbarch)->pc_in_sigtramp (pc, name))
899 return &alpha_sigtramp_frame_unwind;
905 /* Heuristic_proc_start may hunt through the text section for a long
906 time across a 2400 baud serial line. Allows the user to limit this
908 static unsigned int heuristic_fence_post = 0;
910 /* Attempt to locate the start of the function containing PC. We assume that
911 the previous function ends with an about_to_return insn. Not foolproof by
912 any means, since gcc is happy to put the epilogue in the middle of a
913 function. But we're guessing anyway... */
916 alpha_heuristic_proc_start (struct gdbarch *gdbarch, CORE_ADDR pc)
918 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
919 CORE_ADDR last_non_nop = pc;
920 CORE_ADDR fence = pc - heuristic_fence_post;
921 CORE_ADDR orig_pc = pc;
927 /* First see if we can find the start of the function from minimal
928 symbol information. This can succeed with a binary that doesn't
929 have debug info, but hasn't been stripped. */
930 func = get_pc_function_start (pc);
934 if (heuristic_fence_post == UINT_MAX
935 || fence < tdep->vm_min_address)
936 fence = tdep->vm_min_address;
938 /* Search back for previous return; also stop at a 0, which might be
939 seen for instance before the start of a code section. Don't include
940 nops, since this usually indicates padding between functions. */
941 for (pc -= ALPHA_INSN_SIZE; pc >= fence; pc -= ALPHA_INSN_SIZE)
943 unsigned int insn = alpha_read_insn (pc);
946 case 0: /* invalid insn */
947 case 0x6bfa8001: /* ret $31,($26),1 */
950 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
951 case 0x47ff041f: /* nop: bis $31,$31,$31 */
960 /* It's not clear to me why we reach this point when stopping quietly,
961 but with this test, at least we don't print out warnings for every
962 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
963 if (stop_soon == NO_STOP_QUIETLY)
965 static int blurb_printed = 0;
967 if (fence == tdep->vm_min_address)
968 warning (_("Hit beginning of text section without finding \
969 enclosing function for address 0x%s"), paddr_nz (orig_pc));
971 warning (_("Hit heuristic-fence-post without finding \
972 enclosing function for address 0x%s"), paddr_nz (orig_pc));
976 printf_filtered (_("\
977 This warning occurs if you are debugging a function without any symbols\n\
978 (for example, in a stripped executable). In that case, you may wish to\n\
979 increase the size of the search with the `set heuristic-fence-post' command.\n\
981 Otherwise, you told GDB there was a function where there isn't one, or\n\
982 (more likely) you have encountered a bug in GDB.\n"));
990 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
991 something about the traditional layout of alpha stack frames. */
993 struct alpha_heuristic_unwind_cache
997 struct trad_frame_saved_reg *saved_regs;
1001 static struct alpha_heuristic_unwind_cache *
1002 alpha_heuristic_frame_unwind_cache (struct frame_info *next_frame,
1003 void **this_prologue_cache,
1006 struct gdbarch *gdbarch = get_frame_arch (next_frame);
1007 struct alpha_heuristic_unwind_cache *info;
1009 CORE_ADDR limit_pc, cur_pc;
1010 int frame_reg, frame_size, return_reg, reg;
1012 if (*this_prologue_cache)
1013 return *this_prologue_cache;
1015 info = FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache);
1016 *this_prologue_cache = info;
1017 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1019 limit_pc = frame_pc_unwind (next_frame);
1021 start_pc = alpha_heuristic_proc_start (gdbarch, limit_pc);
1022 info->start_pc = start_pc;
1024 frame_reg = ALPHA_SP_REGNUM;
1028 /* If we've identified a likely place to start, do code scanning. */
1031 /* Limit the forward search to 50 instructions. */
1032 if (start_pc + 200 < limit_pc)
1033 limit_pc = start_pc + 200;
1035 for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += ALPHA_INSN_SIZE)
1037 unsigned int word = alpha_read_insn (cur_pc);
1039 if ((word & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1043 /* Consider only the first stack allocation instruction
1044 to contain the static size of the frame. */
1045 if (frame_size == 0)
1046 frame_size = (-word) & 0xffff;
1050 /* Exit loop if a positive stack adjustment is found, which
1051 usually means that the stack cleanup code in the function
1052 epilogue is reached. */
1056 else if ((word & 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1058 reg = (word & 0x03e00000) >> 21;
1060 /* Ignore this instruction if we have already encountered
1061 an instruction saving the same register earlier in the
1062 function code. The current instruction does not tell
1063 us where the original value upon function entry is saved.
1064 All it says is that the function we are scanning reused
1065 that register for some computation of its own, and is now
1066 saving its result. */
1067 if (trad_frame_addr_p(info->saved_regs, reg))
1073 /* Do not compute the address where the register was saved yet,
1074 because we don't know yet if the offset will need to be
1075 relative to $sp or $fp (we can not compute the address
1076 relative to $sp if $sp is updated during the execution of
1077 the current subroutine, for instance when doing some alloca).
1078 So just store the offset for the moment, and compute the
1079 address later when we know whether this frame has a frame
1081 /* Hack: temporarily add one, so that the offset is non-zero
1082 and we can tell which registers have save offsets below. */
1083 info->saved_regs[reg].addr = (word & 0xffff) + 1;
1085 /* Starting with OSF/1-3.2C, the system libraries are shipped
1086 without local symbols, but they still contain procedure
1087 descriptors without a symbol reference. GDB is currently
1088 unable to find these procedure descriptors and uses
1089 heuristic_proc_desc instead.
1090 As some low level compiler support routines (__div*, __add*)
1091 use a non-standard return address register, we have to
1092 add some heuristics to determine the return address register,
1093 or stepping over these routines will fail.
1094 Usually the return address register is the first register
1095 saved on the stack, but assembler optimization might
1096 rearrange the register saves.
1097 So we recognize only a few registers (t7, t9, ra) within
1098 the procedure prologue as valid return address registers.
1099 If we encounter a return instruction, we extract the
1100 the return address register from it.
1102 FIXME: Rewriting GDB to access the procedure descriptors,
1103 e.g. via the minimal symbol table, might obviate this hack. */
1104 if (return_reg == -1
1105 && cur_pc < (start_pc + 80)
1106 && (reg == ALPHA_T7_REGNUM
1107 || reg == ALPHA_T9_REGNUM
1108 || reg == ALPHA_RA_REGNUM))
1111 else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1112 return_reg = (word >> 16) & 0x1f;
1113 else if (word == 0x47de040f) /* bis sp,sp,fp */
1114 frame_reg = ALPHA_GCC_FP_REGNUM;
1115 else if (word == 0x47fe040f) /* bis zero,sp,fp */
1116 frame_reg = ALPHA_GCC_FP_REGNUM;
1119 /* If we haven't found a valid return address register yet, keep
1120 searching in the procedure prologue. */
1121 if (return_reg == -1)
1123 while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80))
1125 unsigned int word = alpha_read_insn (cur_pc);
1127 if ((word & 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
1129 reg = (word & 0x03e00000) >> 21;
1130 if (reg == ALPHA_T7_REGNUM
1131 || reg == ALPHA_T9_REGNUM
1132 || reg == ALPHA_RA_REGNUM)
1138 else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1140 return_reg = (word >> 16) & 0x1f;
1144 cur_pc += ALPHA_INSN_SIZE;
1149 /* Failing that, do default to the customary RA. */
1150 if (return_reg == -1)
1151 return_reg = ALPHA_RA_REGNUM;
1152 info->return_reg = return_reg;
1154 val = frame_unwind_register_unsigned (next_frame, frame_reg);
1155 info->vfp = val + frame_size;
1157 /* Convert offsets to absolute addresses. See above about adding
1158 one to the offsets to make all detected offsets non-zero. */
1159 for (reg = 0; reg < ALPHA_NUM_REGS; ++reg)
1160 if (trad_frame_addr_p(info->saved_regs, reg))
1161 info->saved_regs[reg].addr += val - 1;
1166 /* Given a GDB frame, determine the address of the calling function's
1167 frame. This will be used to create a new GDB frame struct. */
1170 alpha_heuristic_frame_this_id (struct frame_info *next_frame,
1171 void **this_prologue_cache,
1172 struct frame_id *this_id)
1174 struct alpha_heuristic_unwind_cache *info
1175 = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
1177 *this_id = frame_id_build (info->vfp, info->start_pc);
1180 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1183 alpha_heuristic_frame_prev_register (struct frame_info *next_frame,
1184 void **this_prologue_cache,
1185 int regnum, int *optimizedp,
1186 enum lval_type *lvalp, CORE_ADDR *addrp,
1187 int *realnump, gdb_byte *bufferp)
1189 struct alpha_heuristic_unwind_cache *info
1190 = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
1192 /* The PC of the previous frame is stored in the link register of
1193 the current frame. Frob regnum so that we pull the value from
1194 the correct place. */
1195 if (regnum == ALPHA_PC_REGNUM)
1196 regnum = info->return_reg;
1198 trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
1199 optimizedp, lvalp, addrp, realnump, bufferp);
1202 static const struct frame_unwind alpha_heuristic_frame_unwind = {
1204 alpha_heuristic_frame_this_id,
1205 alpha_heuristic_frame_prev_register
1208 static const struct frame_unwind *
1209 alpha_heuristic_frame_sniffer (struct frame_info *next_frame)
1211 return &alpha_heuristic_frame_unwind;
1215 alpha_heuristic_frame_base_address (struct frame_info *next_frame,
1216 void **this_prologue_cache)
1218 struct alpha_heuristic_unwind_cache *info
1219 = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
1224 static const struct frame_base alpha_heuristic_frame_base = {
1225 &alpha_heuristic_frame_unwind,
1226 alpha_heuristic_frame_base_address,
1227 alpha_heuristic_frame_base_address,
1228 alpha_heuristic_frame_base_address
1231 /* Just like reinit_frame_cache, but with the right arguments to be
1232 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1235 reinit_frame_cache_sfunc (char *args, int from_tty, struct cmd_list_element *c)
1237 reinit_frame_cache ();
1241 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1242 dummy frame. The frame ID's base needs to match the TOS value
1243 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1246 static struct frame_id
1247 alpha_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
1250 base = frame_unwind_register_unsigned (next_frame, ALPHA_SP_REGNUM);
1251 return frame_id_build (base, frame_pc_unwind (next_frame));
1255 alpha_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1258 pc = frame_unwind_register_unsigned (next_frame, ALPHA_PC_REGNUM);
1263 /* Helper routines for alpha*-nat.c files to move register sets to and
1264 from core files. The UNIQUE pointer is allowed to be NULL, as most
1265 targets don't supply this value in their core files. */
1268 alpha_supply_int_regs (struct regcache *regcache, int regno,
1269 const void *r0_r30, const void *pc, const void *unique)
1271 const gdb_byte *regs = r0_r30;
1274 for (i = 0; i < 31; ++i)
1275 if (regno == i || regno == -1)
1276 regcache_raw_supply (regcache, i, regs + i * 8);
1278 if (regno == ALPHA_ZERO_REGNUM || regno == -1)
1279 regcache_raw_supply (regcache, ALPHA_ZERO_REGNUM, NULL);
1281 if (regno == ALPHA_PC_REGNUM || regno == -1)
1282 regcache_raw_supply (regcache, ALPHA_PC_REGNUM, pc);
1284 if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
1285 regcache_raw_supply (regcache, ALPHA_UNIQUE_REGNUM, unique);
1289 alpha_fill_int_regs (const struct regcache *regcache,
1290 int regno, void *r0_r30, void *pc, void *unique)
1292 gdb_byte *regs = r0_r30;
1295 for (i = 0; i < 31; ++i)
1296 if (regno == i || regno == -1)
1297 regcache_raw_collect (regcache, i, regs + i * 8);
1299 if (regno == ALPHA_PC_REGNUM || regno == -1)
1300 regcache_raw_collect (regcache, ALPHA_PC_REGNUM, pc);
1302 if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1))
1303 regcache_raw_collect (regcache, ALPHA_UNIQUE_REGNUM, unique);
1307 alpha_supply_fp_regs (struct regcache *regcache, int regno,
1308 const void *f0_f30, const void *fpcr)
1310 const gdb_byte *regs = f0_f30;
1313 for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1314 if (regno == i || regno == -1)
1315 regcache_raw_supply (regcache, i,
1316 regs + (i - ALPHA_FP0_REGNUM) * 8);
1318 if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1319 regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, fpcr);
1323 alpha_fill_fp_regs (const struct regcache *regcache,
1324 int regno, void *f0_f30, void *fpcr)
1326 gdb_byte *regs = f0_f30;
1329 for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1330 if (regno == i || regno == -1)
1331 regcache_raw_collect (regcache, i,
1332 regs + (i - ALPHA_FP0_REGNUM) * 8);
1334 if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1335 regcache_raw_collect (regcache, ALPHA_FPCR_REGNUM, fpcr);
1340 /* Return nonzero if the G_floating register value in REG is equal to
1341 zero for FP control instructions. */
1344 fp_register_zero_p (LONGEST reg)
1346 /* Check that all bits except the sign bit are zero. */
1347 const LONGEST zero_mask = ((LONGEST) 1 << 63) ^ -1;
1349 return ((reg & zero_mask) == 0);
1352 /* Return the value of the sign bit for the G_floating register
1353 value held in REG. */
1356 fp_register_sign_bit (LONGEST reg)
1358 const LONGEST sign_mask = (LONGEST) 1 << 63;
1360 return ((reg & sign_mask) != 0);
1363 /* alpha_software_single_step() is called just before we want to resume
1364 the inferior, if we want to single-step it but there is no hardware
1365 or kernel single-step support (NetBSD on Alpha, for example). We find
1366 the target of the coming instruction and breakpoint it. */
1369 alpha_next_pc (struct frame_info *frame, CORE_ADDR pc)
1377 insn = alpha_read_insn (pc);
1379 /* Opcode is top 6 bits. */
1380 op = (insn >> 26) & 0x3f;
1384 /* Jump format: target PC is:
1386 return (get_frame_register_unsigned (frame, (insn >> 16) & 0x1f) & ~3);
1389 if ((op & 0x30) == 0x30)
1391 /* Branch format: target PC is:
1392 (new PC) + (4 * sext(displacement)) */
1393 if (op == 0x30 || /* BR */
1394 op == 0x34) /* BSR */
1397 offset = (insn & 0x001fffff);
1398 if (offset & 0x00100000)
1399 offset |= 0xffe00000;
1400 offset *= ALPHA_INSN_SIZE;
1401 return (pc + ALPHA_INSN_SIZE + offset);
1404 /* Need to determine if branch is taken; read RA. */
1405 regno = (insn >> 21) & 0x1f;
1408 case 0x31: /* FBEQ */
1409 case 0x36: /* FBGE */
1410 case 0x37: /* FBGT */
1411 case 0x33: /* FBLE */
1412 case 0x32: /* FBLT */
1413 case 0x35: /* FBNE */
1414 regno += gdbarch_fp0_regnum (get_frame_arch (frame));
1417 rav = get_frame_register_signed (frame, regno);
1421 case 0x38: /* BLBC */
1425 case 0x3c: /* BLBS */
1429 case 0x39: /* BEQ */
1433 case 0x3d: /* BNE */
1437 case 0x3a: /* BLT */
1441 case 0x3b: /* BLE */
1445 case 0x3f: /* BGT */
1449 case 0x3e: /* BGE */
1454 /* Floating point branches. */
1456 case 0x31: /* FBEQ */
1457 if (fp_register_zero_p (rav))
1460 case 0x36: /* FBGE */
1461 if (fp_register_sign_bit (rav) == 0 || fp_register_zero_p (rav))
1464 case 0x37: /* FBGT */
1465 if (fp_register_sign_bit (rav) == 0 && ! fp_register_zero_p (rav))
1468 case 0x33: /* FBLE */
1469 if (fp_register_sign_bit (rav) == 1 || fp_register_zero_p (rav))
1472 case 0x32: /* FBLT */
1473 if (fp_register_sign_bit (rav) == 1 && ! fp_register_zero_p (rav))
1476 case 0x35: /* FBNE */
1477 if (! fp_register_zero_p (rav))
1483 /* Not a branch or branch not taken; target PC is:
1485 return (pc + ALPHA_INSN_SIZE);
1489 alpha_software_single_step (struct frame_info *frame)
1491 CORE_ADDR pc, next_pc;
1493 pc = get_frame_pc (frame);
1494 next_pc = alpha_next_pc (frame, pc);
1496 insert_single_step_breakpoint (next_pc);
1501 /* Initialize the current architecture based on INFO. If possible, re-use an
1502 architecture from ARCHES, which is a list of architectures already created
1503 during this debugging session.
1505 Called e.g. at program startup, when reading a core file, and when reading
1508 static struct gdbarch *
1509 alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1511 struct gdbarch_tdep *tdep;
1512 struct gdbarch *gdbarch;
1514 /* Try to determine the ABI of the object we are loading. */
1515 if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
1517 /* If it's an ECOFF file, assume it's OSF/1. */
1518 if (bfd_get_flavour (info.abfd) == bfd_target_ecoff_flavour)
1519 info.osabi = GDB_OSABI_OSF1;
1522 /* Find a candidate among extant architectures. */
1523 arches = gdbarch_list_lookup_by_info (arches, &info);
1525 return arches->gdbarch;
1527 tdep = xmalloc (sizeof (struct gdbarch_tdep));
1528 gdbarch = gdbarch_alloc (&info, tdep);
1530 /* Lowest text address. This is used by heuristic_proc_start()
1531 to decide when to stop looking. */
1532 tdep->vm_min_address = (CORE_ADDR) 0x120000000LL;
1534 tdep->dynamic_sigtramp_offset = NULL;
1535 tdep->sigcontext_addr = NULL;
1536 tdep->sc_pc_offset = 2 * 8;
1537 tdep->sc_regs_offset = 4 * 8;
1538 tdep->sc_fpregs_offset = tdep->sc_regs_offset + 32 * 8 + 8;
1540 tdep->jb_pc = -1; /* longjmp support not enabled by default */
1542 tdep->return_in_memory = alpha_return_in_memory_always;
1545 set_gdbarch_short_bit (gdbarch, 16);
1546 set_gdbarch_int_bit (gdbarch, 32);
1547 set_gdbarch_long_bit (gdbarch, 64);
1548 set_gdbarch_long_long_bit (gdbarch, 64);
1549 set_gdbarch_float_bit (gdbarch, 32);
1550 set_gdbarch_double_bit (gdbarch, 64);
1551 set_gdbarch_long_double_bit (gdbarch, 64);
1552 set_gdbarch_ptr_bit (gdbarch, 64);
1555 set_gdbarch_num_regs (gdbarch, ALPHA_NUM_REGS);
1556 set_gdbarch_sp_regnum (gdbarch, ALPHA_SP_REGNUM);
1557 set_gdbarch_pc_regnum (gdbarch, ALPHA_PC_REGNUM);
1558 set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM);
1560 set_gdbarch_register_name (gdbarch, alpha_register_name);
1561 set_gdbarch_register_type (gdbarch, alpha_register_type);
1563 set_gdbarch_cannot_fetch_register (gdbarch, alpha_cannot_fetch_register);
1564 set_gdbarch_cannot_store_register (gdbarch, alpha_cannot_store_register);
1566 set_gdbarch_convert_register_p (gdbarch, alpha_convert_register_p);
1567 set_gdbarch_register_to_value (gdbarch, alpha_register_to_value);
1568 set_gdbarch_value_to_register (gdbarch, alpha_value_to_register);
1570 set_gdbarch_register_reggroup_p (gdbarch, alpha_register_reggroup_p);
1572 /* Prologue heuristics. */
1573 set_gdbarch_skip_prologue (gdbarch, alpha_skip_prologue);
1576 set_gdbarch_print_insn (gdbarch, print_insn_alpha);
1580 set_gdbarch_return_value (gdbarch, alpha_return_value);
1582 /* Settings for calling functions in the inferior. */
1583 set_gdbarch_push_dummy_call (gdbarch, alpha_push_dummy_call);
1585 /* Methods for saving / extracting a dummy frame's ID. */
1586 set_gdbarch_unwind_dummy_id (gdbarch, alpha_unwind_dummy_id);
1588 /* Return the unwound PC value. */
1589 set_gdbarch_unwind_pc (gdbarch, alpha_unwind_pc);
1591 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1592 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1594 set_gdbarch_breakpoint_from_pc (gdbarch, alpha_breakpoint_from_pc);
1595 set_gdbarch_decr_pc_after_break (gdbarch, ALPHA_INSN_SIZE);
1596 set_gdbarch_cannot_step_breakpoint (gdbarch, 1);
1598 /* Hook in ABI-specific overrides, if they have been registered. */
1599 gdbarch_init_osabi (info, gdbarch);
1601 /* Now that we have tuned the configuration, set a few final things
1602 based on what the OS ABI has told us. */
1604 if (tdep->jb_pc >= 0)
1605 set_gdbarch_get_longjmp_target (gdbarch, alpha_get_longjmp_target);
1607 frame_unwind_append_sniffer (gdbarch, alpha_sigtramp_frame_sniffer);
1608 frame_unwind_append_sniffer (gdbarch, alpha_heuristic_frame_sniffer);
1610 frame_base_set_default (gdbarch, &alpha_heuristic_frame_base);
1616 alpha_dwarf2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1618 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
1619 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
1622 extern initialize_file_ftype _initialize_alpha_tdep; /* -Wmissing-prototypes */
1625 _initialize_alpha_tdep (void)
1627 struct cmd_list_element *c;
1629 gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, NULL);
1631 /* Let the user set the fence post for heuristic_proc_start. */
1633 /* We really would like to have both "0" and "unlimited" work, but
1634 command.c doesn't deal with that. So make it a var_zinteger
1635 because the user can always use "999999" or some such for unlimited. */
1636 /* We need to throw away the frame cache when we set this, since it
1637 might change our ability to get backtraces. */
1638 add_setshow_zinteger_cmd ("heuristic-fence-post", class_support,
1639 &heuristic_fence_post, _("\
1640 Set the distance searched for the start of a function."), _("\
1641 Show the distance searched for the start of a function."), _("\
1642 If you are debugging a stripped executable, GDB needs to search through the\n\
1643 program for the start of a function. This command sets the distance of the\n\
1644 search. The only need to set it is when debugging a stripped executable."),
1645 reinit_frame_cache_sfunc,
1646 NULL, /* FIXME: i18n: The distance searched for the start of a function is \"%d\". */
1647 &setlist, &showlist);