1 /* Work with core dump and executable files, for GDB on MIPS.
2 This code would be in core.c if it weren't machine-dependent. */
4 /* Low level interface to ptrace, for GDB when running under Unix.
5 Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc.
6 Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
7 and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25 /* FIXME: Can a MIPS porter/tester determine which of these include
26 files we still need? -- gnu@cygnus.com */
28 #include <mips/inst.h>
38 #include <sys/types.h>
41 #include <sys/param.h>
44 #include <sys/ioctl.h>
50 #define MIPSMAGIC MIPSELMAGIC
52 #define MIPSMAGIC MIPSEBMAGIC
56 #define VM_MIN_ADDRESS (unsigned)0x400000
58 #include <sys/user.h> /* After a.out.h */
63 #define PROC_LOW_ADDR(proc) ((proc)->adr) /* least address */
64 #define PROC_HIGH_ADDR(proc) ((proc)->pad2) /* upper address bound */
65 #define PROC_FRAME_OFFSET(proc) ((proc)->framesize)
66 #define PROC_FRAME_REG(proc) ((proc)->framereg)
67 #define PROC_REG_MASK(proc) ((proc)->regmask)
68 #define PROC_FREG_MASK(proc) ((proc)->fregmask)
69 #define PROC_REG_OFFSET(proc) ((proc)->regoffset)
70 #define PROC_FREG_OFFSET(proc) ((proc)->fregoffset)
71 #define PROC_PC_REG(proc) ((proc)->pcreg)
72 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->isym)
73 #define _PROC_MAGIC_ 0x0F0F0F0F
74 #define PROC_DESC_IS_DUMMY(proc) ((proc)->isym == _PROC_MAGIC_)
75 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->isym = _PROC_MAGIC_)
77 struct linked_proc_info
79 struct mips_extra_func_info info
;
80 struct linked_proc_info
*next
;
81 } * linked_proc_desc_table
= NULL
;
84 #define READ_FRAME_REG(fi, regno) read_next_frame_reg((fi)->next, regno)
87 read_next_frame_reg(fi
, regno
)
91 #define SIGFRAME_BASE sizeof(struct sigcontext)
92 #define SIGFRAME_PC_OFF (-SIGFRAME_BASE+ 2*sizeof(int))
93 #define SIGFRAME_SP_OFF (-SIGFRAME_BASE+32*sizeof(int))
94 #define SIGFRAME_RA_OFF (-SIGFRAME_BASE+34*sizeof(int))
95 for (; fi
; fi
= fi
->next
)
96 if (in_sigtramp(fi
->pc
, 0)) {
97 /* No idea if this code works. --PB. */
99 if (regno
== PC_REGNUM
) offset
= SIGFRAME_PC_OFF
;
100 else if (regno
== RA_REGNUM
) offset
= SIGFRAME_RA_OFF
;
101 else if (regno
== SP_REGNUM
) offset
= SIGFRAME_SP_OFF
;
103 return read_memory_integer(fi
->frame
+ offset
, 4);
105 else if (regno
== SP_REGNUM
) return fi
->frame
;
106 else if (fi
->saved_regs
->regs
[regno
])
107 return read_memory_integer(fi
->saved_regs
->regs
[regno
], 4);
108 return read_register(regno
);
112 mips_frame_saved_pc(frame
)
115 mips_extra_func_info_t proc_desc
= (mips_extra_func_info_t
)frame
->proc_desc
;
116 int pcreg
= proc_desc
? PROC_PC_REG(proc_desc
) : RA_REGNUM
;
117 if (proc_desc
&& PROC_DESC_IS_DUMMY(proc_desc
))
118 return read_memory_integer(frame
->frame
- 4, 4);
120 /* If in the procedure prologue, RA_REGNUM might not have been saved yet.
121 * Assume non-leaf functions start with:
122 * addiu $sp,$sp,-frame_size
123 * sw $ra,ra_offset($sp)
124 * This if the pc is pointing at either of these instructions,
125 * then $ra hasn't been trashed.
126 * If the pc has advanced beyond these two instructions,
127 * then $ra has been saved.
128 * critical, and much more complex. Handling $ra is enough to get
129 * a stack trace, but some register values with be wrong.
131 if (frame
->proc_desc
&& frame
->pc
< PROC_LOW_ADDR(proc_desc
) + 8)
132 return read_register(pcreg
);
134 return read_next_frame_reg(frame
, pcreg
);
137 static struct mips_extra_func_info temp_proc_desc
;
138 static struct frame_saved_regs temp_saved_regs
;
140 CORE_ADDR
heuristic_proc_start(pc
)
144 CORE_ADDR start_pc
= pc
;
145 CORE_ADDR fence
= start_pc
- 10000;
146 if (fence
< VM_MIN_ADDRESS
) fence
= VM_MIN_ADDRESS
;
147 /* search back for previous return */
148 for (start_pc
-= 4; ; start_pc
-= 4)
149 if (start_pc
< fence
) return 0;
150 else if (ABOUT_TO_RETURN(start_pc
))
153 start_pc
+= 8; /* skip return, and its delay slot */
155 /* skip nops (usually 1) 0 - is this */
156 while (start_pc
< pc
&& read_memory_integer (start_pc
, 4) == 0)
162 mips_extra_func_info_t
163 heuristic_proc_desc(start_pc
, limit_pc
, next_frame
)
164 CORE_ADDR start_pc
, limit_pc
;
167 CORE_ADDR sp
= next_frame
? next_frame
->frame
: read_register (SP_REGNUM
);
170 int has_frame_reg
= 0;
171 int reg30
; /* Value of $r30. Used by gcc for frame-pointer */
172 unsigned long reg_mask
= 0;
174 if (start_pc
== 0) return NULL
;
175 bzero(&temp_proc_desc
, sizeof(temp_proc_desc
));
176 bzero(&temp_saved_regs
, sizeof(struct frame_saved_regs
));
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) {
184 status
= read_memory_nobpt (cur_pc
, &word
, 4);
185 if (status
) memory_error (status
, cur_pc
);
186 if ((word
& 0xFFFF0000) == 0x27bd0000) /* addiu $sp,$sp,-i */
187 frame_size
+= (-word
) & 0xFFFF;
188 else if ((word
& 0xFFFF0000) == 0x23bd0000) /* addu $sp,$sp,-i */
189 frame_size
+= (-word
) & 0xFFFF;
190 else if ((word
& 0xFFE00000) == 0xafa00000) { /* sw reg,offset($sp) */
191 int reg
= (word
& 0x001F0000) >> 16;
192 reg_mask
|= 1 << reg
;
193 temp_saved_regs
.regs
[reg
] = sp
+ (short)word
;
195 else if ((word
& 0xFFFF0000) == 0x27be0000) { /* addiu $30,$sp,size */
196 if ((unsigned short)word
!= frame_size
)
197 reg30
= sp
+ (unsigned short)word
;
198 else if (!has_frame_reg
) {
201 reg30
= read_next_frame_reg(next_frame
, 30);
202 alloca_adjust
= reg30
- (sp
+ (unsigned short)word
);
203 if (alloca_adjust
> 0) {
204 /* FP > SP + frame_size. This may be because
205 /* of an alloca or somethings similar.
206 * Fix sp to "pre-alloca" value, and try again.
213 else if ((word
& 0xFFE00000) == 0xafc00000) { /* sw reg,offset($30) */
214 int reg
= (word
& 0x001F0000) >> 16;
215 reg_mask
|= 1 << reg
;
216 temp_saved_regs
.regs
[reg
] = reg30
+ (short)word
;
220 PROC_FRAME_REG(&temp_proc_desc
) = 30;
221 PROC_FRAME_OFFSET(&temp_proc_desc
) = 0;
224 PROC_FRAME_REG(&temp_proc_desc
) = SP_REGNUM
;
225 PROC_FRAME_OFFSET(&temp_proc_desc
) = frame_size
;
227 PROC_REG_MASK(&temp_proc_desc
) = reg_mask
;
228 PROC_PC_REG(&temp_proc_desc
) = RA_REGNUM
;
229 return &temp_proc_desc
;
232 mips_extra_func_info_t
233 find_proc_desc(pc
, next_frame
)
237 mips_extra_func_info_t proc_desc
;
238 extern struct block
*block_for_pc();
239 struct block
*b
= block_for_pc(pc
);
242 b
? lookup_symbol(".gdbinfo.", b
, LABEL_NAMESPACE
, 0, NULL
) : NULL
;
245 /* IF this is the topmost frame AND
246 * (this proc does not have debugging information OR
247 * the PC is in the procedure prologue)
248 * THEN create a "hueristic" proc_desc (by analyzing
249 * the actual code) to replace the "official" proc_desc.
251 proc_desc
= (struct mips_extra_func_info
*)sym
->value
.value
;
252 if (next_frame
== NULL
) {
253 struct symtab_and_line val
;
254 struct symbol
*proc_symbol
=
255 PROC_DESC_IS_DUMMY(proc_desc
) ? 0 : PROC_SYMBOL(proc_desc
);
257 val
= find_pc_line (BLOCK_START
258 (SYMBOL_BLOCK_VALUE(proc_symbol
)),
260 val
.pc
= val
.end
? val
.end
: pc
;
262 if (!proc_symbol
|| pc
< val
.pc
) {
263 mips_extra_func_info_t found_heuristic
=
264 heuristic_proc_desc(PROC_LOW_ADDR(proc_desc
),
266 if (found_heuristic
) proc_desc
= found_heuristic
;
272 register struct linked_proc_info
*link
;
273 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
274 if (PROC_LOW_ADDR(&link
->info
) <= pc
275 && PROC_HIGH_ADDR(&link
->info
) > pc
)
278 heuristic_proc_desc(heuristic_proc_start(pc
), pc
, next_frame
);
283 mips_extra_func_info_t cached_proc_desc
;
285 FRAME_ADDR
mips_frame_chain(frame
)
288 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
289 mips_extra_func_info_t proc_desc
;
290 CORE_ADDR saved_pc
= FRAME_SAVED_PC(frame
);
291 if (startup_file_start
)
292 { /* has at least the __start symbol */
293 if (saved_pc
== 0 || !outside_startup_file (saved_pc
)) return 0;
296 { /* This hack depends on the internals of __start. */
297 /* We also assume the breakpoints are *not* inserted */
299 || read_memory_integer (saved_pc
+ 8, 4) & 0xFC00003F == 0xD)
300 return 0; /* break */
302 proc_desc
= find_proc_desc(saved_pc
, frame
);
303 if (!proc_desc
) return 0;
304 cached_proc_desc
= proc_desc
;
305 return read_next_frame_reg(frame
, PROC_FRAME_REG(proc_desc
))
306 + PROC_FRAME_OFFSET(proc_desc
);
310 init_extra_frame_info(fci
)
311 struct frame_info
*fci
;
313 extern struct obstack frame_cache_obstack
;
314 /* Use proc_desc calculated in frame_chain */
315 mips_extra_func_info_t proc_desc
= fci
->next
? cached_proc_desc
:
316 find_proc_desc(fci
->pc
, fci
->next
);
317 fci
->saved_regs
= (struct frame_saved_regs
*)
318 obstack_alloc (&frame_cache_obstack
, sizeof(struct frame_saved_regs
));
319 bzero(fci
->saved_regs
, sizeof(struct frame_saved_regs
));
321 proc_desc
== &temp_proc_desc
? (char*)NULL
: (char*)proc_desc
;
325 CORE_ADDR reg_position
;
327 /* r0 bit means kernel trap */
328 int kernel_trap
= PROC_REG_MASK(proc_desc
) & 1;
330 /* Fixup frame-pointer - only needed for top frame */
331 /* This may not be quite right, if procedure has a real frame register */
332 if (fci
->pc
== PROC_LOW_ADDR(proc_desc
))
333 fci
->frame
= read_register (SP_REGNUM
);
335 fci
->frame
= READ_FRAME_REG(fci
, PROC_FRAME_REG(proc_desc
))
336 + PROC_FRAME_OFFSET(proc_desc
);
338 if (proc_desc
== &temp_proc_desc
)
339 *fci
->saved_regs
= temp_saved_regs
;
342 /* find which general-purpose registers were saved */
343 reg_position
= fci
->frame
+ PROC_REG_OFFSET(proc_desc
);
344 mask
= kernel_trap
? 0xFFFFFFFF : PROC_REG_MASK(proc_desc
);
345 for (ireg
= 31; mask
; --ireg
, mask
<<= 1)
346 if (mask
& 0x80000000)
348 fci
->saved_regs
->regs
[ireg
] = reg_position
;
351 /* find which floating-point registers were saved */
352 reg_position
= fci
->frame
+ PROC_FREG_OFFSET(proc_desc
);
353 /* The freg_offset points to where the first *double* register is saved.
354 * So skip to the high-order word. */
356 mask
= kernel_trap
? 0xFFFFFFFF : PROC_FREG_MASK(proc_desc
);
357 for (ireg
= 31; mask
; --ireg
, mask
<<= 1)
358 if (mask
& 0x80000000)
360 fci
->saved_regs
->regs
[32+ireg
] = reg_position
;
365 /* hack: if argument regs are saved, guess these contain args */
366 if ((PROC_REG_MASK(proc_desc
) & 0xF0) == 0) fci
->num_args
= -1;
367 else if ((PROC_REG_MASK(proc_desc
) & 0x80) == 0) fci
->num_args
= 4;
368 else if ((PROC_REG_MASK(proc_desc
) & 0x40) == 0) fci
->num_args
= 3;
369 else if ((PROC_REG_MASK(proc_desc
) & 0x20) == 0) fci
->num_args
= 2;
370 else if ((PROC_REG_MASK(proc_desc
) & 0x10) == 0) fci
->num_args
= 1;
372 fci
->saved_regs
->regs
[PC_REGNUM
] = fci
->saved_regs
->regs
[RA_REGNUM
];
375 supply_register(FP_REGNUM
, &fci
->frame
);
379 CORE_ADDR
mips_push_arguments(nargs
, args
, sp
, struct_return
, struct_addr
)
384 CORE_ADDR struct_addr
;
388 int accumulate_size
= struct_return
? 4 : 0;
389 struct mips_arg
{ char *contents
; int len
; int offset
; };
390 struct mips_arg
*mips_args
=
391 (struct mips_arg
*)alloca(nargs
* sizeof(struct mips_arg
));
392 register struct mips_arg
*m_arg
;
393 for (i
= 0, m_arg
= mips_args
; i
< nargs
; i
++, m_arg
++) {
394 extern value
value_arg_coerce();
395 value arg
= value_arg_coerce (args
[i
]);
396 m_arg
->len
= TYPE_LENGTH (VALUE_TYPE (arg
));
397 /* This entire mips-specific routine is because doubles must be aligned
398 * on 8-byte boundaries. It still isn't quite right, because MIPS decided
399 * to align 'struct {int a, b}' on 4-byte boundaries (even though this
400 * breaks their varargs implementation...). A correct solution
401 * requires an simulation of gcc's 'alignof' (and use of 'alignof'
402 * in stdarg.h/varargs.h).
404 if (m_arg
->len
> 4) accumulate_size
= (accumulate_size
+ 7) & -8;
405 m_arg
->offset
= accumulate_size
;
406 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 3) & -4;
407 m_arg
->contents
= VALUE_CONTENTS(arg
);
409 accumulate_size
= (accumulate_size
+ 7) & (-8);
410 if (accumulate_size
< 16) accumulate_size
= 16;
411 sp
-= accumulate_size
;
412 for (i
= nargs
; m_arg
--, --i
>= 0; )
413 write_memory(sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
416 write_memory(sp
, &buf
, sizeof(CORE_ADDR
));
421 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
422 #define MASK(i,j) ((1 << (j)+1)-1 ^ (1 << (i))-1)
425 mips_push_dummy_frame()
428 struct linked_proc_info
*link
= (struct linked_proc_info
*)
429 xmalloc(sizeof(struct linked_proc_info
));
430 mips_extra_func_info_t proc_desc
= &link
->info
;
431 CORE_ADDR sp
= read_register (SP_REGNUM
);
432 CORE_ADDR save_address
;
433 REGISTER_TYPE buffer
;
434 link
->next
= linked_proc_desc_table
;
435 linked_proc_desc_table
= link
;
436 #define PUSH_FP_REGNUM 16 /* must be a register preserved across calls */
437 #define GEN_REG_SAVE_MASK MASK(1,16)|MASK(24,28)|(1<<31)
438 #define GEN_REG_SAVE_COUNT 22
439 #define FLOAT_REG_SAVE_MASK MASK(0,19)
440 #define FLOAT_REG_SAVE_COUNT 20
441 #define SPECIAL_REG_SAVE_COUNT 4
443 * The registers we must save are all those not preserved across
444 * procedure calls. Dest_Reg (see tm-mips.h) must also be saved.
445 * In addition, we must save the PC, and PUSH_FP_REGNUM.
446 * (Ideally, we should also save MDLO/-HI and FP Control/Status reg.)
448 * Dummy frame layout:
451 * Saved MMHI, MMLO, FPC_CSR
456 * Saved D18 (i.e. F19, F18)
458 * Saved D0 (i.e. F1, F0)
459 * CALL_DUMMY (subroutine stub; see m-mips.h)
460 * Parameter build area (not yet implemented)
463 PROC_REG_MASK(proc_desc
) = GEN_REG_SAVE_MASK
;
464 PROC_FREG_MASK(proc_desc
) = FLOAT_REG_SAVE_MASK
;
465 PROC_REG_OFFSET(proc_desc
) = /* offset of (Saved R31) from FP */
466 -sizeof(long) - 4 * SPECIAL_REG_SAVE_COUNT
;
467 PROC_FREG_OFFSET(proc_desc
) = /* offset of (Saved D18) from FP */
468 -sizeof(double) - 4 * (SPECIAL_REG_SAVE_COUNT
+ GEN_REG_SAVE_COUNT
);
469 /* save general registers */
470 save_address
= sp
+ PROC_REG_OFFSET(proc_desc
);
471 for (ireg
= 32; --ireg
>= 0; )
472 if (PROC_REG_MASK(proc_desc
) & (1 << ireg
))
474 buffer
= read_register (ireg
);
475 write_memory (save_address
, &buffer
, sizeof(REGISTER_TYPE
));
478 /* save floating-points registers */
479 save_address
= sp
+ PROC_FREG_OFFSET(proc_desc
);
480 for (ireg
= 32; --ireg
>= 0; )
481 if (PROC_FREG_MASK(proc_desc
) & (1 << ireg
))
483 buffer
= read_register (ireg
);
484 write_memory (save_address
, &buffer
, 4);
487 write_register (PUSH_FP_REGNUM
, sp
);
488 PROC_FRAME_REG(proc_desc
) = PUSH_FP_REGNUM
;
489 PROC_FRAME_OFFSET(proc_desc
) = 0;
490 buffer
= read_register (PC_REGNUM
);
491 write_memory (sp
- 4, &buffer
, sizeof(REGISTER_TYPE
));
492 buffer
= read_register (HI_REGNUM
);
493 write_memory (sp
- 8, &buffer
, sizeof(REGISTER_TYPE
));
494 buffer
= read_register (LO_REGNUM
);
495 write_memory (sp
- 12, &buffer
, sizeof(REGISTER_TYPE
));
496 buffer
= read_register (FCRCS_REGNUM
);
497 write_memory (sp
- 16, &buffer
, sizeof(REGISTER_TYPE
));
498 sp
-= 4 * (GEN_REG_SAVE_COUNT
+FLOAT_REG_SAVE_COUNT
+SPECIAL_REG_SAVE_COUNT
);
499 write_register (SP_REGNUM
, sp
);
500 PROC_LOW_ADDR(proc_desc
) = sp
- CALL_DUMMY_SIZE
+ CALL_DUMMY_START_OFFSET
;
501 PROC_HIGH_ADDR(proc_desc
) = sp
;
502 SET_PROC_DESC_IS_DUMMY(proc_desc
);
503 PROC_PC_REG(proc_desc
) = RA_REGNUM
;
508 { register int regnum
;
509 FRAME frame
= get_current_frame ();
510 CORE_ADDR new_sp
= frame
->frame
;
511 mips_extra_func_info_t proc_desc
= (mips_extra_func_info_t
)frame
->proc_desc
;
512 if (PROC_DESC_IS_DUMMY(proc_desc
))
514 struct linked_proc_info
**ptr
= &linked_proc_desc_table
;;
515 for (; &ptr
[0]->info
!= proc_desc
; ptr
= &ptr
[0]->next
)
516 if (ptr
[0] == NULL
) abort();
519 write_register (HI_REGNUM
, read_memory_integer(new_sp
- 8, 4));
520 write_register (LO_REGNUM
, read_memory_integer(new_sp
- 12, 4));
521 write_register (FCRCS_REGNUM
, read_memory_integer(new_sp
- 16, 4));
523 write_register (PC_REGNUM
, FRAME_SAVED_PC(frame
));
524 if (frame
->proc_desc
) {
525 for (regnum
= 32; --regnum
>= 0; )
526 if (PROC_REG_MASK(proc_desc
) & (1 << regnum
))
527 write_register (regnum
,
528 read_memory_integer (frame
->saved_regs
->regs
[regnum
], 4));
529 for (regnum
= 64; --regnum
>= 32; )
530 if (PROC_FREG_MASK(proc_desc
) & (1 << regnum
))
531 write_register (regnum
,
532 read_memory_integer (frame
->saved_regs
->regs
[regnum
], 4));
534 write_register (SP_REGNUM
, new_sp
);
535 flush_cached_frames ();
536 set_current_frame (create_new_frame (new_sp
, read_pc ()));
539 static mips_print_register(regnum
, all
)
542 unsigned char raw_buffer
[8];
545 read_relative_register_raw_bytes (regnum
, raw_buffer
);
547 if (!(regnum
& 1) && regnum
>= FP0_REGNUM
&& regnum
< FP0_REGNUM
+32) {
548 read_relative_register_raw_bytes (regnum
+1, raw_buffer
+4);
549 printf_filtered ("(d%d: ", regnum
&31);
550 val_print (builtin_type_double
, raw_buffer
, 0,
551 stdout
, 0, 1, 0, Val_pretty_default
);
552 printf_filtered ("); ", regnum
&31);
554 fputs_filtered (reg_names
[regnum
], stdout
);
555 #ifndef NUMERIC_REG_NAMES
557 printf_filtered ("(r%d): ", regnum
);
560 printf_filtered (": ");
562 /* If virtual format is floating, print it that way. */
563 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum
)) == TYPE_CODE_FLT
564 && ! INVALID_FLOAT (raw_buffer
, REGISTER_VIRTUAL_SIZE(regnum
))) {
565 val_print (REGISTER_VIRTUAL_TYPE (regnum
), raw_buffer
, 0,
566 stdout
, 0, 1, 0, Val_pretty_default
);
568 /* Else print as integer in hex. */
573 bcopy (raw_buffer
, &val
, sizeof (long));
575 printf_filtered ("0");
577 printf_filtered ("0x%x", val
);
579 printf_filtered ("0x%x=%d", val
, val
);
583 /* Replacement for generic do_registers_info. fpregs is currently ignored. */
584 mips_do_registers_info (regnum
, fpregs
)
589 mips_print_register (regnum
, 0);
590 printf_filtered ("\n");
593 for (regnum
= 0; regnum
< NUM_REGS
; ) {
594 mips_print_register (regnum
, 1);
596 if ((regnum
& 3) == 0 || regnum
== NUM_REGS
)
597 printf_filtered (";\n");
599 printf_filtered ("; ");
603 /* Return number of args passed to a frame. described by FIP.
604 Can return -1, meaning no way to tell. */
606 mips_frame_num_args(fip
)
610 struct chain_info_t
*p
;
612 p
= mips_find_cached_frame(FRAME_FP(fip
));
614 return p
->the_info
.numargs
;
620 /* Bad floats: Returns 0 if P points to a valid IEEE floating point number,
621 1 if P points to a denormalized number or a NaN. LEN says whether this is
622 a single-precision or double-precision float */
623 #define SINGLE_EXP_BITS 8
624 #define DOUBLE_EXP_BITS 11
633 exponent
= exponent
<< 1 >> (32 - SINGLE_EXP_BITS
- 1);
634 return ((exponent
== -1) || (! exponent
&& *p
));
639 exponent
= exponent
<< 1 >> (32 - DOUBLE_EXP_BITS
- 1);
640 return ((exponent
== -1) || (! exponent
&& *p
* *(p
+1)));
645 /* To skip prologues, I use this predicate. Returns either PC
646 itself if the code at PC does not look like a function prologue,
647 PC+4 if it does (our caller does not need anything more fancy). */
649 CORE_ADDR
mips_skip_prologue(pc
)
656 /* For -g modules and most functions anyways the
657 first instruction adjusts the stack. */
658 inst
= read_memory_integer(pc
, 4);
659 if ((inst
& 0xffff0000) == 0x27bd0000)
662 /* Well, it looks like a frameless. Let's make sure.
663 Note that we are not called on the current PC,
664 but on the function`s start PC, and I have definitely
665 seen optimized code that adjusts the SP quite later */
666 b
= block_for_pc(pc
);
669 f
= lookup_symbol(".gdbinfo.", b
, LABEL_NAMESPACE
, 0, NULL
);
671 /* Ideally, I would like to use the adjusted info
672 from mips_frame_info(), but for all practical
673 purposes it will not matter (and it would require
674 a different definition of SKIP_PROLOGUE())
676 Actually, it would not hurt to skip the storing
677 of arguments on the stack as well. */
678 if (((struct mips_extra_func_info
*)f
->value
.value
)->framesize
)