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. */
32 #include "gdb_string.h"
36 #include "arch-utils.h"
42 #include "alpha-tdep.h"
44 static gdbarch_init_ftype alpha_gdbarch_init
;
46 static gdbarch_register_name_ftype alpha_register_name
;
47 static gdbarch_register_raw_size_ftype alpha_register_raw_size
;
48 static gdbarch_register_virtual_size_ftype alpha_register_virtual_size
;
49 static gdbarch_register_virtual_type_ftype alpha_register_virtual_type
;
50 static gdbarch_register_byte_ftype alpha_register_byte
;
51 static gdbarch_cannot_fetch_register_ftype alpha_cannot_fetch_register
;
52 static gdbarch_cannot_store_register_ftype alpha_cannot_store_register
;
53 static gdbarch_register_convertible_ftype alpha_register_convertible
;
54 static gdbarch_register_convert_to_virtual_ftype
55 alpha_register_convert_to_virtual
;
56 static gdbarch_register_convert_to_raw_ftype alpha_register_convert_to_raw
;
57 static gdbarch_deprecated_extract_return_value_ftype alpha_extract_return_value
;
58 static gdbarch_deprecated_extract_struct_value_address_ftype
59 alpha_extract_struct_value_address
;
60 static gdbarch_use_struct_convention_ftype alpha_use_struct_convention
;
62 static gdbarch_breakpoint_from_pc_ftype alpha_breakpoint_from_pc
;
64 static gdbarch_frame_args_address_ftype alpha_frame_args_address
;
65 static gdbarch_frame_locals_address_ftype alpha_frame_locals_address
;
67 static gdbarch_skip_prologue_ftype alpha_skip_prologue
;
69 static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy
;
71 static gdbarch_get_longjmp_target_ftype alpha_get_longjmp_target
;
73 struct frame_extra_info
75 alpha_extra_func_info_t proc_desc
;
80 /* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
82 /* Prototypes for local functions. */
84 static void alpha_find_saved_regs (struct frame_info
*);
86 static alpha_extra_func_info_t
push_sigtramp_desc (CORE_ADDR low_addr
);
88 static CORE_ADDR
read_next_frame_reg (struct frame_info
*, int);
90 static CORE_ADDR
heuristic_proc_start (CORE_ADDR
);
92 static alpha_extra_func_info_t
heuristic_proc_desc (CORE_ADDR
,
96 static alpha_extra_func_info_t
find_proc_desc (CORE_ADDR
,
100 static int alpha_in_lenient_prologue (CORE_ADDR
, CORE_ADDR
);
103 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element
*);
105 static CORE_ADDR
after_prologue (CORE_ADDR pc
,
106 alpha_extra_func_info_t proc_desc
);
108 static int alpha_in_prologue (CORE_ADDR pc
,
109 alpha_extra_func_info_t proc_desc
);
111 static int alpha_about_to_return (CORE_ADDR pc
);
113 void _initialize_alpha_tdep (void);
115 /* Heuristic_proc_start may hunt through the text section for a long
116 time across a 2400 baud serial line. Allows the user to limit this
118 static unsigned int heuristic_fence_post
= 0;
120 /* Layout of a stack frame on the alpha:
123 pdr members: | 7th ... nth arg, |
124 | `pushed' by caller. |
126 ----------------|-------------------------------|<-- old_sp == vfp
129 | |localoff | Copies of 1st .. 6th |
130 | | | | | argument if necessary. |
132 | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS
134 | | | | Locals and temporaries. |
136 | | | |-------------------------------|
138 |-fregoffset | Saved float registers. |
144 | | -------|-------------------------------|
146 | | | Saved registers. |
153 | ----------|-------------------------------|
155 frameoffset | Argument build area, gets |
156 | | 7th ... nth arg for any |
157 | | called procedure. |
159 -------------|-------------------------------|<-- sp
164 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
165 /* These next two fields are kind of being hijacked. I wonder if
166 iline is too small for the values it needs to hold, if GDB is
167 running on a 32-bit host. */
168 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
169 #define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset) /*CALL_DUMMY frame */
170 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
171 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
172 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
173 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
174 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
175 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
176 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
177 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
178 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
179 #define _PROC_MAGIC_ 0x0F0F0F0F
180 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
181 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
183 struct linked_proc_info
185 struct alpha_extra_func_info info
;
186 struct linked_proc_info
*next
;
188 *linked_proc_desc_table
= NULL
;
191 alpha_frame_past_sigtramp_frame (struct frame_info
*frame
, CORE_ADDR pc
)
193 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
195 if (tdep
->skip_sigtramp_frame
!= NULL
)
196 return (tdep
->skip_sigtramp_frame (frame
, pc
));
202 alpha_dynamic_sigtramp_offset (CORE_ADDR pc
)
204 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
206 /* Must be provided by OS/ABI variant code if supported. */
207 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
208 return (tdep
->dynamic_sigtramp_offset (pc
));
213 #define ALPHA_PROC_SIGTRAMP_MAGIC 0x0e0f0f0f
215 /* Return TRUE if the procedure descriptor PROC is a procedure
216 descriptor that refers to a dynamically generated signal
217 trampoline routine. */
219 alpha_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info
*proc
)
221 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
223 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
224 return (proc
->pdr
.isym
== ALPHA_PROC_SIGTRAMP_MAGIC
);
230 alpha_set_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info
*proc
)
232 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
234 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
235 proc
->pdr
.isym
= ALPHA_PROC_SIGTRAMP_MAGIC
;
238 /* Dynamically create a signal-handler caller procedure descriptor for
239 the signal-handler return code starting at address LOW_ADDR. The
240 descriptor is added to the linked_proc_desc_table. */
242 static alpha_extra_func_info_t
243 push_sigtramp_desc (CORE_ADDR low_addr
)
245 struct linked_proc_info
*link
;
246 alpha_extra_func_info_t proc_desc
;
248 link
= (struct linked_proc_info
*)
249 xmalloc (sizeof (struct linked_proc_info
));
250 link
->next
= linked_proc_desc_table
;
251 linked_proc_desc_table
= link
;
253 proc_desc
= &link
->info
;
255 proc_desc
->numargs
= 0;
256 PROC_LOW_ADDR (proc_desc
) = low_addr
;
257 PROC_HIGH_ADDR (proc_desc
) = low_addr
+ 3 * 4;
258 PROC_DUMMY_FRAME (proc_desc
) = 0;
259 PROC_FRAME_OFFSET (proc_desc
) = 0x298; /* sizeof(struct sigcontext_struct) */
260 PROC_FRAME_REG (proc_desc
) = SP_REGNUM
;
261 PROC_REG_MASK (proc_desc
) = 0xffff;
262 PROC_FREG_MASK (proc_desc
) = 0xffff;
263 PROC_PC_REG (proc_desc
) = 26;
264 PROC_LOCALOFF (proc_desc
) = 0;
265 alpha_set_proc_desc_is_dyn_sigtramp (proc_desc
);
271 alpha_register_name (int regno
)
273 static char *register_names
[] =
275 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
276 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
277 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
278 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
279 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
280 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
281 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
282 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
283 "pc", "vfp", "unique",
288 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
290 return (register_names
[regno
]);
294 alpha_cannot_fetch_register (int regno
)
296 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
300 alpha_cannot_store_register (int regno
)
302 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
306 alpha_register_convertible (int regno
)
308 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
312 alpha_register_virtual_type (int regno
)
314 return ((regno
>= FP0_REGNUM
&& regno
< (FP0_REGNUM
+31))
315 ? builtin_type_double
: builtin_type_long
);
319 alpha_register_byte (int regno
)
325 alpha_register_raw_size (int regno
)
331 alpha_register_virtual_size (int regno
)
338 alpha_sigcontext_addr (struct frame_info
*fi
)
340 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
342 if (tdep
->sigcontext_addr
)
343 return (tdep
->sigcontext_addr (fi
));
348 /* Guaranteed to set frame->saved_regs to some values (it never leaves it
352 alpha_find_saved_regs (struct frame_info
*frame
)
355 CORE_ADDR reg_position
;
357 alpha_extra_func_info_t proc_desc
;
360 frame_saved_regs_zalloc (frame
);
362 /* If it is the frame for __sigtramp, the saved registers are located
363 in a sigcontext structure somewhere on the stack. __sigtramp
364 passes a pointer to the sigcontext structure on the stack.
365 If the stack layout for __sigtramp changes, or if sigcontext offsets
366 change, we might have to update this code. */
367 #ifndef SIGFRAME_PC_OFF
368 #define SIGFRAME_PC_OFF (2 * 8)
369 #define SIGFRAME_REGSAVE_OFF (4 * 8)
370 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
372 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
374 CORE_ADDR sigcontext_addr
;
376 sigcontext_addr
= alpha_sigcontext_addr (frame
);
377 if (sigcontext_addr
== 0)
379 /* Don't know where the sigcontext is; just bail. */
382 for (ireg
= 0; ireg
< 32; ireg
++)
384 reg_position
= sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ ireg
* 8;
385 get_frame_saved_regs (frame
)[ireg
] = reg_position
;
387 for (ireg
= 0; ireg
< 32; ireg
++)
389 reg_position
= sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ ireg
* 8;
390 get_frame_saved_regs (frame
)[FP0_REGNUM
+ ireg
] = reg_position
;
392 get_frame_saved_regs (frame
)[PC_REGNUM
] = sigcontext_addr
+ SIGFRAME_PC_OFF
;
396 proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
397 if (proc_desc
== NULL
)
398 /* I'm not sure how/whether this can happen. Normally when we can't
399 find a proc_desc, we "synthesize" one using heuristic_proc_desc
400 and set the saved_regs right away. */
403 /* Fill in the offsets for the registers which gen_mask says
406 reg_position
= get_frame_base (frame
) + PROC_REG_OFFSET (proc_desc
);
407 mask
= PROC_REG_MASK (proc_desc
);
409 returnreg
= PROC_PC_REG (proc_desc
);
411 /* Note that RA is always saved first, regardless of its actual
413 if (mask
& (1 << returnreg
))
415 get_frame_saved_regs (frame
)[returnreg
] = reg_position
;
417 mask
&= ~(1 << returnreg
); /* Clear bit for RA so we
418 don't save again later. */
421 for (ireg
= 0; ireg
<= 31; ++ireg
)
422 if (mask
& (1 << ireg
))
424 get_frame_saved_regs (frame
)[ireg
] = reg_position
;
428 /* Fill in the offsets for the registers which float_mask says
431 reg_position
= get_frame_base (frame
) + PROC_FREG_OFFSET (proc_desc
);
432 mask
= PROC_FREG_MASK (proc_desc
);
434 for (ireg
= 0; ireg
<= 31; ++ireg
)
435 if (mask
& (1 << ireg
))
437 get_frame_saved_regs (frame
)[FP0_REGNUM
+ ireg
] = reg_position
;
441 get_frame_saved_regs (frame
)[PC_REGNUM
] = get_frame_saved_regs (frame
)[returnreg
];
445 alpha_frame_init_saved_regs (struct frame_info
*fi
)
447 if (get_frame_saved_regs (fi
) == NULL
)
448 alpha_find_saved_regs (fi
);
449 get_frame_saved_regs (fi
)[SP_REGNUM
] = get_frame_base (fi
);
453 alpha_init_frame_pc_first (int fromleaf
, struct frame_info
*prev
)
456 ? DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev
))
457 : get_next_frame (prev
)
458 ? DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev
))
463 read_next_frame_reg (struct frame_info
*fi
, int regno
)
465 for (; fi
; fi
= get_next_frame (fi
))
467 /* We have to get the saved sp from the sigcontext
468 if it is a signal handler frame. */
469 if (regno
== SP_REGNUM
&& !(get_frame_type (fi
) == SIGTRAMP_FRAME
))
470 return get_frame_base (fi
);
473 if (get_frame_saved_regs (fi
) == NULL
)
474 alpha_find_saved_regs (fi
);
475 if (get_frame_saved_regs (fi
)[regno
])
476 return read_memory_integer (get_frame_saved_regs (fi
)[regno
], 8);
479 return read_register (regno
);
483 alpha_frame_saved_pc (struct frame_info
*frame
)
485 alpha_extra_func_info_t proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
486 /* We have to get the saved pc from the sigcontext
487 if it is a signal handler frame. */
488 int pcreg
= ((get_frame_type (frame
) == SIGTRAMP_FRAME
)
490 : get_frame_extra_info (frame
)->pc_reg
);
492 if (proc_desc
&& PROC_DESC_IS_DUMMY (proc_desc
))
493 return read_memory_integer (get_frame_base (frame
) - 8, 8);
495 return read_next_frame_reg (frame
, pcreg
);
499 alpha_saved_pc_after_call (struct frame_info
*frame
)
501 CORE_ADDR pc
= get_frame_pc (frame
);
503 alpha_extra_func_info_t proc_desc
;
506 /* Skip over shared library trampoline if necessary. */
507 tmp
= SKIP_TRAMPOLINE_CODE (pc
);
511 proc_desc
= find_proc_desc (pc
, get_next_frame (frame
));
512 pcreg
= proc_desc
? PROC_PC_REG (proc_desc
) : ALPHA_RA_REGNUM
;
514 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
515 return alpha_frame_saved_pc (frame
);
517 return read_register (pcreg
);
521 static struct alpha_extra_func_info temp_proc_desc
;
522 static CORE_ADDR temp_saved_regs
[ALPHA_NUM_REGS
];
524 /* Nonzero if instruction at PC is a return instruction. "ret
525 $zero,($ra),1" on alpha. */
528 alpha_about_to_return (CORE_ADDR pc
)
530 return read_memory_integer (pc
, 4) == 0x6bfa8001;
535 /* This fencepost looks highly suspicious to me. Removing it also
536 seems suspicious as it could affect remote debugging across serial
540 heuristic_proc_start (CORE_ADDR pc
)
542 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
543 CORE_ADDR start_pc
= pc
;
544 CORE_ADDR fence
= start_pc
- heuristic_fence_post
;
549 if (heuristic_fence_post
== UINT_MAX
550 || fence
< tdep
->vm_min_address
)
551 fence
= tdep
->vm_min_address
;
553 /* search back for previous return */
554 for (start_pc
-= 4;; start_pc
-= 4)
555 if (start_pc
< fence
)
557 /* It's not clear to me why we reach this point when
558 stop_soon, but with this test, at least we
559 don't print out warnings for every child forked (eg, on
560 decstation). 22apr93 rich@cygnus.com. */
561 if (stop_soon
== NO_STOP_QUIETLY
)
563 static int blurb_printed
= 0;
565 if (fence
== tdep
->vm_min_address
)
566 warning ("Hit beginning of text section without finding");
568 warning ("Hit heuristic-fence-post without finding");
570 warning ("enclosing function for address 0x%s", paddr_nz (pc
));
574 This warning occurs if you are debugging a function without any symbols\n\
575 (for example, in a stripped executable). In that case, you may wish to\n\
576 increase the size of the search with the `set heuristic-fence-post' command.\n\
578 Otherwise, you told GDB there was a function where there isn't one, or\n\
579 (more likely) you have encountered a bug in GDB.\n");
586 else if (alpha_about_to_return (start_pc
))
589 start_pc
+= 4; /* skip return */
593 static alpha_extra_func_info_t
594 heuristic_proc_desc (CORE_ADDR start_pc
, CORE_ADDR limit_pc
,
595 struct frame_info
*next_frame
)
597 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
601 int has_frame_reg
= 0;
602 unsigned long reg_mask
= 0;
608 memset (&temp_proc_desc
, '\0', sizeof (temp_proc_desc
));
609 memset (&temp_saved_regs
, '\0', SIZEOF_FRAME_SAVED_REGS
);
610 PROC_LOW_ADDR (&temp_proc_desc
) = start_pc
;
612 if (start_pc
+ 200 < limit_pc
)
613 limit_pc
= start_pc
+ 200;
615 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
621 status
= read_memory_nobpt (cur_pc
, buf
, 4);
623 memory_error (status
, cur_pc
);
624 word
= extract_unsigned_integer (buf
, 4);
626 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
630 /* Consider only the first stack allocation instruction
631 to contain the static size of the frame. */
633 frame_size
+= (-word
) & 0xffff;
636 /* Exit loop if a positive stack adjustment is found, which
637 usually means that the stack cleanup code in the function
638 epilogue is reached. */
641 else if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
642 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
644 int reg
= (word
& 0x03e00000) >> 21;
645 reg_mask
|= 1 << reg
;
647 /* Do not compute the address where the register was saved yet,
648 because we don't know yet if the offset will need to be
649 relative to $sp or $fp (we can not compute the address relative
650 to $sp if $sp is updated during the execution of the current
651 subroutine, for instance when doing some alloca). So just store
652 the offset for the moment, and compute the address later
653 when we know whether this frame has a frame pointer or not.
655 temp_saved_regs
[reg
] = (short) word
;
657 /* Starting with OSF/1-3.2C, the system libraries are shipped
658 without local symbols, but they still contain procedure
659 descriptors without a symbol reference. GDB is currently
660 unable to find these procedure descriptors and uses
661 heuristic_proc_desc instead.
662 As some low level compiler support routines (__div*, __add*)
663 use a non-standard return address register, we have to
664 add some heuristics to determine the return address register,
665 or stepping over these routines will fail.
666 Usually the return address register is the first register
667 saved on the stack, but assembler optimization might
668 rearrange the register saves.
669 So we recognize only a few registers (t7, t9, ra) within
670 the procedure prologue as valid return address registers.
671 If we encounter a return instruction, we extract the
672 the return address register from it.
674 FIXME: Rewriting GDB to access the procedure descriptors,
675 e.g. via the minimal symbol table, might obviate this hack. */
677 && cur_pc
< (start_pc
+ 80)
678 && (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
679 || reg
== ALPHA_RA_REGNUM
))
682 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
683 pcreg
= (word
>> 16) & 0x1f;
684 else if (word
== 0x47de040f || word
== 0x47fe040f) /* bis sp,sp fp */
686 /* ??? I am not sure what instruction is 0x47fe040f, and I
687 am suspecting that there was a typo and should have been
688 0x47fe040f. I'm keeping it in the test above until further
691 vfp
= read_next_frame_reg (next_frame
, ALPHA_GCC_FP_REGNUM
);
696 /* If we haven't found a valid return address register yet,
697 keep searching in the procedure prologue. */
698 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
703 if (read_memory_nobpt (cur_pc
, buf
, 4))
706 word
= extract_unsigned_integer (buf
, 4);
708 if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
709 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
711 int reg
= (word
& 0x03e00000) >> 21;
712 if (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
713 || reg
== ALPHA_RA_REGNUM
)
719 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
721 pcreg
= (word
>> 16) & 0x1f;
728 PROC_FRAME_REG (&temp_proc_desc
) = ALPHA_GCC_FP_REGNUM
;
730 PROC_FRAME_REG (&temp_proc_desc
) = SP_REGNUM
;
732 /* At this point, we know which of the Stack Pointer or the Frame Pointer
733 to use as the reference address to compute the saved registers address.
734 But in both cases, the processing above has set vfp to this reference
735 address, so just need to increment the offset of each saved register
737 for (regno
= 0; regno
< NUM_REGS
; regno
++)
739 if (reg_mask
& 1 << regno
)
740 temp_saved_regs
[regno
] += vfp
;
743 PROC_FRAME_OFFSET (&temp_proc_desc
) = frame_size
;
744 PROC_REG_MASK (&temp_proc_desc
) = reg_mask
;
745 PROC_PC_REG (&temp_proc_desc
) = (pcreg
== -1) ? ALPHA_RA_REGNUM
: pcreg
;
746 PROC_LOCALOFF (&temp_proc_desc
) = 0; /* XXX - bogus */
747 return &temp_proc_desc
;
750 /* This returns the PC of the first inst after the prologue. If we can't
751 find the prologue, then return 0. */
754 after_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
756 struct symtab_and_line sal
;
757 CORE_ADDR func_addr
, func_end
;
760 proc_desc
= find_proc_desc (pc
, NULL
);
764 if (alpha_proc_desc_is_dyn_sigtramp (proc_desc
))
765 return PROC_LOW_ADDR (proc_desc
); /* "prologue" is in kernel */
767 /* If function is frameless, then we need to do it the hard way. I
768 strongly suspect that frameless always means prologueless... */
769 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
770 && PROC_FRAME_OFFSET (proc_desc
) == 0)
774 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
775 return 0; /* Unknown */
777 sal
= find_pc_line (func_addr
, 0);
779 if (sal
.end
< func_end
)
782 /* The line after the prologue is after the end of the function. In this
783 case, tell the caller to find the prologue the hard way. */
788 /* Return non-zero if we *might* be in a function prologue. Return zero if we
789 are definitively *not* in a function prologue. */
792 alpha_in_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
794 CORE_ADDR after_prologue_pc
;
796 after_prologue_pc
= after_prologue (pc
, proc_desc
);
798 if (after_prologue_pc
== 0
799 || pc
< after_prologue_pc
)
805 static alpha_extra_func_info_t
806 find_proc_desc (CORE_ADDR pc
, struct frame_info
*next_frame
)
808 alpha_extra_func_info_t proc_desc
;
813 /* Try to get the proc_desc from the linked call dummy proc_descs
814 if the pc is in the call dummy.
815 This is hairy. In the case of nested dummy calls we have to find the
816 right proc_desc, but we might not yet know the frame for the dummy
817 as it will be contained in the proc_desc we are searching for.
818 So we have to find the proc_desc whose frame is closest to the current
821 if (DEPRECATED_PC_IN_CALL_DUMMY (pc
, 0, 0))
823 struct linked_proc_info
*link
;
824 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
825 alpha_extra_func_info_t found_proc_desc
= NULL
;
826 long min_distance
= LONG_MAX
;
828 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
830 long distance
= (CORE_ADDR
) PROC_DUMMY_FRAME (&link
->info
) - sp
;
831 if (distance
> 0 && distance
< min_distance
)
833 min_distance
= distance
;
834 found_proc_desc
= &link
->info
;
837 if (found_proc_desc
!= NULL
)
838 return found_proc_desc
;
841 b
= block_for_pc (pc
);
843 find_pc_partial_function (pc
, NULL
, &startaddr
, NULL
);
848 if (startaddr
> BLOCK_START (b
))
849 /* This is the "pathological" case referred to in a comment in
850 print_frame_info. It might be better to move this check into
854 sym
= lookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
,
858 /* If we never found a PDR for this function in symbol reading, then
859 examine prologues to find the information. */
860 if (sym
&& ((mips_extra_func_info_t
) SYMBOL_VALUE (sym
))->pdr
.framereg
== -1)
865 /* IF this is the topmost frame AND
866 * (this proc does not have debugging information OR
867 * the PC is in the procedure prologue)
868 * THEN create a "heuristic" proc_desc (by analyzing
869 * the actual code) to replace the "official" proc_desc.
871 proc_desc
= (alpha_extra_func_info_t
) SYMBOL_VALUE (sym
);
872 if (next_frame
== NULL
)
874 if (PROC_DESC_IS_DUMMY (proc_desc
) || alpha_in_prologue (pc
, proc_desc
))
876 alpha_extra_func_info_t found_heuristic
=
877 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc
),
881 PROC_LOCALOFF (found_heuristic
) =
882 PROC_LOCALOFF (proc_desc
);
883 PROC_PC_REG (found_heuristic
) = PROC_PC_REG (proc_desc
);
884 proc_desc
= found_heuristic
;
893 /* Is linked_proc_desc_table really necessary? It only seems to be used
894 by procedure call dummys. However, the procedures being called ought
895 to have their own proc_descs, and even if they don't,
896 heuristic_proc_desc knows how to create them! */
898 register struct linked_proc_info
*link
;
899 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
900 if (PROC_LOW_ADDR (&link
->info
) <= pc
901 && PROC_HIGH_ADDR (&link
->info
) > pc
)
904 /* If PC is inside a dynamically generated sigtramp handler,
905 create and push a procedure descriptor for that code: */
906 offset
= alpha_dynamic_sigtramp_offset (pc
);
908 return push_sigtramp_desc (pc
- offset
);
910 /* If heuristic_fence_post is non-zero, determine the procedure
911 start address by examining the instructions.
912 This allows us to find the start address of static functions which
913 have no symbolic information, as startaddr would have been set to
914 the preceding global function start address by the
915 find_pc_partial_function call above. */
916 if (startaddr
== 0 || heuristic_fence_post
!= 0)
917 startaddr
= heuristic_proc_start (pc
);
920 heuristic_proc_desc (startaddr
, pc
, next_frame
);
925 alpha_extra_func_info_t cached_proc_desc
;
928 alpha_frame_chain (struct frame_info
*frame
)
930 alpha_extra_func_info_t proc_desc
;
931 CORE_ADDR saved_pc
= DEPRECATED_FRAME_SAVED_PC (frame
);
933 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
936 proc_desc
= find_proc_desc (saved_pc
, frame
);
940 cached_proc_desc
= proc_desc
;
942 /* Fetch the frame pointer for a dummy frame from the procedure
944 if (PROC_DESC_IS_DUMMY (proc_desc
))
945 return (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
947 /* If no frame pointer and frame size is zero, we must be at end
948 of stack (or otherwise hosed). If we don't check frame size,
949 we loop forever if we see a zero size frame. */
950 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
951 && PROC_FRAME_OFFSET (proc_desc
) == 0
952 /* The previous frame from a sigtramp frame might be frameless
953 and have frame size zero. */
954 && !(get_frame_type (frame
) == SIGTRAMP_FRAME
))
955 return alpha_frame_past_sigtramp_frame (frame
, saved_pc
);
957 return read_next_frame_reg (frame
, PROC_FRAME_REG (proc_desc
))
958 + PROC_FRAME_OFFSET (proc_desc
);
962 alpha_print_extra_frame_info (struct frame_info
*fi
)
965 && get_frame_extra_info (fi
)
966 && get_frame_extra_info (fi
)->proc_desc
967 && get_frame_extra_info (fi
)->proc_desc
->pdr
.framereg
< NUM_REGS
)
968 printf_filtered (" frame pointer is at %s+%s\n",
969 REGISTER_NAME (get_frame_extra_info (fi
)->proc_desc
->pdr
.framereg
),
970 paddr_d (get_frame_extra_info (fi
)->proc_desc
->pdr
.frameoffset
));
974 alpha_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
976 /* Use proc_desc calculated in frame_chain */
977 alpha_extra_func_info_t proc_desc
=
978 get_next_frame (frame
)
980 : find_proc_desc (get_frame_pc (frame
), get_next_frame (frame
));
982 frame_extra_info_zalloc (frame
, sizeof (struct frame_extra_info
));
984 /* NOTE: cagney/2003-01-03: No need to set saved_regs to NULL,
985 always NULL by default. */
986 /* frame->saved_regs = NULL; */
987 get_frame_extra_info (frame
)->localoff
= 0;
988 get_frame_extra_info (frame
)->pc_reg
= ALPHA_RA_REGNUM
;
989 get_frame_extra_info (frame
)->proc_desc
= proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
992 /* Get the locals offset and the saved pc register from the
993 procedure descriptor, they are valid even if we are in the
994 middle of the prologue. */
995 get_frame_extra_info (frame
)->localoff
= PROC_LOCALOFF (proc_desc
);
996 get_frame_extra_info (frame
)->pc_reg
= PROC_PC_REG (proc_desc
);
998 /* Fixup frame-pointer - only needed for top frame */
1000 /* Fetch the frame pointer for a dummy frame from the procedure
1002 if (PROC_DESC_IS_DUMMY (proc_desc
))
1003 deprecated_update_frame_base_hack (frame
, (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
));
1005 /* This may not be quite right, if proc has a real frame register.
1006 Get the value of the frame relative sp, procedure might have been
1007 interrupted by a signal at it's very start. */
1008 else if (get_frame_pc (frame
) == PROC_LOW_ADDR (proc_desc
)
1009 && !alpha_proc_desc_is_dyn_sigtramp (proc_desc
))
1010 deprecated_update_frame_base_hack (frame
, read_next_frame_reg (get_next_frame (frame
), SP_REGNUM
));
1012 deprecated_update_frame_base_hack (frame
, read_next_frame_reg (get_next_frame (frame
), PROC_FRAME_REG (proc_desc
))
1013 + PROC_FRAME_OFFSET (proc_desc
));
1015 if (proc_desc
== &temp_proc_desc
)
1019 /* Do not set the saved registers for a sigtramp frame,
1020 alpha_find_saved_registers will do that for us. We can't
1021 use (get_frame_type (frame) == SIGTRAMP_FRAME), it is not
1023 /* FIXME: cagney/2002-11-18: This problem will go away once
1024 frame.c:get_prev_frame() is modified to set the frame's
1025 type before calling functions like this. */
1026 find_pc_partial_function (get_frame_pc (frame
), &name
,
1027 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
1028 if (!PC_IN_SIGTRAMP (get_frame_pc (frame
), name
))
1030 frame_saved_regs_zalloc (frame
);
1031 memcpy (get_frame_saved_regs (frame
), temp_saved_regs
,
1032 SIZEOF_FRAME_SAVED_REGS
);
1033 get_frame_saved_regs (frame
)[PC_REGNUM
]
1034 = get_frame_saved_regs (frame
)[ALPHA_RA_REGNUM
];
1041 alpha_frame_locals_address (struct frame_info
*fi
)
1043 return (get_frame_base (fi
) - get_frame_extra_info (fi
)->localoff
);
1047 alpha_frame_args_address (struct frame_info
*fi
)
1049 return (get_frame_base (fi
) - (ALPHA_NUM_ARG_REGS
* 8));
1052 /* ALPHA stack frames are almost impenetrable. When execution stops,
1053 we basically have to look at symbol information for the function
1054 that we stopped in, which tells us *which* register (if any) is
1055 the base of the frame pointer, and what offset from that register
1056 the frame itself is at.
1058 This presents a problem when trying to examine a stack in memory
1059 (that isn't executing at the moment), using the "frame" command. We
1060 don't have a PC, nor do we have any registers except SP.
1062 This routine takes two arguments, SP and PC, and tries to make the
1063 cached frames look as if these two arguments defined a frame on the
1064 cache. This allows the rest of info frame to extract the important
1065 arguments without difficulty. */
1068 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1071 error ("ALPHA frame specifications require two arguments: sp and pc");
1073 return create_new_frame (argv
[0], argv
[1]);
1076 /* The alpha passes the first six arguments in the registers, the rest on
1077 the stack. The register arguments are eventually transferred to the
1078 argument transfer area immediately below the stack by the called function
1079 anyway. So we `push' at least six arguments on the stack, `reload' the
1080 argument registers and then adjust the stack pointer to point past the
1081 sixth argument. This algorithm simplifies the passing of a large struct
1082 which extends from the registers to the stack.
1083 If the called function is returning a structure, the address of the
1084 structure to be returned is passed as a hidden first argument. */
1087 alpha_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1088 int struct_return
, CORE_ADDR struct_addr
)
1091 int accumulate_size
= struct_return
? 8 : 0;
1092 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
1099 struct alpha_arg
*alpha_args
=
1100 (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
1101 register struct alpha_arg
*m_arg
;
1102 char raw_buffer
[sizeof (CORE_ADDR
)];
1103 int required_arg_regs
;
1105 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
1107 struct value
*arg
= args
[i
];
1108 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1109 /* Cast argument to long if necessary as the compiler does it too. */
1110 switch (TYPE_CODE (arg_type
))
1113 case TYPE_CODE_BOOL
:
1114 case TYPE_CODE_CHAR
:
1115 case TYPE_CODE_RANGE
:
1116 case TYPE_CODE_ENUM
:
1117 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
1119 arg_type
= builtin_type_long
;
1120 arg
= value_cast (arg_type
, arg
);
1126 m_arg
->len
= TYPE_LENGTH (arg_type
);
1127 m_arg
->offset
= accumulate_size
;
1128 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
1129 m_arg
->contents
= VALUE_CONTENTS (arg
);
1132 /* Determine required argument register loads, loading an argument register
1133 is expensive as it uses three ptrace calls. */
1134 required_arg_regs
= accumulate_size
/ 8;
1135 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
1136 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
1138 /* Make room for the arguments on the stack. */
1139 if (accumulate_size
< arg_regs_size
)
1140 accumulate_size
= arg_regs_size
;
1141 sp
-= accumulate_size
;
1143 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
1146 /* `Push' arguments on the stack. */
1147 for (i
= nargs
; m_arg
--, --i
>= 0;)
1148 write_memory (sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
1151 store_address (raw_buffer
, sizeof (CORE_ADDR
), struct_addr
);
1152 write_memory (sp
, raw_buffer
, sizeof (CORE_ADDR
));
1155 /* Load the argument registers. */
1156 for (i
= 0; i
< required_arg_regs
; i
++)
1160 val
= read_memory_integer (sp
+ i
* 8, 8);
1161 write_register (ALPHA_A0_REGNUM
+ i
, val
);
1162 write_register (ALPHA_FPA0_REGNUM
+ i
, val
);
1165 return sp
+ arg_regs_size
;
1169 alpha_push_dummy_frame (void)
1172 struct linked_proc_info
*link
;
1173 alpha_extra_func_info_t proc_desc
;
1174 CORE_ADDR sp
= read_register (SP_REGNUM
);
1175 CORE_ADDR save_address
;
1176 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1179 link
= (struct linked_proc_info
*) xmalloc (sizeof (struct linked_proc_info
));
1180 link
->next
= linked_proc_desc_table
;
1181 linked_proc_desc_table
= link
;
1183 proc_desc
= &link
->info
;
1186 * The registers we must save are all those not preserved across
1188 * In addition, we must save the PC and RA.
1190 * Dummy frame layout:
1200 * Parameter build area
1204 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
1205 #define MASK(i,j) ((((LONGEST)1 << ((j)+1)) - 1) ^ (((LONGEST)1 << (i)) - 1))
1206 #define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
1207 #define GEN_REG_SAVE_COUNT 24
1208 #define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
1209 #define FLOAT_REG_SAVE_COUNT 23
1210 /* The special register is the PC as we have no bit for it in the save masks.
1211 alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
1212 #define SPECIAL_REG_SAVE_COUNT 1
1214 PROC_REG_MASK (proc_desc
) = GEN_REG_SAVE_MASK
;
1215 PROC_FREG_MASK (proc_desc
) = FLOAT_REG_SAVE_MASK
;
1216 /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
1217 but keep SP aligned to a multiple of 16. */
1218 PROC_REG_OFFSET (proc_desc
) =
1219 -((8 * (SPECIAL_REG_SAVE_COUNT
1220 + GEN_REG_SAVE_COUNT
1221 + FLOAT_REG_SAVE_COUNT
)
1223 PROC_FREG_OFFSET (proc_desc
) =
1224 PROC_REG_OFFSET (proc_desc
) + 8 * GEN_REG_SAVE_COUNT
;
1226 /* Save general registers.
1227 The return address register is the first saved register, all other
1228 registers follow in ascending order.
1229 The PC is saved immediately below the SP. */
1230 save_address
= sp
+ PROC_REG_OFFSET (proc_desc
);
1231 store_address (raw_buffer
, 8, read_register (ALPHA_RA_REGNUM
));
1232 write_memory (save_address
, raw_buffer
, 8);
1234 mask
= PROC_REG_MASK (proc_desc
) & 0xffffffffL
;
1235 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1238 if (ireg
== ALPHA_RA_REGNUM
)
1240 store_address (raw_buffer
, 8, read_register (ireg
));
1241 write_memory (save_address
, raw_buffer
, 8);
1245 store_address (raw_buffer
, 8, read_register (PC_REGNUM
));
1246 write_memory (sp
- 8, raw_buffer
, 8);
1248 /* Save floating point registers. */
1249 save_address
= sp
+ PROC_FREG_OFFSET (proc_desc
);
1250 mask
= PROC_FREG_MASK (proc_desc
) & 0xffffffffL
;
1251 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1254 store_address (raw_buffer
, 8, read_register (ireg
+ FP0_REGNUM
));
1255 write_memory (save_address
, raw_buffer
, 8);
1259 /* Set and save the frame address for the dummy.
1260 This is tricky. The only registers that are suitable for a frame save
1261 are those that are preserved across procedure calls (s0-s6). But if
1262 a read system call is interrupted and then a dummy call is made
1263 (see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
1264 is satisfied. Then it returns with the s0-s6 registers set to the values
1265 on entry to the read system call and our dummy frame pointer would be
1266 destroyed. So we save the dummy frame in the proc_desc and handle the
1267 retrieval of the frame pointer of a dummy specifically. The frame register
1268 is set to the virtual frame (pseudo) register, it's value will always
1269 be read as zero and will help us to catch any errors in the dummy frame
1271 PROC_DUMMY_FRAME (proc_desc
) = sp
;
1272 PROC_FRAME_REG (proc_desc
) = FP_REGNUM
;
1273 PROC_FRAME_OFFSET (proc_desc
) = 0;
1274 sp
+= PROC_REG_OFFSET (proc_desc
);
1275 write_register (SP_REGNUM
, sp
);
1277 PROC_LOW_ADDR (proc_desc
) = CALL_DUMMY_ADDRESS ();
1278 PROC_HIGH_ADDR (proc_desc
) = PROC_LOW_ADDR (proc_desc
) + 4;
1280 SET_PROC_DESC_IS_DUMMY (proc_desc
);
1281 PROC_PC_REG (proc_desc
) = ALPHA_RA_REGNUM
;
1285 alpha_pop_frame (void)
1287 register int regnum
;
1288 struct frame_info
*frame
= get_current_frame ();
1289 CORE_ADDR new_sp
= get_frame_base (frame
);
1291 alpha_extra_func_info_t proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
1293 /* we need proc_desc to know how to restore the registers;
1294 if it is NULL, construct (a temporary) one */
1295 if (proc_desc
== NULL
)
1296 proc_desc
= find_proc_desc (get_frame_pc (frame
), get_next_frame (frame
));
1298 /* Question: should we copy this proc_desc and save it in
1299 frame->proc_desc? If we do, who will free it?
1300 For now, we don't save a copy... */
1302 write_register (PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (frame
));
1303 if (get_frame_saved_regs (frame
) == NULL
)
1304 alpha_find_saved_regs (frame
);
1307 for (regnum
= 32; --regnum
>= 0;)
1308 if (PROC_REG_MASK (proc_desc
) & (1 << regnum
))
1309 write_register (regnum
,
1310 read_memory_integer (get_frame_saved_regs (frame
)[regnum
],
1312 for (regnum
= 32; --regnum
>= 0;)
1313 if (PROC_FREG_MASK (proc_desc
) & (1 << regnum
))
1314 write_register (regnum
+ FP0_REGNUM
,
1315 read_memory_integer (get_frame_saved_regs (frame
)[regnum
+ FP0_REGNUM
], 8));
1317 write_register (SP_REGNUM
, new_sp
);
1318 flush_cached_frames ();
1320 if (proc_desc
&& (PROC_DESC_IS_DUMMY (proc_desc
)
1321 || alpha_proc_desc_is_dyn_sigtramp (proc_desc
)))
1323 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
1325 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
1327 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
1329 if (&pi_ptr
->info
== proc_desc
)
1334 error ("Can't locate dummy extra frame info\n");
1336 if (prev_ptr
!= NULL
)
1337 prev_ptr
->next
= pi_ptr
->next
;
1339 linked_proc_desc_table
= pi_ptr
->next
;
1345 /* To skip prologues, I use this predicate. Returns either PC itself
1346 if the code at PC does not look like a function prologue; otherwise
1347 returns an address that (if we're lucky) follows the prologue. If
1348 LENIENT, then we must skip everything which is involved in setting
1349 up the frame (it's OK to skip more, just so long as we don't skip
1350 anything which might clobber the registers which are being saved.
1351 Currently we must not skip more on the alpha, but we might need the
1352 lenient stuff some day. */
1355 alpha_skip_prologue_internal (CORE_ADDR pc
, int lenient
)
1359 CORE_ADDR post_prologue_pc
;
1362 /* Silently return the unaltered pc upon memory errors.
1363 This could happen on OSF/1 if decode_line_1 tries to skip the
1364 prologue for quickstarted shared library functions when the
1365 shared library is not yet mapped in.
1366 Reading target memory is slow over serial lines, so we perform
1367 this check only if the target has shared libraries (which all
1368 Alpha targets do). */
1369 if (target_read_memory (pc
, buf
, 4))
1372 /* See if we can determine the end of the prologue via the symbol table.
1373 If so, then return either PC, or the PC after the prologue, whichever
1376 post_prologue_pc
= after_prologue (pc
, NULL
);
1378 if (post_prologue_pc
!= 0)
1379 return max (pc
, post_prologue_pc
);
1381 /* Can't determine prologue from the symbol table, need to examine
1384 /* Skip the typical prologue instructions. These are the stack adjustment
1385 instruction and the instructions that save registers on the stack
1386 or in the gcc frame. */
1387 for (offset
= 0; offset
< 100; offset
+= 4)
1391 status
= read_memory_nobpt (pc
+ offset
, buf
, 4);
1393 memory_error (status
, pc
+ offset
);
1394 inst
= extract_unsigned_integer (buf
, 4);
1396 /* The alpha has no delay slots. But let's keep the lenient stuff,
1397 we might need it for something else in the future. */
1401 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
1403 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
1405 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1407 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
1410 if ((inst
& 0xfc1f0000) == 0xb41e0000
1411 && (inst
& 0xffff0000) != 0xb7fe0000)
1412 continue; /* stq reg,n($sp) */
1414 if ((inst
& 0xfc1f0000) == 0x9c1e0000
1415 && (inst
& 0xffff0000) != 0x9ffe0000)
1416 continue; /* stt reg,n($sp) */
1418 if (inst
== 0x47de040f) /* bis sp,sp,fp */
1427 alpha_skip_prologue (CORE_ADDR addr
)
1429 return (alpha_skip_prologue_internal (addr
, 0));
1433 /* Is address PC in the prologue (loosely defined) for function at
1437 alpha_in_lenient_prologue (CORE_ADDR startaddr
, CORE_ADDR pc
)
1439 CORE_ADDR end_prologue
= alpha_skip_prologue_internal (startaddr
, 1);
1440 return pc
>= startaddr
&& pc
< end_prologue
;
1444 /* The alpha needs a conversion between register and memory format if
1445 the register is a floating point register and
1446 memory format is float, as the register format must be double
1448 memory format is an integer with 4 bytes or less, as the representation
1449 of integers in floating point registers is different. */
1451 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
1452 char *raw_buffer
, char *virtual_buffer
)
1454 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1456 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
1460 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1462 double d
= deprecated_extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1463 deprecated_store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
1465 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1468 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1469 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
1470 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
1473 error ("Cannot retrieve value from floating point register");
1477 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
1478 char *virtual_buffer
, char *raw_buffer
)
1480 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1482 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
1486 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1488 double d
= deprecated_extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
1489 deprecated_store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
1491 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1494 if (TYPE_UNSIGNED (valtype
))
1495 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1497 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1498 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
1499 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
1502 error ("Cannot store value in floating point register");
1505 static const unsigned char *
1506 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1508 static const unsigned char alpha_breakpoint
[] =
1509 { 0x80, 0, 0, 0 }; /* call_pal bpt */
1511 *lenptr
= sizeof(alpha_breakpoint
);
1512 return (alpha_breakpoint
);
1515 /* Given a return value in `regbuf' with a type `valtype',
1516 extract and copy its value into `valbuf'. */
1519 alpha_extract_return_value (struct type
*valtype
,
1520 char regbuf
[ALPHA_REGISTER_BYTES
], char *valbuf
)
1522 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1523 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
1524 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
1527 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1528 TYPE_LENGTH (valtype
));
1531 /* Given a return value in `regbuf' with a type `valtype',
1532 write its value into the appropriate register. */
1535 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
1537 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1538 int regnum
= ALPHA_V0_REGNUM
;
1539 int length
= TYPE_LENGTH (valtype
);
1541 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1543 regnum
= FP0_REGNUM
;
1544 length
= REGISTER_RAW_SIZE (regnum
);
1545 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
1548 memcpy (raw_buffer
, valbuf
, length
);
1550 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
1553 /* Just like reinit_frame_cache, but with the right arguments to be
1554 callable as an sfunc. */
1557 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1559 reinit_frame_cache ();
1562 /* This is the definition of CALL_DUMMY_ADDRESS. It's a heuristic that is used
1563 to find a convenient place in the text segment to stick a breakpoint to
1564 detect the completion of a target function call (ala call_function_by_hand).
1568 alpha_call_dummy_address (void)
1571 struct minimal_symbol
*sym
;
1573 entry
= entry_point_address ();
1578 sym
= lookup_minimal_symbol ("_Prelude", NULL
, symfile_objfile
);
1580 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1583 return SYMBOL_VALUE_ADDRESS (sym
) + 4;
1587 alpha_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
1588 struct value
**args
, struct type
*type
, int gcc_p
)
1590 CORE_ADDR bp_address
= CALL_DUMMY_ADDRESS ();
1592 if (bp_address
== 0)
1593 error ("no place to put call");
1594 write_register (ALPHA_RA_REGNUM
, bp_address
);
1595 write_register (ALPHA_T12_REGNUM
, fun
);
1598 /* On the Alpha, the call dummy code is nevery copied to user space
1599 (see alpha_fix_call_dummy() above). The contents of this do not
1601 LONGEST alpha_call_dummy_words
[] = { 0 };
1604 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
1606 /* Structures are returned by ref in extra arg0. */
1611 alpha_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1613 /* Store the address of the place in which to copy the structure the
1614 subroutine will return. Handled by alpha_push_arguments. */
1618 alpha_extract_struct_value_address (char *regbuf
)
1620 return (extract_address (regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1621 REGISTER_RAW_SIZE (ALPHA_V0_REGNUM
)));
1624 /* Figure out where the longjmp will land.
1625 We expect the first arg to be a pointer to the jmp_buf structure from
1626 which we extract the PC (JB_PC) that we will land at. The PC is copied
1627 into the "pc". This routine returns true on success. */
1630 alpha_get_longjmp_target (CORE_ADDR
*pc
)
1632 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1634 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1636 jb_addr
= read_register (ALPHA_A0_REGNUM
);
1638 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
1639 raw_buffer
, tdep
->jb_elt_size
))
1642 *pc
= extract_address (raw_buffer
, tdep
->jb_elt_size
);
1646 /* alpha_software_single_step() is called just before we want to resume
1647 the inferior, if we want to single-step it but there is no hardware
1648 or kernel single-step support (NetBSD on Alpha, for example). We find
1649 the target of the coming instruction and breakpoint it.
1651 single_step is also called just after the inferior stops. If we had
1652 set up a simulated single-step, we undo our damage. */
1655 alpha_next_pc (CORE_ADDR pc
)
1662 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1664 /* Opcode is top 6 bits. */
1665 op
= (insn
>> 26) & 0x3f;
1669 /* Jump format: target PC is:
1671 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1674 if ((op
& 0x30) == 0x30)
1676 /* Branch format: target PC is:
1677 (new PC) + (4 * sext(displacement)) */
1678 if (op
== 0x30 || /* BR */
1679 op
== 0x34) /* BSR */
1682 offset
= (insn
& 0x001fffff);
1683 if (offset
& 0x00100000)
1684 offset
|= 0xffe00000;
1686 return (pc
+ 4 + offset
);
1689 /* Need to determine if branch is taken; read RA. */
1690 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1693 case 0x38: /* BLBC */
1697 case 0x3c: /* BLBS */
1701 case 0x39: /* BEQ */
1705 case 0x3d: /* BNE */
1709 case 0x3a: /* BLT */
1713 case 0x3b: /* BLE */
1717 case 0x3f: /* BGT */
1721 case 0x3e: /* BGE */
1728 /* Not a branch or branch not taken; target PC is:
1734 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1736 static CORE_ADDR next_pc
;
1737 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1738 static binsn_quantum break_mem
;
1741 if (insert_breakpoints_p
)
1744 next_pc
= alpha_next_pc (pc
);
1746 target_insert_breakpoint (next_pc
, break_mem
);
1750 target_remove_breakpoint (next_pc
, break_mem
);
1757 /* Initialize the current architecture based on INFO. If possible, re-use an
1758 architecture from ARCHES, which is a list of architectures already created
1759 during this debugging session.
1761 Called e.g. at program startup, when reading a core file, and when reading
1764 static struct gdbarch
*
1765 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1767 struct gdbarch_tdep
*tdep
;
1768 struct gdbarch
*gdbarch
;
1770 /* Try to determine the ABI of the object we are loading. */
1771 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1773 /* If it's an ECOFF file, assume it's OSF/1. */
1774 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1775 info
.osabi
= GDB_OSABI_OSF1
;
1778 /* Find a candidate among extant architectures. */
1779 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1781 return arches
->gdbarch
;
1783 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1784 gdbarch
= gdbarch_alloc (&info
, tdep
);
1786 /* Lowest text address. This is used by heuristic_proc_start() to
1787 decide when to stop looking. */
1788 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1790 tdep
->dynamic_sigtramp_offset
= NULL
;
1791 tdep
->skip_sigtramp_frame
= NULL
;
1792 tdep
->sigcontext_addr
= NULL
;
1794 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1797 set_gdbarch_short_bit (gdbarch
, 16);
1798 set_gdbarch_int_bit (gdbarch
, 32);
1799 set_gdbarch_long_bit (gdbarch
, 64);
1800 set_gdbarch_long_long_bit (gdbarch
, 64);
1801 set_gdbarch_float_bit (gdbarch
, 32);
1802 set_gdbarch_double_bit (gdbarch
, 64);
1803 set_gdbarch_long_double_bit (gdbarch
, 64);
1804 set_gdbarch_ptr_bit (gdbarch
, 64);
1807 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1808 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1809 set_gdbarch_fp_regnum (gdbarch
, ALPHA_FP_REGNUM
);
1810 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1811 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1813 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1814 set_gdbarch_register_size (gdbarch
, ALPHA_REGISTER_SIZE
);
1815 set_gdbarch_register_bytes (gdbarch
, ALPHA_REGISTER_BYTES
);
1816 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1817 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1818 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, ALPHA_MAX_REGISTER_RAW_SIZE
);
1819 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1820 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
1821 ALPHA_MAX_REGISTER_VIRTUAL_SIZE
);
1822 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1824 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1825 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1827 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1828 set_gdbarch_register_convert_to_virtual (gdbarch
,
1829 alpha_register_convert_to_virtual
);
1830 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1832 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1834 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1835 set_gdbarch_frameless_function_invocation (gdbarch
,
1836 generic_frameless_function_invocation_not
);
1838 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, alpha_saved_pc_after_call
);
1840 set_gdbarch_deprecated_frame_chain (gdbarch
, alpha_frame_chain
);
1841 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, alpha_frame_saved_pc
);
1843 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, alpha_frame_init_saved_regs
);
1845 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1846 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1848 set_gdbarch_deprecated_store_struct_return (gdbarch
, alpha_store_struct_return
);
1849 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1850 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1851 alpha_extract_struct_value_address
);
1853 /* Settings for calling functions in the inferior. */
1854 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
1855 set_gdbarch_deprecated_push_arguments (gdbarch
, alpha_push_arguments
);
1856 set_gdbarch_deprecated_pop_frame (gdbarch
, alpha_pop_frame
);
1858 /* On the Alpha, the call dummy code is never copied to user space,
1859 stopping the user call is achieved via a bp_call_dummy breakpoint.
1860 But we need a fake CALL_DUMMY definition to enable the proper
1861 call_function_by_hand and to avoid zero length array warnings. */
1862 set_gdbarch_call_dummy_words (gdbarch
, alpha_call_dummy_words
);
1863 set_gdbarch_sizeof_call_dummy_words (gdbarch
, 0);
1864 set_gdbarch_frame_args_address (gdbarch
, alpha_frame_args_address
);
1865 set_gdbarch_frame_locals_address (gdbarch
, alpha_frame_locals_address
);
1866 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, alpha_init_extra_frame_info
);
1868 /* Alpha OSF/1 inhibits execution of code on the stack. But there is
1869 no need for a dummy on the Alpha. PUSH_ARGUMENTS takes care of all
1870 argument handling and bp_call_dummy takes care of stopping the dummy. */
1871 set_gdbarch_call_dummy_address (gdbarch
, alpha_call_dummy_address
);
1872 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1873 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, alpha_push_dummy_frame
);
1874 /* Should be using push_dummy_call. */
1875 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, generic_target_write_sp
);
1876 set_gdbarch_fix_call_dummy (gdbarch
, alpha_fix_call_dummy
);
1877 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_noop
);
1878 set_gdbarch_deprecated_init_frame_pc_first (gdbarch
, alpha_init_frame_pc_first
);
1880 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1881 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1883 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1884 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1886 set_gdbarch_function_start_offset (gdbarch
, 0);
1887 set_gdbarch_frame_args_skip (gdbarch
, 0);
1889 /* Hook in ABI-specific overrides, if they have been registered. */
1890 gdbarch_init_osabi (info
, gdbarch
);
1892 /* Now that we have tuned the configuration, set a few final things
1893 based on what the OS ABI has told us. */
1895 if (tdep
->jb_pc
>= 0)
1896 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1902 alpha_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1904 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1909 fprintf_unfiltered (file
,
1910 "alpha_dump_tdep: vm_min_address = 0x%lx\n",
1911 (long) tdep
->vm_min_address
);
1913 fprintf_unfiltered (file
,
1914 "alpha_dump_tdep: jb_pc = %d\n",
1916 fprintf_unfiltered (file
,
1917 "alpha_dump_tdep: jb_elt_size = %ld\n",
1918 (long) tdep
->jb_elt_size
);
1922 _initialize_alpha_tdep (void)
1924 struct cmd_list_element
*c
;
1926 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, alpha_dump_tdep
);
1928 deprecated_tm_print_insn
= print_insn_alpha
;
1930 /* Let the user set the fence post for heuristic_proc_start. */
1932 /* We really would like to have both "0" and "unlimited" work, but
1933 command.c doesn't deal with that. So make it a var_zinteger
1934 because the user can always use "999999" or some such for unlimited. */
1935 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1936 (char *) &heuristic_fence_post
,
1938 Set the distance searched for the start of a function.\n\
1939 If you are debugging a stripped executable, GDB needs to search through the\n\
1940 program for the start of a function. This command sets the distance of the\n\
1941 search. The only need to set it is when debugging a stripped executable.",
1943 /* We need to throw away the frame cache when we set this, since it
1944 might change our ability to get backtraces. */
1945 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1946 add_show_from_set (c
, &showlist
);