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"
37 struct frame_extra_info
39 alpha_extra_func_info_t proc_desc
;
44 /* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
46 /* Prototypes for local functions. */
48 static void alpha_find_saved_regs (struct frame_info
*);
50 static alpha_extra_func_info_t
push_sigtramp_desc (CORE_ADDR low_addr
);
52 static CORE_ADDR
read_next_frame_reg (struct frame_info
*, int);
54 static CORE_ADDR
heuristic_proc_start (CORE_ADDR
);
56 static alpha_extra_func_info_t
heuristic_proc_desc (CORE_ADDR
,
60 static alpha_extra_func_info_t
find_proc_desc (CORE_ADDR
,
64 static int alpha_in_lenient_prologue (CORE_ADDR
, CORE_ADDR
);
67 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element
*);
69 static CORE_ADDR
after_prologue (CORE_ADDR pc
,
70 alpha_extra_func_info_t proc_desc
);
72 static int alpha_in_prologue (CORE_ADDR pc
,
73 alpha_extra_func_info_t proc_desc
);
75 static int alpha_about_to_return (CORE_ADDR pc
);
77 void _initialize_alpha_tdep (void);
79 /* Heuristic_proc_start may hunt through the text section for a long
80 time across a 2400 baud serial line. Allows the user to limit this
82 static unsigned int heuristic_fence_post
= 0;
84 /* Layout of a stack frame on the alpha:
87 pdr members: | 7th ... nth arg, |
88 | `pushed' by caller. |
90 ----------------|-------------------------------|<-- old_sp == vfp
93 | |localoff | Copies of 1st .. 6th |
94 | | | | | argument if necessary. |
96 | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS
98 | | | | Locals and temporaries. |
100 | | | |-------------------------------|
102 |-fregoffset | Saved float registers. |
108 | | -------|-------------------------------|
110 | | | Saved registers. |
117 | ----------|-------------------------------|
119 frameoffset | Argument build area, gets |
120 | | 7th ... nth arg for any |
121 | | called procedure. |
123 -------------|-------------------------------|<-- sp
130 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
131 /* These next two fields are kind of being hijacked. I wonder if
132 iline is too small for the values it needs to hold, if GDB is
133 running on a 32-bit host. */
134 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
135 #define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset) /*CALL_DUMMY frame */
136 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
137 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
138 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
139 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
140 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
141 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
142 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
143 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
144 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
145 #define _PROC_MAGIC_ 0x0F0F0F0F
146 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
147 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
149 struct linked_proc_info
151 struct alpha_extra_func_info info
;
152 struct linked_proc_info
*next
;
154 *linked_proc_desc_table
= NULL
;
157 alpha_osf_in_sigtramp (CORE_ADDR pc
, char *func_name
)
159 return (func_name
!= NULL
&& STREQ ("__sigtramp", func_name
));
162 /* Under GNU/Linux, signal handler invocations can be identified by the
163 designated code sequence that is used to return from a signal
164 handler. In particular, the return address of a signal handler
165 points to the following sequence (the first instruction is quadword
172 Each instruction has a unique encoding, so we simply attempt to
173 match the instruction the pc is pointing to with any of the above
174 instructions. If there is a hit, we know the offset to the start
175 of the designated sequence and can then check whether we really are
176 executing in a designated sequence. If not, -1 is returned,
177 otherwise the offset from the start of the desingated sequence is
180 There is a slight chance of false hits: code could jump into the
181 middle of the designated sequence, in which case there is no
182 guarantee that we are in the middle of a sigreturn syscall. Don't
183 think this will be a problem in praxis, though.
186 #ifndef TM_LINUXALPHA_H
187 /* HACK: Provide a prototype when compiling this file for non
188 linuxalpha targets. */
189 long alpha_linux_sigtramp_offset (CORE_ADDR pc
);
192 alpha_linux_sigtramp_offset (CORE_ADDR pc
)
194 unsigned int i
[3], w
;
197 if (read_memory_nobpt (pc
, (char *) &w
, 4) != 0)
205 break; /* bis $30,$30,$16 */
208 break; /* addq $31,0x67,$0 */
211 break; /* call_pal callsys */
218 /* designated sequence is not quadword aligned */
222 if (read_memory_nobpt (pc
, (char *) i
, sizeof (i
)) != 0)
225 if (i
[0] == 0x47de0410 && i
[1] == 0x43ecf400 && i
[2] == 0x00000083)
232 /* Under OSF/1, the __sigtramp routine is frameless and has a frame
233 size of zero, but we are able to backtrace through it. */
235 alpha_osf_skip_sigtramp_frame (struct frame_info
*frame
, CORE_ADDR pc
)
238 find_pc_partial_function (pc
, &name
, (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
239 if (IN_SIGTRAMP (pc
, name
))
246 /* Dynamically create a signal-handler caller procedure descriptor for
247 the signal-handler return code starting at address LOW_ADDR. The
248 descriptor is added to the linked_proc_desc_table. */
250 static alpha_extra_func_info_t
251 push_sigtramp_desc (CORE_ADDR low_addr
)
253 struct linked_proc_info
*link
;
254 alpha_extra_func_info_t proc_desc
;
256 link
= (struct linked_proc_info
*)
257 xmalloc (sizeof (struct linked_proc_info
));
258 link
->next
= linked_proc_desc_table
;
259 linked_proc_desc_table
= link
;
261 proc_desc
= &link
->info
;
263 proc_desc
->numargs
= 0;
264 PROC_LOW_ADDR (proc_desc
) = low_addr
;
265 PROC_HIGH_ADDR (proc_desc
) = low_addr
+ 3 * 4;
266 PROC_DUMMY_FRAME (proc_desc
) = 0;
267 PROC_FRAME_OFFSET (proc_desc
) = 0x298; /* sizeof(struct sigcontext_struct) */
268 PROC_FRAME_REG (proc_desc
) = SP_REGNUM
;
269 PROC_REG_MASK (proc_desc
) = 0xffff;
270 PROC_FREG_MASK (proc_desc
) = 0xffff;
271 PROC_PC_REG (proc_desc
) = 26;
272 PROC_LOCALOFF (proc_desc
) = 0;
273 SET_PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
);
279 alpha_register_name (int regno
)
281 static char *register_names
[] =
283 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
284 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
285 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
286 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
287 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
288 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
289 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
290 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
296 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
298 return (register_names
[regno
]);
302 alpha_cannot_fetch_register (int regno
)
304 return (regno
== FP_REGNUM
|| regno
== ZERO_REGNUM
);
308 alpha_cannot_store_register (int regno
)
310 return (regno
== FP_REGNUM
|| regno
== ZERO_REGNUM
);
314 alpha_register_convertible (int regno
)
316 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
320 /* Guaranteed to set frame->saved_regs to some values (it never leaves it
324 alpha_find_saved_regs (struct frame_info
*frame
)
327 CORE_ADDR reg_position
;
329 alpha_extra_func_info_t proc_desc
;
332 frame_saved_regs_zalloc (frame
);
334 /* If it is the frame for __sigtramp, the saved registers are located
335 in a sigcontext structure somewhere on the stack. __sigtramp
336 passes a pointer to the sigcontext structure on the stack.
337 If the stack layout for __sigtramp changes, or if sigcontext offsets
338 change, we might have to update this code. */
339 #ifndef SIGFRAME_PC_OFF
340 #define SIGFRAME_PC_OFF (2 * 8)
341 #define SIGFRAME_REGSAVE_OFF (4 * 8)
342 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
344 if (frame
->signal_handler_caller
)
346 CORE_ADDR sigcontext_addr
;
348 sigcontext_addr
= SIGCONTEXT_ADDR (frame
);
349 for (ireg
= 0; ireg
< 32; ireg
++)
351 reg_position
= sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ ireg
* 8;
352 frame
->saved_regs
[ireg
] = reg_position
;
354 for (ireg
= 0; ireg
< 32; ireg
++)
356 reg_position
= sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ ireg
* 8;
357 frame
->saved_regs
[FP0_REGNUM
+ ireg
] = reg_position
;
359 frame
->saved_regs
[PC_REGNUM
] = sigcontext_addr
+ SIGFRAME_PC_OFF
;
363 proc_desc
= frame
->extra_info
->proc_desc
;
364 if (proc_desc
== NULL
)
365 /* I'm not sure how/whether this can happen. Normally when we can't
366 find a proc_desc, we "synthesize" one using heuristic_proc_desc
367 and set the saved_regs right away. */
370 /* Fill in the offsets for the registers which gen_mask says
373 reg_position
= frame
->frame
+ PROC_REG_OFFSET (proc_desc
);
374 mask
= PROC_REG_MASK (proc_desc
);
376 returnreg
= PROC_PC_REG (proc_desc
);
378 /* Note that RA is always saved first, regardless of its actual
380 if (mask
& (1 << returnreg
))
382 frame
->saved_regs
[returnreg
] = reg_position
;
384 mask
&= ~(1 << returnreg
); /* Clear bit for RA so we
385 don't save again later. */
388 for (ireg
= 0; ireg
<= 31; ++ireg
)
389 if (mask
& (1 << ireg
))
391 frame
->saved_regs
[ireg
] = reg_position
;
395 /* Fill in the offsets for the registers which float_mask says
398 reg_position
= frame
->frame
+ PROC_FREG_OFFSET (proc_desc
);
399 mask
= PROC_FREG_MASK (proc_desc
);
401 for (ireg
= 0; ireg
<= 31; ++ireg
)
402 if (mask
& (1 << ireg
))
404 frame
->saved_regs
[FP0_REGNUM
+ ireg
] = reg_position
;
408 frame
->saved_regs
[PC_REGNUM
] = frame
->saved_regs
[returnreg
];
412 alpha_frame_init_saved_regs (struct frame_info
*fi
)
414 if (fi
->saved_regs
== NULL
)
415 alpha_find_saved_regs (fi
);
416 fi
->saved_regs
[SP_REGNUM
] = fi
->frame
;
420 read_next_frame_reg (struct frame_info
*fi
, int regno
)
422 for (; fi
; fi
= fi
->next
)
424 /* We have to get the saved sp from the sigcontext
425 if it is a signal handler frame. */
426 if (regno
== SP_REGNUM
&& !fi
->signal_handler_caller
)
430 if (fi
->saved_regs
== NULL
)
431 alpha_find_saved_regs (fi
);
432 if (fi
->saved_regs
[regno
])
433 return read_memory_integer (fi
->saved_regs
[regno
], 8);
436 return read_register (regno
);
440 alpha_frame_saved_pc (struct frame_info
*frame
)
442 alpha_extra_func_info_t proc_desc
= frame
->extra_info
->proc_desc
;
443 /* We have to get the saved pc from the sigcontext
444 if it is a signal handler frame. */
445 int pcreg
= frame
->signal_handler_caller
? PC_REGNUM
446 : frame
->extra_info
->pc_reg
;
448 if (proc_desc
&& PROC_DESC_IS_DUMMY (proc_desc
))
449 return read_memory_integer (frame
->frame
- 8, 8);
451 return read_next_frame_reg (frame
, pcreg
);
455 alpha_saved_pc_after_call (struct frame_info
*frame
)
457 CORE_ADDR pc
= frame
->pc
;
459 alpha_extra_func_info_t proc_desc
;
462 /* Skip over shared library trampoline if necessary. */
463 tmp
= SKIP_TRAMPOLINE_CODE (pc
);
467 proc_desc
= find_proc_desc (pc
, frame
->next
);
468 pcreg
= proc_desc
? PROC_PC_REG (proc_desc
) : RA_REGNUM
;
470 if (frame
->signal_handler_caller
)
471 return alpha_frame_saved_pc (frame
);
473 return read_register (pcreg
);
477 static struct alpha_extra_func_info temp_proc_desc
;
478 static CORE_ADDR temp_saved_regs
[NUM_REGS
];
480 /* Nonzero if instruction at PC is a return instruction. "ret
481 $zero,($ra),1" on alpha. */
484 alpha_about_to_return (CORE_ADDR pc
)
486 return read_memory_integer (pc
, 4) == 0x6bfa8001;
491 /* This fencepost looks highly suspicious to me. Removing it also
492 seems suspicious as it could affect remote debugging across serial
496 heuristic_proc_start (CORE_ADDR pc
)
498 CORE_ADDR start_pc
= pc
;
499 CORE_ADDR fence
= start_pc
- heuristic_fence_post
;
504 if (heuristic_fence_post
== UINT_MAX
505 || fence
< VM_MIN_ADDRESS
)
506 fence
= VM_MIN_ADDRESS
;
508 /* search back for previous return */
509 for (start_pc
-= 4;; start_pc
-= 4)
510 if (start_pc
< fence
)
512 /* It's not clear to me why we reach this point when
513 stop_soon_quietly, but with this test, at least we
514 don't print out warnings for every child forked (eg, on
515 decstation). 22apr93 rich@cygnus.com. */
516 if (!stop_soon_quietly
)
518 static int blurb_printed
= 0;
520 if (fence
== VM_MIN_ADDRESS
)
521 warning ("Hit beginning of text section without finding");
523 warning ("Hit heuristic-fence-post without finding");
525 warning ("enclosing function for address 0x%s", paddr_nz (pc
));
529 This warning occurs if you are debugging a function without any symbols\n\
530 (for example, in a stripped executable). In that case, you may wish to\n\
531 increase the size of the search with the `set heuristic-fence-post' command.\n\
533 Otherwise, you told GDB there was a function where there isn't one, or\n\
534 (more likely) you have encountered a bug in GDB.\n");
541 else if (alpha_about_to_return (start_pc
))
544 start_pc
+= 4; /* skip return */
548 static alpha_extra_func_info_t
549 heuristic_proc_desc (CORE_ADDR start_pc
, CORE_ADDR limit_pc
,
550 struct frame_info
*next_frame
)
552 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
555 int has_frame_reg
= 0;
556 unsigned long reg_mask
= 0;
561 memset (&temp_proc_desc
, '\0', sizeof (temp_proc_desc
));
562 memset (&temp_saved_regs
, '\0', SIZEOF_FRAME_SAVED_REGS
);
563 PROC_LOW_ADDR (&temp_proc_desc
) = start_pc
;
565 if (start_pc
+ 200 < limit_pc
)
566 limit_pc
= start_pc
+ 200;
568 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
574 status
= read_memory_nobpt (cur_pc
, buf
, 4);
576 memory_error (status
, cur_pc
);
577 word
= extract_unsigned_integer (buf
, 4);
579 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
582 frame_size
+= (-word
) & 0xffff;
584 /* Exit loop if a positive stack adjustment is found, which
585 usually means that the stack cleanup code in the function
586 epilogue is reached. */
589 else if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
590 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
592 int reg
= (word
& 0x03e00000) >> 21;
593 reg_mask
|= 1 << reg
;
594 temp_saved_regs
[reg
] = sp
+ (short) word
;
596 /* Starting with OSF/1-3.2C, the system libraries are shipped
597 without local symbols, but they still contain procedure
598 descriptors without a symbol reference. GDB is currently
599 unable to find these procedure descriptors and uses
600 heuristic_proc_desc instead.
601 As some low level compiler support routines (__div*, __add*)
602 use a non-standard return address register, we have to
603 add some heuristics to determine the return address register,
604 or stepping over these routines will fail.
605 Usually the return address register is the first register
606 saved on the stack, but assembler optimization might
607 rearrange the register saves.
608 So we recognize only a few registers (t7, t9, ra) within
609 the procedure prologue as valid return address registers.
610 If we encounter a return instruction, we extract the
611 the return address register from it.
613 FIXME: Rewriting GDB to access the procedure descriptors,
614 e.g. via the minimal symbol table, might obviate this hack. */
616 && cur_pc
< (start_pc
+ 80)
617 && (reg
== T7_REGNUM
|| reg
== T9_REGNUM
|| reg
== RA_REGNUM
))
620 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
621 pcreg
= (word
>> 16) & 0x1f;
622 else if (word
== 0x47de040f) /* bis sp,sp fp */
627 /* If we haven't found a valid return address register yet,
628 keep searching in the procedure prologue. */
629 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
634 if (read_memory_nobpt (cur_pc
, buf
, 4))
637 word
= extract_unsigned_integer (buf
, 4);
639 if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
640 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
642 int reg
= (word
& 0x03e00000) >> 21;
643 if (reg
== T7_REGNUM
|| reg
== T9_REGNUM
|| reg
== RA_REGNUM
)
649 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
651 pcreg
= (word
>> 16) & 0x1f;
658 PROC_FRAME_REG (&temp_proc_desc
) = GCC_FP_REGNUM
;
660 PROC_FRAME_REG (&temp_proc_desc
) = SP_REGNUM
;
661 PROC_FRAME_OFFSET (&temp_proc_desc
) = frame_size
;
662 PROC_REG_MASK (&temp_proc_desc
) = reg_mask
;
663 PROC_PC_REG (&temp_proc_desc
) = (pcreg
== -1) ? RA_REGNUM
: pcreg
;
664 PROC_LOCALOFF (&temp_proc_desc
) = 0; /* XXX - bogus */
665 return &temp_proc_desc
;
668 /* This returns the PC of the first inst after the prologue. If we can't
669 find the prologue, then return 0. */
672 after_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
674 struct symtab_and_line sal
;
675 CORE_ADDR func_addr
, func_end
;
678 proc_desc
= find_proc_desc (pc
, NULL
);
682 if (PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
))
683 return PROC_LOW_ADDR (proc_desc
); /* "prologue" is in kernel */
685 /* If function is frameless, then we need to do it the hard way. I
686 strongly suspect that frameless always means prologueless... */
687 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
688 && PROC_FRAME_OFFSET (proc_desc
) == 0)
692 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
693 return 0; /* Unknown */
695 sal
= find_pc_line (func_addr
, 0);
697 if (sal
.end
< func_end
)
700 /* The line after the prologue is after the end of the function. In this
701 case, tell the caller to find the prologue the hard way. */
706 /* Return non-zero if we *might* be in a function prologue. Return zero if we
707 are definitively *not* in a function prologue. */
710 alpha_in_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
712 CORE_ADDR after_prologue_pc
;
714 after_prologue_pc
= after_prologue (pc
, proc_desc
);
716 if (after_prologue_pc
== 0
717 || pc
< after_prologue_pc
)
723 static alpha_extra_func_info_t
724 find_proc_desc (CORE_ADDR pc
, struct frame_info
*next_frame
)
726 alpha_extra_func_info_t proc_desc
;
731 /* Try to get the proc_desc from the linked call dummy proc_descs
732 if the pc is in the call dummy.
733 This is hairy. In the case of nested dummy calls we have to find the
734 right proc_desc, but we might not yet know the frame for the dummy
735 as it will be contained in the proc_desc we are searching for.
736 So we have to find the proc_desc whose frame is closest to the current
739 if (PC_IN_CALL_DUMMY (pc
, 0, 0))
741 struct linked_proc_info
*link
;
742 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
743 alpha_extra_func_info_t found_proc_desc
= NULL
;
744 long min_distance
= LONG_MAX
;
746 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
748 long distance
= (CORE_ADDR
) PROC_DUMMY_FRAME (&link
->info
) - sp
;
749 if (distance
> 0 && distance
< min_distance
)
751 min_distance
= distance
;
752 found_proc_desc
= &link
->info
;
755 if (found_proc_desc
!= NULL
)
756 return found_proc_desc
;
759 b
= block_for_pc (pc
);
761 find_pc_partial_function (pc
, NULL
, &startaddr
, NULL
);
766 if (startaddr
> BLOCK_START (b
))
767 /* This is the "pathological" case referred to in a comment in
768 print_frame_info. It might be better to move this check into
772 sym
= lookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
,
776 /* If we never found a PDR for this function in symbol reading, then
777 examine prologues to find the information. */
778 if (sym
&& ((mips_extra_func_info_t
) SYMBOL_VALUE (sym
))->pdr
.framereg
== -1)
783 /* IF this is the topmost frame AND
784 * (this proc does not have debugging information OR
785 * the PC is in the procedure prologue)
786 * THEN create a "heuristic" proc_desc (by analyzing
787 * the actual code) to replace the "official" proc_desc.
789 proc_desc
= (alpha_extra_func_info_t
) SYMBOL_VALUE (sym
);
790 if (next_frame
== NULL
)
792 if (PROC_DESC_IS_DUMMY (proc_desc
) || alpha_in_prologue (pc
, proc_desc
))
794 alpha_extra_func_info_t found_heuristic
=
795 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc
),
799 PROC_LOCALOFF (found_heuristic
) =
800 PROC_LOCALOFF (proc_desc
);
801 PROC_PC_REG (found_heuristic
) = PROC_PC_REG (proc_desc
);
802 proc_desc
= found_heuristic
;
811 /* Is linked_proc_desc_table really necessary? It only seems to be used
812 by procedure call dummys. However, the procedures being called ought
813 to have their own proc_descs, and even if they don't,
814 heuristic_proc_desc knows how to create them! */
816 register struct linked_proc_info
*link
;
817 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
818 if (PROC_LOW_ADDR (&link
->info
) <= pc
819 && PROC_HIGH_ADDR (&link
->info
) > pc
)
822 /* If PC is inside a dynamically generated sigtramp handler,
823 create and push a procedure descriptor for that code: */
824 offset
= DYNAMIC_SIGTRAMP_OFFSET (pc
);
826 return push_sigtramp_desc (pc
- offset
);
828 /* If heuristic_fence_post is non-zero, determine the procedure
829 start address by examining the instructions.
830 This allows us to find the start address of static functions which
831 have no symbolic information, as startaddr would have been set to
832 the preceding global function start address by the
833 find_pc_partial_function call above. */
834 if (startaddr
== 0 || heuristic_fence_post
!= 0)
835 startaddr
= heuristic_proc_start (pc
);
838 heuristic_proc_desc (startaddr
, pc
, next_frame
);
843 alpha_extra_func_info_t cached_proc_desc
;
846 alpha_frame_chain (struct frame_info
*frame
)
848 alpha_extra_func_info_t proc_desc
;
849 CORE_ADDR saved_pc
= FRAME_SAVED_PC (frame
);
851 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
854 proc_desc
= find_proc_desc (saved_pc
, frame
);
858 cached_proc_desc
= proc_desc
;
860 /* Fetch the frame pointer for a dummy frame from the procedure
862 if (PROC_DESC_IS_DUMMY (proc_desc
))
863 return (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
865 /* If no frame pointer and frame size is zero, we must be at end
866 of stack (or otherwise hosed). If we don't check frame size,
867 we loop forever if we see a zero size frame. */
868 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
869 && PROC_FRAME_OFFSET (proc_desc
) == 0
870 /* The previous frame from a sigtramp frame might be frameless
871 and have frame size zero. */
872 && !frame
->signal_handler_caller
)
873 return FRAME_PAST_SIGTRAMP_FRAME (frame
, saved_pc
);
875 return read_next_frame_reg (frame
, PROC_FRAME_REG (proc_desc
))
876 + PROC_FRAME_OFFSET (proc_desc
);
880 alpha_print_extra_frame_info (struct frame_info
*fi
)
884 && fi
->extra_info
->proc_desc
885 && fi
->extra_info
->proc_desc
->pdr
.framereg
< NUM_REGS
)
886 printf_filtered (" frame pointer is at %s+%s\n",
887 REGISTER_NAME (fi
->extra_info
->proc_desc
->pdr
.framereg
),
888 paddr_d (fi
->extra_info
->proc_desc
->pdr
.frameoffset
));
892 alpha_init_extra_frame_info (int fromleaf
, struct frame_info
*frame
)
894 /* Use proc_desc calculated in frame_chain */
895 alpha_extra_func_info_t proc_desc
=
896 frame
->next
? cached_proc_desc
: find_proc_desc (frame
->pc
, frame
->next
);
898 frame
->extra_info
= (struct frame_extra_info
*)
899 frame_obstack_alloc (sizeof (struct frame_extra_info
));
901 frame
->saved_regs
= NULL
;
902 frame
->extra_info
->localoff
= 0;
903 frame
->extra_info
->pc_reg
= RA_REGNUM
;
904 frame
->extra_info
->proc_desc
= proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
907 /* Get the locals offset and the saved pc register from the
908 procedure descriptor, they are valid even if we are in the
909 middle of the prologue. */
910 frame
->extra_info
->localoff
= PROC_LOCALOFF (proc_desc
);
911 frame
->extra_info
->pc_reg
= PROC_PC_REG (proc_desc
);
913 /* Fixup frame-pointer - only needed for top frame */
915 /* Fetch the frame pointer for a dummy frame from the procedure
917 if (PROC_DESC_IS_DUMMY (proc_desc
))
918 frame
->frame
= (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
920 /* This may not be quite right, if proc has a real frame register.
921 Get the value of the frame relative sp, procedure might have been
922 interrupted by a signal at it's very start. */
923 else if (frame
->pc
== PROC_LOW_ADDR (proc_desc
)
924 && !PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
))
925 frame
->frame
= read_next_frame_reg (frame
->next
, SP_REGNUM
);
927 frame
->frame
= read_next_frame_reg (frame
->next
, PROC_FRAME_REG (proc_desc
))
928 + PROC_FRAME_OFFSET (proc_desc
);
930 if (proc_desc
== &temp_proc_desc
)
934 /* Do not set the saved registers for a sigtramp frame,
935 alpha_find_saved_registers will do that for us.
936 We can't use frame->signal_handler_caller, it is not yet set. */
937 find_pc_partial_function (frame
->pc
, &name
,
938 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
939 if (!IN_SIGTRAMP (frame
->pc
, name
))
941 frame
->saved_regs
= (CORE_ADDR
*)
942 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS
);
943 memcpy (frame
->saved_regs
, temp_saved_regs
,
944 SIZEOF_FRAME_SAVED_REGS
);
945 frame
->saved_regs
[PC_REGNUM
]
946 = frame
->saved_regs
[RA_REGNUM
];
953 alpha_frame_locals_address (struct frame_info
*fi
)
955 return (fi
->frame
- fi
->extra_info
->localoff
);
959 alpha_frame_args_address (struct frame_info
*fi
)
961 return (fi
->frame
- (ALPHA_NUM_ARG_REGS
* 8));
964 /* ALPHA stack frames are almost impenetrable. When execution stops,
965 we basically have to look at symbol information for the function
966 that we stopped in, which tells us *which* register (if any) is
967 the base of the frame pointer, and what offset from that register
968 the frame itself is at.
970 This presents a problem when trying to examine a stack in memory
971 (that isn't executing at the moment), using the "frame" command. We
972 don't have a PC, nor do we have any registers except SP.
974 This routine takes two arguments, SP and PC, and tries to make the
975 cached frames look as if these two arguments defined a frame on the
976 cache. This allows the rest of info frame to extract the important
977 arguments without difficulty. */
980 setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
983 error ("ALPHA frame specifications require two arguments: sp and pc");
985 return create_new_frame (argv
[0], argv
[1]);
988 /* The alpha passes the first six arguments in the registers, the rest on
989 the stack. The register arguments are eventually transferred to the
990 argument transfer area immediately below the stack by the called function
991 anyway. So we `push' at least six arguments on the stack, `reload' the
992 argument registers and then adjust the stack pointer to point past the
993 sixth argument. This algorithm simplifies the passing of a large struct
994 which extends from the registers to the stack.
995 If the called function is returning a structure, the address of the
996 structure to be returned is passed as a hidden first argument. */
999 alpha_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1000 int struct_return
, CORE_ADDR struct_addr
)
1003 int accumulate_size
= struct_return
? 8 : 0;
1004 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
1011 struct alpha_arg
*alpha_args
=
1012 (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
1013 register struct alpha_arg
*m_arg
;
1014 char raw_buffer
[sizeof (CORE_ADDR
)];
1015 int required_arg_regs
;
1017 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
1019 struct value
*arg
= args
[i
];
1020 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1021 /* Cast argument to long if necessary as the compiler does it too. */
1022 switch (TYPE_CODE (arg_type
))
1025 case TYPE_CODE_BOOL
:
1026 case TYPE_CODE_CHAR
:
1027 case TYPE_CODE_RANGE
:
1028 case TYPE_CODE_ENUM
:
1029 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
1031 arg_type
= builtin_type_long
;
1032 arg
= value_cast (arg_type
, arg
);
1038 m_arg
->len
= TYPE_LENGTH (arg_type
);
1039 m_arg
->offset
= accumulate_size
;
1040 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
1041 m_arg
->contents
= VALUE_CONTENTS (arg
);
1044 /* Determine required argument register loads, loading an argument register
1045 is expensive as it uses three ptrace calls. */
1046 required_arg_regs
= accumulate_size
/ 8;
1047 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
1048 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
1050 /* Make room for the arguments on the stack. */
1051 if (accumulate_size
< arg_regs_size
)
1052 accumulate_size
= arg_regs_size
;
1053 sp
-= accumulate_size
;
1055 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
1058 /* `Push' arguments on the stack. */
1059 for (i
= nargs
; m_arg
--, --i
>= 0;)
1060 write_memory (sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
1063 store_address (raw_buffer
, sizeof (CORE_ADDR
), struct_addr
);
1064 write_memory (sp
, raw_buffer
, sizeof (CORE_ADDR
));
1067 /* Load the argument registers. */
1068 for (i
= 0; i
< required_arg_regs
; i
++)
1072 val
= read_memory_integer (sp
+ i
* 8, 8);
1073 write_register (A0_REGNUM
+ i
, val
);
1074 write_register (FPA0_REGNUM
+ i
, val
);
1077 return sp
+ arg_regs_size
;
1081 alpha_push_dummy_frame (void)
1084 struct linked_proc_info
*link
;
1085 alpha_extra_func_info_t proc_desc
;
1086 CORE_ADDR sp
= read_register (SP_REGNUM
);
1087 CORE_ADDR save_address
;
1088 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1091 link
= (struct linked_proc_info
*) xmalloc (sizeof (struct linked_proc_info
));
1092 link
->next
= linked_proc_desc_table
;
1093 linked_proc_desc_table
= link
;
1095 proc_desc
= &link
->info
;
1098 * The registers we must save are all those not preserved across
1100 * In addition, we must save the PC and RA.
1102 * Dummy frame layout:
1112 * Parameter build area
1116 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
1117 #define MASK(i,j) ((((LONGEST)1 << ((j)+1)) - 1) ^ (((LONGEST)1 << (i)) - 1))
1118 #define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
1119 #define GEN_REG_SAVE_COUNT 24
1120 #define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
1121 #define FLOAT_REG_SAVE_COUNT 23
1122 /* The special register is the PC as we have no bit for it in the save masks.
1123 alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
1124 #define SPECIAL_REG_SAVE_COUNT 1
1126 PROC_REG_MASK (proc_desc
) = GEN_REG_SAVE_MASK
;
1127 PROC_FREG_MASK (proc_desc
) = FLOAT_REG_SAVE_MASK
;
1128 /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
1129 but keep SP aligned to a multiple of 16. */
1130 PROC_REG_OFFSET (proc_desc
) =
1131 -((8 * (SPECIAL_REG_SAVE_COUNT
1132 + GEN_REG_SAVE_COUNT
1133 + FLOAT_REG_SAVE_COUNT
)
1135 PROC_FREG_OFFSET (proc_desc
) =
1136 PROC_REG_OFFSET (proc_desc
) + 8 * GEN_REG_SAVE_COUNT
;
1138 /* Save general registers.
1139 The return address register is the first saved register, all other
1140 registers follow in ascending order.
1141 The PC is saved immediately below the SP. */
1142 save_address
= sp
+ PROC_REG_OFFSET (proc_desc
);
1143 store_address (raw_buffer
, 8, read_register (RA_REGNUM
));
1144 write_memory (save_address
, raw_buffer
, 8);
1146 mask
= PROC_REG_MASK (proc_desc
) & 0xffffffffL
;
1147 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1150 if (ireg
== RA_REGNUM
)
1152 store_address (raw_buffer
, 8, read_register (ireg
));
1153 write_memory (save_address
, raw_buffer
, 8);
1157 store_address (raw_buffer
, 8, read_register (PC_REGNUM
));
1158 write_memory (sp
- 8, raw_buffer
, 8);
1160 /* Save floating point registers. */
1161 save_address
= sp
+ PROC_FREG_OFFSET (proc_desc
);
1162 mask
= PROC_FREG_MASK (proc_desc
) & 0xffffffffL
;
1163 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1166 store_address (raw_buffer
, 8, read_register (ireg
+ FP0_REGNUM
));
1167 write_memory (save_address
, raw_buffer
, 8);
1171 /* Set and save the frame address for the dummy.
1172 This is tricky. The only registers that are suitable for a frame save
1173 are those that are preserved across procedure calls (s0-s6). But if
1174 a read system call is interrupted and then a dummy call is made
1175 (see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
1176 is satisfied. Then it returns with the s0-s6 registers set to the values
1177 on entry to the read system call and our dummy frame pointer would be
1178 destroyed. So we save the dummy frame in the proc_desc and handle the
1179 retrieval of the frame pointer of a dummy specifically. The frame register
1180 is set to the virtual frame (pseudo) register, it's value will always
1181 be read as zero and will help us to catch any errors in the dummy frame
1183 PROC_DUMMY_FRAME (proc_desc
) = sp
;
1184 PROC_FRAME_REG (proc_desc
) = FP_REGNUM
;
1185 PROC_FRAME_OFFSET (proc_desc
) = 0;
1186 sp
+= PROC_REG_OFFSET (proc_desc
);
1187 write_register (SP_REGNUM
, sp
);
1189 PROC_LOW_ADDR (proc_desc
) = CALL_DUMMY_ADDRESS ();
1190 PROC_HIGH_ADDR (proc_desc
) = PROC_LOW_ADDR (proc_desc
) + 4;
1192 SET_PROC_DESC_IS_DUMMY (proc_desc
);
1193 PROC_PC_REG (proc_desc
) = RA_REGNUM
;
1197 alpha_pop_frame (void)
1199 register int regnum
;
1200 struct frame_info
*frame
= get_current_frame ();
1201 CORE_ADDR new_sp
= frame
->frame
;
1203 alpha_extra_func_info_t proc_desc
= frame
->extra_info
->proc_desc
;
1205 /* we need proc_desc to know how to restore the registers;
1206 if it is NULL, construct (a temporary) one */
1207 if (proc_desc
== NULL
)
1208 proc_desc
= find_proc_desc (frame
->pc
, frame
->next
);
1210 /* Question: should we copy this proc_desc and save it in
1211 frame->proc_desc? If we do, who will free it?
1212 For now, we don't save a copy... */
1214 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
1215 if (frame
->saved_regs
== NULL
)
1216 alpha_find_saved_regs (frame
);
1219 for (regnum
= 32; --regnum
>= 0;)
1220 if (PROC_REG_MASK (proc_desc
) & (1 << regnum
))
1221 write_register (regnum
,
1222 read_memory_integer (frame
->saved_regs
[regnum
],
1224 for (regnum
= 32; --regnum
>= 0;)
1225 if (PROC_FREG_MASK (proc_desc
) & (1 << regnum
))
1226 write_register (regnum
+ FP0_REGNUM
,
1227 read_memory_integer (frame
->saved_regs
[regnum
+ FP0_REGNUM
], 8));
1229 write_register (SP_REGNUM
, new_sp
);
1230 flush_cached_frames ();
1232 if (proc_desc
&& (PROC_DESC_IS_DUMMY (proc_desc
)
1233 || PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
)))
1235 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
1237 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
1239 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
1241 if (&pi_ptr
->info
== proc_desc
)
1246 error ("Can't locate dummy extra frame info\n");
1248 if (prev_ptr
!= NULL
)
1249 prev_ptr
->next
= pi_ptr
->next
;
1251 linked_proc_desc_table
= pi_ptr
->next
;
1257 /* To skip prologues, I use this predicate. Returns either PC itself
1258 if the code at PC does not look like a function prologue; otherwise
1259 returns an address that (if we're lucky) follows the prologue. If
1260 LENIENT, then we must skip everything which is involved in setting
1261 up the frame (it's OK to skip more, just so long as we don't skip
1262 anything which might clobber the registers which are being saved.
1263 Currently we must not skip more on the alpha, but we might need the
1264 lenient stuff some day. */
1267 alpha_skip_prologue (CORE_ADDR pc
, int lenient
)
1271 CORE_ADDR post_prologue_pc
;
1274 #ifdef GDB_TARGET_HAS_SHARED_LIBS
1275 /* Silently return the unaltered pc upon memory errors.
1276 This could happen on OSF/1 if decode_line_1 tries to skip the
1277 prologue for quickstarted shared library functions when the
1278 shared library is not yet mapped in.
1279 Reading target memory is slow over serial lines, so we perform
1280 this check only if the target has shared libraries. */
1281 if (target_read_memory (pc
, buf
, 4))
1285 /* See if we can determine the end of the prologue via the symbol table.
1286 If so, then return either PC, or the PC after the prologue, whichever
1289 post_prologue_pc
= after_prologue (pc
, NULL
);
1291 if (post_prologue_pc
!= 0)
1292 return max (pc
, post_prologue_pc
);
1294 /* Can't determine prologue from the symbol table, need to examine
1297 /* Skip the typical prologue instructions. These are the stack adjustment
1298 instruction and the instructions that save registers on the stack
1299 or in the gcc frame. */
1300 for (offset
= 0; offset
< 100; offset
+= 4)
1304 status
= read_memory_nobpt (pc
+ offset
, buf
, 4);
1306 memory_error (status
, pc
+ offset
);
1307 inst
= extract_unsigned_integer (buf
, 4);
1309 /* The alpha has no delay slots. But let's keep the lenient stuff,
1310 we might need it for something else in the future. */
1314 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
1316 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
1318 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1320 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
1323 if ((inst
& 0xfc1f0000) == 0xb41e0000
1324 && (inst
& 0xffff0000) != 0xb7fe0000)
1325 continue; /* stq reg,n($sp) */
1327 if ((inst
& 0xfc1f0000) == 0x9c1e0000
1328 && (inst
& 0xffff0000) != 0x9ffe0000)
1329 continue; /* stt reg,n($sp) */
1331 if (inst
== 0x47de040f) /* bis sp,sp,fp */
1340 /* Is address PC in the prologue (loosely defined) for function at
1344 alpha_in_lenient_prologue (CORE_ADDR startaddr
, CORE_ADDR pc
)
1346 CORE_ADDR end_prologue
= alpha_skip_prologue (startaddr
, 1);
1347 return pc
>= startaddr
&& pc
< end_prologue
;
1351 /* The alpha needs a conversion between register and memory format if
1352 the register is a floating point register and
1353 memory format is float, as the register format must be double
1355 memory format is an integer with 4 bytes or less, as the representation
1356 of integers in floating point registers is different. */
1358 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
1359 char *raw_buffer
, char *virtual_buffer
)
1361 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1363 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
1367 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1369 double d
= extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1370 store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
1372 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1375 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1376 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
1377 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
1380 error ("Cannot retrieve value from floating point register");
1384 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
1385 char *virtual_buffer
, char *raw_buffer
)
1387 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1389 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
1393 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1395 double d
= extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
1396 store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
1398 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1401 if (TYPE_UNSIGNED (valtype
))
1402 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1404 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1405 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
1406 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
1409 error ("Cannot store value in floating point register");
1412 /* Given a return value in `regbuf' with a type `valtype',
1413 extract and copy its value into `valbuf'. */
1416 alpha_extract_return_value (struct type
*valtype
,
1417 char regbuf
[REGISTER_BYTES
], char *valbuf
)
1419 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1420 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
1421 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
1424 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (V0_REGNUM
), TYPE_LENGTH (valtype
));
1427 /* Given a return value in `regbuf' with a type `valtype',
1428 write its value into the appropriate register. */
1431 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
1433 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1434 int regnum
= V0_REGNUM
;
1435 int length
= TYPE_LENGTH (valtype
);
1437 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1439 regnum
= FP0_REGNUM
;
1440 length
= REGISTER_RAW_SIZE (regnum
);
1441 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
1444 memcpy (raw_buffer
, valbuf
, length
);
1446 write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
1449 /* Just like reinit_frame_cache, but with the right arguments to be
1450 callable as an sfunc. */
1453 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1455 reinit_frame_cache ();
1458 /* This is the definition of CALL_DUMMY_ADDRESS. It's a heuristic that is used
1459 to find a convenient place in the text segment to stick a breakpoint to
1460 detect the completion of a target function call (ala call_function_by_hand).
1464 alpha_call_dummy_address (void)
1467 struct minimal_symbol
*sym
;
1469 entry
= entry_point_address ();
1474 sym
= lookup_minimal_symbol ("_Prelude", NULL
, symfile_objfile
);
1476 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1479 return SYMBOL_VALUE_ADDRESS (sym
) + 4;
1483 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
1485 /* Structures are returned by ref in extra arg0. */
1489 /* alpha_software_single_step() is called just before we want to resume
1490 the inferior, if we want to single-step it but there is no hardware
1491 or kernel single-step support (NetBSD on Alpha, for example). We find
1492 the target of the coming instruction and breakpoint it.
1494 single_step is also called just after the inferior stops. If we had
1495 set up a simulated single-step, we undo our damage. */
1498 alpha_next_pc (CORE_ADDR pc
)
1505 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1507 /* Opcode is top 6 bits. */
1508 op
= (insn
>> 26) & 0x3f;
1512 /* Jump format: target PC is:
1514 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1517 if ((op
& 0x30) == 0x30)
1519 /* Branch format: target PC is:
1520 (new PC) + (4 * sext(displacement)) */
1521 if (op
== 0x30 || /* BR */
1522 op
== 0x34) /* BSR */
1525 offset
= (insn
& 0x001fffff);
1526 if (offset
& 0x00100000)
1527 offset
|= 0xffe00000;
1529 return (pc
+ 4 + offset
);
1532 /* Need to determine if branch is taken; read RA. */
1533 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1536 case 0x38: /* BLBC */
1540 case 0x3c: /* BLBS */
1544 case 0x39: /* BEQ */
1548 case 0x3d: /* BNE */
1552 case 0x3a: /* BLT */
1556 case 0x3b: /* BLE */
1560 case 0x3f: /* BGT */
1564 case 0x3e: /* BGE */
1571 /* Not a branch or branch not taken; target PC is:
1577 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1579 static CORE_ADDR next_pc
;
1580 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1581 static binsn_quantum break_mem
;
1584 if (insert_breakpoints_p
)
1587 next_pc
= alpha_next_pc (pc
);
1589 target_insert_breakpoint (next_pc
, break_mem
);
1593 target_remove_breakpoint (next_pc
, break_mem
);
1599 _initialize_alpha_tdep (void)
1601 struct cmd_list_element
*c
;
1603 tm_print_insn
= print_insn_alpha
;
1605 /* Let the user set the fence post for heuristic_proc_start. */
1607 /* We really would like to have both "0" and "unlimited" work, but
1608 command.c doesn't deal with that. So make it a var_zinteger
1609 because the user can always use "999999" or some such for unlimited. */
1610 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1611 (char *) &heuristic_fence_post
,
1613 Set the distance searched for the start of a function.\n\
1614 If you are debugging a stripped executable, GDB needs to search through the\n\
1615 program for the start of a function. This command sets the distance of the\n\
1616 search. The only need to set it is when debugging a stripped executable.",
1618 /* We need to throw away the frame cache when we set this, since it
1619 might change our ability to get backtraces. */
1620 c
->function
.sfunc
= reinit_frame_cache_sfunc
;
1621 add_show_from_set (c
, &showlist
);