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. */
25 #include "frame-unwind.h"
26 #include "frame-base.h"
35 #include "gdb_string.h"
38 #include "reggroups.h"
39 #include "arch-utils.h"
45 #include "alpha-tdep.h"
49 alpha_register_name (int regno
)
51 static const char * const register_names
[] =
53 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
54 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
55 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
56 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
57 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
58 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
59 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
60 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
66 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
68 return register_names
[regno
];
72 alpha_cannot_fetch_register (int regno
)
74 return regno
== ALPHA_ZERO_REGNUM
;
78 alpha_cannot_store_register (int regno
)
80 return regno
== ALPHA_ZERO_REGNUM
;
84 alpha_register_convertible (int regno
)
86 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
90 alpha_register_virtual_type (int regno
)
92 return ((regno
>= FP0_REGNUM
&& regno
< (FP0_REGNUM
+31))
93 ? builtin_type_double
: builtin_type_long
);
96 /* Is REGNUM a member of REGGROUP? */
99 alpha_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
100 struct reggroup
*group
)
102 /* Filter out any registers eliminated, but whose regnum is
103 reserved for backward compatibility, e.g. the vfp. */
104 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
107 /* Since we implement no pseudo registers, save/restore is equal to all. */
108 if (group
== all_reggroup
109 || group
== save_reggroup
110 || group
== restore_reggroup
)
113 /* All other groups are non-overlapping. */
115 /* Since this is really a PALcode memory slot... */
116 if (regnum
== ALPHA_UNIQUE_REGNUM
)
117 return group
== system_reggroup
;
119 /* Force the FPCR to be considered part of the floating point state. */
120 if (regnum
== ALPHA_FPCR_REGNUM
)
121 return group
== float_reggroup
;
123 if (regnum
>= ALPHA_FP0_REGNUM
&& regnum
< ALPHA_FP0_REGNUM
+ 31)
124 return group
== float_reggroup
;
126 return group
== general_reggroup
;
130 alpha_register_byte (int regno
)
136 alpha_register_raw_size (int regno
)
142 alpha_register_virtual_size (int regno
)
147 /* The alpha needs a conversion between register and memory format if the
148 register is a floating point register and memory format is float, as the
149 register format must be double or memory format is an integer with 4
150 bytes or less, as the representation of integers in floating point
151 registers is different. */
154 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
155 char *raw_buffer
, char *virtual_buffer
)
157 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
159 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
163 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
165 double d
= deprecated_extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
166 deprecated_store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
168 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
171 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
172 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
173 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
176 error ("Cannot retrieve value from floating point register");
180 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
181 char *virtual_buffer
, char *raw_buffer
)
183 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
185 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
189 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
191 double d
= deprecated_extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
192 deprecated_store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
194 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
197 if (TYPE_UNSIGNED (valtype
))
198 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
200 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
201 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
202 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
205 error ("Cannot store value in floating point register");
209 /* The alpha passes the first six arguments in the registers, the rest on
210 the stack. The register arguments are stored in ARG_REG_BUFFER, and
211 then moved into the register file; this simplifies the passing of a
212 large struct which extends from the registers to the stack, plus avoids
213 three ptrace invocations per word.
215 We don't bother tracking which register values should go in integer
216 regs or fp regs; we load the same values into both.
218 If the called function is returning a structure, the address of the
219 structure to be returned is passed as a hidden first argument. */
222 alpha_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
223 struct regcache
*regcache
, CORE_ADDR bp_addr
,
224 int nargs
, struct value
**args
, CORE_ADDR sp
,
225 int struct_return
, CORE_ADDR struct_addr
)
228 int accumulate_size
= struct_return
? 8 : 0;
235 struct alpha_arg
*alpha_args
236 = (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
237 register struct alpha_arg
*m_arg
;
238 char arg_reg_buffer
[ALPHA_REGISTER_SIZE
* ALPHA_NUM_ARG_REGS
];
239 int required_arg_regs
;
241 /* The ABI places the address of the called function in T12. */
242 regcache_cooked_write_signed (regcache
, ALPHA_T12_REGNUM
, func_addr
);
244 /* Set the return address register to point to the entry point
245 of the program, where a breakpoint lies in wait. */
246 regcache_cooked_write_signed (regcache
, ALPHA_RA_REGNUM
, bp_addr
);
248 /* Lay out the arguments in memory. */
249 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
251 struct value
*arg
= args
[i
];
252 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
254 /* Cast argument to long if necessary as the compiler does it too. */
255 switch (TYPE_CODE (arg_type
))
260 case TYPE_CODE_RANGE
:
262 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
264 arg_type
= builtin_type_long
;
265 arg
= value_cast (arg_type
, arg
);
269 /* "float" arguments loaded in registers must be passed in
270 register format, aka "double". */
271 if (accumulate_size
< sizeof (arg_reg_buffer
)
272 && TYPE_LENGTH (arg_type
) == 4)
274 arg_type
= builtin_type_double
;
275 arg
= value_cast (arg_type
, arg
);
277 /* Tru64 5.1 has a 128-bit long double, and passes this by
278 invisible reference. No one else uses this data type. */
279 else if (TYPE_LENGTH (arg_type
) == 16)
281 /* Allocate aligned storage. */
282 sp
= (sp
& -16) - 16;
284 /* Write the real data into the stack. */
285 write_memory (sp
, VALUE_CONTENTS (arg
), 16);
287 /* Construct the indirection. */
288 arg_type
= lookup_pointer_type (arg_type
);
289 arg
= value_from_pointer (arg_type
, sp
);
295 m_arg
->len
= TYPE_LENGTH (arg_type
);
296 m_arg
->offset
= accumulate_size
;
297 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
298 m_arg
->contents
= VALUE_CONTENTS (arg
);
301 /* Determine required argument register loads, loading an argument register
302 is expensive as it uses three ptrace calls. */
303 required_arg_regs
= accumulate_size
/ 8;
304 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
305 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
307 /* Make room for the arguments on the stack. */
308 if (accumulate_size
< sizeof(arg_reg_buffer
))
311 accumulate_size
-= sizeof(arg_reg_buffer
);
312 sp
-= accumulate_size
;
314 /* Keep sp aligned to a multiple of 16 as the ABI requires. */
317 /* `Push' arguments on the stack. */
318 for (i
= nargs
; m_arg
--, --i
>= 0;)
320 char *contents
= m_arg
->contents
;
321 int offset
= m_arg
->offset
;
322 int len
= m_arg
->len
;
324 /* Copy the bytes destined for registers into arg_reg_buffer. */
325 if (offset
< sizeof(arg_reg_buffer
))
327 if (offset
+ len
<= sizeof(arg_reg_buffer
))
329 memcpy (arg_reg_buffer
+ offset
, contents
, len
);
334 int tlen
= sizeof(arg_reg_buffer
) - offset
;
335 memcpy (arg_reg_buffer
+ offset
, contents
, tlen
);
342 /* Everything else goes to the stack. */
343 write_memory (sp
+ offset
- sizeof(arg_reg_buffer
), contents
, len
);
346 store_unsigned_integer (arg_reg_buffer
, ALPHA_REGISTER_SIZE
, struct_addr
);
348 /* Load the argument registers. */
349 for (i
= 0; i
< required_arg_regs
; i
++)
351 regcache_cooked_write (regcache
, ALPHA_A0_REGNUM
+ i
,
352 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
353 regcache_cooked_write (regcache
, ALPHA_FPA0_REGNUM
+ i
,
354 arg_reg_buffer
+ i
*ALPHA_REGISTER_SIZE
);
357 /* Finally, update the stack pointer. */
358 regcache_cooked_write_signed (regcache
, ALPHA_SP_REGNUM
, sp
);
363 /* Given a return value in `regbuf' with a type `valtype',
364 extract and copy its value into `valbuf'. */
367 alpha_extract_return_value (struct type
*valtype
,
368 char regbuf
[ALPHA_REGISTER_BYTES
], char *valbuf
)
370 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
371 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
372 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
375 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
376 TYPE_LENGTH (valtype
));
379 /* Given a return value in `regbuf' with a type `valtype',
380 write its value into the appropriate register. */
383 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
385 char raw_buffer
[ALPHA_REGISTER_SIZE
];
386 int regnum
= ALPHA_V0_REGNUM
;
387 int length
= TYPE_LENGTH (valtype
);
389 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
392 length
= ALPHA_REGISTER_SIZE
;
393 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
396 memcpy (raw_buffer
, valbuf
, length
);
398 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
402 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
404 /* Structures are returned by ref in extra arg0. */
409 alpha_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
411 /* Store the address of the place in which to copy the structure the
412 subroutine will return. Handled by alpha_push_arguments. */
416 alpha_extract_struct_value_address (char *regbuf
)
418 return (extract_unsigned_integer (regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
419 REGISTER_RAW_SIZE (ALPHA_V0_REGNUM
)));
423 static const unsigned char *
424 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
426 static const unsigned char alpha_breakpoint
[] =
427 { 0x80, 0, 0, 0 }; /* call_pal bpt */
429 *lenptr
= sizeof(alpha_breakpoint
);
430 return (alpha_breakpoint
);
434 /* This returns the PC of the first insn after the prologue.
435 If we can't find the prologue, then return 0. */
438 alpha_after_prologue (CORE_ADDR pc
)
440 struct symtab_and_line sal
;
441 CORE_ADDR func_addr
, func_end
;
443 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
446 sal
= find_pc_line (func_addr
, 0);
447 if (sal
.end
< func_end
)
450 /* The line after the prologue is after the end of the function. In this
451 case, tell the caller to find the prologue the hard way. */
455 /* Read an instruction from memory at PC, looking through breakpoints. */
458 alpha_read_insn (CORE_ADDR pc
)
463 status
= read_memory_nobpt (pc
, buf
, 4);
465 memory_error (status
, pc
);
466 return extract_unsigned_integer (buf
, 4);
469 /* To skip prologues, I use this predicate. Returns either PC itself
470 if the code at PC does not look like a function prologue; otherwise
471 returns an address that (if we're lucky) follows the prologue. If
472 LENIENT, then we must skip everything which is involved in setting
473 up the frame (it's OK to skip more, just so long as we don't skip
474 anything which might clobber the registers which are being saved. */
477 alpha_skip_prologue (CORE_ADDR pc
)
481 CORE_ADDR post_prologue_pc
;
484 /* Silently return the unaltered pc upon memory errors.
485 This could happen on OSF/1 if decode_line_1 tries to skip the
486 prologue for quickstarted shared library functions when the
487 shared library is not yet mapped in.
488 Reading target memory is slow over serial lines, so we perform
489 this check only if the target has shared libraries (which all
490 Alpha targets do). */
491 if (target_read_memory (pc
, buf
, 4))
494 /* See if we can determine the end of the prologue via the symbol table.
495 If so, then return either PC, or the PC after the prologue, whichever
498 post_prologue_pc
= alpha_after_prologue (pc
);
499 if (post_prologue_pc
!= 0)
500 return max (pc
, post_prologue_pc
);
502 /* Can't determine prologue from the symbol table, need to examine
505 /* Skip the typical prologue instructions. These are the stack adjustment
506 instruction and the instructions that save registers on the stack
507 or in the gcc frame. */
508 for (offset
= 0; offset
< 100; offset
+= 4)
510 inst
= alpha_read_insn (pc
+ offset
);
512 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
514 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
516 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
518 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
521 if (((inst
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
522 || (inst
& 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */
523 && (inst
& 0x03e00000) != 0x03e00000) /* reg != $zero */
526 if (inst
== 0x47de040f) /* bis sp,sp,fp */
528 if (inst
== 0x47fe040f) /* bis zero,sp,fp */
537 /* Figure out where the longjmp will land.
538 We expect the first arg to be a pointer to the jmp_buf structure from
539 which we extract the PC (JB_PC) that we will land at. The PC is copied
540 into the "pc". This routine returns true on success. */
543 alpha_get_longjmp_target (CORE_ADDR
*pc
)
545 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
547 char raw_buffer
[ALPHA_REGISTER_SIZE
];
549 jb_addr
= read_register (ALPHA_A0_REGNUM
);
551 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
552 raw_buffer
, tdep
->jb_elt_size
))
555 *pc
= extract_unsigned_integer (raw_buffer
, tdep
->jb_elt_size
);
560 /* Frame unwinder for signal trampolines. We use alpha tdep bits that
561 describe the location and shape of the sigcontext structure. After
562 that, all registers are in memory, so it's easy. */
563 /* ??? Shouldn't we be able to do this generically, rather than with
564 OSABI data specific to Alpha? */
566 struct alpha_sigtramp_unwind_cache
568 CORE_ADDR sigcontext_addr
;
571 static struct alpha_sigtramp_unwind_cache
*
572 alpha_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
573 void **this_prologue_cache
)
575 struct alpha_sigtramp_unwind_cache
*info
;
576 struct gdbarch_tdep
*tdep
;
578 if (*this_prologue_cache
)
579 return *this_prologue_cache
;
581 info
= FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache
);
582 *this_prologue_cache
= info
;
584 tdep
= gdbarch_tdep (current_gdbarch
);
585 info
->sigcontext_addr
= tdep
->sigcontext_addr (next_frame
);
590 /* Return the address of REGNO in a sigtramp frame. Since this is all
591 arithmetic, it doesn't seem worthwhile to cache it. */
593 #ifndef SIGFRAME_PC_OFF
594 #define SIGFRAME_PC_OFF (2 * 8)
595 #define SIGFRAME_REGSAVE_OFF (4 * 8)
596 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
600 alpha_sigtramp_register_address (CORE_ADDR sigcontext_addr
, unsigned int regno
)
603 return sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ regno
* 8;
604 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32)
605 return sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ regno
* 8;
606 if (regno
== PC_REGNUM
)
607 return sigcontext_addr
+ SIGFRAME_PC_OFF
;
612 /* Given a GDB frame, determine the address of the calling function's
613 frame. This will be used to create a new GDB frame struct. */
616 alpha_sigtramp_frame_this_id (struct frame_info
*next_frame
,
617 void **this_prologue_cache
,
618 struct frame_id
*this_id
)
620 struct alpha_sigtramp_unwind_cache
*info
621 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
622 struct gdbarch_tdep
*tdep
;
623 CORE_ADDR stack_addr
, code_addr
;
625 /* If the OSABI couldn't locate the sigcontext, give up. */
626 if (info
->sigcontext_addr
== 0)
629 /* If we have dynamic signal trampolines, find their start.
630 If we do not, then we must assume there is a symbol record
631 that can provide the start address. */
632 tdep
= gdbarch_tdep (current_gdbarch
);
633 if (tdep
->dynamic_sigtramp_offset
)
636 code_addr
= frame_pc_unwind (next_frame
);
637 offset
= tdep
->dynamic_sigtramp_offset (code_addr
);
644 code_addr
= frame_func_unwind (next_frame
);
646 /* The stack address is trivially read from the sigcontext. */
647 stack_addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
,
649 stack_addr
= read_memory_unsigned_integer (stack_addr
, ALPHA_REGISTER_SIZE
);
651 *this_id
= frame_id_build (stack_addr
, code_addr
);
654 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
657 alpha_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
658 void **this_prologue_cache
,
659 int regnum
, int *optimizedp
,
660 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
661 int *realnump
, void *bufferp
)
663 struct alpha_sigtramp_unwind_cache
*info
664 = alpha_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
667 if (info
->sigcontext_addr
!= 0)
669 /* All integer and fp registers are stored in memory. */
670 addr
= alpha_sigtramp_register_address (info
->sigcontext_addr
, regnum
);
674 *lvalp
= lval_memory
;
678 read_memory (addr
, bufferp
, ALPHA_REGISTER_SIZE
);
683 /* This extra register may actually be in the sigcontext, but our
684 current description of it in alpha_sigtramp_frame_unwind_cache
685 doesn't include it. Too bad. Fall back on whatever's in the
687 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
691 static const struct frame_unwind alpha_sigtramp_frame_unwind
= {
693 alpha_sigtramp_frame_this_id
,
694 alpha_sigtramp_frame_prev_register
697 static const struct frame_unwind
*
698 alpha_sigtramp_frame_p (CORE_ADDR pc
)
702 /* We shouldn't even bother to try if the OSABI didn't register
703 a sigcontext_addr handler. */
704 if (!gdbarch_tdep (current_gdbarch
)->sigcontext_addr
)
707 /* Otherwise we should be in a signal frame. */
708 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
709 if (PC_IN_SIGTRAMP (pc
, name
))
710 return &alpha_sigtramp_frame_unwind
;
715 /* Fallback alpha frame unwinder. Uses instruction scanning and knows
716 something about the traditional layout of alpha stack frames. */
718 struct alpha_heuristic_unwind_cache
720 CORE_ADDR
*saved_regs
;
726 /* Heuristic_proc_start may hunt through the text section for a long
727 time across a 2400 baud serial line. Allows the user to limit this
729 static unsigned int heuristic_fence_post
= 0;
731 /* Attempt to locate the start of the function containing PC. We assume that
732 the previous function ends with an about_to_return insn. Not foolproof by
733 any means, since gcc is happy to put the epilogue in the middle of a
734 function. But we're guessing anyway... */
737 alpha_heuristic_proc_start (CORE_ADDR pc
)
739 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
740 CORE_ADDR last_non_nop
= pc
;
741 CORE_ADDR fence
= pc
- heuristic_fence_post
;
742 CORE_ADDR orig_pc
= pc
;
748 /* First see if we can find the start of the function from minimal
749 symbol information. This can succeed with a binary that doesn't
750 have debug info, but hasn't been stripped. */
751 func
= get_pc_function_start (pc
);
755 if (heuristic_fence_post
== UINT_MAX
756 || fence
< tdep
->vm_min_address
)
757 fence
= tdep
->vm_min_address
;
759 /* Search back for previous return; also stop at a 0, which might be
760 seen for instance before the start of a code section. Don't include
761 nops, since this usually indicates padding between functions. */
762 for (pc
-= 4; pc
>= fence
; pc
-= 4)
764 unsigned int insn
= alpha_read_insn (pc
);
767 case 0: /* invalid insn */
768 case 0x6bfa8001: /* ret $31,($26),1 */
771 case 0x2ffe0000: /* unop: ldq_u $31,0($30) */
772 case 0x47ff041f: /* nop: bis $31,$31,$31 */
781 /* It's not clear to me why we reach this point when stopping quietly,
782 but with this test, at least we don't print out warnings for every
783 child forked (eg, on decstation). 22apr93 rich@cygnus.com. */
784 if (stop_soon
== NO_STOP_QUIETLY
)
786 static int blurb_printed
= 0;
788 if (fence
== tdep
->vm_min_address
)
789 warning ("Hit beginning of text section without finding");
791 warning ("Hit heuristic-fence-post without finding");
792 warning ("enclosing function for address 0x%s", paddr_nz (orig_pc
));
797 This warning occurs if you are debugging a function without any symbols\n\
798 (for example, in a stripped executable). In that case, you may wish to\n\
799 increase the size of the search with the `set heuristic-fence-post' command.\n\
801 Otherwise, you told GDB there was a function where there isn't one, or\n\
802 (more likely) you have encountered a bug in GDB.\n");
810 static struct alpha_heuristic_unwind_cache
*
811 alpha_heuristic_frame_unwind_cache (struct frame_info
*next_frame
,
812 void **this_prologue_cache
,
815 struct alpha_heuristic_unwind_cache
*info
;
817 CORE_ADDR limit_pc
, cur_pc
;
818 int frame_reg
, frame_size
, return_reg
, reg
;
820 if (*this_prologue_cache
)
821 return *this_prologue_cache
;
823 info
= FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache
);
824 *this_prologue_cache
= info
;
825 info
->saved_regs
= frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
827 limit_pc
= frame_pc_unwind (next_frame
);
829 start_pc
= alpha_heuristic_proc_start (limit_pc
);
830 info
->start_pc
= start_pc
;
832 frame_reg
= ALPHA_SP_REGNUM
;
836 /* If we've identified a likely place to start, do code scanning. */
839 /* Limit the forward search to 50 instructions. */
840 if (start_pc
+ 200 < limit_pc
)
841 limit_pc
= start_pc
+ 200;
843 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
845 unsigned int word
= alpha_read_insn (cur_pc
);
847 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
851 /* Consider only the first stack allocation instruction
852 to contain the static size of the frame. */
854 frame_size
= (-word
) & 0xffff;
858 /* Exit loop if a positive stack adjustment is found, which
859 usually means that the stack cleanup code in the function
860 epilogue is reached. */
864 else if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
866 reg
= (word
& 0x03e00000) >> 21;
871 /* Do not compute the address where the register was saved yet,
872 because we don't know yet if the offset will need to be
873 relative to $sp or $fp (we can not compute the address
874 relative to $sp if $sp is updated during the execution of
875 the current subroutine, for instance when doing some alloca).
876 So just store the offset for the moment, and compute the
877 address later when we know whether this frame has a frame
879 /* Hack: temporarily add one, so that the offset is non-zero
880 and we can tell which registers have save offsets below. */
881 info
->saved_regs
[reg
] = (word
& 0xffff) + 1;
883 /* Starting with OSF/1-3.2C, the system libraries are shipped
884 without local symbols, but they still contain procedure
885 descriptors without a symbol reference. GDB is currently
886 unable to find these procedure descriptors and uses
887 heuristic_proc_desc instead.
888 As some low level compiler support routines (__div*, __add*)
889 use a non-standard return address register, we have to
890 add some heuristics to determine the return address register,
891 or stepping over these routines will fail.
892 Usually the return address register is the first register
893 saved on the stack, but assembler optimization might
894 rearrange the register saves.
895 So we recognize only a few registers (t7, t9, ra) within
896 the procedure prologue as valid return address registers.
897 If we encounter a return instruction, we extract the
898 the return address register from it.
900 FIXME: Rewriting GDB to access the procedure descriptors,
901 e.g. via the minimal symbol table, might obviate this hack. */
903 && cur_pc
< (start_pc
+ 80)
904 && (reg
== ALPHA_T7_REGNUM
905 || reg
== ALPHA_T9_REGNUM
906 || reg
== ALPHA_RA_REGNUM
))
909 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
910 return_reg
= (word
>> 16) & 0x1f;
911 else if (word
== 0x47de040f) /* bis sp,sp,fp */
912 frame_reg
= ALPHA_GCC_FP_REGNUM
;
913 else if (word
== 0x47fe040f) /* bis zero,sp,fp */
914 frame_reg
= ALPHA_GCC_FP_REGNUM
;
917 /* If we haven't found a valid return address register yet, keep
918 searching in the procedure prologue. */
919 if (return_reg
== -1)
921 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
923 unsigned int word
= alpha_read_insn (cur_pc
);
925 if ((word
& 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */
927 reg
= (word
& 0x03e00000) >> 21;
928 if (reg
== ALPHA_T7_REGNUM
929 || reg
== ALPHA_T9_REGNUM
930 || reg
== ALPHA_RA_REGNUM
)
936 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
938 return_reg
= (word
>> 16) & 0x1f;
947 /* Failing that, do default to the customary RA. */
948 if (return_reg
== -1)
949 return_reg
= ALPHA_RA_REGNUM
;
950 info
->return_reg
= return_reg
;
952 frame_unwind_unsigned_register (next_frame
, frame_reg
, &val
);
953 info
->vfp
= val
+ frame_size
;
955 /* Convert offsets to absolute addresses. See above about adding
956 one to the offsets to make all detected offsets non-zero. */
957 for (reg
= 0; reg
< ALPHA_NUM_REGS
; ++reg
)
958 if (info
->saved_regs
[reg
])
959 info
->saved_regs
[reg
] += val
- 1;
964 /* Given a GDB frame, determine the address of the calling function's
965 frame. This will be used to create a new GDB frame struct. */
968 alpha_heuristic_frame_this_id (struct frame_info
*next_frame
,
969 void **this_prologue_cache
,
970 struct frame_id
*this_id
)
972 struct alpha_heuristic_unwind_cache
*info
973 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
975 /* This is meant to halt the backtrace at "_start". Make sure we
976 don't halt it at a generic dummy frame. */
977 if (inside_entry_file (info
->start_pc
))
980 *this_id
= frame_id_build (info
->vfp
, info
->start_pc
);
983 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
986 alpha_heuristic_frame_prev_register (struct frame_info
*next_frame
,
987 void **this_prologue_cache
,
988 int regnum
, int *optimizedp
,
989 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
990 int *realnump
, void *bufferp
)
992 struct alpha_heuristic_unwind_cache
*info
993 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
995 /* The PC of the previous frame is stored in the link register of
996 the current frame. Frob regnum so that we pull the value from
997 the correct place. */
998 if (regnum
== ALPHA_PC_REGNUM
)
999 regnum
= info
->return_reg
;
1001 /* For all registers known to be saved in the current frame,
1002 do the obvious and pull the value out. */
1003 if (info
->saved_regs
[regnum
])
1006 *lvalp
= lval_memory
;
1007 *addrp
= info
->saved_regs
[regnum
];
1009 if (bufferp
!= NULL
)
1010 read_memory (*addrp
, bufferp
, ALPHA_REGISTER_SIZE
);
1014 /* The stack pointer of the previous frame is computed by popping
1015 the current stack frame. */
1016 if (regnum
== ALPHA_SP_REGNUM
)
1022 if (bufferp
!= NULL
)
1023 store_unsigned_integer (bufferp
, ALPHA_REGISTER_SIZE
, info
->vfp
);
1027 /* Otherwise assume the next frame has the same register value. */
1028 frame_register (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1032 static const struct frame_unwind alpha_heuristic_frame_unwind
= {
1034 alpha_heuristic_frame_this_id
,
1035 alpha_heuristic_frame_prev_register
1038 static const struct frame_unwind
*
1039 alpha_heuristic_frame_p (CORE_ADDR pc
)
1041 return &alpha_heuristic_frame_unwind
;
1045 alpha_heuristic_frame_base_address (struct frame_info
*next_frame
,
1046 void **this_prologue_cache
)
1048 struct alpha_heuristic_unwind_cache
*info
1049 = alpha_heuristic_frame_unwind_cache (next_frame
, this_prologue_cache
, 0);
1054 static const struct frame_base alpha_heuristic_frame_base
= {
1055 &alpha_heuristic_frame_unwind
,
1056 alpha_heuristic_frame_base_address
,
1057 alpha_heuristic_frame_base_address
,
1058 alpha_heuristic_frame_base_address
1061 /* Just like reinit_frame_cache, but with the right arguments to be
1062 callable as an sfunc. Used by the "set heuristic-fence-post" command. */
1065 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1067 reinit_frame_cache ();
1071 /* ALPHA stack frames are almost impenetrable. When execution stops,
1072 we basically have to look at symbol information for the function
1073 that we stopped in, which tells us *which* register (if any) is
1074 the base of the frame pointer, and what offset from that register
1075 the frame itself is at.
1077 This presents a problem when trying to examine a stack in memory
1078 (that isn't executing at the moment), using the "frame" command. We
1079 don't have a PC, nor do we have any registers except SP.
1081 This routine takes two arguments, SP and PC, and tries to make the
1082 cached frames look as if these two arguments defined a frame on the
1083 cache. This allows the rest of info frame to extract the important
1084 arguments without difficulty. */
1087 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1090 error ("ALPHA frame specifications require two arguments: sp and pc");
1092 return create_new_frame (argv
[0], argv
[1]);
1095 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1096 dummy frame. The frame ID's base needs to match the TOS value
1097 saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1100 static struct frame_id
1101 alpha_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1104 frame_unwind_unsigned_register (next_frame
, ALPHA_SP_REGNUM
, &base
);
1105 return frame_id_build (base
, frame_pc_unwind (next_frame
));
1109 alpha_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1112 frame_unwind_unsigned_register (next_frame
, ALPHA_PC_REGNUM
, &pc
);
1117 /* alpha_software_single_step() is called just before we want to resume
1118 the inferior, if we want to single-step it but there is no hardware
1119 or kernel single-step support (NetBSD on Alpha, for example). We find
1120 the target of the coming instruction and breakpoint it.
1122 single_step is also called just after the inferior stops. If we had
1123 set up a simulated single-step, we undo our damage. */
1126 alpha_next_pc (CORE_ADDR pc
)
1133 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1135 /* Opcode is top 6 bits. */
1136 op
= (insn
>> 26) & 0x3f;
1140 /* Jump format: target PC is:
1142 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1145 if ((op
& 0x30) == 0x30)
1147 /* Branch format: target PC is:
1148 (new PC) + (4 * sext(displacement)) */
1149 if (op
== 0x30 || /* BR */
1150 op
== 0x34) /* BSR */
1153 offset
= (insn
& 0x001fffff);
1154 if (offset
& 0x00100000)
1155 offset
|= 0xffe00000;
1157 return (pc
+ 4 + offset
);
1160 /* Need to determine if branch is taken; read RA. */
1161 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1164 case 0x38: /* BLBC */
1168 case 0x3c: /* BLBS */
1172 case 0x39: /* BEQ */
1176 case 0x3d: /* BNE */
1180 case 0x3a: /* BLT */
1184 case 0x3b: /* BLE */
1188 case 0x3f: /* BGT */
1192 case 0x3e: /* BGE */
1197 /* ??? Missing floating-point branches. */
1201 /* Not a branch or branch not taken; target PC is:
1207 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1209 static CORE_ADDR next_pc
;
1210 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1211 static binsn_quantum break_mem
;
1214 if (insert_breakpoints_p
)
1217 next_pc
= alpha_next_pc (pc
);
1219 target_insert_breakpoint (next_pc
, break_mem
);
1223 target_remove_breakpoint (next_pc
, break_mem
);
1229 /* Initialize the current architecture based on INFO. If possible, re-use an
1230 architecture from ARCHES, which is a list of architectures already created
1231 during this debugging session.
1233 Called e.g. at program startup, when reading a core file, and when reading
1236 static struct gdbarch
*
1237 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1239 struct gdbarch_tdep
*tdep
;
1240 struct gdbarch
*gdbarch
;
1242 /* Try to determine the ABI of the object we are loading. */
1243 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1245 /* If it's an ECOFF file, assume it's OSF/1. */
1246 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1247 info
.osabi
= GDB_OSABI_OSF1
;
1250 /* Find a candidate among extant architectures. */
1251 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1253 return arches
->gdbarch
;
1255 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1256 gdbarch
= gdbarch_alloc (&info
, tdep
);
1258 /* Lowest text address. This is used by heuristic_proc_start()
1259 to decide when to stop looking. */
1260 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1262 tdep
->dynamic_sigtramp_offset
= NULL
;
1263 tdep
->sigcontext_addr
= NULL
;
1265 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1268 set_gdbarch_short_bit (gdbarch
, 16);
1269 set_gdbarch_int_bit (gdbarch
, 32);
1270 set_gdbarch_long_bit (gdbarch
, 64);
1271 set_gdbarch_long_long_bit (gdbarch
, 64);
1272 set_gdbarch_float_bit (gdbarch
, 32);
1273 set_gdbarch_double_bit (gdbarch
, 64);
1274 set_gdbarch_long_double_bit (gdbarch
, 64);
1275 set_gdbarch_ptr_bit (gdbarch
, 64);
1278 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1279 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1280 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1281 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1283 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1284 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1285 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1286 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1287 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1289 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1290 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1292 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1293 set_gdbarch_register_convert_to_virtual (gdbarch
,
1294 alpha_register_convert_to_virtual
);
1295 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1297 set_gdbarch_register_reggroup_p (gdbarch
, alpha_register_reggroup_p
);
1299 /* Prologue heuristics. */
1300 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1303 set_gdbarch_print_insn (gdbarch
, print_insn_alpha
);
1306 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1307 set_gdbarch_frameless_function_invocation (gdbarch
,
1308 generic_frameless_function_invocation_not
);
1310 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1311 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1312 set_gdbarch_deprecated_store_struct_return (gdbarch
, alpha_store_struct_return
);
1313 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1314 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1315 alpha_extract_struct_value_address
);
1317 /* Settings for calling functions in the inferior. */
1318 set_gdbarch_push_dummy_call (gdbarch
, alpha_push_dummy_call
);
1320 /* Methods for saving / extracting a dummy frame's ID. */
1321 set_gdbarch_unwind_dummy_id (gdbarch
, alpha_unwind_dummy_id
);
1322 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1324 /* Return the unwound PC value. */
1325 set_gdbarch_unwind_pc (gdbarch
, alpha_unwind_pc
);
1327 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1328 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1330 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1331 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1333 set_gdbarch_function_start_offset (gdbarch
, 0);
1334 set_gdbarch_frame_args_skip (gdbarch
, 0);
1336 /* Hook in ABI-specific overrides, if they have been registered. */
1337 gdbarch_init_osabi (info
, gdbarch
);
1339 /* Now that we have tuned the configuration, set a few final things
1340 based on what the OS ABI has told us. */
1342 if (tdep
->jb_pc
>= 0)
1343 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1345 frame_unwind_append_predicate (gdbarch
, alpha_sigtramp_frame_p
);
1346 frame_unwind_append_predicate (gdbarch
, alpha_heuristic_frame_p
);
1348 frame_base_set_default (gdbarch
, &alpha_heuristic_frame_base
);
1354 _initialize_alpha_tdep (void)
1356 struct cmd_list_element
*c
;
1358 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, NULL
);
1360 /* Let the user set the fence post for heuristic_proc_start. */
1362 /* We really would like to have both "0" and "unlimited" work, but
1363 command.c doesn't deal with that. So make it a var_zinteger
1364 because the user can always use "999999" or some such for unlimited. */
1365 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1366 (char *) &heuristic_fence_post
,
1368 Set the distance searched for the start of a function.\n\
1369 If you are debugging a stripped executable, GDB needs to search through the\n\
1370 program for the start of a function. This command sets the distance of the\n\
1371 search. The only need to set it is when debugging a stripped executable.",
1373 /* We need to throw away the frame cache when we set this, since it
1374 might change our ability to get backtraces. */
1375 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1376 add_show_from_set (c
, &showlist
);