1 /* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
2 Copyright 1993, 1994 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
31 /* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
33 /* FIXME: Put this declaration in frame.h. */
34 extern struct obstack frame_cache_obstack
;
37 /* Forward declarations. */
39 static CORE_ADDR read_next_frame_reg
PARAMS ((struct frame_info
*, int));
41 static CORE_ADDR heuristic_proc_start
PARAMS ((CORE_ADDR
));
43 static alpha_extra_func_info_t heuristic_proc_desc
PARAMS ((CORE_ADDR
,
45 struct frame_info
*));
47 static alpha_extra_func_info_t find_proc_desc
PARAMS ((CORE_ADDR
,
48 struct frame_info
*));
51 static int alpha_in_lenient_prologue
PARAMS ((CORE_ADDR
, CORE_ADDR
));
54 static void reinit_frame_cache_sfunc
PARAMS ((char *, int,
55 struct cmd_list_element
*));
57 static CORE_ADDR after_prologue
PARAMS ((CORE_ADDR pc
,
58 alpha_extra_func_info_t proc_desc
));
60 static int in_prologue
PARAMS ((CORE_ADDR pc
,
61 alpha_extra_func_info_t proc_desc
));
63 /* Heuristic_proc_start may hunt through the text section for a long
64 time across a 2400 baud serial line. Allows the user to limit this
66 static unsigned int heuristic_fence_post
= 0;
68 /* Layout of a stack frame on the alpha:
71 pdr members: | 7th ... nth arg, |
72 | `pushed' by caller. |
74 ----------------|-------------------------------|<-- old_sp == vfp
77 | |localoff | Copies of 1st .. 6th |
78 | | | | | argument if necessary. |
80 | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS
82 | | | | Locals and temporaries. |
84 | | | |-------------------------------|
86 |-fregoffset | Saved float registers. |
92 | | -------|-------------------------------|
94 | | | Saved registers. |
101 | ----------|-------------------------------|
103 frameoffset | Argument build area, gets |
104 | | 7th ... nth arg for any |
105 | | called procedure. |
107 -------------|-------------------------------|<-- sp
111 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
112 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
113 #define PROC_DUMMY_FRAME(proc) ((proc)->pdr.iopt) /* frame for CALL_DUMMY */
114 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
115 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
116 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
117 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
118 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
119 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
120 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
121 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
122 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
123 #define _PROC_MAGIC_ 0x0F0F0F0F
124 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
125 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
127 struct linked_proc_info
129 struct alpha_extra_func_info info
;
130 struct linked_proc_info
*next
;
131 } *linked_proc_desc_table
= NULL
;
134 /* Guaranteed to set fci->saved_regs to some values (it never leaves it
138 alpha_find_saved_regs (frame
)
139 struct frame_info
*frame
;
142 CORE_ADDR reg_position
;
144 alpha_extra_func_info_t proc_desc
;
147 frame
->saved_regs
= (struct frame_saved_regs
*)
148 obstack_alloc (&frame_cache_obstack
, sizeof(struct frame_saved_regs
));
149 memset (frame
->saved_regs
, 0, sizeof (struct frame_saved_regs
));
151 proc_desc
= frame
->proc_desc
;
152 if (proc_desc
== NULL
)
153 /* I'm not sure how/whether this can happen. Normally when we can't
154 find a proc_desc, we "synthesize" one using heuristic_proc_desc
155 and set the saved_regs right away. */
158 /* Fill in the offsets for the registers which gen_mask says
161 reg_position
= frame
->frame
+ PROC_REG_OFFSET (proc_desc
);
162 mask
= PROC_REG_MASK (proc_desc
);
164 returnreg
= PROC_PC_REG (proc_desc
);
166 /* Note that RA is always saved first, regardless of it's actual
168 if (mask
& (1 << returnreg
))
170 frame
->saved_regs
->regs
[returnreg
] = reg_position
;
172 mask
&= ~(1 << returnreg
); /* Clear bit for RA so we
173 don't save again later. */
176 for (ireg
= 0; ireg
<= 31 ; ++ireg
)
177 if (mask
& (1 << ireg
))
179 frame
->saved_regs
->regs
[ireg
] = reg_position
;
183 /* Fill in the offsets for the registers which float_mask says
186 reg_position
= frame
->frame
+ PROC_FREG_OFFSET (proc_desc
);
187 mask
= PROC_FREG_MASK (proc_desc
);
189 for (ireg
= 0; ireg
<= 31 ; ++ireg
)
190 if (mask
& (1 << ireg
))
192 frame
->saved_regs
->regs
[FP0_REGNUM
+ireg
] = reg_position
;
196 frame
->saved_regs
->regs
[PC_REGNUM
] = frame
->saved_regs
->regs
[returnreg
];
200 read_next_frame_reg(fi
, regno
)
201 struct frame_info
*fi
;
204 /* If it is the frame for sigtramp we have a pointer to the sigcontext
206 If the stack layout for __sigtramp changes or if sigcontext offsets
207 change we might have to update this code. */
208 #ifndef SIGFRAME_PC_OFF
209 #define SIGFRAME_PC_OFF (2 * 8)
210 #define SIGFRAME_REGSAVE_OFF (4 * 8)
212 for (; fi
; fi
= fi
->next
)
214 if (fi
->signal_handler_caller
)
217 CORE_ADDR sigcontext_addr
= read_memory_integer(fi
->frame
, 8);
219 if (regno
== PC_REGNUM
)
220 offset
= SIGFRAME_PC_OFF
;
222 offset
= SIGFRAME_REGSAVE_OFF
+ regno
* 8;
225 return read_memory_integer(sigcontext_addr
+ offset
, 8);
227 else if (regno
== SP_REGNUM
)
231 if (fi
->saved_regs
== NULL
)
232 alpha_find_saved_regs (fi
);
233 if (fi
->saved_regs
->regs
[regno
])
234 return read_memory_integer(fi
->saved_regs
->regs
[regno
], 8);
237 return read_register(regno
);
241 alpha_frame_saved_pc(frame
)
242 struct frame_info
*frame
;
244 alpha_extra_func_info_t proc_desc
= frame
->proc_desc
;
245 /* We have to get the saved pc from the sigcontext
246 if it is a signal handler frame. */
247 int pcreg
= frame
->signal_handler_caller
? PC_REGNUM
248 : (proc_desc
? PROC_PC_REG(proc_desc
) : RA_REGNUM
);
250 if (proc_desc
&& PROC_DESC_IS_DUMMY(proc_desc
))
251 return read_memory_integer(frame
->frame
- 8, 8);
253 return read_next_frame_reg(frame
, pcreg
);
257 alpha_saved_pc_after_call (frame
)
258 struct frame_info
*frame
;
260 alpha_extra_func_info_t proc_desc
= find_proc_desc (frame
->pc
, frame
->next
);
261 int pcreg
= proc_desc
? PROC_PC_REG (proc_desc
) : RA_REGNUM
;
263 return read_register (pcreg
);
267 static struct alpha_extra_func_info temp_proc_desc
;
268 static struct frame_saved_regs temp_saved_regs
;
270 /* This fencepost looks highly suspicious to me. Removing it also
271 seems suspicious as it could affect remote debugging across serial
275 heuristic_proc_start(pc
)
278 CORE_ADDR start_pc
= pc
;
279 CORE_ADDR fence
= start_pc
- heuristic_fence_post
;
281 if (start_pc
== 0) return 0;
283 if (heuristic_fence_post
== UINT_MAX
284 || fence
< VM_MIN_ADDRESS
)
285 fence
= VM_MIN_ADDRESS
;
287 /* search back for previous return */
288 for (start_pc
-= 4; ; start_pc
-= 4)
289 if (start_pc
< fence
)
291 /* It's not clear to me why we reach this point when
292 stop_soon_quietly, but with this test, at least we
293 don't print out warnings for every child forked (eg, on
294 decstation). 22apr93 rich@cygnus.com. */
295 if (!stop_soon_quietly
)
297 static int blurb_printed
= 0;
299 if (fence
== VM_MIN_ADDRESS
)
300 warning("Hit beginning of text section without finding");
302 warning("Hit heuristic-fence-post without finding");
304 warning("enclosing function for address 0x%lx", pc
);
308 This warning occurs if you are debugging a function without any symbols\n\
309 (for example, in a stripped executable). In that case, you may wish to\n\
310 increase the size of the search with the `set heuristic-fence-post' command.\n\
312 Otherwise, you told GDB there was a function where there isn't one, or\n\
313 (more likely) you have encountered a bug in GDB.\n");
320 else if (ABOUT_TO_RETURN(start_pc
))
323 start_pc
+= 4; /* skip return */
327 static alpha_extra_func_info_t
328 heuristic_proc_desc(start_pc
, limit_pc
, next_frame
)
329 CORE_ADDR start_pc
, limit_pc
;
330 struct frame_info
*next_frame
;
332 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
335 int has_frame_reg
= 0;
336 unsigned long reg_mask
= 0;
340 memset (&temp_proc_desc
, '\0', sizeof(temp_proc_desc
));
341 memset (&temp_saved_regs
, '\0', sizeof(struct frame_saved_regs
));
342 PROC_LOW_ADDR (&temp_proc_desc
) = start_pc
;
344 if (start_pc
+ 200 < limit_pc
)
345 limit_pc
= start_pc
+ 200;
347 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4)
353 status
= read_memory_nobpt (cur_pc
, buf
, 4);
355 memory_error (status
, cur_pc
);
356 word
= extract_unsigned_integer (buf
, 4);
358 if ((word
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
359 frame_size
+= (-word
) & 0xffff;
360 else if ((word
& 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */
361 && (word
& 0xffff0000) != 0xb7fe0000) /* reg != $zero */
363 int reg
= (word
& 0x03e00000) >> 21;
364 reg_mask
|= 1 << reg
;
365 temp_saved_regs
.regs
[reg
] = sp
+ (short)word
;
367 else if (word
== 0x47de040f) /* bis sp,sp fp */
371 PROC_FRAME_REG(&temp_proc_desc
) = GCC_FP_REGNUM
;
373 PROC_FRAME_REG(&temp_proc_desc
) = SP_REGNUM
;
374 PROC_FRAME_OFFSET(&temp_proc_desc
) = frame_size
;
375 PROC_REG_MASK(&temp_proc_desc
) = reg_mask
;
376 PROC_PC_REG(&temp_proc_desc
) = RA_REGNUM
;
377 PROC_LOCALOFF(&temp_proc_desc
) = 0; /* XXX - bogus */
378 return &temp_proc_desc
;
381 /* This returns the PC of the first inst after the prologue. If we can't
382 find the prologue, then return 0. */
385 after_prologue (pc
, proc_desc
)
387 alpha_extra_func_info_t proc_desc
;
389 struct symtab_and_line sal
;
390 CORE_ADDR func_addr
, func_end
;
393 proc_desc
= find_proc_desc (pc
, NULL
);
397 /* If function is frameless, then we need to do it the hard way. I
398 strongly suspect that frameless always means prologueless... */
399 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
400 && PROC_FRAME_OFFSET (proc_desc
) == 0)
404 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
405 return 0; /* Unknown */
407 sal
= find_pc_line (func_addr
, 0);
409 if (sal
.end
< func_end
)
412 /* The line after the prologue is after the end of the function. In this
413 case, tell the caller to find the prologue the hard way. */
418 /* Return non-zero if we *might* be in a function prologue. Return zero if we
419 are definatly *not* in a function prologue. */
422 in_prologue (pc
, proc_desc
)
424 alpha_extra_func_info_t proc_desc
;
426 CORE_ADDR after_prologue_pc
;
428 after_prologue_pc
= after_prologue (pc
, proc_desc
);
430 if (after_prologue_pc
== 0
431 || pc
< after_prologue_pc
)
437 static alpha_extra_func_info_t
438 find_proc_desc (pc
, next_frame
)
440 struct frame_info
*next_frame
;
442 alpha_extra_func_info_t proc_desc
;
447 /* Try to get the proc_desc from the linked call dummy proc_descs
448 if the pc is in the call dummy.
449 This is hairy. In the case of nested dummy calls we have to find the
450 right proc_desc, but we might not yet know the frame for the dummy
451 as it will be contained in the proc_desc we are searching for.
452 So we have to find the proc_desc whose frame is closest to the current
455 if (PC_IN_CALL_DUMMY (pc
, 0, 0))
457 struct linked_proc_info
*link
;
458 CORE_ADDR sp
= read_next_frame_reg (next_frame
, SP_REGNUM
);
459 alpha_extra_func_info_t found_proc_desc
= NULL
;
460 long min_distance
= LONG_MAX
;
462 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
464 long distance
= (CORE_ADDR
) PROC_DUMMY_FRAME (&link
->info
) - sp
;
465 if (distance
> 0 && distance
< min_distance
)
467 min_distance
= distance
;
468 found_proc_desc
= &link
->info
;
471 if (found_proc_desc
!= NULL
)
472 return found_proc_desc
;
475 b
= block_for_pc(pc
);
477 find_pc_partial_function (pc
, NULL
, &startaddr
, NULL
);
482 if (startaddr
> BLOCK_START (b
))
483 /* This is the "pathological" case referred to in a comment in
484 print_frame_info. It might be better to move this check into
488 sym
= lookup_symbol (MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
,
494 /* IF this is the topmost frame AND
495 * (this proc does not have debugging information OR
496 * the PC is in the procedure prologue)
497 * THEN create a "heuristic" proc_desc (by analyzing
498 * the actual code) to replace the "official" proc_desc.
500 proc_desc
= (alpha_extra_func_info_t
)SYMBOL_VALUE(sym
);
501 if (next_frame
== NULL
)
503 if (PROC_DESC_IS_DUMMY (proc_desc
) || in_prologue (pc
, proc_desc
))
505 alpha_extra_func_info_t found_heuristic
=
506 heuristic_proc_desc (PROC_LOW_ADDR (proc_desc
),
510 PROC_LOCALOFF (found_heuristic
) =
511 PROC_LOCALOFF (proc_desc
);
512 proc_desc
= found_heuristic
;
519 /* Is linked_proc_desc_table really necessary? It only seems to be used
520 by procedure call dummys. However, the procedures being called ought
521 to have their own proc_descs, and even if they don't,
522 heuristic_proc_desc knows how to create them! */
524 register struct linked_proc_info
*link
;
525 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
526 if (PROC_LOW_ADDR(&link
->info
) <= pc
527 && PROC_HIGH_ADDR(&link
->info
) > pc
)
531 startaddr
= heuristic_proc_start (pc
);
534 heuristic_proc_desc (startaddr
, pc
, next_frame
);
539 alpha_extra_func_info_t cached_proc_desc
;
542 alpha_frame_chain(frame
)
543 struct frame_info
*frame
;
545 alpha_extra_func_info_t proc_desc
;
546 CORE_ADDR saved_pc
= FRAME_SAVED_PC(frame
);
548 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
551 proc_desc
= find_proc_desc(saved_pc
, frame
);
555 cached_proc_desc
= proc_desc
;
557 /* Fetch the frame pointer for a dummy frame from the procedure
559 if (PROC_DESC_IS_DUMMY(proc_desc
))
560 return (CORE_ADDR
) PROC_DUMMY_FRAME(proc_desc
);
562 /* If no frame pointer and frame size is zero, we must be at end
563 of stack (or otherwise hosed). If we don't check frame size,
564 we loop forever if we see a zero size frame. */
565 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
566 && PROC_FRAME_OFFSET (proc_desc
) == 0
567 /* The previous frame from a sigtramp frame might be frameless
568 and have frame size zero. */
569 && !frame
->signal_handler_caller
)
571 /* The alpha __sigtramp routine is frameless and has a frame size
572 of zero, but we are able to backtrace through it. */
574 find_pc_partial_function (saved_pc
, &name
,
575 (CORE_ADDR
*)NULL
, (CORE_ADDR
*)NULL
);
576 if (IN_SIGTRAMP (saved_pc
, name
))
582 return read_next_frame_reg(frame
, PROC_FRAME_REG(proc_desc
))
583 + PROC_FRAME_OFFSET(proc_desc
);
587 init_extra_frame_info (frame
)
588 struct frame_info
*frame
;
590 /* Use proc_desc calculated in frame_chain */
591 alpha_extra_func_info_t proc_desc
=
592 frame
->next
? cached_proc_desc
: find_proc_desc(frame
->pc
, frame
->next
);
594 frame
->saved_regs
= NULL
;
596 proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
599 /* Get the locals offset from the procedure descriptor, it is valid
600 even if we are in the middle of the prologue. */
601 frame
->localoff
= PROC_LOCALOFF(proc_desc
);
603 /* Fixup frame-pointer - only needed for top frame */
605 /* Fetch the frame pointer for a dummy frame from the procedure
607 if (PROC_DESC_IS_DUMMY(proc_desc
))
608 frame
->frame
= (CORE_ADDR
) PROC_DUMMY_FRAME(proc_desc
);
610 /* This may not be quite right, if proc has a real frame register.
611 Get the value of the frame relative sp, procedure might have been
612 interrupted by a signal at it's very start. */
613 else if (frame
->pc
== PROC_LOW_ADDR (proc_desc
) && !PROC_DESC_IS_DUMMY (proc_desc
))
614 frame
->frame
= read_next_frame_reg (frame
->next
, SP_REGNUM
);
616 frame
->frame
= read_next_frame_reg (frame
->next
, PROC_FRAME_REG (proc_desc
))
617 + PROC_FRAME_OFFSET (proc_desc
);
619 if (proc_desc
== &temp_proc_desc
)
621 frame
->saved_regs
= (struct frame_saved_regs
*)
622 obstack_alloc (&frame_cache_obstack
,
623 sizeof (struct frame_saved_regs
));
624 *frame
->saved_regs
= temp_saved_regs
;
625 frame
->saved_regs
->regs
[PC_REGNUM
] = frame
->saved_regs
->regs
[RA_REGNUM
];
630 /* ALPHA stack frames are almost impenetrable. When execution stops,
631 we basically have to look at symbol information for the function
632 that we stopped in, which tells us *which* register (if any) is
633 the base of the frame pointer, and what offset from that register
634 the frame itself is at.
636 This presents a problem when trying to examine a stack in memory
637 (that isn't executing at the moment), using the "frame" command. We
638 don't have a PC, nor do we have any registers except SP.
640 This routine takes two arguments, SP and PC, and tries to make the
641 cached frames look as if these two arguments defined a frame on the
642 cache. This allows the rest of info frame to extract the important
643 arguments without difficulty. */
646 setup_arbitrary_frame (argc
, argv
)
651 error ("ALPHA frame specifications require two arguments: sp and pc");
653 return create_new_frame (argv
[0], argv
[1]);
656 /* The alpha passes the first six arguments in the registers, the rest on
657 the stack. The register arguments are eventually transferred to the
658 argument transfer area immediately below the stack by the called function
659 anyway. So we `push' at least six arguments on the stack, `reload' the
660 argument registers and then adjust the stack pointer to point past the
661 sixth argument. This algorithm simplifies the passing of a large struct
662 which extends from the registers to the stack.
663 If the called function is returning a structure, the address of the
664 structure to be returned is passed as a hidden first argument. */
667 alpha_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
672 CORE_ADDR struct_addr
;
675 int accumulate_size
= struct_return
? 8 : 0;
676 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
677 struct alpha_arg
{ char *contents
; int len
; int offset
; };
678 struct alpha_arg
*alpha_args
=
679 (struct alpha_arg
*)alloca (nargs
* sizeof (struct alpha_arg
));
680 register struct alpha_arg
*m_arg
;
681 char raw_buffer
[sizeof (CORE_ADDR
)];
682 int required_arg_regs
;
684 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
686 value_ptr arg
= args
[i
];
687 /* Cast argument to long if necessary as the compiler does it too. */
688 if (TYPE_LENGTH (VALUE_TYPE (arg
)) < TYPE_LENGTH (builtin_type_long
))
689 arg
= value_cast (builtin_type_long
, arg
);
690 m_arg
->len
= TYPE_LENGTH (VALUE_TYPE (arg
));
691 m_arg
->offset
= accumulate_size
;
692 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
693 m_arg
->contents
= VALUE_CONTENTS(arg
);
696 /* Determine required argument register loads, loading an argument register
697 is expensive as it uses three ptrace calls. */
698 required_arg_regs
= accumulate_size
/ 8;
699 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
700 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
702 /* Make room for the arguments on the stack. */
703 if (accumulate_size
< arg_regs_size
)
704 accumulate_size
= arg_regs_size
;
705 sp
-= accumulate_size
;
707 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
710 /* `Push' arguments on the stack. */
711 for (i
= nargs
; m_arg
--, --i
>= 0; )
712 write_memory(sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
715 store_address (raw_buffer
, sizeof (CORE_ADDR
), struct_addr
);
716 write_memory (sp
, raw_buffer
, sizeof (CORE_ADDR
));
719 /* Load the argument registers. */
720 for (i
= 0; i
< required_arg_regs
; i
++)
724 val
= read_memory_integer (sp
+ i
* 8, 8);
725 write_register (A0_REGNUM
+ i
, val
);
726 write_register (FPA0_REGNUM
+ i
, val
);
729 return sp
+ arg_regs_size
;
733 alpha_push_dummy_frame()
736 struct linked_proc_info
*link
;
737 alpha_extra_func_info_t proc_desc
;
738 CORE_ADDR sp
= read_register (SP_REGNUM
);
739 CORE_ADDR save_address
;
740 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
743 link
= (struct linked_proc_info
*) xmalloc(sizeof (struct linked_proc_info
));
744 link
->next
= linked_proc_desc_table
;
745 linked_proc_desc_table
= link
;
747 proc_desc
= &link
->info
;
750 * The registers we must save are all those not preserved across
752 * In addition, we must save the PC and RA.
754 * Dummy frame layout:
764 * Parameter build area
768 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
769 #define MASK(i,j) (((1L << ((j)+1)) - 1) ^ ((1L << (i)) - 1))
770 #define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
771 #define GEN_REG_SAVE_COUNT 24
772 #define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
773 #define FLOAT_REG_SAVE_COUNT 23
774 /* The special register is the PC as we have no bit for it in the save masks.
775 alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
776 #define SPECIAL_REG_SAVE_COUNT 1
778 PROC_REG_MASK(proc_desc
) = GEN_REG_SAVE_MASK
;
779 PROC_FREG_MASK(proc_desc
) = FLOAT_REG_SAVE_MASK
;
780 /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
781 but keep SP aligned to a multiple of 16. */
782 PROC_REG_OFFSET(proc_desc
) =
783 - ((8 * (SPECIAL_REG_SAVE_COUNT
785 + FLOAT_REG_SAVE_COUNT
)
787 PROC_FREG_OFFSET(proc_desc
) =
788 PROC_REG_OFFSET(proc_desc
) + 8 * GEN_REG_SAVE_COUNT
;
790 /* Save general registers.
791 The return address register is the first saved register, all other
792 registers follow in ascending order.
793 The PC is saved immediately below the SP. */
794 save_address
= sp
+ PROC_REG_OFFSET(proc_desc
);
795 store_address (raw_buffer
, 8, read_register (RA_REGNUM
));
796 write_memory (save_address
, raw_buffer
, 8);
798 mask
= PROC_REG_MASK(proc_desc
) & 0xffffffffL
;
799 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
802 if (ireg
== RA_REGNUM
)
804 store_address (raw_buffer
, 8, read_register (ireg
));
805 write_memory (save_address
, raw_buffer
, 8);
809 store_address (raw_buffer
, 8, read_register (PC_REGNUM
));
810 write_memory (sp
- 8, raw_buffer
, 8);
812 /* Save floating point registers. */
813 save_address
= sp
+ PROC_FREG_OFFSET(proc_desc
);
814 mask
= PROC_FREG_MASK(proc_desc
) & 0xffffffffL
;
815 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
818 store_address (raw_buffer
, 8, read_register (ireg
+ FP0_REGNUM
));
819 write_memory (save_address
, raw_buffer
, 8);
823 /* Set and save the frame address for the dummy.
824 This is tricky. The only registers that are suitable for a frame save
825 are those that are preserved across procedure calls (s0-s6). But if
826 a read system call is interrupted and then a dummy call is made
827 (see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
828 is satisfied. Then it returns with the s0-s6 registers set to the values
829 on entry to the read system call and our dummy frame pointer would be
830 destroyed. So we save the dummy frame in the proc_desc and handle the
831 retrieval of the frame pointer of a dummy specifically. The frame register
832 is set to the virtual frame (pseudo) register, it's value will always
833 be read as zero and will help us to catch any errors in the dummy frame
835 PROC_DUMMY_FRAME(proc_desc
) = sp
;
836 PROC_FRAME_REG(proc_desc
) = FP_REGNUM
;
837 PROC_FRAME_OFFSET(proc_desc
) = 0;
838 sp
+= PROC_REG_OFFSET(proc_desc
);
839 write_register (SP_REGNUM
, sp
);
841 PROC_LOW_ADDR(proc_desc
) = CALL_DUMMY_ADDRESS ();
842 PROC_HIGH_ADDR(proc_desc
) = PROC_LOW_ADDR(proc_desc
) + 4;
844 SET_PROC_DESC_IS_DUMMY(proc_desc
);
845 PROC_PC_REG(proc_desc
) = RA_REGNUM
;
852 struct frame_info
*frame
= get_current_frame ();
853 CORE_ADDR new_sp
= frame
->frame
;
855 alpha_extra_func_info_t proc_desc
= frame
->proc_desc
;
857 write_register (PC_REGNUM
, FRAME_SAVED_PC(frame
));
858 if (frame
->saved_regs
== NULL
)
859 alpha_find_saved_regs (frame
);
862 for (regnum
= 32; --regnum
>= 0; )
863 if (PROC_REG_MASK(proc_desc
) & (1 << regnum
))
864 write_register (regnum
,
865 read_memory_integer (frame
->saved_regs
->regs
[regnum
],
867 for (regnum
= 32; --regnum
>= 0; )
868 if (PROC_FREG_MASK(proc_desc
) & (1 << regnum
))
869 write_register (regnum
+ FP0_REGNUM
,
870 read_memory_integer (frame
->saved_regs
->regs
[regnum
+ FP0_REGNUM
], 8));
872 write_register (SP_REGNUM
, new_sp
);
873 flush_cached_frames ();
875 if (proc_desc
&& PROC_DESC_IS_DUMMY(proc_desc
))
877 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
879 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
881 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
883 if (&pi_ptr
->info
== proc_desc
)
888 error ("Can't locate dummy extra frame info\n");
890 if (prev_ptr
!= NULL
)
891 prev_ptr
->next
= pi_ptr
->next
;
893 linked_proc_desc_table
= pi_ptr
->next
;
899 /* To skip prologues, I use this predicate. Returns either PC itself
900 if the code at PC does not look like a function prologue; otherwise
901 returns an address that (if we're lucky) follows the prologue. If
902 LENIENT, then we must skip everything which is involved in setting
903 up the frame (it's OK to skip more, just so long as we don't skip
904 anything which might clobber the registers which are being saved.
905 Currently we must not skip more on the alpha, but we might the lenient
909 alpha_skip_prologue (pc
, lenient
)
915 CORE_ADDR post_prologue_pc
;
918 #ifdef GDB_TARGET_HAS_SHARED_LIBS
919 /* Silently return the unaltered pc upon memory errors.
920 This could happen on OSF/1 if decode_line_1 tries to skip the
921 prologue for quickstarted shared library functions when the
922 shared library is not yet mapped in.
923 Reading target memory is slow over serial lines, so we perform
924 this check only if the target has shared libraries. */
925 if (target_read_memory (pc
, buf
, 4))
929 /* See if we can determine the end of the prologue via the symbol table.
930 If so, then return either PC, or the PC after the prologue, whichever
933 post_prologue_pc
= after_prologue (pc
, NULL
);
935 if (post_prologue_pc
!= 0)
936 return max (pc
, post_prologue_pc
);
938 /* Can't determine prologue from the symbol table, need to examine
941 /* Skip the typical prologue instructions. These are the stack adjustment
942 instruction and the instructions that save registers on the stack
943 or in the gcc frame. */
944 for (offset
= 0; offset
< 100; offset
+= 4)
948 status
= read_memory_nobpt (pc
+ offset
, buf
, 4);
950 memory_error (status
, pc
+ offset
);
951 inst
= extract_unsigned_integer (buf
, 4);
953 /* The alpha has no delay slots. But let's keep the lenient stuff,
954 we might need it for something else in the future. */
958 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
960 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
962 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
964 else if ((inst
& 0xfc1f0000) == 0xb41e0000
965 && (inst
& 0xffff0000) != 0xb7fe0000)
966 continue; /* stq reg,n($sp) */
968 else if ((inst
& 0xfc1f0000) == 0x9c1e0000
969 && (inst
& 0xffff0000) != 0x9ffe0000)
970 continue; /* stt reg,n($sp) */
972 else if (inst
== 0x47de040f) /* bis sp,sp,fp */
981 /* Is address PC in the prologue (loosely defined) for function at
985 alpha_in_lenient_prologue (startaddr
, pc
)
989 CORE_ADDR end_prologue
= alpha_skip_prologue (startaddr
, 1);
990 return pc
>= startaddr
&& pc
< end_prologue
;
994 /* The alpha needs a conversion between register and memory format if
995 the register is a floating point register and
996 memory format is float, as the register format must be double
998 memory format is an integer with 4 bytes or less, as the representation
999 of integers in floating point registers is different. */
1001 alpha_register_convert_to_virtual (regnum
, valtype
, raw_buffer
, virtual_buffer
)
1003 struct type
*valtype
;
1005 char *virtual_buffer
;
1007 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1009 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
1013 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1015 double d
= extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1016 store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
1018 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1021 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1022 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
1023 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
1026 error ("Cannot retrieve value from floating point register");
1030 alpha_register_convert_to_raw (valtype
, regnum
, virtual_buffer
, raw_buffer
)
1031 struct type
*valtype
;
1033 char *virtual_buffer
;
1036 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1038 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
1042 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1044 double d
= extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
1045 store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
1047 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1050 if (TYPE_UNSIGNED (valtype
))
1051 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1053 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1054 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
1055 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
1058 error ("Cannot store value in floating point register");
1061 /* Given a return value in `regbuf' with a type `valtype',
1062 extract and copy its value into `valbuf'. */
1065 alpha_extract_return_value (valtype
, regbuf
, valbuf
)
1066 struct type
*valtype
;
1067 char regbuf
[REGISTER_BYTES
];
1072 regnum
= TYPE_CODE (valtype
) == TYPE_CODE_FLT
? FP0_REGNUM
: V0_REGNUM
;
1074 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (regnum
), TYPE_LENGTH (valtype
));
1077 /* Given a return value in `regbuf' with a type `valtype',
1078 write its value into the appropriate register. */
1081 alpha_store_return_value (valtype
, valbuf
)
1082 struct type
*valtype
;
1086 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1088 regnum
= TYPE_CODE (valtype
) == TYPE_CODE_FLT
? FP0_REGNUM
: V0_REGNUM
;
1089 memcpy(raw_buffer
, valbuf
, TYPE_LENGTH (valtype
));
1091 write_register_bytes(REGISTER_BYTE (regnum
), raw_buffer
, TYPE_LENGTH (valtype
));
1094 /* Just like reinit_frame_cache, but with the right arguments to be
1095 callable as an sfunc. */
1098 reinit_frame_cache_sfunc (args
, from_tty
, c
)
1101 struct cmd_list_element
*c
;
1103 reinit_frame_cache ();
1106 /* This is the definition of CALL_DUMMY_ADDRESS. It's a heuristic that is used
1107 to find a convenient place in the text segment to stick a breakpoint to
1108 detect the completion of a target function call (ala call_function_by_hand).
1112 alpha_call_dummy_address ()
1115 struct minimal_symbol
*sym
;
1117 entry
= entry_point_address ();
1122 sym
= lookup_minimal_symbol ("_Prelude", NULL
, symfile_objfile
);
1124 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1127 return SYMBOL_VALUE_ADDRESS (sym
) + 4;
1131 _initialize_alpha_tdep ()
1133 struct cmd_list_element
*c
;
1135 tm_print_insn
= print_insn_alpha
;
1137 /* Let the user set the fence post for heuristic_proc_start. */
1139 /* We really would like to have both "0" and "unlimited" work, but
1140 command.c doesn't deal with that. So make it a var_zinteger
1141 because the user can always use "999999" or some such for unlimited. */
1142 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1143 (char *) &heuristic_fence_post
,
1145 Set the distance searched for the start of a function.\n\
1146 If you are debugging a stripped executable, GDB needs to search through the\n\
1147 program for the start of a function. This command sets the distance of the\n\
1148 search. The only need to set it is when debugging a stripped executable.",
1150 /* We need to throw away the frame cache when we set this, since it
1151 might change our ability to get backtraces. */
1152 c
->function
.sfunc
= reinit_frame_cache_sfunc
;
1153 add_show_from_set (c
, &showlist
);