alpha-tdep.c/mips-tdep.c: "set heuristic-fence-post" is signed/zinteger.
[external/binutils.git] / gdb / alpha-tdep.c
1 /* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
2
3    Copyright (C) 1993-2013 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "doublest.h"
22 #include "frame.h"
23 #include "frame-unwind.h"
24 #include "frame-base.h"
25 #include "dwarf2-frame.h"
26 #include "inferior.h"
27 #include "symtab.h"
28 #include "value.h"
29 #include "gdbcmd.h"
30 #include "gdbcore.h"
31 #include "dis-asm.h"
32 #include "symfile.h"
33 #include "objfiles.h"
34 #include "gdb_string.h"
35 #include "linespec.h"
36 #include "regcache.h"
37 #include "reggroups.h"
38 #include "arch-utils.h"
39 #include "osabi.h"
40 #include "block.h"
41 #include "infcall.h"
42 #include "trad-frame.h"
43
44 #include "elf-bfd.h"
45
46 #include "alpha-tdep.h"
47
48 /* Instruction decoding.  The notations for registers, immediates and
49    opcodes are the same as the one used in Compaq's Alpha architecture
50    handbook.  */
51
52 #define INSN_OPCODE(insn) ((insn & 0xfc000000) >> 26)
53
54 /* Memory instruction format */
55 #define MEM_RA(insn) ((insn & 0x03e00000) >> 21)
56 #define MEM_RB(insn) ((insn & 0x001f0000) >> 16)
57 #define MEM_DISP(insn) \
58   (((insn & 0x8000) == 0) ? (insn & 0xffff) : -((-insn) & 0xffff))
59
60 static const int lda_opcode = 0x08;
61 static const int stq_opcode = 0x2d;
62
63 /* Branch instruction format */
64 #define BR_RA(insn) MEM_RA(insn)
65
66 static const int br_opcode = 0x30;
67 static const int bne_opcode = 0x3d;
68
69 /* Operate instruction format */
70 #define OPR_FUNCTION(insn) ((insn & 0xfe0) >> 5)
71 #define OPR_HAS_IMMEDIATE(insn) ((insn & 0x1000) == 0x1000)
72 #define OPR_RA(insn) MEM_RA(insn)
73 #define OPR_RC(insn) ((insn & 0x1f))
74 #define OPR_LIT(insn) ((insn & 0x1fe000) >> 13)
75
76 static const int subq_opcode = 0x10;
77 static const int subq_function = 0x29;
78
79 \f
80 /* Return the name of the REGNO register.
81
82    An empty name corresponds to a register number that used to
83    be used for a virtual register.  That virtual register has
84    been removed, but the index is still reserved to maintain
85    compatibility with existing remote alpha targets.  */
86
87 static const char *
88 alpha_register_name (struct gdbarch *gdbarch, int regno)
89 {
90   static const char * const register_names[] =
91   {
92     "v0",   "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",
93     "t7",   "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "fp",
94     "a0",   "a1",   "a2",   "a3",   "a4",   "a5",   "t8",   "t9",
95     "t10",  "t11",  "ra",   "t12",  "at",   "gp",   "sp",   "zero",
96     "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7",
97     "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15",
98     "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",
99     "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "fpcr",
100     "pc",   "",     "unique"
101   };
102
103   if (regno < 0)
104     return NULL;
105   if (regno >= ARRAY_SIZE(register_names))
106     return NULL;
107   return register_names[regno];
108 }
109
110 static int
111 alpha_cannot_fetch_register (struct gdbarch *gdbarch, int regno)
112 {
113   return (strlen (alpha_register_name (gdbarch, regno)) == 0);
114 }
115
116 static int
117 alpha_cannot_store_register (struct gdbarch *gdbarch, int regno)
118 {
119   return (regno == ALPHA_ZERO_REGNUM
120           || strlen (alpha_register_name (gdbarch, regno)) == 0);
121 }
122
123 static struct type *
124 alpha_register_type (struct gdbarch *gdbarch, int regno)
125 {
126   if (regno == ALPHA_SP_REGNUM || regno == ALPHA_GP_REGNUM)
127     return builtin_type (gdbarch)->builtin_data_ptr;
128   if (regno == ALPHA_PC_REGNUM)
129     return builtin_type (gdbarch)->builtin_func_ptr;
130
131   /* Don't need to worry about little vs big endian until 
132      some jerk tries to port to alpha-unicosmk.  */
133   if (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31)
134     return builtin_type (gdbarch)->builtin_double;
135
136   return builtin_type (gdbarch)->builtin_int64;
137 }
138
139 /* Is REGNUM a member of REGGROUP?  */
140
141 static int
142 alpha_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
143                            struct reggroup *group)
144 {
145   /* Filter out any registers eliminated, but whose regnum is 
146      reserved for backward compatibility, e.g. the vfp.  */
147   if (gdbarch_register_name (gdbarch, regnum) == NULL
148       || *gdbarch_register_name (gdbarch, regnum) == '\0')
149     return 0;
150
151   if (group == all_reggroup)
152     return 1;
153
154   /* Zero should not be saved or restored.  Technically it is a general
155      register (just as $f31 would be a float if we represented it), but
156      there's no point displaying it during "info regs", so leave it out
157      of all groups except for "all".  */
158   if (regnum == ALPHA_ZERO_REGNUM)
159     return 0;
160
161   /* All other registers are saved and restored.  */
162   if (group == save_reggroup || group == restore_reggroup)
163     return 1;
164
165   /* All other groups are non-overlapping.  */
166
167   /* Since this is really a PALcode memory slot...  */
168   if (regnum == ALPHA_UNIQUE_REGNUM)
169     return group == system_reggroup;
170
171   /* Force the FPCR to be considered part of the floating point state.  */
172   if (regnum == ALPHA_FPCR_REGNUM)
173     return group == float_reggroup;
174
175   if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 31)
176     return group == float_reggroup;
177   else
178     return group == general_reggroup;
179 }
180
181 /* The following represents exactly the conversion performed by
182    the LDS instruction.  This applies to both single-precision
183    floating point and 32-bit integers.  */
184
185 static void
186 alpha_lds (struct gdbarch *gdbarch, void *out, const void *in)
187 {
188   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
189   ULONGEST mem     = extract_unsigned_integer (in, 4, byte_order);
190   ULONGEST frac    = (mem >>  0) & 0x7fffff;
191   ULONGEST sign    = (mem >> 31) & 1;
192   ULONGEST exp_msb = (mem >> 30) & 1;
193   ULONGEST exp_low = (mem >> 23) & 0x7f;
194   ULONGEST exp, reg;
195
196   exp = (exp_msb << 10) | exp_low;
197   if (exp_msb)
198     {
199       if (exp_low == 0x7f)
200         exp = 0x7ff;
201     }
202   else
203     {
204       if (exp_low != 0x00)
205         exp |= 0x380;
206     }
207
208   reg = (sign << 63) | (exp << 52) | (frac << 29);
209   store_unsigned_integer (out, 8, byte_order, reg);
210 }
211
212 /* Similarly, this represents exactly the conversion performed by
213    the STS instruction.  */
214
215 static void
216 alpha_sts (struct gdbarch *gdbarch, void *out, const void *in)
217 {
218   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
219   ULONGEST reg, mem;
220
221   reg = extract_unsigned_integer (in, 8, byte_order);
222   mem = ((reg >> 32) & 0xc0000000) | ((reg >> 29) & 0x3fffffff);
223   store_unsigned_integer (out, 4, byte_order, mem);
224 }
225
226 /* The alpha needs a conversion between register and memory format if the
227    register is a floating point register and memory format is float, as the
228    register format must be double or memory format is an integer with 4
229    bytes or less, as the representation of integers in floating point
230    registers is different.  */
231
232 static int
233 alpha_convert_register_p (struct gdbarch *gdbarch, int regno,
234                           struct type *type)
235 {
236   return (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31
237           && TYPE_LENGTH (type) != 8);
238 }
239
240 static int
241 alpha_register_to_value (struct frame_info *frame, int regnum,
242                          struct type *valtype, gdb_byte *out,
243                         int *optimizedp, int *unavailablep)
244 {
245   struct gdbarch *gdbarch = get_frame_arch (frame);
246   gdb_byte in[MAX_REGISTER_SIZE];
247
248   /* Convert to TYPE.  */
249   if (!get_frame_register_bytes (frame, regnum, 0,
250                                  register_size (gdbarch, regnum),
251                                  in, optimizedp, unavailablep))
252     return 0;
253
254   if (TYPE_LENGTH (valtype) == 4)
255     {
256       alpha_sts (gdbarch, out, in);
257       *optimizedp = *unavailablep = 0;
258       return 1;
259     }
260
261   error (_("Cannot retrieve value from floating point register"));
262 }
263
264 static void
265 alpha_value_to_register (struct frame_info *frame, int regnum,
266                          struct type *valtype, const gdb_byte *in)
267 {
268   gdb_byte out[MAX_REGISTER_SIZE];
269
270   switch (TYPE_LENGTH (valtype))
271     {
272     case 4:
273       alpha_lds (get_frame_arch (frame), out, in);
274       break;
275     default:
276       error (_("Cannot store value in floating point register"));
277     }
278   put_frame_register (frame, regnum, out);
279 }
280
281 \f
282 /* The alpha passes the first six arguments in the registers, the rest on
283    the stack.  The register arguments are stored in ARG_REG_BUFFER, and
284    then moved into the register file; this simplifies the passing of a
285    large struct which extends from the registers to the stack, plus avoids
286    three ptrace invocations per word.
287
288    We don't bother tracking which register values should go in integer
289    regs or fp regs; we load the same values into both.
290
291    If the called function is returning a structure, the address of the
292    structure to be returned is passed as a hidden first argument.  */
293
294 static CORE_ADDR
295 alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
296                        struct regcache *regcache, CORE_ADDR bp_addr,
297                        int nargs, struct value **args, CORE_ADDR sp,
298                        int struct_return, CORE_ADDR struct_addr)
299 {
300   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
301   int i;
302   int accumulate_size = struct_return ? 8 : 0;
303   struct alpha_arg
304     {
305       const gdb_byte *contents;
306       int len;
307       int offset;
308     };
309   struct alpha_arg *alpha_args
310     = (struct alpha_arg *) alloca (nargs * sizeof (struct alpha_arg));
311   struct alpha_arg *m_arg;
312   gdb_byte arg_reg_buffer[ALPHA_REGISTER_SIZE * ALPHA_NUM_ARG_REGS];
313   int required_arg_regs;
314   CORE_ADDR func_addr = find_function_addr (function, NULL);
315
316   /* The ABI places the address of the called function in T12.  */
317   regcache_cooked_write_signed (regcache, ALPHA_T12_REGNUM, func_addr);
318
319   /* Set the return address register to point to the entry point
320      of the program, where a breakpoint lies in wait.  */
321   regcache_cooked_write_signed (regcache, ALPHA_RA_REGNUM, bp_addr);
322
323   /* Lay out the arguments in memory.  */
324   for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
325     {
326       struct value *arg = args[i];
327       struct type *arg_type = check_typedef (value_type (arg));
328
329       /* Cast argument to long if necessary as the compiler does it too.  */
330       switch (TYPE_CODE (arg_type))
331         {
332         case TYPE_CODE_INT:
333         case TYPE_CODE_BOOL:
334         case TYPE_CODE_CHAR:
335         case TYPE_CODE_RANGE:
336         case TYPE_CODE_ENUM:
337           if (TYPE_LENGTH (arg_type) == 4)
338             {
339               /* 32-bit values must be sign-extended to 64 bits
340                  even if the base data type is unsigned.  */
341               arg_type = builtin_type (gdbarch)->builtin_int32;
342               arg = value_cast (arg_type, arg);
343             }
344           if (TYPE_LENGTH (arg_type) < ALPHA_REGISTER_SIZE)
345             {
346               arg_type = builtin_type (gdbarch)->builtin_int64;
347               arg = value_cast (arg_type, arg);
348             }
349           break;
350
351         case TYPE_CODE_FLT:
352           /* "float" arguments loaded in registers must be passed in
353              register format, aka "double".  */
354           if (accumulate_size < sizeof (arg_reg_buffer)
355               && TYPE_LENGTH (arg_type) == 4)
356             {
357               arg_type = builtin_type (gdbarch)->builtin_double;
358               arg = value_cast (arg_type, arg);
359             }
360           /* Tru64 5.1 has a 128-bit long double, and passes this by
361              invisible reference.  No one else uses this data type.  */
362           else if (TYPE_LENGTH (arg_type) == 16)
363             {
364               /* Allocate aligned storage.  */
365               sp = (sp & -16) - 16;
366
367               /* Write the real data into the stack.  */
368               write_memory (sp, value_contents (arg), 16);
369
370               /* Construct the indirection.  */
371               arg_type = lookup_pointer_type (arg_type);
372               arg = value_from_pointer (arg_type, sp);
373             }
374           break;
375
376         case TYPE_CODE_COMPLEX:
377           /* ??? The ABI says that complex values are passed as two
378              separate scalar values.  This distinction only matters
379              for complex float.  However, GCC does not implement this.  */
380
381           /* Tru64 5.1 has a 128-bit long double, and passes this by
382              invisible reference.  */
383           if (TYPE_LENGTH (arg_type) == 32)
384             {
385               /* Allocate aligned storage.  */
386               sp = (sp & -16) - 16;
387
388               /* Write the real data into the stack.  */
389               write_memory (sp, value_contents (arg), 32);
390
391               /* Construct the indirection.  */
392               arg_type = lookup_pointer_type (arg_type);
393               arg = value_from_pointer (arg_type, sp);
394             }
395           break;
396
397         default:
398           break;
399         }
400       m_arg->len = TYPE_LENGTH (arg_type);
401       m_arg->offset = accumulate_size;
402       accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
403       m_arg->contents = value_contents (arg);
404     }
405
406   /* Determine required argument register loads, loading an argument register
407      is expensive as it uses three ptrace calls.  */
408   required_arg_regs = accumulate_size / 8;
409   if (required_arg_regs > ALPHA_NUM_ARG_REGS)
410     required_arg_regs = ALPHA_NUM_ARG_REGS;
411
412   /* Make room for the arguments on the stack.  */
413   if (accumulate_size < sizeof(arg_reg_buffer))
414     accumulate_size = 0;
415   else
416     accumulate_size -= sizeof(arg_reg_buffer);
417   sp -= accumulate_size;
418
419   /* Keep sp aligned to a multiple of 16 as the ABI requires.  */
420   sp &= ~15;
421
422   /* `Push' arguments on the stack.  */
423   for (i = nargs; m_arg--, --i >= 0;)
424     {
425       const gdb_byte *contents = m_arg->contents;
426       int offset = m_arg->offset;
427       int len = m_arg->len;
428
429       /* Copy the bytes destined for registers into arg_reg_buffer.  */
430       if (offset < sizeof(arg_reg_buffer))
431         {
432           if (offset + len <= sizeof(arg_reg_buffer))
433             {
434               memcpy (arg_reg_buffer + offset, contents, len);
435               continue;
436             }
437           else
438             {
439               int tlen = sizeof(arg_reg_buffer) - offset;
440               memcpy (arg_reg_buffer + offset, contents, tlen);
441               offset += tlen;
442               contents += tlen;
443               len -= tlen;
444             }
445         }
446
447       /* Everything else goes to the stack.  */
448       write_memory (sp + offset - sizeof(arg_reg_buffer), contents, len);
449     }
450   if (struct_return)
451     store_unsigned_integer (arg_reg_buffer, ALPHA_REGISTER_SIZE,
452                             byte_order, struct_addr);
453
454   /* Load the argument registers.  */
455   for (i = 0; i < required_arg_regs; i++)
456     {
457       regcache_cooked_write (regcache, ALPHA_A0_REGNUM + i,
458                              arg_reg_buffer + i*ALPHA_REGISTER_SIZE);
459       regcache_cooked_write (regcache, ALPHA_FPA0_REGNUM + i,
460                              arg_reg_buffer + i*ALPHA_REGISTER_SIZE);
461     }
462
463   /* Finally, update the stack pointer.  */
464   regcache_cooked_write_signed (regcache, ALPHA_SP_REGNUM, sp);
465
466   return sp;
467 }
468
469 /* Extract from REGCACHE the value about to be returned from a function
470    and copy it into VALBUF.  */
471
472 static void
473 alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
474                             gdb_byte *valbuf)
475 {
476   struct gdbarch *gdbarch = get_regcache_arch (regcache);
477   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
478   gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
479   ULONGEST l;
480
481   switch (TYPE_CODE (valtype))
482     {
483     case TYPE_CODE_FLT:
484       switch (TYPE_LENGTH (valtype))
485         {
486         case 4:
487           regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, raw_buffer);
488           alpha_sts (gdbarch, valbuf, raw_buffer);
489           break;
490
491         case 8:
492           regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
493           break;
494
495         case 16:
496           regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l);
497           read_memory (l, valbuf, 16);
498           break;
499
500         default:
501           internal_error (__FILE__, __LINE__,
502                           _("unknown floating point width"));
503         }
504       break;
505
506     case TYPE_CODE_COMPLEX:
507       switch (TYPE_LENGTH (valtype))
508         {
509         case 8:
510           /* ??? This isn't correct wrt the ABI, but it's what GCC does.  */
511           regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
512           break;
513
514         case 16:
515           regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf);
516           regcache_cooked_read (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8);
517           break;
518
519         case 32:
520           regcache_cooked_read_signed (regcache, ALPHA_V0_REGNUM, &l);
521           read_memory (l, valbuf, 32);
522           break;
523
524         default:
525           internal_error (__FILE__, __LINE__,
526                           _("unknown floating point width"));
527         }
528       break;
529
530     default:
531       /* Assume everything else degenerates to an integer.  */
532       regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l);
533       store_unsigned_integer (valbuf, TYPE_LENGTH (valtype), byte_order, l);
534       break;
535     }
536 }
537
538 /* Insert the given value into REGCACHE as if it was being 
539    returned by a function.  */
540
541 static void
542 alpha_store_return_value (struct type *valtype, struct regcache *regcache,
543                           const gdb_byte *valbuf)
544 {
545   struct gdbarch *gdbarch = get_regcache_arch (regcache);
546   gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
547   ULONGEST l;
548
549   switch (TYPE_CODE (valtype))
550     {
551     case TYPE_CODE_FLT:
552       switch (TYPE_LENGTH (valtype))
553         {
554         case 4:
555           alpha_lds (gdbarch, raw_buffer, valbuf);
556           regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, raw_buffer);
557           break;
558
559         case 8:
560           regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
561           break;
562
563         case 16:
564           /* FIXME: 128-bit long doubles are returned like structures:
565              by writing into indirect storage provided by the caller
566              as the first argument.  */
567           error (_("Cannot set a 128-bit long double return value."));
568
569         default:
570           internal_error (__FILE__, __LINE__,
571                           _("unknown floating point width"));
572         }
573       break;
574
575     case TYPE_CODE_COMPLEX:
576       switch (TYPE_LENGTH (valtype))
577         {
578         case 8:
579           /* ??? This isn't correct wrt the ABI, but it's what GCC does.  */
580           regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
581           break;
582
583         case 16:
584           regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf);
585           regcache_cooked_write (regcache, ALPHA_FP0_REGNUM + 1, valbuf + 8);
586           break;
587
588         case 32:
589           /* FIXME: 128-bit long doubles are returned like structures:
590              by writing into indirect storage provided by the caller
591              as the first argument.  */
592           error (_("Cannot set a 128-bit long double return value."));
593
594         default:
595           internal_error (__FILE__, __LINE__,
596                           _("unknown floating point width"));
597         }
598       break;
599
600     default:
601       /* Assume everything else degenerates to an integer.  */
602       /* 32-bit values must be sign-extended to 64 bits
603          even if the base data type is unsigned.  */
604       if (TYPE_LENGTH (valtype) == 4)
605         valtype = builtin_type (gdbarch)->builtin_int32;
606       l = unpack_long (valtype, valbuf);
607       regcache_cooked_write_unsigned (regcache, ALPHA_V0_REGNUM, l);
608       break;
609     }
610 }
611
612 static enum return_value_convention
613 alpha_return_value (struct gdbarch *gdbarch, struct value *function,
614                     struct type *type, struct regcache *regcache,
615                     gdb_byte *readbuf, const gdb_byte *writebuf)
616 {
617   enum type_code code = TYPE_CODE (type);
618
619   if ((code == TYPE_CODE_STRUCT
620        || code == TYPE_CODE_UNION
621        || code == TYPE_CODE_ARRAY)
622       && gdbarch_tdep (gdbarch)->return_in_memory (type))
623     {
624       if (readbuf)
625         {
626           ULONGEST addr;
627           regcache_raw_read_unsigned (regcache, ALPHA_V0_REGNUM, &addr);
628           read_memory (addr, readbuf, TYPE_LENGTH (type));
629         }
630
631       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
632     }
633
634   if (readbuf)
635     alpha_extract_return_value (type, regcache, readbuf);
636   if (writebuf)
637     alpha_store_return_value (type, regcache, writebuf);
638
639   return RETURN_VALUE_REGISTER_CONVENTION;
640 }
641
642 static int
643 alpha_return_in_memory_always (struct type *type)
644 {
645   return 1;
646 }
647 \f
648 static const gdb_byte *
649 alpha_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
650 {
651   static const gdb_byte break_insn[] = { 0x80, 0, 0, 0 }; /* call_pal bpt */
652
653   *len = sizeof(break_insn);
654   return break_insn;
655 }
656
657 \f
658 /* This returns the PC of the first insn after the prologue.
659    If we can't find the prologue, then return 0.  */
660
661 CORE_ADDR
662 alpha_after_prologue (CORE_ADDR pc)
663 {
664   struct symtab_and_line sal;
665   CORE_ADDR func_addr, func_end;
666
667   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
668     return 0;
669
670   sal = find_pc_line (func_addr, 0);
671   if (sal.end < func_end)
672     return sal.end;
673
674   /* The line after the prologue is after the end of the function.  In this
675      case, tell the caller to find the prologue the hard way.  */
676   return 0;
677 }
678
679 /* Read an instruction from memory at PC, looking through breakpoints.  */
680
681 unsigned int
682 alpha_read_insn (struct gdbarch *gdbarch, CORE_ADDR pc)
683 {
684   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
685   gdb_byte buf[ALPHA_INSN_SIZE];
686   int status;
687
688   status = target_read_memory (pc, buf, sizeof (buf));
689   if (status)
690     memory_error (status, pc);
691   return extract_unsigned_integer (buf, sizeof (buf), byte_order);
692 }
693
694 /* To skip prologues, I use this predicate.  Returns either PC itself
695    if the code at PC does not look like a function prologue; otherwise
696    returns an address that (if we're lucky) follows the prologue.  If
697    LENIENT, then we must skip everything which is involved in setting
698    up the frame (it's OK to skip more, just so long as we don't skip
699    anything which might clobber the registers which are being saved.  */
700
701 static CORE_ADDR
702 alpha_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
703 {
704   unsigned long inst;
705   int offset;
706   CORE_ADDR post_prologue_pc;
707   gdb_byte buf[ALPHA_INSN_SIZE];
708
709   /* Silently return the unaltered pc upon memory errors.
710      This could happen on OSF/1 if decode_line_1 tries to skip the
711      prologue for quickstarted shared library functions when the
712      shared library is not yet mapped in.
713      Reading target memory is slow over serial lines, so we perform
714      this check only if the target has shared libraries (which all
715      Alpha targets do).  */
716   if (target_read_memory (pc, buf, sizeof (buf)))
717     return pc;
718
719   /* See if we can determine the end of the prologue via the symbol table.
720      If so, then return either PC, or the PC after the prologue, whichever
721      is greater.  */
722
723   post_prologue_pc = alpha_after_prologue (pc);
724   if (post_prologue_pc != 0)
725     return max (pc, post_prologue_pc);
726
727   /* Can't determine prologue from the symbol table, need to examine
728      instructions.  */
729
730   /* Skip the typical prologue instructions.  These are the stack adjustment
731      instruction and the instructions that save registers on the stack
732      or in the gcc frame.  */
733   for (offset = 0; offset < 100; offset += ALPHA_INSN_SIZE)
734     {
735       inst = alpha_read_insn (gdbarch, pc + offset);
736
737       if ((inst & 0xffff0000) == 0x27bb0000)    /* ldah $gp,n($t12) */
738         continue;
739       if ((inst & 0xffff0000) == 0x23bd0000)    /* lda $gp,n($gp) */
740         continue;
741       if ((inst & 0xffff0000) == 0x23de0000)    /* lda $sp,n($sp) */
742         continue;
743       if ((inst & 0xffe01fff) == 0x43c0153e)    /* subq $sp,n,$sp */
744         continue;
745
746       if (((inst & 0xfc1f0000) == 0xb41e0000            /* stq reg,n($sp) */
747            || (inst & 0xfc1f0000) == 0x9c1e0000)        /* stt reg,n($sp) */
748           && (inst & 0x03e00000) != 0x03e00000)         /* reg != $zero */
749         continue;
750
751       if (inst == 0x47de040f)                   /* bis sp,sp,fp */
752         continue;
753       if (inst == 0x47fe040f)                   /* bis zero,sp,fp */
754         continue;
755
756       break;
757     }
758   return pc + offset;
759 }
760
761 \f
762 static const int ldl_l_opcode = 0x2a;
763 static const int ldq_l_opcode = 0x2b;
764 static const int stl_c_opcode = 0x2e;
765 static const int stq_c_opcode = 0x2f;
766
767 /* Checks for an atomic sequence of instructions beginning with a LDL_L/LDQ_L
768    instruction and ending with a STL_C/STQ_C instruction.  If such a sequence
769    is found, attempt to step through it.  A breakpoint is placed at the end of 
770    the sequence.  */
771
772 static int 
773 alpha_deal_with_atomic_sequence (struct frame_info *frame)
774 {
775   struct gdbarch *gdbarch = get_frame_arch (frame);
776   struct address_space *aspace = get_frame_address_space (frame);
777   CORE_ADDR pc = get_frame_pc (frame);
778   CORE_ADDR breaks[2] = {-1, -1};
779   CORE_ADDR loc = pc;
780   CORE_ADDR closing_insn; /* Instruction that closes the atomic sequence.  */
781   unsigned int insn = alpha_read_insn (gdbarch, loc);
782   int insn_count;
783   int index;
784   int last_breakpoint = 0; /* Defaults to 0 (no breakpoints placed).  */  
785   const int atomic_sequence_length = 16; /* Instruction sequence length.  */
786   int bc_insn_count = 0; /* Conditional branch instruction count.  */
787
788   /* Assume all atomic sequences start with a LDL_L/LDQ_L instruction.  */
789   if (INSN_OPCODE (insn) != ldl_l_opcode
790       && INSN_OPCODE (insn) != ldq_l_opcode)
791     return 0;
792
793   /* Assume that no atomic sequence is longer than "atomic_sequence_length" 
794      instructions.  */
795   for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
796     {
797       loc += ALPHA_INSN_SIZE;
798       insn = alpha_read_insn (gdbarch, loc);
799
800       /* Assume that there is at most one branch in the atomic
801          sequence.  If a branch is found, put a breakpoint in 
802          its destination address.  */
803       if (INSN_OPCODE (insn) >= br_opcode)
804         {
805           int immediate = (insn & 0x001fffff) << 2;
806
807           immediate = (immediate ^ 0x400000) - 0x400000;
808
809           if (bc_insn_count >= 1)
810             return 0; /* More than one branch found, fallback 
811                          to the standard single-step code.  */
812
813           breaks[1] = loc + ALPHA_INSN_SIZE + immediate;
814
815           bc_insn_count++;
816           last_breakpoint++;
817         }
818
819       if (INSN_OPCODE (insn) == stl_c_opcode
820           || INSN_OPCODE (insn) == stq_c_opcode)
821         break;
822     }
823
824   /* Assume that the atomic sequence ends with a STL_C/STQ_C instruction.  */
825   if (INSN_OPCODE (insn) != stl_c_opcode
826       && INSN_OPCODE (insn) != stq_c_opcode)
827     return 0;
828
829   closing_insn = loc;
830   loc += ALPHA_INSN_SIZE;
831
832   /* Insert a breakpoint right after the end of the atomic sequence.  */
833   breaks[0] = loc;
834
835   /* Check for duplicated breakpoints.  Check also for a breakpoint
836      placed (branch instruction's destination) anywhere in sequence.  */ 
837   if (last_breakpoint
838       && (breaks[1] == breaks[0]
839           || (breaks[1] >= pc && breaks[1] <= closing_insn)))
840     last_breakpoint = 0;
841
842   /* Effectively inserts the breakpoints.  */
843   for (index = 0; index <= last_breakpoint; index++)
844     insert_single_step_breakpoint (gdbarch, aspace, breaks[index]);
845
846   return 1;
847 }
848
849 \f
850 /* Figure out where the longjmp will land.
851    We expect the first arg to be a pointer to the jmp_buf structure from
852    which we extract the PC (JB_PC) that we will land at.  The PC is copied
853    into the "pc".  This routine returns true on success.  */
854
855 static int
856 alpha_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
857 {
858   struct gdbarch *gdbarch = get_frame_arch (frame);
859   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
860   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
861   CORE_ADDR jb_addr;
862   gdb_byte raw_buffer[ALPHA_REGISTER_SIZE];
863
864   jb_addr = get_frame_register_unsigned (frame, ALPHA_A0_REGNUM);
865
866   if (target_read_memory (jb_addr + (tdep->jb_pc * tdep->jb_elt_size),
867                           raw_buffer, tdep->jb_elt_size))
868     return 0;
869
870   *pc = extract_unsigned_integer (raw_buffer, tdep->jb_elt_size, byte_order);
871   return 1;
872 }
873
874 \f
875 /* Frame unwinder for signal trampolines.  We use alpha tdep bits that
876    describe the location and shape of the sigcontext structure.  After
877    that, all registers are in memory, so it's easy.  */
878 /* ??? Shouldn't we be able to do this generically, rather than with
879    OSABI data specific to Alpha?  */
880
881 struct alpha_sigtramp_unwind_cache
882 {
883   CORE_ADDR sigcontext_addr;
884 };
885
886 static struct alpha_sigtramp_unwind_cache *
887 alpha_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
888                                    void **this_prologue_cache)
889 {
890   struct alpha_sigtramp_unwind_cache *info;
891   struct gdbarch_tdep *tdep;
892
893   if (*this_prologue_cache)
894     return *this_prologue_cache;
895
896   info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache);
897   *this_prologue_cache = info;
898
899   tdep = gdbarch_tdep (get_frame_arch (this_frame));
900   info->sigcontext_addr = tdep->sigcontext_addr (this_frame);
901
902   return info;
903 }
904
905 /* Return the address of REGNUM in a sigtramp frame.  Since this is
906    all arithmetic, it doesn't seem worthwhile to cache it.  */
907
908 static CORE_ADDR
909 alpha_sigtramp_register_address (struct gdbarch *gdbarch,
910                                  CORE_ADDR sigcontext_addr, int regnum)
911
912   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
913
914   if (regnum >= 0 && regnum < 32)
915     return sigcontext_addr + tdep->sc_regs_offset + regnum * 8;
916   else if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 32)
917     return sigcontext_addr + tdep->sc_fpregs_offset + regnum * 8;
918   else if (regnum == ALPHA_PC_REGNUM)
919     return sigcontext_addr + tdep->sc_pc_offset; 
920
921   return 0;
922 }
923
924 /* Given a GDB frame, determine the address of the calling function's
925    frame.  This will be used to create a new GDB frame struct.  */
926
927 static void
928 alpha_sigtramp_frame_this_id (struct frame_info *this_frame,
929                               void **this_prologue_cache,
930                               struct frame_id *this_id)
931 {
932   struct gdbarch *gdbarch = get_frame_arch (this_frame);
933   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
934   struct alpha_sigtramp_unwind_cache *info
935     = alpha_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
936   CORE_ADDR stack_addr, code_addr;
937
938   /* If the OSABI couldn't locate the sigcontext, give up.  */
939   if (info->sigcontext_addr == 0)
940     return;
941
942   /* If we have dynamic signal trampolines, find their start.
943      If we do not, then we must assume there is a symbol record
944      that can provide the start address.  */
945   if (tdep->dynamic_sigtramp_offset)
946     {
947       int offset;
948       code_addr = get_frame_pc (this_frame);
949       offset = tdep->dynamic_sigtramp_offset (gdbarch, code_addr);
950       if (offset >= 0)
951         code_addr -= offset;
952       else
953         code_addr = 0;
954     }
955   else
956     code_addr = get_frame_func (this_frame);
957
958   /* The stack address is trivially read from the sigcontext.  */
959   stack_addr = alpha_sigtramp_register_address (gdbarch, info->sigcontext_addr,
960                                                 ALPHA_SP_REGNUM);
961   stack_addr = get_frame_memory_unsigned (this_frame, stack_addr,
962                                           ALPHA_REGISTER_SIZE);
963
964   *this_id = frame_id_build (stack_addr, code_addr);
965 }
966
967 /* Retrieve the value of REGNUM in FRAME.  Don't give up!  */
968
969 static struct value *
970 alpha_sigtramp_frame_prev_register (struct frame_info *this_frame,
971                                     void **this_prologue_cache, int regnum)
972 {
973   struct alpha_sigtramp_unwind_cache *info
974     = alpha_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
975   CORE_ADDR addr;
976
977   if (info->sigcontext_addr != 0)
978     {
979       /* All integer and fp registers are stored in memory.  */
980       addr = alpha_sigtramp_register_address (get_frame_arch (this_frame),
981                                               info->sigcontext_addr, regnum);
982       if (addr != 0)
983         return frame_unwind_got_memory (this_frame, regnum, addr);
984     }
985
986   /* This extra register may actually be in the sigcontext, but our
987      current description of it in alpha_sigtramp_frame_unwind_cache
988      doesn't include it.  Too bad.  Fall back on whatever's in the
989      outer frame.  */
990   return frame_unwind_got_register (this_frame, regnum, regnum);
991 }
992
993 static int
994 alpha_sigtramp_frame_sniffer (const struct frame_unwind *self,
995                               struct frame_info *this_frame,
996                               void **this_prologue_cache)
997 {
998   struct gdbarch *gdbarch = get_frame_arch (this_frame);
999   CORE_ADDR pc = get_frame_pc (this_frame);
1000   const char *name;
1001
1002   /* NOTE: cagney/2004-04-30: Do not copy/clone this code.  Instead
1003      look at tramp-frame.h and other simplier per-architecture
1004      sigtramp unwinders.  */
1005
1006   /* We shouldn't even bother to try if the OSABI didn't register a
1007      sigcontext_addr handler or pc_in_sigtramp hander.  */
1008   if (gdbarch_tdep (gdbarch)->sigcontext_addr == NULL)
1009     return 0;
1010   if (gdbarch_tdep (gdbarch)->pc_in_sigtramp == NULL)
1011     return 0;
1012
1013   /* Otherwise we should be in a signal frame.  */
1014   find_pc_partial_function (pc, &name, NULL, NULL);
1015   if (gdbarch_tdep (gdbarch)->pc_in_sigtramp (gdbarch, pc, name))
1016     return 1;
1017
1018   return 0;
1019 }
1020
1021 static const struct frame_unwind alpha_sigtramp_frame_unwind = {
1022   SIGTRAMP_FRAME,
1023   default_frame_unwind_stop_reason,
1024   alpha_sigtramp_frame_this_id,
1025   alpha_sigtramp_frame_prev_register,
1026   NULL,
1027   alpha_sigtramp_frame_sniffer
1028 };
1029
1030 \f
1031
1032 /* Heuristic_proc_start may hunt through the text section for a long
1033    time across a 2400 baud serial line.  Allows the user to limit this
1034    search.  */
1035 static int heuristic_fence_post = 0;
1036
1037 /* Attempt to locate the start of the function containing PC.  We assume that
1038    the previous function ends with an about_to_return insn.  Not foolproof by
1039    any means, since gcc is happy to put the epilogue in the middle of a
1040    function.  But we're guessing anyway...  */
1041
1042 static CORE_ADDR
1043 alpha_heuristic_proc_start (struct gdbarch *gdbarch, CORE_ADDR pc)
1044 {
1045   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1046   CORE_ADDR last_non_nop = pc;
1047   CORE_ADDR fence = pc - heuristic_fence_post;
1048   CORE_ADDR orig_pc = pc;
1049   CORE_ADDR func;
1050   struct inferior *inf;
1051
1052   if (pc == 0)
1053     return 0;
1054
1055   /* First see if we can find the start of the function from minimal
1056      symbol information.  This can succeed with a binary that doesn't
1057      have debug info, but hasn't been stripped.  */
1058   func = get_pc_function_start (pc);
1059   if (func)
1060     return func;
1061
1062   if (heuristic_fence_post == -1
1063       || fence < tdep->vm_min_address)
1064     fence = tdep->vm_min_address;
1065
1066   /* Search back for previous return; also stop at a 0, which might be
1067      seen for instance before the start of a code section.  Don't include
1068      nops, since this usually indicates padding between functions.  */
1069   for (pc -= ALPHA_INSN_SIZE; pc >= fence; pc -= ALPHA_INSN_SIZE)
1070     {
1071       unsigned int insn = alpha_read_insn (gdbarch, pc);
1072       switch (insn)
1073         {
1074         case 0:                 /* invalid insn */
1075         case 0x6bfa8001:        /* ret $31,($26),1 */
1076           return last_non_nop;
1077
1078         case 0x2ffe0000:        /* unop: ldq_u $31,0($30) */
1079         case 0x47ff041f:        /* nop: bis $31,$31,$31 */
1080           break;
1081
1082         default:
1083           last_non_nop = pc;
1084           break;
1085         }
1086     }
1087
1088   inf = current_inferior ();
1089
1090   /* It's not clear to me why we reach this point when stopping quietly,
1091      but with this test, at least we don't print out warnings for every
1092      child forked (eg, on decstation).  22apr93 rich@cygnus.com.  */
1093   if (inf->control.stop_soon == NO_STOP_QUIETLY)
1094     {
1095       static int blurb_printed = 0;
1096
1097       if (fence == tdep->vm_min_address)
1098         warning (_("Hit beginning of text section without finding \
1099 enclosing function for address %s"), paddress (gdbarch, orig_pc));
1100       else
1101         warning (_("Hit heuristic-fence-post without finding \
1102 enclosing function for address %s"), paddress (gdbarch, orig_pc));
1103
1104       if (!blurb_printed)
1105         {
1106           printf_filtered (_("\
1107 This warning occurs if you are debugging a function without any symbols\n\
1108 (for example, in a stripped executable).  In that case, you may wish to\n\
1109 increase the size of the search with the `set heuristic-fence-post' command.\n\
1110 \n\
1111 Otherwise, you told GDB there was a function where there isn't one, or\n\
1112 (more likely) you have encountered a bug in GDB.\n"));
1113           blurb_printed = 1;
1114         }
1115     }
1116
1117   return 0;
1118 }
1119
1120 /* Fallback alpha frame unwinder.  Uses instruction scanning and knows
1121    something about the traditional layout of alpha stack frames.  */
1122
1123 struct alpha_heuristic_unwind_cache
1124
1125   CORE_ADDR vfp;
1126   CORE_ADDR start_pc;
1127   struct trad_frame_saved_reg *saved_regs;
1128   int return_reg;
1129 };
1130
1131 /* If a probing loop sequence starts at PC, simulate it and compute
1132    FRAME_SIZE and PC after its execution.  Otherwise, return with PC and
1133    FRAME_SIZE unchanged.  */
1134
1135 static void
1136 alpha_heuristic_analyze_probing_loop (struct gdbarch *gdbarch, CORE_ADDR *pc,
1137                                       int *frame_size)
1138 {
1139   CORE_ADDR cur_pc = *pc;
1140   int cur_frame_size = *frame_size;
1141   int nb_of_iterations, reg_index, reg_probe;
1142   unsigned int insn;
1143
1144   /* The following pattern is recognized as a probing loop:
1145
1146         lda     REG_INDEX,NB_OF_ITERATIONS
1147         lda     REG_PROBE,<immediate>(sp)
1148
1149      LOOP_START:
1150         stq     zero,<immediate>(REG_PROBE)
1151         subq    REG_INDEX,0x1,REG_INDEX
1152         lda     REG_PROBE,<immediate>(REG_PROBE)
1153         bne     REG_INDEX, LOOP_START
1154  
1155         lda     sp,<immediate>(REG_PROBE)
1156
1157      If anything different is found, the function returns without
1158      changing PC and FRAME_SIZE.  Otherwise, PC will point immediately
1159      after this sequence, and FRAME_SIZE will be updated.  */
1160
1161   /* lda     REG_INDEX,NB_OF_ITERATIONS */
1162
1163   insn = alpha_read_insn (gdbarch, cur_pc);
1164   if (INSN_OPCODE (insn) != lda_opcode)
1165     return;
1166   reg_index = MEM_RA (insn);
1167   nb_of_iterations = MEM_DISP (insn);
1168
1169   /* lda     REG_PROBE,<immediate>(sp) */
1170
1171   cur_pc += ALPHA_INSN_SIZE;
1172   insn = alpha_read_insn (gdbarch, cur_pc);
1173   if (INSN_OPCODE (insn) != lda_opcode
1174       || MEM_RB (insn) != ALPHA_SP_REGNUM)
1175     return;
1176   reg_probe = MEM_RA (insn);
1177   cur_frame_size -= MEM_DISP (insn);
1178
1179   /* stq     zero,<immediate>(REG_PROBE) */
1180   
1181   cur_pc += ALPHA_INSN_SIZE;
1182   insn = alpha_read_insn (gdbarch, cur_pc);
1183   if (INSN_OPCODE (insn) != stq_opcode
1184       || MEM_RA (insn) != 0x1f
1185       || MEM_RB (insn) != reg_probe)
1186     return;
1187   
1188   /* subq    REG_INDEX,0x1,REG_INDEX */
1189
1190   cur_pc += ALPHA_INSN_SIZE;
1191   insn = alpha_read_insn (gdbarch, cur_pc);
1192   if (INSN_OPCODE (insn) != subq_opcode
1193       || !OPR_HAS_IMMEDIATE (insn)
1194       || OPR_FUNCTION (insn) != subq_function
1195       || OPR_LIT(insn) != 1
1196       || OPR_RA (insn) != reg_index
1197       || OPR_RC (insn) != reg_index)
1198     return;
1199   
1200   /* lda     REG_PROBE,<immediate>(REG_PROBE) */
1201   
1202   cur_pc += ALPHA_INSN_SIZE;
1203   insn = alpha_read_insn (gdbarch, cur_pc);
1204   if (INSN_OPCODE (insn) != lda_opcode
1205       || MEM_RA (insn) != reg_probe
1206       || MEM_RB (insn) != reg_probe)
1207     return;
1208   cur_frame_size -= MEM_DISP (insn) * nb_of_iterations;
1209
1210   /* bne     REG_INDEX, LOOP_START */
1211
1212   cur_pc += ALPHA_INSN_SIZE;
1213   insn = alpha_read_insn (gdbarch, cur_pc);
1214   if (INSN_OPCODE (insn) != bne_opcode
1215       || MEM_RA (insn) != reg_index)
1216     return;
1217
1218   /* lda     sp,<immediate>(REG_PROBE) */
1219
1220   cur_pc += ALPHA_INSN_SIZE;
1221   insn = alpha_read_insn (gdbarch, cur_pc);
1222   if (INSN_OPCODE (insn) != lda_opcode
1223       || MEM_RA (insn) != ALPHA_SP_REGNUM
1224       || MEM_RB (insn) != reg_probe)
1225     return;
1226   cur_frame_size -= MEM_DISP (insn);
1227
1228   *pc = cur_pc;
1229   *frame_size = cur_frame_size;
1230 }
1231
1232 static struct alpha_heuristic_unwind_cache *
1233 alpha_heuristic_frame_unwind_cache (struct frame_info *this_frame,
1234                                     void **this_prologue_cache,
1235                                     CORE_ADDR start_pc)
1236 {
1237   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1238   struct alpha_heuristic_unwind_cache *info;
1239   ULONGEST val;
1240   CORE_ADDR limit_pc, cur_pc;
1241   int frame_reg, frame_size, return_reg, reg;
1242
1243   if (*this_prologue_cache)
1244     return *this_prologue_cache;
1245
1246   info = FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache);
1247   *this_prologue_cache = info;
1248   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1249
1250   limit_pc = get_frame_pc (this_frame);
1251   if (start_pc == 0)
1252     start_pc = alpha_heuristic_proc_start (gdbarch, limit_pc);
1253   info->start_pc = start_pc;
1254
1255   frame_reg = ALPHA_SP_REGNUM;
1256   frame_size = 0;
1257   return_reg = -1;
1258
1259   /* If we've identified a likely place to start, do code scanning.  */
1260   if (start_pc != 0)
1261     {
1262       /* Limit the forward search to 50 instructions.  */
1263       if (start_pc + 200 < limit_pc)
1264         limit_pc = start_pc + 200;
1265
1266       for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += ALPHA_INSN_SIZE)
1267         {
1268           unsigned int word = alpha_read_insn (gdbarch, cur_pc);
1269
1270           if ((word & 0xffff0000) == 0x23de0000)        /* lda $sp,n($sp) */
1271             {
1272               if (word & 0x8000)
1273                 {
1274                   /* Consider only the first stack allocation instruction
1275                      to contain the static size of the frame.  */
1276                   if (frame_size == 0)
1277                     frame_size = (-word) & 0xffff;
1278                 }
1279               else
1280                 {
1281                   /* Exit loop if a positive stack adjustment is found, which
1282                      usually means that the stack cleanup code in the function
1283                      epilogue is reached.  */
1284                   break;
1285                 }
1286             }
1287           else if ((word & 0xfc1f0000) == 0xb41e0000)   /* stq reg,n($sp) */
1288             {
1289               reg = (word & 0x03e00000) >> 21;
1290
1291               /* Ignore this instruction if we have already encountered
1292                  an instruction saving the same register earlier in the
1293                  function code.  The current instruction does not tell
1294                  us where the original value upon function entry is saved.
1295                  All it says is that the function we are scanning reused
1296                  that register for some computation of its own, and is now
1297                  saving its result.  */
1298               if (trad_frame_addr_p(info->saved_regs, reg))
1299                 continue;
1300
1301               if (reg == 31)
1302                 continue;
1303
1304               /* Do not compute the address where the register was saved yet,
1305                  because we don't know yet if the offset will need to be
1306                  relative to $sp or $fp (we can not compute the address
1307                  relative to $sp if $sp is updated during the execution of
1308                  the current subroutine, for instance when doing some alloca).
1309                  So just store the offset for the moment, and compute the
1310                  address later when we know whether this frame has a frame
1311                  pointer or not.  */
1312               /* Hack: temporarily add one, so that the offset is non-zero
1313                  and we can tell which registers have save offsets below.  */
1314               info->saved_regs[reg].addr = (word & 0xffff) + 1;
1315
1316               /* Starting with OSF/1-3.2C, the system libraries are shipped
1317                  without local symbols, but they still contain procedure
1318                  descriptors without a symbol reference. GDB is currently
1319                  unable to find these procedure descriptors and uses
1320                  heuristic_proc_desc instead.
1321                  As some low level compiler support routines (__div*, __add*)
1322                  use a non-standard return address register, we have to
1323                  add some heuristics to determine the return address register,
1324                  or stepping over these routines will fail.
1325                  Usually the return address register is the first register
1326                  saved on the stack, but assembler optimization might
1327                  rearrange the register saves.
1328                  So we recognize only a few registers (t7, t9, ra) within
1329                  the procedure prologue as valid return address registers.
1330                  If we encounter a return instruction, we extract the
1331                  return address register from it.
1332
1333                  FIXME: Rewriting GDB to access the procedure descriptors,
1334                  e.g. via the minimal symbol table, might obviate this
1335                  hack.  */
1336               if (return_reg == -1
1337                   && cur_pc < (start_pc + 80)
1338                   && (reg == ALPHA_T7_REGNUM
1339                       || reg == ALPHA_T9_REGNUM
1340                       || reg == ALPHA_RA_REGNUM))
1341                 return_reg = reg;
1342             }
1343           else if ((word & 0xffe0ffff) == 0x6be08001)   /* ret zero,reg,1 */
1344             return_reg = (word >> 16) & 0x1f;
1345           else if (word == 0x47de040f)                  /* bis sp,sp,fp */
1346             frame_reg = ALPHA_GCC_FP_REGNUM;
1347           else if (word == 0x47fe040f)                  /* bis zero,sp,fp */
1348             frame_reg = ALPHA_GCC_FP_REGNUM;
1349
1350           alpha_heuristic_analyze_probing_loop (gdbarch, &cur_pc, &frame_size);
1351         }
1352
1353       /* If we haven't found a valid return address register yet, keep
1354          searching in the procedure prologue.  */
1355       if (return_reg == -1)
1356         {
1357           while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80))
1358             {
1359               unsigned int word = alpha_read_insn (gdbarch, cur_pc);
1360
1361               if ((word & 0xfc1f0000) == 0xb41e0000)    /* stq reg,n($sp) */
1362                 {
1363                   reg = (word & 0x03e00000) >> 21;
1364                   if (reg == ALPHA_T7_REGNUM
1365                       || reg == ALPHA_T9_REGNUM
1366                       || reg == ALPHA_RA_REGNUM)
1367                     {
1368                       return_reg = reg;
1369                       break;
1370                     }
1371                 }
1372               else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
1373                 {
1374                   return_reg = (word >> 16) & 0x1f;
1375                   break;
1376                 }
1377
1378               cur_pc += ALPHA_INSN_SIZE;
1379             }
1380         }
1381     }
1382
1383   /* Failing that, do default to the customary RA.  */
1384   if (return_reg == -1)
1385     return_reg = ALPHA_RA_REGNUM;
1386   info->return_reg = return_reg;
1387
1388   val = get_frame_register_unsigned (this_frame, frame_reg);
1389   info->vfp = val + frame_size;
1390
1391   /* Convert offsets to absolute addresses.  See above about adding
1392      one to the offsets to make all detected offsets non-zero.  */
1393   for (reg = 0; reg < ALPHA_NUM_REGS; ++reg)
1394     if (trad_frame_addr_p(info->saved_regs, reg))
1395       info->saved_regs[reg].addr += val - 1;
1396
1397   /* The stack pointer of the previous frame is computed by popping
1398      the current stack frame.  */
1399   if (!trad_frame_addr_p (info->saved_regs, ALPHA_SP_REGNUM))
1400    trad_frame_set_value (info->saved_regs, ALPHA_SP_REGNUM, info->vfp);
1401
1402   return info;
1403 }
1404
1405 /* Given a GDB frame, determine the address of the calling function's
1406    frame.  This will be used to create a new GDB frame struct.  */
1407
1408 static void
1409 alpha_heuristic_frame_this_id (struct frame_info *this_frame,
1410                                void **this_prologue_cache,
1411                                struct frame_id *this_id)
1412 {
1413   struct alpha_heuristic_unwind_cache *info
1414     = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
1415
1416   *this_id = frame_id_build (info->vfp, info->start_pc);
1417 }
1418
1419 /* Retrieve the value of REGNUM in FRAME.  Don't give up!  */
1420
1421 static struct value *
1422 alpha_heuristic_frame_prev_register (struct frame_info *this_frame,
1423                                      void **this_prologue_cache, int regnum)
1424 {
1425   struct alpha_heuristic_unwind_cache *info
1426     = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
1427
1428   /* The PC of the previous frame is stored in the link register of
1429      the current frame.  Frob regnum so that we pull the value from
1430      the correct place.  */
1431   if (regnum == ALPHA_PC_REGNUM)
1432     regnum = info->return_reg;
1433   
1434   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1435 }
1436
1437 static const struct frame_unwind alpha_heuristic_frame_unwind = {
1438   NORMAL_FRAME,
1439   default_frame_unwind_stop_reason,
1440   alpha_heuristic_frame_this_id,
1441   alpha_heuristic_frame_prev_register,
1442   NULL,
1443   default_frame_sniffer
1444 };
1445
1446 static CORE_ADDR
1447 alpha_heuristic_frame_base_address (struct frame_info *this_frame,
1448                                     void **this_prologue_cache)
1449 {
1450   struct alpha_heuristic_unwind_cache *info
1451     = alpha_heuristic_frame_unwind_cache (this_frame, this_prologue_cache, 0);
1452
1453   return info->vfp;
1454 }
1455
1456 static const struct frame_base alpha_heuristic_frame_base = {
1457   &alpha_heuristic_frame_unwind,
1458   alpha_heuristic_frame_base_address,
1459   alpha_heuristic_frame_base_address,
1460   alpha_heuristic_frame_base_address
1461 };
1462
1463 /* Just like reinit_frame_cache, but with the right arguments to be
1464    callable as an sfunc.  Used by the "set heuristic-fence-post" command.  */
1465
1466 static void
1467 reinit_frame_cache_sfunc (char *args, int from_tty, struct cmd_list_element *c)
1468 {
1469   reinit_frame_cache ();
1470 }
1471
1472 \f
1473 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1474    dummy frame.  The frame ID's base needs to match the TOS value
1475    saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1476    breakpoint.  */
1477
1478 static struct frame_id
1479 alpha_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1480 {
1481   ULONGEST base;
1482   base = get_frame_register_unsigned (this_frame, ALPHA_SP_REGNUM);
1483   return frame_id_build (base, get_frame_pc (this_frame));
1484 }
1485
1486 static CORE_ADDR
1487 alpha_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1488 {
1489   ULONGEST pc;
1490   pc = frame_unwind_register_unsigned (next_frame, ALPHA_PC_REGNUM);
1491   return pc;
1492 }
1493
1494 \f
1495 /* Helper routines for alpha*-nat.c files to move register sets to and
1496    from core files.  The UNIQUE pointer is allowed to be NULL, as most
1497    targets don't supply this value in their core files.  */
1498
1499 void
1500 alpha_supply_int_regs (struct regcache *regcache, int regno,
1501                        const void *r0_r30, const void *pc, const void *unique)
1502 {
1503   const gdb_byte *regs = r0_r30;
1504   int i;
1505
1506   for (i = 0; i < 31; ++i)
1507     if (regno == i || regno == -1)
1508       regcache_raw_supply (regcache, i, regs + i * 8);
1509
1510   if (regno == ALPHA_ZERO_REGNUM || regno == -1)
1511     {
1512       const gdb_byte zero[8] = { 0 };
1513
1514       regcache_raw_supply (regcache, ALPHA_ZERO_REGNUM, zero);
1515     }
1516
1517   if (regno == ALPHA_PC_REGNUM || regno == -1)
1518     regcache_raw_supply (regcache, ALPHA_PC_REGNUM, pc);
1519
1520   if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
1521     regcache_raw_supply (regcache, ALPHA_UNIQUE_REGNUM, unique);
1522 }
1523
1524 void
1525 alpha_fill_int_regs (const struct regcache *regcache,
1526                      int regno, void *r0_r30, void *pc, void *unique)
1527 {
1528   gdb_byte *regs = r0_r30;
1529   int i;
1530
1531   for (i = 0; i < 31; ++i)
1532     if (regno == i || regno == -1)
1533       regcache_raw_collect (regcache, i, regs + i * 8);
1534
1535   if (regno == ALPHA_PC_REGNUM || regno == -1)
1536     regcache_raw_collect (regcache, ALPHA_PC_REGNUM, pc);
1537
1538   if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1))
1539     regcache_raw_collect (regcache, ALPHA_UNIQUE_REGNUM, unique);
1540 }
1541
1542 void
1543 alpha_supply_fp_regs (struct regcache *regcache, int regno,
1544                       const void *f0_f30, const void *fpcr)
1545 {
1546   const gdb_byte *regs = f0_f30;
1547   int i;
1548
1549   for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1550     if (regno == i || regno == -1)
1551       regcache_raw_supply (regcache, i,
1552                            regs + (i - ALPHA_FP0_REGNUM) * 8);
1553
1554   if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1555     regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, fpcr);
1556 }
1557
1558 void
1559 alpha_fill_fp_regs (const struct regcache *regcache,
1560                     int regno, void *f0_f30, void *fpcr)
1561 {
1562   gdb_byte *regs = f0_f30;
1563   int i;
1564
1565   for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
1566     if (regno == i || regno == -1)
1567       regcache_raw_collect (regcache, i,
1568                             regs + (i - ALPHA_FP0_REGNUM) * 8);
1569
1570   if (regno == ALPHA_FPCR_REGNUM || regno == -1)
1571     regcache_raw_collect (regcache, ALPHA_FPCR_REGNUM, fpcr);
1572 }
1573
1574 \f
1575
1576 /* Return nonzero if the G_floating register value in REG is equal to
1577    zero for FP control instructions.  */
1578    
1579 static int
1580 fp_register_zero_p (LONGEST reg)
1581 {
1582   /* Check that all bits except the sign bit are zero.  */
1583   const LONGEST zero_mask = ((LONGEST) 1 << 63) ^ -1;
1584
1585   return ((reg & zero_mask) == 0);
1586 }
1587
1588 /* Return the value of the sign bit for the G_floating register
1589    value held in REG.  */
1590
1591 static int
1592 fp_register_sign_bit (LONGEST reg)
1593 {
1594   const LONGEST sign_mask = (LONGEST) 1 << 63;
1595
1596   return ((reg & sign_mask) != 0);
1597 }
1598
1599 /* alpha_software_single_step() is called just before we want to resume
1600    the inferior, if we want to single-step it but there is no hardware
1601    or kernel single-step support (NetBSD on Alpha, for example).  We find
1602    the target of the coming instruction and breakpoint it.  */
1603
1604 static CORE_ADDR
1605 alpha_next_pc (struct frame_info *frame, CORE_ADDR pc)
1606 {
1607   struct gdbarch *gdbarch = get_frame_arch (frame);
1608   unsigned int insn;
1609   unsigned int op;
1610   int regno;
1611   int offset;
1612   LONGEST rav;
1613
1614   insn = alpha_read_insn (gdbarch, pc);
1615
1616   /* Opcode is top 6 bits.  */
1617   op = (insn >> 26) & 0x3f;
1618
1619   if (op == 0x1a)
1620     {
1621       /* Jump format: target PC is:
1622          RB & ~3  */
1623       return (get_frame_register_unsigned (frame, (insn >> 16) & 0x1f) & ~3);
1624     }
1625
1626   if ((op & 0x30) == 0x30)
1627     {
1628       /* Branch format: target PC is:
1629          (new PC) + (4 * sext(displacement))  */
1630       if (op == 0x30            /* BR */
1631           || op == 0x34)        /* BSR */
1632         {
1633  branch_taken:
1634           offset = (insn & 0x001fffff);
1635           if (offset & 0x00100000)
1636             offset  |= 0xffe00000;
1637           offset *= ALPHA_INSN_SIZE;
1638           return (pc + ALPHA_INSN_SIZE + offset);
1639         }
1640
1641       /* Need to determine if branch is taken; read RA.  */
1642       regno = (insn >> 21) & 0x1f;
1643       switch (op)
1644         {
1645           case 0x31:              /* FBEQ */
1646           case 0x36:              /* FBGE */
1647           case 0x37:              /* FBGT */
1648           case 0x33:              /* FBLE */
1649           case 0x32:              /* FBLT */
1650           case 0x35:              /* FBNE */
1651             regno += gdbarch_fp0_regnum (gdbarch);
1652         }
1653       
1654       rav = get_frame_register_signed (frame, regno);
1655
1656       switch (op)
1657         {
1658         case 0x38:              /* BLBC */
1659           if ((rav & 1) == 0)
1660             goto branch_taken;
1661           break;
1662         case 0x3c:              /* BLBS */
1663           if (rav & 1)
1664             goto branch_taken;
1665           break;
1666         case 0x39:              /* BEQ */
1667           if (rav == 0)
1668             goto branch_taken;
1669           break;
1670         case 0x3d:              /* BNE */
1671           if (rav != 0)
1672             goto branch_taken;
1673           break;
1674         case 0x3a:              /* BLT */
1675           if (rav < 0)
1676             goto branch_taken;
1677           break;
1678         case 0x3b:              /* BLE */
1679           if (rav <= 0)
1680             goto branch_taken;
1681           break;
1682         case 0x3f:              /* BGT */
1683           if (rav > 0)
1684             goto branch_taken;
1685           break;
1686         case 0x3e:              /* BGE */
1687           if (rav >= 0)
1688             goto branch_taken;
1689           break;
1690
1691         /* Floating point branches.  */
1692         
1693         case 0x31:              /* FBEQ */
1694           if (fp_register_zero_p (rav))
1695             goto branch_taken;
1696           break;
1697         case 0x36:              /* FBGE */
1698           if (fp_register_sign_bit (rav) == 0 || fp_register_zero_p (rav))
1699             goto branch_taken;
1700           break;
1701         case 0x37:              /* FBGT */
1702           if (fp_register_sign_bit (rav) == 0 && ! fp_register_zero_p (rav))
1703             goto branch_taken;
1704           break;
1705         case 0x33:              /* FBLE */
1706           if (fp_register_sign_bit (rav) == 1 || fp_register_zero_p (rav))
1707             goto branch_taken;
1708           break;
1709         case 0x32:              /* FBLT */
1710           if (fp_register_sign_bit (rav) == 1 && ! fp_register_zero_p (rav))
1711             goto branch_taken;
1712           break;
1713         case 0x35:              /* FBNE */
1714           if (! fp_register_zero_p (rav))
1715             goto branch_taken;
1716           break;
1717         }
1718     }
1719
1720   /* Not a branch or branch not taken; target PC is:
1721      pc + 4  */
1722   return (pc + ALPHA_INSN_SIZE);
1723 }
1724
1725 int
1726 alpha_software_single_step (struct frame_info *frame)
1727 {
1728   struct gdbarch *gdbarch = get_frame_arch (frame);
1729   struct address_space *aspace = get_frame_address_space (frame);
1730   CORE_ADDR pc, next_pc;
1731
1732   pc = get_frame_pc (frame);
1733   next_pc = alpha_next_pc (frame, pc);
1734
1735   insert_single_step_breakpoint (gdbarch, aspace, next_pc);
1736   return 1;
1737 }
1738
1739 \f
1740 /* Initialize the current architecture based on INFO.  If possible, re-use an
1741    architecture from ARCHES, which is a list of architectures already created
1742    during this debugging session.
1743
1744    Called e.g. at program startup, when reading a core file, and when reading
1745    a binary file.  */
1746
1747 static struct gdbarch *
1748 alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1749 {
1750   struct gdbarch_tdep *tdep;
1751   struct gdbarch *gdbarch;
1752
1753   /* Try to determine the ABI of the object we are loading.  */
1754   if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
1755     {
1756       /* If it's an ECOFF file, assume it's OSF/1.  */
1757       if (bfd_get_flavour (info.abfd) == bfd_target_ecoff_flavour)
1758         info.osabi = GDB_OSABI_OSF1;
1759     }
1760
1761   /* Find a candidate among extant architectures.  */
1762   arches = gdbarch_list_lookup_by_info (arches, &info);
1763   if (arches != NULL)
1764     return arches->gdbarch;
1765
1766   tdep = xmalloc (sizeof (struct gdbarch_tdep));
1767   gdbarch = gdbarch_alloc (&info, tdep);
1768
1769   /* Lowest text address.  This is used by heuristic_proc_start()
1770      to decide when to stop looking.  */
1771   tdep->vm_min_address = (CORE_ADDR) 0x120000000LL;
1772
1773   tdep->dynamic_sigtramp_offset = NULL;
1774   tdep->sigcontext_addr = NULL;
1775   tdep->sc_pc_offset = 2 * 8;
1776   tdep->sc_regs_offset = 4 * 8;
1777   tdep->sc_fpregs_offset = tdep->sc_regs_offset + 32 * 8 + 8;
1778
1779   tdep->jb_pc = -1;     /* longjmp support not enabled by default.  */
1780
1781   tdep->return_in_memory = alpha_return_in_memory_always;
1782
1783   /* Type sizes */
1784   set_gdbarch_short_bit (gdbarch, 16);
1785   set_gdbarch_int_bit (gdbarch, 32);
1786   set_gdbarch_long_bit (gdbarch, 64);
1787   set_gdbarch_long_long_bit (gdbarch, 64);
1788   set_gdbarch_float_bit (gdbarch, 32);
1789   set_gdbarch_double_bit (gdbarch, 64);
1790   set_gdbarch_long_double_bit (gdbarch, 64);
1791   set_gdbarch_ptr_bit (gdbarch, 64);
1792
1793   /* Register info */
1794   set_gdbarch_num_regs (gdbarch, ALPHA_NUM_REGS);
1795   set_gdbarch_sp_regnum (gdbarch, ALPHA_SP_REGNUM);
1796   set_gdbarch_pc_regnum (gdbarch, ALPHA_PC_REGNUM);
1797   set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM);
1798
1799   set_gdbarch_register_name (gdbarch, alpha_register_name);
1800   set_gdbarch_register_type (gdbarch, alpha_register_type);
1801
1802   set_gdbarch_cannot_fetch_register (gdbarch, alpha_cannot_fetch_register);
1803   set_gdbarch_cannot_store_register (gdbarch, alpha_cannot_store_register);
1804
1805   set_gdbarch_convert_register_p (gdbarch, alpha_convert_register_p);
1806   set_gdbarch_register_to_value (gdbarch, alpha_register_to_value);
1807   set_gdbarch_value_to_register (gdbarch, alpha_value_to_register);
1808
1809   set_gdbarch_register_reggroup_p (gdbarch, alpha_register_reggroup_p);
1810
1811   /* Prologue heuristics.  */
1812   set_gdbarch_skip_prologue (gdbarch, alpha_skip_prologue);
1813
1814   /* Disassembler.  */
1815   set_gdbarch_print_insn (gdbarch, print_insn_alpha);
1816
1817   /* Call info.  */
1818
1819   set_gdbarch_return_value (gdbarch, alpha_return_value);
1820
1821   /* Settings for calling functions in the inferior.  */
1822   set_gdbarch_push_dummy_call (gdbarch, alpha_push_dummy_call);
1823
1824   /* Methods for saving / extracting a dummy frame's ID.  */
1825   set_gdbarch_dummy_id (gdbarch, alpha_dummy_id);
1826
1827   /* Return the unwound PC value.  */
1828   set_gdbarch_unwind_pc (gdbarch, alpha_unwind_pc);
1829
1830   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1831   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1832
1833   set_gdbarch_breakpoint_from_pc (gdbarch, alpha_breakpoint_from_pc);
1834   set_gdbarch_decr_pc_after_break (gdbarch, ALPHA_INSN_SIZE);
1835   set_gdbarch_cannot_step_breakpoint (gdbarch, 1);
1836
1837   /* Handles single stepping of atomic sequences.  */
1838   set_gdbarch_software_single_step (gdbarch, alpha_deal_with_atomic_sequence);
1839
1840   /* Hook in ABI-specific overrides, if they have been registered.  */
1841   gdbarch_init_osabi (info, gdbarch);
1842
1843   /* Now that we have tuned the configuration, set a few final things
1844      based on what the OS ABI has told us.  */
1845
1846   if (tdep->jb_pc >= 0)
1847     set_gdbarch_get_longjmp_target (gdbarch, alpha_get_longjmp_target);
1848
1849   frame_unwind_append_unwinder (gdbarch, &alpha_sigtramp_frame_unwind);
1850   frame_unwind_append_unwinder (gdbarch, &alpha_heuristic_frame_unwind);
1851
1852   frame_base_set_default (gdbarch, &alpha_heuristic_frame_base);
1853
1854   return gdbarch;
1855 }
1856
1857 void
1858 alpha_dwarf2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1859 {
1860   dwarf2_append_unwinders (gdbarch);
1861   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
1862 }
1863
1864 extern initialize_file_ftype _initialize_alpha_tdep; /* -Wmissing-prototypes */
1865
1866 void
1867 _initialize_alpha_tdep (void)
1868 {
1869   struct cmd_list_element *c;
1870
1871   gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, NULL);
1872
1873   /* Let the user set the fence post for heuristic_proc_start.  */
1874
1875   /* We really would like to have both "0" and "unlimited" work, but
1876      command.c doesn't deal with that.  So make it a var_zinteger
1877      because the user can always use "999999" or some such for unlimited.  */
1878   /* We need to throw away the frame cache when we set this, since it
1879      might change our ability to get backtraces.  */
1880   add_setshow_zinteger_cmd ("heuristic-fence-post", class_support,
1881                             &heuristic_fence_post, _("\
1882 Set the distance searched for the start of a function."), _("\
1883 Show the distance searched for the start of a function."), _("\
1884 If you are debugging a stripped executable, GDB needs to search through the\n\
1885 program for the start of a function.  This command sets the distance of the\n\
1886 search.  The only need to set it is when debugging a stripped executable."),
1887                             reinit_frame_cache_sfunc,
1888                             NULL, /* FIXME: i18n: The distance searched for
1889                                      the start of a function is \"%d\".  */
1890                             &setlist, &showlist);
1891 }