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. */
24 #include "frame-unwind.h"
25 #include "frame-base.h"
34 #include "gdb_string.h"
38 #include "arch-utils.h"
44 #include "alpha-tdep.h"
48 alpha_register_name (int regno
)
50 static char *register_names
[] =
52 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
53 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
54 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
55 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
56 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
57 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
58 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
59 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
60 "pc", "vfp", "unique",
65 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
67 return (register_names
[regno
]);
71 alpha_cannot_fetch_register (int regno
)
73 return (regno
== ALPHA_FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
77 alpha_cannot_store_register (int regno
)
79 return (regno
== ALPHA_FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
83 alpha_register_convertible (int regno
)
85 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
89 alpha_register_virtual_type (int regno
)
91 return ((regno
>= FP0_REGNUM
&& regno
< (FP0_REGNUM
+31))
92 ? builtin_type_double
: builtin_type_long
);
96 alpha_register_byte (int regno
)
102 alpha_register_raw_size (int regno
)
108 alpha_register_virtual_size (int regno
)
113 /* The alpha needs a conversion between register and memory format if the
114 register is a floating point register and memory format is float, as the
115 register format must be double or memory format is an integer with 4
116 bytes or less, as the representation of integers in floating point
117 registers is different. */
120 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
121 char *raw_buffer
, char *virtual_buffer
)
123 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
125 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
129 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
131 double d
= deprecated_extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
132 deprecated_store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
134 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
137 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
138 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
139 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
142 error ("Cannot retrieve value from floating point register");
146 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
147 char *virtual_buffer
, char *raw_buffer
)
149 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
151 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
155 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
157 double d
= deprecated_extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
158 deprecated_store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
160 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
163 if (TYPE_UNSIGNED (valtype
))
164 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
166 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
167 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
168 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
171 error ("Cannot store value in floating point register");
175 /* The alpha passes the first six arguments in the registers, the rest on
176 the stack. The register arguments are eventually transferred to the
177 argument transfer area immediately below the stack by the called function
178 anyway. So we `push' at least six arguments on the stack, `reload' the
179 argument registers and then adjust the stack pointer to point past the
180 sixth argument. This algorithm simplifies the passing of a large struct
181 which extends from the registers to the stack.
182 If the called function is returning a structure, the address of the
183 structure to be returned is passed as a hidden first argument. */
186 alpha_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
187 int struct_return
, CORE_ADDR struct_addr
)
190 int accumulate_size
= struct_return
? 8 : 0;
191 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
198 struct alpha_arg
*alpha_args
=
199 (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
200 register struct alpha_arg
*m_arg
;
201 char raw_buffer
[ALPHA_REGISTER_BYTES
];
202 int required_arg_regs
;
204 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
206 struct value
*arg
= args
[i
];
207 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
208 /* Cast argument to long if necessary as the compiler does it too. */
209 switch (TYPE_CODE (arg_type
))
214 case TYPE_CODE_RANGE
:
216 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
218 arg_type
= builtin_type_long
;
219 arg
= value_cast (arg_type
, arg
);
225 m_arg
->len
= TYPE_LENGTH (arg_type
);
226 m_arg
->offset
= accumulate_size
;
227 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
228 m_arg
->contents
= VALUE_CONTENTS (arg
);
231 /* Determine required argument register loads, loading an argument register
232 is expensive as it uses three ptrace calls. */
233 required_arg_regs
= accumulate_size
/ 8;
234 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
235 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
237 /* Make room for the arguments on the stack. */
238 if (accumulate_size
< arg_regs_size
)
239 accumulate_size
= arg_regs_size
;
240 sp
-= accumulate_size
;
242 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
245 /* `Push' arguments on the stack. */
246 for (i
= nargs
; m_arg
--, --i
>= 0;)
247 write_memory (sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
250 store_unsigned_integer (raw_buffer
, ALPHA_REGISTER_BYTES
, struct_addr
);
251 write_memory (sp
, raw_buffer
, ALPHA_REGISTER_BYTES
);
254 /* Load the argument registers. */
255 for (i
= 0; i
< required_arg_regs
; i
++)
259 val
= read_memory_integer (sp
+ i
* 8, ALPHA_REGISTER_BYTES
);
260 write_register (ALPHA_A0_REGNUM
+ i
, val
);
261 write_register (ALPHA_FPA0_REGNUM
+ i
, val
);
264 return sp
+ arg_regs_size
;
267 /* Given a return value in `regbuf' with a type `valtype',
268 extract and copy its value into `valbuf'. */
271 alpha_extract_return_value (struct type
*valtype
,
272 char regbuf
[ALPHA_REGISTER_BYTES
], char *valbuf
)
274 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
275 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
276 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
279 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
280 TYPE_LENGTH (valtype
));
283 /* Given a return value in `regbuf' with a type `valtype',
284 write its value into the appropriate register. */
287 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
289 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
290 int regnum
= ALPHA_V0_REGNUM
;
291 int length
= TYPE_LENGTH (valtype
);
293 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
296 length
= REGISTER_RAW_SIZE (regnum
);
297 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
300 memcpy (raw_buffer
, valbuf
, length
);
302 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
306 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
308 /* Structures are returned by ref in extra arg0. */
313 alpha_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
315 /* Store the address of the place in which to copy the structure the
316 subroutine will return. Handled by alpha_push_arguments. */
320 alpha_extract_struct_value_address (char *regbuf
)
322 return (extract_address (regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
323 REGISTER_RAW_SIZE (ALPHA_V0_REGNUM
)));
327 static const unsigned char *
328 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
330 static const unsigned char alpha_breakpoint
[] =
331 { 0x80, 0, 0, 0 }; /* call_pal bpt */
333 *lenptr
= sizeof(alpha_breakpoint
);
334 return (alpha_breakpoint
);
338 /* This returns the PC of the first insn after the prologue.
339 If we can't find the prologue, then return 0. */
342 alpha_after_prologue (CORE_ADDR pc
)
344 struct symtab_and_line sal
;
345 CORE_ADDR func_addr
, func_end
;
347 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
350 sal
= find_pc_line (func_addr
, 0);
351 if (sal
.end
< func_end
)
354 /* The line after the prologue is after the end of the function. In this
355 case, tell the caller to find the prologue the hard way. */
359 /* Read an instruction from memory at PC, looking through breakpoints. */
362 alpha_read_insn (CORE_ADDR pc
)
367 status
= read_memory_nobpt (pc
, buf
, 4);
369 memory_error (status
, pc
);
370 return extract_unsigned_integer (buf
, 4);
373 /* To skip prologues, I use this predicate. Returns either PC itself
374 if the code at PC does not look like a function prologue; otherwise
375 returns an address that (if we're lucky) follows the prologue. If
376 LENIENT, then we must skip everything which is involved in setting
377 up the frame (it's OK to skip more, just so long as we don't skip
378 anything which might clobber the registers which are being saved. */
381 alpha_skip_prologue (CORE_ADDR pc
)
385 CORE_ADDR post_prologue_pc
;
388 /* Silently return the unaltered pc upon memory errors.
389 This could happen on OSF/1 if decode_line_1 tries to skip the
390 prologue for quickstarted shared library functions when the
391 shared library is not yet mapped in.
392 Reading target memory is slow over serial lines, so we perform
393 this check only if the target has shared libraries (which all
394 Alpha targets do). */
395 if (target_read_memory (pc
, buf
, 4))
398 /* See if we can determine the end of the prologue via the symbol table.
399 If so, then return either PC, or the PC after the prologue, whichever
402 post_prologue_pc
= alpha_after_prologue (pc
);
403 if (post_prologue_pc
!= 0)
404 return max (pc
, post_prologue_pc
);
406 /* Can't determine prologue from the symbol table, need to examine
409 /* Skip the typical prologue instructions. These are the stack adjustment
410 instruction and the instructions that save registers on the stack
411 or in the gcc frame. */
412 for (offset
= 0; offset
< 100; offset
+= 4)
414 inst
= alpha_read_insn (pc
+ offset
);
416 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
418 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
420 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
422 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
425 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
426 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
427 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
430 if (inst
== 0x47de040f) /* bis sp,sp,fp */
432 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
441 /* Construct an inferior call to FUN. For Alpha this is as simple as
442 initializing the RA and T12 registers; everything else is set up by
446 alpha_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
447 struct value
**args
, struct type
*type
, int gcc_p
)
449 CORE_ADDR bp_address
= CALL_DUMMY_ADDRESS ();
452 error ("no place to put call");
453 write_register (ALPHA_RA_REGNUM
, bp_address
);
454 write_register (ALPHA_T12_REGNUM
, fun
);
457 /* On the Alpha, the call dummy code is never copied to user space
458 (see alpha_fix_call_dummy() above). The contents of this do not
460 LONGEST alpha_call_dummy_words
[] = { 0 };
463 /* Figure out where the longjmp will land.
464 We expect the first arg to be a pointer to the jmp_buf structure from
465 which we extract the PC (JB_PC) that we will land at. The PC is copied
466 into the "pc". This routine returns true on success. */
469 alpha_get_longjmp_target (CORE_ADDR
*pc
)
471 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
473 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
475 jb_addr
= read_register (ALPHA_A0_REGNUM
);
477 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
478 raw_buffer
, tdep
->jb_elt_size
))
481 *pc
= extract_address (raw_buffer
, tdep
->jb_elt_size
);
486 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
487 describe the location and shape of the sigcontext structure. After
488 that, all registers are in memory, so it's easy. */
489 /* ??? Shouldn't we be able to do this generically, rather than with
490 OSABI data specific to Alpha? */
492 struct alpha_sigtramp_unwind_cache
494 CORE_ADDR sigcontext_addr
;
497 static struct alpha_sigtramp_unwind_cache
*
498 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
499 void **this_prologue_cache
)
501 struct alpha_sigtramp_unwind_cache
*info
;
502 struct gdbarch_tdep
*tdep
;
504 if (*this_prologue_cache
)
505 return *this_prologue_cache
;
507 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
508 *this_prologue_cache
= info
;
510 tdep
= gdbarch_tdep (current_gdbarch
);
511 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
516 /* Return the address of REGNO in a sigtramp frame. Since this is all
517 arithmetic, it doesn't seem worthwhile to cache it. */
519 #ifndef SIGFRAME_PC_OFF
520 #define SIGFRAME_PC_OFF (2 * 8)
521 #define SIGFRAME_REGSAVE_OFF (4 * 8)
522 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
526 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, unsigned int regno
)
529 return sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ regno
* 8;
530 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
531 return sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ regno
* 8;
532 if (regno
== PC_REGNUM
)
533 return sigcontext_addr
+ SIGFRAME_PC_OFF
;
538 /* Given a GDB frame, determine the address of the calling function's
539 frame. This will be used to create a new GDB frame struct. */
542 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
543 void **this_prologue_cache
,
544 struct frame_id
*this_id
)
546 struct alpha_sigtramp_unwind_cache
*info
547 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
548 struct gdbarch_tdep
*tdep
;
549 CORE_ADDR stack_addr
, code_addr
;
551 /* If the OSABI couldn't locate the sigcontext, give up. */
552 if (info
->sigcontext_addr
== 0)
555 /* If we have dynamic signal trampolines, find their start.
556 If we do not, then we must assume there is a symbol record
557 that can provide the start address. */
558 tdep
= gdbarch_tdep (current_gdbarch
);
559 if (tdep
->dynamic_sigtramp_offset
)
562 code_addr
= frame_pc_unwind (next_frame
);
563 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
570 code_addr
= frame_func_unwind (next_frame
);
572 /* The stack address is trivially read from the sigcontext. */
573 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
575 stack_addr
= read_memory_unsigned_integer (stack_addr
, ALPHA_REGISTER_SIZE
);
577 *this_id
= frame_id_build (stack_addr
, code_addr
);
580 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
583 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
584 void **this_prologue_cache
,
585 int regnum
, int *optimizedp
,
586 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
587 int *realnump
, void *bufferp
)
589 struct alpha_sigtramp_unwind_cache
*info
590 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
593 if (info
->sigcontext_addr
!= 0)
595 /* All integer and fp registers are stored in memory. */
596 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
600 *lvalp
= lval_memory
;
604 read_memory (addr
, bufferp
, ALPHA_REGISTER_SIZE
);
609 /* This extra register may actually be in the sigcontext, but our
610 current description of it in alpha_sigtramp_frame_unwind_cache
611 doesn't include it. Too bad. Fall back on whatever's in the
613 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
617 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
619 alpha_sigtramp_frame_this_id
,
620 alpha_sigtramp_frame_prev_register
623 static const struct frame_unwind
*
624 alpha_sigtramp_frame_p (CORE_ADDR pc
)
628 /* We shouldn't even bother to try if the OSABI didn't register
629 a sigcontext_addr handler. */
630 if (!gdbarch_tdep (current_gdbarch
)->sigcontext_addr
)
633 /* Otherwise we should be in a signal frame. */
634 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
635 if (PC_IN_SIGTRAMP (pc
, name
))
636 return &alpha_sigtramp_frame_unwind
;
641 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
642 something about the traditional layout of alpha stack frames. */
644 struct alpha_heuristic_unwind_cache
646 CORE_ADDR
*saved_regs
;
652 /* Heuristic_proc_start may hunt through the text section for a long
653 time across a 2400 baud serial line. Allows the user to limit this
655 static unsigned int heuristic_fence_post
= 0;
657 /* Attempt to locate the start of the function containing PC. We assume that
658 the previous function ends with an about_to_return insn. Not foolproof by
659 any means, since gcc is happy to put the epilogue in the middle of a
660 function. But we're guessing anyway... */
663 alpha_heuristic_proc_start (CORE_ADDR pc
)
665 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
666 CORE_ADDR last_non_nop
= pc
;
667 CORE_ADDR fence
= pc
- heuristic_fence_post
;
668 CORE_ADDR orig_pc
= pc
;
673 if (heuristic_fence_post
== UINT_MAX
674 || fence
< tdep
->vm_min_address
)
675 fence
= tdep
->vm_min_address
;
677 /* Search back for previous return; also stop at a 0, which might be
678 seen for instance before the start of a code section. Don't include
679 nops, since this usually indicates padding between functions. */
680 for (pc
-= 4; pc
>= fence
; pc
-= 4)
682 unsigned int insn
= alpha_read_insn (pc
);
685 case 0: /* invalid insn */
686 case 0x6bfa8001: /* ret $31,($26),1 */
689 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
690 case 0x47ff041f: /* nop: bis $31,$31,$31 */
699 /* It's not clear to me why we reach this point when stopping quietly,
700 but with this test, at least we don't print out warnings for every
701 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
702 if (stop_soon
== NO_STOP_QUIETLY
)
704 static int blurb_printed
= 0;
706 if (fence
== tdep
->vm_min_address
)
707 warning ("Hit beginning of text section without finding");
709 warning ("Hit heuristic-fence-post without finding");
710 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
715 This warning occurs if you are debugging a function without any symbols\n\
716 (for example, in a stripped executable). In that case, you may wish to\n\
717 increase the size of the search with the `set heuristic-fence-post' command.\n\
719 Otherwise, you told GDB there was a function where there isn't one, or\n\
720 (more likely) you have encountered a bug in GDB.\n");
728 struct alpha_heuristic_unwind_cache
*
729 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
730 void **this_prologue_cache
,
733 struct alpha_heuristic_unwind_cache
*info
;
735 CORE_ADDR limit_pc
, cur_pc
;
736 int frame_reg
, frame_size
, return_reg
, reg
;
738 if (*this_prologue_cache
)
739 return *this_prologue_cache
;
741 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
742 *this_prologue_cache
= info
;
743 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
745 limit_pc
= frame_pc_unwind (next_frame
);
747 start_pc
= alpha_heuristic_proc_start (limit_pc
);
748 info
->start_pc
= start_pc
;
750 frame_reg
= ALPHA_SP_REGNUM
;
754 /* If we've identified a likely place to start, do code scanning. */
757 /* Limit the forward search to 50 instructions. */
758 if (start_pc
+ 200 < limit_pc
)
759 limit_pc
= start_pc
+ 200;
761 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
763 unsigned int word
= alpha_read_insn (cur_pc
);
765 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
769 /* Consider only the first stack allocation instruction
770 to contain the static size of the frame. */
772 frame_size
= (-word
) & 0xffff;
776 /* Exit loop if a positive stack adjustment is found, which
777 usually means that the stack cleanup code in the function
778 epilogue is reached. */
782 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
784 reg
= (word
& 0x03e00000) >> 21;
789 /* Do not compute the address where the register was saved yet,
790 because we don't know yet if the offset will need to be
791 relative to $sp or $fp (we can not compute the address
792 relative to $sp if $sp is updated during the execution of
793 the current subroutine, for instance when doing some alloca).
794 So just store the offset for the moment, and compute the
795 address later when we know whether this frame has a frame
797 /* Hack: temporarily add one, so that the offset is non-zero
798 and we can tell which registers have save offsets below. */
799 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
801 /* Starting with OSF/1-3.2C, the system libraries are shipped
802 without local symbols, but they still contain procedure
803 descriptors without a symbol reference. GDB is currently
804 unable to find these procedure descriptors and uses
805 heuristic_proc_desc instead.
806 As some low level compiler support routines (__div*, __add*)
807 use a non-standard return address register, we have to
808 add some heuristics to determine the return address register,
809 or stepping over these routines will fail.
810 Usually the return address register is the first register
811 saved on the stack, but assembler optimization might
812 rearrange the register saves.
813 So we recognize only a few registers (t7, t9, ra) within
814 the procedure prologue as valid return address registers.
815 If we encounter a return instruction, we extract the
816 the return address register from it.
818 FIXME: Rewriting GDB to access the procedure descriptors,
819 e.g. via the minimal symbol table, might obviate this hack. */
821 && cur_pc
< (start_pc
+ 80)
822 && (reg
== ALPHA_T7_REGNUM
823 || reg
== ALPHA_T9_REGNUM
824 || reg
== ALPHA_RA_REGNUM
))
827 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
828 return_reg
= (word
>> 16) & 0x1f;
829 else if (word
== 0x47de040f) /* bis sp,sp,fp */
830 frame_reg
= ALPHA_GCC_FP_REGNUM
;
831 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
832 frame_reg
= ALPHA_GCC_FP_REGNUM
;
835 /* If we haven't found a valid return address register yet, keep
836 searching in the procedure prologue. */
837 if (return_reg
== -1)
839 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
841 unsigned int word
= alpha_read_insn (cur_pc
);
843 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
845 reg
= (word
& 0x03e00000) >> 21;
846 if (reg
== ALPHA_T7_REGNUM
847 || reg
== ALPHA_T9_REGNUM
848 || reg
== ALPHA_RA_REGNUM
)
854 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
856 return_reg
= (word
>> 16) & 0x1f;
863 /* Failing that, do default to the customary RA. */
864 if (return_reg
== -1)
865 return_reg
= ALPHA_RA_REGNUM
;
866 info
->return_reg
= return_reg
;
868 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
869 info
->vfp
= val
+ frame_size
;
871 /* Convert offsets to absolute addresses. See above about adding
872 one to the offsets to make all detected offsets non-zero. */
873 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
874 if (info
->saved_regs
[reg
])
875 info
->saved_regs
[reg
] += val
- 1;
880 /* Given a GDB frame, determine the address of the calling function's
881 frame. This will be used to create a new GDB frame struct. */
884 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
885 void **this_prologue_cache
,
886 struct frame_id
*this_id
)
888 struct alpha_heuristic_unwind_cache
*info
889 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
891 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
894 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
897 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
898 void **this_prologue_cache
,
899 int regnum
, int *optimizedp
,
900 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
901 int *realnump
, void *bufferp
)
903 struct alpha_heuristic_unwind_cache
*info
904 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
906 /* The PC of the previous frame is stored in the link register of
907 the current frame. Frob regnum so that we pull the value from
908 the correct place. */
909 if (regnum
== ALPHA_PC_REGNUM
)
910 regnum
= info
->return_reg
;
912 /* For all registers known to be saved in the current frame,
913 do the obvious and pull the value out. */
914 if (info
->saved_regs
[regnum
])
917 *lvalp
= lval_memory
;
918 *addrp
= info
->saved_regs
[regnum
];
921 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
925 /* The stack pointer of the previous frame is computed by popping
926 the current stack frame. */
927 if (regnum
== ALPHA_SP_REGNUM
)
934 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
938 /* Otherwise assume the next frame has the same register value. */
939 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
943 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
945 alpha_heuristic_frame_this_id
,
946 alpha_heuristic_frame_prev_register
949 static const struct frame_unwind
*
950 alpha_heuristic_frame_p (CORE_ADDR pc
)
952 return &alpha_heuristic_frame_unwind
;
956 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
957 void **this_prologue_cache
)
959 struct alpha_heuristic_unwind_cache
*info
960 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
965 static const struct frame_base alpha_heuristic_frame_base
= {
966 &alpha_heuristic_frame_unwind
,
967 alpha_heuristic_frame_base_address
,
968 alpha_heuristic_frame_base_address
,
969 alpha_heuristic_frame_base_address
972 /* Just like reinit_frame_cache, but with the right arguments to be
973 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
976 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
978 reinit_frame_cache ();
982 /* ALPHA stack frames are almost impenetrable. When execution stops,
983 we basically have to look at symbol information for the function
984 that we stopped in, which tells us *which* register (if any) is
985 the base of the frame pointer, and what offset from that register
986 the frame itself is at.
988 This presents a problem when trying to examine a stack in memory
989 (that isn't executing at the moment), using the "frame" command. We
990 don't have a PC, nor do we have any registers except SP.
992 This routine takes two arguments, SP and PC, and tries to make the
993 cached frames look as if these two arguments defined a frame on the
994 cache. This allows the rest of info frame to extract the important
995 arguments without difficulty. */
998 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1001 error ("ALPHA frame specifications require two arguments: sp and pc");
1003 return create_new_frame (argv
[0], argv
[1]);
1006 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1007 dummy frame. The frame ID's base needs to match the TOS value
1008 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1011 static struct frame_id
1012 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1015 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1016 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1020 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1023 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1028 /* alpha_software_single_step() is called just before we want to resume
1029 the inferior, if we want to single-step it but there is no hardware
1030 or kernel single-step support (NetBSD on Alpha, for example). We find
1031 the target of the coming instruction and breakpoint it.
1033 single_step is also called just after the inferior stops. If we had
1034 set up a simulated single-step, we undo our damage. */
1037 alpha_next_pc (CORE_ADDR pc
)
1044 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1046 /* Opcode is top 6 bits. */
1047 op
= (insn
>> 26) & 0x3f;
1051 /* Jump format: target PC is:
1053 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1056 if ((op
& 0x30) == 0x30)
1058 /* Branch format: target PC is:
1059 (new PC) + (4 * sext(displacement)) */
1060 if (op
== 0x30 || /* BR */
1061 op
== 0x34) /* BSR */
1064 offset
= (insn
& 0x001fffff);
1065 if (offset
& 0x00100000)
1066 offset
|= 0xffe00000;
1068 return (pc
+ 4 + offset
);
1071 /* Need to determine if branch is taken; read RA. */
1072 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1075 case 0x38: /* BLBC */
1079 case 0x3c: /* BLBS */
1083 case 0x39: /* BEQ */
1087 case 0x3d: /* BNE */
1091 case 0x3a: /* BLT */
1095 case 0x3b: /* BLE */
1099 case 0x3f: /* BGT */
1103 case 0x3e: /* BGE */
1108 /* ??? Missing floating-point branches. */
1112 /* Not a branch or branch not taken; target PC is:
1118 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1120 static CORE_ADDR next_pc
;
1121 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1122 static binsn_quantum break_mem
;
1125 if (insert_breakpoints_p
)
1128 next_pc
= alpha_next_pc (pc
);
1130 target_insert_breakpoint (next_pc
, break_mem
);
1134 target_remove_breakpoint (next_pc
, break_mem
);
1140 /* Initialize the current architecture based on INFO. If possible, re-use an
1141 architecture from ARCHES, which is a list of architectures already created
1142 during this debugging session.
1144 Called e.g. at program startup, when reading a core file, and when reading
1147 static struct gdbarch
*
1148 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1150 struct gdbarch_tdep
*tdep
;
1151 struct gdbarch
*gdbarch
;
1153 /* Try to determine the ABI of the object we are loading. */
1154 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1156 /* If it's an ECOFF file, assume it's OSF/1. */
1157 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1158 info
.osabi
= GDB_OSABI_OSF1
;
1161 /* Find a candidate among extant architectures. */
1162 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1164 return arches
->gdbarch
;
1166 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1167 gdbarch
= gdbarch_alloc (&info
, tdep
);
1169 /* Lowest text address. This is used by heuristic_proc_start()
1170 to decide when to stop looking. */
1171 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1173 tdep
->dynamic_sigtramp_offset
= NULL
;
1174 tdep
->sigcontext_addr
= NULL
;
1176 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1179 set_gdbarch_short_bit (gdbarch
, 16);
1180 set_gdbarch_int_bit (gdbarch
, 32);
1181 set_gdbarch_long_bit (gdbarch
, 64);
1182 set_gdbarch_long_long_bit (gdbarch
, 64);
1183 set_gdbarch_float_bit (gdbarch
, 32);
1184 set_gdbarch_double_bit (gdbarch
, 64);
1185 set_gdbarch_long_double_bit (gdbarch
, 64);
1186 set_gdbarch_ptr_bit (gdbarch
, 64);
1189 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1190 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1191 set_gdbarch_deprecated_fp_regnum (gdbarch
, ALPHA_FP_REGNUM
);
1192 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1193 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1195 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1196 set_gdbarch_deprecated_register_size (gdbarch
, ALPHA_REGISTER_SIZE
);
1197 set_gdbarch_deprecated_register_bytes (gdbarch
, ALPHA_REGISTER_BYTES
);
1198 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1199 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1200 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, ALPHA_MAX_REGISTER_RAW_SIZE
);
1201 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1202 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
1203 ALPHA_MAX_REGISTER_VIRTUAL_SIZE
);
1204 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1206 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1207 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1209 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1210 set_gdbarch_register_convert_to_virtual (gdbarch
,
1211 alpha_register_convert_to_virtual
);
1212 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1214 /* Prologue heuristics. */
1215 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1218 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1219 set_gdbarch_frameless_function_invocation (gdbarch
,
1220 generic_frameless_function_invocation_not
);
1222 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1223 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1224 set_gdbarch_deprecated_store_struct_return (gdbarch
, alpha_store_struct_return
);
1225 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1226 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1227 alpha_extract_struct_value_address
);
1229 /* Settings for calling functions in the inferior. */
1230 set_gdbarch_deprecated_push_arguments (gdbarch
, alpha_push_arguments
);
1231 set_gdbarch_deprecated_call_dummy_words (gdbarch
, alpha_call_dummy_words
);
1232 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
1233 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1234 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, alpha_fix_call_dummy
);
1236 /* Methods for saving / extracting a dummy frame's ID. */
1237 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1238 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1240 /* Return the unwound PC value. */
1241 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1243 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1244 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1246 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1247 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1249 set_gdbarch_function_start_offset (gdbarch
, 0);
1250 set_gdbarch_frame_args_skip (gdbarch
, 0);
1252 /* Hook in ABI-specific overrides, if they have been registered. */
1253 gdbarch_init_osabi (info
, gdbarch
);
1255 /* Now that we have tuned the configuration, set a few final things
1256 based on what the OS ABI has told us. */
1258 if (tdep
->jb_pc
>= 0)
1259 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1261 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1262 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1264 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1270 _initialize_alpha_tdep (void)
1272 struct cmd_list_element
*c
;
1274 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1275 deprecated_tm_print_insn
= print_insn_alpha
;
1277 /* Let the user set the fence post for heuristic_proc_start. */
1279 /* We really would like to have both "0" and "unlimited" work, but
1280 command.c doesn't deal with that. So make it a var_zinteger
1281 because the user can always use "999999" or some such for unlimited. */
1282 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1283 (char *) &heuristic_fence_post
,
1285 Set the distance searched for the start of a function.\n\
1286 If you are debugging a stripped executable, GDB needs to search through the\n\
1287 program for the start of a function. This command sets the distance of the\n\
1288 search. The only need to set it is when debugging a stripped executable.",
1290 /* We need to throw away the frame cache when we set this, since it
1291 might change our ability to get backtraces. */
1292 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1293 add_show_from_set (c
, &showlist
);