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 const char * const 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",
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_ZERO_REGNUM
;
77 alpha_cannot_store_register (int regno
)
79 return 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
++)
317 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
318 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
319 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
320 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
323 /* Finally, update the stack pointer. */
324 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
329 /* Given a return value in `regbuf' with a type `valtype',
330 extract and copy its value into `valbuf'. */
333 alpha_extract_return_value (struct type
*valtype
,
334 char regbuf
[ALPHA_REGISTER_BYTES
], char *valbuf
)
336 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
337 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
338 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
341 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
342 TYPE_LENGTH (valtype
));
345 /* Given a return value in `regbuf' with a type `valtype',
346 write its value into the appropriate register. */
349 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
351 char raw_buffer
[ALPHA_REGISTER_SIZE
];
352 int regnum
= ALPHA_V0_REGNUM
;
353 int length
= TYPE_LENGTH (valtype
);
355 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
358 length
= ALPHA_REGISTER_SIZE
;
359 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
362 memcpy (raw_buffer
, valbuf
, length
);
364 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
368 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
370 /* Structures are returned by ref in extra arg0. */
375 alpha_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
377 /* Store the address of the place in which to copy the structure the
378 subroutine will return. Handled by alpha_push_arguments. */
382 alpha_extract_struct_value_address (char *regbuf
)
384 return (extract_address (regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
385 REGISTER_RAW_SIZE (ALPHA_V0_REGNUM
)));
389 static const unsigned char *
390 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
392 static const unsigned char alpha_breakpoint
[] =
393 { 0x80, 0, 0, 0 }; /* call_pal bpt */
395 *lenptr
= sizeof(alpha_breakpoint
);
396 return (alpha_breakpoint
);
400 /* This returns the PC of the first insn after the prologue.
401 If we can't find the prologue, then return 0. */
404 alpha_after_prologue (CORE_ADDR pc
)
406 struct symtab_and_line sal
;
407 CORE_ADDR func_addr
, func_end
;
409 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
412 sal
= find_pc_line (func_addr
, 0);
413 if (sal
.end
< func_end
)
416 /* The line after the prologue is after the end of the function. In this
417 case, tell the caller to find the prologue the hard way. */
421 /* Read an instruction from memory at PC, looking through breakpoints. */
424 alpha_read_insn (CORE_ADDR pc
)
429 status
= read_memory_nobpt (pc
, buf
, 4);
431 memory_error (status
, pc
);
432 return extract_unsigned_integer (buf
, 4);
435 /* To skip prologues, I use this predicate. Returns either PC itself
436 if the code at PC does not look like a function prologue; otherwise
437 returns an address that (if we're lucky) follows the prologue. If
438 LENIENT, then we must skip everything which is involved in setting
439 up the frame (it's OK to skip more, just so long as we don't skip
440 anything which might clobber the registers which are being saved. */
443 alpha_skip_prologue (CORE_ADDR pc
)
447 CORE_ADDR post_prologue_pc
;
450 /* Silently return the unaltered pc upon memory errors.
451 This could happen on OSF/1 if decode_line_1 tries to skip the
452 prologue for quickstarted shared library functions when the
453 shared library is not yet mapped in.
454 Reading target memory is slow over serial lines, so we perform
455 this check only if the target has shared libraries (which all
456 Alpha targets do). */
457 if (target_read_memory (pc
, buf
, 4))
460 /* See if we can determine the end of the prologue via the symbol table.
461 If so, then return either PC, or the PC after the prologue, whichever
464 post_prologue_pc
= alpha_after_prologue (pc
);
465 if (post_prologue_pc
!= 0)
466 return max (pc
, post_prologue_pc
);
468 /* Can't determine prologue from the symbol table, need to examine
471 /* Skip the typical prologue instructions. These are the stack adjustment
472 instruction and the instructions that save registers on the stack
473 or in the gcc frame. */
474 for (offset
= 0; offset
< 100; offset
+= 4)
476 inst
= alpha_read_insn (pc
+ offset
);
478 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
480 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
482 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
484 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
487 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
488 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
489 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
492 if (inst
== 0x47de040f) /* bis sp,sp,fp */
494 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
503 /* Figure out where the longjmp will land.
504 We expect the first arg to be a pointer to the jmp_buf structure from
505 which we extract the PC (JB_PC) that we will land at. The PC is copied
506 into the "pc". This routine returns true on success. */
509 alpha_get_longjmp_target (CORE_ADDR
*pc
)
511 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
513 char raw_buffer
[ALPHA_REGISTER_SIZE
];
515 jb_addr
= read_register (ALPHA_A0_REGNUM
);
517 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
518 raw_buffer
, tdep
->jb_elt_size
))
521 *pc
= extract_address (raw_buffer
, tdep
->jb_elt_size
);
526 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
527 describe the location and shape of the sigcontext structure. After
528 that, all registers are in memory, so it's easy. */
529 /* ??? Shouldn't we be able to do this generically, rather than with
530 OSABI data specific to Alpha? */
532 struct alpha_sigtramp_unwind_cache
534 CORE_ADDR sigcontext_addr
;
537 static struct alpha_sigtramp_unwind_cache
*
538 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
539 void **this_prologue_cache
)
541 struct alpha_sigtramp_unwind_cache
*info
;
542 struct gdbarch_tdep
*tdep
;
544 if (*this_prologue_cache
)
545 return *this_prologue_cache
;
547 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
548 *this_prologue_cache
= info
;
550 tdep
= gdbarch_tdep (current_gdbarch
);
551 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
556 /* Return the address of REGNO in a sigtramp frame. Since this is all
557 arithmetic, it doesn't seem worthwhile to cache it. */
559 #ifndef SIGFRAME_PC_OFF
560 #define SIGFRAME_PC_OFF (2 * 8)
561 #define SIGFRAME_REGSAVE_OFF (4 * 8)
562 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
566 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, unsigned int regno
)
569 return sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ regno
* 8;
570 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
571 return sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ regno
* 8;
572 if (regno
== PC_REGNUM
)
573 return sigcontext_addr
+ SIGFRAME_PC_OFF
;
578 /* Given a GDB frame, determine the address of the calling function's
579 frame. This will be used to create a new GDB frame struct. */
582 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
583 void **this_prologue_cache
,
584 struct frame_id
*this_id
)
586 struct alpha_sigtramp_unwind_cache
*info
587 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
588 struct gdbarch_tdep
*tdep
;
589 CORE_ADDR stack_addr
, code_addr
;
591 /* If the OSABI couldn't locate the sigcontext, give up. */
592 if (info
->sigcontext_addr
== 0)
595 /* If we have dynamic signal trampolines, find their start.
596 If we do not, then we must assume there is a symbol record
597 that can provide the start address. */
598 tdep
= gdbarch_tdep (current_gdbarch
);
599 if (tdep
->dynamic_sigtramp_offset
)
602 code_addr
= frame_pc_unwind (next_frame
);
603 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
610 code_addr
= frame_func_unwind (next_frame
);
612 /* The stack address is trivially read from the sigcontext. */
613 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
615 stack_addr
= read_memory_unsigned_integer (stack_addr
, ALPHA_REGISTER_SIZE
);
617 *this_id
= frame_id_build (stack_addr
, code_addr
);
620 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
623 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
624 void **this_prologue_cache
,
625 int regnum
, int *optimizedp
,
626 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
627 int *realnump
, void *bufferp
)
629 struct alpha_sigtramp_unwind_cache
*info
630 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
633 if (info
->sigcontext_addr
!= 0)
635 /* All integer and fp registers are stored in memory. */
636 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
640 *lvalp
= lval_memory
;
644 read_memory (addr
, bufferp
, ALPHA_REGISTER_SIZE
);
649 /* This extra register may actually be in the sigcontext, but our
650 current description of it in alpha_sigtramp_frame_unwind_cache
651 doesn't include it. Too bad. Fall back on whatever's in the
653 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
657 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
659 alpha_sigtramp_frame_this_id
,
660 alpha_sigtramp_frame_prev_register
663 static const struct frame_unwind
*
664 alpha_sigtramp_frame_p (CORE_ADDR pc
)
668 /* We shouldn't even bother to try if the OSABI didn't register
669 a sigcontext_addr handler. */
670 if (!gdbarch_tdep (current_gdbarch
)->sigcontext_addr
)
673 /* Otherwise we should be in a signal frame. */
674 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
675 if (PC_IN_SIGTRAMP (pc
, name
))
676 return &alpha_sigtramp_frame_unwind
;
681 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
682 something about the traditional layout of alpha stack frames. */
684 struct alpha_heuristic_unwind_cache
686 CORE_ADDR
*saved_regs
;
692 /* Heuristic_proc_start may hunt through the text section for a long
693 time across a 2400 baud serial line. Allows the user to limit this
695 static unsigned int heuristic_fence_post
= 0;
697 /* Attempt to locate the start of the function containing PC. We assume that
698 the previous function ends with an about_to_return insn. Not foolproof by
699 any means, since gcc is happy to put the epilogue in the middle of a
700 function. But we're guessing anyway... */
703 alpha_heuristic_proc_start (CORE_ADDR pc
)
705 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
706 CORE_ADDR last_non_nop
= pc
;
707 CORE_ADDR fence
= pc
- heuristic_fence_post
;
708 CORE_ADDR orig_pc
= pc
;
714 /* First see if we can find the start of the function from minimal
715 symbol information. This can succeed with a binary that doesn't
716 have debug info, but hasn't been stripped. */
717 func
= get_pc_function_start (pc
);
721 if (heuristic_fence_post
== UINT_MAX
722 || fence
< tdep
->vm_min_address
)
723 fence
= tdep
->vm_min_address
;
725 /* Search back for previous return; also stop at a 0, which might be
726 seen for instance before the start of a code section. Don't include
727 nops, since this usually indicates padding between functions. */
728 for (pc
-= 4; pc
>= fence
; pc
-= 4)
730 unsigned int insn
= alpha_read_insn (pc
);
733 case 0: /* invalid insn */
734 case 0x6bfa8001: /* ret $31,($26),1 */
737 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
738 case 0x47ff041f: /* nop: bis $31,$31,$31 */
747 /* It's not clear to me why we reach this point when stopping quietly,
748 but with this test, at least we don't print out warnings for every
749 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
750 if (stop_soon
== NO_STOP_QUIETLY
)
752 static int blurb_printed
= 0;
754 if (fence
== tdep
->vm_min_address
)
755 warning ("Hit beginning of text section without finding");
757 warning ("Hit heuristic-fence-post without finding");
758 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
763 This warning occurs if you are debugging a function without any symbols\n\
764 (for example, in a stripped executable). In that case, you may wish to\n\
765 increase the size of the search with the `set heuristic-fence-post' command.\n\
767 Otherwise, you told GDB there was a function where there isn't one, or\n\
768 (more likely) you have encountered a bug in GDB.\n");
776 static struct alpha_heuristic_unwind_cache
*
777 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
778 void **this_prologue_cache
,
781 struct alpha_heuristic_unwind_cache
*info
;
783 CORE_ADDR limit_pc
, cur_pc
;
784 int frame_reg
, frame_size
, return_reg
, reg
;
786 if (*this_prologue_cache
)
787 return *this_prologue_cache
;
789 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
790 *this_prologue_cache
= info
;
791 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
793 limit_pc
= frame_pc_unwind (next_frame
);
795 start_pc
= alpha_heuristic_proc_start (limit_pc
);
796 info
->start_pc
= start_pc
;
798 frame_reg
= ALPHA_SP_REGNUM
;
802 /* If we've identified a likely place to start, do code scanning. */
805 /* Limit the forward search to 50 instructions. */
806 if (start_pc
+ 200 < limit_pc
)
807 limit_pc
= start_pc
+ 200;
809 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
811 unsigned int word
= alpha_read_insn (cur_pc
);
813 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
817 /* Consider only the first stack allocation instruction
818 to contain the static size of the frame. */
820 frame_size
= (-word
) & 0xffff;
824 /* Exit loop if a positive stack adjustment is found, which
825 usually means that the stack cleanup code in the function
826 epilogue is reached. */
830 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
832 reg
= (word
& 0x03e00000) >> 21;
837 /* Do not compute the address where the register was saved yet,
838 because we don't know yet if the offset will need to be
839 relative to $sp or $fp (we can not compute the address
840 relative to $sp if $sp is updated during the execution of
841 the current subroutine, for instance when doing some alloca).
842 So just store the offset for the moment, and compute the
843 address later when we know whether this frame has a frame
845 /* Hack: temporarily add one, so that the offset is non-zero
846 and we can tell which registers have save offsets below. */
847 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
849 /* Starting with OSF/1-3.2C, the system libraries are shipped
850 without local symbols, but they still contain procedure
851 descriptors without a symbol reference. GDB is currently
852 unable to find these procedure descriptors and uses
853 heuristic_proc_desc instead.
854 As some low level compiler support routines (__div*, __add*)
855 use a non-standard return address register, we have to
856 add some heuristics to determine the return address register,
857 or stepping over these routines will fail.
858 Usually the return address register is the first register
859 saved on the stack, but assembler optimization might
860 rearrange the register saves.
861 So we recognize only a few registers (t7, t9, ra) within
862 the procedure prologue as valid return address registers.
863 If we encounter a return instruction, we extract the
864 the return address register from it.
866 FIXME: Rewriting GDB to access the procedure descriptors,
867 e.g. via the minimal symbol table, might obviate this hack. */
869 && cur_pc
< (start_pc
+ 80)
870 && (reg
== ALPHA_T7_REGNUM
871 || reg
== ALPHA_T9_REGNUM
872 || reg
== ALPHA_RA_REGNUM
))
875 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
876 return_reg
= (word
>> 16) & 0x1f;
877 else if (word
== 0x47de040f) /* bis sp,sp,fp */
878 frame_reg
= ALPHA_GCC_FP_REGNUM
;
879 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
880 frame_reg
= ALPHA_GCC_FP_REGNUM
;
883 /* If we haven't found a valid return address register yet, keep
884 searching in the procedure prologue. */
885 if (return_reg
== -1)
887 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
889 unsigned int word
= alpha_read_insn (cur_pc
);
891 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
893 reg
= (word
& 0x03e00000) >> 21;
894 if (reg
== ALPHA_T7_REGNUM
895 || reg
== ALPHA_T9_REGNUM
896 || reg
== ALPHA_RA_REGNUM
)
902 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
904 return_reg
= (word
>> 16) & 0x1f;
913 /* Failing that, do default to the customary RA. */
914 if (return_reg
== -1)
915 return_reg
= ALPHA_RA_REGNUM
;
916 info
->return_reg
= return_reg
;
918 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
919 info
->vfp
= val
+ frame_size
;
921 /* Convert offsets to absolute addresses. See above about adding
922 one to the offsets to make all detected offsets non-zero. */
923 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
924 if (info
->saved_regs
[reg
])
925 info
->saved_regs
[reg
] += val
- 1;
930 /* Given a GDB frame, determine the address of the calling function's
931 frame. This will be used to create a new GDB frame struct. */
934 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
935 void **this_prologue_cache
,
936 struct frame_id
*this_id
)
938 struct alpha_heuristic_unwind_cache
*info
939 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
941 /* This is meant to halt the backtrace at "_start". Make sure we
942 don't halt it at a generic dummy frame. */
943 if (inside_entry_file (info
->start_pc
))
946 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
949 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
952 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
953 void **this_prologue_cache
,
954 int regnum
, int *optimizedp
,
955 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
956 int *realnump
, void *bufferp
)
958 struct alpha_heuristic_unwind_cache
*info
959 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
961 /* The PC of the previous frame is stored in the link register of
962 the current frame. Frob regnum so that we pull the value from
963 the correct place. */
964 if (regnum
== ALPHA_PC_REGNUM
)
965 regnum
= info
->return_reg
;
967 /* For all registers known to be saved in the current frame,
968 do the obvious and pull the value out. */
969 if (info
->saved_regs
[regnum
])
972 *lvalp
= lval_memory
;
973 *addrp
= info
->saved_regs
[regnum
];
976 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
980 /* The stack pointer of the previous frame is computed by popping
981 the current stack frame. */
982 if (regnum
== ALPHA_SP_REGNUM
)
989 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
993 /* Otherwise assume the next frame has the same register value. */
994 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
998 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1000 alpha_heuristic_frame_this_id
,
1001 alpha_heuristic_frame_prev_register
1004 static const struct frame_unwind
*
1005 alpha_heuristic_frame_p (CORE_ADDR pc
)
1007 return &alpha_heuristic_frame_unwind
;
1011 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1012 void **this_prologue_cache
)
1014 struct alpha_heuristic_unwind_cache
*info
1015 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1020 static const struct frame_base alpha_heuristic_frame_base
= {
1021 &alpha_heuristic_frame_unwind
,
1022 alpha_heuristic_frame_base_address
,
1023 alpha_heuristic_frame_base_address
,
1024 alpha_heuristic_frame_base_address
1027 /* Just like reinit_frame_cache, but with the right arguments to be
1028 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1031 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1033 reinit_frame_cache ();
1037 /* ALPHA stack frames are almost impenetrable. When execution stops,
1038 we basically have to look at symbol information for the function
1039 that we stopped in, which tells us *which* register (if any) is
1040 the base of the frame pointer, and what offset from that register
1041 the frame itself is at.
1043 This presents a problem when trying to examine a stack in memory
1044 (that isn't executing at the moment), using the "frame" command. We
1045 don't have a PC, nor do we have any registers except SP.
1047 This routine takes two arguments, SP and PC, and tries to make the
1048 cached frames look as if these two arguments defined a frame on the
1049 cache. This allows the rest of info frame to extract the important
1050 arguments without difficulty. */
1053 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1056 error ("ALPHA frame specifications require two arguments: sp and pc");
1058 return create_new_frame (argv
[0], argv
[1]);
1061 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1062 dummy frame. The frame ID's base needs to match the TOS value
1063 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1066 static struct frame_id
1067 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1070 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1071 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1075 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1078 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1083 /* alpha_software_single_step() is called just before we want to resume
1084 the inferior, if we want to single-step it but there is no hardware
1085 or kernel single-step support (NetBSD on Alpha, for example). We find
1086 the target of the coming instruction and breakpoint it.
1088 single_step is also called just after the inferior stops. If we had
1089 set up a simulated single-step, we undo our damage. */
1092 alpha_next_pc (CORE_ADDR pc
)
1099 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1101 /* Opcode is top 6 bits. */
1102 op
= (insn
>> 26) & 0x3f;
1106 /* Jump format: target PC is:
1108 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1111 if ((op
& 0x30) == 0x30)
1113 /* Branch format: target PC is:
1114 (new PC) + (4 * sext(displacement)) */
1115 if (op
== 0x30 || /* BR */
1116 op
== 0x34) /* BSR */
1119 offset
= (insn
& 0x001fffff);
1120 if (offset
& 0x00100000)
1121 offset
|= 0xffe00000;
1123 return (pc
+ 4 + offset
);
1126 /* Need to determine if branch is taken; read RA. */
1127 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1130 case 0x38: /* BLBC */
1134 case 0x3c: /* BLBS */
1138 case 0x39: /* BEQ */
1142 case 0x3d: /* BNE */
1146 case 0x3a: /* BLT */
1150 case 0x3b: /* BLE */
1154 case 0x3f: /* BGT */
1158 case 0x3e: /* BGE */
1163 /* ??? Missing floating-point branches. */
1167 /* Not a branch or branch not taken; target PC is:
1173 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1175 static CORE_ADDR next_pc
;
1176 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1177 static binsn_quantum break_mem
;
1180 if (insert_breakpoints_p
)
1183 next_pc
= alpha_next_pc (pc
);
1185 target_insert_breakpoint (next_pc
, break_mem
);
1189 target_remove_breakpoint (next_pc
, break_mem
);
1195 /* Initialize the current architecture based on INFO. If possible, re-use an
1196 architecture from ARCHES, which is a list of architectures already created
1197 during this debugging session.
1199 Called e.g. at program startup, when reading a core file, and when reading
1202 static struct gdbarch
*
1203 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1205 struct gdbarch_tdep
*tdep
;
1206 struct gdbarch
*gdbarch
;
1208 /* Try to determine the ABI of the object we are loading. */
1209 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1211 /* If it's an ECOFF file, assume it's OSF/1. */
1212 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1213 info
.osabi
= GDB_OSABI_OSF1
;
1216 /* Find a candidate among extant architectures. */
1217 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1219 return arches
->gdbarch
;
1221 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1222 gdbarch
= gdbarch_alloc (&info
, tdep
);
1224 /* Lowest text address. This is used by heuristic_proc_start()
1225 to decide when to stop looking. */
1226 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1228 tdep
->dynamic_sigtramp_offset
= NULL
;
1229 tdep
->sigcontext_addr
= NULL
;
1231 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1234 set_gdbarch_short_bit (gdbarch
, 16);
1235 set_gdbarch_int_bit (gdbarch
, 32);
1236 set_gdbarch_long_bit (gdbarch
, 64);
1237 set_gdbarch_long_long_bit (gdbarch
, 64);
1238 set_gdbarch_float_bit (gdbarch
, 32);
1239 set_gdbarch_double_bit (gdbarch
, 64);
1240 set_gdbarch_long_double_bit (gdbarch
, 64);
1241 set_gdbarch_ptr_bit (gdbarch
, 64);
1244 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1245 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_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_register_byte (gdbarch
, alpha_register_byte
);
1251 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1252 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1253 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1255 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1256 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1258 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1259 set_gdbarch_register_convert_to_virtual (gdbarch
,
1260 alpha_register_convert_to_virtual
);
1261 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1263 /* Prologue heuristics. */
1264 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1267 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1268 set_gdbarch_frameless_function_invocation (gdbarch
,
1269 generic_frameless_function_invocation_not
);
1271 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1272 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1273 set_gdbarch_deprecated_store_struct_return (gdbarch
, alpha_store_struct_return
);
1274 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1275 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1276 alpha_extract_struct_value_address
);
1278 /* Settings for calling functions in the inferior. */
1279 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1281 /* Methods for saving / extracting a dummy frame's ID. */
1282 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1283 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1285 /* Return the unwound PC value. */
1286 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1288 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1289 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1291 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1292 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1294 set_gdbarch_function_start_offset (gdbarch
, 0);
1295 set_gdbarch_frame_args_skip (gdbarch
, 0);
1297 /* Hook in ABI-specific overrides, if they have been registered. */
1298 gdbarch_init_osabi (info
, gdbarch
);
1300 /* Now that we have tuned the configuration, set a few final things
1301 based on what the OS ABI has told us. */
1303 if (tdep
->jb_pc
>= 0)
1304 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1306 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1307 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1309 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1315 _initialize_alpha_tdep (void)
1317 struct cmd_list_element
*c
;
1319 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1320 deprecated_tm_print_insn
= print_insn_alpha
;
1322 /* Let the user set the fence post for heuristic_proc_start. */
1324 /* We really would like to have both "0" and "unlimited" work, but
1325 command.c doesn't deal with that. So make it a var_zinteger
1326 because the user can always use "999999" or some such for unlimited. */
1327 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1328 (char *) &heuristic_fence_post
,
1330 Set the distance searched for the start of a function.\n\
1331 If you are debugging a stripped executable, GDB needs to search through the\n\
1332 program for the start of a function. This command sets the distance of the\n\
1333 search. The only need to set it is when debugging a stripped executable.",
1335 /* We need to throw away the frame cache when we set this, since it
1336 might change our ability to get backtraces. */
1337 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1338 add_show_from_set (c
, &showlist
);