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
;
71 static gdbarch_push_arguments_ftype alpha_push_arguments
;
72 static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy
;
74 static gdbarch_get_longjmp_target_ftype alpha_get_longjmp_target
;
76 struct frame_extra_info
78 alpha_extra_func_info_t proc_desc
;
83 /* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
85 /* Prototypes for local functions. */
87 static void alpha_find_saved_regs (struct frame_info
*);
89 static alpha_extra_func_info_t
push_sigtramp_desc (CORE_ADDR low_addr
);
91 static CORE_ADDR
read_next_frame_reg (struct frame_info
*, int);
93 static CORE_ADDR
heuristic_proc_start (CORE_ADDR
);
95 static alpha_extra_func_info_t
heuristic_proc_desc (CORE_ADDR
,
99 static alpha_extra_func_info_t
find_proc_desc (CORE_ADDR
,
100 struct frame_info
*);
103 static int alpha_in_lenient_prologue (CORE_ADDR
, CORE_ADDR
);
106 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element
*);
108 static CORE_ADDR
after_prologue (CORE_ADDR pc
,
109 alpha_extra_func_info_t proc_desc
);
111 static int alpha_in_prologue (CORE_ADDR pc
,
112 alpha_extra_func_info_t proc_desc
);
114 static int alpha_about_to_return (CORE_ADDR pc
);
116 void _initialize_alpha_tdep (void);
118 /* Heuristic_proc_start may hunt through the text section for a long
119 time across a 2400 baud serial line. Allows the user to limit this
121 static unsigned int heuristic_fence_post
= 0;
123 /* Layout of a stack frame on the alpha:
126 pdr members: | 7th ... nth arg, |
127 | `pushed' by caller. |
129 ----------------|-------------------------------|<-- old_sp == vfp
132 | |localoff | Copies of 1st .. 6th |
133 | | | | | argument if necessary. |
135 | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS
137 | | | | Locals and temporaries. |
139 | | | |-------------------------------|
141 |-fregoffset | Saved float registers. |
147 | | -------|-------------------------------|
149 | | | Saved registers. |
156 | ----------|-------------------------------|
158 frameoffset | Argument build area, gets |
159 | | 7th ... nth arg for any |
160 | | called procedure. |
162 -------------|-------------------------------|<-- sp
167 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
168 /* These next two fields are kind of being hijacked. I wonder if
169 iline is too small for the values it needs to hold, if GDB is
170 running on a 32-bit host. */
171 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
172 #define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset) /*CALL_DUMMY frame */
173 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
174 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
175 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
176 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
177 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
178 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
179 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
180 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
181 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
182 #define _PROC_MAGIC_ 0x0F0F0F0F
183 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
184 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
186 struct linked_proc_info
188 struct alpha_extra_func_info info
;
189 struct linked_proc_info
*next
;
191 *linked_proc_desc_table
= NULL
;
194 alpha_frame_past_sigtramp_frame (struct frame_info
*frame
, CORE_ADDR pc
)
196 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
198 if (tdep
->skip_sigtramp_frame
!= NULL
)
199 return (tdep
->skip_sigtramp_frame (frame
, pc
));
205 alpha_dynamic_sigtramp_offset (CORE_ADDR pc
)
207 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
209 /* Must be provided by OS/ABI variant code if supported. */
210 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
211 return (tdep
->dynamic_sigtramp_offset (pc
));
216 #define ALPHA_PROC_SIGTRAMP_MAGIC 0x0e0f0f0f
218 /* Return TRUE if the procedure descriptor PROC is a procedure
219 descriptor that refers to a dynamically generated signal
220 trampoline routine. */
222 alpha_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info
*proc
)
224 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
226 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
227 return (proc
->pdr
.isym
== ALPHA_PROC_SIGTRAMP_MAGIC
);
233 alpha_set_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info
*proc
)
235 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
237 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
238 proc
->pdr
.isym
= ALPHA_PROC_SIGTRAMP_MAGIC
;
241 /* Dynamically create a signal-handler caller procedure descriptor for
242 the signal-handler return code starting at address LOW_ADDR. The
243 descriptor is added to the linked_proc_desc_table. */
245 static alpha_extra_func_info_t
246 push_sigtramp_desc (CORE_ADDR low_addr
)
248 struct linked_proc_info
*link
;
249 alpha_extra_func_info_t proc_desc
;
251 link
= (struct linked_proc_info
*)
252 xmalloc (sizeof (struct linked_proc_info
));
253 link
->next
= linked_proc_desc_table
;
254 linked_proc_desc_table
= link
;
256 proc_desc
= &link
->info
;
258 proc_desc
->numargs
= 0;
259 PROC_LOW_ADDR (proc_desc
) = low_addr
;
260 PROC_HIGH_ADDR (proc_desc
) = low_addr
+ 3 * 4;
261 PROC_DUMMY_FRAME (proc_desc
) = 0;
262 PROC_FRAME_OFFSET (proc_desc
) = 0x298; /* sizeof(struct sigcontext_struct) */
263 PROC_FRAME_REG (proc_desc
) = SP_REGNUM
;
264 PROC_REG_MASK (proc_desc
) = 0xffff;
265 PROC_FREG_MASK (proc_desc
) = 0xffff;
266 PROC_PC_REG (proc_desc
) = 26;
267 PROC_LOCALOFF (proc_desc
) = 0;
268 alpha_set_proc_desc_is_dyn_sigtramp (proc_desc
);
274 alpha_register_name (int regno
)
276 static char *register_names
[] =
278 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
279 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
280 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
281 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
282 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
283 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
284 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
285 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
286 "pc", "vfp", "unique",
291 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
293 return (register_names
[regno
]);
297 alpha_cannot_fetch_register (int regno
)
299 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
303 alpha_cannot_store_register (int regno
)
305 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
309 alpha_register_convertible (int regno
)
311 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
315 alpha_register_virtual_type (int regno
)
317 return ((regno
>= FP0_REGNUM
&& regno
< (FP0_REGNUM
+31))
318 ? builtin_type_double
: builtin_type_long
);
322 alpha_register_byte (int regno
)
328 alpha_register_raw_size (int regno
)
334 alpha_register_virtual_size (int regno
)
341 alpha_sigcontext_addr (struct frame_info
*fi
)
343 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
345 if (tdep
->sigcontext_addr
)
346 return (tdep
->sigcontext_addr (fi
));
351 /* Guaranteed to set frame->saved_regs to some values (it never leaves it
355 alpha_find_saved_regs (struct frame_info
*frame
)
358 CORE_ADDR reg_position
;
360 alpha_extra_func_info_t proc_desc
;
363 frame_saved_regs_zalloc (frame
);
365 /* If it is the frame for __sigtramp, the saved registers are located
366 in a sigcontext structure somewhere on the stack. __sigtramp
367 passes a pointer to the sigcontext structure on the stack.
368 If the stack layout for __sigtramp changes, or if sigcontext offsets
369 change, we might have to update this code. */
370 #ifndef SIGFRAME_PC_OFF
371 #define SIGFRAME_PC_OFF (2 * 8)
372 #define SIGFRAME_REGSAVE_OFF (4 * 8)
373 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
375 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
377 CORE_ADDR sigcontext_addr
;
379 sigcontext_addr
= alpha_sigcontext_addr (frame
);
380 if (sigcontext_addr
== 0)
382 /* Don't know where the sigcontext is; just bail. */
385 for (ireg
= 0; ireg
< 32; ireg
++)
387 reg_position
= sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ ireg
* 8;
388 get_frame_saved_regs (frame
)[ireg
] = reg_position
;
390 for (ireg
= 0; ireg
< 32; ireg
++)
392 reg_position
= sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ ireg
* 8;
393 get_frame_saved_regs (frame
)[FP0_REGNUM
+ ireg
] = reg_position
;
395 get_frame_saved_regs (frame
)[PC_REGNUM
] = sigcontext_addr
+ SIGFRAME_PC_OFF
;
399 proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
400 if (proc_desc
== NULL
)
401 /* I'm not sure how/whether this can happen. Normally when we can't
402 find a proc_desc, we "synthesize" one using heuristic_proc_desc
403 and set the saved_regs right away. */
406 /* Fill in the offsets for the registers which gen_mask says
409 reg_position
= get_frame_base (frame
) + PROC_REG_OFFSET (proc_desc
);
410 mask
= PROC_REG_MASK (proc_desc
);
412 returnreg
= PROC_PC_REG (proc_desc
);
414 /* Note that RA is always saved first, regardless of its actual
416 if (mask
& (1 << returnreg
))
418 get_frame_saved_regs (frame
)[returnreg
] = reg_position
;
420 mask
&= ~(1 << returnreg
); /* Clear bit for RA so we
421 don't save again later. */
424 for (ireg
= 0; ireg
<= 31; ++ireg
)
425 if (mask
& (1 << ireg
))
427 get_frame_saved_regs (frame
)[ireg
] = reg_position
;
431 /* Fill in the offsets for the registers which float_mask says
434 reg_position
= get_frame_base (frame
) + PROC_FREG_OFFSET (proc_desc
);
435 mask
= PROC_FREG_MASK (proc_desc
);
437 for (ireg
= 0; ireg
<= 31; ++ireg
)
438 if (mask
& (1 << ireg
))
440 get_frame_saved_regs (frame
)[FP0_REGNUM
+ ireg
] = reg_position
;
444 get_frame_saved_regs (frame
)[PC_REGNUM
] = get_frame_saved_regs (frame
)[returnreg
];
448 alpha_frame_init_saved_regs (struct frame_info
*fi
)
450 if (get_frame_saved_regs (fi
) == NULL
)
451 alpha_find_saved_regs (fi
);
452 get_frame_saved_regs (fi
)[SP_REGNUM
] = get_frame_base (fi
);
456 alpha_init_frame_pc_first (int fromleaf
, struct frame_info
*prev
)
458 return (fromleaf
? SAVED_PC_AFTER_CALL (get_next_frame (prev
))
459 : get_next_frame (prev
) ? DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev
))
464 read_next_frame_reg (struct frame_info
*fi
, int regno
)
466 for (; fi
; fi
= get_next_frame (fi
))
468 /* We have to get the saved sp from the sigcontext
469 if it is a signal handler frame. */
470 if (regno
== SP_REGNUM
&& !(get_frame_type (fi
) == SIGTRAMP_FRAME
))
471 return get_frame_base (fi
);
474 if (get_frame_saved_regs (fi
) == NULL
)
475 alpha_find_saved_regs (fi
);
476 if (get_frame_saved_regs (fi
)[regno
])
477 return read_memory_integer (get_frame_saved_regs (fi
)[regno
], 8);
480 return read_register (regno
);
484 alpha_frame_saved_pc (struct frame_info
*frame
)
486 alpha_extra_func_info_t proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
487 /* We have to get the saved pc from the sigcontext
488 if it is a signal handler frame. */
489 int pcreg
= ((get_frame_type (frame
) == SIGTRAMP_FRAME
)
491 : get_frame_extra_info (frame
)->pc_reg
);
493 if (proc_desc
&& PROC_DESC_IS_DUMMY (proc_desc
))
494 return read_memory_integer (get_frame_base (frame
) - 8, 8);
496 return read_next_frame_reg (frame
, pcreg
);
500 alpha_saved_pc_after_call (struct frame_info
*frame
)
502 CORE_ADDR pc
= get_frame_pc (frame
);
504 alpha_extra_func_info_t proc_desc
;
507 /* Skip over shared library trampoline if necessary. */
508 tmp
= SKIP_TRAMPOLINE_CODE (pc
);
512 proc_desc
= find_proc_desc (pc
, get_next_frame (frame
));
513 pcreg
= proc_desc
? PROC_PC_REG (proc_desc
) : ALPHA_RA_REGNUM
;
515 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
516 return alpha_frame_saved_pc (frame
);
518 return read_register (pcreg
);
522 static struct alpha_extra_func_info temp_proc_desc
;
523 static CORE_ADDR temp_saved_regs
[ALPHA_NUM_REGS
];
525 /* Nonzero if instruction at PC is a return instruction. "ret
526 $zero,($ra),1" on alpha. */
529 alpha_about_to_return (CORE_ADDR pc
)
531 return read_memory_integer (pc
, 4) == 0x6bfa8001;
536 /* This fencepost looks highly suspicious to me. Removing it also
537 seems suspicious as it could affect remote debugging across serial
541 heuristic_proc_start (CORE_ADDR pc
)
543 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
544 CORE_ADDR start_pc
= pc
;
545 CORE_ADDR fence
= start_pc
- heuristic_fence_post
;
550 if (heuristic_fence_post
== UINT_MAX
551 || fence
< tdep
->vm_min_address
)
552 fence
= tdep
->vm_min_address
;
554 /* search back for previous return */
555 for (start_pc
-= 4;; start_pc
-= 4)
556 if (start_pc
< fence
)
558 /* It's not clear to me why we reach this point when
559 stop_soon_quietly, but with this test, at least we
560 don't print out warnings for every child forked (eg, on
561 decstation). 22apr93 rich@cygnus.com. */
562 if (!stop_soon_quietly
)
564 static int blurb_printed
= 0;
566 if (fence
== tdep
->vm_min_address
)
567 warning ("Hit beginning of text section without finding");
569 warning ("Hit heuristic-fence-post without finding");
571 warning ("enclosing function for address 0x%s", paddr_nz (pc
));
575 This warning occurs if you are debugging a function without any symbols\n\
576 (for example, in a stripped executable). In that case, you may wish to\n\
577 increase the size of the search with the `set heuristic-fence-post' command.\n\
579 Otherwise, you told GDB there was a function where there isn't one, or\n\
580 (more likely) you have encountered a bug in GDB.\n");
587 else if (alpha_about_to_return (start_pc
))
590 start_pc
+= 4; /* skip return */
594 static alpha_extra_func_info_t
595 heuristic_proc_desc (CORE_ADDR start_pc
, CORE_ADDR limit_pc
,
596 struct frame_info
*next_frame
)
598 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
602 int has_frame_reg
= 0;
603 unsigned long reg_mask
= 0;
609 memset (&temp_proc_desc
, '\0', sizeof (temp_proc_desc
));
610 memset (&temp_saved_regs
, '\0', SIZEOF_FRAME_SAVED_REGS
);
611 PROC_LOW_ADDR (&temp_proc_desc
) = start_pc
;
613 if (start_pc
+ 200 < limit_pc
)
614 limit_pc
= start_pc
+ 200;
616 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
622 status
= read_memory_nobpt (cur_pc
, buf
, 4);
624 memory_error (status
, cur_pc
);
625 word
= extract_unsigned_integer (buf
, 4);
627 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
631 /* Consider only the first stack allocation instruction
632 to contain the static size of the frame. */
634 frame_size
+= (-word
) & 0xffff;
637 /* Exit loop if a positive stack adjustment is found, which
638 usually means that the stack cleanup code in the function
639 epilogue is reached. */
642 else if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
643 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
645 int reg
= (word
& 0x03e00000) >> 21;
646 reg_mask
|= 1 << reg
;
648 /* Do not compute the address where the register was saved yet,
649 because we don't know yet if the offset will need to be
650 relative to $sp or $fp (we can not compute the address relative
651 to $sp if $sp is updated during the execution of the current
652 subroutine, for instance when doing some alloca). So just store
653 the offset for the moment, and compute the address later
654 when we know whether this frame has a frame pointer or not.
656 temp_saved_regs
[reg
] = (short) word
;
658 /* Starting with OSF/1-3.2C, the system libraries are shipped
659 without local symbols, but they still contain procedure
660 descriptors without a symbol reference. GDB is currently
661 unable to find these procedure descriptors and uses
662 heuristic_proc_desc instead.
663 As some low level compiler support routines (__div*, __add*)
664 use a non-standard return address register, we have to
665 add some heuristics to determine the return address register,
666 or stepping over these routines will fail.
667 Usually the return address register is the first register
668 saved on the stack, but assembler optimization might
669 rearrange the register saves.
670 So we recognize only a few registers (t7, t9, ra) within
671 the procedure prologue as valid return address registers.
672 If we encounter a return instruction, we extract the
673 the return address register from it.
675 FIXME: Rewriting GDB to access the procedure descriptors,
676 e.g. via the minimal symbol table, might obviate this hack. */
678 && cur_pc
< (start_pc
+ 80)
679 && (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
680 || reg
== ALPHA_RA_REGNUM
))
683 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
684 pcreg
= (word
>> 16) & 0x1f;
685 else if (word
== 0x47de040f || word
== 0x47fe040f) /* bis sp,sp fp */
687 /* ??? I am not sure what instruction is 0x47fe040f, and I
688 am suspecting that there was a typo and should have been
689 0x47fe040f. I'm keeping it in the test above until further
692 vfp
= read_next_frame_reg (next_frame
, ALPHA_GCC_FP_REGNUM
);
697 /* If we haven't found a valid return address register yet,
698 keep searching in the procedure prologue. */
699 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
704 if (read_memory_nobpt (cur_pc
, buf
, 4))
707 word
= extract_unsigned_integer (buf
, 4);
709 if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
710 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
712 int reg
= (word
& 0x03e00000) >> 21;
713 if (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
714 || reg
== ALPHA_RA_REGNUM
)
720 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
722 pcreg
= (word
>> 16) & 0x1f;
729 PROC_FRAME_REG (&temp_proc_desc
) = ALPHA_GCC_FP_REGNUM
;
731 PROC_FRAME_REG (&temp_proc_desc
) = SP_REGNUM
;
733 /* At this point, we know which of the Stack Pointer or the Frame Pointer
734 to use as the reference address to compute the saved registers address.
735 But in both cases, the processing above has set vfp to this reference
736 address, so just need to increment the offset of each saved register
738 for (regno
= 0; regno
< NUM_REGS
; regno
++)
740 if (reg_mask
& 1 << regno
)
741 temp_saved_regs
[regno
] += vfp
;
744 PROC_FRAME_OFFSET (&temp_proc_desc
) = frame_size
;
745 PROC_REG_MASK (&temp_proc_desc
) = reg_mask
;
746 PROC_PC_REG (&temp_proc_desc
) = (pcreg
== -1) ? ALPHA_RA_REGNUM
: pcreg
;
747 PROC_LOCALOFF (&temp_proc_desc
) = 0; /* XXX - bogus */
748 return &temp_proc_desc
;
751 /* This returns the PC of the first inst after the prologue. If we can't
752 find the prologue, then return 0. */
755 after_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
757 struct symtab_and_line sal
;
758 CORE_ADDR func_addr
, func_end
;
761 proc_desc
= find_proc_desc (pc
, NULL
);
765 if (alpha_proc_desc_is_dyn_sigtramp (proc_desc
))
766 return PROC_LOW_ADDR (proc_desc
); /* "prologue" is in kernel */
768 /* If function is frameless, then we need to do it the hard way. I
769 strongly suspect that frameless always means prologueless... */
770 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
771 && PROC_FRAME_OFFSET (proc_desc
) == 0)
775 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
776 return 0; /* Unknown */
778 sal
= find_pc_line (func_addr
, 0);
780 if (sal
.end
< func_end
)
783 /* The line after the prologue is after the end of the function. In this
784 case, tell the caller to find the prologue the hard way. */
789 /* Return non-zero if we *might* be in a function prologue. Return zero if we
790 are definitively *not* in a function prologue. */
793 alpha_in_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
795 CORE_ADDR after_prologue_pc
;
797 after_prologue_pc
= after_prologue (pc
, proc_desc
);
799 if (after_prologue_pc
== 0
800 || pc
< after_prologue_pc
)
806 static alpha_extra_func_info_t
807 find_proc_desc (CORE_ADDR pc
, struct frame_info
*next_frame
)
809 alpha_extra_func_info_t proc_desc
;
814 /* Try to get the proc_desc from the linked call dummy proc_descs
815 if the pc is in the call dummy.
816 This is hairy. In the case of nested dummy calls we have to find the
817 right proc_desc, but we might not yet know the frame for the dummy
818 as it will be contained in the proc_desc we are searching for.
819 So we have to find the proc_desc whose frame is closest to the current
822 if (DEPRECATED_PC_IN_CALL_DUMMY (pc
, 0, 0))
824 struct linked_proc_info
*link
;
825 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
826 alpha_extra_func_info_t found_proc_desc
= NULL
;
827 long min_distance
= LONG_MAX
;
829 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
831 long distance
= (CORE_ADDR
) PROC_DUMMY_FRAME (&link
->info
) - sp
;
832 if (distance
> 0 && distance
< min_distance
)
834 min_distance
= distance
;
835 found_proc_desc
= &link
->info
;
838 if (found_proc_desc
!= NULL
)
839 return found_proc_desc
;
842 b
= block_for_pc (pc
);
844 find_pc_partial_function (pc
, NULL
, &startaddr
, NULL
);
849 if (startaddr
> BLOCK_START (b
))
850 /* This is the "pathological" case referred to in a comment in
851 print_frame_info. It might be better to move this check into
855 sym
= lookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
,
859 /* If we never found a PDR for this function in symbol reading, then
860 examine prologues to find the information. */
861 if (sym
&& ((mips_extra_func_info_t
) SYMBOL_VALUE (sym
))->pdr
.framereg
== -1)
866 /* IF this is the topmost frame AND
867 * (this proc does not have debugging information OR
868 * the PC is in the procedure prologue)
869 * THEN create a "heuristic" proc_desc (by analyzing
870 * the actual code) to replace the "official" proc_desc.
872 proc_desc
= (alpha_extra_func_info_t
) SYMBOL_VALUE (sym
);
873 if (next_frame
== NULL
)
875 if (PROC_DESC_IS_DUMMY (proc_desc
) || alpha_in_prologue (pc
, proc_desc
))
877 alpha_extra_func_info_t found_heuristic
=
878 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc
),
882 PROC_LOCALOFF (found_heuristic
) =
883 PROC_LOCALOFF (proc_desc
);
884 PROC_PC_REG (found_heuristic
) = PROC_PC_REG (proc_desc
);
885 proc_desc
= found_heuristic
;
894 /* Is linked_proc_desc_table really necessary? It only seems to be used
895 by procedure call dummys. However, the procedures being called ought
896 to have their own proc_descs, and even if they don't,
897 heuristic_proc_desc knows how to create them! */
899 register struct linked_proc_info
*link
;
900 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
901 if (PROC_LOW_ADDR (&link
->info
) <= pc
902 && PROC_HIGH_ADDR (&link
->info
) > pc
)
905 /* If PC is inside a dynamically generated sigtramp handler,
906 create and push a procedure descriptor for that code: */
907 offset
= alpha_dynamic_sigtramp_offset (pc
);
909 return push_sigtramp_desc (pc
- offset
);
911 /* If heuristic_fence_post is non-zero, determine the procedure
912 start address by examining the instructions.
913 This allows us to find the start address of static functions which
914 have no symbolic information, as startaddr would have been set to
915 the preceding global function start address by the
916 find_pc_partial_function call above. */
917 if (startaddr
== 0 || heuristic_fence_post
!= 0)
918 startaddr
= heuristic_proc_start (pc
);
921 heuristic_proc_desc (startaddr
, pc
, next_frame
);
926 alpha_extra_func_info_t cached_proc_desc
;
929 alpha_frame_chain (struct frame_info
*frame
)
931 alpha_extra_func_info_t proc_desc
;
932 CORE_ADDR saved_pc
= DEPRECATED_FRAME_SAVED_PC (frame
);
934 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
937 proc_desc
= find_proc_desc (saved_pc
, frame
);
941 cached_proc_desc
= proc_desc
;
943 /* Fetch the frame pointer for a dummy frame from the procedure
945 if (PROC_DESC_IS_DUMMY (proc_desc
))
946 return (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
948 /* If no frame pointer and frame size is zero, we must be at end
949 of stack (or otherwise hosed). If we don't check frame size,
950 we loop forever if we see a zero size frame. */
951 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
952 && PROC_FRAME_OFFSET (proc_desc
) == 0
953 /* The previous frame from a sigtramp frame might be frameless
954 and have frame size zero. */
955 && !(get_frame_type (frame
) == SIGTRAMP_FRAME
))
956 return alpha_frame_past_sigtramp_frame (frame
, saved_pc
);
958 return read_next_frame_reg (frame
, PROC_FRAME_REG (proc_desc
))
959 + PROC_FRAME_OFFSET (proc_desc
);
963 alpha_print_extra_frame_info (struct frame_info
*fi
)
966 && get_frame_extra_info (fi
)
967 && get_frame_extra_info (fi
)->proc_desc
968 && get_frame_extra_info (fi
)->proc_desc
->pdr
.framereg
< NUM_REGS
)
969 printf_filtered (" frame pointer is at %s+%s\n",
970 REGISTER_NAME (get_frame_extra_info (fi
)->proc_desc
->pdr
.framereg
),
971 paddr_d (get_frame_extra_info (fi
)->proc_desc
->pdr
.frameoffset
));
975 alpha_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
977 /* Use proc_desc calculated in frame_chain */
978 alpha_extra_func_info_t proc_desc
=
979 get_next_frame (frame
)
981 : find_proc_desc (get_frame_pc (frame
), get_next_frame (frame
));
983 frame_extra_info_zalloc (frame
, sizeof (struct frame_extra_info
));
985 /* NOTE: cagney/2003-01-03: No need to set saved_regs to NULL,
986 always NULL by default. */
987 /* frame->saved_regs = NULL; */
988 get_frame_extra_info (frame
)->localoff
= 0;
989 get_frame_extra_info (frame
)->pc_reg
= ALPHA_RA_REGNUM
;
990 get_frame_extra_info (frame
)->proc_desc
= proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
993 /* Get the locals offset and the saved pc register from the
994 procedure descriptor, they are valid even if we are in the
995 middle of the prologue. */
996 get_frame_extra_info (frame
)->localoff
= PROC_LOCALOFF (proc_desc
);
997 get_frame_extra_info (frame
)->pc_reg
= PROC_PC_REG (proc_desc
);
999 /* Fixup frame-pointer - only needed for top frame */
1001 /* Fetch the frame pointer for a dummy frame from the procedure
1003 if (PROC_DESC_IS_DUMMY (proc_desc
))
1004 deprecated_update_frame_base_hack (frame
, (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
));
1006 /* This may not be quite right, if proc has a real frame register.
1007 Get the value of the frame relative sp, procedure might have been
1008 interrupted by a signal at it's very start. */
1009 else if (get_frame_pc (frame
) == PROC_LOW_ADDR (proc_desc
)
1010 && !alpha_proc_desc_is_dyn_sigtramp (proc_desc
))
1011 deprecated_update_frame_base_hack (frame
, read_next_frame_reg (get_next_frame (frame
), SP_REGNUM
));
1013 deprecated_update_frame_base_hack (frame
, read_next_frame_reg (get_next_frame (frame
), PROC_FRAME_REG (proc_desc
))
1014 + PROC_FRAME_OFFSET (proc_desc
));
1016 if (proc_desc
== &temp_proc_desc
)
1020 /* Do not set the saved registers for a sigtramp frame,
1021 alpha_find_saved_registers will do that for us. We can't
1022 use (get_frame_type (frame) == SIGTRAMP_FRAME), it is not
1024 /* FIXME: cagney/2002-11-18: This problem will go away once
1025 frame.c:get_prev_frame() is modified to set the frame's
1026 type before calling functions like this. */
1027 find_pc_partial_function (get_frame_pc (frame
), &name
,
1028 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
1029 if (!PC_IN_SIGTRAMP (get_frame_pc (frame
), name
))
1031 frame_saved_regs_zalloc (frame
);
1032 memcpy (get_frame_saved_regs (frame
), temp_saved_regs
,
1033 SIZEOF_FRAME_SAVED_REGS
);
1034 get_frame_saved_regs (frame
)[PC_REGNUM
]
1035 = get_frame_saved_regs (frame
)[ALPHA_RA_REGNUM
];
1042 alpha_frame_locals_address (struct frame_info
*fi
)
1044 return (get_frame_base (fi
) - get_frame_extra_info (fi
)->localoff
);
1048 alpha_frame_args_address (struct frame_info
*fi
)
1050 return (get_frame_base (fi
) - (ALPHA_NUM_ARG_REGS
* 8));
1053 /* ALPHA stack frames are almost impenetrable. When execution stops,
1054 we basically have to look at symbol information for the function
1055 that we stopped in, which tells us *which* register (if any) is
1056 the base of the frame pointer, and what offset from that register
1057 the frame itself is at.
1059 This presents a problem when trying to examine a stack in memory
1060 (that isn't executing at the moment), using the "frame" command. We
1061 don't have a PC, nor do we have any registers except SP.
1063 This routine takes two arguments, SP and PC, and tries to make the
1064 cached frames look as if these two arguments defined a frame on the
1065 cache. This allows the rest of info frame to extract the important
1066 arguments without difficulty. */
1069 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1072 error ("ALPHA frame specifications require two arguments: sp and pc");
1074 return create_new_frame (argv
[0], argv
[1]);
1077 /* The alpha passes the first six arguments in the registers, the rest on
1078 the stack. The register arguments are eventually transferred to the
1079 argument transfer area immediately below the stack by the called function
1080 anyway. So we `push' at least six arguments on the stack, `reload' the
1081 argument registers and then adjust the stack pointer to point past the
1082 sixth argument. This algorithm simplifies the passing of a large struct
1083 which extends from the registers to the stack.
1084 If the called function is returning a structure, the address of the
1085 structure to be returned is passed as a hidden first argument. */
1088 alpha_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1089 int struct_return
, CORE_ADDR struct_addr
)
1092 int accumulate_size
= struct_return
? 8 : 0;
1093 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
1100 struct alpha_arg
*alpha_args
=
1101 (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
1102 register struct alpha_arg
*m_arg
;
1103 char raw_buffer
[sizeof (CORE_ADDR
)];
1104 int required_arg_regs
;
1106 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
1108 struct value
*arg
= args
[i
];
1109 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1110 /* Cast argument to long if necessary as the compiler does it too. */
1111 switch (TYPE_CODE (arg_type
))
1114 case TYPE_CODE_BOOL
:
1115 case TYPE_CODE_CHAR
:
1116 case TYPE_CODE_RANGE
:
1117 case TYPE_CODE_ENUM
:
1118 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
1120 arg_type
= builtin_type_long
;
1121 arg
= value_cast (arg_type
, arg
);
1127 m_arg
->len
= TYPE_LENGTH (arg_type
);
1128 m_arg
->offset
= accumulate_size
;
1129 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
1130 m_arg
->contents
= VALUE_CONTENTS (arg
);
1133 /* Determine required argument register loads, loading an argument register
1134 is expensive as it uses three ptrace calls. */
1135 required_arg_regs
= accumulate_size
/ 8;
1136 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
1137 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
1139 /* Make room for the arguments on the stack. */
1140 if (accumulate_size
< arg_regs_size
)
1141 accumulate_size
= arg_regs_size
;
1142 sp
-= accumulate_size
;
1144 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
1147 /* `Push' arguments on the stack. */
1148 for (i
= nargs
; m_arg
--, --i
>= 0;)
1149 write_memory (sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
1152 store_address (raw_buffer
, sizeof (CORE_ADDR
), struct_addr
);
1153 write_memory (sp
, raw_buffer
, sizeof (CORE_ADDR
));
1156 /* Load the argument registers. */
1157 for (i
= 0; i
< required_arg_regs
; i
++)
1161 val
= read_memory_integer (sp
+ i
* 8, 8);
1162 write_register (ALPHA_A0_REGNUM
+ i
, val
);
1163 write_register (ALPHA_FPA0_REGNUM
+ i
, val
);
1166 return sp
+ arg_regs_size
;
1170 alpha_push_dummy_frame (void)
1173 struct linked_proc_info
*link
;
1174 alpha_extra_func_info_t proc_desc
;
1175 CORE_ADDR sp
= read_register (SP_REGNUM
);
1176 CORE_ADDR save_address
;
1177 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1180 link
= (struct linked_proc_info
*) xmalloc (sizeof (struct linked_proc_info
));
1181 link
->next
= linked_proc_desc_table
;
1182 linked_proc_desc_table
= link
;
1184 proc_desc
= &link
->info
;
1187 * The registers we must save are all those not preserved across
1189 * In addition, we must save the PC and RA.
1191 * Dummy frame layout:
1201 * Parameter build area
1205 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
1206 #define MASK(i,j) ((((LONGEST)1 << ((j)+1)) - 1) ^ (((LONGEST)1 << (i)) - 1))
1207 #define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
1208 #define GEN_REG_SAVE_COUNT 24
1209 #define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
1210 #define FLOAT_REG_SAVE_COUNT 23
1211 /* The special register is the PC as we have no bit for it in the save masks.
1212 alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
1213 #define SPECIAL_REG_SAVE_COUNT 1
1215 PROC_REG_MASK (proc_desc
) = GEN_REG_SAVE_MASK
;
1216 PROC_FREG_MASK (proc_desc
) = FLOAT_REG_SAVE_MASK
;
1217 /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
1218 but keep SP aligned to a multiple of 16. */
1219 PROC_REG_OFFSET (proc_desc
) =
1220 -((8 * (SPECIAL_REG_SAVE_COUNT
1221 + GEN_REG_SAVE_COUNT
1222 + FLOAT_REG_SAVE_COUNT
)
1224 PROC_FREG_OFFSET (proc_desc
) =
1225 PROC_REG_OFFSET (proc_desc
) + 8 * GEN_REG_SAVE_COUNT
;
1227 /* Save general registers.
1228 The return address register is the first saved register, all other
1229 registers follow in ascending order.
1230 The PC is saved immediately below the SP. */
1231 save_address
= sp
+ PROC_REG_OFFSET (proc_desc
);
1232 store_address (raw_buffer
, 8, read_register (ALPHA_RA_REGNUM
));
1233 write_memory (save_address
, raw_buffer
, 8);
1235 mask
= PROC_REG_MASK (proc_desc
) & 0xffffffffL
;
1236 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1239 if (ireg
== ALPHA_RA_REGNUM
)
1241 store_address (raw_buffer
, 8, read_register (ireg
));
1242 write_memory (save_address
, raw_buffer
, 8);
1246 store_address (raw_buffer
, 8, read_register (PC_REGNUM
));
1247 write_memory (sp
- 8, raw_buffer
, 8);
1249 /* Save floating point registers. */
1250 save_address
= sp
+ PROC_FREG_OFFSET (proc_desc
);
1251 mask
= PROC_FREG_MASK (proc_desc
) & 0xffffffffL
;
1252 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1255 store_address (raw_buffer
, 8, read_register (ireg
+ FP0_REGNUM
));
1256 write_memory (save_address
, raw_buffer
, 8);
1260 /* Set and save the frame address for the dummy.
1261 This is tricky. The only registers that are suitable for a frame save
1262 are those that are preserved across procedure calls (s0-s6). But if
1263 a read system call is interrupted and then a dummy call is made
1264 (see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
1265 is satisfied. Then it returns with the s0-s6 registers set to the values
1266 on entry to the read system call and our dummy frame pointer would be
1267 destroyed. So we save the dummy frame in the proc_desc and handle the
1268 retrieval of the frame pointer of a dummy specifically. The frame register
1269 is set to the virtual frame (pseudo) register, it's value will always
1270 be read as zero and will help us to catch any errors in the dummy frame
1272 PROC_DUMMY_FRAME (proc_desc
) = sp
;
1273 PROC_FRAME_REG (proc_desc
) = FP_REGNUM
;
1274 PROC_FRAME_OFFSET (proc_desc
) = 0;
1275 sp
+= PROC_REG_OFFSET (proc_desc
);
1276 write_register (SP_REGNUM
, sp
);
1278 PROC_LOW_ADDR (proc_desc
) = CALL_DUMMY_ADDRESS ();
1279 PROC_HIGH_ADDR (proc_desc
) = PROC_LOW_ADDR (proc_desc
) + 4;
1281 SET_PROC_DESC_IS_DUMMY (proc_desc
);
1282 PROC_PC_REG (proc_desc
) = ALPHA_RA_REGNUM
;
1286 alpha_pop_frame (void)
1288 register int regnum
;
1289 struct frame_info
*frame
= get_current_frame ();
1290 CORE_ADDR new_sp
= get_frame_base (frame
);
1292 alpha_extra_func_info_t proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
1294 /* we need proc_desc to know how to restore the registers;
1295 if it is NULL, construct (a temporary) one */
1296 if (proc_desc
== NULL
)
1297 proc_desc
= find_proc_desc (get_frame_pc (frame
), get_next_frame (frame
));
1299 /* Question: should we copy this proc_desc and save it in
1300 frame->proc_desc? If we do, who will free it?
1301 For now, we don't save a copy... */
1303 write_register (PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (frame
));
1304 if (get_frame_saved_regs (frame
) == NULL
)
1305 alpha_find_saved_regs (frame
);
1308 for (regnum
= 32; --regnum
>= 0;)
1309 if (PROC_REG_MASK (proc_desc
) & (1 << regnum
))
1310 write_register (regnum
,
1311 read_memory_integer (get_frame_saved_regs (frame
)[regnum
],
1313 for (regnum
= 32; --regnum
>= 0;)
1314 if (PROC_FREG_MASK (proc_desc
) & (1 << regnum
))
1315 write_register (regnum
+ FP0_REGNUM
,
1316 read_memory_integer (get_frame_saved_regs (frame
)[regnum
+ FP0_REGNUM
], 8));
1318 write_register (SP_REGNUM
, new_sp
);
1319 flush_cached_frames ();
1321 if (proc_desc
&& (PROC_DESC_IS_DUMMY (proc_desc
)
1322 || alpha_proc_desc_is_dyn_sigtramp (proc_desc
)))
1324 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
1326 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
1328 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
1330 if (&pi_ptr
->info
== proc_desc
)
1335 error ("Can't locate dummy extra frame info\n");
1337 if (prev_ptr
!= NULL
)
1338 prev_ptr
->next
= pi_ptr
->next
;
1340 linked_proc_desc_table
= pi_ptr
->next
;
1346 /* To skip prologues, I use this predicate. Returns either PC itself
1347 if the code at PC does not look like a function prologue; otherwise
1348 returns an address that (if we're lucky) follows the prologue. If
1349 LENIENT, then we must skip everything which is involved in setting
1350 up the frame (it's OK to skip more, just so long as we don't skip
1351 anything which might clobber the registers which are being saved.
1352 Currently we must not skip more on the alpha, but we might need the
1353 lenient stuff some day. */
1356 alpha_skip_prologue_internal (CORE_ADDR pc
, int lenient
)
1360 CORE_ADDR post_prologue_pc
;
1363 /* Silently return the unaltered pc upon memory errors.
1364 This could happen on OSF/1 if decode_line_1 tries to skip the
1365 prologue for quickstarted shared library functions when the
1366 shared library is not yet mapped in.
1367 Reading target memory is slow over serial lines, so we perform
1368 this check only if the target has shared libraries (which all
1369 Alpha targets do). */
1370 if (target_read_memory (pc
, buf
, 4))
1373 /* See if we can determine the end of the prologue via the symbol table.
1374 If so, then return either PC, or the PC after the prologue, whichever
1377 post_prologue_pc
= after_prologue (pc
, NULL
);
1379 if (post_prologue_pc
!= 0)
1380 return max (pc
, post_prologue_pc
);
1382 /* Can't determine prologue from the symbol table, need to examine
1385 /* Skip the typical prologue instructions. These are the stack adjustment
1386 instruction and the instructions that save registers on the stack
1387 or in the gcc frame. */
1388 for (offset
= 0; offset
< 100; offset
+= 4)
1392 status
= read_memory_nobpt (pc
+ offset
, buf
, 4);
1394 memory_error (status
, pc
+ offset
);
1395 inst
= extract_unsigned_integer (buf
, 4);
1397 /* The alpha has no delay slots. But let's keep the lenient stuff,
1398 we might need it for something else in the future. */
1402 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
1404 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
1406 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1408 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
1411 if ((inst
& 0xfc1f0000) == 0xb41e0000
1412 && (inst
& 0xffff0000) != 0xb7fe0000)
1413 continue; /* stq reg,n($sp) */
1415 if ((inst
& 0xfc1f0000) == 0x9c1e0000
1416 && (inst
& 0xffff0000) != 0x9ffe0000)
1417 continue; /* stt reg,n($sp) */
1419 if (inst
== 0x47de040f) /* bis sp,sp,fp */
1428 alpha_skip_prologue (CORE_ADDR addr
)
1430 return (alpha_skip_prologue_internal (addr
, 0));
1434 /* Is address PC in the prologue (loosely defined) for function at
1438 alpha_in_lenient_prologue (CORE_ADDR startaddr
, CORE_ADDR pc
)
1440 CORE_ADDR end_prologue
= alpha_skip_prologue_internal (startaddr
, 1);
1441 return pc
>= startaddr
&& pc
< end_prologue
;
1445 /* The alpha needs a conversion between register and memory format if
1446 the register is a floating point register and
1447 memory format is float, as the register format must be double
1449 memory format is an integer with 4 bytes or less, as the representation
1450 of integers in floating point registers is different. */
1452 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
1453 char *raw_buffer
, char *virtual_buffer
)
1455 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1457 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
1461 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1463 double d
= extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1464 store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
1466 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1469 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1470 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
1471 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
1474 error ("Cannot retrieve value from floating point register");
1478 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
1479 char *virtual_buffer
, char *raw_buffer
)
1481 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1483 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
1487 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1489 double d
= extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
1490 store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
1492 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1495 if (TYPE_UNSIGNED (valtype
))
1496 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1498 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1499 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
1500 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
1503 error ("Cannot store value in floating point register");
1506 static const unsigned char *
1507 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1509 static const unsigned char alpha_breakpoint
[] =
1510 { 0x80, 0, 0, 0 }; /* call_pal bpt */
1512 *lenptr
= sizeof(alpha_breakpoint
);
1513 return (alpha_breakpoint
);
1516 /* Given a return value in `regbuf' with a type `valtype',
1517 extract and copy its value into `valbuf'. */
1520 alpha_extract_return_value (struct type
*valtype
,
1521 char regbuf
[ALPHA_REGISTER_BYTES
], char *valbuf
)
1523 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1524 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
1525 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
1528 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1529 TYPE_LENGTH (valtype
));
1532 /* Given a return value in `regbuf' with a type `valtype',
1533 write its value into the appropriate register. */
1536 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
1538 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1539 int regnum
= ALPHA_V0_REGNUM
;
1540 int length
= TYPE_LENGTH (valtype
);
1542 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1544 regnum
= FP0_REGNUM
;
1545 length
= REGISTER_RAW_SIZE (regnum
);
1546 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
1549 memcpy (raw_buffer
, valbuf
, length
);
1551 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
1554 /* Just like reinit_frame_cache, but with the right arguments to be
1555 callable as an sfunc. */
1558 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1560 reinit_frame_cache ();
1563 /* This is the definition of CALL_DUMMY_ADDRESS. It's a heuristic that is used
1564 to find a convenient place in the text segment to stick a breakpoint to
1565 detect the completion of a target function call (ala call_function_by_hand).
1569 alpha_call_dummy_address (void)
1572 struct minimal_symbol
*sym
;
1574 entry
= entry_point_address ();
1579 sym
= lookup_minimal_symbol ("_Prelude", NULL
, symfile_objfile
);
1581 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1584 return SYMBOL_VALUE_ADDRESS (sym
) + 4;
1588 alpha_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
1589 struct value
**args
, struct type
*type
, int gcc_p
)
1591 CORE_ADDR bp_address
= CALL_DUMMY_ADDRESS ();
1593 if (bp_address
== 0)
1594 error ("no place to put call");
1595 write_register (ALPHA_RA_REGNUM
, bp_address
);
1596 write_register (ALPHA_T12_REGNUM
, fun
);
1599 /* On the Alpha, the call dummy code is nevery copied to user space
1600 (see alpha_fix_call_dummy() above). The contents of this do not
1602 LONGEST alpha_call_dummy_words
[] = { 0 };
1605 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
1607 /* Structures are returned by ref in extra arg0. */
1612 alpha_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1614 /* Store the address of the place in which to copy the structure the
1615 subroutine will return. Handled by alpha_push_arguments. */
1619 alpha_extract_struct_value_address (char *regbuf
)
1621 return (extract_address (regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1622 REGISTER_RAW_SIZE (ALPHA_V0_REGNUM
)));
1625 /* Figure out where the longjmp will land.
1626 We expect the first arg to be a pointer to the jmp_buf structure from
1627 which we extract the PC (JB_PC) that we will land at. The PC is copied
1628 into the "pc". This routine returns true on success. */
1631 alpha_get_longjmp_target (CORE_ADDR
*pc
)
1633 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1635 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1637 jb_addr
= read_register (ALPHA_A0_REGNUM
);
1639 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
1640 raw_buffer
, tdep
->jb_elt_size
))
1643 *pc
= extract_address (raw_buffer
, tdep
->jb_elt_size
);
1647 /* alpha_software_single_step() is called just before we want to resume
1648 the inferior, if we want to single-step it but there is no hardware
1649 or kernel single-step support (NetBSD on Alpha, for example). We find
1650 the target of the coming instruction and breakpoint it.
1652 single_step is also called just after the inferior stops. If we had
1653 set up a simulated single-step, we undo our damage. */
1656 alpha_next_pc (CORE_ADDR pc
)
1663 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1665 /* Opcode is top 6 bits. */
1666 op
= (insn
>> 26) & 0x3f;
1670 /* Jump format: target PC is:
1672 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1675 if ((op
& 0x30) == 0x30)
1677 /* Branch format: target PC is:
1678 (new PC) + (4 * sext(displacement)) */
1679 if (op
== 0x30 || /* BR */
1680 op
== 0x34) /* BSR */
1683 offset
= (insn
& 0x001fffff);
1684 if (offset
& 0x00100000)
1685 offset
|= 0xffe00000;
1687 return (pc
+ 4 + offset
);
1690 /* Need to determine if branch is taken; read RA. */
1691 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1694 case 0x38: /* BLBC */
1698 case 0x3c: /* BLBS */
1702 case 0x39: /* BEQ */
1706 case 0x3d: /* BNE */
1710 case 0x3a: /* BLT */
1714 case 0x3b: /* BLE */
1718 case 0x3f: /* BGT */
1722 case 0x3e: /* BGE */
1729 /* Not a branch or branch not taken; target PC is:
1735 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1737 static CORE_ADDR next_pc
;
1738 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1739 static binsn_quantum break_mem
;
1742 if (insert_breakpoints_p
)
1745 next_pc
= alpha_next_pc (pc
);
1747 target_insert_breakpoint (next_pc
, break_mem
);
1751 target_remove_breakpoint (next_pc
, break_mem
);
1758 /* Initialize the current architecture based on INFO. If possible, re-use an
1759 architecture from ARCHES, which is a list of architectures already created
1760 during this debugging session.
1762 Called e.g. at program startup, when reading a core file, and when reading
1765 static struct gdbarch
*
1766 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1768 struct gdbarch_tdep
*tdep
;
1769 struct gdbarch
*gdbarch
;
1771 /* Try to determine the ABI of the object we are loading. */
1772 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1774 /* If it's an ECOFF file, assume it's OSF/1. */
1775 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1776 info
.osabi
= GDB_OSABI_OSF1
;
1779 /* Find a candidate among extant architectures. */
1780 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1782 return arches
->gdbarch
;
1784 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1785 gdbarch
= gdbarch_alloc (&info
, tdep
);
1787 /* Lowest text address. This is used by heuristic_proc_start() to
1788 decide when to stop looking. */
1789 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1791 tdep
->dynamic_sigtramp_offset
= NULL
;
1792 tdep
->skip_sigtramp_frame
= NULL
;
1793 tdep
->sigcontext_addr
= NULL
;
1795 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1798 set_gdbarch_short_bit (gdbarch
, 16);
1799 set_gdbarch_int_bit (gdbarch
, 32);
1800 set_gdbarch_long_bit (gdbarch
, 64);
1801 set_gdbarch_long_long_bit (gdbarch
, 64);
1802 set_gdbarch_float_bit (gdbarch
, 32);
1803 set_gdbarch_double_bit (gdbarch
, 64);
1804 set_gdbarch_long_double_bit (gdbarch
, 64);
1805 set_gdbarch_ptr_bit (gdbarch
, 64);
1808 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1809 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1810 set_gdbarch_fp_regnum (gdbarch
, ALPHA_FP_REGNUM
);
1811 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1812 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1814 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1815 set_gdbarch_register_size (gdbarch
, ALPHA_REGISTER_SIZE
);
1816 set_gdbarch_register_bytes (gdbarch
, ALPHA_REGISTER_BYTES
);
1817 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1818 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1819 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, ALPHA_MAX_REGISTER_RAW_SIZE
);
1820 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1821 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
1822 ALPHA_MAX_REGISTER_VIRTUAL_SIZE
);
1823 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1825 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1826 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1828 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1829 set_gdbarch_register_convert_to_virtual (gdbarch
,
1830 alpha_register_convert_to_virtual
);
1831 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1833 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1835 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1836 set_gdbarch_frameless_function_invocation (gdbarch
,
1837 generic_frameless_function_invocation_not
);
1839 set_gdbarch_saved_pc_after_call (gdbarch
, alpha_saved_pc_after_call
);
1841 set_gdbarch_deprecated_frame_chain (gdbarch
, alpha_frame_chain
);
1842 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, alpha_frame_saved_pc
);
1844 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, alpha_frame_init_saved_regs
);
1846 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1847 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1849 set_gdbarch_store_struct_return (gdbarch
, alpha_store_struct_return
);
1850 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1851 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1852 alpha_extract_struct_value_address
);
1854 /* Settings for calling functions in the inferior. */
1855 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
1856 set_gdbarch_call_dummy_length (gdbarch
, 0);
1857 set_gdbarch_push_arguments (gdbarch
, alpha_push_arguments
);
1858 set_gdbarch_deprecated_pop_frame (gdbarch
, alpha_pop_frame
);
1860 /* On the Alpha, the call dummy code is never copied to user space,
1861 stopping the user call is achieved via a bp_call_dummy breakpoint.
1862 But we need a fake CALL_DUMMY definition to enable the proper
1863 call_function_by_hand and to avoid zero length array warnings. */
1864 set_gdbarch_call_dummy_p (gdbarch
, 1);
1865 set_gdbarch_call_dummy_words (gdbarch
, alpha_call_dummy_words
);
1866 set_gdbarch_sizeof_call_dummy_words (gdbarch
, 0);
1867 set_gdbarch_frame_args_address (gdbarch
, alpha_frame_args_address
);
1868 set_gdbarch_frame_locals_address (gdbarch
, alpha_frame_locals_address
);
1869 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, alpha_init_extra_frame_info
);
1871 /* Alpha OSF/1 inhibits execution of code on the stack. But there is
1872 no need for a dummy on the Alpha. PUSH_ARGUMENTS takes care of all
1873 argument handling and bp_call_dummy takes care of stopping the dummy. */
1874 set_gdbarch_call_dummy_address (gdbarch
, alpha_call_dummy_address
);
1875 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1876 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1877 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1878 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1879 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1880 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, alpha_push_dummy_frame
);
1881 set_gdbarch_fix_call_dummy (gdbarch
, alpha_fix_call_dummy
);
1882 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_noop
);
1883 set_gdbarch_deprecated_init_frame_pc_first (gdbarch
, alpha_init_frame_pc_first
);
1885 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1886 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1888 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1889 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1891 set_gdbarch_function_start_offset (gdbarch
, 0);
1892 set_gdbarch_frame_args_skip (gdbarch
, 0);
1894 /* Hook in ABI-specific overrides, if they have been registered. */
1895 gdbarch_init_osabi (info
, gdbarch
);
1897 /* Now that we have tuned the configuration, set a few final things
1898 based on what the OS ABI has told us. */
1900 if (tdep
->jb_pc
>= 0)
1901 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1907 alpha_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1909 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1914 fprintf_unfiltered (file
,
1915 "alpha_dump_tdep: vm_min_address = 0x%lx\n",
1916 (long) tdep
->vm_min_address
);
1918 fprintf_unfiltered (file
,
1919 "alpha_dump_tdep: jb_pc = %d\n",
1921 fprintf_unfiltered (file
,
1922 "alpha_dump_tdep: jb_elt_size = %ld\n",
1923 (long) tdep
->jb_elt_size
);
1927 _initialize_alpha_tdep (void)
1929 struct cmd_list_element
*c
;
1931 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, alpha_dump_tdep
);
1933 tm_print_insn
= print_insn_alpha
;
1935 /* Let the user set the fence post for heuristic_proc_start. */
1937 /* We really would like to have both "0" and "unlimited" work, but
1938 command.c doesn't deal with that. So make it a var_zinteger
1939 because the user can always use "999999" or some such for unlimited. */
1940 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1941 (char *) &heuristic_fence_post
,
1943 Set the distance searched for the start of a function.\n\
1944 If you are debugging a stripped executable, GDB needs to search through the\n\
1945 program for the start of a function. This command sets the distance of the\n\
1946 search. The only need to set it is when debugging a stripped executable.",
1948 /* We need to throw away the frame cache when we set this, since it
1949 might change our ability to get backtraces. */
1950 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1951 add_show_from_set (c
, &showlist
);