1 /* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
32 #include "gdb_string.h"
36 #include "arch-utils.h"
42 #include "alpha-tdep.h"
44 static gdbarch_init_ftype alpha_gdbarch_init
;
46 static gdbarch_register_name_ftype alpha_register_name
;
47 static gdbarch_register_raw_size_ftype alpha_register_raw_size
;
48 static gdbarch_register_virtual_size_ftype alpha_register_virtual_size
;
49 static gdbarch_register_virtual_type_ftype alpha_register_virtual_type
;
50 static gdbarch_register_byte_ftype alpha_register_byte
;
51 static gdbarch_cannot_fetch_register_ftype alpha_cannot_fetch_register
;
52 static gdbarch_cannot_store_register_ftype alpha_cannot_store_register
;
53 static gdbarch_register_convertible_ftype alpha_register_convertible
;
54 static gdbarch_register_convert_to_virtual_ftype
55 alpha_register_convert_to_virtual
;
56 static gdbarch_register_convert_to_raw_ftype alpha_register_convert_to_raw
;
57 static gdbarch_deprecated_extract_return_value_ftype alpha_extract_return_value
;
58 static gdbarch_deprecated_extract_struct_value_address_ftype
59 alpha_extract_struct_value_address
;
60 static gdbarch_use_struct_convention_ftype alpha_use_struct_convention
;
62 static gdbarch_breakpoint_from_pc_ftype alpha_breakpoint_from_pc
;
64 static gdbarch_frame_args_address_ftype alpha_frame_args_address
;
65 static gdbarch_frame_locals_address_ftype alpha_frame_locals_address
;
67 static gdbarch_skip_prologue_ftype alpha_skip_prologue
;
68 static gdbarch_saved_pc_after_call_ftype alpha_saved_pc_after_call
;
70 static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy
;
72 static gdbarch_get_longjmp_target_ftype alpha_get_longjmp_target
;
74 struct frame_extra_info
76 alpha_extra_func_info_t proc_desc
;
81 /* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
83 /* Prototypes for local functions. */
85 static void alpha_find_saved_regs (struct frame_info
*);
87 static alpha_extra_func_info_t
push_sigtramp_desc (CORE_ADDR low_addr
);
89 static CORE_ADDR
read_next_frame_reg (struct frame_info
*, int);
91 static CORE_ADDR
heuristic_proc_start (CORE_ADDR
);
93 static alpha_extra_func_info_t
heuristic_proc_desc (CORE_ADDR
,
97 static alpha_extra_func_info_t
find_proc_desc (CORE_ADDR
,
101 static int alpha_in_lenient_prologue (CORE_ADDR
, CORE_ADDR
);
104 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element
*);
106 static CORE_ADDR
after_prologue (CORE_ADDR pc
,
107 alpha_extra_func_info_t proc_desc
);
109 static int alpha_in_prologue (CORE_ADDR pc
,
110 alpha_extra_func_info_t proc_desc
);
112 static int alpha_about_to_return (CORE_ADDR pc
);
114 void _initialize_alpha_tdep (void);
116 /* Heuristic_proc_start may hunt through the text section for a long
117 time across a 2400 baud serial line. Allows the user to limit this
119 static unsigned int heuristic_fence_post
= 0;
121 /* Layout of a stack frame on the alpha:
124 pdr members: | 7th ... nth arg, |
125 | `pushed' by caller. |
127 ----------------|-------------------------------|<-- old_sp == vfp
130 | |localoff | Copies of 1st .. 6th |
131 | | | | | argument if necessary. |
133 | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS
135 | | | | Locals and temporaries. |
137 | | | |-------------------------------|
139 |-fregoffset | Saved float registers. |
145 | | -------|-------------------------------|
147 | | | Saved registers. |
154 | ----------|-------------------------------|
156 frameoffset | Argument build area, gets |
157 | | 7th ... nth arg for any |
158 | | called procedure. |
160 -------------|-------------------------------|<-- sp
165 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
166 /* These next two fields are kind of being hijacked. I wonder if
167 iline is too small for the values it needs to hold, if GDB is
168 running on a 32-bit host. */
169 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
170 #define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset) /*CALL_DUMMY frame */
171 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
172 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
173 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
174 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
175 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
176 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
177 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
178 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
179 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
180 #define _PROC_MAGIC_ 0x0F0F0F0F
181 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
182 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
184 struct linked_proc_info
186 struct alpha_extra_func_info info
;
187 struct linked_proc_info
*next
;
189 *linked_proc_desc_table
= NULL
;
192 alpha_frame_past_sigtramp_frame (struct frame_info
*frame
, CORE_ADDR pc
)
194 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
196 if (tdep
->skip_sigtramp_frame
!= NULL
)
197 return (tdep
->skip_sigtramp_frame (frame
, pc
));
203 alpha_dynamic_sigtramp_offset (CORE_ADDR pc
)
205 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
207 /* Must be provided by OS/ABI variant code if supported. */
208 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
209 return (tdep
->dynamic_sigtramp_offset (pc
));
214 #define ALPHA_PROC_SIGTRAMP_MAGIC 0x0e0f0f0f
216 /* Return TRUE if the procedure descriptor PROC is a procedure
217 descriptor that refers to a dynamically generated signal
218 trampoline routine. */
220 alpha_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info
*proc
)
222 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
224 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
225 return (proc
->pdr
.isym
== ALPHA_PROC_SIGTRAMP_MAGIC
);
231 alpha_set_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info
*proc
)
233 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
235 if (tdep
->dynamic_sigtramp_offset
!= NULL
)
236 proc
->pdr
.isym
= ALPHA_PROC_SIGTRAMP_MAGIC
;
239 /* Dynamically create a signal-handler caller procedure descriptor for
240 the signal-handler return code starting at address LOW_ADDR. The
241 descriptor is added to the linked_proc_desc_table. */
243 static alpha_extra_func_info_t
244 push_sigtramp_desc (CORE_ADDR low_addr
)
246 struct linked_proc_info
*link
;
247 alpha_extra_func_info_t proc_desc
;
249 link
= (struct linked_proc_info
*)
250 xmalloc (sizeof (struct linked_proc_info
));
251 link
->next
= linked_proc_desc_table
;
252 linked_proc_desc_table
= link
;
254 proc_desc
= &link
->info
;
256 proc_desc
->numargs
= 0;
257 PROC_LOW_ADDR (proc_desc
) = low_addr
;
258 PROC_HIGH_ADDR (proc_desc
) = low_addr
+ 3 * 4;
259 PROC_DUMMY_FRAME (proc_desc
) = 0;
260 PROC_FRAME_OFFSET (proc_desc
) = 0x298; /* sizeof(struct sigcontext_struct) */
261 PROC_FRAME_REG (proc_desc
) = SP_REGNUM
;
262 PROC_REG_MASK (proc_desc
) = 0xffff;
263 PROC_FREG_MASK (proc_desc
) = 0xffff;
264 PROC_PC_REG (proc_desc
) = 26;
265 PROC_LOCALOFF (proc_desc
) = 0;
266 alpha_set_proc_desc_is_dyn_sigtramp (proc_desc
);
272 alpha_register_name (int regno
)
274 static char *register_names
[] =
276 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
277 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
278 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
279 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
280 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
281 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
282 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
283 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
284 "pc", "vfp", "unique",
289 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
291 return (register_names
[regno
]);
295 alpha_cannot_fetch_register (int regno
)
297 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
301 alpha_cannot_store_register (int regno
)
303 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
307 alpha_register_convertible (int regno
)
309 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
313 alpha_register_virtual_type (int regno
)
315 return ((regno
>= FP0_REGNUM
&& regno
< (FP0_REGNUM
+31))
316 ? builtin_type_double
: builtin_type_long
);
320 alpha_register_byte (int regno
)
326 alpha_register_raw_size (int regno
)
332 alpha_register_virtual_size (int regno
)
339 alpha_sigcontext_addr (struct frame_info
*fi
)
341 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
343 if (tdep
->sigcontext_addr
)
344 return (tdep
->sigcontext_addr (fi
));
349 /* Guaranteed to set frame->saved_regs to some values (it never leaves it
353 alpha_find_saved_regs (struct frame_info
*frame
)
356 CORE_ADDR reg_position
;
358 alpha_extra_func_info_t proc_desc
;
361 frame_saved_regs_zalloc (frame
);
363 /* If it is the frame for __sigtramp, the saved registers are located
364 in a sigcontext structure somewhere on the stack. __sigtramp
365 passes a pointer to the sigcontext structure on the stack.
366 If the stack layout for __sigtramp changes, or if sigcontext offsets
367 change, we might have to update this code. */
368 #ifndef SIGFRAME_PC_OFF
369 #define SIGFRAME_PC_OFF (2 * 8)
370 #define SIGFRAME_REGSAVE_OFF (4 * 8)
371 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
373 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
375 CORE_ADDR sigcontext_addr
;
377 sigcontext_addr
= alpha_sigcontext_addr (frame
);
378 if (sigcontext_addr
== 0)
380 /* Don't know where the sigcontext is; just bail. */
383 for (ireg
= 0; ireg
< 32; ireg
++)
385 reg_position
= sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ ireg
* 8;
386 get_frame_saved_regs (frame
)[ireg
] = reg_position
;
388 for (ireg
= 0; ireg
< 32; ireg
++)
390 reg_position
= sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ ireg
* 8;
391 get_frame_saved_regs (frame
)[FP0_REGNUM
+ ireg
] = reg_position
;
393 get_frame_saved_regs (frame
)[PC_REGNUM
] = sigcontext_addr
+ SIGFRAME_PC_OFF
;
397 proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
398 if (proc_desc
== NULL
)
399 /* I'm not sure how/whether this can happen. Normally when we can't
400 find a proc_desc, we "synthesize" one using heuristic_proc_desc
401 and set the saved_regs right away. */
404 /* Fill in the offsets for the registers which gen_mask says
407 reg_position
= get_frame_base (frame
) + PROC_REG_OFFSET (proc_desc
);
408 mask
= PROC_REG_MASK (proc_desc
);
410 returnreg
= PROC_PC_REG (proc_desc
);
412 /* Note that RA is always saved first, regardless of its actual
414 if (mask
& (1 << returnreg
))
416 get_frame_saved_regs (frame
)[returnreg
] = reg_position
;
418 mask
&= ~(1 << returnreg
); /* Clear bit for RA so we
419 don't save again later. */
422 for (ireg
= 0; ireg
<= 31; ++ireg
)
423 if (mask
& (1 << ireg
))
425 get_frame_saved_regs (frame
)[ireg
] = reg_position
;
429 /* Fill in the offsets for the registers which float_mask says
432 reg_position
= get_frame_base (frame
) + PROC_FREG_OFFSET (proc_desc
);
433 mask
= PROC_FREG_MASK (proc_desc
);
435 for (ireg
= 0; ireg
<= 31; ++ireg
)
436 if (mask
& (1 << ireg
))
438 get_frame_saved_regs (frame
)[FP0_REGNUM
+ ireg
] = reg_position
;
442 get_frame_saved_regs (frame
)[PC_REGNUM
] = get_frame_saved_regs (frame
)[returnreg
];
446 alpha_frame_init_saved_regs (struct frame_info
*fi
)
448 if (get_frame_saved_regs (fi
) == NULL
)
449 alpha_find_saved_regs (fi
);
450 get_frame_saved_regs (fi
)[SP_REGNUM
] = get_frame_base (fi
);
454 alpha_init_frame_pc_first (int fromleaf
, struct frame_info
*prev
)
456 return (fromleaf
? SAVED_PC_AFTER_CALL (get_next_frame (prev
))
457 : get_next_frame (prev
) ? DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev
))
462 read_next_frame_reg (struct frame_info
*fi
, int regno
)
464 for (; fi
; fi
= get_next_frame (fi
))
466 /* We have to get the saved sp from the sigcontext
467 if it is a signal handler frame. */
468 if (regno
== SP_REGNUM
&& !(get_frame_type (fi
) == SIGTRAMP_FRAME
))
469 return get_frame_base (fi
);
472 if (get_frame_saved_regs (fi
) == NULL
)
473 alpha_find_saved_regs (fi
);
474 if (get_frame_saved_regs (fi
)[regno
])
475 return read_memory_integer (get_frame_saved_regs (fi
)[regno
], 8);
478 return read_register (regno
);
482 alpha_frame_saved_pc (struct frame_info
*frame
)
484 alpha_extra_func_info_t proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
485 /* We have to get the saved pc from the sigcontext
486 if it is a signal handler frame. */
487 int pcreg
= ((get_frame_type (frame
) == SIGTRAMP_FRAME
)
489 : get_frame_extra_info (frame
)->pc_reg
);
491 if (proc_desc
&& PROC_DESC_IS_DUMMY (proc_desc
))
492 return read_memory_integer (get_frame_base (frame
) - 8, 8);
494 return read_next_frame_reg (frame
, pcreg
);
498 alpha_saved_pc_after_call (struct frame_info
*frame
)
500 CORE_ADDR pc
= get_frame_pc (frame
);
502 alpha_extra_func_info_t proc_desc
;
505 /* Skip over shared library trampoline if necessary. */
506 tmp
= SKIP_TRAMPOLINE_CODE (pc
);
510 proc_desc
= find_proc_desc (pc
, get_next_frame (frame
));
511 pcreg
= proc_desc
? PROC_PC_REG (proc_desc
) : ALPHA_RA_REGNUM
;
513 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
514 return alpha_frame_saved_pc (frame
);
516 return read_register (pcreg
);
520 static struct alpha_extra_func_info temp_proc_desc
;
521 static CORE_ADDR temp_saved_regs
[ALPHA_NUM_REGS
];
523 /* Nonzero if instruction at PC is a return instruction. "ret
524 $zero,($ra),1" on alpha. */
527 alpha_about_to_return (CORE_ADDR pc
)
529 return read_memory_integer (pc
, 4) == 0x6bfa8001;
534 /* This fencepost looks highly suspicious to me. Removing it also
535 seems suspicious as it could affect remote debugging across serial
539 heuristic_proc_start (CORE_ADDR pc
)
541 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
542 CORE_ADDR start_pc
= pc
;
543 CORE_ADDR fence
= start_pc
- heuristic_fence_post
;
548 if (heuristic_fence_post
== UINT_MAX
549 || fence
< tdep
->vm_min_address
)
550 fence
= tdep
->vm_min_address
;
552 /* search back for previous return */
553 for (start_pc
-= 4;; start_pc
-= 4)
554 if (start_pc
< fence
)
556 /* It's not clear to me why we reach this point when
557 stop_soon, but with this test, at least we
558 don't print out warnings for every child forked (eg, on
559 decstation). 22apr93 rich@cygnus.com. */
560 if (stop_soon
== NO_STOP_QUIETLY
)
562 static int blurb_printed
= 0;
564 if (fence
== tdep
->vm_min_address
)
565 warning ("Hit beginning of text section without finding");
567 warning ("Hit heuristic-fence-post without finding");
569 warning ("enclosing function for address 0x%s", paddr_nz (pc
));
573 This warning occurs if you are debugging a function without any symbols\n\
574 (for example, in a stripped executable). In that case, you may wish to\n\
575 increase the size of the search with the `set heuristic-fence-post' command.\n\
577 Otherwise, you told GDB there was a function where there isn't one, or\n\
578 (more likely) you have encountered a bug in GDB.\n");
585 else if (alpha_about_to_return (start_pc
))
588 start_pc
+= 4; /* skip return */
592 static alpha_extra_func_info_t
593 heuristic_proc_desc (CORE_ADDR start_pc
, CORE_ADDR limit_pc
,
594 struct frame_info
*next_frame
)
596 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
600 int has_frame_reg
= 0;
601 unsigned long reg_mask
= 0;
607 memset (&temp_proc_desc
, '\0', sizeof (temp_proc_desc
));
608 memset (&temp_saved_regs
, '\0', SIZEOF_FRAME_SAVED_REGS
);
609 PROC_LOW_ADDR (&temp_proc_desc
) = start_pc
;
611 if (start_pc
+ 200 < limit_pc
)
612 limit_pc
= start_pc
+ 200;
614 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
620 status
= read_memory_nobpt (cur_pc
, buf
, 4);
622 memory_error (status
, cur_pc
);
623 word
= extract_unsigned_integer (buf
, 4);
625 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
629 /* Consider only the first stack allocation instruction
630 to contain the static size of the frame. */
632 frame_size
+= (-word
) & 0xffff;
635 /* Exit loop if a positive stack adjustment is found, which
636 usually means that the stack cleanup code in the function
637 epilogue is reached. */
640 else if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
641 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
643 int reg
= (word
& 0x03e00000) >> 21;
644 reg_mask
|= 1 << reg
;
646 /* Do not compute the address where the register was saved yet,
647 because we don't know yet if the offset will need to be
648 relative to $sp or $fp (we can not compute the address relative
649 to $sp if $sp is updated during the execution of the current
650 subroutine, for instance when doing some alloca). So just store
651 the offset for the moment, and compute the address later
652 when we know whether this frame has a frame pointer or not.
654 temp_saved_regs
[reg
] = (short) word
;
656 /* Starting with OSF/1-3.2C, the system libraries are shipped
657 without local symbols, but they still contain procedure
658 descriptors without a symbol reference. GDB is currently
659 unable to find these procedure descriptors and uses
660 heuristic_proc_desc instead.
661 As some low level compiler support routines (__div*, __add*)
662 use a non-standard return address register, we have to
663 add some heuristics to determine the return address register,
664 or stepping over these routines will fail.
665 Usually the return address register is the first register
666 saved on the stack, but assembler optimization might
667 rearrange the register saves.
668 So we recognize only a few registers (t7, t9, ra) within
669 the procedure prologue as valid return address registers.
670 If we encounter a return instruction, we extract the
671 the return address register from it.
673 FIXME: Rewriting GDB to access the procedure descriptors,
674 e.g. via the minimal symbol table, might obviate this hack. */
676 && cur_pc
< (start_pc
+ 80)
677 && (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
678 || reg
== ALPHA_RA_REGNUM
))
681 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
682 pcreg
= (word
>> 16) & 0x1f;
683 else if (word
== 0x47de040f || word
== 0x47fe040f) /* bis sp,sp fp */
685 /* ??? I am not sure what instruction is 0x47fe040f, and I
686 am suspecting that there was a typo and should have been
687 0x47fe040f. I'm keeping it in the test above until further
690 vfp
= read_next_frame_reg (next_frame
, ALPHA_GCC_FP_REGNUM
);
695 /* If we haven't found a valid return address register yet,
696 keep searching in the procedure prologue. */
697 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
702 if (read_memory_nobpt (cur_pc
, buf
, 4))
705 word
= extract_unsigned_integer (buf
, 4);
707 if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
708 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
710 int reg
= (word
& 0x03e00000) >> 21;
711 if (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
712 || reg
== ALPHA_RA_REGNUM
)
718 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
720 pcreg
= (word
>> 16) & 0x1f;
727 PROC_FRAME_REG (&temp_proc_desc
) = ALPHA_GCC_FP_REGNUM
;
729 PROC_FRAME_REG (&temp_proc_desc
) = SP_REGNUM
;
731 /* At this point, we know which of the Stack Pointer or the Frame Pointer
732 to use as the reference address to compute the saved registers address.
733 But in both cases, the processing above has set vfp to this reference
734 address, so just need to increment the offset of each saved register
736 for (regno
= 0; regno
< NUM_REGS
; regno
++)
738 if (reg_mask
& 1 << regno
)
739 temp_saved_regs
[regno
] += vfp
;
742 PROC_FRAME_OFFSET (&temp_proc_desc
) = frame_size
;
743 PROC_REG_MASK (&temp_proc_desc
) = reg_mask
;
744 PROC_PC_REG (&temp_proc_desc
) = (pcreg
== -1) ? ALPHA_RA_REGNUM
: pcreg
;
745 PROC_LOCALOFF (&temp_proc_desc
) = 0; /* XXX - bogus */
746 return &temp_proc_desc
;
749 /* This returns the PC of the first inst after the prologue. If we can't
750 find the prologue, then return 0. */
753 after_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
755 struct symtab_and_line sal
;
756 CORE_ADDR func_addr
, func_end
;
759 proc_desc
= find_proc_desc (pc
, NULL
);
763 if (alpha_proc_desc_is_dyn_sigtramp (proc_desc
))
764 return PROC_LOW_ADDR (proc_desc
); /* "prologue" is in kernel */
766 /* If function is frameless, then we need to do it the hard way. I
767 strongly suspect that frameless always means prologueless... */
768 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
769 && PROC_FRAME_OFFSET (proc_desc
) == 0)
773 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
774 return 0; /* Unknown */
776 sal
= find_pc_line (func_addr
, 0);
778 if (sal
.end
< func_end
)
781 /* The line after the prologue is after the end of the function. In this
782 case, tell the caller to find the prologue the hard way. */
787 /* Return non-zero if we *might* be in a function prologue. Return zero if we
788 are definitively *not* in a function prologue. */
791 alpha_in_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
793 CORE_ADDR after_prologue_pc
;
795 after_prologue_pc
= after_prologue (pc
, proc_desc
);
797 if (after_prologue_pc
== 0
798 || pc
< after_prologue_pc
)
804 static alpha_extra_func_info_t
805 find_proc_desc (CORE_ADDR pc
, struct frame_info
*next_frame
)
807 alpha_extra_func_info_t proc_desc
;
812 /* Try to get the proc_desc from the linked call dummy proc_descs
813 if the pc is in the call dummy.
814 This is hairy. In the case of nested dummy calls we have to find the
815 right proc_desc, but we might not yet know the frame for the dummy
816 as it will be contained in the proc_desc we are searching for.
817 So we have to find the proc_desc whose frame is closest to the current
820 if (DEPRECATED_PC_IN_CALL_DUMMY (pc
, 0, 0))
822 struct linked_proc_info
*link
;
823 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
824 alpha_extra_func_info_t found_proc_desc
= NULL
;
825 long min_distance
= LONG_MAX
;
827 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
829 long distance
= (CORE_ADDR
) PROC_DUMMY_FRAME (&link
->info
) - sp
;
830 if (distance
> 0 && distance
< min_distance
)
832 min_distance
= distance
;
833 found_proc_desc
= &link
->info
;
836 if (found_proc_desc
!= NULL
)
837 return found_proc_desc
;
840 b
= block_for_pc (pc
);
842 find_pc_partial_function (pc
, NULL
, &startaddr
, NULL
);
847 if (startaddr
> BLOCK_START (b
))
848 /* This is the "pathological" case referred to in a comment in
849 print_frame_info. It might be better to move this check into
853 sym
= lookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
,
857 /* If we never found a PDR for this function in symbol reading, then
858 examine prologues to find the information. */
859 if (sym
&& ((mips_extra_func_info_t
) SYMBOL_VALUE (sym
))->pdr
.framereg
== -1)
864 /* IF this is the topmost frame AND
865 * (this proc does not have debugging information OR
866 * the PC is in the procedure prologue)
867 * THEN create a "heuristic" proc_desc (by analyzing
868 * the actual code) to replace the "official" proc_desc.
870 proc_desc
= (alpha_extra_func_info_t
) SYMBOL_VALUE (sym
);
871 if (next_frame
== NULL
)
873 if (PROC_DESC_IS_DUMMY (proc_desc
) || alpha_in_prologue (pc
, proc_desc
))
875 alpha_extra_func_info_t found_heuristic
=
876 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc
),
880 PROC_LOCALOFF (found_heuristic
) =
881 PROC_LOCALOFF (proc_desc
);
882 PROC_PC_REG (found_heuristic
) = PROC_PC_REG (proc_desc
);
883 proc_desc
= found_heuristic
;
892 /* Is linked_proc_desc_table really necessary? It only seems to be used
893 by procedure call dummys. However, the procedures being called ought
894 to have their own proc_descs, and even if they don't,
895 heuristic_proc_desc knows how to create them! */
897 register struct linked_proc_info
*link
;
898 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
899 if (PROC_LOW_ADDR (&link
->info
) <= pc
900 && PROC_HIGH_ADDR (&link
->info
) > pc
)
903 /* If PC is inside a dynamically generated sigtramp handler,
904 create and push a procedure descriptor for that code: */
905 offset
= alpha_dynamic_sigtramp_offset (pc
);
907 return push_sigtramp_desc (pc
- offset
);
909 /* If heuristic_fence_post is non-zero, determine the procedure
910 start address by examining the instructions.
911 This allows us to find the start address of static functions which
912 have no symbolic information, as startaddr would have been set to
913 the preceding global function start address by the
914 find_pc_partial_function call above. */
915 if (startaddr
== 0 || heuristic_fence_post
!= 0)
916 startaddr
= heuristic_proc_start (pc
);
919 heuristic_proc_desc (startaddr
, pc
, next_frame
);
924 alpha_extra_func_info_t cached_proc_desc
;
927 alpha_frame_chain (struct frame_info
*frame
)
929 alpha_extra_func_info_t proc_desc
;
930 CORE_ADDR saved_pc
= DEPRECATED_FRAME_SAVED_PC (frame
);
932 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
935 proc_desc
= find_proc_desc (saved_pc
, frame
);
939 cached_proc_desc
= proc_desc
;
941 /* Fetch the frame pointer for a dummy frame from the procedure
943 if (PROC_DESC_IS_DUMMY (proc_desc
))
944 return (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
946 /* If no frame pointer and frame size is zero, we must be at end
947 of stack (or otherwise hosed). If we don't check frame size,
948 we loop forever if we see a zero size frame. */
949 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
950 && PROC_FRAME_OFFSET (proc_desc
) == 0
951 /* The previous frame from a sigtramp frame might be frameless
952 and have frame size zero. */
953 && !(get_frame_type (frame
) == SIGTRAMP_FRAME
))
954 return alpha_frame_past_sigtramp_frame (frame
, saved_pc
);
956 return read_next_frame_reg (frame
, PROC_FRAME_REG (proc_desc
))
957 + PROC_FRAME_OFFSET (proc_desc
);
961 alpha_print_extra_frame_info (struct frame_info
*fi
)
964 && get_frame_extra_info (fi
)
965 && get_frame_extra_info (fi
)->proc_desc
966 && get_frame_extra_info (fi
)->proc_desc
->pdr
.framereg
< NUM_REGS
)
967 printf_filtered (" frame pointer is at %s+%s\n",
968 REGISTER_NAME (get_frame_extra_info (fi
)->proc_desc
->pdr
.framereg
),
969 paddr_d (get_frame_extra_info (fi
)->proc_desc
->pdr
.frameoffset
));
973 alpha_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
975 /* Use proc_desc calculated in frame_chain */
976 alpha_extra_func_info_t proc_desc
=
977 get_next_frame (frame
)
979 : find_proc_desc (get_frame_pc (frame
), get_next_frame (frame
));
981 frame_extra_info_zalloc (frame
, sizeof (struct frame_extra_info
));
983 /* NOTE: cagney/2003-01-03: No need to set saved_regs to NULL,
984 always NULL by default. */
985 /* frame->saved_regs = NULL; */
986 get_frame_extra_info (frame
)->localoff
= 0;
987 get_frame_extra_info (frame
)->pc_reg
= ALPHA_RA_REGNUM
;
988 get_frame_extra_info (frame
)->proc_desc
= proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
991 /* Get the locals offset and the saved pc register from the
992 procedure descriptor, they are valid even if we are in the
993 middle of the prologue. */
994 get_frame_extra_info (frame
)->localoff
= PROC_LOCALOFF (proc_desc
);
995 get_frame_extra_info (frame
)->pc_reg
= PROC_PC_REG (proc_desc
);
997 /* Fixup frame-pointer - only needed for top frame */
999 /* Fetch the frame pointer for a dummy frame from the procedure
1001 if (PROC_DESC_IS_DUMMY (proc_desc
))
1002 deprecated_update_frame_base_hack (frame
, (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
));
1004 /* This may not be quite right, if proc has a real frame register.
1005 Get the value of the frame relative sp, procedure might have been
1006 interrupted by a signal at it's very start. */
1007 else if (get_frame_pc (frame
) == PROC_LOW_ADDR (proc_desc
)
1008 && !alpha_proc_desc_is_dyn_sigtramp (proc_desc
))
1009 deprecated_update_frame_base_hack (frame
, read_next_frame_reg (get_next_frame (frame
), SP_REGNUM
));
1011 deprecated_update_frame_base_hack (frame
, read_next_frame_reg (get_next_frame (frame
), PROC_FRAME_REG (proc_desc
))
1012 + PROC_FRAME_OFFSET (proc_desc
));
1014 if (proc_desc
== &temp_proc_desc
)
1018 /* Do not set the saved registers for a sigtramp frame,
1019 alpha_find_saved_registers will do that for us. We can't
1020 use (get_frame_type (frame) == SIGTRAMP_FRAME), it is not
1022 /* FIXME: cagney/2002-11-18: This problem will go away once
1023 frame.c:get_prev_frame() is modified to set the frame's
1024 type before calling functions like this. */
1025 find_pc_partial_function (get_frame_pc (frame
), &name
,
1026 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
1027 if (!PC_IN_SIGTRAMP (get_frame_pc (frame
), name
))
1029 frame_saved_regs_zalloc (frame
);
1030 memcpy (get_frame_saved_regs (frame
), temp_saved_regs
,
1031 SIZEOF_FRAME_SAVED_REGS
);
1032 get_frame_saved_regs (frame
)[PC_REGNUM
]
1033 = get_frame_saved_regs (frame
)[ALPHA_RA_REGNUM
];
1040 alpha_frame_locals_address (struct frame_info
*fi
)
1042 return (get_frame_base (fi
) - get_frame_extra_info (fi
)->localoff
);
1046 alpha_frame_args_address (struct frame_info
*fi
)
1048 return (get_frame_base (fi
) - (ALPHA_NUM_ARG_REGS
* 8));
1051 /* ALPHA stack frames are almost impenetrable. When execution stops,
1052 we basically have to look at symbol information for the function
1053 that we stopped in, which tells us *which* register (if any) is
1054 the base of the frame pointer, and what offset from that register
1055 the frame itself is at.
1057 This presents a problem when trying to examine a stack in memory
1058 (that isn't executing at the moment), using the "frame" command. We
1059 don't have a PC, nor do we have any registers except SP.
1061 This routine takes two arguments, SP and PC, and tries to make the
1062 cached frames look as if these two arguments defined a frame on the
1063 cache. This allows the rest of info frame to extract the important
1064 arguments without difficulty. */
1067 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1070 error ("ALPHA frame specifications require two arguments: sp and pc");
1072 return create_new_frame (argv
[0], argv
[1]);
1075 /* The alpha passes the first six arguments in the registers, the rest on
1076 the stack. The register arguments are eventually transferred to the
1077 argument transfer area immediately below the stack by the called function
1078 anyway. So we `push' at least six arguments on the stack, `reload' the
1079 argument registers and then adjust the stack pointer to point past the
1080 sixth argument. This algorithm simplifies the passing of a large struct
1081 which extends from the registers to the stack.
1082 If the called function is returning a structure, the address of the
1083 structure to be returned is passed as a hidden first argument. */
1086 alpha_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1087 int struct_return
, CORE_ADDR struct_addr
)
1090 int accumulate_size
= struct_return
? 8 : 0;
1091 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
1098 struct alpha_arg
*alpha_args
=
1099 (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
1100 register struct alpha_arg
*m_arg
;
1101 char raw_buffer
[sizeof (CORE_ADDR
)];
1102 int required_arg_regs
;
1104 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
1106 struct value
*arg
= args
[i
];
1107 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1108 /* Cast argument to long if necessary as the compiler does it too. */
1109 switch (TYPE_CODE (arg_type
))
1112 case TYPE_CODE_BOOL
:
1113 case TYPE_CODE_CHAR
:
1114 case TYPE_CODE_RANGE
:
1115 case TYPE_CODE_ENUM
:
1116 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
1118 arg_type
= builtin_type_long
;
1119 arg
= value_cast (arg_type
, arg
);
1125 m_arg
->len
= TYPE_LENGTH (arg_type
);
1126 m_arg
->offset
= accumulate_size
;
1127 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
1128 m_arg
->contents
= VALUE_CONTENTS (arg
);
1131 /* Determine required argument register loads, loading an argument register
1132 is expensive as it uses three ptrace calls. */
1133 required_arg_regs
= accumulate_size
/ 8;
1134 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
1135 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
1137 /* Make room for the arguments on the stack. */
1138 if (accumulate_size
< arg_regs_size
)
1139 accumulate_size
= arg_regs_size
;
1140 sp
-= accumulate_size
;
1142 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
1145 /* `Push' arguments on the stack. */
1146 for (i
= nargs
; m_arg
--, --i
>= 0;)
1147 write_memory (sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
1150 store_address (raw_buffer
, sizeof (CORE_ADDR
), struct_addr
);
1151 write_memory (sp
, raw_buffer
, sizeof (CORE_ADDR
));
1154 /* Load the argument registers. */
1155 for (i
= 0; i
< required_arg_regs
; i
++)
1159 val
= read_memory_integer (sp
+ i
* 8, 8);
1160 write_register (ALPHA_A0_REGNUM
+ i
, val
);
1161 write_register (ALPHA_FPA0_REGNUM
+ i
, val
);
1164 return sp
+ arg_regs_size
;
1168 alpha_push_dummy_frame (void)
1171 struct linked_proc_info
*link
;
1172 alpha_extra_func_info_t proc_desc
;
1173 CORE_ADDR sp
= read_register (SP_REGNUM
);
1174 CORE_ADDR save_address
;
1175 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1178 link
= (struct linked_proc_info
*) xmalloc (sizeof (struct linked_proc_info
));
1179 link
->next
= linked_proc_desc_table
;
1180 linked_proc_desc_table
= link
;
1182 proc_desc
= &link
->info
;
1185 * The registers we must save are all those not preserved across
1187 * In addition, we must save the PC and RA.
1189 * Dummy frame layout:
1199 * Parameter build area
1203 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
1204 #define MASK(i,j) ((((LONGEST)1 << ((j)+1)) - 1) ^ (((LONGEST)1 << (i)) - 1))
1205 #define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
1206 #define GEN_REG_SAVE_COUNT 24
1207 #define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
1208 #define FLOAT_REG_SAVE_COUNT 23
1209 /* The special register is the PC as we have no bit for it in the save masks.
1210 alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
1211 #define SPECIAL_REG_SAVE_COUNT 1
1213 PROC_REG_MASK (proc_desc
) = GEN_REG_SAVE_MASK
;
1214 PROC_FREG_MASK (proc_desc
) = FLOAT_REG_SAVE_MASK
;
1215 /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
1216 but keep SP aligned to a multiple of 16. */
1217 PROC_REG_OFFSET (proc_desc
) =
1218 -((8 * (SPECIAL_REG_SAVE_COUNT
1219 + GEN_REG_SAVE_COUNT
1220 + FLOAT_REG_SAVE_COUNT
)
1222 PROC_FREG_OFFSET (proc_desc
) =
1223 PROC_REG_OFFSET (proc_desc
) + 8 * GEN_REG_SAVE_COUNT
;
1225 /* Save general registers.
1226 The return address register is the first saved register, all other
1227 registers follow in ascending order.
1228 The PC is saved immediately below the SP. */
1229 save_address
= sp
+ PROC_REG_OFFSET (proc_desc
);
1230 store_address (raw_buffer
, 8, read_register (ALPHA_RA_REGNUM
));
1231 write_memory (save_address
, raw_buffer
, 8);
1233 mask
= PROC_REG_MASK (proc_desc
) & 0xffffffffL
;
1234 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1237 if (ireg
== ALPHA_RA_REGNUM
)
1239 store_address (raw_buffer
, 8, read_register (ireg
));
1240 write_memory (save_address
, raw_buffer
, 8);
1244 store_address (raw_buffer
, 8, read_register (PC_REGNUM
));
1245 write_memory (sp
- 8, raw_buffer
, 8);
1247 /* Save floating point registers. */
1248 save_address
= sp
+ PROC_FREG_OFFSET (proc_desc
);
1249 mask
= PROC_FREG_MASK (proc_desc
) & 0xffffffffL
;
1250 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1253 store_address (raw_buffer
, 8, read_register (ireg
+ FP0_REGNUM
));
1254 write_memory (save_address
, raw_buffer
, 8);
1258 /* Set and save the frame address for the dummy.
1259 This is tricky. The only registers that are suitable for a frame save
1260 are those that are preserved across procedure calls (s0-s6). But if
1261 a read system call is interrupted and then a dummy call is made
1262 (see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
1263 is satisfied. Then it returns with the s0-s6 registers set to the values
1264 on entry to the read system call and our dummy frame pointer would be
1265 destroyed. So we save the dummy frame in the proc_desc and handle the
1266 retrieval of the frame pointer of a dummy specifically. The frame register
1267 is set to the virtual frame (pseudo) register, it's value will always
1268 be read as zero and will help us to catch any errors in the dummy frame
1270 PROC_DUMMY_FRAME (proc_desc
) = sp
;
1271 PROC_FRAME_REG (proc_desc
) = FP_REGNUM
;
1272 PROC_FRAME_OFFSET (proc_desc
) = 0;
1273 sp
+= PROC_REG_OFFSET (proc_desc
);
1274 write_register (SP_REGNUM
, sp
);
1276 PROC_LOW_ADDR (proc_desc
) = CALL_DUMMY_ADDRESS ();
1277 PROC_HIGH_ADDR (proc_desc
) = PROC_LOW_ADDR (proc_desc
) + 4;
1279 SET_PROC_DESC_IS_DUMMY (proc_desc
);
1280 PROC_PC_REG (proc_desc
) = ALPHA_RA_REGNUM
;
1284 alpha_pop_frame (void)
1286 register int regnum
;
1287 struct frame_info
*frame
= get_current_frame ();
1288 CORE_ADDR new_sp
= get_frame_base (frame
);
1290 alpha_extra_func_info_t proc_desc
= get_frame_extra_info (frame
)->proc_desc
;
1292 /* we need proc_desc to know how to restore the registers;
1293 if it is NULL, construct (a temporary) one */
1294 if (proc_desc
== NULL
)
1295 proc_desc
= find_proc_desc (get_frame_pc (frame
), get_next_frame (frame
));
1297 /* Question: should we copy this proc_desc and save it in
1298 frame->proc_desc? If we do, who will free it?
1299 For now, we don't save a copy... */
1301 write_register (PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (frame
));
1302 if (get_frame_saved_regs (frame
) == NULL
)
1303 alpha_find_saved_regs (frame
);
1306 for (regnum
= 32; --regnum
>= 0;)
1307 if (PROC_REG_MASK (proc_desc
) & (1 << regnum
))
1308 write_register (regnum
,
1309 read_memory_integer (get_frame_saved_regs (frame
)[regnum
],
1311 for (regnum
= 32; --regnum
>= 0;)
1312 if (PROC_FREG_MASK (proc_desc
) & (1 << regnum
))
1313 write_register (regnum
+ FP0_REGNUM
,
1314 read_memory_integer (get_frame_saved_regs (frame
)[regnum
+ FP0_REGNUM
], 8));
1316 write_register (SP_REGNUM
, new_sp
);
1317 flush_cached_frames ();
1319 if (proc_desc
&& (PROC_DESC_IS_DUMMY (proc_desc
)
1320 || alpha_proc_desc_is_dyn_sigtramp (proc_desc
)))
1322 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
1324 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
1326 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
1328 if (&pi_ptr
->info
== proc_desc
)
1333 error ("Can't locate dummy extra frame info\n");
1335 if (prev_ptr
!= NULL
)
1336 prev_ptr
->next
= pi_ptr
->next
;
1338 linked_proc_desc_table
= pi_ptr
->next
;
1344 /* To skip prologues, I use this predicate. Returns either PC itself
1345 if the code at PC does not look like a function prologue; otherwise
1346 returns an address that (if we're lucky) follows the prologue. If
1347 LENIENT, then we must skip everything which is involved in setting
1348 up the frame (it's OK to skip more, just so long as we don't skip
1349 anything which might clobber the registers which are being saved.
1350 Currently we must not skip more on the alpha, but we might need the
1351 lenient stuff some day. */
1354 alpha_skip_prologue_internal (CORE_ADDR pc
, int lenient
)
1358 CORE_ADDR post_prologue_pc
;
1361 /* Silently return the unaltered pc upon memory errors.
1362 This could happen on OSF/1 if decode_line_1 tries to skip the
1363 prologue for quickstarted shared library functions when the
1364 shared library is not yet mapped in.
1365 Reading target memory is slow over serial lines, so we perform
1366 this check only if the target has shared libraries (which all
1367 Alpha targets do). */
1368 if (target_read_memory (pc
, buf
, 4))
1371 /* See if we can determine the end of the prologue via the symbol table.
1372 If so, then return either PC, or the PC after the prologue, whichever
1375 post_prologue_pc
= after_prologue (pc
, NULL
);
1377 if (post_prologue_pc
!= 0)
1378 return max (pc
, post_prologue_pc
);
1380 /* Can't determine prologue from the symbol table, need to examine
1383 /* Skip the typical prologue instructions. These are the stack adjustment
1384 instruction and the instructions that save registers on the stack
1385 or in the gcc frame. */
1386 for (offset
= 0; offset
< 100; offset
+= 4)
1390 status
= read_memory_nobpt (pc
+ offset
, buf
, 4);
1392 memory_error (status
, pc
+ offset
);
1393 inst
= extract_unsigned_integer (buf
, 4);
1395 /* The alpha has no delay slots. But let's keep the lenient stuff,
1396 we might need it for something else in the future. */
1400 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
1402 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
1404 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1406 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
1409 if ((inst
& 0xfc1f0000) == 0xb41e0000
1410 && (inst
& 0xffff0000) != 0xb7fe0000)
1411 continue; /* stq reg,n($sp) */
1413 if ((inst
& 0xfc1f0000) == 0x9c1e0000
1414 && (inst
& 0xffff0000) != 0x9ffe0000)
1415 continue; /* stt reg,n($sp) */
1417 if (inst
== 0x47de040f) /* bis sp,sp,fp */
1426 alpha_skip_prologue (CORE_ADDR addr
)
1428 return (alpha_skip_prologue_internal (addr
, 0));
1432 /* Is address PC in the prologue (loosely defined) for function at
1436 alpha_in_lenient_prologue (CORE_ADDR startaddr
, CORE_ADDR pc
)
1438 CORE_ADDR end_prologue
= alpha_skip_prologue_internal (startaddr
, 1);
1439 return pc
>= startaddr
&& pc
< end_prologue
;
1443 /* The alpha needs a conversion between register and memory format if
1444 the register is a floating point register and
1445 memory format is float, as the register format must be double
1447 memory format is an integer with 4 bytes or less, as the representation
1448 of integers in floating point registers is different. */
1450 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
1451 char *raw_buffer
, char *virtual_buffer
)
1453 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1455 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
1459 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1461 double d
= extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1462 store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
1464 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1467 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1468 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
1469 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
1472 error ("Cannot retrieve value from floating point register");
1476 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
1477 char *virtual_buffer
, char *raw_buffer
)
1479 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1481 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
1485 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1487 double d
= extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
1488 store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
1490 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1493 if (TYPE_UNSIGNED (valtype
))
1494 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1496 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1497 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
1498 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
1501 error ("Cannot store value in floating point register");
1504 static const unsigned char *
1505 alpha_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1507 static const unsigned char alpha_breakpoint
[] =
1508 { 0x80, 0, 0, 0 }; /* call_pal bpt */
1510 *lenptr
= sizeof(alpha_breakpoint
);
1511 return (alpha_breakpoint
);
1514 /* Given a return value in `regbuf' with a type `valtype',
1515 extract and copy its value into `valbuf'. */
1518 alpha_extract_return_value (struct type
*valtype
,
1519 char regbuf
[ALPHA_REGISTER_BYTES
], char *valbuf
)
1521 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1522 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
1523 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
1526 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1527 TYPE_LENGTH (valtype
));
1530 /* Given a return value in `regbuf' with a type `valtype',
1531 write its value into the appropriate register. */
1534 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
1536 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1537 int regnum
= ALPHA_V0_REGNUM
;
1538 int length
= TYPE_LENGTH (valtype
);
1540 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1542 regnum
= FP0_REGNUM
;
1543 length
= REGISTER_RAW_SIZE (regnum
);
1544 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
1547 memcpy (raw_buffer
, valbuf
, length
);
1549 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
1552 /* Just like reinit_frame_cache, but with the right arguments to be
1553 callable as an sfunc. */
1556 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1558 reinit_frame_cache ();
1561 /* This is the definition of CALL_DUMMY_ADDRESS. It's a heuristic that is used
1562 to find a convenient place in the text segment to stick a breakpoint to
1563 detect the completion of a target function call (ala call_function_by_hand).
1567 alpha_call_dummy_address (void)
1570 struct minimal_symbol
*sym
;
1572 entry
= entry_point_address ();
1577 sym
= lookup_minimal_symbol ("_Prelude", NULL
, symfile_objfile
);
1579 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1582 return SYMBOL_VALUE_ADDRESS (sym
) + 4;
1586 alpha_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
1587 struct value
**args
, struct type
*type
, int gcc_p
)
1589 CORE_ADDR bp_address
= CALL_DUMMY_ADDRESS ();
1591 if (bp_address
== 0)
1592 error ("no place to put call");
1593 write_register (ALPHA_RA_REGNUM
, bp_address
);
1594 write_register (ALPHA_T12_REGNUM
, fun
);
1597 /* On the Alpha, the call dummy code is nevery copied to user space
1598 (see alpha_fix_call_dummy() above). The contents of this do not
1600 LONGEST alpha_call_dummy_words
[] = { 0 };
1603 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
1605 /* Structures are returned by ref in extra arg0. */
1610 alpha_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1612 /* Store the address of the place in which to copy the structure the
1613 subroutine will return. Handled by alpha_push_arguments. */
1617 alpha_extract_struct_value_address (char *regbuf
)
1619 return (extract_address (regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1620 REGISTER_RAW_SIZE (ALPHA_V0_REGNUM
)));
1623 /* Figure out where the longjmp will land.
1624 We expect the first arg to be a pointer to the jmp_buf structure from
1625 which we extract the PC (JB_PC) that we will land at. The PC is copied
1626 into the "pc". This routine returns true on success. */
1629 alpha_get_longjmp_target (CORE_ADDR
*pc
)
1631 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1633 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1635 jb_addr
= read_register (ALPHA_A0_REGNUM
);
1637 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* tdep
->jb_elt_size
),
1638 raw_buffer
, tdep
->jb_elt_size
))
1641 *pc
= extract_address (raw_buffer
, tdep
->jb_elt_size
);
1645 /* alpha_software_single_step() is called just before we want to resume
1646 the inferior, if we want to single-step it but there is no hardware
1647 or kernel single-step support (NetBSD on Alpha, for example). We find
1648 the target of the coming instruction and breakpoint it.
1650 single_step is also called just after the inferior stops. If we had
1651 set up a simulated single-step, we undo our damage. */
1654 alpha_next_pc (CORE_ADDR pc
)
1661 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1663 /* Opcode is top 6 bits. */
1664 op
= (insn
>> 26) & 0x3f;
1668 /* Jump format: target PC is:
1670 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1673 if ((op
& 0x30) == 0x30)
1675 /* Branch format: target PC is:
1676 (new PC) + (4 * sext(displacement)) */
1677 if (op
== 0x30 || /* BR */
1678 op
== 0x34) /* BSR */
1681 offset
= (insn
& 0x001fffff);
1682 if (offset
& 0x00100000)
1683 offset
|= 0xffe00000;
1685 return (pc
+ 4 + offset
);
1688 /* Need to determine if branch is taken; read RA. */
1689 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1692 case 0x38: /* BLBC */
1696 case 0x3c: /* BLBS */
1700 case 0x39: /* BEQ */
1704 case 0x3d: /* BNE */
1708 case 0x3a: /* BLT */
1712 case 0x3b: /* BLE */
1716 case 0x3f: /* BGT */
1720 case 0x3e: /* BGE */
1727 /* Not a branch or branch not taken; target PC is:
1733 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1735 static CORE_ADDR next_pc
;
1736 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1737 static binsn_quantum break_mem
;
1740 if (insert_breakpoints_p
)
1743 next_pc
= alpha_next_pc (pc
);
1745 target_insert_breakpoint (next_pc
, break_mem
);
1749 target_remove_breakpoint (next_pc
, break_mem
);
1756 /* Initialize the current architecture based on INFO. If possible, re-use an
1757 architecture from ARCHES, which is a list of architectures already created
1758 during this debugging session.
1760 Called e.g. at program startup, when reading a core file, and when reading
1763 static struct gdbarch
*
1764 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1766 struct gdbarch_tdep
*tdep
;
1767 struct gdbarch
*gdbarch
;
1769 /* Try to determine the ABI of the object we are loading. */
1770 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
1772 /* If it's an ECOFF file, assume it's OSF/1. */
1773 if (bfd_get_flavour (info
.abfd
) == bfd_target_ecoff_flavour
)
1774 info
.osabi
= GDB_OSABI_OSF1
;
1777 /* Find a candidate among extant architectures. */
1778 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1780 return arches
->gdbarch
;
1782 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1783 gdbarch
= gdbarch_alloc (&info
, tdep
);
1785 /* Lowest text address. This is used by heuristic_proc_start() to
1786 decide when to stop looking. */
1787 tdep
->vm_min_address
= (CORE_ADDR
) 0x120000000;
1789 tdep
->dynamic_sigtramp_offset
= NULL
;
1790 tdep
->skip_sigtramp_frame
= NULL
;
1791 tdep
->sigcontext_addr
= NULL
;
1793 tdep
->jb_pc
= -1; /* longjmp support not enabled by default */
1796 set_gdbarch_short_bit (gdbarch
, 16);
1797 set_gdbarch_int_bit (gdbarch
, 32);
1798 set_gdbarch_long_bit (gdbarch
, 64);
1799 set_gdbarch_long_long_bit (gdbarch
, 64);
1800 set_gdbarch_float_bit (gdbarch
, 32);
1801 set_gdbarch_double_bit (gdbarch
, 64);
1802 set_gdbarch_long_double_bit (gdbarch
, 64);
1803 set_gdbarch_ptr_bit (gdbarch
, 64);
1806 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1807 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1808 set_gdbarch_fp_regnum (gdbarch
, ALPHA_FP_REGNUM
);
1809 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1810 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1812 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1813 set_gdbarch_register_size (gdbarch
, ALPHA_REGISTER_SIZE
);
1814 set_gdbarch_register_bytes (gdbarch
, ALPHA_REGISTER_BYTES
);
1815 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1816 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1817 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, ALPHA_MAX_REGISTER_RAW_SIZE
);
1818 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1819 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
,
1820 ALPHA_MAX_REGISTER_VIRTUAL_SIZE
);
1821 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1823 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1824 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1826 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1827 set_gdbarch_register_convert_to_virtual (gdbarch
,
1828 alpha_register_convert_to_virtual
);
1829 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1831 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
1833 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1834 set_gdbarch_frameless_function_invocation (gdbarch
,
1835 generic_frameless_function_invocation_not
);
1837 set_gdbarch_saved_pc_after_call (gdbarch
, alpha_saved_pc_after_call
);
1839 set_gdbarch_deprecated_frame_chain (gdbarch
, alpha_frame_chain
);
1840 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, alpha_frame_saved_pc
);
1842 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, alpha_frame_init_saved_regs
);
1844 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
1845 set_gdbarch_deprecated_extract_return_value (gdbarch
, alpha_extract_return_value
);
1847 set_gdbarch_deprecated_store_struct_return (gdbarch
, alpha_store_struct_return
);
1848 set_gdbarch_deprecated_store_return_value (gdbarch
, alpha_store_return_value
);
1849 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1850 alpha_extract_struct_value_address
);
1852 /* Settings for calling functions in the inferior. */
1853 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
1854 set_gdbarch_deprecated_push_arguments (gdbarch
, alpha_push_arguments
);
1855 set_gdbarch_deprecated_pop_frame (gdbarch
, alpha_pop_frame
);
1857 /* On the Alpha, the call dummy code is never copied to user space,
1858 stopping the user call is achieved via a bp_call_dummy breakpoint.
1859 But we need a fake CALL_DUMMY definition to enable the proper
1860 call_function_by_hand and to avoid zero length array warnings. */
1861 set_gdbarch_call_dummy_words (gdbarch
, alpha_call_dummy_words
);
1862 set_gdbarch_sizeof_call_dummy_words (gdbarch
, 0);
1863 set_gdbarch_frame_args_address (gdbarch
, alpha_frame_args_address
);
1864 set_gdbarch_frame_locals_address (gdbarch
, alpha_frame_locals_address
);
1865 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, alpha_init_extra_frame_info
);
1867 /* Alpha OSF/1 inhibits execution of code on the stack. But there is
1868 no need for a dummy on the Alpha. PUSH_ARGUMENTS takes care of all
1869 argument handling and bp_call_dummy takes care of stopping the dummy. */
1870 set_gdbarch_call_dummy_address (gdbarch
, alpha_call_dummy_address
);
1871 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1872 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, alpha_push_dummy_frame
);
1873 /* Should be using push_dummy_call. */
1874 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, generic_target_write_sp
);
1875 set_gdbarch_fix_call_dummy (gdbarch
, alpha_fix_call_dummy
);
1876 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_noop
);
1877 set_gdbarch_deprecated_init_frame_pc_first (gdbarch
, alpha_init_frame_pc_first
);
1879 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1880 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1882 set_gdbarch_breakpoint_from_pc (gdbarch
, alpha_breakpoint_from_pc
);
1883 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
1885 set_gdbarch_function_start_offset (gdbarch
, 0);
1886 set_gdbarch_frame_args_skip (gdbarch
, 0);
1888 /* Hook in ABI-specific overrides, if they have been registered. */
1889 gdbarch_init_osabi (info
, gdbarch
);
1891 /* Now that we have tuned the configuration, set a few final things
1892 based on what the OS ABI has told us. */
1894 if (tdep
->jb_pc
>= 0)
1895 set_gdbarch_get_longjmp_target (gdbarch
, alpha_get_longjmp_target
);
1901 alpha_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1903 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1908 fprintf_unfiltered (file
,
1909 "alpha_dump_tdep: vm_min_address = 0x%lx\n",
1910 (long) tdep
->vm_min_address
);
1912 fprintf_unfiltered (file
,
1913 "alpha_dump_tdep: jb_pc = %d\n",
1915 fprintf_unfiltered (file
,
1916 "alpha_dump_tdep: jb_elt_size = %ld\n",
1917 (long) tdep
->jb_elt_size
);
1921 _initialize_alpha_tdep (void)
1923 struct cmd_list_element
*c
;
1925 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, alpha_dump_tdep
);
1927 tm_print_insn
= print_insn_alpha
;
1929 /* Let the user set the fence post for heuristic_proc_start. */
1931 /* We really would like to have both "0" and "unlimited" work, but
1932 command.c doesn't deal with that. So make it a var_zinteger
1933 because the user can always use "999999" or some such for unlimited. */
1934 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1935 (char *) &heuristic_fence_post
,
1937 Set the distance searched for the start of a function.\n\
1938 If you are debugging a stripped executable, GDB needs to search through the\n\
1939 program for the start of a function. This command sets the distance of the\n\
1940 search. The only need to set it is when debugging a stripped executable.",
1942 /* We need to throw away the frame cache when we set this, since it
1943 might change our ability to get backtraces. */
1944 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
1945 add_show_from_set (c
, &showlist
);