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;
865 /* Failing that, do default to the customary RA. */
866 if (return_reg
== -1)
867 return_reg
= ALPHA_RA_REGNUM
;
868 info
->return_reg
= return_reg
;
870 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
871 info
->vfp
= val
+ frame_size
;
873 /* Convert offsets to absolute addresses. See above about adding
874 one to the offsets to make all detected offsets non-zero. */
875 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
876 if (info
->saved_regs
[reg
])
877 info
->saved_regs
[reg
] += val
- 1;
882 /* Given a GDB frame, determine the address of the calling function's
883 frame. This will be used to create a new GDB frame struct. */
886 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
887 void **this_prologue_cache
,
888 struct frame_id
*this_id
)
890 struct alpha_heuristic_unwind_cache
*info
891 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
893 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
896 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
899 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
900 void **this_prologue_cache
,
901 int regnum
, int *optimizedp
,
902 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
903 int *realnump
, void *bufferp
)
905 struct alpha_heuristic_unwind_cache
*info
906 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
908 /* The PC of the previous frame is stored in the link register of
909 the current frame. Frob regnum so that we pull the value from
910 the correct place. */
911 if (regnum
== ALPHA_PC_REGNUM
)
912 regnum
= info
->return_reg
;
914 /* For all registers known to be saved in the current frame,
915 do the obvious and pull the value out. */
916 if (info
->saved_regs
[regnum
])
919 *lvalp
= lval_memory
;
920 *addrp
= info
->saved_regs
[regnum
];
923 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
927 /* The stack pointer of the previous frame is computed by popping
928 the current stack frame. */
929 if (regnum
== ALPHA_SP_REGNUM
)
936 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
940 /* Otherwise assume the next frame has the same register value. */
941 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
945 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
947 alpha_heuristic_frame_this_id
,
948 alpha_heuristic_frame_prev_register
951 static const struct frame_unwind
*
952 alpha_heuristic_frame_p (CORE_ADDR pc
)
954 return &alpha_heuristic_frame_unwind
;
958 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
959 void **this_prologue_cache
)
961 struct alpha_heuristic_unwind_cache
*info
962 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
967 static const struct frame_base alpha_heuristic_frame_base
= {
968 &alpha_heuristic_frame_unwind
,
969 alpha_heuristic_frame_base_address
,
970 alpha_heuristic_frame_base_address
,
971 alpha_heuristic_frame_base_address
974 /* Just like reinit_frame_cache, but with the right arguments to be
975 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
978 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
980 reinit_frame_cache ();
984 /* ALPHA stack frames are almost impenetrable. When execution stops,
985 we basically have to look at symbol information for the function
986 that we stopped in, which tells us *which* register (if any) is
987 the base of the frame pointer, and what offset from that register
988 the frame itself is at.
990 This presents a problem when trying to examine a stack in memory
991 (that isn't executing at the moment), using the "frame" command. We
992 don't have a PC, nor do we have any registers except SP.
994 This routine takes two arguments, SP and PC, and tries to make the
995 cached frames look as if these two arguments defined a frame on the
996 cache. This allows the rest of info frame to extract the important
997 arguments without difficulty. */
1000 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1003 error ("ALPHA frame specifications require two arguments: sp and pc");
1005 return create_new_frame (argv
[0], argv
[1]);
1008 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1009 dummy frame. The frame ID's base needs to match the TOS value
1010 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1013 static struct frame_id
1014 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1017 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1018 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1022 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1025 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1030 /* alpha_software_single_step() is called just before we want to resume
1031 the inferior, if we want to single-step it but there is no hardware
1032 or kernel single-step support (NetBSD on Alpha, for example). We find
1033 the target of the coming instruction and breakpoint it.
1035 single_step is also called just after the inferior stops. If we had
1036 set up a simulated single-step, we undo our damage. */
1039 alpha_next_pc (CORE_ADDR pc
)
1046 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1048 /* Opcode is top 6 bits. */
1049 op
= (insn
>> 26) & 0x3f;
1053 /* Jump format: target PC is:
1055 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1058 if ((op
& 0x30) == 0x30)
1060 /* Branch format: target PC is:
1061 (new PC) + (4 * sext(displacement)) */
1062 if (op
== 0x30 || /* BR */
1063 op
== 0x34) /* BSR */
1066 offset
= (insn
& 0x001fffff);
1067 if (offset
& 0x00100000)
1068 offset
|= 0xffe00000;
1070 return (pc
+ 4 + offset
);
1073 /* Need to determine if branch is taken; read RA. */
1074 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1077 case 0x38: /* BLBC */
1081 case 0x3c: /* BLBS */
1085 case 0x39: /* BEQ */
1089 case 0x3d: /* BNE */
1093 case 0x3a: /* BLT */
1097 case 0x3b: /* BLE */
1101 case 0x3f: /* BGT */
1105 case 0x3e: /* BGE */
1110 /* ??? Missing floating-point branches. */
1114 /* Not a branch or branch not taken; target PC is:
1120 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1122 static CORE_ADDR next_pc
;
1123 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1124 static binsn_quantum break_mem
;
1127 if (insert_breakpoints_p
)
1130 next_pc
= alpha_next_pc (pc
);
1132 target_insert_breakpoint (next_pc
, break_mem
);
1136 target_remove_breakpoint (next_pc
, break_mem
);
1142 /* Initialize the current architecture based on INFO. If possible, re-use an
1143 architecture from ARCHES, which is a list of architectures already created
1144 during this debugging session.
1146 Called e.g. at program startup, when reading a core file, and when reading
1149 static struct gdbarch
*
1150 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1152 struct gdbarch_tdep
*tdep
;
1153 struct gdbarch
*gdbarch
;
1155 /* Try to determine the ABI of the object we are loading. */
1156 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1158 /* If it's an ECOFF file, assume it's OSF/1. */
1159 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1160 info
.osabi
= GDB_OSABI_OSF1
;
1163 /* Find a candidate among extant architectures. */
1164 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1166 return arches
->gdbarch
;
1168 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1169 gdbarch
= gdbarch_alloc (&info
, tdep
);
1171 /* Lowest text address. This is used by heuristic_proc_start()
1172 to decide when to stop looking. */
1173 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1175 tdep
->dynamic_sigtramp_offset
= NULL
;
1176 tdep
->sigcontext_addr
= NULL
;
1178 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1181 set_gdbarch_short_bit (gdbarch
, 16);
1182 set_gdbarch_int_bit (gdbarch
, 32);
1183 set_gdbarch_long_bit (gdbarch
, 64);
1184 set_gdbarch_long_long_bit (gdbarch
, 64);
1185 set_gdbarch_float_bit (gdbarch
, 32);
1186 set_gdbarch_double_bit (gdbarch
, 64);
1187 set_gdbarch_long_double_bit (gdbarch
, 64);
1188 set_gdbarch_ptr_bit (gdbarch
, 64);
1191 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1192 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1193 set_gdbarch_deprecated_fp_regnum (gdbarch
, ALPHA_FP_REGNUM
);
1194 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1195 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1197 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1198 set_gdbarch_deprecated_register_size (gdbarch
, ALPHA_REGISTER_SIZE
);
1199 set_gdbarch_deprecated_register_bytes (gdbarch
, ALPHA_REGISTER_BYTES
);
1200 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1201 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1202 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, ALPHA_MAX_REGISTER_RAW_SIZE
);
1203 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1204 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
1205 ALPHA_MAX_REGISTER_VIRTUAL_SIZE
);
1206 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1208 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1209 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1211 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1212 set_gdbarch_register_convert_to_virtual (gdbarch
,
1213 alpha_register_convert_to_virtual
);
1214 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1216 /* Prologue heuristics. */
1217 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1220 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1221 set_gdbarch_frameless_function_invocation (gdbarch
,
1222 generic_frameless_function_invocation_not
);
1224 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1225 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1226 set_gdbarch_deprecated_store_struct_return (gdbarch
, alpha_store_struct_return
);
1227 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1228 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1229 alpha_extract_struct_value_address
);
1231 /* Settings for calling functions in the inferior. */
1232 set_gdbarch_deprecated_push_arguments (gdbarch
, alpha_push_arguments
);
1233 set_gdbarch_deprecated_call_dummy_words (gdbarch
, alpha_call_dummy_words
);
1234 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
1235 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1236 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, alpha_fix_call_dummy
);
1238 /* Methods for saving / extracting a dummy frame's ID. */
1239 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1240 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1242 /* Return the unwound PC value. */
1243 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1245 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1246 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1248 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1249 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1251 set_gdbarch_function_start_offset (gdbarch
, 0);
1252 set_gdbarch_frame_args_skip (gdbarch
, 0);
1254 /* Hook in ABI-specific overrides, if they have been registered. */
1255 gdbarch_init_osabi (info
, gdbarch
);
1257 /* Now that we have tuned the configuration, set a few final things
1258 based on what the OS ABI has told us. */
1260 if (tdep
->jb_pc
>= 0)
1261 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1263 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1264 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1266 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1272 _initialize_alpha_tdep (void)
1274 struct cmd_list_element
*c
;
1276 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1277 deprecated_tm_print_insn
= print_insn_alpha
;
1279 /* Let the user set the fence post for heuristic_proc_start. */
1281 /* We really would like to have both "0" and "unlimited" work, but
1282 command.c doesn't deal with that. So make it a var_zinteger
1283 because the user can always use "999999" or some such for unlimited. */
1284 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1285 (char *) &heuristic_fence_post
,
1287 Set the distance searched for the start of a function.\n\
1288 If you are debugging a stripped executable, GDB needs to search through the\n\
1289 program for the start of a function. This command sets the distance of the\n\
1290 search. The only need to set it is when debugging a stripped executable.",
1292 /* We need to throw away the frame cache when we set this, since it
1293 might change our ability to get backtraces. */
1294 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1295 add_show_from_set (c
, &showlist
);