1 /* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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 2 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
25 #include "frame-unwind.h"
26 #include "frame-base.h"
35 #include "gdb_string.h"
38 #include "reggroups.h"
39 #include "arch-utils.h"
45 #include "alpha-tdep.h"
49 alpha_register_name (int regno
)
51 static const char * const register_names
[] =
53 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
54 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
55 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
56 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
57 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
58 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
59 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
60 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
66 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
68 return register_names
[regno
];
72 alpha_cannot_fetch_register (int regno
)
74 return regno
== ALPHA_ZERO_REGNUM
;
78 alpha_cannot_store_register (int regno
)
80 return regno
== ALPHA_ZERO_REGNUM
;
84 alpha_register_convertible (int regno
)
86 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
90 alpha_register_virtual_type (int regno
)
92 if (regno
== ALPHA_SP_REGNUM
|| regno
== ALPHA_GP_REGNUM
)
93 return builtin_type_void_data_ptr
;
94 if (regno
== ALPHA_PC_REGNUM
)
95 return builtin_type_void_func_ptr
;
97 /* Don't need to worry about little vs big endian until
98 some jerk tries to port to alpha-unicosmk. */
99 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 31)
100 return builtin_type_ieee_double_little
;
102 return builtin_type_int64
;
105 /* Is REGNUM a member of REGGROUP? */
108 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
109 struct reggroup
*group
)
111 /* Filter out any registers eliminated, but whose regnum is
112 reserved for backward compatibility, e.g. the vfp. */
113 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
116 /* Since we implement no pseudo registers, save/restore is equal to all. */
117 if (group
== all_reggroup
118 || group
== save_reggroup
119 || group
== restore_reggroup
)
122 /* All other groups are non-overlapping. */
124 /* Since this is really a PALcode memory slot... */
125 if (regnum
== ALPHA_UNIQUE_REGNUM
)
126 return group
== system_reggroup
;
128 /* Force the FPCR to be considered part of the floating point state. */
129 if (regnum
== ALPHA_FPCR_REGNUM
)
130 return group
== float_reggroup
;
132 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
133 return group
== float_reggroup
;
135 return group
== general_reggroup
;
139 alpha_register_byte (int regno
)
145 alpha_register_raw_size (int regno
)
151 alpha_register_virtual_size (int regno
)
156 /* The alpha needs a conversion between register and memory format if the
157 register is a floating point register and memory format is float, as the
158 register format must be double or memory format is an integer with 4
159 bytes or less, as the representation of integers in floating point
160 registers is different. */
163 alpha_convert_flt_dbl (void *out
, const void *in
)
165 DOUBLEST d
= extract_typed_floating (in
, builtin_type_ieee_single_little
);
166 store_typed_floating (out
, builtin_type_ieee_double_little
, d
);
170 alpha_convert_dbl_flt (void *out
, const void *in
)
172 DOUBLEST d
= extract_typed_floating (in
, builtin_type_ieee_double_little
);
173 store_typed_floating (out
, builtin_type_ieee_single_little
, d
);
177 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
178 char *raw_buffer
, char *virtual_buffer
)
180 if (TYPE_LENGTH (valtype
) >= ALPHA_REGISTER_SIZE
)
182 memcpy (virtual_buffer
, raw_buffer
, ALPHA_REGISTER_SIZE
);
186 /* Note that everything below is less than 8 bytes long. */
188 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
189 alpha_convert_dbl_flt (virtual_buffer
, raw_buffer
);
190 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
)
193 l
= extract_unsigned_integer (raw_buffer
, ALPHA_REGISTER_SIZE
);
194 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
195 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
198 error ("Cannot retrieve value from floating point register");
202 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
203 char *virtual_buffer
, char *raw_buffer
)
205 if (TYPE_LENGTH (valtype
) >= ALPHA_REGISTER_SIZE
)
207 memcpy (raw_buffer
, virtual_buffer
, ALPHA_REGISTER_SIZE
);
211 /* Note that everything below is less than 8 bytes long. */
213 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
214 alpha_convert_flt_dbl (raw_buffer
, virtual_buffer
);
215 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
)
217 ULONGEST l
= unpack_long (valtype
, virtual_buffer
);
218 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
219 store_unsigned_integer (raw_buffer
, ALPHA_REGISTER_SIZE
, l
);
222 error ("Cannot store value in floating point register");
226 /* The alpha passes the first six arguments in the registers, the rest on
227 the stack. The register arguments are stored in ARG_REG_BUFFER, and
228 then moved into the register file; this simplifies the passing of a
229 large struct which extends from the registers to the stack, plus avoids
230 three ptrace invocations per word.
232 We don't bother tracking which register values should go in integer
233 regs or fp regs; we load the same values into both.
235 If the called function is returning a structure, the address of the
236 structure to be returned is passed as a hidden first argument. */
239 alpha_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
240 struct regcache
*regcache
, CORE_ADDR bp_addr
,
241 int nargs
, struct value
**args
, CORE_ADDR sp
,
242 int struct_return
, CORE_ADDR struct_addr
)
245 int accumulate_size
= struct_return
? 8 : 0;
252 struct alpha_arg
*alpha_args
253 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
254 register struct alpha_arg
*m_arg
;
255 char arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
256 int required_arg_regs
;
258 /* The ABI places the address of the called function in T12. */
259 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
261 /* Set the return address register to point to the entry point
262 of the program, where a breakpoint lies in wait. */
263 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
265 /* Lay out the arguments in memory. */
266 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
268 struct value
*arg
= args
[i
];
269 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
271 /* Cast argument to long if necessary as the compiler does it too. */
272 switch (TYPE_CODE (arg_type
))
277 case TYPE_CODE_RANGE
:
279 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
281 arg_type
= builtin_type_long
;
282 arg
= value_cast (arg_type
, arg
);
286 /* "float" arguments loaded in registers must be passed in
287 register format, aka "double". */
288 if (accumulate_size
< sizeof (arg_reg_buffer
)
289 && TYPE_LENGTH (arg_type
) == 4)
291 arg_type
= builtin_type_double
;
292 arg
= value_cast (arg_type
, arg
);
294 /* Tru64 5.1 has a 128-bit long double, and passes this by
295 invisible reference. No one else uses this data type. */
296 else if (TYPE_LENGTH (arg_type
) == 16)
298 /* Allocate aligned storage. */
299 sp
= (sp
& -16) - 16;
301 /* Write the real data into the stack. */
302 write_memory (sp
, VALUE_CONTENTS (arg
), 16);
304 /* Construct the indirection. */
305 arg_type
= lookup_pointer_type (arg_type
);
306 arg
= value_from_pointer (arg_type
, sp
);
312 m_arg
->len
= TYPE_LENGTH (arg_type
);
313 m_arg
->offset
= accumulate_size
;
314 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
315 m_arg
->contents
= VALUE_CONTENTS (arg
);
318 /* Determine required argument register loads, loading an argument register
319 is expensive as it uses three ptrace calls. */
320 required_arg_regs
= accumulate_size
/ 8;
321 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
322 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
324 /* Make room for the arguments on the stack. */
325 if (accumulate_size
< sizeof(arg_reg_buffer
))
328 accumulate_size
-= sizeof(arg_reg_buffer
);
329 sp
-= accumulate_size
;
331 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
334 /* `Push' arguments on the stack. */
335 for (i
= nargs
; m_arg
--, --i
>= 0;)
337 char *contents
= m_arg
->contents
;
338 int offset
= m_arg
->offset
;
339 int len
= m_arg
->len
;
341 /* Copy the bytes destined for registers into arg_reg_buffer. */
342 if (offset
< sizeof(arg_reg_buffer
))
344 if (offset
+ len
<= sizeof(arg_reg_buffer
))
346 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
351 int tlen
= sizeof(arg_reg_buffer
) - offset
;
352 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
359 /* Everything else goes to the stack. */
360 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
363 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
365 /* Load the argument registers. */
366 for (i
= 0; i
< required_arg_regs
; i
++)
368 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
369 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
370 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
371 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
374 /* Finally, update the stack pointer. */
375 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
380 /* Extract from REGCACHE the value about to be returned from a function
381 and copy it into VALBUF. */
384 alpha_extract_return_value (struct type
*valtype
, struct regcache
*regcache
,
387 char raw_buffer
[ALPHA_REGISTER_SIZE
];
390 switch (TYPE_CODE (valtype
))
393 switch (TYPE_LENGTH (valtype
))
396 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, raw_buffer
);
397 alpha_convert_dbl_flt (valbuf
, raw_buffer
);
401 regcache_cooked_read (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
410 /* Assume everything else degenerates to an integer. */
411 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &l
);
412 store_unsigned_integer (valbuf
, TYPE_LENGTH (valtype
), l
);
417 /* Extract from REGCACHE the address of a structure about to be returned
421 alpha_extract_struct_value_address (struct regcache
*regcache
)
424 regcache_cooked_read_unsigned (regcache
, ALPHA_V0_REGNUM
, &addr
);
428 /* Insert the given value into REGCACHE as if it was being
429 returned by a function. */
432 alpha_store_return_value (struct type
*valtype
, struct regcache
*regcache
,
435 int length
= TYPE_LENGTH (valtype
);
436 char raw_buffer
[ALPHA_REGISTER_SIZE
];
439 switch (TYPE_CODE (valtype
))
445 alpha_convert_flt_dbl (raw_buffer
, valbuf
);
450 regcache_cooked_write (regcache
, ALPHA_FP0_REGNUM
, valbuf
);
459 /* Assume everything else degenerates to an integer. */
460 l
= unpack_long (valtype
, valbuf
);
461 regcache_cooked_write_unsigned (regcache
, ALPHA_V0_REGNUM
, l
);
467 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
469 /* Structures are returned by ref in extra arg0. */
474 static const unsigned char *
475 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
477 static const unsigned char alpha_breakpoint
[] =
478 { 0x80, 0, 0, 0 }; /* call_pal bpt */
480 *lenptr
= sizeof(alpha_breakpoint
);
481 return (alpha_breakpoint
);
485 /* This returns the PC of the first insn after the prologue.
486 If we can't find the prologue, then return 0. */
489 alpha_after_prologue (CORE_ADDR pc
)
491 struct symtab_and_line sal
;
492 CORE_ADDR func_addr
, func_end
;
494 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
497 sal
= find_pc_line (func_addr
, 0);
498 if (sal
.end
< func_end
)
501 /* The line after the prologue is after the end of the function. In this
502 case, tell the caller to find the prologue the hard way. */
506 /* Read an instruction from memory at PC, looking through breakpoints. */
509 alpha_read_insn (CORE_ADDR pc
)
514 status
= read_memory_nobpt (pc
, buf
, 4);
516 memory_error (status
, pc
);
517 return extract_unsigned_integer (buf
, 4);
520 /* To skip prologues, I use this predicate. Returns either PC itself
521 if the code at PC does not look like a function prologue; otherwise
522 returns an address that (if we're lucky) follows the prologue. If
523 LENIENT, then we must skip everything which is involved in setting
524 up the frame (it's OK to skip more, just so long as we don't skip
525 anything which might clobber the registers which are being saved. */
528 alpha_skip_prologue (CORE_ADDR pc
)
532 CORE_ADDR post_prologue_pc
;
535 /* Silently return the unaltered pc upon memory errors.
536 This could happen on OSF/1 if decode_line_1 tries to skip the
537 prologue for quickstarted shared library functions when the
538 shared library is not yet mapped in.
539 Reading target memory is slow over serial lines, so we perform
540 this check only if the target has shared libraries (which all
541 Alpha targets do). */
542 if (target_read_memory (pc
, buf
, 4))
545 /* See if we can determine the end of the prologue via the symbol table.
546 If so, then return either PC, or the PC after the prologue, whichever
549 post_prologue_pc
= alpha_after_prologue (pc
);
550 if (post_prologue_pc
!= 0)
551 return max (pc
, post_prologue_pc
);
553 /* Can't determine prologue from the symbol table, need to examine
556 /* Skip the typical prologue instructions. These are the stack adjustment
557 instruction and the instructions that save registers on the stack
558 or in the gcc frame. */
559 for (offset
= 0; offset
< 100; offset
+= 4)
561 inst
= alpha_read_insn (pc
+ offset
);
563 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
565 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
567 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
569 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
572 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
573 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
574 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
577 if (inst
== 0x47de040f) /* bis sp,sp,fp */
579 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
588 /* Figure out where the longjmp will land.
589 We expect the first arg to be a pointer to the jmp_buf structure from
590 which we extract the PC (JB_PC) that we will land at. The PC is copied
591 into the "pc". This routine returns true on success. */
594 alpha_get_longjmp_target (CORE_ADDR
*pc
)
596 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
598 char raw_buffer
[ALPHA_REGISTER_SIZE
];
600 jb_addr
= read_register (ALPHA_A0_REGNUM
);
602 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
603 raw_buffer
, tdep
->jb_elt_size
))
606 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
611 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
612 describe the location and shape of the sigcontext structure. After
613 that, all registers are in memory, so it's easy. */
614 /* ??? Shouldn't we be able to do this generically, rather than with
615 OSABI data specific to Alpha? */
617 struct alpha_sigtramp_unwind_cache
619 CORE_ADDR sigcontext_addr
;
622 static struct alpha_sigtramp_unwind_cache
*
623 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
624 void **this_prologue_cache
)
626 struct alpha_sigtramp_unwind_cache
*info
;
627 struct gdbarch_tdep
*tdep
;
629 if (*this_prologue_cache
)
630 return *this_prologue_cache
;
632 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
633 *this_prologue_cache
= info
;
635 tdep
= gdbarch_tdep (current_gdbarch
);
636 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
641 /* Return the address of REGNO in a sigtramp frame. Since this is all
642 arithmetic, it doesn't seem worthwhile to cache it. */
644 #ifndef SIGFRAME_PC_OFF
645 #define SIGFRAME_PC_OFF (2 * 8)
646 #define SIGFRAME_REGSAVE_OFF (4 * 8)
647 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
651 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, unsigned int regno
)
654 return sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ regno
* 8;
655 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
656 return sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ regno
* 8;
657 if (regno
== PC_REGNUM
)
658 return sigcontext_addr
+ SIGFRAME_PC_OFF
;
663 /* Given a GDB frame, determine the address of the calling function's
664 frame. This will be used to create a new GDB frame struct. */
667 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
668 void **this_prologue_cache
,
669 struct frame_id
*this_id
)
671 struct alpha_sigtramp_unwind_cache
*info
672 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
673 struct gdbarch_tdep
*tdep
;
674 CORE_ADDR stack_addr
, code_addr
;
676 /* If the OSABI couldn't locate the sigcontext, give up. */
677 if (info
->sigcontext_addr
== 0)
680 /* If we have dynamic signal trampolines, find their start.
681 If we do not, then we must assume there is a symbol record
682 that can provide the start address. */
683 tdep
= gdbarch_tdep (current_gdbarch
);
684 if (tdep
->dynamic_sigtramp_offset
)
687 code_addr
= frame_pc_unwind (next_frame
);
688 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
695 code_addr
= frame_func_unwind (next_frame
);
697 /* The stack address is trivially read from the sigcontext. */
698 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
700 stack_addr
= read_memory_unsigned_integer (stack_addr
, ALPHA_REGISTER_SIZE
);
702 *this_id
= frame_id_build (stack_addr
, code_addr
);
705 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
708 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
709 void **this_prologue_cache
,
710 int regnum
, int *optimizedp
,
711 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
712 int *realnump
, void *bufferp
)
714 struct alpha_sigtramp_unwind_cache
*info
715 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
718 if (info
->sigcontext_addr
!= 0)
720 /* All integer and fp registers are stored in memory. */
721 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
725 *lvalp
= lval_memory
;
729 read_memory (addr
, bufferp
, ALPHA_REGISTER_SIZE
);
734 /* This extra register may actually be in the sigcontext, but our
735 current description of it in alpha_sigtramp_frame_unwind_cache
736 doesn't include it. Too bad. Fall back on whatever's in the
738 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
742 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
744 alpha_sigtramp_frame_this_id
,
745 alpha_sigtramp_frame_prev_register
748 static const struct frame_unwind
*
749 alpha_sigtramp_frame_p (CORE_ADDR pc
)
753 /* We shouldn't even bother to try if the OSABI didn't register
754 a sigcontext_addr handler. */
755 if (!gdbarch_tdep (current_gdbarch
)->sigcontext_addr
)
758 /* Otherwise we should be in a signal frame. */
759 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
760 if (PC_IN_SIGTRAMP (pc
, name
))
761 return &alpha_sigtramp_frame_unwind
;
766 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
767 something about the traditional layout of alpha stack frames. */
769 struct alpha_heuristic_unwind_cache
771 CORE_ADDR
*saved_regs
;
777 /* Heuristic_proc_start may hunt through the text section for a long
778 time across a 2400 baud serial line. Allows the user to limit this
780 static unsigned int heuristic_fence_post
= 0;
782 /* Attempt to locate the start of the function containing PC. We assume that
783 the previous function ends with an about_to_return insn. Not foolproof by
784 any means, since gcc is happy to put the epilogue in the middle of a
785 function. But we're guessing anyway... */
788 alpha_heuristic_proc_start (CORE_ADDR pc
)
790 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
791 CORE_ADDR last_non_nop
= pc
;
792 CORE_ADDR fence
= pc
- heuristic_fence_post
;
793 CORE_ADDR orig_pc
= pc
;
799 /* First see if we can find the start of the function from minimal
800 symbol information. This can succeed with a binary that doesn't
801 have debug info, but hasn't been stripped. */
802 func
= get_pc_function_start (pc
);
806 if (heuristic_fence_post
== UINT_MAX
807 || fence
< tdep
->vm_min_address
)
808 fence
= tdep
->vm_min_address
;
810 /* Search back for previous return; also stop at a 0, which might be
811 seen for instance before the start of a code section. Don't include
812 nops, since this usually indicates padding between functions. */
813 for (pc
-= 4; pc
>= fence
; pc
-= 4)
815 unsigned int insn
= alpha_read_insn (pc
);
818 case 0: /* invalid insn */
819 case 0x6bfa8001: /* ret $31,($26),1 */
822 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
823 case 0x47ff041f: /* nop: bis $31,$31,$31 */
832 /* It's not clear to me why we reach this point when stopping quietly,
833 but with this test, at least we don't print out warnings for every
834 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
835 if (stop_soon
== NO_STOP_QUIETLY
)
837 static int blurb_printed
= 0;
839 if (fence
== tdep
->vm_min_address
)
840 warning ("Hit beginning of text section without finding");
842 warning ("Hit heuristic-fence-post without finding");
843 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
848 This warning occurs if you are debugging a function without any symbols\n\
849 (for example, in a stripped executable). In that case, you may wish to\n\
850 increase the size of the search with the `set heuristic-fence-post' command.\n\
852 Otherwise, you told GDB there was a function where there isn't one, or\n\
853 (more likely) you have encountered a bug in GDB.\n");
861 static struct alpha_heuristic_unwind_cache
*
862 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
863 void **this_prologue_cache
,
866 struct alpha_heuristic_unwind_cache
*info
;
868 CORE_ADDR limit_pc
, cur_pc
;
869 int frame_reg
, frame_size
, return_reg
, reg
;
871 if (*this_prologue_cache
)
872 return *this_prologue_cache
;
874 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
875 *this_prologue_cache
= info
;
876 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
878 limit_pc
= frame_pc_unwind (next_frame
);
880 start_pc
= alpha_heuristic_proc_start (limit_pc
);
881 info
->start_pc
= start_pc
;
883 frame_reg
= ALPHA_SP_REGNUM
;
887 /* If we've identified a likely place to start, do code scanning. */
890 /* Limit the forward search to 50 instructions. */
891 if (start_pc
+ 200 < limit_pc
)
892 limit_pc
= start_pc
+ 200;
894 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
896 unsigned int word
= alpha_read_insn (cur_pc
);
898 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
902 /* Consider only the first stack allocation instruction
903 to contain the static size of the frame. */
905 frame_size
= (-word
) & 0xffff;
909 /* Exit loop if a positive stack adjustment is found, which
910 usually means that the stack cleanup code in the function
911 epilogue is reached. */
915 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
917 reg
= (word
& 0x03e00000) >> 21;
922 /* Do not compute the address where the register was saved yet,
923 because we don't know yet if the offset will need to be
924 relative to $sp or $fp (we can not compute the address
925 relative to $sp if $sp is updated during the execution of
926 the current subroutine, for instance when doing some alloca).
927 So just store the offset for the moment, and compute the
928 address later when we know whether this frame has a frame
930 /* Hack: temporarily add one, so that the offset is non-zero
931 and we can tell which registers have save offsets below. */
932 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
934 /* Starting with OSF/1-3.2C, the system libraries are shipped
935 without local symbols, but they still contain procedure
936 descriptors without a symbol reference. GDB is currently
937 unable to find these procedure descriptors and uses
938 heuristic_proc_desc instead.
939 As some low level compiler support routines (__div*, __add*)
940 use a non-standard return address register, we have to
941 add some heuristics to determine the return address register,
942 or stepping over these routines will fail.
943 Usually the return address register is the first register
944 saved on the stack, but assembler optimization might
945 rearrange the register saves.
946 So we recognize only a few registers (t7, t9, ra) within
947 the procedure prologue as valid return address registers.
948 If we encounter a return instruction, we extract the
949 the return address register from it.
951 FIXME: Rewriting GDB to access the procedure descriptors,
952 e.g. via the minimal symbol table, might obviate this hack. */
954 && cur_pc
< (start_pc
+ 80)
955 && (reg
== ALPHA_T7_REGNUM
956 || reg
== ALPHA_T9_REGNUM
957 || reg
== ALPHA_RA_REGNUM
))
960 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
961 return_reg
= (word
>> 16) & 0x1f;
962 else if (word
== 0x47de040f) /* bis sp,sp,fp */
963 frame_reg
= ALPHA_GCC_FP_REGNUM
;
964 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
965 frame_reg
= ALPHA_GCC_FP_REGNUM
;
968 /* If we haven't found a valid return address register yet, keep
969 searching in the procedure prologue. */
970 if (return_reg
== -1)
972 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
974 unsigned int word
= alpha_read_insn (cur_pc
);
976 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
978 reg
= (word
& 0x03e00000) >> 21;
979 if (reg
== ALPHA_T7_REGNUM
980 || reg
== ALPHA_T9_REGNUM
981 || reg
== ALPHA_RA_REGNUM
)
987 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
989 return_reg
= (word
>> 16) & 0x1f;
998 /* Failing that, do default to the customary RA. */
999 if (return_reg
== -1)
1000 return_reg
= ALPHA_RA_REGNUM
;
1001 info
->return_reg
= return_reg
;
1003 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
1004 info
->vfp
= val
+ frame_size
;
1006 /* Convert offsets to absolute addresses. See above about adding
1007 one to the offsets to make all detected offsets non-zero. */
1008 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
1009 if (info
->saved_regs
[reg
])
1010 info
->saved_regs
[reg
] += val
- 1;
1015 /* Given a GDB frame, determine the address of the calling function's
1016 frame. This will be used to create a new GDB frame struct. */
1019 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
1020 void **this_prologue_cache
,
1021 struct frame_id
*this_id
)
1023 struct alpha_heuristic_unwind_cache
*info
1024 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1026 /* This is meant to halt the backtrace at "_start". Make sure we
1027 don't halt it at a generic dummy frame. */
1028 if (inside_entry_file (info
->start_pc
))
1031 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
1034 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
1037 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
1038 void **this_prologue_cache
,
1039 int regnum
, int *optimizedp
,
1040 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1041 int *realnump
, void *bufferp
)
1043 struct alpha_heuristic_unwind_cache
*info
1044 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1046 /* The PC of the previous frame is stored in the link register of
1047 the current frame. Frob regnum so that we pull the value from
1048 the correct place. */
1049 if (regnum
== ALPHA_PC_REGNUM
)
1050 regnum
= info
->return_reg
;
1052 /* For all registers known to be saved in the current frame,
1053 do the obvious and pull the value out. */
1054 if (info
->saved_regs
[regnum
])
1057 *lvalp
= lval_memory
;
1058 *addrp
= info
->saved_regs
[regnum
];
1060 if (bufferp
!= NULL
)
1061 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1065 /* The stack pointer of the previous frame is computed by popping
1066 the current stack frame. */
1067 if (regnum
== ALPHA_SP_REGNUM
)
1073 if (bufferp
!= NULL
)
1074 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1078 /* Otherwise assume the next frame has the same register value. */
1079 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1083 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1085 alpha_heuristic_frame_this_id
,
1086 alpha_heuristic_frame_prev_register
1089 static const struct frame_unwind
*
1090 alpha_heuristic_frame_p (CORE_ADDR pc
)
1092 return &alpha_heuristic_frame_unwind
;
1096 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1097 void **this_prologue_cache
)
1099 struct alpha_heuristic_unwind_cache
*info
1100 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1105 static const struct frame_base alpha_heuristic_frame_base
= {
1106 &alpha_heuristic_frame_unwind
,
1107 alpha_heuristic_frame_base_address
,
1108 alpha_heuristic_frame_base_address
,
1109 alpha_heuristic_frame_base_address
1112 /* Just like reinit_frame_cache, but with the right arguments to be
1113 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1116 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1118 reinit_frame_cache ();
1122 /* ALPHA stack frames are almost impenetrable. When execution stops,
1123 we basically have to look at symbol information for the function
1124 that we stopped in, which tells us *which* register (if any) is
1125 the base of the frame pointer, and what offset from that register
1126 the frame itself is at.
1128 This presents a problem when trying to examine a stack in memory
1129 (that isn't executing at the moment), using the "frame" command. We
1130 don't have a PC, nor do we have any registers except SP.
1132 This routine takes two arguments, SP and PC, and tries to make the
1133 cached frames look as if these two arguments defined a frame on the
1134 cache. This allows the rest of info frame to extract the important
1135 arguments without difficulty. */
1138 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1141 error ("ALPHA frame specifications require two arguments: sp and pc");
1143 return create_new_frame (argv
[0], argv
[1]);
1146 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1147 dummy frame. The frame ID's base needs to match the TOS value
1148 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1151 static struct frame_id
1152 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1155 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1156 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1160 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1163 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1168 /* alpha_software_single_step() is called just before we want to resume
1169 the inferior, if we want to single-step it but there is no hardware
1170 or kernel single-step support (NetBSD on Alpha, for example). We find
1171 the target of the coming instruction and breakpoint it.
1173 single_step is also called just after the inferior stops. If we had
1174 set up a simulated single-step, we undo our damage. */
1177 alpha_next_pc (CORE_ADDR pc
)
1184 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1186 /* Opcode is top 6 bits. */
1187 op
= (insn
>> 26) & 0x3f;
1191 /* Jump format: target PC is:
1193 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1196 if ((op
& 0x30) == 0x30)
1198 /* Branch format: target PC is:
1199 (new PC) + (4 * sext(displacement)) */
1200 if (op
== 0x30 || /* BR */
1201 op
== 0x34) /* BSR */
1204 offset
= (insn
& 0x001fffff);
1205 if (offset
& 0x00100000)
1206 offset
|= 0xffe00000;
1208 return (pc
+ 4 + offset
);
1211 /* Need to determine if branch is taken; read RA. */
1212 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1215 case 0x38: /* BLBC */
1219 case 0x3c: /* BLBS */
1223 case 0x39: /* BEQ */
1227 case 0x3d: /* BNE */
1231 case 0x3a: /* BLT */
1235 case 0x3b: /* BLE */
1239 case 0x3f: /* BGT */
1243 case 0x3e: /* BGE */
1248 /* ??? Missing floating-point branches. */
1252 /* Not a branch or branch not taken; target PC is:
1258 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1260 static CORE_ADDR next_pc
;
1261 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1262 static binsn_quantum break_mem
;
1265 if (insert_breakpoints_p
)
1268 next_pc
= alpha_next_pc (pc
);
1270 target_insert_breakpoint (next_pc
, break_mem
);
1274 target_remove_breakpoint (next_pc
, break_mem
);
1280 /* Initialize the current architecture based on INFO. If possible, re-use an
1281 architecture from ARCHES, which is a list of architectures already created
1282 during this debugging session.
1284 Called e.g. at program startup, when reading a core file, and when reading
1287 static struct gdbarch
*
1288 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1290 struct gdbarch_tdep
*tdep
;
1291 struct gdbarch
*gdbarch
;
1293 /* Try to determine the ABI of the object we are loading. */
1294 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1296 /* If it's an ECOFF file, assume it's OSF/1. */
1297 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1298 info
.osabi
= GDB_OSABI_OSF1
;
1301 /* Find a candidate among extant architectures. */
1302 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1304 return arches
->gdbarch
;
1306 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1307 gdbarch
= gdbarch_alloc (&info
, tdep
);
1309 /* Lowest text address. This is used by heuristic_proc_start()
1310 to decide when to stop looking. */
1311 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1313 tdep
->dynamic_sigtramp_offset
= NULL
;
1314 tdep
->sigcontext_addr
= NULL
;
1316 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1319 set_gdbarch_short_bit (gdbarch
, 16);
1320 set_gdbarch_int_bit (gdbarch
, 32);
1321 set_gdbarch_long_bit (gdbarch
, 64);
1322 set_gdbarch_long_long_bit (gdbarch
, 64);
1323 set_gdbarch_float_bit (gdbarch
, 32);
1324 set_gdbarch_double_bit (gdbarch
, 64);
1325 set_gdbarch_long_double_bit (gdbarch
, 64);
1326 set_gdbarch_ptr_bit (gdbarch
, 64);
1329 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1330 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1331 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1332 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1334 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1335 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1336 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1337 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1338 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1340 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1341 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1343 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1344 set_gdbarch_register_convert_to_virtual (gdbarch
,
1345 alpha_register_convert_to_virtual
);
1346 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1348 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1350 /* Prologue heuristics. */
1351 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1354 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1357 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1358 set_gdbarch_frameless_function_invocation (gdbarch
,
1359 generic_frameless_function_invocation_not
);
1361 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1362 set_gdbarch_extract_return_value (gdbarch
, alpha_extract_return_value
);
1363 set_gdbarch_store_return_value (gdbarch
, alpha_store_return_value
);
1364 set_gdbarch_extract_struct_value_address (gdbarch
,
1365 alpha_extract_struct_value_address
);
1367 /* Settings for calling functions in the inferior. */
1368 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1370 /* Methods for saving / extracting a dummy frame's ID. */
1371 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1372 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1374 /* Return the unwound PC value. */
1375 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1377 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1378 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1380 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1381 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1383 set_gdbarch_function_start_offset (gdbarch
, 0);
1384 set_gdbarch_frame_args_skip (gdbarch
, 0);
1386 /* Hook in ABI-specific overrides, if they have been registered. */
1387 gdbarch_init_osabi (info
, gdbarch
);
1389 /* Now that we have tuned the configuration, set a few final things
1390 based on what the OS ABI has told us. */
1392 if (tdep
->jb_pc
>= 0)
1393 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1395 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1396 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1398 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1404 _initialize_alpha_tdep (void)
1406 struct cmd_list_element
*c
;
1408 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1410 /* Let the user set the fence post for heuristic_proc_start. */
1412 /* We really would like to have both "0" and "unlimited" work, but
1413 command.c doesn't deal with that. So make it a var_zinteger
1414 because the user can always use "999999" or some such for unlimited. */
1415 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1416 (char *) &heuristic_fence_post
,
1418 Set the distance searched for the start of a function.\n\
1419 If you are debugging a stripped executable, GDB needs to search through the\n\
1420 program for the start of a function. This command sets the distance of the\n\
1421 search. The only need to set it is when debugging a stripped executable.",
1423 /* We need to throw away the frame cache when we set this, since it
1424 might change our ability to get backtraces. */
1425 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1426 add_show_from_set (c
, &showlist
);