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 stored in ARG_REG_BUFFER, and
177 then moved into the register file; this simplifies the passing of a
178 large struct which extends from the registers to the stack, plus avoids
179 three ptrace invocations per word.
181 We don't bother tracking which register values should go in integer
182 regs or fp regs; we load the same values into both.
184 If the called function is returning a structure, the address of the
185 structure to be returned is passed as a hidden first argument. */
188 alpha_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
189 struct regcache
*regcache
, CORE_ADDR bp_addr
,
190 int nargs
, struct value
**args
, CORE_ADDR sp
,
191 int struct_return
, CORE_ADDR struct_addr
)
194 int accumulate_size
= struct_return
? 8 : 0;
201 struct alpha_arg
*alpha_args
202 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
203 register struct alpha_arg
*m_arg
;
204 char arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
205 int required_arg_regs
;
207 /* The ABI places the address of the called function in T12. */
208 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
210 /* Set the return address register to point to the entry point
211 of the program, where a breakpoint lies in wait. */
212 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
214 /* Lay out the arguments in memory. */
215 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
217 struct value
*arg
= args
[i
];
218 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
220 /* Cast argument to long if necessary as the compiler does it too. */
221 switch (TYPE_CODE (arg_type
))
226 case TYPE_CODE_RANGE
:
228 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
230 arg_type
= builtin_type_long
;
231 arg
= value_cast (arg_type
, arg
);
235 /* "float" arguments loaded in registers must be passed in
236 register format, aka "double". */
237 if (accumulate_size
< sizeof (arg_reg_buffer
)
238 && TYPE_LENGTH (arg_type
) == 4)
240 arg_type
= builtin_type_double
;
241 arg
= value_cast (arg_type
, arg
);
243 /* Tru64 5.1 has a 128-bit long double, and passes this by
244 invisible reference. No one else uses this data type. */
245 else if (TYPE_LENGTH (arg_type
) == 16)
247 /* Allocate aligned storage. */
248 sp
= (sp
& -16) - 16;
250 /* Write the real data into the stack. */
251 write_memory (sp
, VALUE_CONTENTS (arg
), 16);
253 /* Construct the indirection. */
254 arg_type
= lookup_pointer_type (arg_type
);
255 arg
= value_from_pointer (arg_type
, sp
);
261 m_arg
->len
= TYPE_LENGTH (arg_type
);
262 m_arg
->offset
= accumulate_size
;
263 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
264 m_arg
->contents
= VALUE_CONTENTS (arg
);
267 /* Determine required argument register loads, loading an argument register
268 is expensive as it uses three ptrace calls. */
269 required_arg_regs
= accumulate_size
/ 8;
270 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
271 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
273 /* Make room for the arguments on the stack. */
274 if (accumulate_size
< sizeof(arg_reg_buffer
))
277 accumulate_size
-= sizeof(arg_reg_buffer
);
278 sp
-= accumulate_size
;
280 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
283 /* `Push' arguments on the stack. */
284 for (i
= nargs
; m_arg
--, --i
>= 0;)
286 char *contents
= m_arg
->contents
;
287 int offset
= m_arg
->offset
;
288 int len
= m_arg
->len
;
290 /* Copy the bytes destined for registers into arg_reg_buffer. */
291 if (offset
< sizeof(arg_reg_buffer
))
293 if (offset
+ len
<= sizeof(arg_reg_buffer
))
295 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
300 int tlen
= sizeof(arg_reg_buffer
) - offset
;
301 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
308 /* Everything else goes to the stack. */
309 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
312 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
314 /* Load the argument registers. */
315 for (i
= 0; i
< required_arg_regs
; i
++)
319 val
= extract_unsigned_integer (arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
,
320 ALPHA_REGISTER_SIZE
);
321 regcache_cooked_write_signed (regcache
, ALPHA_A0_REGNUM
+ i
, val
);
322 regcache_cooked_write_signed (regcache
, ALPHA_FPA0_REGNUM
+ i
, val
);
328 /* Given a return value in `regbuf' with a type `valtype',
329 extract and copy its value into `valbuf'. */
332 alpha_extract_return_value (struct type
*valtype
,
333 char regbuf
[ALPHA_REGISTER_BYTES
], char *valbuf
)
335 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
336 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
337 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
340 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
341 TYPE_LENGTH (valtype
));
344 /* Given a return value in `regbuf' with a type `valtype',
345 write its value into the appropriate register. */
348 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
350 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
351 int regnum
= ALPHA_V0_REGNUM
;
352 int length
= TYPE_LENGTH (valtype
);
354 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
357 length
= REGISTER_RAW_SIZE (regnum
);
358 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
361 memcpy (raw_buffer
, valbuf
, length
);
363 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
367 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
369 /* Structures are returned by ref in extra arg0. */
374 alpha_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
376 /* Store the address of the place in which to copy the structure the
377 subroutine will return. Handled by alpha_push_arguments. */
381 alpha_extract_struct_value_address (char *regbuf
)
383 return (extract_address (regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
384 REGISTER_RAW_SIZE (ALPHA_V0_REGNUM
)));
388 static const unsigned char *
389 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
391 static const unsigned char alpha_breakpoint
[] =
392 { 0x80, 0, 0, 0 }; /* call_pal bpt */
394 *lenptr
= sizeof(alpha_breakpoint
);
395 return (alpha_breakpoint
);
399 /* This returns the PC of the first insn after the prologue.
400 If we can't find the prologue, then return 0. */
403 alpha_after_prologue (CORE_ADDR pc
)
405 struct symtab_and_line sal
;
406 CORE_ADDR func_addr
, func_end
;
408 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
411 sal
= find_pc_line (func_addr
, 0);
412 if (sal
.end
< func_end
)
415 /* The line after the prologue is after the end of the function. In this
416 case, tell the caller to find the prologue the hard way. */
420 /* Read an instruction from memory at PC, looking through breakpoints. */
423 alpha_read_insn (CORE_ADDR pc
)
428 status
= read_memory_nobpt (pc
, buf
, 4);
430 memory_error (status
, pc
);
431 return extract_unsigned_integer (buf
, 4);
434 /* To skip prologues, I use this predicate. Returns either PC itself
435 if the code at PC does not look like a function prologue; otherwise
436 returns an address that (if we're lucky) follows the prologue. If
437 LENIENT, then we must skip everything which is involved in setting
438 up the frame (it's OK to skip more, just so long as we don't skip
439 anything which might clobber the registers which are being saved. */
442 alpha_skip_prologue (CORE_ADDR pc
)
446 CORE_ADDR post_prologue_pc
;
449 /* Silently return the unaltered pc upon memory errors.
450 This could happen on OSF/1 if decode_line_1 tries to skip the
451 prologue for quickstarted shared library functions when the
452 shared library is not yet mapped in.
453 Reading target memory is slow over serial lines, so we perform
454 this check only if the target has shared libraries (which all
455 Alpha targets do). */
456 if (target_read_memory (pc
, buf
, 4))
459 /* See if we can determine the end of the prologue via the symbol table.
460 If so, then return either PC, or the PC after the prologue, whichever
463 post_prologue_pc
= alpha_after_prologue (pc
);
464 if (post_prologue_pc
!= 0)
465 return max (pc
, post_prologue_pc
);
467 /* Can't determine prologue from the symbol table, need to examine
470 /* Skip the typical prologue instructions. These are the stack adjustment
471 instruction and the instructions that save registers on the stack
472 or in the gcc frame. */
473 for (offset
= 0; offset
< 100; offset
+= 4)
475 inst
= alpha_read_insn (pc
+ offset
);
477 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
479 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
481 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
483 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
486 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
487 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
488 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
491 if (inst
== 0x47de040f) /* bis sp,sp,fp */
493 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
502 /* Figure out where the longjmp will land.
503 We expect the first arg to be a pointer to the jmp_buf structure from
504 which we extract the PC (JB_PC) that we will land at. The PC is copied
505 into the "pc". This routine returns true on success. */
508 alpha_get_longjmp_target (CORE_ADDR
*pc
)
510 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
512 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
514 jb_addr
= read_register (ALPHA_A0_REGNUM
);
516 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
517 raw_buffer
, tdep
->jb_elt_size
))
520 *pc
= extract_address (raw_buffer
, tdep
->jb_elt_size
);
525 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
526 describe the location and shape of the sigcontext structure. After
527 that, all registers are in memory, so it's easy. */
528 /* ??? Shouldn't we be able to do this generically, rather than with
529 OSABI data specific to Alpha? */
531 struct alpha_sigtramp_unwind_cache
533 CORE_ADDR sigcontext_addr
;
536 static struct alpha_sigtramp_unwind_cache
*
537 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
538 void **this_prologue_cache
)
540 struct alpha_sigtramp_unwind_cache
*info
;
541 struct gdbarch_tdep
*tdep
;
543 if (*this_prologue_cache
)
544 return *this_prologue_cache
;
546 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
547 *this_prologue_cache
= info
;
549 tdep
= gdbarch_tdep (current_gdbarch
);
550 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
555 /* Return the address of REGNO in a sigtramp frame. Since this is all
556 arithmetic, it doesn't seem worthwhile to cache it. */
558 #ifndef SIGFRAME_PC_OFF
559 #define SIGFRAME_PC_OFF (2 * 8)
560 #define SIGFRAME_REGSAVE_OFF (4 * 8)
561 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
565 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, unsigned int regno
)
568 return sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ regno
* 8;
569 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
570 return sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ regno
* 8;
571 if (regno
== PC_REGNUM
)
572 return sigcontext_addr
+ SIGFRAME_PC_OFF
;
577 /* Given a GDB frame, determine the address of the calling function's
578 frame. This will be used to create a new GDB frame struct. */
581 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
582 void **this_prologue_cache
,
583 struct frame_id
*this_id
)
585 struct alpha_sigtramp_unwind_cache
*info
586 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
587 struct gdbarch_tdep
*tdep
;
588 CORE_ADDR stack_addr
, code_addr
;
590 /* If the OSABI couldn't locate the sigcontext, give up. */
591 if (info
->sigcontext_addr
== 0)
594 /* If we have dynamic signal trampolines, find their start.
595 If we do not, then we must assume there is a symbol record
596 that can provide the start address. */
597 tdep
= gdbarch_tdep (current_gdbarch
);
598 if (tdep
->dynamic_sigtramp_offset
)
601 code_addr
= frame_pc_unwind (next_frame
);
602 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
609 code_addr
= frame_func_unwind (next_frame
);
611 /* The stack address is trivially read from the sigcontext. */
612 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
614 stack_addr
= read_memory_unsigned_integer (stack_addr
, ALPHA_REGISTER_SIZE
);
616 *this_id
= frame_id_build (stack_addr
, code_addr
);
619 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
622 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
623 void **this_prologue_cache
,
624 int regnum
, int *optimizedp
,
625 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
626 int *realnump
, void *bufferp
)
628 struct alpha_sigtramp_unwind_cache
*info
629 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
632 if (info
->sigcontext_addr
!= 0)
634 /* All integer and fp registers are stored in memory. */
635 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
639 *lvalp
= lval_memory
;
643 read_memory (addr
, bufferp
, ALPHA_REGISTER_SIZE
);
648 /* This extra register may actually be in the sigcontext, but our
649 current description of it in alpha_sigtramp_frame_unwind_cache
650 doesn't include it. Too bad. Fall back on whatever's in the
652 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
656 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
658 alpha_sigtramp_frame_this_id
,
659 alpha_sigtramp_frame_prev_register
662 static const struct frame_unwind
*
663 alpha_sigtramp_frame_p (CORE_ADDR pc
)
667 /* We shouldn't even bother to try if the OSABI didn't register
668 a sigcontext_addr handler. */
669 if (!gdbarch_tdep (current_gdbarch
)->sigcontext_addr
)
672 /* Otherwise we should be in a signal frame. */
673 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
674 if (PC_IN_SIGTRAMP (pc
, name
))
675 return &alpha_sigtramp_frame_unwind
;
680 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
681 something about the traditional layout of alpha stack frames. */
683 struct alpha_heuristic_unwind_cache
685 CORE_ADDR
*saved_regs
;
691 /* Heuristic_proc_start may hunt through the text section for a long
692 time across a 2400 baud serial line. Allows the user to limit this
694 static unsigned int heuristic_fence_post
= 0;
696 /* Attempt to locate the start of the function containing PC. We assume that
697 the previous function ends with an about_to_return insn. Not foolproof by
698 any means, since gcc is happy to put the epilogue in the middle of a
699 function. But we're guessing anyway... */
702 alpha_heuristic_proc_start (CORE_ADDR pc
)
704 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
705 CORE_ADDR last_non_nop
= pc
;
706 CORE_ADDR fence
= pc
- heuristic_fence_post
;
707 CORE_ADDR orig_pc
= pc
;
713 /* First see if we can find the start of the function from minimal
714 symbol information. This can succeed with a binary that doesn't
715 have debug info, but hasn't been stripped. */
716 func
= get_pc_function_start (pc
);
720 if (heuristic_fence_post
== UINT_MAX
721 || fence
< tdep
->vm_min_address
)
722 fence
= tdep
->vm_min_address
;
724 /* Search back for previous return; also stop at a 0, which might be
725 seen for instance before the start of a code section. Don't include
726 nops, since this usually indicates padding between functions. */
727 for (pc
-= 4; pc
>= fence
; pc
-= 4)
729 unsigned int insn
= alpha_read_insn (pc
);
732 case 0: /* invalid insn */
733 case 0x6bfa8001: /* ret $31,($26),1 */
736 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
737 case 0x47ff041f: /* nop: bis $31,$31,$31 */
746 /* It's not clear to me why we reach this point when stopping quietly,
747 but with this test, at least we don't print out warnings for every
748 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
749 if (stop_soon
== NO_STOP_QUIETLY
)
751 static int blurb_printed
= 0;
753 if (fence
== tdep
->vm_min_address
)
754 warning ("Hit beginning of text section without finding");
756 warning ("Hit heuristic-fence-post without finding");
757 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
762 This warning occurs if you are debugging a function without any symbols\n\
763 (for example, in a stripped executable). In that case, you may wish to\n\
764 increase the size of the search with the `set heuristic-fence-post' command.\n\
766 Otherwise, you told GDB there was a function where there isn't one, or\n\
767 (more likely) you have encountered a bug in GDB.\n");
775 static struct alpha_heuristic_unwind_cache
*
776 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
777 void **this_prologue_cache
,
780 struct alpha_heuristic_unwind_cache
*info
;
782 CORE_ADDR limit_pc
, cur_pc
;
783 int frame_reg
, frame_size
, return_reg
, reg
;
785 if (*this_prologue_cache
)
786 return *this_prologue_cache
;
788 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
789 *this_prologue_cache
= info
;
790 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
792 limit_pc
= frame_pc_unwind (next_frame
);
794 start_pc
= alpha_heuristic_proc_start (limit_pc
);
795 info
->start_pc
= start_pc
;
797 frame_reg
= ALPHA_SP_REGNUM
;
801 /* If we've identified a likely place to start, do code scanning. */
804 /* Limit the forward search to 50 instructions. */
805 if (start_pc
+ 200 < limit_pc
)
806 limit_pc
= start_pc
+ 200;
808 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
810 unsigned int word
= alpha_read_insn (cur_pc
);
812 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
816 /* Consider only the first stack allocation instruction
817 to contain the static size of the frame. */
819 frame_size
= (-word
) & 0xffff;
823 /* Exit loop if a positive stack adjustment is found, which
824 usually means that the stack cleanup code in the function
825 epilogue is reached. */
829 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
831 reg
= (word
& 0x03e00000) >> 21;
836 /* Do not compute the address where the register was saved yet,
837 because we don't know yet if the offset will need to be
838 relative to $sp or $fp (we can not compute the address
839 relative to $sp if $sp is updated during the execution of
840 the current subroutine, for instance when doing some alloca).
841 So just store the offset for the moment, and compute the
842 address later when we know whether this frame has a frame
844 /* Hack: temporarily add one, so that the offset is non-zero
845 and we can tell which registers have save offsets below. */
846 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
848 /* Starting with OSF/1-3.2C, the system libraries are shipped
849 without local symbols, but they still contain procedure
850 descriptors without a symbol reference. GDB is currently
851 unable to find these procedure descriptors and uses
852 heuristic_proc_desc instead.
853 As some low level compiler support routines (__div*, __add*)
854 use a non-standard return address register, we have to
855 add some heuristics to determine the return address register,
856 or stepping over these routines will fail.
857 Usually the return address register is the first register
858 saved on the stack, but assembler optimization might
859 rearrange the register saves.
860 So we recognize only a few registers (t7, t9, ra) within
861 the procedure prologue as valid return address registers.
862 If we encounter a return instruction, we extract the
863 the return address register from it.
865 FIXME: Rewriting GDB to access the procedure descriptors,
866 e.g. via the minimal symbol table, might obviate this hack. */
868 && cur_pc
< (start_pc
+ 80)
869 && (reg
== ALPHA_T7_REGNUM
870 || reg
== ALPHA_T9_REGNUM
871 || reg
== ALPHA_RA_REGNUM
))
874 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
875 return_reg
= (word
>> 16) & 0x1f;
876 else if (word
== 0x47de040f) /* bis sp,sp,fp */
877 frame_reg
= ALPHA_GCC_FP_REGNUM
;
878 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
879 frame_reg
= ALPHA_GCC_FP_REGNUM
;
882 /* If we haven't found a valid return address register yet, keep
883 searching in the procedure prologue. */
884 if (return_reg
== -1)
886 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
888 unsigned int word
= alpha_read_insn (cur_pc
);
890 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
892 reg
= (word
& 0x03e00000) >> 21;
893 if (reg
== ALPHA_T7_REGNUM
894 || reg
== ALPHA_T9_REGNUM
895 || reg
== ALPHA_RA_REGNUM
)
901 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
903 return_reg
= (word
>> 16) & 0x1f;
912 /* Failing that, do default to the customary RA. */
913 if (return_reg
== -1)
914 return_reg
= ALPHA_RA_REGNUM
;
915 info
->return_reg
= return_reg
;
917 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
918 info
->vfp
= val
+ frame_size
;
920 /* Convert offsets to absolute addresses. See above about adding
921 one to the offsets to make all detected offsets non-zero. */
922 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
923 if (info
->saved_regs
[reg
])
924 info
->saved_regs
[reg
] += val
- 1;
929 /* Given a GDB frame, determine the address of the calling function's
930 frame. This will be used to create a new GDB frame struct. */
933 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
934 void **this_prologue_cache
,
935 struct frame_id
*this_id
)
937 struct alpha_heuristic_unwind_cache
*info
938 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
940 /* This is meant to halt the backtrace at "_start". Make sure we
941 don't halt it at a generic dummy frame. */
942 if (inside_entry_file (info
->start_pc
))
945 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
948 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
951 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
952 void **this_prologue_cache
,
953 int regnum
, int *optimizedp
,
954 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
955 int *realnump
, void *bufferp
)
957 struct alpha_heuristic_unwind_cache
*info
958 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
960 /* The PC of the previous frame is stored in the link register of
961 the current frame. Frob regnum so that we pull the value from
962 the correct place. */
963 if (regnum
== ALPHA_PC_REGNUM
)
964 regnum
= info
->return_reg
;
966 /* For all registers known to be saved in the current frame,
967 do the obvious and pull the value out. */
968 if (info
->saved_regs
[regnum
])
971 *lvalp
= lval_memory
;
972 *addrp
= info
->saved_regs
[regnum
];
975 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
979 /* The stack pointer of the previous frame is computed by popping
980 the current stack frame. */
981 if (regnum
== ALPHA_SP_REGNUM
)
988 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
992 /* Otherwise assume the next frame has the same register value. */
993 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
997 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
999 alpha_heuristic_frame_this_id
,
1000 alpha_heuristic_frame_prev_register
1003 static const struct frame_unwind
*
1004 alpha_heuristic_frame_p (CORE_ADDR pc
)
1006 return &alpha_heuristic_frame_unwind
;
1010 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1011 void **this_prologue_cache
)
1013 struct alpha_heuristic_unwind_cache
*info
1014 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1019 static const struct frame_base alpha_heuristic_frame_base
= {
1020 &alpha_heuristic_frame_unwind
,
1021 alpha_heuristic_frame_base_address
,
1022 alpha_heuristic_frame_base_address
,
1023 alpha_heuristic_frame_base_address
1026 /* Just like reinit_frame_cache, but with the right arguments to be
1027 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1030 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1032 reinit_frame_cache ();
1036 /* ALPHA stack frames are almost impenetrable. When execution stops,
1037 we basically have to look at symbol information for the function
1038 that we stopped in, which tells us *which* register (if any) is
1039 the base of the frame pointer, and what offset from that register
1040 the frame itself is at.
1042 This presents a problem when trying to examine a stack in memory
1043 (that isn't executing at the moment), using the "frame" command. We
1044 don't have a PC, nor do we have any registers except SP.
1046 This routine takes two arguments, SP and PC, and tries to make the
1047 cached frames look as if these two arguments defined a frame on the
1048 cache. This allows the rest of info frame to extract the important
1049 arguments without difficulty. */
1052 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1055 error ("ALPHA frame specifications require two arguments: sp and pc");
1057 return create_new_frame (argv
[0], argv
[1]);
1060 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1061 dummy frame. The frame ID's base needs to match the TOS value
1062 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1065 static struct frame_id
1066 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1069 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1070 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1074 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1077 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1082 /* alpha_software_single_step() is called just before we want to resume
1083 the inferior, if we want to single-step it but there is no hardware
1084 or kernel single-step support (NetBSD on Alpha, for example). We find
1085 the target of the coming instruction and breakpoint it.
1087 single_step is also called just after the inferior stops. If we had
1088 set up a simulated single-step, we undo our damage. */
1091 alpha_next_pc (CORE_ADDR pc
)
1098 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1100 /* Opcode is top 6 bits. */
1101 op
= (insn
>> 26) & 0x3f;
1105 /* Jump format: target PC is:
1107 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1110 if ((op
& 0x30) == 0x30)
1112 /* Branch format: target PC is:
1113 (new PC) + (4 * sext(displacement)) */
1114 if (op
== 0x30 || /* BR */
1115 op
== 0x34) /* BSR */
1118 offset
= (insn
& 0x001fffff);
1119 if (offset
& 0x00100000)
1120 offset
|= 0xffe00000;
1122 return (pc
+ 4 + offset
);
1125 /* Need to determine if branch is taken; read RA. */
1126 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1129 case 0x38: /* BLBC */
1133 case 0x3c: /* BLBS */
1137 case 0x39: /* BEQ */
1141 case 0x3d: /* BNE */
1145 case 0x3a: /* BLT */
1149 case 0x3b: /* BLE */
1153 case 0x3f: /* BGT */
1157 case 0x3e: /* BGE */
1162 /* ??? Missing floating-point branches. */
1166 /* Not a branch or branch not taken; target PC is:
1172 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1174 static CORE_ADDR next_pc
;
1175 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1176 static binsn_quantum break_mem
;
1179 if (insert_breakpoints_p
)
1182 next_pc
= alpha_next_pc (pc
);
1184 target_insert_breakpoint (next_pc
, break_mem
);
1188 target_remove_breakpoint (next_pc
, break_mem
);
1194 /* Initialize the current architecture based on INFO. If possible, re-use an
1195 architecture from ARCHES, which is a list of architectures already created
1196 during this debugging session.
1198 Called e.g. at program startup, when reading a core file, and when reading
1201 static struct gdbarch
*
1202 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1204 struct gdbarch_tdep
*tdep
;
1205 struct gdbarch
*gdbarch
;
1207 /* Try to determine the ABI of the object we are loading. */
1208 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1210 /* If it's an ECOFF file, assume it's OSF/1. */
1211 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1212 info
.osabi
= GDB_OSABI_OSF1
;
1215 /* Find a candidate among extant architectures. */
1216 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1218 return arches
->gdbarch
;
1220 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1221 gdbarch
= gdbarch_alloc (&info
, tdep
);
1223 /* Lowest text address. This is used by heuristic_proc_start()
1224 to decide when to stop looking. */
1225 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1227 tdep
->dynamic_sigtramp_offset
= NULL
;
1228 tdep
->sigcontext_addr
= NULL
;
1230 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1233 set_gdbarch_short_bit (gdbarch
, 16);
1234 set_gdbarch_int_bit (gdbarch
, 32);
1235 set_gdbarch_long_bit (gdbarch
, 64);
1236 set_gdbarch_long_long_bit (gdbarch
, 64);
1237 set_gdbarch_float_bit (gdbarch
, 32);
1238 set_gdbarch_double_bit (gdbarch
, 64);
1239 set_gdbarch_long_double_bit (gdbarch
, 64);
1240 set_gdbarch_ptr_bit (gdbarch
, 64);
1243 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1244 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1245 set_gdbarch_deprecated_fp_regnum (gdbarch
, ALPHA_FP_REGNUM
);
1246 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1247 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1249 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1250 set_gdbarch_deprecated_register_size (gdbarch
, ALPHA_REGISTER_SIZE
);
1251 set_gdbarch_deprecated_register_bytes (gdbarch
, ALPHA_REGISTER_BYTES
);
1252 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1253 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1254 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, ALPHA_MAX_REGISTER_RAW_SIZE
);
1255 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1256 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
1257 ALPHA_MAX_REGISTER_VIRTUAL_SIZE
);
1258 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1260 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1261 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1263 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1264 set_gdbarch_register_convert_to_virtual (gdbarch
,
1265 alpha_register_convert_to_virtual
);
1266 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1268 /* Prologue heuristics. */
1269 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1272 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1273 set_gdbarch_frameless_function_invocation (gdbarch
,
1274 generic_frameless_function_invocation_not
);
1276 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1277 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1278 set_gdbarch_deprecated_store_struct_return (gdbarch
, alpha_store_struct_return
);
1279 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1280 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1281 alpha_extract_struct_value_address
);
1283 /* Settings for calling functions in the inferior. */
1284 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1286 /* Methods for saving / extracting a dummy frame's ID. */
1287 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1288 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1290 /* Return the unwound PC value. */
1291 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1293 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1294 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1296 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1297 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1299 set_gdbarch_function_start_offset (gdbarch
, 0);
1300 set_gdbarch_frame_args_skip (gdbarch
, 0);
1302 /* Hook in ABI-specific overrides, if they have been registered. */
1303 gdbarch_init_osabi (info
, gdbarch
);
1305 /* Now that we have tuned the configuration, set a few final things
1306 based on what the OS ABI has told us. */
1308 if (tdep
->jb_pc
>= 0)
1309 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1311 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1312 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1314 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1320 _initialize_alpha_tdep (void)
1322 struct cmd_list_element
*c
;
1324 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1325 deprecated_tm_print_insn
= print_insn_alpha
;
1327 /* Let the user set the fence post for heuristic_proc_start. */
1329 /* We really would like to have both "0" and "unlimited" work, but
1330 command.c doesn't deal with that. So make it a var_zinteger
1331 because the user can always use "999999" or some such for unlimited. */
1332 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1333 (char *) &heuristic_fence_post
,
1335 Set the distance searched for the start of a function.\n\
1336 If you are debugging a stripped executable, GDB needs to search through the\n\
1337 program for the start of a function. This command sets the distance of the\n\
1338 search. The only need to set it is when debugging a stripped executable.",
1340 /* We need to throw away the frame cache when we set this, since it
1341 might change our ability to get backtraces. */
1342 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1343 add_show_from_set (c
, &showlist
);