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
;
674 /* First see if we can find the start of the function from minimal
675 symbol information. This can succeed with a binary that doesn't
676 have debug info, but hasn't been stripped. */
677 func
= get_pc_function_start (pc
);
681 if (heuristic_fence_post
== UINT_MAX
682 || fence
< tdep
->vm_min_address
)
683 fence
= tdep
->vm_min_address
;
685 /* Search back for previous return; also stop at a 0, which might be
686 seen for instance before the start of a code section. Don't include
687 nops, since this usually indicates padding between functions. */
688 for (pc
-= 4; pc
>= fence
; pc
-= 4)
690 unsigned int insn
= alpha_read_insn (pc
);
693 case 0: /* invalid insn */
694 case 0x6bfa8001: /* ret $31,($26),1 */
697 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
698 case 0x47ff041f: /* nop: bis $31,$31,$31 */
707 /* It's not clear to me why we reach this point when stopping quietly,
708 but with this test, at least we don't print out warnings for every
709 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
710 if (stop_soon
== NO_STOP_QUIETLY
)
712 static int blurb_printed
= 0;
714 if (fence
== tdep
->vm_min_address
)
715 warning ("Hit beginning of text section without finding");
717 warning ("Hit heuristic-fence-post without finding");
718 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
723 This warning occurs if you are debugging a function without any symbols\n\
724 (for example, in a stripped executable). In that case, you may wish to\n\
725 increase the size of the search with the `set heuristic-fence-post' command.\n\
727 Otherwise, you told GDB there was a function where there isn't one, or\n\
728 (more likely) you have encountered a bug in GDB.\n");
736 static struct alpha_heuristic_unwind_cache
*
737 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
738 void **this_prologue_cache
,
741 struct alpha_heuristic_unwind_cache
*info
;
743 CORE_ADDR limit_pc
, cur_pc
;
744 int frame_reg
, frame_size
, return_reg
, reg
;
746 if (*this_prologue_cache
)
747 return *this_prologue_cache
;
749 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
750 *this_prologue_cache
= info
;
751 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
753 limit_pc
= frame_pc_unwind (next_frame
);
755 start_pc
= alpha_heuristic_proc_start (limit_pc
);
756 info
->start_pc
= start_pc
;
758 frame_reg
= ALPHA_SP_REGNUM
;
762 /* If we've identified a likely place to start, do code scanning. */
765 /* Limit the forward search to 50 instructions. */
766 if (start_pc
+ 200 < limit_pc
)
767 limit_pc
= start_pc
+ 200;
769 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
771 unsigned int word
= alpha_read_insn (cur_pc
);
773 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
777 /* Consider only the first stack allocation instruction
778 to contain the static size of the frame. */
780 frame_size
= (-word
) & 0xffff;
784 /* Exit loop if a positive stack adjustment is found, which
785 usually means that the stack cleanup code in the function
786 epilogue is reached. */
790 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
792 reg
= (word
& 0x03e00000) >> 21;
797 /* Do not compute the address where the register was saved yet,
798 because we don't know yet if the offset will need to be
799 relative to $sp or $fp (we can not compute the address
800 relative to $sp if $sp is updated during the execution of
801 the current subroutine, for instance when doing some alloca).
802 So just store the offset for the moment, and compute the
803 address later when we know whether this frame has a frame
805 /* Hack: temporarily add one, so that the offset is non-zero
806 and we can tell which registers have save offsets below. */
807 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
809 /* Starting with OSF/1-3.2C, the system libraries are shipped
810 without local symbols, but they still contain procedure
811 descriptors without a symbol reference. GDB is currently
812 unable to find these procedure descriptors and uses
813 heuristic_proc_desc instead.
814 As some low level compiler support routines (__div*, __add*)
815 use a non-standard return address register, we have to
816 add some heuristics to determine the return address register,
817 or stepping over these routines will fail.
818 Usually the return address register is the first register
819 saved on the stack, but assembler optimization might
820 rearrange the register saves.
821 So we recognize only a few registers (t7, t9, ra) within
822 the procedure prologue as valid return address registers.
823 If we encounter a return instruction, we extract the
824 the return address register from it.
826 FIXME: Rewriting GDB to access the procedure descriptors,
827 e.g. via the minimal symbol table, might obviate this hack. */
829 && cur_pc
< (start_pc
+ 80)
830 && (reg
== ALPHA_T7_REGNUM
831 || reg
== ALPHA_T9_REGNUM
832 || reg
== ALPHA_RA_REGNUM
))
835 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
836 return_reg
= (word
>> 16) & 0x1f;
837 else if (word
== 0x47de040f) /* bis sp,sp,fp */
838 frame_reg
= ALPHA_GCC_FP_REGNUM
;
839 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
840 frame_reg
= ALPHA_GCC_FP_REGNUM
;
843 /* If we haven't found a valid return address register yet, keep
844 searching in the procedure prologue. */
845 if (return_reg
== -1)
847 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
849 unsigned int word
= alpha_read_insn (cur_pc
);
851 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
853 reg
= (word
& 0x03e00000) >> 21;
854 if (reg
== ALPHA_T7_REGNUM
855 || reg
== ALPHA_T9_REGNUM
856 || reg
== ALPHA_RA_REGNUM
)
862 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
864 return_reg
= (word
>> 16) & 0x1f;
873 /* Failing that, do default to the customary RA. */
874 if (return_reg
== -1)
875 return_reg
= ALPHA_RA_REGNUM
;
876 info
->return_reg
= return_reg
;
878 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
879 info
->vfp
= val
+ frame_size
;
881 /* Convert offsets to absolute addresses. See above about adding
882 one to the offsets to make all detected offsets non-zero. */
883 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
884 if (info
->saved_regs
[reg
])
885 info
->saved_regs
[reg
] += val
- 1;
890 /* Given a GDB frame, determine the address of the calling function's
891 frame. This will be used to create a new GDB frame struct. */
894 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
895 void **this_prologue_cache
,
896 struct frame_id
*this_id
)
898 struct alpha_heuristic_unwind_cache
*info
899 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
901 /* This is meant to halt the backtrace at "_start". Make sure we
902 don't halt it at a generic dummy frame. */
903 if (inside_entry_file (info
->start_pc
))
906 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
909 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
912 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
913 void **this_prologue_cache
,
914 int regnum
, int *optimizedp
,
915 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
916 int *realnump
, void *bufferp
)
918 struct alpha_heuristic_unwind_cache
*info
919 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
921 /* The PC of the previous frame is stored in the link register of
922 the current frame. Frob regnum so that we pull the value from
923 the correct place. */
924 if (regnum
== ALPHA_PC_REGNUM
)
925 regnum
= info
->return_reg
;
927 /* For all registers known to be saved in the current frame,
928 do the obvious and pull the value out. */
929 if (info
->saved_regs
[regnum
])
932 *lvalp
= lval_memory
;
933 *addrp
= info
->saved_regs
[regnum
];
936 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
940 /* The stack pointer of the previous frame is computed by popping
941 the current stack frame. */
942 if (regnum
== ALPHA_SP_REGNUM
)
949 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
953 /* Otherwise assume the next frame has the same register value. */
954 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
958 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
960 alpha_heuristic_frame_this_id
,
961 alpha_heuristic_frame_prev_register
964 static const struct frame_unwind
*
965 alpha_heuristic_frame_p (CORE_ADDR pc
)
967 return &alpha_heuristic_frame_unwind
;
971 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
972 void **this_prologue_cache
)
974 struct alpha_heuristic_unwind_cache
*info
975 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
980 static const struct frame_base alpha_heuristic_frame_base
= {
981 &alpha_heuristic_frame_unwind
,
982 alpha_heuristic_frame_base_address
,
983 alpha_heuristic_frame_base_address
,
984 alpha_heuristic_frame_base_address
987 /* Just like reinit_frame_cache, but with the right arguments to be
988 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
991 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
993 reinit_frame_cache ();
997 /* ALPHA stack frames are almost impenetrable. When execution stops,
998 we basically have to look at symbol information for the function
999 that we stopped in, which tells us *which* register (if any) is
1000 the base of the frame pointer, and what offset from that register
1001 the frame itself is at.
1003 This presents a problem when trying to examine a stack in memory
1004 (that isn't executing at the moment), using the "frame" command. We
1005 don't have a PC, nor do we have any registers except SP.
1007 This routine takes two arguments, SP and PC, and tries to make the
1008 cached frames look as if these two arguments defined a frame on the
1009 cache. This allows the rest of info frame to extract the important
1010 arguments without difficulty. */
1013 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1016 error ("ALPHA frame specifications require two arguments: sp and pc");
1018 return create_new_frame (argv
[0], argv
[1]);
1021 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1022 dummy frame. The frame ID's base needs to match the TOS value
1023 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1026 static struct frame_id
1027 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1030 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1031 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1035 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1038 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1043 /* alpha_software_single_step() is called just before we want to resume
1044 the inferior, if we want to single-step it but there is no hardware
1045 or kernel single-step support (NetBSD on Alpha, for example). We find
1046 the target of the coming instruction and breakpoint it.
1048 single_step is also called just after the inferior stops. If we had
1049 set up a simulated single-step, we undo our damage. */
1052 alpha_next_pc (CORE_ADDR pc
)
1059 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1061 /* Opcode is top 6 bits. */
1062 op
= (insn
>> 26) & 0x3f;
1066 /* Jump format: target PC is:
1068 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1071 if ((op
& 0x30) == 0x30)
1073 /* Branch format: target PC is:
1074 (new PC) + (4 * sext(displacement)) */
1075 if (op
== 0x30 || /* BR */
1076 op
== 0x34) /* BSR */
1079 offset
= (insn
& 0x001fffff);
1080 if (offset
& 0x00100000)
1081 offset
|= 0xffe00000;
1083 return (pc
+ 4 + offset
);
1086 /* Need to determine if branch is taken; read RA. */
1087 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1090 case 0x38: /* BLBC */
1094 case 0x3c: /* BLBS */
1098 case 0x39: /* BEQ */
1102 case 0x3d: /* BNE */
1106 case 0x3a: /* BLT */
1110 case 0x3b: /* BLE */
1114 case 0x3f: /* BGT */
1118 case 0x3e: /* BGE */
1123 /* ??? Missing floating-point branches. */
1127 /* Not a branch or branch not taken; target PC is:
1133 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1135 static CORE_ADDR next_pc
;
1136 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1137 static binsn_quantum break_mem
;
1140 if (insert_breakpoints_p
)
1143 next_pc
= alpha_next_pc (pc
);
1145 target_insert_breakpoint (next_pc
, break_mem
);
1149 target_remove_breakpoint (next_pc
, break_mem
);
1155 /* Initialize the current architecture based on INFO. If possible, re-use an
1156 architecture from ARCHES, which is a list of architectures already created
1157 during this debugging session.
1159 Called e.g. at program startup, when reading a core file, and when reading
1162 static struct gdbarch
*
1163 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1165 struct gdbarch_tdep
*tdep
;
1166 struct gdbarch
*gdbarch
;
1168 /* Try to determine the ABI of the object we are loading. */
1169 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1171 /* If it's an ECOFF file, assume it's OSF/1. */
1172 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1173 info
.osabi
= GDB_OSABI_OSF1
;
1176 /* Find a candidate among extant architectures. */
1177 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1179 return arches
->gdbarch
;
1181 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1182 gdbarch
= gdbarch_alloc (&info
, tdep
);
1184 /* Lowest text address. This is used by heuristic_proc_start()
1185 to decide when to stop looking. */
1186 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1188 tdep
->dynamic_sigtramp_offset
= NULL
;
1189 tdep
->sigcontext_addr
= NULL
;
1191 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1194 set_gdbarch_short_bit (gdbarch
, 16);
1195 set_gdbarch_int_bit (gdbarch
, 32);
1196 set_gdbarch_long_bit (gdbarch
, 64);
1197 set_gdbarch_long_long_bit (gdbarch
, 64);
1198 set_gdbarch_float_bit (gdbarch
, 32);
1199 set_gdbarch_double_bit (gdbarch
, 64);
1200 set_gdbarch_long_double_bit (gdbarch
, 64);
1201 set_gdbarch_ptr_bit (gdbarch
, 64);
1204 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1205 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1206 set_gdbarch_deprecated_fp_regnum (gdbarch
, ALPHA_FP_REGNUM
);
1207 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1208 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1210 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1211 set_gdbarch_deprecated_register_size (gdbarch
, ALPHA_REGISTER_SIZE
);
1212 set_gdbarch_deprecated_register_bytes (gdbarch
, ALPHA_REGISTER_BYTES
);
1213 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1214 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1215 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, ALPHA_MAX_REGISTER_RAW_SIZE
);
1216 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1217 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
1218 ALPHA_MAX_REGISTER_VIRTUAL_SIZE
);
1219 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1221 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1222 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1224 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1225 set_gdbarch_register_convert_to_virtual (gdbarch
,
1226 alpha_register_convert_to_virtual
);
1227 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1229 /* Prologue heuristics. */
1230 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1233 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1234 set_gdbarch_frameless_function_invocation (gdbarch
,
1235 generic_frameless_function_invocation_not
);
1237 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1238 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1239 set_gdbarch_deprecated_store_struct_return (gdbarch
, alpha_store_struct_return
);
1240 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1241 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1242 alpha_extract_struct_value_address
);
1244 /* Settings for calling functions in the inferior. */
1245 set_gdbarch_deprecated_push_arguments (gdbarch
, alpha_push_arguments
);
1246 set_gdbarch_deprecated_call_dummy_words (gdbarch
, alpha_call_dummy_words
);
1247 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
1248 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1249 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, alpha_fix_call_dummy
);
1251 /* Methods for saving / extracting a dummy frame's ID. */
1252 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1253 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1255 /* Return the unwound PC value. */
1256 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1258 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1259 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1261 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1262 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1264 set_gdbarch_function_start_offset (gdbarch
, 0);
1265 set_gdbarch_frame_args_skip (gdbarch
, 0);
1267 /* Hook in ABI-specific overrides, if they have been registered. */
1268 gdbarch_init_osabi (info
, gdbarch
);
1270 /* Now that we have tuned the configuration, set a few final things
1271 based on what the OS ABI has told us. */
1273 if (tdep
->jb_pc
>= 0)
1274 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1276 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1277 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1279 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1285 _initialize_alpha_tdep (void)
1287 struct cmd_list_element
*c
;
1289 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1290 deprecated_tm_print_insn
= print_insn_alpha
;
1292 /* Let the user set the fence post for heuristic_proc_start. */
1294 /* We really would like to have both "0" and "unlimited" work, but
1295 command.c doesn't deal with that. So make it a var_zinteger
1296 because the user can always use "999999" or some such for unlimited. */
1297 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1298 (char *) &heuristic_fence_post
,
1300 Set the distance searched for the start of a function.\n\
1301 If you are debugging a stripped executable, GDB needs to search through the\n\
1302 program for the start of a function. This command sets the distance of the\n\
1303 search. The only need to set it is when debugging a stripped executable.",
1305 /* We need to throw away the frame cache when we set this, since it
1306 might change our ability to get backtraces. */
1307 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1308 add_show_from_set (c
, &showlist
);