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 /* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
39 /* Prototypes for local functions. */
41 static alpha_extra_func_info_t
push_sigtramp_desc (CORE_ADDR low_addr
);
43 static CORE_ADDR
read_next_frame_reg (struct frame_info
*, int);
45 static CORE_ADDR
heuristic_proc_start (CORE_ADDR
);
47 static alpha_extra_func_info_t
heuristic_proc_desc (CORE_ADDR
,
51 static alpha_extra_func_info_t
find_proc_desc (CORE_ADDR
,
55 static int alpha_in_lenient_prologue (CORE_ADDR
, CORE_ADDR
);
58 static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element
*);
60 static CORE_ADDR
after_prologue (CORE_ADDR pc
,
61 alpha_extra_func_info_t proc_desc
);
63 static int alpha_in_prologue (CORE_ADDR pc
,
64 alpha_extra_func_info_t proc_desc
);
66 static int alpha_about_to_return (CORE_ADDR pc
);
68 void _initialize_alpha_tdep (void);
70 /* Heuristic_proc_start may hunt through the text section for a long
71 time across a 2400 baud serial line. Allows the user to limit this
73 static unsigned int heuristic_fence_post
= 0;
75 /* Layout of a stack frame on the alpha:
78 pdr members: | 7th ... nth arg, |
79 | `pushed' by caller. |
81 ----------------|-------------------------------|<-- old_sp == vfp
84 | |localoff | Copies of 1st .. 6th |
85 | | | | | argument if necessary. |
87 | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS
89 | | | | Locals and temporaries. |
91 | | | |-------------------------------|
93 |-fregoffset | Saved float registers. |
99 | | -------|-------------------------------|
101 | | | Saved registers. |
108 | ----------|-------------------------------|
110 frameoffset | Argument build area, gets |
111 | | 7th ... nth arg for any |
112 | | called procedure. |
114 -------------|-------------------------------|<-- sp
121 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
122 /* These next two fields are kind of being hijacked. I wonder if
123 iline is too small for the values it needs to hold, if GDB is
124 running on a 32-bit host. */
125 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
126 #define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset) /*CALL_DUMMY frame */
127 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
128 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
129 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
130 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
131 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
132 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
133 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
134 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
135 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
136 #define _PROC_MAGIC_ 0x0F0F0F0F
137 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
138 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
140 struct linked_proc_info
142 struct alpha_extra_func_info info
;
143 struct linked_proc_info
*next
;
145 *linked_proc_desc_table
= NULL
;
148 alpha_osf_in_sigtramp (CORE_ADDR pc
, char *func_name
)
150 return (func_name
!= NULL
&& STREQ ("__sigtramp", func_name
));
153 /* Under GNU/Linux, signal handler invocations can be identified by the
154 designated code sequence that is used to return from a signal
155 handler. In particular, the return address of a signal handler
156 points to the following sequence (the first instruction is quadword
163 Each instruction has a unique encoding, so we simply attempt to
164 match the instruction the pc is pointing to with any of the above
165 instructions. If there is a hit, we know the offset to the start
166 of the designated sequence and can then check whether we really are
167 executing in a designated sequence. If not, -1 is returned,
168 otherwise the offset from the start of the desingated sequence is
171 There is a slight chance of false hits: code could jump into the
172 middle of the designated sequence, in which case there is no
173 guarantee that we are in the middle of a sigreturn syscall. Don't
174 think this will be a problem in praxis, though.
177 #ifndef TM_LINUXALPHA_H
178 /* HACK: Provide a prototype when compiling this file for non
179 linuxalpha targets. */
180 long alpha_linux_sigtramp_offset (CORE_ADDR pc
);
183 alpha_linux_sigtramp_offset (CORE_ADDR pc
)
185 unsigned int i
[3], w
;
188 if (read_memory_nobpt (pc
, (char *) &w
, 4) != 0)
196 break; /* bis $30,$30,$16 */
199 break; /* addq $31,0x67,$0 */
202 break; /* call_pal callsys */
209 /* designated sequence is not quadword aligned */
213 if (read_memory_nobpt (pc
, (char *) i
, sizeof (i
)) != 0)
216 if (i
[0] == 0x47de0410 && i
[1] == 0x43ecf400 && i
[2] == 0x00000083)
223 /* Under OSF/1, the __sigtramp routine is frameless and has a frame
224 size of zero, but we are able to backtrace through it. */
226 alpha_osf_skip_sigtramp_frame (struct frame_info
*frame
, CORE_ADDR pc
)
229 find_pc_partial_function (pc
, &name
, (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
230 if (IN_SIGTRAMP (pc
, name
))
237 /* Dynamically create a signal-handler caller procedure descriptor for
238 the signal-handler return code starting at address LOW_ADDR. The
239 descriptor is added to the linked_proc_desc_table. */
241 static alpha_extra_func_info_t
242 push_sigtramp_desc (CORE_ADDR low_addr
)
244 struct linked_proc_info
*link
;
245 alpha_extra_func_info_t proc_desc
;
247 link
= (struct linked_proc_info
*)
248 xmalloc (sizeof (struct linked_proc_info
));
249 link
->next
= linked_proc_desc_table
;
250 linked_proc_desc_table
= link
;
252 proc_desc
= &link
->info
;
254 proc_desc
->numargs
= 0;
255 PROC_LOW_ADDR (proc_desc
) = low_addr
;
256 PROC_HIGH_ADDR (proc_desc
) = low_addr
+ 3 * 4;
257 PROC_DUMMY_FRAME (proc_desc
) = 0;
258 PROC_FRAME_OFFSET (proc_desc
) = 0x298; /* sizeof(struct sigcontext_struct) */
259 PROC_FRAME_REG (proc_desc
) = SP_REGNUM
;
260 PROC_REG_MASK (proc_desc
) = 0xffff;
261 PROC_FREG_MASK (proc_desc
) = 0xffff;
262 PROC_PC_REG (proc_desc
) = 26;
263 PROC_LOCALOFF (proc_desc
) = 0;
264 SET_PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
);
270 alpha_register_name (int regno
)
272 static char *register_names
[] =
274 "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6",
275 "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp",
276 "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9",
277 "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero",
278 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
279 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
280 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
281 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr",
287 if (regno
>= (sizeof(register_names
) / sizeof(*register_names
)))
289 return (register_names
[regno
]);
293 alpha_cannot_fetch_register (int regno
)
295 return (regno
== FP_REGNUM
|| regno
== ZERO_REGNUM
);
299 alpha_cannot_store_register (int regno
)
301 return (regno
== FP_REGNUM
|| regno
== ZERO_REGNUM
);
305 alpha_register_convertible (int regno
)
307 return (regno
>= FP0_REGNUM
&& regno
<= FP0_REGNUM
+ 31);
311 /* Guaranteed to set frame->saved_regs to some values (it never leaves it
315 alpha_find_saved_regs (struct frame_info
*frame
)
318 CORE_ADDR reg_position
;
320 alpha_extra_func_info_t proc_desc
;
323 frame_saved_regs_zalloc (frame
);
325 /* If it is the frame for __sigtramp, the saved registers are located
326 in a sigcontext structure somewhere on the stack. __sigtramp
327 passes a pointer to the sigcontext structure on the stack.
328 If the stack layout for __sigtramp changes, or if sigcontext offsets
329 change, we might have to update this code. */
330 #ifndef SIGFRAME_PC_OFF
331 #define SIGFRAME_PC_OFF (2 * 8)
332 #define SIGFRAME_REGSAVE_OFF (4 * 8)
333 #define SIGFRAME_FPREGSAVE_OFF (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)
335 if (frame
->signal_handler_caller
)
337 CORE_ADDR sigcontext_addr
;
339 sigcontext_addr
= SIGCONTEXT_ADDR (frame
);
340 for (ireg
= 0; ireg
< 32; ireg
++)
342 reg_position
= sigcontext_addr
+ SIGFRAME_REGSAVE_OFF
+ ireg
* 8;
343 frame
->saved_regs
[ireg
] = reg_position
;
345 for (ireg
= 0; ireg
< 32; ireg
++)
347 reg_position
= sigcontext_addr
+ SIGFRAME_FPREGSAVE_OFF
+ ireg
* 8;
348 frame
->saved_regs
[FP0_REGNUM
+ ireg
] = reg_position
;
350 frame
->saved_regs
[PC_REGNUM
] = sigcontext_addr
+ SIGFRAME_PC_OFF
;
354 proc_desc
= frame
->proc_desc
;
355 if (proc_desc
== NULL
)
356 /* I'm not sure how/whether this can happen. Normally when we can't
357 find a proc_desc, we "synthesize" one using heuristic_proc_desc
358 and set the saved_regs right away. */
361 /* Fill in the offsets for the registers which gen_mask says
364 reg_position
= frame
->frame
+ PROC_REG_OFFSET (proc_desc
);
365 mask
= PROC_REG_MASK (proc_desc
);
367 returnreg
= PROC_PC_REG (proc_desc
);
369 /* Note that RA is always saved first, regardless of its actual
371 if (mask
& (1 << returnreg
))
373 frame
->saved_regs
[returnreg
] = reg_position
;
375 mask
&= ~(1 << returnreg
); /* Clear bit for RA so we
376 don't save again later. */
379 for (ireg
= 0; ireg
<= 31; ++ireg
)
380 if (mask
& (1 << ireg
))
382 frame
->saved_regs
[ireg
] = reg_position
;
386 /* Fill in the offsets for the registers which float_mask says
389 reg_position
= frame
->frame
+ PROC_FREG_OFFSET (proc_desc
);
390 mask
= PROC_FREG_MASK (proc_desc
);
392 for (ireg
= 0; ireg
<= 31; ++ireg
)
393 if (mask
& (1 << ireg
))
395 frame
->saved_regs
[FP0_REGNUM
+ ireg
] = reg_position
;
399 frame
->saved_regs
[PC_REGNUM
] = frame
->saved_regs
[returnreg
];
403 read_next_frame_reg (struct frame_info
*fi
, int regno
)
405 for (; fi
; fi
= fi
->next
)
407 /* We have to get the saved sp from the sigcontext
408 if it is a signal handler frame. */
409 if (regno
== SP_REGNUM
&& !fi
->signal_handler_caller
)
413 if (fi
->saved_regs
== NULL
)
414 alpha_find_saved_regs (fi
);
415 if (fi
->saved_regs
[regno
])
416 return read_memory_integer (fi
->saved_regs
[regno
], 8);
419 return read_register (regno
);
423 alpha_frame_saved_pc (struct frame_info
*frame
)
425 alpha_extra_func_info_t proc_desc
= frame
->proc_desc
;
426 /* We have to get the saved pc from the sigcontext
427 if it is a signal handler frame. */
428 int pcreg
= frame
->signal_handler_caller
? PC_REGNUM
: frame
->pc_reg
;
430 if (proc_desc
&& PROC_DESC_IS_DUMMY (proc_desc
))
431 return read_memory_integer (frame
->frame
- 8, 8);
433 return read_next_frame_reg (frame
, pcreg
);
437 alpha_saved_pc_after_call (struct frame_info
*frame
)
439 CORE_ADDR pc
= frame
->pc
;
441 alpha_extra_func_info_t proc_desc
;
444 /* Skip over shared library trampoline if necessary. */
445 tmp
= SKIP_TRAMPOLINE_CODE (pc
);
449 proc_desc
= find_proc_desc (pc
, frame
->next
);
450 pcreg
= proc_desc
? PROC_PC_REG (proc_desc
) : RA_REGNUM
;
452 if (frame
->signal_handler_caller
)
453 return alpha_frame_saved_pc (frame
);
455 return read_register (pcreg
);
459 static struct alpha_extra_func_info temp_proc_desc
;
460 static struct frame_saved_regs temp_saved_regs
;
462 /* Nonzero if instruction at PC is a return instruction. "ret
463 $zero,($ra),1" on alpha. */
466 alpha_about_to_return (CORE_ADDR pc
)
468 return read_memory_integer (pc
, 4) == 0x6bfa8001;
473 /* This fencepost looks highly suspicious to me. Removing it also
474 seems suspicious as it could affect remote debugging across serial
478 heuristic_proc_start (CORE_ADDR pc
)
480 CORE_ADDR start_pc
= pc
;
481 CORE_ADDR fence
= start_pc
- heuristic_fence_post
;
486 if (heuristic_fence_post
== UINT_MAX
487 || fence
< VM_MIN_ADDRESS
)
488 fence
= VM_MIN_ADDRESS
;
490 /* search back for previous return */
491 for (start_pc
-= 4;; start_pc
-= 4)
492 if (start_pc
< fence
)
494 /* It's not clear to me why we reach this point when
495 stop_soon_quietly, but with this test, at least we
496 don't print out warnings for every child forked (eg, on
497 decstation). 22apr93 rich@cygnus.com. */
498 if (!stop_soon_quietly
)
500 static int blurb_printed
= 0;
502 if (fence
== VM_MIN_ADDRESS
)
503 warning ("Hit beginning of text section without finding");
505 warning ("Hit heuristic-fence-post without finding");
507 warning ("enclosing function for address 0x%s", paddr_nz (pc
));
511 This warning occurs if you are debugging a function without any symbols\n\
512 (for example, in a stripped executable). In that case, you may wish to\n\
513 increase the size of the search with the `set heuristic-fence-post' command.\n\
515 Otherwise, you told GDB there was a function where there isn't one, or\n\
516 (more likely) you have encountered a bug in GDB.\n");
523 else if (alpha_about_to_return (start_pc
))
526 start_pc
+= 4; /* skip return */
530 static alpha_extra_func_info_t
531 heuristic_proc_desc (CORE_ADDR start_pc
, CORE_ADDR limit_pc
,
532 struct frame_info
*next_frame
)
534 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
537 int has_frame_reg
= 0;
538 unsigned long reg_mask
= 0;
543 memset (&temp_proc_desc
, '\0', sizeof (temp_proc_desc
));
544 memset (&temp_saved_regs
, '\0', sizeof (struct frame_saved_regs
));
545 PROC_LOW_ADDR (&temp_proc_desc
) = start_pc
;
547 if (start_pc
+ 200 < limit_pc
)
548 limit_pc
= start_pc
+ 200;
550 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
556 status
= read_memory_nobpt (cur_pc
, buf
, 4);
558 memory_error (status
, cur_pc
);
559 word
= extract_unsigned_integer (buf
, 4);
561 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
564 frame_size
+= (-word
) & 0xffff;
566 /* Exit loop if a positive stack adjustment is found, which
567 usually means that the stack cleanup code in the function
568 epilogue is reached. */
571 else if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
572 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
574 int reg
= (word
& 0x03e00000) >> 21;
575 reg_mask
|= 1 << reg
;
576 temp_saved_regs
.regs
[reg
] = sp
+ (short) word
;
578 /* Starting with OSF/1-3.2C, the system libraries are shipped
579 without local symbols, but they still contain procedure
580 descriptors without a symbol reference. GDB is currently
581 unable to find these procedure descriptors and uses
582 heuristic_proc_desc instead.
583 As some low level compiler support routines (__div*, __add*)
584 use a non-standard return address register, we have to
585 add some heuristics to determine the return address register,
586 or stepping over these routines will fail.
587 Usually the return address register is the first register
588 saved on the stack, but assembler optimization might
589 rearrange the register saves.
590 So we recognize only a few registers (t7, t9, ra) within
591 the procedure prologue as valid return address registers.
592 If we encounter a return instruction, we extract the
593 the return address register from it.
595 FIXME: Rewriting GDB to access the procedure descriptors,
596 e.g. via the minimal symbol table, might obviate this hack. */
598 && cur_pc
< (start_pc
+ 80)
599 && (reg
== T7_REGNUM
|| reg
== T9_REGNUM
|| reg
== RA_REGNUM
))
602 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
603 pcreg
= (word
>> 16) & 0x1f;
604 else if (word
== 0x47de040f) /* bis sp,sp fp */
609 /* If we haven't found a valid return address register yet,
610 keep searching in the procedure prologue. */
611 while (cur_pc
< (limit_pc
+ 80) && cur_pc
< (start_pc
+ 80))
616 if (read_memory_nobpt (cur_pc
, buf
, 4))
619 word
= extract_unsigned_integer (buf
, 4);
621 if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
622 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
624 int reg
= (word
& 0x03e00000) >> 21;
625 if (reg
== T7_REGNUM
|| reg
== T9_REGNUM
|| reg
== RA_REGNUM
)
631 else if ((word
& 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
633 pcreg
= (word
>> 16) & 0x1f;
640 PROC_FRAME_REG (&temp_proc_desc
) = GCC_FP_REGNUM
;
642 PROC_FRAME_REG (&temp_proc_desc
) = SP_REGNUM
;
643 PROC_FRAME_OFFSET (&temp_proc_desc
) = frame_size
;
644 PROC_REG_MASK (&temp_proc_desc
) = reg_mask
;
645 PROC_PC_REG (&temp_proc_desc
) = (pcreg
== -1) ? RA_REGNUM
: pcreg
;
646 PROC_LOCALOFF (&temp_proc_desc
) = 0; /* XXX - bogus */
647 return &temp_proc_desc
;
650 /* This returns the PC of the first inst after the prologue. If we can't
651 find the prologue, then return 0. */
654 after_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
656 struct symtab_and_line sal
;
657 CORE_ADDR func_addr
, func_end
;
660 proc_desc
= find_proc_desc (pc
, NULL
);
664 if (PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
))
665 return PROC_LOW_ADDR (proc_desc
); /* "prologue" is in kernel */
667 /* If function is frameless, then we need to do it the hard way. I
668 strongly suspect that frameless always means prologueless... */
669 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
670 && PROC_FRAME_OFFSET (proc_desc
) == 0)
674 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
675 return 0; /* Unknown */
677 sal
= find_pc_line (func_addr
, 0);
679 if (sal
.end
< func_end
)
682 /* The line after the prologue is after the end of the function. In this
683 case, tell the caller to find the prologue the hard way. */
688 /* Return non-zero if we *might* be in a function prologue. Return zero if we
689 are definitively *not* in a function prologue. */
692 alpha_in_prologue (CORE_ADDR pc
, alpha_extra_func_info_t proc_desc
)
694 CORE_ADDR after_prologue_pc
;
696 after_prologue_pc
= after_prologue (pc
, proc_desc
);
698 if (after_prologue_pc
== 0
699 || pc
< after_prologue_pc
)
705 static alpha_extra_func_info_t
706 find_proc_desc (CORE_ADDR pc
, struct frame_info
*next_frame
)
708 alpha_extra_func_info_t proc_desc
;
713 /* Try to get the proc_desc from the linked call dummy proc_descs
714 if the pc is in the call dummy.
715 This is hairy. In the case of nested dummy calls we have to find the
716 right proc_desc, but we might not yet know the frame for the dummy
717 as it will be contained in the proc_desc we are searching for.
718 So we have to find the proc_desc whose frame is closest to the current
721 if (PC_IN_CALL_DUMMY (pc
, 0, 0))
723 struct linked_proc_info
*link
;
724 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
725 alpha_extra_func_info_t found_proc_desc
= NULL
;
726 long min_distance
= LONG_MAX
;
728 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
730 long distance
= (CORE_ADDR
) PROC_DUMMY_FRAME (&link
->info
) - sp
;
731 if (distance
> 0 && distance
< min_distance
)
733 min_distance
= distance
;
734 found_proc_desc
= &link
->info
;
737 if (found_proc_desc
!= NULL
)
738 return found_proc_desc
;
741 b
= block_for_pc (pc
);
743 find_pc_partial_function (pc
, NULL
, &startaddr
, NULL
);
748 if (startaddr
> BLOCK_START (b
))
749 /* This is the "pathological" case referred to in a comment in
750 print_frame_info. It might be better to move this check into
754 sym
= lookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
,
758 /* If we never found a PDR for this function in symbol reading, then
759 examine prologues to find the information. */
760 if (sym
&& ((mips_extra_func_info_t
) SYMBOL_VALUE (sym
))->pdr
.framereg
== -1)
765 /* IF this is the topmost frame AND
766 * (this proc does not have debugging information OR
767 * the PC is in the procedure prologue)
768 * THEN create a "heuristic" proc_desc (by analyzing
769 * the actual code) to replace the "official" proc_desc.
771 proc_desc
= (alpha_extra_func_info_t
) SYMBOL_VALUE (sym
);
772 if (next_frame
== NULL
)
774 if (PROC_DESC_IS_DUMMY (proc_desc
) || alpha_in_prologue (pc
, proc_desc
))
776 alpha_extra_func_info_t found_heuristic
=
777 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc
),
781 PROC_LOCALOFF (found_heuristic
) =
782 PROC_LOCALOFF (proc_desc
);
783 PROC_PC_REG (found_heuristic
) = PROC_PC_REG (proc_desc
);
784 proc_desc
= found_heuristic
;
793 /* Is linked_proc_desc_table really necessary? It only seems to be used
794 by procedure call dummys. However, the procedures being called ought
795 to have their own proc_descs, and even if they don't,
796 heuristic_proc_desc knows how to create them! */
798 register struct linked_proc_info
*link
;
799 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
800 if (PROC_LOW_ADDR (&link
->info
) <= pc
801 && PROC_HIGH_ADDR (&link
->info
) > pc
)
804 /* If PC is inside a dynamically generated sigtramp handler,
805 create and push a procedure descriptor for that code: */
806 offset
= DYNAMIC_SIGTRAMP_OFFSET (pc
);
808 return push_sigtramp_desc (pc
- offset
);
810 /* If heuristic_fence_post is non-zero, determine the procedure
811 start address by examining the instructions.
812 This allows us to find the start address of static functions which
813 have no symbolic information, as startaddr would have been set to
814 the preceding global function start address by the
815 find_pc_partial_function call above. */
816 if (startaddr
== 0 || heuristic_fence_post
!= 0)
817 startaddr
= heuristic_proc_start (pc
);
820 heuristic_proc_desc (startaddr
, pc
, next_frame
);
825 alpha_extra_func_info_t cached_proc_desc
;
828 alpha_frame_chain (struct frame_info
*frame
)
830 alpha_extra_func_info_t proc_desc
;
831 CORE_ADDR saved_pc
= FRAME_SAVED_PC (frame
);
833 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
836 proc_desc
= find_proc_desc (saved_pc
, frame
);
840 cached_proc_desc
= proc_desc
;
842 /* Fetch the frame pointer for a dummy frame from the procedure
844 if (PROC_DESC_IS_DUMMY (proc_desc
))
845 return (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
847 /* If no frame pointer and frame size is zero, we must be at end
848 of stack (or otherwise hosed). If we don't check frame size,
849 we loop forever if we see a zero size frame. */
850 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
851 && PROC_FRAME_OFFSET (proc_desc
) == 0
852 /* The previous frame from a sigtramp frame might be frameless
853 and have frame size zero. */
854 && !frame
->signal_handler_caller
)
855 return FRAME_PAST_SIGTRAMP_FRAME (frame
, saved_pc
);
857 return read_next_frame_reg (frame
, PROC_FRAME_REG (proc_desc
))
858 + PROC_FRAME_OFFSET (proc_desc
);
862 init_extra_frame_info (struct frame_info
*frame
)
864 /* Use proc_desc calculated in frame_chain */
865 alpha_extra_func_info_t proc_desc
=
866 frame
->next
? cached_proc_desc
: find_proc_desc (frame
->pc
, frame
->next
);
868 frame
->saved_regs
= NULL
;
870 frame
->pc_reg
= RA_REGNUM
;
871 frame
->proc_desc
= proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
874 /* Get the locals offset and the saved pc register from the
875 procedure descriptor, they are valid even if we are in the
876 middle of the prologue. */
877 frame
->localoff
= PROC_LOCALOFF (proc_desc
);
878 frame
->pc_reg
= PROC_PC_REG (proc_desc
);
880 /* Fixup frame-pointer - only needed for top frame */
882 /* Fetch the frame pointer for a dummy frame from the procedure
884 if (PROC_DESC_IS_DUMMY (proc_desc
))
885 frame
->frame
= (CORE_ADDR
) PROC_DUMMY_FRAME (proc_desc
);
887 /* This may not be quite right, if proc has a real frame register.
888 Get the value of the frame relative sp, procedure might have been
889 interrupted by a signal at it's very start. */
890 else if (frame
->pc
== PROC_LOW_ADDR (proc_desc
)
891 && !PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
))
892 frame
->frame
= read_next_frame_reg (frame
->next
, SP_REGNUM
);
894 frame
->frame
= read_next_frame_reg (frame
->next
, PROC_FRAME_REG (proc_desc
))
895 + PROC_FRAME_OFFSET (proc_desc
);
897 if (proc_desc
== &temp_proc_desc
)
901 /* Do not set the saved registers for a sigtramp frame,
902 alpha_find_saved_registers will do that for us.
903 We can't use frame->signal_handler_caller, it is not yet set. */
904 find_pc_partial_function (frame
->pc
, &name
,
905 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
906 if (!IN_SIGTRAMP (frame
->pc
, name
))
908 frame
->saved_regs
= (CORE_ADDR
*)
909 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS
);
910 memcpy (frame
->saved_regs
, temp_saved_regs
.regs
, SIZEOF_FRAME_SAVED_REGS
);
911 frame
->saved_regs
[PC_REGNUM
]
912 = frame
->saved_regs
[RA_REGNUM
];
918 /* ALPHA stack frames are almost impenetrable. When execution stops,
919 we basically have to look at symbol information for the function
920 that we stopped in, which tells us *which* register (if any) is
921 the base of the frame pointer, and what offset from that register
922 the frame itself is at.
924 This presents a problem when trying to examine a stack in memory
925 (that isn't executing at the moment), using the "frame" command. We
926 don't have a PC, nor do we have any registers except SP.
928 This routine takes two arguments, SP and PC, and tries to make the
929 cached frames look as if these two arguments defined a frame on the
930 cache. This allows the rest of info frame to extract the important
931 arguments without difficulty. */
934 setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
937 error ("ALPHA frame specifications require two arguments: sp and pc");
939 return create_new_frame (argv
[0], argv
[1]);
942 /* The alpha passes the first six arguments in the registers, the rest on
943 the stack. The register arguments are eventually transferred to the
944 argument transfer area immediately below the stack by the called function
945 anyway. So we `push' at least six arguments on the stack, `reload' the
946 argument registers and then adjust the stack pointer to point past the
947 sixth argument. This algorithm simplifies the passing of a large struct
948 which extends from the registers to the stack.
949 If the called function is returning a structure, the address of the
950 structure to be returned is passed as a hidden first argument. */
953 alpha_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
954 int struct_return
, CORE_ADDR struct_addr
)
957 int accumulate_size
= struct_return
? 8 : 0;
958 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
965 struct alpha_arg
*alpha_args
=
966 (struct alpha_arg
*) alloca (nargs
* sizeof (struct alpha_arg
));
967 register struct alpha_arg
*m_arg
;
968 char raw_buffer
[sizeof (CORE_ADDR
)];
969 int required_arg_regs
;
971 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
973 struct value
*arg
= args
[i
];
974 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
975 /* Cast argument to long if necessary as the compiler does it too. */
976 switch (TYPE_CODE (arg_type
))
981 case TYPE_CODE_RANGE
:
983 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
985 arg_type
= builtin_type_long
;
986 arg
= value_cast (arg_type
, arg
);
992 m_arg
->len
= TYPE_LENGTH (arg_type
);
993 m_arg
->offset
= accumulate_size
;
994 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
995 m_arg
->contents
= VALUE_CONTENTS (arg
);
998 /* Determine required argument register loads, loading an argument register
999 is expensive as it uses three ptrace calls. */
1000 required_arg_regs
= accumulate_size
/ 8;
1001 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
1002 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
1004 /* Make room for the arguments on the stack. */
1005 if (accumulate_size
< arg_regs_size
)
1006 accumulate_size
= arg_regs_size
;
1007 sp
-= accumulate_size
;
1009 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
1012 /* `Push' arguments on the stack. */
1013 for (i
= nargs
; m_arg
--, --i
>= 0;)
1014 write_memory (sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
1017 store_address (raw_buffer
, sizeof (CORE_ADDR
), struct_addr
);
1018 write_memory (sp
, raw_buffer
, sizeof (CORE_ADDR
));
1021 /* Load the argument registers. */
1022 for (i
= 0; i
< required_arg_regs
; i
++)
1026 val
= read_memory_integer (sp
+ i
* 8, 8);
1027 write_register (A0_REGNUM
+ i
, val
);
1028 write_register (FPA0_REGNUM
+ i
, val
);
1031 return sp
+ arg_regs_size
;
1035 alpha_push_dummy_frame (void)
1038 struct linked_proc_info
*link
;
1039 alpha_extra_func_info_t proc_desc
;
1040 CORE_ADDR sp
= read_register (SP_REGNUM
);
1041 CORE_ADDR save_address
;
1042 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1045 link
= (struct linked_proc_info
*) xmalloc (sizeof (struct linked_proc_info
));
1046 link
->next
= linked_proc_desc_table
;
1047 linked_proc_desc_table
= link
;
1049 proc_desc
= &link
->info
;
1052 * The registers we must save are all those not preserved across
1054 * In addition, we must save the PC and RA.
1056 * Dummy frame layout:
1066 * Parameter build area
1070 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
1071 #define MASK(i,j) ((((LONGEST)1 << ((j)+1)) - 1) ^ (((LONGEST)1 << (i)) - 1))
1072 #define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
1073 #define GEN_REG_SAVE_COUNT 24
1074 #define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
1075 #define FLOAT_REG_SAVE_COUNT 23
1076 /* The special register is the PC as we have no bit for it in the save masks.
1077 alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
1078 #define SPECIAL_REG_SAVE_COUNT 1
1080 PROC_REG_MASK (proc_desc
) = GEN_REG_SAVE_MASK
;
1081 PROC_FREG_MASK (proc_desc
) = FLOAT_REG_SAVE_MASK
;
1082 /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
1083 but keep SP aligned to a multiple of 16. */
1084 PROC_REG_OFFSET (proc_desc
) =
1085 -((8 * (SPECIAL_REG_SAVE_COUNT
1086 + GEN_REG_SAVE_COUNT
1087 + FLOAT_REG_SAVE_COUNT
)
1089 PROC_FREG_OFFSET (proc_desc
) =
1090 PROC_REG_OFFSET (proc_desc
) + 8 * GEN_REG_SAVE_COUNT
;
1092 /* Save general registers.
1093 The return address register is the first saved register, all other
1094 registers follow in ascending order.
1095 The PC is saved immediately below the SP. */
1096 save_address
= sp
+ PROC_REG_OFFSET (proc_desc
);
1097 store_address (raw_buffer
, 8, read_register (RA_REGNUM
));
1098 write_memory (save_address
, raw_buffer
, 8);
1100 mask
= PROC_REG_MASK (proc_desc
) & 0xffffffffL
;
1101 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1104 if (ireg
== RA_REGNUM
)
1106 store_address (raw_buffer
, 8, read_register (ireg
));
1107 write_memory (save_address
, raw_buffer
, 8);
1111 store_address (raw_buffer
, 8, read_register (PC_REGNUM
));
1112 write_memory (sp
- 8, raw_buffer
, 8);
1114 /* Save floating point registers. */
1115 save_address
= sp
+ PROC_FREG_OFFSET (proc_desc
);
1116 mask
= PROC_FREG_MASK (proc_desc
) & 0xffffffffL
;
1117 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
1120 store_address (raw_buffer
, 8, read_register (ireg
+ FP0_REGNUM
));
1121 write_memory (save_address
, raw_buffer
, 8);
1125 /* Set and save the frame address for the dummy.
1126 This is tricky. The only registers that are suitable for a frame save
1127 are those that are preserved across procedure calls (s0-s6). But if
1128 a read system call is interrupted and then a dummy call is made
1129 (see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
1130 is satisfied. Then it returns with the s0-s6 registers set to the values
1131 on entry to the read system call and our dummy frame pointer would be
1132 destroyed. So we save the dummy frame in the proc_desc and handle the
1133 retrieval of the frame pointer of a dummy specifically. The frame register
1134 is set to the virtual frame (pseudo) register, it's value will always
1135 be read as zero and will help us to catch any errors in the dummy frame
1137 PROC_DUMMY_FRAME (proc_desc
) = sp
;
1138 PROC_FRAME_REG (proc_desc
) = FP_REGNUM
;
1139 PROC_FRAME_OFFSET (proc_desc
) = 0;
1140 sp
+= PROC_REG_OFFSET (proc_desc
);
1141 write_register (SP_REGNUM
, sp
);
1143 PROC_LOW_ADDR (proc_desc
) = CALL_DUMMY_ADDRESS ();
1144 PROC_HIGH_ADDR (proc_desc
) = PROC_LOW_ADDR (proc_desc
) + 4;
1146 SET_PROC_DESC_IS_DUMMY (proc_desc
);
1147 PROC_PC_REG (proc_desc
) = RA_REGNUM
;
1151 alpha_pop_frame (void)
1153 register int regnum
;
1154 struct frame_info
*frame
= get_current_frame ();
1155 CORE_ADDR new_sp
= frame
->frame
;
1157 alpha_extra_func_info_t proc_desc
= frame
->proc_desc
;
1159 /* we need proc_desc to know how to restore the registers;
1160 if it is NULL, construct (a temporary) one */
1161 if (proc_desc
== NULL
)
1162 proc_desc
= find_proc_desc (frame
->pc
, frame
->next
);
1164 /* Question: should we copy this proc_desc and save it in
1165 frame->proc_desc? If we do, who will free it?
1166 For now, we don't save a copy... */
1168 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
1169 if (frame
->saved_regs
== NULL
)
1170 alpha_find_saved_regs (frame
);
1173 for (regnum
= 32; --regnum
>= 0;)
1174 if (PROC_REG_MASK (proc_desc
) & (1 << regnum
))
1175 write_register (regnum
,
1176 read_memory_integer (frame
->saved_regs
[regnum
],
1178 for (regnum
= 32; --regnum
>= 0;)
1179 if (PROC_FREG_MASK (proc_desc
) & (1 << regnum
))
1180 write_register (regnum
+ FP0_REGNUM
,
1181 read_memory_integer (frame
->saved_regs
[regnum
+ FP0_REGNUM
], 8));
1183 write_register (SP_REGNUM
, new_sp
);
1184 flush_cached_frames ();
1186 if (proc_desc
&& (PROC_DESC_IS_DUMMY (proc_desc
)
1187 || PROC_DESC_IS_DYN_SIGTRAMP (proc_desc
)))
1189 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
1191 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
1193 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
1195 if (&pi_ptr
->info
== proc_desc
)
1200 error ("Can't locate dummy extra frame info\n");
1202 if (prev_ptr
!= NULL
)
1203 prev_ptr
->next
= pi_ptr
->next
;
1205 linked_proc_desc_table
= pi_ptr
->next
;
1211 /* To skip prologues, I use this predicate. Returns either PC itself
1212 if the code at PC does not look like a function prologue; otherwise
1213 returns an address that (if we're lucky) follows the prologue. If
1214 LENIENT, then we must skip everything which is involved in setting
1215 up the frame (it's OK to skip more, just so long as we don't skip
1216 anything which might clobber the registers which are being saved.
1217 Currently we must not skip more on the alpha, but we might need the
1218 lenient stuff some day. */
1221 alpha_skip_prologue (CORE_ADDR pc
, int lenient
)
1225 CORE_ADDR post_prologue_pc
;
1228 #ifdef GDB_TARGET_HAS_SHARED_LIBS
1229 /* Silently return the unaltered pc upon memory errors.
1230 This could happen on OSF/1 if decode_line_1 tries to skip the
1231 prologue for quickstarted shared library functions when the
1232 shared library is not yet mapped in.
1233 Reading target memory is slow over serial lines, so we perform
1234 this check only if the target has shared libraries. */
1235 if (target_read_memory (pc
, buf
, 4))
1239 /* See if we can determine the end of the prologue via the symbol table.
1240 If so, then return either PC, or the PC after the prologue, whichever
1243 post_prologue_pc
= after_prologue (pc
, NULL
);
1245 if (post_prologue_pc
!= 0)
1246 return max (pc
, post_prologue_pc
);
1248 /* Can't determine prologue from the symbol table, need to examine
1251 /* Skip the typical prologue instructions. These are the stack adjustment
1252 instruction and the instructions that save registers on the stack
1253 or in the gcc frame. */
1254 for (offset
= 0; offset
< 100; offset
+= 4)
1258 status
= read_memory_nobpt (pc
+ offset
, buf
, 4);
1260 memory_error (status
, pc
+ offset
);
1261 inst
= extract_unsigned_integer (buf
, 4);
1263 /* The alpha has no delay slots. But let's keep the lenient stuff,
1264 we might need it for something else in the future. */
1268 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
1270 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
1272 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
1274 if ((inst
& 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */
1277 if ((inst
& 0xfc1f0000) == 0xb41e0000
1278 && (inst
& 0xffff0000) != 0xb7fe0000)
1279 continue; /* stq reg,n($sp) */
1281 if ((inst
& 0xfc1f0000) == 0x9c1e0000
1282 && (inst
& 0xffff0000) != 0x9ffe0000)
1283 continue; /* stt reg,n($sp) */
1285 if (inst
== 0x47de040f) /* bis sp,sp,fp */
1294 /* Is address PC in the prologue (loosely defined) for function at
1298 alpha_in_lenient_prologue (CORE_ADDR startaddr
, CORE_ADDR pc
)
1300 CORE_ADDR end_prologue
= alpha_skip_prologue (startaddr
, 1);
1301 return pc
>= startaddr
&& pc
< end_prologue
;
1305 /* The alpha needs a conversion between register and memory format if
1306 the register is a floating point register and
1307 memory format is float, as the register format must be double
1309 memory format is an integer with 4 bytes or less, as the representation
1310 of integers in floating point registers is different. */
1312 alpha_register_convert_to_virtual (int regnum
, struct type
*valtype
,
1313 char *raw_buffer
, char *virtual_buffer
)
1315 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1317 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
1321 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1323 double d
= extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1324 store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
1326 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1329 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1330 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
1331 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
1334 error ("Cannot retrieve value from floating point register");
1338 alpha_register_convert_to_raw (struct type
*valtype
, int regnum
,
1339 char *virtual_buffer
, char *raw_buffer
)
1341 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1343 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
1347 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1349 double d
= extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
1350 store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
1352 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1355 if (TYPE_UNSIGNED (valtype
))
1356 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1358 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1359 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
1360 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
1363 error ("Cannot store value in floating point register");
1366 /* Given a return value in `regbuf' with a type `valtype',
1367 extract and copy its value into `valbuf'. */
1370 alpha_extract_return_value (struct type
*valtype
,
1371 char regbuf
[REGISTER_BYTES
], char *valbuf
)
1373 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1374 alpha_register_convert_to_virtual (FP0_REGNUM
, valtype
,
1375 regbuf
+ REGISTER_BYTE (FP0_REGNUM
),
1378 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (V0_REGNUM
), TYPE_LENGTH (valtype
));
1381 /* Given a return value in `regbuf' with a type `valtype',
1382 write its value into the appropriate register. */
1385 alpha_store_return_value (struct type
*valtype
, char *valbuf
)
1387 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1388 int regnum
= V0_REGNUM
;
1389 int length
= TYPE_LENGTH (valtype
);
1391 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1393 regnum
= FP0_REGNUM
;
1394 length
= REGISTER_RAW_SIZE (regnum
);
1395 alpha_register_convert_to_raw (valtype
, regnum
, valbuf
, raw_buffer
);
1398 memcpy (raw_buffer
, valbuf
, length
);
1400 write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, length
);
1403 /* Just like reinit_frame_cache, but with the right arguments to be
1404 callable as an sfunc. */
1407 reinit_frame_cache_sfunc (char *args
, int from_tty
, struct cmd_list_element
*c
)
1409 reinit_frame_cache ();
1412 /* This is the definition of CALL_DUMMY_ADDRESS. It's a heuristic that is used
1413 to find a convenient place in the text segment to stick a breakpoint to
1414 detect the completion of a target function call (ala call_function_by_hand).
1418 alpha_call_dummy_address (void)
1421 struct minimal_symbol
*sym
;
1423 entry
= entry_point_address ();
1428 sym
= lookup_minimal_symbol ("_Prelude", NULL
, symfile_objfile
);
1430 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1433 return SYMBOL_VALUE_ADDRESS (sym
) + 4;
1437 alpha_use_struct_convention (int gcc_p
, struct type
*type
)
1439 /* Structures are returned by ref in extra arg0. */
1443 /* alpha_software_single_step() is called just before we want to resume
1444 the inferior, if we want to single-step it but there is no hardware
1445 or kernel single-step support (NetBSD on Alpha, for example). We find
1446 the target of the coming instruction and breakpoint it.
1448 single_step is also called just after the inferior stops. If we had
1449 set up a simulated single-step, we undo our damage. */
1452 alpha_next_pc (CORE_ADDR pc
)
1459 insn
= read_memory_unsigned_integer (pc
, sizeof (insn
));
1461 /* Opcode is top 6 bits. */
1462 op
= (insn
>> 26) & 0x3f;
1466 /* Jump format: target PC is:
1468 return (read_register ((insn
>> 16) & 0x1f) & ~3);
1471 if ((op
& 0x30) == 0x30)
1473 /* Branch format: target PC is:
1474 (new PC) + (4 * sext(displacement)) */
1475 if (op
== 0x30 || /* BR */
1476 op
== 0x34) /* BSR */
1479 offset
= (insn
& 0x001fffff);
1480 if (offset
& 0x00100000)
1481 offset
|= 0xffe00000;
1483 return (pc
+ 4 + offset
);
1486 /* Need to determine if branch is taken; read RA. */
1487 rav
= (LONGEST
) read_register ((insn
>> 21) & 0x1f);
1490 case 0x38: /* BLBC */
1494 case 0x3c: /* BLBS */
1498 case 0x39: /* BEQ */
1502 case 0x3d: /* BNE */
1506 case 0x3a: /* BLT */
1510 case 0x3b: /* BLE */
1514 case 0x3f: /* BGT */
1518 case 0x3e: /* BGE */
1525 /* Not a branch or branch not taken; target PC is:
1531 alpha_software_single_step (enum target_signal sig
, int insert_breakpoints_p
)
1533 static CORE_ADDR next_pc
;
1534 typedef char binsn_quantum
[BREAKPOINT_MAX
];
1535 static binsn_quantum break_mem
;
1538 if (insert_breakpoints_p
)
1541 next_pc
= alpha_next_pc (pc
);
1543 target_insert_breakpoint (next_pc
, break_mem
);
1547 target_remove_breakpoint (next_pc
, break_mem
);
1553 _initialize_alpha_tdep (void)
1555 struct cmd_list_element
*c
;
1557 tm_print_insn
= print_insn_alpha
;
1559 /* Let the user set the fence post for heuristic_proc_start. */
1561 /* We really would like to have both "0" and "unlimited" work, but
1562 command.c doesn't deal with that. So make it a var_zinteger
1563 because the user can always use "999999" or some such for unlimited. */
1564 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1565 (char *) &heuristic_fence_post
,
1567 Set the distance searched for the start of a function.\n\
1568 If you are debugging a stripped executable, GDB needs to search through the\n\
1569 program for the start of a function. This command sets the distance of the\n\
1570 search. The only need to set it is when debugging a stripped executable.",
1572 /* We need to throw away the frame cache when we set this, since it
1573 might change our ability to get backtraces. */
1574 c
->function
.sfunc
= reinit_frame_cache_sfunc
;
1575 add_show_from_set (c
, &showlist
);