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_store_struct_return_ftype alpha_store_struct_return
;
58 static gdbarch_deprecated_extract_return_value_ftype alpha_extract_return_value
;
59 static gdbarch_deprecated_extract_struct_value_address_ftype
60 alpha_extract_struct_value_address
;
61 static gdbarch_use_struct_convention_ftype alpha_use_struct_convention
;
63 static gdbarch_breakpoint_from_pc_ftype alpha_breakpoint_from_pc
;
65 static gdbarch_frame_args_address_ftype alpha_frame_args_address
;
66 static gdbarch_frame_locals_address_ftype alpha_frame_locals_address
;
68 static gdbarch_skip_prologue_ftype alpha_skip_prologue
;
69 static gdbarch_saved_pc_after_call_ftype alpha_saved_pc_after_call
;
70 static gdbarch_frame_chain_ftype alpha_frame_chain
;
72 static gdbarch_push_arguments_ftype alpha_push_arguments
;
73 static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy
;
75 static gdbarch_get_longjmp_target_ftype alpha_get_longjmp_target
;
77 struct frame_extra_info
79 alpha_extra_func_info_t proc_desc
;
84 /* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
86 /* Prototypes for local functions. */
88 static void alpha_find_saved_regs (struct frame_info
*);
90 static alpha_extra_func_info_t
push_sigtramp_desc (CORE_ADDR low_addr
);
92 static CORE_ADDR
read_next_frame_reg (struct frame_info
*, int);
94 static CORE_ADDR
heuristic_proc_start (CORE_ADDR
);
96 static alpha_extra_func_info_t
heuristic_proc_desc (CORE_ADDR
,
100 static alpha_extra_func_info_t
find_proc_desc (CORE_ADDR
,
101 struct frame_info
*);
104 static int alpha_in_lenient_prologue (CORE_ADDR
, CORE_ADDR
);
107 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element
*);
109 static CORE_ADDR
after_prologue (CORE_ADDR pc
,
110 alpha_extra_func_info_t proc_desc
);
112 static int alpha_in_prologue (CORE_ADDR pc
,
113 alpha_extra_func_info_t proc_desc
);
115 static int alpha_about_to_return (CORE_ADDR pc
);
117 void _initialize_alpha_tdep (void);
119 /* Heuristic_proc_start may hunt through the text section for a long
120 time across a 2400 baud serial line. Allows the user to limit this
122 static unsigned int heuristic_fence_post
= 0;
124 /* Layout of a stack frame on the alpha:
127 pdr members: | 7th ... nth arg, |
128 | `pushed' by caller. |
130 ----------------|-------------------------------|<-- old_sp == vfp
133 | |localoff | Copies of 1st .. 6th |
134 | | | | | argument if necessary. |
136 | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS
138 | | | | Locals and temporaries. |
140 | | | |-------------------------------|
142 |-fregoffset | Saved float registers. |
148 | | -------|-------------------------------|
150 | | | Saved registers. |
157 | ----------|-------------------------------|
159 frameoffset | Argument build area, gets |
160 | | 7th ... nth arg for any |
161 | | called procedure. |
163 -------------|-------------------------------|<-- sp
168 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
169 /* These next two fields are kind of being hijacked. I wonder if
170 iline is too small for the values it needs to hold, if GDB is
171 running on a 32-bit host. */
172 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
173 #define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset) /*CALL_DUMMY frame */
174 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
175 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
176 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
177 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
178 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
179 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
180 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
181 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
182 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
183 #define _PROC_MAGIC_ 0x0F0F0F0F
184 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
185 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
187 struct linked_proc_info
189 struct alpha_extra_func_info info
;
190 struct linked_proc_info
*next
;
192 *linked_proc_desc_table
= NULL
;
195 alpha_frame_past_sigtramp_frame (struct frame_info
*frame
, CORE_ADDR pc
)
197 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
199 if (tdep
->skip_sigtramp_frame
!= NULL
)
200 return (tdep
->skip_sigtramp_frame (frame
, pc
));
206 alpha_dynamic_sigtramp_offset (CORE_ADDR pc
)
208 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
210 /* Must be provided by OS/ABI variant code if supported. */
211 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
212 return (tdep
->dynamic_sigtramp_offset (pc
));
217 #define ALPHA_PROC_SIGTRAMP_MAGIC 0x0e0f0f0f
219 /* Return TRUE if the procedure descriptor PROC is a procedure
220 descriptor that refers to a dynamically generated signal
221 trampoline routine. */
223 alpha_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info
*proc
)
225 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
227 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
228 return (proc
->pdr
.isym
== ALPHA_PROC_SIGTRAMP_MAGIC
);
234 alpha_set_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info
*proc
)
236 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
238 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
239 proc
->pdr
.isym
= ALPHA_PROC_SIGTRAMP_MAGIC
;
242 /* Dynamically create a signal-handler caller procedure descriptor for
243 the signal-handler return code starting at address LOW_ADDR. The
244 descriptor is added to the linked_proc_desc_table. */
246 static alpha_extra_func_info_t
247 push_sigtramp_desc (CORE_ADDR low_addr
)
249 struct linked_proc_info
*link
;
250 alpha_extra_func_info_t proc_desc
;
252 link
= (struct linked_proc_info
*)
253 xmalloc (sizeof (struct linked_proc_info
));
254 link
->next
= linked_proc_desc_table
;
255 linked_proc_desc_table
= link
;
257 proc_desc
= &link
->info
;
259 proc_desc
->numargs
= 0;
260 PROC_LOW_ADDR (proc_desc
) = low_addr
;
261 PROC_HIGH_ADDR (proc_desc
) = low_addr
+ 3 * 4;
262 PROC_DUMMY_FRAME (proc_desc
) = 0;
263 PROC_FRAME_OFFSET (proc_desc
) = 0x298; /* sizeof(struct sigcontext_struct) */
264 PROC_FRAME_REG (proc_desc
) = SP_REGNUM
;
265 PROC_REG_MASK (proc_desc
) = 0xffff;
266 PROC_FREG_MASK (proc_desc
) = 0xffff;
267 PROC_PC_REG (proc_desc
) = 26;
268 PROC_LOCALOFF (proc_desc
) = 0;
269 alpha_set_proc_desc_is_dyn_sigtramp (proc_desc
);
275 alpha_register_name (int regno
)
277 static char *register_names
[] =
279 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
280 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
281 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
282 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
283 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
284 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
285 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
286 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
287 "pc", "vfp", "unique",
292 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
294 return (register_names
[regno
]);
298 alpha_cannot_fetch_register (int regno
)
300 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
304 alpha_cannot_store_register (int regno
)
306 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
310 alpha_register_convertible (int regno
)
312 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
316 alpha_register_virtual_type (int regno
)
318 return ((regno
>= FP0_REGNUM
&& regno
< (FP0_REGNUM
+31))
319 ? builtin_type_double
: builtin_type_long
);
323 alpha_register_byte (int regno
)
329 alpha_register_raw_size (int regno
)
335 alpha_register_virtual_size (int regno
)
342 alpha_sigcontext_addr (struct frame_info
*fi
)
344 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
346 if (tdep
->sigcontext_addr
)
347 return (tdep
->sigcontext_addr (fi
));
352 /* Guaranteed to set frame->saved_regs to some values (it never leaves it
356 alpha_find_saved_regs (struct frame_info
*frame
)
359 CORE_ADDR reg_position
;
361 alpha_extra_func_info_t proc_desc
;
364 frame_saved_regs_zalloc (frame
);
366 /* If it is the frame for __sigtramp, the saved registers are located
367 in a sigcontext structure somewhere on the stack. __sigtramp
368 passes a pointer to the sigcontext structure on the stack.
369 If the stack layout for __sigtramp changes, or if sigcontext offsets
370 change, we might have to update this code. */
371 #ifndef SIGFRAME_PC_OFF
372 #define SIGFRAME_PC_OFF (2 * 8)
373 #define SIGFRAME_REGSAVE_OFF (4 * 8)
374 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
376 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
378 CORE_ADDR sigcontext_addr
;
380 sigcontext_addr
= alpha_sigcontext_addr (frame
);
381 if (sigcontext_addr
== 0)
383 /* Don't know where the sigcontext is; just bail. */
386 for (ireg
= 0; ireg
< 32; ireg
++)
388 reg_position
= sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ ireg
* 8;
389 get_frame_saved_regs (frame
)[ireg
] = reg_position
;
391 for (ireg
= 0; ireg
< 32; ireg
++)
393 reg_position
= sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ ireg
* 8;
394 get_frame_saved_regs (frame
)[FP0_REGNUM
+ ireg
] = reg_position
;
396 get_frame_saved_regs (frame
)[PC_REGNUM
] = sigcontext_addr
+ SIGFRAME_PC_OFF
;
400 proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
401 if (proc_desc
== NULL
)
402 /* I'm not sure how/whether this can happen. Normally when we can't
403 find a proc_desc, we "synthesize" one using heuristic_proc_desc
404 and set the saved_regs right away. */
407 /* Fill in the offsets for the registers which gen_mask says
410 reg_position
= get_frame_base (frame
) + PROC_REG_OFFSET (proc_desc
);
411 mask
= PROC_REG_MASK (proc_desc
);
413 returnreg
= PROC_PC_REG (proc_desc
);
415 /* Note that RA is always saved first, regardless of its actual
417 if (mask
& (1 << returnreg
))
419 get_frame_saved_regs (frame
)[returnreg
] = reg_position
;
421 mask
&= ~(1 << returnreg
); /* Clear bit for RA so we
422 don't save again later. */
425 for (ireg
= 0; ireg
<= 31; ++ireg
)
426 if (mask
& (1 << ireg
))
428 get_frame_saved_regs (frame
)[ireg
] = reg_position
;
432 /* Fill in the offsets for the registers which float_mask says
435 reg_position
= get_frame_base (frame
) + PROC_FREG_OFFSET (proc_desc
);
436 mask
= PROC_FREG_MASK (proc_desc
);
438 for (ireg
= 0; ireg
<= 31; ++ireg
)
439 if (mask
& (1 << ireg
))
441 get_frame_saved_regs (frame
)[FP0_REGNUM
+ ireg
] = reg_position
;
445 get_frame_saved_regs (frame
)[PC_REGNUM
] = get_frame_saved_regs (frame
)[returnreg
];
449 alpha_frame_init_saved_regs (struct frame_info
*fi
)
451 if (get_frame_saved_regs (fi
) == NULL
)
452 alpha_find_saved_regs (fi
);
453 get_frame_saved_regs (fi
)[SP_REGNUM
] = get_frame_base (fi
);
457 alpha_init_frame_pc_first (int fromleaf
, struct frame_info
*prev
)
459 return (fromleaf
? SAVED_PC_AFTER_CALL (get_next_frame (prev
))
460 : get_next_frame (prev
) ? DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev
))
465 read_next_frame_reg (struct frame_info
*fi
, int regno
)
467 for (; fi
; fi
= get_next_frame (fi
))
469 /* We have to get the saved sp from the sigcontext
470 if it is a signal handler frame. */
471 if (regno
== SP_REGNUM
&& !(get_frame_type (fi
) == SIGTRAMP_FRAME
))
472 return get_frame_base (fi
);
475 if (get_frame_saved_regs (fi
) == NULL
)
476 alpha_find_saved_regs (fi
);
477 if (get_frame_saved_regs (fi
)[regno
])
478 return read_memory_integer (get_frame_saved_regs (fi
)[regno
], 8);
481 return read_register (regno
);
485 alpha_frame_saved_pc (struct frame_info
*frame
)
487 alpha_extra_func_info_t proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
488 /* We have to get the saved pc from the sigcontext
489 if it is a signal handler frame. */
490 int pcreg
= ((get_frame_type (frame
) == SIGTRAMP_FRAME
)
492 : get_frame_extra_info (frame
)->pc_reg
);
494 if (proc_desc
&& PROC_DESC_IS_DUMMY (proc_desc
))
495 return read_memory_integer (get_frame_base (frame
) - 8, 8);
497 return read_next_frame_reg (frame
, pcreg
);
501 alpha_saved_pc_after_call (struct frame_info
*frame
)
503 CORE_ADDR pc
= get_frame_pc (frame
);
505 alpha_extra_func_info_t proc_desc
;
508 /* Skip over shared library trampoline if necessary. */
509 tmp
= SKIP_TRAMPOLINE_CODE (pc
);
513 proc_desc
= find_proc_desc (pc
, get_next_frame (frame
));
514 pcreg
= proc_desc
? PROC_PC_REG (proc_desc
) : ALPHA_RA_REGNUM
;
516 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
517 return alpha_frame_saved_pc (frame
);
519 return read_register (pcreg
);
523 static struct alpha_extra_func_info temp_proc_desc
;
524 static CORE_ADDR temp_saved_regs
[ALPHA_NUM_REGS
];
526 /* Nonzero if instruction at PC is a return instruction. "ret
527 $zero,($ra),1" on alpha. */
530 alpha_about_to_return (CORE_ADDR pc
)
532 return read_memory_integer (pc
, 4) == 0x6bfa8001;
537 /* This fencepost looks highly suspicious to me. Removing it also
538 seems suspicious as it could affect remote debugging across serial
542 heuristic_proc_start (CORE_ADDR pc
)
544 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
545 CORE_ADDR start_pc
= pc
;
546 CORE_ADDR fence
= start_pc
- heuristic_fence_post
;
551 if (heuristic_fence_post
== UINT_MAX
552 || fence
< tdep
->vm_min_address
)
553 fence
= tdep
->vm_min_address
;
555 /* search back for previous return */
556 for (start_pc
-= 4;; start_pc
-= 4)
557 if (start_pc
< fence
)
559 /* It's not clear to me why we reach this point when
560 stop_soon_quietly, but with this test, at least we
561 don't print out warnings for every child forked (eg, on
562 decstation). 22apr93 rich@cygnus.com. */
563 if (!stop_soon_quietly
)
565 static int blurb_printed
= 0;
567 if (fence
== tdep
->vm_min_address
)
568 warning ("Hit beginning of text section without finding");
570 warning ("Hit heuristic-fence-post without finding");
572 warning ("enclosing function for address 0x%s", paddr_nz (pc
));
576 This warning occurs if you are debugging a function without any symbols\n\
577 (for example, in a stripped executable). In that case, you may wish to\n\
578 increase the size of the search with the `set heuristic-fence-post' command.\n\
580 Otherwise, you told GDB there was a function where there isn't one, or\n\
581 (more likely) you have encountered a bug in GDB.\n");
588 else if (alpha_about_to_return (start_pc
))
591 start_pc
+= 4; /* skip return */
595 static alpha_extra_func_info_t
596 heuristic_proc_desc (CORE_ADDR start_pc
, CORE_ADDR limit_pc
,
597 struct frame_info
*next_frame
)
599 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
603 int has_frame_reg
= 0;
604 unsigned long reg_mask
= 0;
610 memset (&temp_proc_desc
, '\0', sizeof (temp_proc_desc
));
611 memset (&temp_saved_regs
, '\0', SIZEOF_FRAME_SAVED_REGS
);
612 PROC_LOW_ADDR (&temp_proc_desc
) = start_pc
;
614 if (start_pc
+ 200 < limit_pc
)
615 limit_pc
= start_pc
+ 200;
617 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
623 status
= read_memory_nobpt (cur_pc
, buf
, 4);
625 memory_error (status
, cur_pc
);
626 word
= extract_unsigned_integer (buf
, 4);
628 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
632 /* Consider only the first stack allocation instruction
633 to contain the static size of the frame. */
635 frame_size
+= (-word
) & 0xffff;
638 /* Exit loop if a positive stack adjustment is found, which
639 usually means that the stack cleanup code in the function
640 epilogue is reached. */
643 else if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
644 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
646 int reg
= (word
& 0x03e00000) >> 21;
647 reg_mask
|= 1 << reg
;
649 /* Do not compute the address where the register was saved yet,
650 because we don't know yet if the offset will need to be
651 relative to $sp or $fp (we can not compute the address relative
652 to $sp if $sp is updated during the execution of the current
653 subroutine, for instance when doing some alloca). So just store
654 the offset for the moment, and compute the address later
655 when we know whether this frame has a frame pointer or not.
657 temp_saved_regs
[reg
] = (short) word
;
659 /* Starting with OSF/1-3.2C, the system libraries are shipped
660 without local symbols, but they still contain procedure
661 descriptors without a symbol reference. GDB is currently
662 unable to find these procedure descriptors and uses
663 heuristic_proc_desc instead.
664 As some low level compiler support routines (__div*, __add*)
665 use a non-standard return address register, we have to
666 add some heuristics to determine the return address register,
667 or stepping over these routines will fail.
668 Usually the return address register is the first register
669 saved on the stack, but assembler optimization might
670 rearrange the register saves.
671 So we recognize only a few registers (t7, t9, ra) within
672 the procedure prologue as valid return address registers.
673 If we encounter a return instruction, we extract the
674 the return address register from it.
676 FIXME: Rewriting GDB to access the procedure descriptors,
677 e.g. via the minimal symbol table, might obviate this hack. */
679 && cur_pc
< (start_pc
+ 80)
680 && (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
681 || reg
== ALPHA_RA_REGNUM
))
684 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
685 pcreg
= (word
>> 16) & 0x1f;
686 else if (word
== 0x47de040f || word
== 0x47fe040f) /* bis sp,sp fp */
688 /* ??? I am not sure what instruction is 0x47fe040f, and I
689 am suspecting that there was a typo and should have been
690 0x47fe040f. I'm keeping it in the test above until further
693 vfp
= read_next_frame_reg (next_frame
, ALPHA_GCC_FP_REGNUM
);
698 /* If we haven't found a valid return address register yet,
699 keep searching in the procedure prologue. */
700 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
705 if (read_memory_nobpt (cur_pc
, buf
, 4))
708 word
= extract_unsigned_integer (buf
, 4);
710 if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
711 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
713 int reg
= (word
& 0x03e00000) >> 21;
714 if (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
715 || reg
== ALPHA_RA_REGNUM
)
721 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
723 pcreg
= (word
>> 16) & 0x1f;
730 PROC_FRAME_REG (&temp_proc_desc
) = ALPHA_GCC_FP_REGNUM
;
732 PROC_FRAME_REG (&temp_proc_desc
) = SP_REGNUM
;
734 /* At this point, we know which of the Stack Pointer or the Frame Pointer
735 to use as the reference address to compute the saved registers address.
736 But in both cases, the processing above has set vfp to this reference
737 address, so just need to increment the offset of each saved register
739 for (regno
= 0; regno
< NUM_REGS
; regno
++)
741 if (reg_mask
& 1 << regno
)
742 temp_saved_regs
[regno
] += vfp
;
745 PROC_FRAME_OFFSET (&temp_proc_desc
) = frame_size
;
746 PROC_REG_MASK (&temp_proc_desc
) = reg_mask
;
747 PROC_PC_REG (&temp_proc_desc
) = (pcreg
== -1) ? ALPHA_RA_REGNUM
: pcreg
;
748 PROC_LOCALOFF (&temp_proc_desc
) = 0; /* XXX - bogus */
749 return &temp_proc_desc
;
752 /* This returns the PC of the first inst after the prologue. If we can't
753 find the prologue, then return 0. */
756 after_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
758 struct symtab_and_line sal
;
759 CORE_ADDR func_addr
, func_end
;
762 proc_desc
= find_proc_desc (pc
, NULL
);
766 if (alpha_proc_desc_is_dyn_sigtramp (proc_desc
))
767 return PROC_LOW_ADDR (proc_desc
); /* "prologue" is in kernel */
769 /* If function is frameless, then we need to do it the hard way. I
770 strongly suspect that frameless always means prologueless... */
771 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
772 && PROC_FRAME_OFFSET (proc_desc
) == 0)
776 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
777 return 0; /* Unknown */
779 sal
= find_pc_line (func_addr
, 0);
781 if (sal
.end
< func_end
)
784 /* The line after the prologue is after the end of the function. In this
785 case, tell the caller to find the prologue the hard way. */
790 /* Return non-zero if we *might* be in a function prologue. Return zero if we
791 are definitively *not* in a function prologue. */
794 alpha_in_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
796 CORE_ADDR after_prologue_pc
;
798 after_prologue_pc
= after_prologue (pc
, proc_desc
);
800 if (after_prologue_pc
== 0
801 || pc
< after_prologue_pc
)
807 static alpha_extra_func_info_t
808 find_proc_desc (CORE_ADDR pc
, struct frame_info
*next_frame
)
810 alpha_extra_func_info_t proc_desc
;
815 /* Try to get the proc_desc from the linked call dummy proc_descs
816 if the pc is in the call dummy.
817 This is hairy. In the case of nested dummy calls we have to find the
818 right proc_desc, but we might not yet know the frame for the dummy
819 as it will be contained in the proc_desc we are searching for.
820 So we have to find the proc_desc whose frame is closest to the current
823 if (DEPRECATED_PC_IN_CALL_DUMMY (pc
, 0, 0))
825 struct linked_proc_info
*link
;
826 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
827 alpha_extra_func_info_t found_proc_desc
= NULL
;
828 long min_distance
= LONG_MAX
;
830 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
832 long distance
= (CORE_ADDR
) PROC_DUMMY_FRAME (&link
->info
) - sp
;
833 if (distance
> 0 && distance
< min_distance
)
835 min_distance
= distance
;
836 found_proc_desc
= &link
->info
;
839 if (found_proc_desc
!= NULL
)
840 return found_proc_desc
;
843 b
= block_for_pc (pc
);
845 find_pc_partial_function (pc
, NULL
, &startaddr
, NULL
);
850 if (startaddr
> BLOCK_START (b
))
851 /* This is the "pathological" case referred to in a comment in
852 print_frame_info. It might be better to move this check into
856 sym
= lookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
,
860 /* If we never found a PDR for this function in symbol reading, then
861 examine prologues to find the information. */
862 if (sym
&& ((mips_extra_func_info_t
) SYMBOL_VALUE (sym
))->pdr
.framereg
== -1)
867 /* IF this is the topmost frame AND
868 * (this proc does not have debugging information OR
869 * the PC is in the procedure prologue)
870 * THEN create a "heuristic" proc_desc (by analyzing
871 * the actual code) to replace the "official" proc_desc.
873 proc_desc
= (alpha_extra_func_info_t
) SYMBOL_VALUE (sym
);
874 if (next_frame
== NULL
)
876 if (PROC_DESC_IS_DUMMY (proc_desc
) || alpha_in_prologue (pc
, proc_desc
))
878 alpha_extra_func_info_t found_heuristic
=
879 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc
),
883 PROC_LOCALOFF (found_heuristic
) =
884 PROC_LOCALOFF (proc_desc
);
885 PROC_PC_REG (found_heuristic
) = PROC_PC_REG (proc_desc
);
886 proc_desc
= found_heuristic
;
895 /* Is linked_proc_desc_table really necessary? It only seems to be used
896 by procedure call dummys. However, the procedures being called ought
897 to have their own proc_descs, and even if they don't,
898 heuristic_proc_desc knows how to create them! */
900 register struct linked_proc_info
*link
;
901 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
902 if (PROC_LOW_ADDR (&link
->info
) <= pc
903 && PROC_HIGH_ADDR (&link
->info
) > pc
)
906 /* If PC is inside a dynamically generated sigtramp handler,
907 create and push a procedure descriptor for that code: */
908 offset
= alpha_dynamic_sigtramp_offset (pc
);
910 return push_sigtramp_desc (pc
- offset
);
912 /* If heuristic_fence_post is non-zero, determine the procedure
913 start address by examining the instructions.
914 This allows us to find the start address of static functions which
915 have no symbolic information, as startaddr would have been set to
916 the preceding global function start address by the
917 find_pc_partial_function call above. */
918 if (startaddr
== 0 || heuristic_fence_post
!= 0)
919 startaddr
= heuristic_proc_start (pc
);
922 heuristic_proc_desc (startaddr
, pc
, next_frame
);
927 alpha_extra_func_info_t cached_proc_desc
;
930 alpha_frame_chain (struct frame_info
*frame
)
932 alpha_extra_func_info_t proc_desc
;
933 CORE_ADDR saved_pc
= DEPRECATED_FRAME_SAVED_PC (frame
);
935 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
938 proc_desc
= find_proc_desc (saved_pc
, frame
);
942 cached_proc_desc
= proc_desc
;
944 /* Fetch the frame pointer for a dummy frame from the procedure
946 if (PROC_DESC_IS_DUMMY (proc_desc
))
947 return (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
949 /* If no frame pointer and frame size is zero, we must be at end
950 of stack (or otherwise hosed). If we don't check frame size,
951 we loop forever if we see a zero size frame. */
952 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
953 && PROC_FRAME_OFFSET (proc_desc
) == 0
954 /* The previous frame from a sigtramp frame might be frameless
955 and have frame size zero. */
956 && !(get_frame_type (frame
) == SIGTRAMP_FRAME
))
957 return alpha_frame_past_sigtramp_frame (frame
, saved_pc
);
959 return read_next_frame_reg (frame
, PROC_FRAME_REG (proc_desc
))
960 + PROC_FRAME_OFFSET (proc_desc
);
964 alpha_print_extra_frame_info (struct frame_info
*fi
)
967 && get_frame_extra_info (fi
)
968 && get_frame_extra_info (fi
)->proc_desc
969 && get_frame_extra_info (fi
)->proc_desc
->pdr
.framereg
< NUM_REGS
)
970 printf_filtered (" frame pointer is at %s+%s\n",
971 REGISTER_NAME (get_frame_extra_info (fi
)->proc_desc
->pdr
.framereg
),
972 paddr_d (get_frame_extra_info (fi
)->proc_desc
->pdr
.frameoffset
));
976 alpha_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
978 /* Use proc_desc calculated in frame_chain */
979 alpha_extra_func_info_t proc_desc
=
980 get_next_frame (frame
)
982 : find_proc_desc (get_frame_pc (frame
), get_next_frame (frame
));
984 frame_extra_info_zalloc (frame
, sizeof (struct frame_extra_info
));
986 /* NOTE: cagney/2003-01-03: No need to set saved_regs to NULL,
987 always NULL by default. */
988 /* frame->saved_regs = NULL; */
989 get_frame_extra_info (frame
)->localoff
= 0;
990 get_frame_extra_info (frame
)->pc_reg
= ALPHA_RA_REGNUM
;
991 get_frame_extra_info (frame
)->proc_desc
= proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
994 /* Get the locals offset and the saved pc register from the
995 procedure descriptor, they are valid even if we are in the
996 middle of the prologue. */
997 get_frame_extra_info (frame
)->localoff
= PROC_LOCALOFF (proc_desc
);
998 get_frame_extra_info (frame
)->pc_reg
= PROC_PC_REG (proc_desc
);
1000 /* Fixup frame-pointer - only needed for top frame */
1002 /* Fetch the frame pointer for a dummy frame from the procedure
1004 if (PROC_DESC_IS_DUMMY (proc_desc
))
1005 deprecated_update_frame_base_hack (frame
, (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
));
1007 /* This may not be quite right, if proc has a real frame register.
1008 Get the value of the frame relative sp, procedure might have been
1009 interrupted by a signal at it's very start. */
1010 else if (get_frame_pc (frame
) == PROC_LOW_ADDR (proc_desc
)
1011 && !alpha_proc_desc_is_dyn_sigtramp (proc_desc
))
1012 deprecated_update_frame_base_hack (frame
, read_next_frame_reg (get_next_frame (frame
), SP_REGNUM
));
1014 deprecated_update_frame_base_hack (frame
, read_next_frame_reg (get_next_frame (frame
), PROC_FRAME_REG (proc_desc
))
1015 + PROC_FRAME_OFFSET (proc_desc
));
1017 if (proc_desc
== &temp_proc_desc
)
1021 /* Do not set the saved registers for a sigtramp frame,
1022 alpha_find_saved_registers will do that for us. We can't
1023 use (get_frame_type (frame) == SIGTRAMP_FRAME), it is not
1025 /* FIXME: cagney/2002-11-18: This problem will go away once
1026 frame.c:get_prev_frame() is modified to set the frame's
1027 type before calling functions like this. */
1028 find_pc_partial_function (get_frame_pc (frame
), &name
,
1029 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
1030 if (!PC_IN_SIGTRAMP (get_frame_pc (frame
), name
))
1032 frame_saved_regs_zalloc (frame
);
1033 memcpy (get_frame_saved_regs (frame
), temp_saved_regs
,
1034 SIZEOF_FRAME_SAVED_REGS
);
1035 get_frame_saved_regs (frame
)[PC_REGNUM
]
1036 = get_frame_saved_regs (frame
)[ALPHA_RA_REGNUM
];
1043 alpha_frame_locals_address (struct frame_info
*fi
)
1045 return (get_frame_base (fi
) - get_frame_extra_info (fi
)->localoff
);
1049 alpha_frame_args_address (struct frame_info
*fi
)
1051 return (get_frame_base (fi
) - (ALPHA_NUM_ARG_REGS
* 8));
1054 /* ALPHA stack frames are almost impenetrable. When execution stops,
1055 we basically have to look at symbol information for the function
1056 that we stopped in, which tells us *which* register (if any) is
1057 the base of the frame pointer, and what offset from that register
1058 the frame itself is at.
1060 This presents a problem when trying to examine a stack in memory
1061 (that isn't executing at the moment), using the "frame" command. We
1062 don't have a PC, nor do we have any registers except SP.
1064 This routine takes two arguments, SP and PC, and tries to make the
1065 cached frames look as if these two arguments defined a frame on the
1066 cache. This allows the rest of info frame to extract the important
1067 arguments without difficulty. */
1070 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1073 error ("ALPHA frame specifications require two arguments: sp and pc");
1075 return create_new_frame (argv
[0], argv
[1]);
1078 /* The alpha passes the first six arguments in the registers, the rest on
1079 the stack. The register arguments are eventually transferred to the
1080 argument transfer area immediately below the stack by the called function
1081 anyway. So we `push' at least six arguments on the stack, `reload' the
1082 argument registers and then adjust the stack pointer to point past the
1083 sixth argument. This algorithm simplifies the passing of a large struct
1084 which extends from the registers to the stack.
1085 If the called function is returning a structure, the address of the
1086 structure to be returned is passed as a hidden first argument. */
1089 alpha_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1090 int struct_return
, CORE_ADDR struct_addr
)
1093 int accumulate_size
= struct_return
? 8 : 0;
1094 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
1101 struct alpha_arg
*alpha_args
=
1102 (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
1103 register struct alpha_arg
*m_arg
;
1104 char raw_buffer
[sizeof (CORE_ADDR
)];
1105 int required_arg_regs
;
1107 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
1109 struct value
*arg
= args
[i
];
1110 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1111 /* Cast argument to long if necessary as the compiler does it too. */
1112 switch (TYPE_CODE (arg_type
))
1115 case TYPE_CODE_BOOL
:
1116 case TYPE_CODE_CHAR
:
1117 case TYPE_CODE_RANGE
:
1118 case TYPE_CODE_ENUM
:
1119 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
1121 arg_type
= builtin_type_long
;
1122 arg
= value_cast (arg_type
, arg
);
1128 m_arg
->len
= TYPE_LENGTH (arg_type
);
1129 m_arg
->offset
= accumulate_size
;
1130 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
1131 m_arg
->contents
= VALUE_CONTENTS (arg
);
1134 /* Determine required argument register loads, loading an argument register
1135 is expensive as it uses three ptrace calls. */
1136 required_arg_regs
= accumulate_size
/ 8;
1137 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
1138 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
1140 /* Make room for the arguments on the stack. */
1141 if (accumulate_size
< arg_regs_size
)
1142 accumulate_size
= arg_regs_size
;
1143 sp
-= accumulate_size
;
1145 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
1148 /* `Push' arguments on the stack. */
1149 for (i
= nargs
; m_arg
--, --i
>= 0;)
1150 write_memory (sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
1153 store_address (raw_buffer
, sizeof (CORE_ADDR
), struct_addr
);
1154 write_memory (sp
, raw_buffer
, sizeof (CORE_ADDR
));
1157 /* Load the argument registers. */
1158 for (i
= 0; i
< required_arg_regs
; i
++)
1162 val
= read_memory_integer (sp
+ i
* 8, 8);
1163 write_register (ALPHA_A0_REGNUM
+ i
, val
);
1164 write_register (ALPHA_FPA0_REGNUM
+ i
, val
);
1167 return sp
+ arg_regs_size
;
1171 alpha_push_dummy_frame (void)
1174 struct linked_proc_info
*link
;
1175 alpha_extra_func_info_t proc_desc
;
1176 CORE_ADDR sp
= read_register (SP_REGNUM
);
1177 CORE_ADDR save_address
;
1178 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1181 link
= (struct linked_proc_info
*) xmalloc (sizeof (struct linked_proc_info
));
1182 link
->next
= linked_proc_desc_table
;
1183 linked_proc_desc_table
= link
;
1185 proc_desc
= &link
->info
;
1188 * The registers we must save are all those not preserved across
1190 * In addition, we must save the PC and RA.
1192 * Dummy frame layout:
1202 * Parameter build area
1206 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
1207 #define MASK(i,j) ((((LONGEST)1 << ((j)+1)) - 1) ^ (((LONGEST)1 << (i)) - 1))
1208 #define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
1209 #define GEN_REG_SAVE_COUNT 24
1210 #define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
1211 #define FLOAT_REG_SAVE_COUNT 23
1212 /* The special register is the PC as we have no bit for it in the save masks.
1213 alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
1214 #define SPECIAL_REG_SAVE_COUNT 1
1216 PROC_REG_MASK (proc_desc
) = GEN_REG_SAVE_MASK
;
1217 PROC_FREG_MASK (proc_desc
) = FLOAT_REG_SAVE_MASK
;
1218 /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
1219 but keep SP aligned to a multiple of 16. */
1220 PROC_REG_OFFSET (proc_desc
) =
1221 -((8 * (SPECIAL_REG_SAVE_COUNT
1222 + GEN_REG_SAVE_COUNT
1223 + FLOAT_REG_SAVE_COUNT
)
1225 PROC_FREG_OFFSET (proc_desc
) =
1226 PROC_REG_OFFSET (proc_desc
) + 8 * GEN_REG_SAVE_COUNT
;
1228 /* Save general registers.
1229 The return address register is the first saved register, all other
1230 registers follow in ascending order.
1231 The PC is saved immediately below the SP. */
1232 save_address
= sp
+ PROC_REG_OFFSET (proc_desc
);
1233 store_address (raw_buffer
, 8, read_register (ALPHA_RA_REGNUM
));
1234 write_memory (save_address
, raw_buffer
, 8);
1236 mask
= PROC_REG_MASK (proc_desc
) & 0xffffffffL
;
1237 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1240 if (ireg
== ALPHA_RA_REGNUM
)
1242 store_address (raw_buffer
, 8, read_register (ireg
));
1243 write_memory (save_address
, raw_buffer
, 8);
1247 store_address (raw_buffer
, 8, read_register (PC_REGNUM
));
1248 write_memory (sp
- 8, raw_buffer
, 8);
1250 /* Save floating point registers. */
1251 save_address
= sp
+ PROC_FREG_OFFSET (proc_desc
);
1252 mask
= PROC_FREG_MASK (proc_desc
) & 0xffffffffL
;
1253 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1256 store_address (raw_buffer
, 8, read_register (ireg
+ FP0_REGNUM
));
1257 write_memory (save_address
, raw_buffer
, 8);
1261 /* Set and save the frame address for the dummy.
1262 This is tricky. The only registers that are suitable for a frame save
1263 are those that are preserved across procedure calls (s0-s6). But if
1264 a read system call is interrupted and then a dummy call is made
1265 (see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
1266 is satisfied. Then it returns with the s0-s6 registers set to the values
1267 on entry to the read system call and our dummy frame pointer would be
1268 destroyed. So we save the dummy frame in the proc_desc and handle the
1269 retrieval of the frame pointer of a dummy specifically. The frame register
1270 is set to the virtual frame (pseudo) register, it's value will always
1271 be read as zero and will help us to catch any errors in the dummy frame
1273 PROC_DUMMY_FRAME (proc_desc
) = sp
;
1274 PROC_FRAME_REG (proc_desc
) = FP_REGNUM
;
1275 PROC_FRAME_OFFSET (proc_desc
) = 0;
1276 sp
+= PROC_REG_OFFSET (proc_desc
);
1277 write_register (SP_REGNUM
, sp
);
1279 PROC_LOW_ADDR (proc_desc
) = CALL_DUMMY_ADDRESS ();
1280 PROC_HIGH_ADDR (proc_desc
) = PROC_LOW_ADDR (proc_desc
) + 4;
1282 SET_PROC_DESC_IS_DUMMY (proc_desc
);
1283 PROC_PC_REG (proc_desc
) = ALPHA_RA_REGNUM
;
1287 alpha_pop_frame (void)
1289 register int regnum
;
1290 struct frame_info
*frame
= get_current_frame ();
1291 CORE_ADDR new_sp
= get_frame_base (frame
);
1293 alpha_extra_func_info_t proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
1295 /* we need proc_desc to know how to restore the registers;
1296 if it is NULL, construct (a temporary) one */
1297 if (proc_desc
== NULL
)
1298 proc_desc
= find_proc_desc (get_frame_pc (frame
), get_next_frame (frame
));
1300 /* Question: should we copy this proc_desc and save it in
1301 frame->proc_desc? If we do, who will free it?
1302 For now, we don't save a copy... */
1304 write_register (PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (frame
));
1305 if (get_frame_saved_regs (frame
) == NULL
)
1306 alpha_find_saved_regs (frame
);
1309 for (regnum
= 32; --regnum
>= 0;)
1310 if (PROC_REG_MASK (proc_desc
) & (1 << regnum
))
1311 write_register (regnum
,
1312 read_memory_integer (get_frame_saved_regs (frame
)[regnum
],
1314 for (regnum
= 32; --regnum
>= 0;)
1315 if (PROC_FREG_MASK (proc_desc
) & (1 << regnum
))
1316 write_register (regnum
+ FP0_REGNUM
,
1317 read_memory_integer (get_frame_saved_regs (frame
)[regnum
+ FP0_REGNUM
], 8));
1319 write_register (SP_REGNUM
, new_sp
);
1320 flush_cached_frames ();
1322 if (proc_desc
&& (PROC_DESC_IS_DUMMY (proc_desc
)
1323 || alpha_proc_desc_is_dyn_sigtramp (proc_desc
)))
1325 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
1327 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
1329 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
1331 if (&pi_ptr
->info
== proc_desc
)
1336 error ("Can't locate dummy extra frame info\n");
1338 if (prev_ptr
!= NULL
)
1339 prev_ptr
->next
= pi_ptr
->next
;
1341 linked_proc_desc_table
= pi_ptr
->next
;
1347 /* To skip prologues, I use this predicate. Returns either PC itself
1348 if the code at PC does not look like a function prologue; otherwise
1349 returns an address that (if we're lucky) follows the prologue. If
1350 LENIENT, then we must skip everything which is involved in setting
1351 up the frame (it's OK to skip more, just so long as we don't skip
1352 anything which might clobber the registers which are being saved.
1353 Currently we must not skip more on the alpha, but we might need the
1354 lenient stuff some day. */
1357 alpha_skip_prologue_internal (CORE_ADDR pc
, int lenient
)
1361 CORE_ADDR post_prologue_pc
;
1364 /* Silently return the unaltered pc upon memory errors.
1365 This could happen on OSF/1 if decode_line_1 tries to skip the
1366 prologue for quickstarted shared library functions when the
1367 shared library is not yet mapped in.
1368 Reading target memory is slow over serial lines, so we perform
1369 this check only if the target has shared libraries (which all
1370 Alpha targets do). */
1371 if (target_read_memory (pc
, buf
, 4))
1374 /* See if we can determine the end of the prologue via the symbol table.
1375 If so, then return either PC, or the PC after the prologue, whichever
1378 post_prologue_pc
= after_prologue (pc
, NULL
);
1380 if (post_prologue_pc
!= 0)
1381 return max (pc
, post_prologue_pc
);
1383 /* Can't determine prologue from the symbol table, need to examine
1386 /* Skip the typical prologue instructions. These are the stack adjustment
1387 instruction and the instructions that save registers on the stack
1388 or in the gcc frame. */
1389 for (offset
= 0; offset
< 100; offset
+= 4)
1393 status
= read_memory_nobpt (pc
+ offset
, buf
, 4);
1395 memory_error (status
, pc
+ offset
);
1396 inst
= extract_unsigned_integer (buf
, 4);
1398 /* The alpha has no delay slots. But let's keep the lenient stuff,
1399 we might need it for something else in the future. */
1403 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
1405 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
1407 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1409 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
1412 if ((inst
& 0xfc1f0000) == 0xb41e0000
1413 && (inst
& 0xffff0000) != 0xb7fe0000)
1414 continue; /* stq reg,n($sp) */
1416 if ((inst
& 0xfc1f0000) == 0x9c1e0000
1417 && (inst
& 0xffff0000) != 0x9ffe0000)
1418 continue; /* stt reg,n($sp) */
1420 if (inst
== 0x47de040f) /* bis sp,sp,fp */
1429 alpha_skip_prologue (CORE_ADDR addr
)
1431 return (alpha_skip_prologue_internal (addr
, 0));
1435 /* Is address PC in the prologue (loosely defined) for function at
1439 alpha_in_lenient_prologue (CORE_ADDR startaddr
, CORE_ADDR pc
)
1441 CORE_ADDR end_prologue
= alpha_skip_prologue_internal (startaddr
, 1);
1442 return pc
>= startaddr
&& pc
< end_prologue
;
1446 /* The alpha needs a conversion between register and memory format if
1447 the register is a floating point register and
1448 memory format is float, as the register format must be double
1450 memory format is an integer with 4 bytes or less, as the representation
1451 of integers in floating point registers is different. */
1453 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
1454 char *raw_buffer
, char *virtual_buffer
)
1456 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1458 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
1462 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1464 double d
= extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1465 store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
1467 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1470 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1471 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
1472 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
1475 error ("Cannot retrieve value from floating point register");
1479 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
1480 char *virtual_buffer
, char *raw_buffer
)
1482 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1484 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
1488 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1490 double d
= extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
1491 store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
1493 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1496 if (TYPE_UNSIGNED (valtype
))
1497 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1499 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1500 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
1501 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
1504 error ("Cannot store value in floating point register");
1507 static const unsigned char *
1508 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1510 static const unsigned char alpha_breakpoint
[] =
1511 { 0x80, 0, 0, 0 }; /* call_pal bpt */
1513 *lenptr
= sizeof(alpha_breakpoint
);
1514 return (alpha_breakpoint
);
1517 /* Given a return value in `regbuf' with a type `valtype',
1518 extract and copy its value into `valbuf'. */
1521 alpha_extract_return_value (struct type
*valtype
,
1522 char regbuf
[ALPHA_REGISTER_BYTES
], char *valbuf
)
1524 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1525 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
1526 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
1529 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1530 TYPE_LENGTH (valtype
));
1533 /* Given a return value in `regbuf' with a type `valtype',
1534 write its value into the appropriate register. */
1537 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
1539 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1540 int regnum
= ALPHA_V0_REGNUM
;
1541 int length
= TYPE_LENGTH (valtype
);
1543 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1545 regnum
= FP0_REGNUM
;
1546 length
= REGISTER_RAW_SIZE (regnum
);
1547 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
1550 memcpy (raw_buffer
, valbuf
, length
);
1552 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
1555 /* Just like reinit_frame_cache, but with the right arguments to be
1556 callable as an sfunc. */
1559 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1561 reinit_frame_cache ();
1564 /* This is the definition of CALL_DUMMY_ADDRESS. It's a heuristic that is used
1565 to find a convenient place in the text segment to stick a breakpoint to
1566 detect the completion of a target function call (ala call_function_by_hand).
1570 alpha_call_dummy_address (void)
1573 struct minimal_symbol
*sym
;
1575 entry
= entry_point_address ();
1580 sym
= lookup_minimal_symbol ("_Prelude", NULL
, symfile_objfile
);
1582 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1585 return SYMBOL_VALUE_ADDRESS (sym
) + 4;
1589 alpha_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
1590 struct value
**args
, struct type
*type
, int gcc_p
)
1592 CORE_ADDR bp_address
= CALL_DUMMY_ADDRESS ();
1594 if (bp_address
== 0)
1595 error ("no place to put call");
1596 write_register (ALPHA_RA_REGNUM
, bp_address
);
1597 write_register (ALPHA_T12_REGNUM
, fun
);
1600 /* On the Alpha, the call dummy code is nevery copied to user space
1601 (see alpha_fix_call_dummy() above). The contents of this do not
1603 LONGEST alpha_call_dummy_words
[] = { 0 };
1606 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
1608 /* Structures are returned by ref in extra arg0. */
1613 alpha_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1615 /* Store the address of the place in which to copy the structure the
1616 subroutine will return. Handled by alpha_push_arguments. */
1620 alpha_extract_struct_value_address (char *regbuf
)
1622 return (extract_address (regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1623 REGISTER_RAW_SIZE (ALPHA_V0_REGNUM
)));
1626 /* Figure out where the longjmp will land.
1627 We expect the first arg to be a pointer to the jmp_buf structure from
1628 which we extract the PC (JB_PC) that we will land at. The PC is copied
1629 into the "pc". This routine returns true on success. */
1632 alpha_get_longjmp_target (CORE_ADDR
*pc
)
1634 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1636 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1638 jb_addr
= read_register (ALPHA_A0_REGNUM
);
1640 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
1641 raw_buffer
, tdep
->jb_elt_size
))
1644 *pc
= extract_address (raw_buffer
, tdep
->jb_elt_size
);
1648 /* alpha_software_single_step() is called just before we want to resume
1649 the inferior, if we want to single-step it but there is no hardware
1650 or kernel single-step support (NetBSD on Alpha, for example). We find
1651 the target of the coming instruction and breakpoint it.
1653 single_step is also called just after the inferior stops. If we had
1654 set up a simulated single-step, we undo our damage. */
1657 alpha_next_pc (CORE_ADDR pc
)
1664 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1666 /* Opcode is top 6 bits. */
1667 op
= (insn
>> 26) & 0x3f;
1671 /* Jump format: target PC is:
1673 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1676 if ((op
& 0x30) == 0x30)
1678 /* Branch format: target PC is:
1679 (new PC) + (4 * sext(displacement)) */
1680 if (op
== 0x30 || /* BR */
1681 op
== 0x34) /* BSR */
1684 offset
= (insn
& 0x001fffff);
1685 if (offset
& 0x00100000)
1686 offset
|= 0xffe00000;
1688 return (pc
+ 4 + offset
);
1691 /* Need to determine if branch is taken; read RA. */
1692 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1695 case 0x38: /* BLBC */
1699 case 0x3c: /* BLBS */
1703 case 0x39: /* BEQ */
1707 case 0x3d: /* BNE */
1711 case 0x3a: /* BLT */
1715 case 0x3b: /* BLE */
1719 case 0x3f: /* BGT */
1723 case 0x3e: /* BGE */
1730 /* Not a branch or branch not taken; target PC is:
1736 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1738 static CORE_ADDR next_pc
;
1739 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1740 static binsn_quantum break_mem
;
1743 if (insert_breakpoints_p
)
1746 next_pc
= alpha_next_pc (pc
);
1748 target_insert_breakpoint (next_pc
, break_mem
);
1752 target_remove_breakpoint (next_pc
, break_mem
);
1759 /* Initialize the current architecture based on INFO. If possible, re-use an
1760 architecture from ARCHES, which is a list of architectures already created
1761 during this debugging session.
1763 Called e.g. at program startup, when reading a core file, and when reading
1766 static struct gdbarch
*
1767 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1769 struct gdbarch_tdep
*tdep
;
1770 struct gdbarch
*gdbarch
;
1772 /* Try to determine the ABI of the object we are loading. */
1773 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1775 /* If it's an ECOFF file, assume it's OSF/1. */
1776 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1777 info
.osabi
= GDB_OSABI_OSF1
;
1780 /* Find a candidate among extant architectures. */
1781 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1783 return arches
->gdbarch
;
1785 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1786 gdbarch
= gdbarch_alloc (&info
, tdep
);
1788 /* Lowest text address. This is used by heuristic_proc_start() to
1789 decide when to stop looking. */
1790 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1792 tdep
->dynamic_sigtramp_offset
= NULL
;
1793 tdep
->skip_sigtramp_frame
= NULL
;
1794 tdep
->sigcontext_addr
= NULL
;
1796 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1799 set_gdbarch_short_bit (gdbarch
, 16);
1800 set_gdbarch_int_bit (gdbarch
, 32);
1801 set_gdbarch_long_bit (gdbarch
, 64);
1802 set_gdbarch_long_long_bit (gdbarch
, 64);
1803 set_gdbarch_float_bit (gdbarch
, 32);
1804 set_gdbarch_double_bit (gdbarch
, 64);
1805 set_gdbarch_long_double_bit (gdbarch
, 64);
1806 set_gdbarch_ptr_bit (gdbarch
, 64);
1809 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1810 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1811 set_gdbarch_fp_regnum (gdbarch
, ALPHA_FP_REGNUM
);
1812 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1813 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1815 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1816 set_gdbarch_register_size (gdbarch
, ALPHA_REGISTER_SIZE
);
1817 set_gdbarch_register_bytes (gdbarch
, ALPHA_REGISTER_BYTES
);
1818 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1819 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1820 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, ALPHA_MAX_REGISTER_RAW_SIZE
);
1821 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1822 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
1823 ALPHA_MAX_REGISTER_VIRTUAL_SIZE
);
1824 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1826 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1827 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1829 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1830 set_gdbarch_register_convert_to_virtual (gdbarch
,
1831 alpha_register_convert_to_virtual
);
1832 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1834 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1836 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1837 set_gdbarch_frameless_function_invocation (gdbarch
,
1838 generic_frameless_function_invocation_not
);
1840 set_gdbarch_saved_pc_after_call (gdbarch
, alpha_saved_pc_after_call
);
1842 set_gdbarch_frame_chain (gdbarch
, alpha_frame_chain
);
1843 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, alpha_frame_saved_pc
);
1845 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, alpha_frame_init_saved_regs
);
1847 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1848 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1850 set_gdbarch_store_struct_return (gdbarch
, alpha_store_struct_return
);
1851 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1852 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1853 alpha_extract_struct_value_address
);
1855 /* Settings for calling functions in the inferior. */
1856 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
1857 set_gdbarch_call_dummy_length (gdbarch
, 0);
1858 set_gdbarch_push_arguments (gdbarch
, alpha_push_arguments
);
1859 set_gdbarch_deprecated_pop_frame (gdbarch
, alpha_pop_frame
);
1861 /* On the Alpha, the call dummy code is never copied to user space,
1862 stopping the user call is achieved via a bp_call_dummy breakpoint.
1863 But we need a fake CALL_DUMMY definition to enable the proper
1864 call_function_by_hand and to avoid zero length array warnings. */
1865 set_gdbarch_call_dummy_p (gdbarch
, 1);
1866 set_gdbarch_call_dummy_words (gdbarch
, alpha_call_dummy_words
);
1867 set_gdbarch_sizeof_call_dummy_words (gdbarch
, 0);
1868 set_gdbarch_frame_args_address (gdbarch
, alpha_frame_args_address
);
1869 set_gdbarch_frame_locals_address (gdbarch
, alpha_frame_locals_address
);
1870 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, alpha_init_extra_frame_info
);
1872 /* Alpha OSF/1 inhibits execution of code on the stack. But there is
1873 no need for a dummy on the Alpha. PUSH_ARGUMENTS takes care of all
1874 argument handling and bp_call_dummy takes care of stopping the dummy. */
1875 set_gdbarch_call_dummy_address (gdbarch
, alpha_call_dummy_address
);
1876 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1877 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1878 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1879 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1880 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1881 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, alpha_push_dummy_frame
);
1882 set_gdbarch_fix_call_dummy (gdbarch
, alpha_fix_call_dummy
);
1883 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_noop
);
1884 set_gdbarch_deprecated_init_frame_pc_first (gdbarch
, alpha_init_frame_pc_first
);
1886 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1887 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1889 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1890 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1892 set_gdbarch_function_start_offset (gdbarch
, 0);
1893 set_gdbarch_frame_args_skip (gdbarch
, 0);
1895 /* Hook in ABI-specific overrides, if they have been registered. */
1896 gdbarch_init_osabi (info
, gdbarch
);
1898 /* Now that we have tuned the configuration, set a few final things
1899 based on what the OS ABI has told us. */
1901 if (tdep
->jb_pc
>= 0)
1902 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1908 alpha_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1910 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1915 fprintf_unfiltered (file
,
1916 "alpha_dump_tdep: vm_min_address = 0x%lx\n",
1917 (long) tdep
->vm_min_address
);
1919 fprintf_unfiltered (file
,
1920 "alpha_dump_tdep: jb_pc = %d\n",
1922 fprintf_unfiltered (file
,
1923 "alpha_dump_tdep: jb_elt_size = %ld\n",
1924 (long) tdep
->jb_elt_size
);
1928 _initialize_alpha_tdep (void)
1930 struct cmd_list_element
*c
;
1932 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, alpha_dump_tdep
);
1934 tm_print_insn
= print_insn_alpha
;
1936 /* Let the user set the fence post for heuristic_proc_start. */
1938 /* We really would like to have both "0" and "unlimited" work, but
1939 command.c doesn't deal with that. So make it a var_zinteger
1940 because the user can always use "999999" or some such for unlimited. */
1941 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1942 (char *) &heuristic_fence_post
,
1944 Set the distance searched for the start of a function.\n\
1945 If you are debugging a stripped executable, GDB needs to search through the\n\
1946 program for the start of a function. This command sets the distance of the\n\
1947 search. The only need to set it is when debugging a stripped executable.",
1949 /* We need to throw away the frame cache when we set this, since it
1950 might change our ability to get backtraces. */
1951 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1952 add_show_from_set (c
, &showlist
);