1 /* Target-dependent code for the MIPS architecture, for GDB, the GNU Debugger.
2 Copyright 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3 Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
4 and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
33 #define VM_MIN_ADDRESS (unsigned)0x400000
35 /* Some MIPS boards don't support floating point, so we permit the
36 user to turn it off. */
39 /* Heuristic_proc_start may hunt through the text section for a long
40 time across a 2400 baud serial line. Allows the user to limit this
42 static unsigned int heuristic_fence_post
= 0;
44 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
45 #define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
46 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
47 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
48 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
49 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
50 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
51 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
52 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
53 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)
54 #define _PROC_MAGIC_ 0x0F0F0F0F
55 #define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)
56 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
58 struct linked_proc_info
60 struct mips_extra_func_info info
;
61 struct linked_proc_info
*next
;
62 } *linked_proc_desc_table
= NULL
;
65 #define READ_FRAME_REG(fi, regno) read_next_frame_reg((fi)->next, regno)
68 read_next_frame_reg(fi
, regno
)
72 /* If it is the frame for sigtramp we have a complete sigcontext
73 immediately below the frame and we get the saved registers from there.
74 If the stack layout for sigtramp changes we might have to change these
75 constants and the companion fixup_sigtramp in mipsread.c */
77 #define SIGFRAME_BASE 0x12c /* sizeof(sigcontext) */
78 #define SIGFRAME_PC_OFF (-SIGFRAME_BASE + 2 * 4)
79 #define SIGFRAME_REGSAVE_OFF (-SIGFRAME_BASE + 3 * 4)
81 for (; fi
; fi
= fi
->next
)
82 if (in_sigtramp(fi
->pc
, 0)) {
84 if (regno
== PC_REGNUM
) offset
= SIGFRAME_PC_OFF
;
85 else if (regno
< 32) offset
= SIGFRAME_REGSAVE_OFF
+ regno
* 4;
87 return read_memory_integer(fi
->frame
+ offset
, 4);
89 else if (regno
== SP_REGNUM
) return fi
->frame
;
90 else if (fi
->saved_regs
->regs
[regno
])
91 return read_memory_integer(fi
->saved_regs
->regs
[regno
], 4);
92 return read_register(regno
);
96 mips_frame_saved_pc(frame
)
99 mips_extra_func_info_t proc_desc
= frame
->proc_desc
;
100 int pcreg
= proc_desc
? PROC_PC_REG(proc_desc
) : RA_REGNUM
;
102 if (proc_desc
&& PROC_DESC_IS_DUMMY(proc_desc
))
103 return read_memory_integer(frame
->frame
- 4, 4);
105 return read_next_frame_reg(frame
, pcreg
);
108 static struct mips_extra_func_info temp_proc_desc
;
109 static struct frame_saved_regs temp_saved_regs
;
111 /* This fencepost looks highly suspicious to me. Removing it also
112 seems suspicious as it could affect remote debugging across serial
116 heuristic_proc_start(pc
)
119 CORE_ADDR start_pc
= pc
;
120 CORE_ADDR fence
= start_pc
- heuristic_fence_post
;
122 if (start_pc
== 0) return 0;
124 if (heuristic_fence_post
== UINT_MAX
125 || fence
< VM_MIN_ADDRESS
)
126 fence
= VM_MIN_ADDRESS
;
128 /* search back for previous return */
129 for (start_pc
-= 4; ; start_pc
-= 4)
130 if (start_pc
< fence
)
132 /* It's not clear to me why we reach this point when
133 stop_soon_quietly, but with this test, at least we
134 don't print out warnings for every child forked (eg, on
135 decstation). 22apr93 rich@cygnus.com. */
136 if (!stop_soon_quietly
)
138 if (fence
== VM_MIN_ADDRESS
)
139 warning("Hit beginning of text section without finding");
141 warning("Hit heuristic-fence-post without finding");
143 warning("enclosing function for pc 0x%x", pc
);
148 else if (ABOUT_TO_RETURN(start_pc
))
151 start_pc
+= 8; /* skip return, and its delay slot */
153 /* skip nops (usually 1) 0 - is this */
154 while (start_pc
< pc
&& read_memory_integer (start_pc
, 4) == 0)
160 static mips_extra_func_info_t
161 heuristic_proc_desc(start_pc
, limit_pc
, next_frame
)
162 CORE_ADDR start_pc
, limit_pc
;
165 CORE_ADDR sp
= next_frame
? next_frame
->frame
: read_register (SP_REGNUM
);
168 int has_frame_reg
= 0;
169 int reg30
; /* Value of $r30. Used by gcc for frame-pointer */
170 unsigned long reg_mask
= 0;
172 if (start_pc
== 0) return NULL
;
173 bzero(&temp_proc_desc
, sizeof(temp_proc_desc
));
174 bzero(&temp_saved_regs
, sizeof(struct frame_saved_regs
));
175 PROC_LOW_ADDR(&temp_proc_desc
) = start_pc
;
177 if (start_pc
+ 200 < limit_pc
) limit_pc
= start_pc
+ 200;
180 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4) {
185 status
= read_memory_nobpt (cur_pc
, buf
, 4);
186 if (status
) memory_error (status
, cur_pc
);
187 word
= extract_unsigned_integer (buf
, 4);
189 if ((word
& 0xFFFF0000) == 0x27bd0000) /* addiu $sp,$sp,-i */
190 frame_size
+= (-word
) & 0xFFFF;
191 else if ((word
& 0xFFFF0000) == 0x23bd0000) /* addu $sp,$sp,-i */
192 frame_size
+= (-word
) & 0xFFFF;
193 else if ((word
& 0xFFE00000) == 0xafa00000) { /* sw reg,offset($sp) */
194 int reg
= (word
& 0x001F0000) >> 16;
195 reg_mask
|= 1 << reg
;
196 temp_saved_regs
.regs
[reg
] = sp
+ (short)word
;
198 else if ((word
& 0xFFFF0000) == 0x27be0000) { /* addiu $30,$sp,size */
199 if ((unsigned short)word
!= frame_size
)
200 reg30
= sp
+ (unsigned short)word
;
201 else if (!has_frame_reg
) {
204 reg30
= read_next_frame_reg(next_frame
, 30);
205 alloca_adjust
= reg30
- (sp
+ (unsigned short)word
);
206 if (alloca_adjust
> 0) {
207 /* FP > SP + frame_size. This may be because
208 /* of an alloca or somethings similar.
209 * Fix sp to "pre-alloca" value, and try again.
216 else if ((word
& 0xFFE00000) == 0xafc00000) { /* sw reg,offset($30) */
217 int reg
= (word
& 0x001F0000) >> 16;
218 reg_mask
|= 1 << reg
;
219 temp_saved_regs
.regs
[reg
] = reg30
+ (short)word
;
223 PROC_FRAME_REG(&temp_proc_desc
) = 30;
224 PROC_FRAME_OFFSET(&temp_proc_desc
) = 0;
227 PROC_FRAME_REG(&temp_proc_desc
) = SP_REGNUM
;
228 PROC_FRAME_OFFSET(&temp_proc_desc
) = frame_size
;
230 PROC_REG_MASK(&temp_proc_desc
) = reg_mask
;
231 PROC_PC_REG(&temp_proc_desc
) = RA_REGNUM
;
232 return &temp_proc_desc
;
235 static mips_extra_func_info_t
236 find_proc_desc(pc
, next_frame
)
240 mips_extra_func_info_t proc_desc
;
241 struct block
*b
= block_for_pc(pc
);
243 b
? lookup_symbol(MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, 0, NULL
) : NULL
;
247 /* IF this is the topmost frame AND
248 * (this proc does not have debugging information OR
249 * the PC is in the procedure prologue)
250 * THEN create a "heuristic" proc_desc (by analyzing
251 * the actual code) to replace the "official" proc_desc.
253 proc_desc
= (mips_extra_func_info_t
)SYMBOL_VALUE(sym
);
254 if (next_frame
== NULL
) {
255 struct symtab_and_line val
;
256 struct symbol
*proc_symbol
=
257 PROC_DESC_IS_DUMMY(proc_desc
) ? 0 : PROC_SYMBOL(proc_desc
);
260 val
= find_pc_line (BLOCK_START
261 (SYMBOL_BLOCK_VALUE(proc_symbol
)),
263 val
.pc
= val
.end
? val
.end
: pc
;
265 if (!proc_symbol
|| pc
< val
.pc
) {
266 mips_extra_func_info_t found_heuristic
=
267 heuristic_proc_desc(PROC_LOW_ADDR(proc_desc
),
269 if (found_heuristic
) proc_desc
= found_heuristic
;
275 /* Is linked_proc_desc_table really necessary? It only seems to be used
276 by procedure call dummys. However, the procedures being called ought
277 to have their own proc_descs, and even if they don't,
278 heuristic_proc_desc knows how to create them! */
280 register struct linked_proc_info
*link
;
281 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
282 if (PROC_LOW_ADDR(&link
->info
) <= pc
283 && PROC_HIGH_ADDR(&link
->info
) > pc
)
286 heuristic_proc_desc(heuristic_proc_start(pc
), pc
, next_frame
);
291 mips_extra_func_info_t cached_proc_desc
;
294 mips_frame_chain(frame
)
297 mips_extra_func_info_t proc_desc
;
298 CORE_ADDR saved_pc
= FRAME_SAVED_PC(frame
);
300 if (saved_pc
== 0 || inside_entry_file (saved_pc
))
303 proc_desc
= find_proc_desc(saved_pc
, frame
);
307 cached_proc_desc
= proc_desc
;
308 return read_next_frame_reg(frame
, PROC_FRAME_REG(proc_desc
))
309 + PROC_FRAME_OFFSET(proc_desc
);
313 init_extra_frame_info(fci
)
314 struct frame_info
*fci
;
316 extern struct obstack frame_cache_obstack
;
317 /* Use proc_desc calculated in frame_chain */
318 mips_extra_func_info_t proc_desc
= fci
->next
? cached_proc_desc
:
319 find_proc_desc(fci
->pc
, fci
->next
);
321 fci
->saved_regs
= (struct frame_saved_regs
*)
322 obstack_alloc (&frame_cache_obstack
, sizeof(struct frame_saved_regs
));
323 bzero(fci
->saved_regs
, sizeof(struct frame_saved_regs
));
325 proc_desc
== &temp_proc_desc
? 0 : proc_desc
;
329 CORE_ADDR reg_position
;
331 /* r0 bit means kernel trap */
332 int kernel_trap
= PROC_REG_MASK(proc_desc
) & 1;
334 /* Fixup frame-pointer - only needed for top frame */
335 /* This may not be quite right, if proc has a real frame register */
336 if (fci
->pc
== PROC_LOW_ADDR(proc_desc
) && !PROC_DESC_IS_DUMMY(proc_desc
))
337 fci
->frame
= read_register (SP_REGNUM
);
339 fci
->frame
= READ_FRAME_REG(fci
, PROC_FRAME_REG(proc_desc
))
340 + PROC_FRAME_OFFSET(proc_desc
);
342 if (proc_desc
== &temp_proc_desc
)
343 *fci
->saved_regs
= temp_saved_regs
;
346 /* find which general-purpose registers were saved */
347 reg_position
= fci
->frame
+ PROC_REG_OFFSET(proc_desc
);
348 mask
= kernel_trap
? 0xFFFFFFFF : PROC_REG_MASK(proc_desc
);
349 for (ireg
= 31; mask
; --ireg
, mask
<<= 1)
350 if (mask
& 0x80000000)
352 fci
->saved_regs
->regs
[ireg
] = reg_position
;
355 /* find which floating-point registers were saved */
356 reg_position
= fci
->frame
+ PROC_FREG_OFFSET(proc_desc
);
357 /* The freg_offset points to where the first *double* register is saved.
358 * So skip to the high-order word. */
360 mask
= kernel_trap
? 0xFFFFFFFF : PROC_FREG_MASK(proc_desc
);
361 for (ireg
= 31; mask
; --ireg
, mask
<<= 1)
362 if (mask
& 0x80000000)
364 fci
->saved_regs
->regs
[FP0_REGNUM
+ireg
] = reg_position
;
369 /* hack: if argument regs are saved, guess these contain args */
370 if ((PROC_REG_MASK(proc_desc
) & 0xF0) == 0) fci
->num_args
= -1;
371 else if ((PROC_REG_MASK(proc_desc
) & 0x80) == 0) fci
->num_args
= 4;
372 else if ((PROC_REG_MASK(proc_desc
) & 0x40) == 0) fci
->num_args
= 3;
373 else if ((PROC_REG_MASK(proc_desc
) & 0x20) == 0) fci
->num_args
= 2;
374 else if ((PROC_REG_MASK(proc_desc
) & 0x10) == 0) fci
->num_args
= 1;
376 fci
->saved_regs
->regs
[PC_REGNUM
] = fci
->saved_regs
->regs
[RA_REGNUM
];
380 /* MIPS stack frames are almost impenetrable. When execution stops,
381 we basically have to look at symbol information for the function
382 that we stopped in, which tells us *which* register (if any) is
383 the base of the frame pointer, and what offset from that register
384 the frame itself is at.
386 This presents a problem when trying to examine a stack in memory
387 (that isn't executing at the moment), using the "frame" command. We
388 don't have a PC, nor do we have any registers except SP.
390 This routine takes two arguments, SP and PC, and tries to make the
391 cached frames look as if these two arguments defined a frame on the
392 cache. This allows the rest of info frame to extract the important
393 arguments without difficulty. */
396 setup_arbitrary_frame (argc
, argv
)
401 error ("MIPS frame specifications require two arguments: sp and pc");
403 return create_new_frame (argv
[0], argv
[1]);
408 mips_push_arguments(nargs
, args
, sp
, struct_return
, struct_addr
)
413 CORE_ADDR struct_addr
;
417 int accumulate_size
= struct_return
? 4 : 0;
418 struct mips_arg
{ char *contents
; int len
; int offset
; };
419 struct mips_arg
*mips_args
=
420 (struct mips_arg
*)alloca(nargs
* sizeof(struct mips_arg
));
421 register struct mips_arg
*m_arg
;
422 for (i
= 0, m_arg
= mips_args
; i
< nargs
; i
++, m_arg
++) {
423 extern value
value_arg_coerce();
424 value arg
= value_arg_coerce (args
[i
]);
425 m_arg
->len
= TYPE_LENGTH (VALUE_TYPE (arg
));
426 /* This entire mips-specific routine is because doubles must be aligned
427 * on 8-byte boundaries. It still isn't quite right, because MIPS decided
428 * to align 'struct {int a, b}' on 4-byte boundaries (even though this
429 * breaks their varargs implementation...). A correct solution
430 * requires an simulation of gcc's 'alignof' (and use of 'alignof'
431 * in stdarg.h/varargs.h).
433 if (m_arg
->len
> 4) accumulate_size
= (accumulate_size
+ 7) & -8;
434 m_arg
->offset
= accumulate_size
;
435 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 3) & -4;
436 m_arg
->contents
= VALUE_CONTENTS(arg
);
438 accumulate_size
= (accumulate_size
+ 7) & (-8);
439 if (accumulate_size
< 16) accumulate_size
= 16;
440 sp
-= accumulate_size
;
441 for (i
= nargs
; m_arg
--, --i
>= 0; )
442 write_memory(sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
445 write_memory(sp
, (char *)&buf
, sizeof(CORE_ADDR
));
450 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
451 #define MASK(i,j) ((1 << (j)+1)-1 ^ (1 << (i))-1)
454 mips_push_dummy_frame()
457 struct linked_proc_info
*link
= (struct linked_proc_info
*)
458 xmalloc(sizeof(struct linked_proc_info
));
459 mips_extra_func_info_t proc_desc
= &link
->info
;
460 CORE_ADDR sp
= read_register (SP_REGNUM
);
461 CORE_ADDR save_address
;
462 REGISTER_TYPE buffer
;
463 link
->next
= linked_proc_desc_table
;
464 linked_proc_desc_table
= link
;
465 #define PUSH_FP_REGNUM 16 /* must be a register preserved across calls */
466 #define GEN_REG_SAVE_MASK MASK(1,16)|MASK(24,28)|(1<<31)
467 #define GEN_REG_SAVE_COUNT 22
468 #define FLOAT_REG_SAVE_MASK MASK(0,19)
469 #define FLOAT_REG_SAVE_COUNT 20
470 #define SPECIAL_REG_SAVE_COUNT 4
472 * The registers we must save are all those not preserved across
473 * procedure calls. Dest_Reg (see tm-mips.h) must also be saved.
474 * In addition, we must save the PC, and PUSH_FP_REGNUM.
475 * (Ideally, we should also save MDLO/-HI and FP Control/Status reg.)
477 * Dummy frame layout:
480 * Saved MMHI, MMLO, FPC_CSR
485 * Saved D18 (i.e. F19, F18)
487 * Saved D0 (i.e. F1, F0)
488 * CALL_DUMMY (subroutine stub; see tm-mips.h)
489 * Parameter build area (not yet implemented)
492 PROC_REG_MASK(proc_desc
) = GEN_REG_SAVE_MASK
;
493 PROC_FREG_MASK(proc_desc
) = mips_fpu
? FLOAT_REG_SAVE_MASK
: 0;
494 PROC_REG_OFFSET(proc_desc
) = /* offset of (Saved R31) from FP */
495 -sizeof(long) - 4 * SPECIAL_REG_SAVE_COUNT
;
496 PROC_FREG_OFFSET(proc_desc
) = /* offset of (Saved D18) from FP */
497 -sizeof(double) - 4 * (SPECIAL_REG_SAVE_COUNT
+ GEN_REG_SAVE_COUNT
);
498 /* save general registers */
499 save_address
= sp
+ PROC_REG_OFFSET(proc_desc
);
500 for (ireg
= 32; --ireg
>= 0; )
501 if (PROC_REG_MASK(proc_desc
) & (1 << ireg
))
503 buffer
= read_register (ireg
);
504 write_memory (save_address
, (char *)&buffer
, sizeof(REGISTER_TYPE
));
507 /* save floating-points registers starting with high order word */
508 save_address
= sp
+ PROC_FREG_OFFSET(proc_desc
) + 4;
509 for (ireg
= 32; --ireg
>= 0; )
510 if (PROC_FREG_MASK(proc_desc
) & (1 << ireg
))
512 buffer
= read_register (ireg
+ FP0_REGNUM
);
513 write_memory (save_address
, (char *)&buffer
, 4);
516 write_register (PUSH_FP_REGNUM
, sp
);
517 PROC_FRAME_REG(proc_desc
) = PUSH_FP_REGNUM
;
518 PROC_FRAME_OFFSET(proc_desc
) = 0;
519 buffer
= read_register (PC_REGNUM
);
520 write_memory (sp
- 4, (char *)&buffer
, sizeof(REGISTER_TYPE
));
521 buffer
= read_register (HI_REGNUM
);
522 write_memory (sp
- 8, (char *)&buffer
, sizeof(REGISTER_TYPE
));
523 buffer
= read_register (LO_REGNUM
);
524 write_memory (sp
- 12, (char *)&buffer
, sizeof(REGISTER_TYPE
));
525 buffer
= read_register (mips_fpu
? FCRCS_REGNUM
: ZERO_REGNUM
);
526 write_memory (sp
- 16, (char *)&buffer
, sizeof(REGISTER_TYPE
));
527 sp
-= 4 * (GEN_REG_SAVE_COUNT
528 + (mips_fpu
? FLOAT_REG_SAVE_COUNT
: 0)
529 + SPECIAL_REG_SAVE_COUNT
);
530 write_register (SP_REGNUM
, sp
);
531 PROC_LOW_ADDR(proc_desc
) = sp
- CALL_DUMMY_SIZE
+ CALL_DUMMY_START_OFFSET
;
532 PROC_HIGH_ADDR(proc_desc
) = sp
;
533 SET_PROC_DESC_IS_DUMMY(proc_desc
);
534 PROC_PC_REG(proc_desc
) = RA_REGNUM
;
541 FRAME frame
= get_current_frame ();
542 CORE_ADDR new_sp
= frame
->frame
;
544 mips_extra_func_info_t proc_desc
= frame
->proc_desc
;
546 write_register (PC_REGNUM
, FRAME_SAVED_PC(frame
));
549 for (regnum
= 32; --regnum
>= 0; )
550 if (PROC_REG_MASK(proc_desc
) & (1 << regnum
))
551 write_register (regnum
,
552 read_memory_integer (frame
->saved_regs
->regs
[regnum
],
554 for (regnum
= 32; --regnum
>= 0; )
555 if (PROC_FREG_MASK(proc_desc
) & (1 << regnum
))
556 write_register (regnum
+ FP0_REGNUM
,
557 read_memory_integer (frame
->saved_regs
->regs
[regnum
+ FP0_REGNUM
], 4));
559 write_register (SP_REGNUM
, new_sp
);
560 flush_cached_frames ();
561 /* We let mips_init_extra_frame_info figure out the frame pointer */
562 set_current_frame (create_new_frame (0, read_pc ()));
564 if (PROC_DESC_IS_DUMMY(proc_desc
))
566 struct linked_proc_info
*pi_ptr
, *prev_ptr
;
568 for (pi_ptr
= linked_proc_desc_table
, prev_ptr
= NULL
;
570 prev_ptr
= pi_ptr
, pi_ptr
= pi_ptr
->next
)
572 if (&pi_ptr
->info
== proc_desc
)
577 error ("Can't locate dummy extra frame info\n");
579 if (prev_ptr
!= NULL
)
580 prev_ptr
->next
= pi_ptr
->next
;
582 linked_proc_desc_table
= pi_ptr
->next
;
586 write_register (HI_REGNUM
, read_memory_integer(new_sp
- 8, 4));
587 write_register (LO_REGNUM
, read_memory_integer(new_sp
- 12, 4));
589 write_register (FCRCS_REGNUM
, read_memory_integer(new_sp
- 16, 4));
594 mips_print_register (regnum
, all
)
597 unsigned char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
600 /* Get the data in raw format. */
601 if (read_relative_register_raw_bytes (regnum
, raw_buffer
))
603 printf_filtered ("%s: [Invalid]", reg_names
[regnum
]);
607 /* If an even floating pointer register, also print as double. */
608 if (regnum
>= FP0_REGNUM
&& regnum
< FP0_REGNUM
+32
609 && !((regnum
-FP0_REGNUM
) & 1)) {
610 char dbuffer
[MAX_REGISTER_RAW_SIZE
];
612 read_relative_register_raw_bytes (regnum
, dbuffer
);
613 read_relative_register_raw_bytes (regnum
+1, dbuffer
+4);
614 #ifdef REGISTER_CONVERT_TO_TYPE
615 REGISTER_CONVERT_TO_TYPE(regnum
, builtin_type_double
, dbuffer
);
617 printf_filtered ("(d%d: ", regnum
-FP0_REGNUM
);
618 val_print (builtin_type_double
, dbuffer
, 0,
619 stdout
, 0, 1, 0, Val_pretty_default
);
620 printf_filtered ("); ");
622 fputs_filtered (reg_names
[regnum
], stdout
);
623 #ifndef NUMERIC_REG_NAMES
625 printf_filtered ("(r%d): ", regnum
);
628 printf_filtered (": ");
630 /* If virtual format is floating, print it that way. */
631 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum
)) == TYPE_CODE_FLT
632 && ! INVALID_FLOAT (raw_buffer
, REGISTER_VIRTUAL_SIZE(regnum
))) {
633 val_print (REGISTER_VIRTUAL_TYPE (regnum
), raw_buffer
, 0,
634 stdout
, 0, 1, 0, Val_pretty_default
);
636 /* Else print as integer in hex. */
641 val
= extract_signed_integer (raw_buffer
,
642 REGISTER_RAW_SIZE (regnum
));
645 printf_filtered ("0");
647 printf_filtered (local_hex_format(), val
);
649 printf_filtered ("%s=%d", local_hex_string(val
), val
);
653 /* Replacement for generic do_registers_info. */
655 mips_do_registers_info (regnum
, fpregs
)
660 mips_print_register (regnum
, 0);
661 printf_filtered ("\n");
664 for (regnum
= 0; regnum
< NUM_REGS
; ) {
665 if ((!fpregs
) && regnum
>= FP0_REGNUM
&& regnum
<= FCRIR_REGNUM
) {
669 mips_print_register (regnum
, 1);
671 if ((regnum
& 3) == 0 || regnum
== NUM_REGS
)
672 printf_filtered (";\n");
674 printf_filtered ("; ");
678 /* Return number of args passed to a frame. described by FIP.
679 Can return -1, meaning no way to tell. */
682 mips_frame_num_args(fip
)
686 struct chain_info_t
*p
;
688 p
= mips_find_cached_frame(FRAME_FP(fip
));
690 return p
->the_info
.numargs
;
695 /* To skip prologues, I use this predicate. Returns either PC
696 itself if the code at PC does not look like a function prologue;
697 otherwise returns an address that (if we're lucky) follows
701 mips_skip_prologue(pc
)
708 int seen_sp_adjust
= 0;
710 /* Skip the typical prologue instructions. These are the stack adjustment
711 instruction and the instructions that save registers on the stack
712 or in the gcc frame. */
713 for (offset
= 0; offset
< 100; offset
+= 4) {
714 inst
= read_memory_integer(pc
+ offset
, 4);
715 if ((inst
& 0xffff0000) == 0x27bd0000) /* addiu $sp,$sp,offset */
717 else if ((inst
& 0xFFE00000) == 0xAFA00000 && (inst
& 0x001F0000))
718 continue; /* sw reg,n($sp) */
720 else if ((inst
& 0xFFE00000) == 0xE7A00000) /* swc1 freg,n($sp) */
722 else if ((inst
& 0xF3E00000) == 0xA3C00000 && (inst
& 0x001F0000))
724 continue; /* reg != $zero */
725 else if (inst
== 0x03A0F021) /* move $s8,$sp */
727 else if ((inst
& 0xFF9F07FF) == 0x00800021) /* move reg,$a0-$a3 */
734 /* FIXME schauer. The following code seems no longer necessary if we
735 always skip the typical prologue instructions. */
741 /* Well, it looks like a frameless. Let's make sure.
742 Note that we are not called on the current PC,
743 but on the function`s start PC, and I have definitely
744 seen optimized code that adjusts the SP quite later */
745 b
= block_for_pc(pc
);
748 f
= lookup_symbol(MIPS_EFI_SYMBOL_NAME
, b
, LABEL_NAMESPACE
, 0, NULL
);
750 /* Ideally, I would like to use the adjusted info
751 from mips_frame_info(), but for all practical
752 purposes it will not matter (and it would require
753 a different definition of SKIP_PROLOGUE())
755 Actually, it would not hurt to skip the storing
756 of arguments on the stack as well. */
757 if (((mips_extra_func_info_t
)SYMBOL_VALUE(f
))->pdr
.frameoffset
)
764 /* Given a return value in `regbuf' with a type `valtype',
765 extract and copy its value into `valbuf'. */
767 mips_extract_return_value (valtype
, regbuf
, valbuf
)
768 struct type
*valtype
;
769 char regbuf
[REGISTER_BYTES
];
774 regnum
= TYPE_CODE (valtype
) == TYPE_CODE_FLT
&& mips_fpu
? FP0_REGNUM
: 2;
776 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (regnum
), TYPE_LENGTH (valtype
));
777 #ifdef REGISTER_CONVERT_TO_TYPE
778 REGISTER_CONVERT_TO_TYPE(regnum
, valtype
, valbuf
);
782 /* Given a return value in `regbuf' with a type `valtype',
783 write it's value into the appropriate register. */
785 mips_store_return_value (valtype
, valbuf
)
786 struct type
*valtype
;
790 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
792 regnum
= TYPE_CODE (valtype
) == TYPE_CODE_FLT
&& mips_fpu
? FP0_REGNUM
: 2;
793 memcpy(raw_buffer
, valbuf
, TYPE_LENGTH (valtype
));
795 #ifdef REGISTER_CONVERT_FROM_TYPE
796 REGISTER_CONVERT_FROM_TYPE(regnum
, valtype
, raw_buffer
);
799 write_register_bytes(REGISTER_BYTE (regnum
), raw_buffer
, TYPE_LENGTH (valtype
));
802 /* Let the user turn off floating point and set the fence post for
803 heuristic_proc_start. */
806 _initialize_mips_tdep ()
809 (add_set_cmd ("mipsfpu", class_support
, var_boolean
,
811 "Set use of floating point coprocessor.\n\
812 Turn off to avoid using floating point instructions when calling functions\n\
813 or dealing with return values.", &setlist
),
817 (add_set_cmd ("heuristic-fence-post", class_support
, var_uinteger
,
818 (char *) &heuristic_fence_post
,
819 "Set the distance searched for the start of a function.\n\
820 Set number of bytes to be searched backward to find the beginning of a\n\
821 function without symbols.", &setlist
),