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
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"
40 #include "alpha-tdep.h"
42 static gdbarch_init_ftype alpha_gdbarch_init
;
44 static gdbarch_register_name_ftype alpha_register_name
;
45 static gdbarch_register_raw_size_ftype alpha_register_raw_size
;
46 static gdbarch_register_virtual_size_ftype alpha_register_virtual_size
;
47 static gdbarch_register_virtual_type_ftype alpha_register_virtual_type
;
48 static gdbarch_register_byte_ftype alpha_register_byte
;
49 static gdbarch_cannot_fetch_register_ftype alpha_cannot_fetch_register
;
50 static gdbarch_cannot_store_register_ftype alpha_cannot_store_register
;
51 static gdbarch_register_convertible_ftype alpha_register_convertible
;
52 static gdbarch_register_convert_to_virtual_ftype
53 alpha_register_convert_to_virtual
;
54 static gdbarch_register_convert_to_raw_ftype alpha_register_convert_to_raw
;
55 static gdbarch_store_struct_return_ftype alpha_store_struct_return
;
56 static gdbarch_extract_return_value_ftype alpha_extract_return_value
;
57 static gdbarch_store_return_value_ftype alpha_store_return_value
;
58 static gdbarch_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_frame_args_address_ftype alpha_frame_args_address
;
63 static gdbarch_frame_locals_address_ftype alpha_frame_locals_address
;
65 static gdbarch_skip_prologue_ftype alpha_skip_prologue
;
66 static gdbarch_get_saved_register_ftype alpha_get_saved_register
;
67 static gdbarch_saved_pc_after_call_ftype alpha_saved_pc_after_call
;
68 static gdbarch_frame_chain_ftype alpha_frame_chain
;
69 static gdbarch_frame_saved_pc_ftype alpha_frame_saved_pc
;
70 static gdbarch_frame_init_saved_regs_ftype alpha_frame_init_saved_regs
;
72 static gdbarch_push_arguments_ftype alpha_push_arguments
;
73 static gdbarch_push_dummy_frame_ftype alpha_push_dummy_frame
;
74 static gdbarch_pop_frame_ftype alpha_pop_frame
;
75 static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy
;
76 static gdbarch_init_frame_pc_first_ftype alpha_init_frame_pc_first
;
77 static gdbarch_init_extra_frame_info_ftype alpha_init_extra_frame_info
;
79 struct frame_extra_info
81 alpha_extra_func_info_t proc_desc
;
86 /* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
88 /* Prototypes for local functions. */
90 static void alpha_find_saved_regs (struct frame_info
*);
92 static alpha_extra_func_info_t
push_sigtramp_desc (CORE_ADDR low_addr
);
94 static CORE_ADDR
read_next_frame_reg (struct frame_info
*, int);
96 static CORE_ADDR
heuristic_proc_start (CORE_ADDR
);
98 static alpha_extra_func_info_t
heuristic_proc_desc (CORE_ADDR
,
100 struct frame_info
*);
102 static alpha_extra_func_info_t
find_proc_desc (CORE_ADDR
,
103 struct frame_info
*);
106 static int alpha_in_lenient_prologue (CORE_ADDR
, CORE_ADDR
);
109 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element
*);
111 static CORE_ADDR
after_prologue (CORE_ADDR pc
,
112 alpha_extra_func_info_t proc_desc
);
114 static int alpha_in_prologue (CORE_ADDR pc
,
115 alpha_extra_func_info_t proc_desc
);
117 static int alpha_about_to_return (CORE_ADDR pc
);
119 void _initialize_alpha_tdep (void);
121 /* Heuristic_proc_start may hunt through the text section for a long
122 time across a 2400 baud serial line. Allows the user to limit this
124 static unsigned int heuristic_fence_post
= 0;
126 /* Layout of a stack frame on the alpha:
129 pdr members: | 7th ... nth arg, |
130 | `pushed' by caller. |
132 ----------------|-------------------------------|<-- old_sp == vfp
135 | |localoff | Copies of 1st .. 6th |
136 | | | | | argument if necessary. |
138 | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS
140 | | | | Locals and temporaries. |
142 | | | |-------------------------------|
144 |-fregoffset | Saved float registers. |
150 | | -------|-------------------------------|
152 | | | Saved registers. |
159 | ----------|-------------------------------|
161 frameoffset | Argument build area, gets |
162 | | 7th ... nth arg for any |
163 | | called procedure. |
165 -------------|-------------------------------|<-- sp
172 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
173 /* These next two fields are kind of being hijacked. I wonder if
174 iline is too small for the values it needs to hold, if GDB is
175 running on a 32-bit host. */
176 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
177 #define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset) /*CALL_DUMMY frame */
178 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
179 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
180 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
181 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
182 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
183 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
184 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
185 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
186 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
187 #define _PROC_MAGIC_ 0x0F0F0F0F
188 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
189 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
191 struct linked_proc_info
193 struct alpha_extra_func_info info
;
194 struct linked_proc_info
*next
;
196 *linked_proc_desc_table
= NULL
;
199 alpha_osf_in_sigtramp (CORE_ADDR pc
, char *func_name
)
201 return (func_name
!= NULL
&& STREQ ("__sigtramp", func_name
));
204 /* Under GNU/Linux, signal handler invocations can be identified by the
205 designated code sequence that is used to return from a signal
206 handler. In particular, the return address of a signal handler
207 points to the following sequence (the first instruction is quadword
214 Each instruction has a unique encoding, so we simply attempt to
215 match the instruction the pc is pointing to with any of the above
216 instructions. If there is a hit, we know the offset to the start
217 of the designated sequence and can then check whether we really are
218 executing in a designated sequence. If not, -1 is returned,
219 otherwise the offset from the start of the desingated sequence is
222 There is a slight chance of false hits: code could jump into the
223 middle of the designated sequence, in which case there is no
224 guarantee that we are in the middle of a sigreturn syscall. Don't
225 think this will be a problem in praxis, though.
228 #ifndef TM_LINUXALPHA_H
229 /* HACK: Provide a prototype when compiling this file for non
230 linuxalpha targets. */
231 long alpha_linux_sigtramp_offset (CORE_ADDR pc
);
234 alpha_linux_sigtramp_offset (CORE_ADDR pc
)
236 unsigned int i
[3], w
;
239 if (read_memory_nobpt (pc
, (char *) &w
, 4) != 0)
247 break; /* bis $30,$30,$16 */
250 break; /* addq $31,0x67,$0 */
253 break; /* call_pal callsys */
260 /* designated sequence is not quadword aligned */
264 if (read_memory_nobpt (pc
, (char *) i
, sizeof (i
)) != 0)
267 if (i
[0] == 0x47de0410 && i
[1] == 0x43ecf400 && i
[2] == 0x00000083)
274 /* Under OSF/1, the __sigtramp routine is frameless and has a frame
275 size of zero, but we are able to backtrace through it. */
277 alpha_osf_skip_sigtramp_frame (struct frame_info
*frame
, CORE_ADDR pc
)
280 find_pc_partial_function (pc
, &name
, (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
281 if (IN_SIGTRAMP (pc
, name
))
288 /* Dynamically create a signal-handler caller procedure descriptor for
289 the signal-handler return code starting at address LOW_ADDR. The
290 descriptor is added to the linked_proc_desc_table. */
292 static alpha_extra_func_info_t
293 push_sigtramp_desc (CORE_ADDR low_addr
)
295 struct linked_proc_info
*link
;
296 alpha_extra_func_info_t proc_desc
;
298 link
= (struct linked_proc_info
*)
299 xmalloc (sizeof (struct linked_proc_info
));
300 link
->next
= linked_proc_desc_table
;
301 linked_proc_desc_table
= link
;
303 proc_desc
= &link
->info
;
305 proc_desc
->numargs
= 0;
306 PROC_LOW_ADDR (proc_desc
) = low_addr
;
307 PROC_HIGH_ADDR (proc_desc
) = low_addr
+ 3 * 4;
308 PROC_DUMMY_FRAME (proc_desc
) = 0;
309 PROC_FRAME_OFFSET (proc_desc
) = 0x298; /* sizeof(struct sigcontext_struct) */
310 PROC_FRAME_REG (proc_desc
) = SP_REGNUM
;
311 PROC_REG_MASK (proc_desc
) = 0xffff;
312 PROC_FREG_MASK (proc_desc
) = 0xffff;
313 PROC_PC_REG (proc_desc
) = 26;
314 PROC_LOCALOFF (proc_desc
) = 0;
315 SET_PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
);
321 alpha_register_name (int regno
)
323 static char *register_names
[] =
325 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
326 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
327 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
328 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
329 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
330 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
331 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
332 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
338 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
340 return (register_names
[regno
]);
344 alpha_cannot_fetch_register (int regno
)
346 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
350 alpha_cannot_store_register (int regno
)
352 return (regno
== FP_REGNUM
|| regno
== ALPHA_ZERO_REGNUM
);
356 alpha_register_convertible (int regno
)
358 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
362 alpha_register_virtual_type (int regno
)
364 return ((regno
>= FP0_REGNUM
&& regno
< (FP0_REGNUM
+31))
365 ? builtin_type_double
: builtin_type_long
);
369 alpha_register_byte (int regno
)
375 alpha_register_raw_size (int regno
)
381 alpha_register_virtual_size (int regno
)
387 /* Guaranteed to set frame->saved_regs to some values (it never leaves it
391 alpha_find_saved_regs (struct frame_info
*frame
)
394 CORE_ADDR reg_position
;
396 alpha_extra_func_info_t proc_desc
;
399 frame_saved_regs_zalloc (frame
);
401 /* If it is the frame for __sigtramp, the saved registers are located
402 in a sigcontext structure somewhere on the stack. __sigtramp
403 passes a pointer to the sigcontext structure on the stack.
404 If the stack layout for __sigtramp changes, or if sigcontext offsets
405 change, we might have to update this code. */
406 #ifndef SIGFRAME_PC_OFF
407 #define SIGFRAME_PC_OFF (2 * 8)
408 #define SIGFRAME_REGSAVE_OFF (4 * 8)
409 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
411 if (frame
->signal_handler_caller
)
413 CORE_ADDR sigcontext_addr
;
415 sigcontext_addr
= SIGCONTEXT_ADDR (frame
);
416 for (ireg
= 0; ireg
< 32; ireg
++)
418 reg_position
= sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ ireg
* 8;
419 frame
->saved_regs
[ireg
] = reg_position
;
421 for (ireg
= 0; ireg
< 32; ireg
++)
423 reg_position
= sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ ireg
* 8;
424 frame
->saved_regs
[FP0_REGNUM
+ ireg
] = reg_position
;
426 frame
->saved_regs
[PC_REGNUM
] = sigcontext_addr
+ SIGFRAME_PC_OFF
;
430 proc_desc
= frame
->extra_info
->proc_desc
;
431 if (proc_desc
== NULL
)
432 /* I'm not sure how/whether this can happen. Normally when we can't
433 find a proc_desc, we "synthesize" one using heuristic_proc_desc
434 and set the saved_regs right away. */
437 /* Fill in the offsets for the registers which gen_mask says
440 reg_position
= frame
->frame
+ PROC_REG_OFFSET (proc_desc
);
441 mask
= PROC_REG_MASK (proc_desc
);
443 returnreg
= PROC_PC_REG (proc_desc
);
445 /* Note that RA is always saved first, regardless of its actual
447 if (mask
& (1 << returnreg
))
449 frame
->saved_regs
[returnreg
] = reg_position
;
451 mask
&= ~(1 << returnreg
); /* Clear bit for RA so we
452 don't save again later. */
455 for (ireg
= 0; ireg
<= 31; ++ireg
)
456 if (mask
& (1 << ireg
))
458 frame
->saved_regs
[ireg
] = reg_position
;
462 /* Fill in the offsets for the registers which float_mask says
465 reg_position
= frame
->frame
+ PROC_FREG_OFFSET (proc_desc
);
466 mask
= PROC_FREG_MASK (proc_desc
);
468 for (ireg
= 0; ireg
<= 31; ++ireg
)
469 if (mask
& (1 << ireg
))
471 frame
->saved_regs
[FP0_REGNUM
+ ireg
] = reg_position
;
475 frame
->saved_regs
[PC_REGNUM
] = frame
->saved_regs
[returnreg
];
479 alpha_frame_init_saved_regs (struct frame_info
*fi
)
481 if (fi
->saved_regs
== NULL
)
482 alpha_find_saved_regs (fi
);
483 fi
->saved_regs
[SP_REGNUM
] = fi
->frame
;
487 alpha_init_frame_pc_first (int fromleaf
, struct frame_info
*prev
)
489 prev
->pc
= (fromleaf
? SAVED_PC_AFTER_CALL (prev
->next
) :
490 prev
->next
? FRAME_SAVED_PC (prev
->next
) : read_pc ());
494 read_next_frame_reg (struct frame_info
*fi
, int regno
)
496 for (; fi
; fi
= fi
->next
)
498 /* We have to get the saved sp from the sigcontext
499 if it is a signal handler frame. */
500 if (regno
== SP_REGNUM
&& !fi
->signal_handler_caller
)
504 if (fi
->saved_regs
== NULL
)
505 alpha_find_saved_regs (fi
);
506 if (fi
->saved_regs
[regno
])
507 return read_memory_integer (fi
->saved_regs
[regno
], 8);
510 return read_register (regno
);
514 alpha_frame_saved_pc (struct frame_info
*frame
)
516 alpha_extra_func_info_t proc_desc
= frame
->extra_info
->proc_desc
;
517 /* We have to get the saved pc from the sigcontext
518 if it is a signal handler frame. */
519 int pcreg
= frame
->signal_handler_caller
? PC_REGNUM
520 : frame
->extra_info
->pc_reg
;
522 if (proc_desc
&& PROC_DESC_IS_DUMMY (proc_desc
))
523 return read_memory_integer (frame
->frame
- 8, 8);
525 return read_next_frame_reg (frame
, pcreg
);
529 alpha_get_saved_register (char *raw_buffer
,
532 struct frame_info
*frame
,
534 enum lval_type
*lval
)
538 if (!target_has_registers
)
539 error ("No registers.");
541 /* Normal systems don't optimize out things with register numbers. */
542 if (optimized
!= NULL
)
544 addr
= find_saved_register (frame
, regnum
);
549 if (regnum
== SP_REGNUM
)
551 if (raw_buffer
!= NULL
)
553 /* Put it back in target format. */
554 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
561 if (raw_buffer
!= NULL
)
562 target_read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
567 *lval
= lval_register
;
568 addr
= REGISTER_BYTE (regnum
);
569 if (raw_buffer
!= NULL
)
570 read_register_gen (regnum
, raw_buffer
);
577 alpha_saved_pc_after_call (struct frame_info
*frame
)
579 CORE_ADDR pc
= frame
->pc
;
581 alpha_extra_func_info_t proc_desc
;
584 /* Skip over shared library trampoline if necessary. */
585 tmp
= SKIP_TRAMPOLINE_CODE (pc
);
589 proc_desc
= find_proc_desc (pc
, frame
->next
);
590 pcreg
= proc_desc
? PROC_PC_REG (proc_desc
) : ALPHA_RA_REGNUM
;
592 if (frame
->signal_handler_caller
)
593 return alpha_frame_saved_pc (frame
);
595 return read_register (pcreg
);
599 static struct alpha_extra_func_info temp_proc_desc
;
600 static CORE_ADDR temp_saved_regs
[ALPHA_NUM_REGS
];
602 /* Nonzero if instruction at PC is a return instruction. "ret
603 $zero,($ra),1" on alpha. */
606 alpha_about_to_return (CORE_ADDR pc
)
608 return read_memory_integer (pc
, 4) == 0x6bfa8001;
613 /* This fencepost looks highly suspicious to me. Removing it also
614 seems suspicious as it could affect remote debugging across serial
618 heuristic_proc_start (CORE_ADDR pc
)
620 CORE_ADDR start_pc
= pc
;
621 CORE_ADDR fence
= start_pc
- heuristic_fence_post
;
626 if (heuristic_fence_post
== UINT_MAX
627 || fence
< VM_MIN_ADDRESS
)
628 fence
= VM_MIN_ADDRESS
;
630 /* search back for previous return */
631 for (start_pc
-= 4;; start_pc
-= 4)
632 if (start_pc
< fence
)
634 /* It's not clear to me why we reach this point when
635 stop_soon_quietly, but with this test, at least we
636 don't print out warnings for every child forked (eg, on
637 decstation). 22apr93 rich@cygnus.com. */
638 if (!stop_soon_quietly
)
640 static int blurb_printed
= 0;
642 if (fence
== VM_MIN_ADDRESS
)
643 warning ("Hit beginning of text section without finding");
645 warning ("Hit heuristic-fence-post without finding");
647 warning ("enclosing function for address 0x%s", paddr_nz (pc
));
651 This warning occurs if you are debugging a function without any symbols\n\
652 (for example, in a stripped executable). In that case, you may wish to\n\
653 increase the size of the search with the `set heuristic-fence-post' command.\n\
655 Otherwise, you told GDB there was a function where there isn't one, or\n\
656 (more likely) you have encountered a bug in GDB.\n");
663 else if (alpha_about_to_return (start_pc
))
666 start_pc
+= 4; /* skip return */
670 static alpha_extra_func_info_t
671 heuristic_proc_desc (CORE_ADDR start_pc
, CORE_ADDR limit_pc
,
672 struct frame_info
*next_frame
)
674 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
677 int has_frame_reg
= 0;
678 unsigned long reg_mask
= 0;
683 memset (&temp_proc_desc
, '\0', sizeof (temp_proc_desc
));
684 memset (&temp_saved_regs
, '\0', SIZEOF_FRAME_SAVED_REGS
);
685 PROC_LOW_ADDR (&temp_proc_desc
) = start_pc
;
687 if (start_pc
+ 200 < limit_pc
)
688 limit_pc
= start_pc
+ 200;
690 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
696 status
= read_memory_nobpt (cur_pc
, buf
, 4);
698 memory_error (status
, cur_pc
);
699 word
= extract_unsigned_integer (buf
, 4);
701 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
704 frame_size
+= (-word
) & 0xffff;
706 /* Exit loop if a positive stack adjustment is found, which
707 usually means that the stack cleanup code in the function
708 epilogue is reached. */
711 else if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
712 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
714 int reg
= (word
& 0x03e00000) >> 21;
715 reg_mask
|= 1 << reg
;
716 temp_saved_regs
[reg
] = sp
+ (short) word
;
718 /* Starting with OSF/1-3.2C, the system libraries are shipped
719 without local symbols, but they still contain procedure
720 descriptors without a symbol reference. GDB is currently
721 unable to find these procedure descriptors and uses
722 heuristic_proc_desc instead.
723 As some low level compiler support routines (__div*, __add*)
724 use a non-standard return address register, we have to
725 add some heuristics to determine the return address register,
726 or stepping over these routines will fail.
727 Usually the return address register is the first register
728 saved on the stack, but assembler optimization might
729 rearrange the register saves.
730 So we recognize only a few registers (t7, t9, ra) within
731 the procedure prologue as valid return address registers.
732 If we encounter a return instruction, we extract the
733 the return address register from it.
735 FIXME: Rewriting GDB to access the procedure descriptors,
736 e.g. via the minimal symbol table, might obviate this hack. */
738 && cur_pc
< (start_pc
+ 80)
739 && (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
740 || reg
== ALPHA_RA_REGNUM
))
743 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
744 pcreg
= (word
>> 16) & 0x1f;
745 else if (word
== 0x47de040f) /* bis sp,sp fp */
750 /* If we haven't found a valid return address register yet,
751 keep searching in the procedure prologue. */
752 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
757 if (read_memory_nobpt (cur_pc
, buf
, 4))
760 word
= extract_unsigned_integer (buf
, 4);
762 if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
763 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
765 int reg
= (word
& 0x03e00000) >> 21;
766 if (reg
== ALPHA_T7_REGNUM
|| reg
== ALPHA_T9_REGNUM
767 || reg
== ALPHA_RA_REGNUM
)
773 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
775 pcreg
= (word
>> 16) & 0x1f;
782 PROC_FRAME_REG (&temp_proc_desc
) = ALPHA_GCC_FP_REGNUM
;
784 PROC_FRAME_REG (&temp_proc_desc
) = SP_REGNUM
;
785 PROC_FRAME_OFFSET (&temp_proc_desc
) = frame_size
;
786 PROC_REG_MASK (&temp_proc_desc
) = reg_mask
;
787 PROC_PC_REG (&temp_proc_desc
) = (pcreg
== -1) ? ALPHA_RA_REGNUM
: pcreg
;
788 PROC_LOCALOFF (&temp_proc_desc
) = 0; /* XXX - bogus */
789 return &temp_proc_desc
;
792 /* This returns the PC of the first inst after the prologue. If we can't
793 find the prologue, then return 0. */
796 after_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
798 struct symtab_and_line sal
;
799 CORE_ADDR func_addr
, func_end
;
802 proc_desc
= find_proc_desc (pc
, NULL
);
806 if (PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
))
807 return PROC_LOW_ADDR (proc_desc
); /* "prologue" is in kernel */
809 /* If function is frameless, then we need to do it the hard way. I
810 strongly suspect that frameless always means prologueless... */
811 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
812 && PROC_FRAME_OFFSET (proc_desc
) == 0)
816 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
817 return 0; /* Unknown */
819 sal
= find_pc_line (func_addr
, 0);
821 if (sal
.end
< func_end
)
824 /* The line after the prologue is after the end of the function. In this
825 case, tell the caller to find the prologue the hard way. */
830 /* Return non-zero if we *might* be in a function prologue. Return zero if we
831 are definitively *not* in a function prologue. */
834 alpha_in_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
836 CORE_ADDR after_prologue_pc
;
838 after_prologue_pc
= after_prologue (pc
, proc_desc
);
840 if (after_prologue_pc
== 0
841 || pc
< after_prologue_pc
)
847 static alpha_extra_func_info_t
848 find_proc_desc (CORE_ADDR pc
, struct frame_info
*next_frame
)
850 alpha_extra_func_info_t proc_desc
;
855 /* Try to get the proc_desc from the linked call dummy proc_descs
856 if the pc is in the call dummy.
857 This is hairy. In the case of nested dummy calls we have to find the
858 right proc_desc, but we might not yet know the frame for the dummy
859 as it will be contained in the proc_desc we are searching for.
860 So we have to find the proc_desc whose frame is closest to the current
863 if (PC_IN_CALL_DUMMY (pc
, 0, 0))
865 struct linked_proc_info
*link
;
866 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
867 alpha_extra_func_info_t found_proc_desc
= NULL
;
868 long min_distance
= LONG_MAX
;
870 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
872 long distance
= (CORE_ADDR
) PROC_DUMMY_FRAME (&link
->info
) - sp
;
873 if (distance
> 0 && distance
< min_distance
)
875 min_distance
= distance
;
876 found_proc_desc
= &link
->info
;
879 if (found_proc_desc
!= NULL
)
880 return found_proc_desc
;
883 b
= block_for_pc (pc
);
885 find_pc_partial_function (pc
, NULL
, &startaddr
, NULL
);
890 if (startaddr
> BLOCK_START (b
))
891 /* This is the "pathological" case referred to in a comment in
892 print_frame_info. It might be better to move this check into
896 sym
= lookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
,
900 /* If we never found a PDR for this function in symbol reading, then
901 examine prologues to find the information. */
902 if (sym
&& ((mips_extra_func_info_t
) SYMBOL_VALUE (sym
))->pdr
.framereg
== -1)
907 /* IF this is the topmost frame AND
908 * (this proc does not have debugging information OR
909 * the PC is in the procedure prologue)
910 * THEN create a "heuristic" proc_desc (by analyzing
911 * the actual code) to replace the "official" proc_desc.
913 proc_desc
= (alpha_extra_func_info_t
) SYMBOL_VALUE (sym
);
914 if (next_frame
== NULL
)
916 if (PROC_DESC_IS_DUMMY (proc_desc
) || alpha_in_prologue (pc
, proc_desc
))
918 alpha_extra_func_info_t found_heuristic
=
919 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc
),
923 PROC_LOCALOFF (found_heuristic
) =
924 PROC_LOCALOFF (proc_desc
);
925 PROC_PC_REG (found_heuristic
) = PROC_PC_REG (proc_desc
);
926 proc_desc
= found_heuristic
;
935 /* Is linked_proc_desc_table really necessary? It only seems to be used
936 by procedure call dummys. However, the procedures being called ought
937 to have their own proc_descs, and even if they don't,
938 heuristic_proc_desc knows how to create them! */
940 register struct linked_proc_info
*link
;
941 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
942 if (PROC_LOW_ADDR (&link
->info
) <= pc
943 && PROC_HIGH_ADDR (&link
->info
) > pc
)
946 /* If PC is inside a dynamically generated sigtramp handler,
947 create and push a procedure descriptor for that code: */
948 offset
= DYNAMIC_SIGTRAMP_OFFSET (pc
);
950 return push_sigtramp_desc (pc
- offset
);
952 /* If heuristic_fence_post is non-zero, determine the procedure
953 start address by examining the instructions.
954 This allows us to find the start address of static functions which
955 have no symbolic information, as startaddr would have been set to
956 the preceding global function start address by the
957 find_pc_partial_function call above. */
958 if (startaddr
== 0 || heuristic_fence_post
!= 0)
959 startaddr
= heuristic_proc_start (pc
);
962 heuristic_proc_desc (startaddr
, pc
, next_frame
);
967 alpha_extra_func_info_t cached_proc_desc
;
970 alpha_frame_chain (struct frame_info
*frame
)
972 alpha_extra_func_info_t proc_desc
;
973 CORE_ADDR saved_pc
= FRAME_SAVED_PC (frame
);
975 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
978 proc_desc
= find_proc_desc (saved_pc
, frame
);
982 cached_proc_desc
= proc_desc
;
984 /* Fetch the frame pointer for a dummy frame from the procedure
986 if (PROC_DESC_IS_DUMMY (proc_desc
))
987 return (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
989 /* If no frame pointer and frame size is zero, we must be at end
990 of stack (or otherwise hosed). If we don't check frame size,
991 we loop forever if we see a zero size frame. */
992 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
993 && PROC_FRAME_OFFSET (proc_desc
) == 0
994 /* The previous frame from a sigtramp frame might be frameless
995 and have frame size zero. */
996 && !frame
->signal_handler_caller
)
997 return FRAME_PAST_SIGTRAMP_FRAME (frame
, saved_pc
);
999 return read_next_frame_reg (frame
, PROC_FRAME_REG (proc_desc
))
1000 + PROC_FRAME_OFFSET (proc_desc
);
1004 alpha_print_extra_frame_info (struct frame_info
*fi
)
1008 && fi
->extra_info
->proc_desc
1009 && fi
->extra_info
->proc_desc
->pdr
.framereg
< NUM_REGS
)
1010 printf_filtered (" frame pointer is at %s+%s\n",
1011 REGISTER_NAME (fi
->extra_info
->proc_desc
->pdr
.framereg
),
1012 paddr_d (fi
->extra_info
->proc_desc
->pdr
.frameoffset
));
1016 alpha_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
1018 /* Use proc_desc calculated in frame_chain */
1019 alpha_extra_func_info_t proc_desc
=
1020 frame
->next
? cached_proc_desc
: find_proc_desc (frame
->pc
, frame
->next
);
1022 frame
->extra_info
= (struct frame_extra_info
*)
1023 frame_obstack_alloc (sizeof (struct frame_extra_info
));
1025 frame
->saved_regs
= NULL
;
1026 frame
->extra_info
->localoff
= 0;
1027 frame
->extra_info
->pc_reg
= ALPHA_RA_REGNUM
;
1028 frame
->extra_info
->proc_desc
= proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
1031 /* Get the locals offset and the saved pc register from the
1032 procedure descriptor, they are valid even if we are in the
1033 middle of the prologue. */
1034 frame
->extra_info
->localoff
= PROC_LOCALOFF (proc_desc
);
1035 frame
->extra_info
->pc_reg
= PROC_PC_REG (proc_desc
);
1037 /* Fixup frame-pointer - only needed for top frame */
1039 /* Fetch the frame pointer for a dummy frame from the procedure
1041 if (PROC_DESC_IS_DUMMY (proc_desc
))
1042 frame
->frame
= (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
1044 /* This may not be quite right, if proc has a real frame register.
1045 Get the value of the frame relative sp, procedure might have been
1046 interrupted by a signal at it's very start. */
1047 else if (frame
->pc
== PROC_LOW_ADDR (proc_desc
)
1048 && !PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
))
1049 frame
->frame
= read_next_frame_reg (frame
->next
, SP_REGNUM
);
1051 frame
->frame
= read_next_frame_reg (frame
->next
, PROC_FRAME_REG (proc_desc
))
1052 + PROC_FRAME_OFFSET (proc_desc
);
1054 if (proc_desc
== &temp_proc_desc
)
1058 /* Do not set the saved registers for a sigtramp frame,
1059 alpha_find_saved_registers will do that for us.
1060 We can't use frame->signal_handler_caller, it is not yet set. */
1061 find_pc_partial_function (frame
->pc
, &name
,
1062 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
1063 if (!IN_SIGTRAMP (frame
->pc
, name
))
1065 frame
->saved_regs
= (CORE_ADDR
*)
1066 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS
);
1067 memcpy (frame
->saved_regs
, temp_saved_regs
,
1068 SIZEOF_FRAME_SAVED_REGS
);
1069 frame
->saved_regs
[PC_REGNUM
]
1070 = frame
->saved_regs
[ALPHA_RA_REGNUM
];
1077 alpha_frame_locals_address (struct frame_info
*fi
)
1079 return (fi
->frame
- fi
->extra_info
->localoff
);
1083 alpha_frame_args_address (struct frame_info
*fi
)
1085 return (fi
->frame
- (ALPHA_NUM_ARG_REGS
* 8));
1088 /* ALPHA stack frames are almost impenetrable. When execution stops,
1089 we basically have to look at symbol information for the function
1090 that we stopped in, which tells us *which* register (if any) is
1091 the base of the frame pointer, and what offset from that register
1092 the frame itself is at.
1094 This presents a problem when trying to examine a stack in memory
1095 (that isn't executing at the moment), using the "frame" command. We
1096 don't have a PC, nor do we have any registers except SP.
1098 This routine takes two arguments, SP and PC, and tries to make the
1099 cached frames look as if these two arguments defined a frame on the
1100 cache. This allows the rest of info frame to extract the important
1101 arguments without difficulty. */
1104 alpha_setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
1107 error ("ALPHA frame specifications require two arguments: sp and pc");
1109 return create_new_frame (argv
[0], argv
[1]);
1112 /* The alpha passes the first six arguments in the registers, the rest on
1113 the stack. The register arguments are eventually transferred to the
1114 argument transfer area immediately below the stack by the called function
1115 anyway. So we `push' at least six arguments on the stack, `reload' the
1116 argument registers and then adjust the stack pointer to point past the
1117 sixth argument. This algorithm simplifies the passing of a large struct
1118 which extends from the registers to the stack.
1119 If the called function is returning a structure, the address of the
1120 structure to be returned is passed as a hidden first argument. */
1123 alpha_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1124 int struct_return
, CORE_ADDR struct_addr
)
1127 int accumulate_size
= struct_return
? 8 : 0;
1128 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
1135 struct alpha_arg
*alpha_args
=
1136 (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
1137 register struct alpha_arg
*m_arg
;
1138 char raw_buffer
[sizeof (CORE_ADDR
)];
1139 int required_arg_regs
;
1141 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
1143 struct value
*arg
= args
[i
];
1144 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1145 /* Cast argument to long if necessary as the compiler does it too. */
1146 switch (TYPE_CODE (arg_type
))
1149 case TYPE_CODE_BOOL
:
1150 case TYPE_CODE_CHAR
:
1151 case TYPE_CODE_RANGE
:
1152 case TYPE_CODE_ENUM
:
1153 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
1155 arg_type
= builtin_type_long
;
1156 arg
= value_cast (arg_type
, arg
);
1162 m_arg
->len
= TYPE_LENGTH (arg_type
);
1163 m_arg
->offset
= accumulate_size
;
1164 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
1165 m_arg
->contents
= VALUE_CONTENTS (arg
);
1168 /* Determine required argument register loads, loading an argument register
1169 is expensive as it uses three ptrace calls. */
1170 required_arg_regs
= accumulate_size
/ 8;
1171 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
1172 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
1174 /* Make room for the arguments on the stack. */
1175 if (accumulate_size
< arg_regs_size
)
1176 accumulate_size
= arg_regs_size
;
1177 sp
-= accumulate_size
;
1179 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
1182 /* `Push' arguments on the stack. */
1183 for (i
= nargs
; m_arg
--, --i
>= 0;)
1184 write_memory (sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
1187 store_address (raw_buffer
, sizeof (CORE_ADDR
), struct_addr
);
1188 write_memory (sp
, raw_buffer
, sizeof (CORE_ADDR
));
1191 /* Load the argument registers. */
1192 for (i
= 0; i
< required_arg_regs
; i
++)
1196 val
= read_memory_integer (sp
+ i
* 8, 8);
1197 write_register (ALPHA_A0_REGNUM
+ i
, val
);
1198 write_register (ALPHA_FPA0_REGNUM
+ i
, val
);
1201 return sp
+ arg_regs_size
;
1205 alpha_push_dummy_frame (void)
1208 struct linked_proc_info
*link
;
1209 alpha_extra_func_info_t proc_desc
;
1210 CORE_ADDR sp
= read_register (SP_REGNUM
);
1211 CORE_ADDR save_address
;
1212 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1215 link
= (struct linked_proc_info
*) xmalloc (sizeof (struct linked_proc_info
));
1216 link
->next
= linked_proc_desc_table
;
1217 linked_proc_desc_table
= link
;
1219 proc_desc
= &link
->info
;
1222 * The registers we must save are all those not preserved across
1224 * In addition, we must save the PC and RA.
1226 * Dummy frame layout:
1236 * Parameter build area
1240 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
1241 #define MASK(i,j) ((((LONGEST)1 << ((j)+1)) - 1) ^ (((LONGEST)1 << (i)) - 1))
1242 #define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
1243 #define GEN_REG_SAVE_COUNT 24
1244 #define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
1245 #define FLOAT_REG_SAVE_COUNT 23
1246 /* The special register is the PC as we have no bit for it in the save masks.
1247 alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
1248 #define SPECIAL_REG_SAVE_COUNT 1
1250 PROC_REG_MASK (proc_desc
) = GEN_REG_SAVE_MASK
;
1251 PROC_FREG_MASK (proc_desc
) = FLOAT_REG_SAVE_MASK
;
1252 /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
1253 but keep SP aligned to a multiple of 16. */
1254 PROC_REG_OFFSET (proc_desc
) =
1255 -((8 * (SPECIAL_REG_SAVE_COUNT
1256 + GEN_REG_SAVE_COUNT
1257 + FLOAT_REG_SAVE_COUNT
)
1259 PROC_FREG_OFFSET (proc_desc
) =
1260 PROC_REG_OFFSET (proc_desc
) + 8 * GEN_REG_SAVE_COUNT
;
1262 /* Save general registers.
1263 The return address register is the first saved register, all other
1264 registers follow in ascending order.
1265 The PC is saved immediately below the SP. */
1266 save_address
= sp
+ PROC_REG_OFFSET (proc_desc
);
1267 store_address (raw_buffer
, 8, read_register (ALPHA_RA_REGNUM
));
1268 write_memory (save_address
, raw_buffer
, 8);
1270 mask
= PROC_REG_MASK (proc_desc
) & 0xffffffffL
;
1271 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1274 if (ireg
== ALPHA_RA_REGNUM
)
1276 store_address (raw_buffer
, 8, read_register (ireg
));
1277 write_memory (save_address
, raw_buffer
, 8);
1281 store_address (raw_buffer
, 8, read_register (PC_REGNUM
));
1282 write_memory (sp
- 8, raw_buffer
, 8);
1284 /* Save floating point registers. */
1285 save_address
= sp
+ PROC_FREG_OFFSET (proc_desc
);
1286 mask
= PROC_FREG_MASK (proc_desc
) & 0xffffffffL
;
1287 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1290 store_address (raw_buffer
, 8, read_register (ireg
+ FP0_REGNUM
));
1291 write_memory (save_address
, raw_buffer
, 8);
1295 /* Set and save the frame address for the dummy.
1296 This is tricky. The only registers that are suitable for a frame save
1297 are those that are preserved across procedure calls (s0-s6). But if
1298 a read system call is interrupted and then a dummy call is made
1299 (see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
1300 is satisfied. Then it returns with the s0-s6 registers set to the values
1301 on entry to the read system call and our dummy frame pointer would be
1302 destroyed. So we save the dummy frame in the proc_desc and handle the
1303 retrieval of the frame pointer of a dummy specifically. The frame register
1304 is set to the virtual frame (pseudo) register, it's value will always
1305 be read as zero and will help us to catch any errors in the dummy frame
1307 PROC_DUMMY_FRAME (proc_desc
) = sp
;
1308 PROC_FRAME_REG (proc_desc
) = FP_REGNUM
;
1309 PROC_FRAME_OFFSET (proc_desc
) = 0;
1310 sp
+= PROC_REG_OFFSET (proc_desc
);
1311 write_register (SP_REGNUM
, sp
);
1313 PROC_LOW_ADDR (proc_desc
) = CALL_DUMMY_ADDRESS ();
1314 PROC_HIGH_ADDR (proc_desc
) = PROC_LOW_ADDR (proc_desc
) + 4;
1316 SET_PROC_DESC_IS_DUMMY (proc_desc
);
1317 PROC_PC_REG (proc_desc
) = ALPHA_RA_REGNUM
;
1321 alpha_pop_frame (void)
1323 register int regnum
;
1324 struct frame_info
*frame
= get_current_frame ();
1325 CORE_ADDR new_sp
= frame
->frame
;
1327 alpha_extra_func_info_t proc_desc
= frame
->extra_info
->proc_desc
;
1329 /* we need proc_desc to know how to restore the registers;
1330 if it is NULL, construct (a temporary) one */
1331 if (proc_desc
== NULL
)
1332 proc_desc
= find_proc_desc (frame
->pc
, frame
->next
);
1334 /* Question: should we copy this proc_desc and save it in
1335 frame->proc_desc? If we do, who will free it?
1336 For now, we don't save a copy... */
1338 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
1339 if (frame
->saved_regs
== NULL
)
1340 alpha_find_saved_regs (frame
);
1343 for (regnum
= 32; --regnum
>= 0;)
1344 if (PROC_REG_MASK (proc_desc
) & (1 << regnum
))
1345 write_register (regnum
,
1346 read_memory_integer (frame
->saved_regs
[regnum
],
1348 for (regnum
= 32; --regnum
>= 0;)
1349 if (PROC_FREG_MASK (proc_desc
) & (1 << regnum
))
1350 write_register (regnum
+ FP0_REGNUM
,
1351 read_memory_integer (frame
->saved_regs
[regnum
+ FP0_REGNUM
], 8));
1353 write_register (SP_REGNUM
, new_sp
);
1354 flush_cached_frames ();
1356 if (proc_desc
&& (PROC_DESC_IS_DUMMY (proc_desc
)
1357 || PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
)))
1359 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
1361 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
1363 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
1365 if (&pi_ptr
->info
== proc_desc
)
1370 error ("Can't locate dummy extra frame info\n");
1372 if (prev_ptr
!= NULL
)
1373 prev_ptr
->next
= pi_ptr
->next
;
1375 linked_proc_desc_table
= pi_ptr
->next
;
1381 /* To skip prologues, I use this predicate. Returns either PC itself
1382 if the code at PC does not look like a function prologue; otherwise
1383 returns an address that (if we're lucky) follows the prologue. If
1384 LENIENT, then we must skip everything which is involved in setting
1385 up the frame (it's OK to skip more, just so long as we don't skip
1386 anything which might clobber the registers which are being saved.
1387 Currently we must not skip more on the alpha, but we might need the
1388 lenient stuff some day. */
1391 alpha_skip_prologue_internal (CORE_ADDR pc
, int lenient
)
1395 CORE_ADDR post_prologue_pc
;
1398 #ifdef GDB_TARGET_HAS_SHARED_LIBS
1399 /* Silently return the unaltered pc upon memory errors.
1400 This could happen on OSF/1 if decode_line_1 tries to skip the
1401 prologue for quickstarted shared library functions when the
1402 shared library is not yet mapped in.
1403 Reading target memory is slow over serial lines, so we perform
1404 this check only if the target has shared libraries. */
1405 if (target_read_memory (pc
, buf
, 4))
1409 /* See if we can determine the end of the prologue via the symbol table.
1410 If so, then return either PC, or the PC after the prologue, whichever
1413 post_prologue_pc
= after_prologue (pc
, NULL
);
1415 if (post_prologue_pc
!= 0)
1416 return max (pc
, post_prologue_pc
);
1418 /* Can't determine prologue from the symbol table, need to examine
1421 /* Skip the typical prologue instructions. These are the stack adjustment
1422 instruction and the instructions that save registers on the stack
1423 or in the gcc frame. */
1424 for (offset
= 0; offset
< 100; offset
+= 4)
1428 status
= read_memory_nobpt (pc
+ offset
, buf
, 4);
1430 memory_error (status
, pc
+ offset
);
1431 inst
= extract_unsigned_integer (buf
, 4);
1433 /* The alpha has no delay slots. But let's keep the lenient stuff,
1434 we might need it for something else in the future. */
1438 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
1440 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
1442 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1444 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
1447 if ((inst
& 0xfc1f0000) == 0xb41e0000
1448 && (inst
& 0xffff0000) != 0xb7fe0000)
1449 continue; /* stq reg,n($sp) */
1451 if ((inst
& 0xfc1f0000) == 0x9c1e0000
1452 && (inst
& 0xffff0000) != 0x9ffe0000)
1453 continue; /* stt reg,n($sp) */
1455 if (inst
== 0x47de040f) /* bis sp,sp,fp */
1464 alpha_skip_prologue (CORE_ADDR addr
)
1466 return (alpha_skip_prologue_internal (addr
, 0));
1470 /* Is address PC in the prologue (loosely defined) for function at
1474 alpha_in_lenient_prologue (CORE_ADDR startaddr
, CORE_ADDR pc
)
1476 CORE_ADDR end_prologue
= alpha_skip_prologue_internal (startaddr
, 1);
1477 return pc
>= startaddr
&& pc
< end_prologue
;
1481 /* The alpha needs a conversion between register and memory format if
1482 the register is a floating point register and
1483 memory format is float, as the register format must be double
1485 memory format is an integer with 4 bytes or less, as the representation
1486 of integers in floating point registers is different. */
1488 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
1489 char *raw_buffer
, char *virtual_buffer
)
1491 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1493 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
1497 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1499 double d
= extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1500 store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
1502 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1505 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1506 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
1507 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
1510 error ("Cannot retrieve value from floating point register");
1514 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
1515 char *virtual_buffer
, char *raw_buffer
)
1517 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1519 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
1523 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1525 double d
= extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
1526 store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
1528 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1531 if (TYPE_UNSIGNED (valtype
))
1532 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1534 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1535 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
1536 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
1539 error ("Cannot store value in floating point register");
1542 /* Given a return value in `regbuf' with a type `valtype',
1543 extract and copy its value into `valbuf'. */
1546 alpha_extract_return_value (struct type
*valtype
,
1547 char regbuf
[REGISTER_BYTES
], char *valbuf
)
1549 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1550 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
1551 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
1554 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1555 TYPE_LENGTH (valtype
));
1558 /* Given a return value in `regbuf' with a type `valtype',
1559 write its value into the appropriate register. */
1562 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
1564 char raw_buffer
[ALPHA_MAX_REGISTER_RAW_SIZE
];
1565 int regnum
= ALPHA_V0_REGNUM
;
1566 int length
= TYPE_LENGTH (valtype
);
1568 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1570 regnum
= FP0_REGNUM
;
1571 length
= REGISTER_RAW_SIZE (regnum
);
1572 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
1575 memcpy (raw_buffer
, valbuf
, length
);
1577 write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
1580 /* Just like reinit_frame_cache, but with the right arguments to be
1581 callable as an sfunc. */
1584 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1586 reinit_frame_cache ();
1589 /* This is the definition of CALL_DUMMY_ADDRESS. It's a heuristic that is used
1590 to find a convenient place in the text segment to stick a breakpoint to
1591 detect the completion of a target function call (ala call_function_by_hand).
1595 alpha_call_dummy_address (void)
1598 struct minimal_symbol
*sym
;
1600 entry
= entry_point_address ();
1605 sym
= lookup_minimal_symbol ("_Prelude", NULL
, symfile_objfile
);
1607 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1610 return SYMBOL_VALUE_ADDRESS (sym
) + 4;
1614 alpha_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
1615 struct value
**args
, struct type
*type
, int gcc_p
)
1617 CORE_ADDR bp_address
= CALL_DUMMY_ADDRESS ();
1619 if (bp_address
== 0)
1620 error ("no place to put call");
1621 write_register (ALPHA_RA_REGNUM
, bp_address
);
1622 write_register (ALPHA_T12_REGNUM
, fun
);
1625 /* On the Alpha, the call dummy code is nevery copied to user space
1626 (see alpha_fix_call_dummy() above). The contents of this do not
1628 LONGEST alpha_call_dummy_words
[] = { 0 };
1631 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
1633 /* Structures are returned by ref in extra arg0. */
1638 alpha_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1640 /* Store the address of the place in which to copy the structure the
1641 subroutine will return. Handled by alpha_push_arguments. */
1645 alpha_extract_struct_value_address (char *regbuf
)
1647 return (extract_address (regbuf
+ REGISTER_BYTE (ALPHA_V0_REGNUM
),
1648 REGISTER_RAW_SIZE (ALPHA_V0_REGNUM
)));
1651 /* alpha_software_single_step() is called just before we want to resume
1652 the inferior, if we want to single-step it but there is no hardware
1653 or kernel single-step support (NetBSD on Alpha, for example). We find
1654 the target of the coming instruction and breakpoint it.
1656 single_step is also called just after the inferior stops. If we had
1657 set up a simulated single-step, we undo our damage. */
1660 alpha_next_pc (CORE_ADDR pc
)
1667 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1669 /* Opcode is top 6 bits. */
1670 op
= (insn
>> 26) & 0x3f;
1674 /* Jump format: target PC is:
1676 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1679 if ((op
& 0x30) == 0x30)
1681 /* Branch format: target PC is:
1682 (new PC) + (4 * sext(displacement)) */
1683 if (op
== 0x30 || /* BR */
1684 op
== 0x34) /* BSR */
1687 offset
= (insn
& 0x001fffff);
1688 if (offset
& 0x00100000)
1689 offset
|= 0xffe00000;
1691 return (pc
+ 4 + offset
);
1694 /* Need to determine if branch is taken; read RA. */
1695 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1698 case 0x38: /* BLBC */
1702 case 0x3c: /* BLBS */
1706 case 0x39: /* BEQ */
1710 case 0x3d: /* BNE */
1714 case 0x3a: /* BLT */
1718 case 0x3b: /* BLE */
1722 case 0x3f: /* BGT */
1726 case 0x3e: /* BGE */
1733 /* Not a branch or branch not taken; target PC is:
1739 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1741 static CORE_ADDR next_pc
;
1742 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1743 static binsn_quantum break_mem
;
1746 if (insert_breakpoints_p
)
1749 next_pc
= alpha_next_pc (pc
);
1751 target_insert_breakpoint (next_pc
, break_mem
);
1755 target_remove_breakpoint (next_pc
, break_mem
);
1761 /* This table matches the indices assigned to enum alpha_abi. Keep
1763 static const char * const alpha_abi_names
[] =
1774 process_note_abi_tag_sections (bfd
*abfd
, asection
*sect
, void *obj
)
1776 enum alpha_abi
*os_ident_ptr
= obj
;
1778 unsigned int sectsize
;
1780 name
= bfd_get_section_name (abfd
, sect
);
1781 sectsize
= bfd_section_size (abfd
, sect
);
1783 if (strcmp (name
, ".note.ABI-tag") == 0 && sectsize
> 0)
1785 unsigned int name_length
, data_length
, note_type
;
1788 /* If the section is larger than this, it's probably not what we are
1793 note
= alloca (sectsize
);
1795 bfd_get_section_contents (abfd
, sect
, note
,
1796 (file_ptr
) 0, (bfd_size_type
) sectsize
);
1798 name_length
= bfd_h_get_32 (abfd
, note
);
1799 data_length
= bfd_h_get_32 (abfd
, note
+ 4);
1800 note_type
= bfd_h_get_32 (abfd
, note
+ 8);
1802 if (name_length
== 4 && data_length
== 16 && note_type
== 1
1803 && strcmp (note
+ 12, "GNU") == 0)
1805 int os_number
= bfd_h_get_32 (abfd
, note
+ 16);
1807 /* The case numbers are from abi-tags in glibc. */
1811 *os_ident_ptr
= ALPHA_ABI_LINUX
;
1816 (__FILE__
, __LINE__
,
1817 "process_note_abi_sections: Hurd objects not supported");
1822 (__FILE__
, __LINE__
,
1823 "process_note_abi_sections: Solaris objects not supported");
1828 (__FILE__
, __LINE__
,
1829 "process_note_abi_sections: unknown OS number %d",
1835 /* NetBSD uses a similar trick. */
1836 else if (strcmp (name
, ".note.netbsd.ident") == 0 && sectsize
> 0)
1838 unsigned int name_length
, desc_length
, note_type
;
1841 /* If the section is larger than this, it's probably not what we are
1846 note
= alloca (sectsize
);
1848 bfd_get_section_contents (abfd
, sect
, note
,
1849 (file_ptr
) 0, (bfd_size_type
) sectsize
);
1851 name_length
= bfd_h_get_32 (abfd
, note
);
1852 desc_length
= bfd_h_get_32 (abfd
, note
+ 4);
1853 note_type
= bfd_h_get_32 (abfd
, note
+ 8);
1855 if (name_length
== 7 && desc_length
== 4 && note_type
== 1
1856 && strcmp (note
+ 12, "NetBSD") == 0)
1857 /* XXX Should we check the version here?
1858 Probably not necessary yet. */
1859 *os_ident_ptr
= ALPHA_ABI_NETBSD
;
1864 get_elfosabi (bfd
*abfd
)
1867 enum alpha_abi alpha_abi
= ALPHA_ABI_UNKNOWN
;
1869 elfosabi
= elf_elfheader (abfd
)->e_ident
[EI_OSABI
];
1871 /* When elfosabi is 0 (ELFOSABI_NONE), this is supposed to indicate
1872 what we're on a SYSV system. However, GNU/Linux uses a note section
1873 to record OS/ABI info, but leaves e_ident[EI_OSABI] zero. So we
1874 have to check the note sections too. */
1877 bfd_map_over_sections (abfd
,
1878 process_note_abi_tag_sections
,
1882 if (alpha_abi
!= ALPHA_ABI_UNKNOWN
)
1888 /* Leave it as unknown. */
1891 case ELFOSABI_NETBSD
:
1892 return ALPHA_ABI_NETBSD
;
1894 case ELFOSABI_FREEBSD
:
1895 return ALPHA_ABI_FREEBSD
;
1897 case ELFOSABI_LINUX
:
1898 return ALPHA_ABI_LINUX
;
1901 return ALPHA_ABI_UNKNOWN
;
1904 /* Initialize the current architecture based on INFO. If possible, re-use an
1905 architecture from ARCHES, which is a list of architectures already created
1906 during this debugging session.
1908 Called e.g. at program startup, when reading a core file, and when reading
1911 static struct gdbarch
*
1912 alpha_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1914 struct gdbarch_tdep
*tdep
;
1915 struct gdbarch
*gdbarch
;
1916 enum alpha_abi alpha_abi
= ALPHA_ABI_UNKNOWN
;
1918 /* Try to determine the ABI of the object we are loading. */
1920 if (info
.abfd
!= NULL
)
1922 switch (bfd_get_flavour (info
.abfd
))
1924 case bfd_target_elf_flavour
:
1925 alpha_abi
= get_elfosabi (info
.abfd
);
1928 case bfd_target_ecoff_flavour
:
1929 /* Assume it's OSF/1. */
1930 alpha_abi
= ALPHA_ABI_OSF1
;
1934 /* Not sure what to do here, leave the ABI as unknown. */
1939 /* Find a candidate among extant architectures. */
1940 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1942 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
1944 /* Make sure the ABI selection matches. */
1945 tdep
= gdbarch_tdep (arches
->gdbarch
);
1946 if (tdep
&& tdep
->alpha_abi
== alpha_abi
)
1947 return arches
->gdbarch
;
1950 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1951 gdbarch
= gdbarch_alloc (&info
, tdep
);
1953 tdep
->alpha_abi
= alpha_abi
;
1954 if (alpha_abi
< ALPHA_ABI_INVALID
)
1955 tdep
->abi_name
= alpha_abi_names
[alpha_abi
];
1958 internal_error (__FILE__
, __LINE__
, "Invalid setting of alpha_abi %d",
1960 tdep
->abi_name
= "<invalid>";
1964 set_gdbarch_short_bit (gdbarch
, 16);
1965 set_gdbarch_int_bit (gdbarch
, 32);
1966 set_gdbarch_long_bit (gdbarch
, 64);
1967 set_gdbarch_long_long_bit (gdbarch
, 64);
1968 set_gdbarch_float_bit (gdbarch
, 32);
1969 set_gdbarch_double_bit (gdbarch
, 64);
1970 set_gdbarch_long_double_bit (gdbarch
, 64);
1971 set_gdbarch_ptr_bit (gdbarch
, 64);
1974 set_gdbarch_num_regs (gdbarch
, ALPHA_NUM_REGS
);
1975 set_gdbarch_sp_regnum (gdbarch
, ALPHA_SP_REGNUM
);
1976 set_gdbarch_fp_regnum (gdbarch
, ALPHA_FP_REGNUM
);
1977 set_gdbarch_pc_regnum (gdbarch
, ALPHA_PC_REGNUM
);
1978 set_gdbarch_fp0_regnum (gdbarch
, ALPHA_FP0_REGNUM
);
1980 set_gdbarch_register_name (gdbarch
, alpha_register_name
);
1981 set_gdbarch_register_size (gdbarch
, ALPHA_REGISTER_SIZE
);
1982 set_gdbarch_register_bytes (gdbarch
, ALPHA_REGISTER_BYTES
);
1983 set_gdbarch_register_byte (gdbarch
, alpha_register_byte
);
1984 set_gdbarch_register_raw_size (gdbarch
, alpha_register_raw_size
);
1985 set_gdbarch_max_register_raw_size (gdbarch
, ALPHA_MAX_REGISTER_RAW_SIZE
);
1986 set_gdbarch_register_virtual_size (gdbarch
, alpha_register_virtual_size
);
1987 set_gdbarch_max_register_virtual_size (gdbarch
,
1988 ALPHA_MAX_REGISTER_VIRTUAL_SIZE
);
1989 set_gdbarch_register_virtual_type (gdbarch
, alpha_register_virtual_type
);
1991 set_gdbarch_cannot_fetch_register (gdbarch
, alpha_cannot_fetch_register
);
1992 set_gdbarch_cannot_store_register (gdbarch
, alpha_cannot_store_register
);
1994 set_gdbarch_register_convertible (gdbarch
, alpha_register_convertible
);
1995 set_gdbarch_register_convert_to_virtual (gdbarch
,
1996 alpha_register_convert_to_virtual
);
1997 set_gdbarch_register_convert_to_raw (gdbarch
, alpha_register_convert_to_raw
);
1999 set_gdbarch_skip_prologue (gdbarch
, alpha_skip_prologue
);
2001 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
2002 set_gdbarch_frameless_function_invocation (gdbarch
,
2003 generic_frameless_function_invocation_not
);
2005 set_gdbarch_saved_pc_after_call (gdbarch
, alpha_saved_pc_after_call
);
2007 set_gdbarch_frame_chain (gdbarch
, alpha_frame_chain
);
2008 set_gdbarch_frame_chain_valid (gdbarch
, func_frame_chain_valid
);
2009 set_gdbarch_frame_saved_pc (gdbarch
, alpha_frame_saved_pc
);
2011 set_gdbarch_frame_init_saved_regs (gdbarch
, alpha_frame_init_saved_regs
);
2012 set_gdbarch_get_saved_register (gdbarch
, alpha_get_saved_register
);
2014 set_gdbarch_use_struct_convention (gdbarch
, alpha_use_struct_convention
);
2015 set_gdbarch_extract_return_value (gdbarch
, alpha_extract_return_value
);
2017 set_gdbarch_store_struct_return (gdbarch
, alpha_store_struct_return
);
2018 set_gdbarch_store_return_value (gdbarch
, alpha_store_return_value
);
2019 set_gdbarch_extract_struct_value_address (gdbarch
,
2020 alpha_extract_struct_value_address
);
2022 /* Settings for calling functions in the inferior. */
2023 set_gdbarch_use_generic_dummy_frames (gdbarch
, 0);
2024 set_gdbarch_call_dummy_length (gdbarch
, 0);
2025 set_gdbarch_push_arguments (gdbarch
, alpha_push_arguments
);
2026 set_gdbarch_pop_frame (gdbarch
, alpha_pop_frame
);
2028 /* On the Alpha, the call dummy code is never copied to user space,
2029 stopping the user call is achieved via a bp_call_dummy breakpoint.
2030 But we need a fake CALL_DUMMY definition to enable the proper
2031 call_function_by_hand and to avoid zero length array warnings. */
2032 set_gdbarch_call_dummy_p (gdbarch
, 1);
2033 set_gdbarch_call_dummy_words (gdbarch
, alpha_call_dummy_words
);
2034 set_gdbarch_sizeof_call_dummy_words (gdbarch
, 0);
2035 set_gdbarch_frame_args_address (gdbarch
, alpha_frame_args_address
);
2036 set_gdbarch_frame_locals_address (gdbarch
, alpha_frame_locals_address
);
2037 set_gdbarch_init_extra_frame_info (gdbarch
, alpha_init_extra_frame_info
);
2039 /* Alpha OSF/1 inhibits execution of code on the stack. But there is
2040 no need for a dummy on the Alpha. PUSH_ARGUMENTS takes care of all
2041 argument handling and bp_call_dummy takes care of stopping the dummy. */
2042 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
2043 set_gdbarch_call_dummy_address (gdbarch
, alpha_call_dummy_address
);
2044 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
2045 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
2046 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
2047 set_gdbarch_pc_in_call_dummy (gdbarch
, pc_in_call_dummy_at_entry_point
);
2048 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
2049 set_gdbarch_push_dummy_frame (gdbarch
, alpha_push_dummy_frame
);
2050 set_gdbarch_fix_call_dummy (gdbarch
, alpha_fix_call_dummy
);
2051 set_gdbarch_init_frame_pc (gdbarch
, init_frame_pc_noop
);
2052 set_gdbarch_init_frame_pc_first (gdbarch
, alpha_init_frame_pc_first
);
2054 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
2056 set_gdbarch_decr_pc_after_break (gdbarch
, 4);
2057 set_gdbarch_frame_args_skip (gdbarch
, 0);
2063 alpha_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2065 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2070 if (tdep
->abi_name
!= NULL
)
2071 fprintf_unfiltered (file
, "alpha_dump_tdep: ABI = %s\n", tdep
->abi_name
);
2073 internal_error (__FILE__
, __LINE__
,
2074 "alpha_dump_tdep: illegal setting of tdep->alpha_abi (%d)",
2075 (int) tdep
->alpha_abi
);
2079 _initialize_alpha_tdep (void)
2081 struct cmd_list_element
*c
;
2083 gdbarch_register (bfd_arch_alpha
, alpha_gdbarch_init
, alpha_dump_tdep
);
2085 tm_print_insn
= print_insn_alpha
;
2087 /* Let the user set the fence post for heuristic_proc_start. */
2089 /* We really would like to have both "0" and "unlimited" work, but
2090 command.c doesn't deal with that. So make it a var_zinteger
2091 because the user can always use "999999" or some such for unlimited. */
2092 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
2093 (char *) &heuristic_fence_post
,
2095 Set the distance searched for the start of a function.\n\
2096 If you are debugging a stripped executable, GDB needs to search through the\n\
2097 program for the start of a function. This command sets the distance of the\n\
2098 search. The only need to set it is when debugging a stripped executable.",
2100 /* We need to throw away the frame cache when we set this, since it
2101 might change our ability to get backtraces. */
2102 set_cmd_sfunc (c
, reinit_frame_cache_sfunc
);
2103 add_show_from_set (c
, &showlist
);