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
),
508 PROC_LOCALOFF (found_heuristic
) = PROC_LOCALOFF (proc_desc
);
510 proc_desc
= found_heuristic
;
516 /* Is linked_proc_desc_table really necessary? It only seems to be used
517 by procedure call dummys. However, the procedures being called ought
518 to have their own proc_descs, and even if they don't,
519 heuristic_proc_desc knows how to create them! */
521 register struct linked_proc_info
*link
;
522 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
523 if (PROC_LOW_ADDR(&link
->info
) <= pc
524 && PROC_HIGH_ADDR(&link
->info
) > pc
)
528 startaddr
= heuristic_proc_start (pc
);
531 heuristic_proc_desc (startaddr
, pc
, next_frame
);
536 alpha_extra_func_info_t cached_proc_desc
;
539 alpha_frame_chain(frame
)
540 struct frame_info
*frame
;
542 alpha_extra_func_info_t proc_desc
;
543 CORE_ADDR saved_pc
= FRAME_SAVED_PC(frame
);
545 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
548 proc_desc
= find_proc_desc(saved_pc
, frame
);
552 cached_proc_desc
= proc_desc
;
554 /* Fetch the frame pointer for a dummy frame from the procedure
556 if (PROC_DESC_IS_DUMMY(proc_desc
))
557 return (CORE_ADDR
) PROC_DUMMY_FRAME(proc_desc
);
559 /* If no frame pointer and frame size is zero, we must be at end
560 of stack (or otherwise hosed). If we don't check frame size,
561 we loop forever if we see a zero size frame. */
562 if (PROC_FRAME_REG (proc_desc
) == SP_REGNUM
563 && PROC_FRAME_OFFSET (proc_desc
) == 0
564 /* The previous frame from a sigtramp frame might be frameless
565 and have frame size zero. */
566 && !frame
->signal_handler_caller
)
568 /* The alpha __sigtramp routine is frameless and has a frame size
569 of zero, but we are able to backtrace through it. */
571 find_pc_partial_function (saved_pc
, &name
,
572 (CORE_ADDR
*)NULL
, (CORE_ADDR
*)NULL
);
573 if (IN_SIGTRAMP (saved_pc
, name
))
579 return read_next_frame_reg(frame
, PROC_FRAME_REG(proc_desc
))
580 + PROC_FRAME_OFFSET(proc_desc
);
584 init_extra_frame_info (frame
)
585 struct frame_info
*frame
;
587 /* Use proc_desc calculated in frame_chain */
588 alpha_extra_func_info_t proc_desc
=
589 frame
->next
? cached_proc_desc
: find_proc_desc(frame
->pc
, frame
->next
);
591 frame
->saved_regs
= NULL
;
593 proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
596 /* Get the locals offset from the procedure descriptor, it is valid
597 even if we are in the middle of the prologue. */
598 frame
->localoff
= PROC_LOCALOFF(proc_desc
);
600 /* Fixup frame-pointer - only needed for top frame */
602 /* Fetch the frame pointer for a dummy frame from the procedure
604 if (PROC_DESC_IS_DUMMY(proc_desc
))
605 frame
->frame
= (CORE_ADDR
) PROC_DUMMY_FRAME(proc_desc
);
607 /* This may not be quite right, if proc has a real frame register.
608 Get the value of the frame relative sp, procedure might have been
609 interrupted by a signal at it's very start. */
610 else if (frame
->pc
== PROC_LOW_ADDR (proc_desc
) && !PROC_DESC_IS_DUMMY (proc_desc
))
611 frame
->frame
= read_next_frame_reg (frame
->next
, SP_REGNUM
);
613 frame
->frame
= read_next_frame_reg (frame
->next
, PROC_FRAME_REG (proc_desc
))
614 + PROC_FRAME_OFFSET (proc_desc
);
616 if (proc_desc
== &temp_proc_desc
)
618 frame
->saved_regs
= (struct frame_saved_regs
*)
619 obstack_alloc (&frame_cache_obstack
,
620 sizeof (struct frame_saved_regs
));
621 *frame
->saved_regs
= temp_saved_regs
;
622 frame
->saved_regs
->regs
[PC_REGNUM
] = frame
->saved_regs
->regs
[RA_REGNUM
];
627 /* ALPHA stack frames are almost impenetrable. When execution stops,
628 we basically have to look at symbol information for the function
629 that we stopped in, which tells us *which* register (if any) is
630 the base of the frame pointer, and what offset from that register
631 the frame itself is at.
633 This presents a problem when trying to examine a stack in memory
634 (that isn't executing at the moment), using the "frame" command. We
635 don't have a PC, nor do we have any registers except SP.
637 This routine takes two arguments, SP and PC, and tries to make the
638 cached frames look as if these two arguments defined a frame on the
639 cache. This allows the rest of info frame to extract the important
640 arguments without difficulty. */
643 setup_arbitrary_frame (argc
, argv
)
648 error ("ALPHA frame specifications require two arguments: sp and pc");
650 return create_new_frame (argv
[0], argv
[1]);
653 /* The alpha passes the first six arguments in the registers, the rest on
654 the stack. The register arguments are eventually transferred to the
655 argument transfer area immediately below the stack by the called function
656 anyway. So we `push' at least six arguments on the stack, `reload' the
657 argument registers and then adjust the stack pointer to point past the
658 sixth argument. This algorithm simplifies the passing of a large struct
659 which extends from the registers to the stack.
660 If the called function is returning a structure, the address of the
661 structure to be returned is passed as a hidden first argument. */
664 alpha_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
669 CORE_ADDR struct_addr
;
672 int accumulate_size
= struct_return
? 8 : 0;
673 int arg_regs_size
= ALPHA_NUM_ARG_REGS
* 8;
674 struct alpha_arg
{ char *contents
; int len
; int offset
; };
675 struct alpha_arg
*alpha_args
=
676 (struct alpha_arg
*)alloca (nargs
* sizeof (struct alpha_arg
));
677 register struct alpha_arg
*m_arg
;
678 char raw_buffer
[sizeof (CORE_ADDR
)];
679 int required_arg_regs
;
681 for (i
= 0, m_arg
= alpha_args
; i
< nargs
; i
++, m_arg
++)
683 value_ptr arg
= args
[i
];
684 /* Cast argument to long if necessary as the compiler does it too. */
685 if (TYPE_LENGTH (VALUE_TYPE (arg
)) < TYPE_LENGTH (builtin_type_long
))
686 arg
= value_cast (builtin_type_long
, arg
);
687 m_arg
->len
= TYPE_LENGTH (VALUE_TYPE (arg
));
688 m_arg
->offset
= accumulate_size
;
689 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 7) & ~7;
690 m_arg
->contents
= VALUE_CONTENTS(arg
);
693 /* Determine required argument register loads, loading an argument register
694 is expensive as it uses three ptrace calls. */
695 required_arg_regs
= accumulate_size
/ 8;
696 if (required_arg_regs
> ALPHA_NUM_ARG_REGS
)
697 required_arg_regs
= ALPHA_NUM_ARG_REGS
;
699 /* Make room for the arguments on the stack. */
700 if (accumulate_size
< arg_regs_size
)
701 accumulate_size
= arg_regs_size
;
702 sp
-= accumulate_size
;
704 /* Keep sp aligned to a multiple of 16 as the compiler does it too. */
707 /* `Push' arguments on the stack. */
708 for (i
= nargs
; m_arg
--, --i
>= 0; )
709 write_memory(sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
712 store_address (raw_buffer
, sizeof (CORE_ADDR
), struct_addr
);
713 write_memory (sp
, raw_buffer
, sizeof (CORE_ADDR
));
716 /* Load the argument registers. */
717 for (i
= 0; i
< required_arg_regs
; i
++)
721 val
= read_memory_integer (sp
+ i
* 8, 8);
722 write_register (A0_REGNUM
+ i
, val
);
723 write_register (FPA0_REGNUM
+ i
, val
);
726 return sp
+ arg_regs_size
;
730 alpha_push_dummy_frame()
733 struct linked_proc_info
*link
;
734 alpha_extra_func_info_t proc_desc
;
735 CORE_ADDR sp
= read_register (SP_REGNUM
);
736 CORE_ADDR save_address
;
737 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
740 link
= (struct linked_proc_info
*) xmalloc(sizeof (struct linked_proc_info
));
741 link
->next
= linked_proc_desc_table
;
742 linked_proc_desc_table
= link
;
744 proc_desc
= &link
->info
;
747 * The registers we must save are all those not preserved across
749 * In addition, we must save the PC and RA.
751 * Dummy frame layout:
761 * Parameter build area
765 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
766 #define MASK(i,j) (((1L << ((j)+1)) - 1) ^ ((1L << (i)) - 1))
767 #define GEN_REG_SAVE_MASK (MASK(0,8) | MASK(16,29))
768 #define GEN_REG_SAVE_COUNT 24
769 #define FLOAT_REG_SAVE_MASK (MASK(0,1) | MASK(10,30))
770 #define FLOAT_REG_SAVE_COUNT 23
771 /* The special register is the PC as we have no bit for it in the save masks.
772 alpha_frame_saved_pc knows where the pc is saved in a dummy frame. */
773 #define SPECIAL_REG_SAVE_COUNT 1
775 PROC_REG_MASK(proc_desc
) = GEN_REG_SAVE_MASK
;
776 PROC_FREG_MASK(proc_desc
) = FLOAT_REG_SAVE_MASK
;
777 /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
778 but keep SP aligned to a multiple of 16. */
779 PROC_REG_OFFSET(proc_desc
) =
780 - ((8 * (SPECIAL_REG_SAVE_COUNT
782 + FLOAT_REG_SAVE_COUNT
)
784 PROC_FREG_OFFSET(proc_desc
) =
785 PROC_REG_OFFSET(proc_desc
) + 8 * GEN_REG_SAVE_COUNT
;
787 /* Save general registers.
788 The return address register is the first saved register, all other
789 registers follow in ascending order.
790 The PC is saved immediately below the SP. */
791 save_address
= sp
+ PROC_REG_OFFSET(proc_desc
);
792 store_address (raw_buffer
, 8, read_register (RA_REGNUM
));
793 write_memory (save_address
, raw_buffer
, 8);
795 mask
= PROC_REG_MASK(proc_desc
) & 0xffffffffL
;
796 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
799 if (ireg
== RA_REGNUM
)
801 store_address (raw_buffer
, 8, read_register (ireg
));
802 write_memory (save_address
, raw_buffer
, 8);
806 store_address (raw_buffer
, 8, read_register (PC_REGNUM
));
807 write_memory (sp
- 8, raw_buffer
, 8);
809 /* Save floating point registers. */
810 save_address
= sp
+ PROC_FREG_OFFSET(proc_desc
);
811 mask
= PROC_FREG_MASK(proc_desc
) & 0xffffffffL
;
812 for (ireg
= 0; mask
; ireg
++, mask
>>= 1)
815 store_address (raw_buffer
, 8, read_register (ireg
+ FP0_REGNUM
));
816 write_memory (save_address
, raw_buffer
, 8);
820 /* Set and save the frame address for the dummy.
821 This is tricky. The only registers that are suitable for a frame save
822 are those that are preserved across procedure calls (s0-s6). But if
823 a read system call is interrupted and then a dummy call is made
824 (see testsuite/gdb.t17/interrupt.exp) the dummy call hangs till the read
825 is satisfied. Then it returns with the s0-s6 registers set to the values
826 on entry to the read system call and our dummy frame pointer would be
827 destroyed. So we save the dummy frame in the proc_desc and handle the
828 retrieval of the frame pointer of a dummy specifically. The frame register
829 is set to the virtual frame (pseudo) register, it's value will always
830 be read as zero and will help us to catch any errors in the dummy frame
832 PROC_DUMMY_FRAME(proc_desc
) = sp
;
833 PROC_FRAME_REG(proc_desc
) = FP_REGNUM
;
834 PROC_FRAME_OFFSET(proc_desc
) = 0;
835 sp
+= PROC_REG_OFFSET(proc_desc
);
836 write_register (SP_REGNUM
, sp
);
838 PROC_LOW_ADDR(proc_desc
) = CALL_DUMMY_ADDRESS ();
839 PROC_HIGH_ADDR(proc_desc
) = PROC_LOW_ADDR(proc_desc
) + 4;
841 SET_PROC_DESC_IS_DUMMY(proc_desc
);
842 PROC_PC_REG(proc_desc
) = RA_REGNUM
;
849 struct frame_info
*frame
= get_current_frame ();
850 CORE_ADDR new_sp
= frame
->frame
;
852 alpha_extra_func_info_t proc_desc
= frame
->proc_desc
;
854 write_register (PC_REGNUM
, FRAME_SAVED_PC(frame
));
855 if (frame
->saved_regs
== NULL
)
856 alpha_find_saved_regs (frame
);
859 for (regnum
= 32; --regnum
>= 0; )
860 if (PROC_REG_MASK(proc_desc
) & (1 << regnum
))
861 write_register (regnum
,
862 read_memory_integer (frame
->saved_regs
->regs
[regnum
],
864 for (regnum
= 32; --regnum
>= 0; )
865 if (PROC_FREG_MASK(proc_desc
) & (1 << regnum
))
866 write_register (regnum
+ FP0_REGNUM
,
867 read_memory_integer (frame
->saved_regs
->regs
[regnum
+ FP0_REGNUM
], 8));
869 write_register (SP_REGNUM
, new_sp
);
870 flush_cached_frames ();
872 if (proc_desc
&& PROC_DESC_IS_DUMMY(proc_desc
))
874 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
876 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
878 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
880 if (&pi_ptr
->info
== proc_desc
)
885 error ("Can't locate dummy extra frame info\n");
887 if (prev_ptr
!= NULL
)
888 prev_ptr
->next
= pi_ptr
->next
;
890 linked_proc_desc_table
= pi_ptr
->next
;
896 /* To skip prologues, I use this predicate. Returns either PC itself
897 if the code at PC does not look like a function prologue; otherwise
898 returns an address that (if we're lucky) follows the prologue. If
899 LENIENT, then we must skip everything which is involved in setting
900 up the frame (it's OK to skip more, just so long as we don't skip
901 anything which might clobber the registers which are being saved.
902 Currently we must not skip more on the alpha, but we might the lenient
906 alpha_skip_prologue (pc
, lenient
)
912 CORE_ADDR post_prologue_pc
;
915 #ifdef GDB_TARGET_HAS_SHARED_LIBS
916 /* Silently return the unaltered pc upon memory errors.
917 This could happen on OSF/1 if decode_line_1 tries to skip the
918 prologue for quickstarted shared library functions when the
919 shared library is not yet mapped in.
920 Reading target memory is slow over serial lines, so we perform
921 this check only if the target has shared libraries. */
922 if (target_read_memory (pc
, buf
, 4))
926 /* See if we can determine the end of the prologue via the symbol table.
927 If so, then return either PC, or the PC after the prologue, whichever
930 post_prologue_pc
= after_prologue (pc
, NULL
);
932 if (post_prologue_pc
!= 0)
933 return max (pc
, post_prologue_pc
);
935 /* Can't determine prologue from the symbol table, need to examine
938 /* Skip the typical prologue instructions. These are the stack adjustment
939 instruction and the instructions that save registers on the stack
940 or in the gcc frame. */
941 for (offset
= 0; offset
< 100; offset
+= 4)
945 status
= read_memory_nobpt (pc
+ offset
, buf
, 4);
947 memory_error (status
, pc
+ offset
);
948 inst
= extract_unsigned_integer (buf
, 4);
950 /* The alpha has no delay slots. But let's keep the lenient stuff,
951 we might need it for something else in the future. */
955 if ((inst
& 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
957 if ((inst
& 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
959 if ((inst
& 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
961 else if ((inst
& 0xfc1f0000) == 0xb41e0000
962 && (inst
& 0xffff0000) != 0xb7fe0000)
963 continue; /* stq reg,n($sp) */
965 else if ((inst
& 0xfc1f0000) == 0x9c1e0000
966 && (inst
& 0xffff0000) != 0x9ffe0000)
967 continue; /* stt reg,n($sp) */
969 else if (inst
== 0x47de040f) /* bis sp,sp,fp */
978 /* Is address PC in the prologue (loosely defined) for function at
982 alpha_in_lenient_prologue (startaddr
, pc
)
986 CORE_ADDR end_prologue
= alpha_skip_prologue (startaddr
, 1);
987 return pc
>= startaddr
&& pc
< end_prologue
;
991 /* The alpha needs a conversion between register and memory format if
992 the register is a floating point register and
993 memory format is float, as the register format must be double
995 memory format is an integer with 4 bytes or less, as the representation
996 of integers in floating point registers is different. */
998 alpha_register_convert_to_virtual (regnum
, valtype
, raw_buffer
, virtual_buffer
)
1000 struct type
*valtype
;
1002 char *virtual_buffer
;
1004 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1006 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
1010 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1012 double d
= extract_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1013 store_floating (virtual_buffer
, TYPE_LENGTH (valtype
), d
);
1015 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1018 l
= extract_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1019 l
= ((l
>> 32) & 0xc0000000) | ((l
>> 29) & 0x3fffffff);
1020 store_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
), l
);
1023 error ("Cannot retrieve value from floating point register");
1027 alpha_register_convert_to_raw (valtype
, regnum
, virtual_buffer
, raw_buffer
)
1028 struct type
*valtype
;
1030 char *virtual_buffer
;
1033 if (TYPE_LENGTH (valtype
) >= REGISTER_RAW_SIZE (regnum
))
1035 memcpy (raw_buffer
, virtual_buffer
, REGISTER_RAW_SIZE (regnum
));
1039 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1041 double d
= extract_floating (virtual_buffer
, TYPE_LENGTH (valtype
));
1042 store_floating (raw_buffer
, REGISTER_RAW_SIZE (regnum
), d
);
1044 else if (TYPE_CODE (valtype
) == TYPE_CODE_INT
&& TYPE_LENGTH (valtype
) <= 4)
1047 if (TYPE_UNSIGNED (valtype
))
1048 l
= extract_unsigned_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1050 l
= extract_signed_integer (virtual_buffer
, TYPE_LENGTH (valtype
));
1051 l
= ((l
& 0xc0000000) << 32) | ((l
& 0x3fffffff) << 29);
1052 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), l
);
1055 error ("Cannot store value in floating point register");
1058 /* Given a return value in `regbuf' with a type `valtype',
1059 extract and copy its value into `valbuf'. */
1062 alpha_extract_return_value (valtype
, regbuf
, valbuf
)
1063 struct type
*valtype
;
1064 char regbuf
[REGISTER_BYTES
];
1069 regnum
= TYPE_CODE (valtype
) == TYPE_CODE_FLT
? FP0_REGNUM
: V0_REGNUM
;
1071 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (regnum
), TYPE_LENGTH (valtype
));
1074 /* Given a return value in `regbuf' with a type `valtype',
1075 write its value into the appropriate register. */
1078 alpha_store_return_value (valtype
, valbuf
)
1079 struct type
*valtype
;
1083 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1085 regnum
= TYPE_CODE (valtype
) == TYPE_CODE_FLT
? FP0_REGNUM
: V0_REGNUM
;
1086 memcpy(raw_buffer
, valbuf
, TYPE_LENGTH (valtype
));
1088 write_register_bytes(REGISTER_BYTE (regnum
), raw_buffer
, TYPE_LENGTH (valtype
));
1091 /* Just like reinit_frame_cache, but with the right arguments to be
1092 callable as an sfunc. */
1095 reinit_frame_cache_sfunc (args
, from_tty
, c
)
1098 struct cmd_list_element
*c
;
1100 reinit_frame_cache ();
1103 /* This is the definition of CALL_DUMMY_ADDRESS. It's a heuristic that is used
1104 to find a convenient place in the text segment to stick a breakpoint to
1105 detect the completion of a target function call (ala call_function_by_hand).
1109 alpha_call_dummy_address ()
1112 struct minimal_symbol
*sym
;
1114 entry
= entry_point_address ();
1119 sym
= lookup_minimal_symbol ("_Prelude", NULL
, symfile_objfile
);
1121 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1124 return SYMBOL_VALUE_ADDRESS (sym
) + 4;
1128 _initialize_alpha_tdep ()
1130 struct cmd_list_element
*c
;
1132 tm_print_insn
= print_insn_alpha
;
1134 /* Let the user set the fence post for heuristic_proc_start. */
1136 /* We really would like to have both "0" and "unlimited" work, but
1137 command.c doesn't deal with that. So make it a var_zinteger
1138 because the user can always use "999999" or some such for unlimited. */
1139 c
= add_set_cmd ("heuristic-fence-post", class_support
, var_zinteger
,
1140 (char *) &heuristic_fence_post
,
1142 Set the distance searched for the start of a function.\n\
1143 If you are debugging a stripped executable, GDB needs to search through the\n\
1144 program for the start of a function. This command sets the distance of the\n\
1145 search. The only need to set it is when debugging a stripped executable.",
1147 /* We need to throw away the frame cache when we set this, since it
1148 might change our ability to get backtraces. */
1149 c
->function
.sfunc
= reinit_frame_cache_sfunc
;
1150 add_show_from_set (c
, &showlist
);