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 */
31 #include <mips/inst.h>
43 #include <sys/types.h>
46 #include <sys/param.h>
49 #include <sys/ioctl.h>
55 #define MIPSMAGIC MIPSELMAGIC
57 #define MIPSMAGIC MIPSEBMAGIC
61 #define VM_MIN_ADDRESS (unsigned)0x400000
63 #include <sys/user.h> /* After a.out.h */
68 #define PROC_LOW_ADDR(proc) ((proc)->adr) /* least address */
69 #define PROC_HIGH_ADDR(proc) ((proc)->pad2) /* upper address bound */
70 #define PROC_FRAME_OFFSET(proc) ((proc)->framesize)
71 #define PROC_FRAME_REG(proc) ((proc)->framereg)
72 #define PROC_REG_MASK(proc) ((proc)->regmask)
73 #define PROC_FREG_MASK(proc) ((proc)->fregmask)
74 #define PROC_REG_OFFSET(proc) ((proc)->regoffset)
75 #define PROC_FREG_OFFSET(proc) ((proc)->fregoffset)
76 #define PROC_PC_REG(proc) ((proc)->pcreg)
77 #define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->isym)
78 #define _PROC_MAGIC_ 0x0F0F0F0F
79 #define PROC_DESC_IS_DUMMY(proc) ((proc)->isym == _PROC_MAGIC_)
80 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->isym = _PROC_MAGIC_)
82 struct linked_proc_info
84 struct mips_extra_func_info info
;
85 struct linked_proc_info
*next
;
86 } * linked_proc_desc_table
= NULL
;
89 #define READ_FRAME_REG(fi, regno) read_next_frame_reg((fi)->next, regno)
92 read_next_frame_reg(fi
, regno
)
96 #define SIGFRAME_BASE sizeof(struct sigcontext)
97 #define SIGFRAME_PC_OFF (-SIGFRAME_BASE+ 2*sizeof(int))
98 #define SIGFRAME_SP_OFF (-SIGFRAME_BASE+32*sizeof(int))
99 #define SIGFRAME_RA_OFF (-SIGFRAME_BASE+34*sizeof(int))
100 for (; fi
; fi
= fi
->next
)
101 if (in_sigtramp(fi
->pc
, 0)) {
102 /* No idea if this code works. --PB. */
104 if (regno
== PC_REGNUM
) offset
= SIGFRAME_PC_OFF
;
105 else if (regno
== RA_REGNUM
) offset
= SIGFRAME_RA_OFF
;
106 else if (regno
== SP_REGNUM
) offset
= SIGFRAME_SP_OFF
;
108 return read_memory_integer(fi
->frame
+ offset
, 4);
110 else if (regno
== SP_REGNUM
) return fi
->frame
;
111 else if (fi
->saved_regs
->regs
[regno
])
112 return read_memory_integer(fi
->saved_regs
->regs
[regno
], 4);
113 return read_register(regno
);
117 mips_frame_saved_pc(frame
)
120 mips_extra_func_info_t proc_desc
= (mips_extra_func_info_t
)frame
->proc_desc
;
121 int pcreg
= proc_desc
? PROC_PC_REG(proc_desc
) : RA_REGNUM
;
122 if (proc_desc
&& PROC_DESC_IS_DUMMY(proc_desc
))
123 return read_memory_integer(frame
->frame
- 4, 4);
125 /* If in the procedure prologue, RA_REGNUM might not have been saved yet.
126 * Assume non-leaf functions start with:
127 * addiu $sp,$sp,-frame_size
128 * sw $ra,ra_offset($sp)
129 * This if the pc is pointing at either of these instructions,
130 * then $ra hasn't been trashed.
131 * If the pc has advanced beyond these two instructions,
132 * then $ra has been saved.
133 * critical, and much more complex. Handling $ra is enough to get
134 * a stack trace, but some register values with be wrong.
136 if (frame
->proc_desc
&& frame
->pc
< PROC_LOW_ADDR(proc_desc
) + 8)
137 return read_register(pcreg
);
139 return read_next_frame_reg(frame
, pcreg
);
142 static struct mips_extra_func_info temp_proc_desc
;
143 static struct frame_saved_regs temp_saved_regs
;
145 CORE_ADDR
heuristic_proc_start(pc
)
149 CORE_ADDR start_pc
= pc
;
150 CORE_ADDR fence
= start_pc
- 10000;
151 if (fence
< VM_MIN_ADDRESS
) fence
= VM_MIN_ADDRESS
;
152 /* search back for previous return */
153 for (start_pc
-= 4; ; start_pc
-= 4)
154 if (start_pc
< fence
) return 0;
155 else if (ABOUT_TO_RETURN(start_pc
))
158 start_pc
+= 8; /* skip return, and its delay slot */
160 /* skip nops (usually 1) 0 - is this */
161 while (start_pc
< pc
&& read_memory_integer (start_pc
, 4) == 0)
167 mips_extra_func_info_t
168 heuristic_proc_desc(start_pc
, limit_pc
, next_frame
)
169 CORE_ADDR start_pc
, limit_pc
;
172 CORE_ADDR sp
= next_frame
? next_frame
->frame
: read_register (SP_REGNUM
);
175 int has_frame_reg
= 0;
176 int reg30
; /* Value of $r30. Used by gcc for frame-pointer */
177 unsigned long reg_mask
= 0;
179 if (start_pc
== 0) return NULL
;
180 bzero(&temp_proc_desc
, sizeof(temp_proc_desc
));
181 bzero(&temp_saved_regs
, sizeof(struct frame_saved_regs
));
182 if (start_pc
+ 200 < limit_pc
) limit_pc
= start_pc
+ 200;
185 for (cur_pc
= start_pc
; cur_pc
< limit_pc
; cur_pc
+= 4) {
189 status
= read_memory_nobpt (cur_pc
, &word
, 4);
190 if (status
) memory_error (status
, cur_pc
);
191 if ((word
& 0xFFFF0000) == 0x27bd0000) /* addiu $sp,$sp,-i */
192 frame_size
+= (-word
) & 0xFFFF;
193 else if ((word
& 0xFFFF0000) == 0x23bd0000) /* addu $sp,$sp,-i */
194 frame_size
+= (-word
) & 0xFFFF;
195 else if ((word
& 0xFFE00000) == 0xafa00000) { /* sw reg,offset($sp) */
196 int reg
= (word
& 0x001F0000) >> 16;
197 reg_mask
|= 1 << reg
;
198 temp_saved_regs
.regs
[reg
] = sp
+ (short)word
;
200 else if ((word
& 0xFFFF0000) == 0x27be0000) { /* addiu $30,$sp,size */
201 if ((unsigned short)word
!= frame_size
)
202 reg30
= sp
+ (unsigned short)word
;
203 else if (!has_frame_reg
) {
206 reg30
= read_next_frame_reg(next_frame
, 30);
207 alloca_adjust
= reg30
- (sp
+ (unsigned short)word
);
208 if (alloca_adjust
> 0) {
209 /* FP > SP + frame_size. This may be because
210 /* of an alloca or somethings similar.
211 * Fix sp to "pre-alloca" value, and try again.
218 else if ((word
& 0xFFE00000) == 0xafc00000) { /* sw reg,offset($30) */
219 int reg
= (word
& 0x001F0000) >> 16;
220 reg_mask
|= 1 << reg
;
221 temp_saved_regs
.regs
[reg
] = reg30
+ (short)word
;
225 PROC_FRAME_REG(&temp_proc_desc
) = 30;
226 PROC_FRAME_OFFSET(&temp_proc_desc
) = 0;
229 PROC_FRAME_REG(&temp_proc_desc
) = SP_REGNUM
;
230 PROC_FRAME_OFFSET(&temp_proc_desc
) = frame_size
;
232 PROC_REG_MASK(&temp_proc_desc
) = reg_mask
;
233 PROC_PC_REG(&temp_proc_desc
) = RA_REGNUM
;
234 return &temp_proc_desc
;
237 mips_extra_func_info_t
238 find_proc_desc(pc
, next_frame
)
242 mips_extra_func_info_t proc_desc
;
243 extern struct block
*block_for_pc();
244 struct block
*b
= block_for_pc(pc
);
247 b
? lookup_symbol(".gdbinfo.", b
, LABEL_NAMESPACE
, 0, NULL
) : NULL
;
250 /* IF this is the topmost frame AND
251 * (this proc does not have debugging information OR
252 * the PC is in the procedure prologue)
253 * THEN create a "hueristic" proc_desc (by analyzing
254 * the actual code) to replace the "official" proc_desc.
256 proc_desc
= (struct mips_extra_func_info
*)sym
->value
.value
;
257 if (next_frame
== NULL
) {
258 struct symtab_and_line val
;
259 struct symbol
*proc_symbol
=
260 PROC_DESC_IS_DUMMY(proc_desc
) ? 0 : PROC_SYMBOL(proc_desc
);
262 val
= find_pc_line (BLOCK_START
263 (SYMBOL_BLOCK_VALUE(proc_symbol
)),
265 val
.pc
= val
.end
? val
.end
: pc
;
267 if (!proc_symbol
|| pc
< val
.pc
) {
268 mips_extra_func_info_t found_heuristic
=
269 heuristic_proc_desc(PROC_LOW_ADDR(proc_desc
),
271 if (found_heuristic
) proc_desc
= found_heuristic
;
277 register struct linked_proc_info
*link
;
278 for (link
= linked_proc_desc_table
; link
; link
= link
->next
)
279 if (PROC_LOW_ADDR(&link
->info
) <= pc
280 && PROC_HIGH_ADDR(&link
->info
) > pc
)
283 heuristic_proc_desc(heuristic_proc_start(pc
), pc
, next_frame
);
288 mips_extra_func_info_t cached_proc_desc
;
290 FRAME_ADDR
mips_frame_chain(frame
)
293 extern CORE_ADDR startup_file_start
; /* From blockframe.c */
294 mips_extra_func_info_t proc_desc
;
295 CORE_ADDR saved_pc
= FRAME_SAVED_PC(frame
);
296 if (startup_file_start
)
297 { /* has at least the __start symbol */
298 if (saved_pc
== 0 || !outside_startup_file (saved_pc
)) return 0;
301 { /* This hack depends on the internals of __start. */
302 /* We also assume the breakpoints are *not* inserted */
304 || read_memory_integer (saved_pc
+ 8, 4) & 0xFC00003F == 0xD)
305 return 0; /* break */
307 proc_desc
= find_proc_desc(saved_pc
, frame
);
308 if (!proc_desc
) return 0;
309 cached_proc_desc
= proc_desc
;
310 return read_next_frame_reg(frame
, PROC_FRAME_REG(proc_desc
))
311 + PROC_FRAME_OFFSET(proc_desc
);
315 init_extra_frame_info(fci
)
316 struct frame_info
*fci
;
318 extern struct obstack frame_cache_obstack
;
319 /* Use proc_desc calculated in frame_chain */
320 mips_extra_func_info_t proc_desc
= fci
->next
? cached_proc_desc
:
321 find_proc_desc(fci
->pc
, fci
->next
);
322 fci
->saved_regs
= (struct frame_saved_regs
*)
323 obstack_alloc (&frame_cache_obstack
, sizeof(struct frame_saved_regs
));
324 bzero(fci
->saved_regs
, sizeof(struct frame_saved_regs
));
326 proc_desc
== &temp_proc_desc
? (char*)NULL
: (char*)proc_desc
;
330 CORE_ADDR reg_position
;
332 /* r0 bit means kernel trap */
333 int kernel_trap
= PROC_REG_MASK(proc_desc
) & 1;
335 /* Fixup frame-pointer - only needed for top frame */
336 /* This may not be quite right, if procedure has a real frame register */
337 if (fci
->pc
== PROC_LOW_ADDR(proc_desc
))
338 fci
->frame
= read_register (SP_REGNUM
);
340 fci
->frame
= READ_FRAME_REG(fci
, PROC_FRAME_REG(proc_desc
))
341 + PROC_FRAME_OFFSET(proc_desc
);
343 if (proc_desc
== &temp_proc_desc
)
344 *fci
->saved_regs
= temp_saved_regs
;
347 /* find which general-purpose registers were saved */
348 reg_position
= fci
->frame
+ PROC_REG_OFFSET(proc_desc
);
349 mask
= kernel_trap
? 0xFFFFFFFF : PROC_REG_MASK(proc_desc
);
350 for (ireg
= 31; mask
; --ireg
, mask
<<= 1)
351 if (mask
& 0x80000000)
353 fci
->saved_regs
->regs
[ireg
] = reg_position
;
356 /* find which floating-point registers were saved */
357 reg_position
= fci
->frame
+ PROC_FREG_OFFSET(proc_desc
);
358 /* The freg_offset points to where the first *double* register is saved.
359 * So skip to the high-order word. */
361 mask
= kernel_trap
? 0xFFFFFFFF : PROC_FREG_MASK(proc_desc
);
362 for (ireg
= 31; mask
; --ireg
, mask
<<= 1)
363 if (mask
& 0x80000000)
365 fci
->saved_regs
->regs
[32+ireg
] = reg_position
;
370 /* hack: if argument regs are saved, guess these contain args */
371 if ((PROC_REG_MASK(proc_desc
) & 0xF0) == 0) fci
->num_args
= -1;
372 else if ((PROC_REG_MASK(proc_desc
) & 0x80) == 0) fci
->num_args
= 4;
373 else if ((PROC_REG_MASK(proc_desc
) & 0x40) == 0) fci
->num_args
= 3;
374 else if ((PROC_REG_MASK(proc_desc
) & 0x20) == 0) fci
->num_args
= 2;
375 else if ((PROC_REG_MASK(proc_desc
) & 0x10) == 0) fci
->num_args
= 1;
377 fci
->saved_regs
->regs
[PC_REGNUM
] = fci
->saved_regs
->regs
[RA_REGNUM
];
380 supply_register(FP_REGNUM
, &fci
->frame
);
384 CORE_ADDR
mips_push_arguments(nargs
, args
, sp
, struct_return
, struct_addr
)
389 CORE_ADDR struct_addr
;
393 int accumulate_size
= struct_return
? 4 : 0;
394 struct mips_arg
{ char *contents
; int len
; int offset
; };
395 struct mips_arg
*mips_args
=
396 (struct mips_arg
*)alloca(nargs
* sizeof(struct mips_arg
));
397 register struct mips_arg
*m_arg
;
398 for (i
= 0, m_arg
= mips_args
; i
< nargs
; i
++, m_arg
++) {
399 extern value
value_arg_coerce();
400 value arg
= value_arg_coerce (args
[i
]);
401 m_arg
->len
= TYPE_LENGTH (VALUE_TYPE (arg
));
402 /* This entire mips-specific routine is because doubles must be aligned
403 * on 8-byte boundaries. It still isn't quite right, because MIPS decided
404 * to align 'struct {int a, b}' on 4-byte boundaries (even though this
405 * breaks their varargs implementation...). A correct solution
406 * requires an simulation of gcc's 'alignof' (and use of 'alignof'
407 * in stdarg.h/varargs.h).
409 if (m_arg
->len
> 4) accumulate_size
= (accumulate_size
+ 7) & -8;
410 m_arg
->offset
= accumulate_size
;
411 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 3) & -4;
412 m_arg
->contents
= VALUE_CONTENTS(arg
);
414 accumulate_size
= (accumulate_size
+ 7) & (-8);
415 if (accumulate_size
< 16) accumulate_size
= 16;
416 sp
-= accumulate_size
;
417 for (i
= nargs
; m_arg
--, --i
>= 0; )
418 write_memory(sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
421 write_memory(sp
, &buf
, sizeof(CORE_ADDR
));
426 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<31. */
427 #define MASK(i,j) ((1 << (j)+1)-1 ^ (1 << (i))-1)
430 mips_push_dummy_frame()
433 struct linked_proc_info
*link
= (struct linked_proc_info
*)
434 xmalloc(sizeof(struct linked_proc_info
));
435 mips_extra_func_info_t proc_desc
= &link
->info
;
436 CORE_ADDR sp
= read_register (SP_REGNUM
);
437 CORE_ADDR save_address
;
438 REGISTER_TYPE buffer
;
439 link
->next
= linked_proc_desc_table
;
440 linked_proc_desc_table
= link
;
441 #define PUSH_FP_REGNUM 16 /* must be a register preserved across calls */
442 #define GEN_REG_SAVE_MASK MASK(1,16)|MASK(24,28)|(1<<31)
443 #define GEN_REG_SAVE_COUNT 22
444 #define FLOAT_REG_SAVE_MASK MASK(0,19)
445 #define FLOAT_REG_SAVE_COUNT 20
446 #define SPECIAL_REG_SAVE_COUNT 4
448 * The registers we must save are all those not preserved across
449 * procedure calls. Dest_Reg (see tm-mips.h) must also be saved.
450 * In addition, we must save the PC, and PUSH_FP_REGNUM.
451 * (Ideally, we should also save MDLO/-HI and FP Control/Status reg.)
453 * Dummy frame layout:
456 * Saved MMHI, MMLO, FPC_CSR
461 * Saved D18 (i.e. F19, F18)
463 * Saved D0 (i.e. F1, F0)
464 * CALL_DUMMY (subroutine stub; see m-mips.h)
465 * Parameter build area (not yet implemented)
468 PROC_REG_MASK(proc_desc
) = GEN_REG_SAVE_MASK
;
469 PROC_FREG_MASK(proc_desc
) = FLOAT_REG_SAVE_MASK
;
470 PROC_REG_OFFSET(proc_desc
) = /* offset of (Saved R31) from FP */
471 -sizeof(long) - 4 * SPECIAL_REG_SAVE_COUNT
;
472 PROC_FREG_OFFSET(proc_desc
) = /* offset of (Saved D18) from FP */
473 -sizeof(double) - 4 * (SPECIAL_REG_SAVE_COUNT
+ GEN_REG_SAVE_COUNT
);
474 /* save general registers */
475 save_address
= sp
+ PROC_REG_OFFSET(proc_desc
);
476 for (ireg
= 32; --ireg
>= 0; )
477 if (PROC_REG_MASK(proc_desc
) & (1 << ireg
))
479 buffer
= read_register (ireg
);
480 write_memory (save_address
, &buffer
, sizeof(REGISTER_TYPE
));
483 /* save floating-points registers */
484 save_address
= sp
+ PROC_FREG_OFFSET(proc_desc
);
485 for (ireg
= 32; --ireg
>= 0; )
486 if (PROC_FREG_MASK(proc_desc
) & (1 << ireg
))
488 buffer
= read_register (ireg
);
489 write_memory (save_address
, &buffer
, 4);
492 write_register (PUSH_FP_REGNUM
, sp
);
493 PROC_FRAME_REG(proc_desc
) = PUSH_FP_REGNUM
;
494 PROC_FRAME_OFFSET(proc_desc
) = 0;
495 buffer
= read_register (PC_REGNUM
);
496 write_memory (sp
- 4, &buffer
, sizeof(REGISTER_TYPE
));
497 buffer
= read_register (HI_REGNUM
);
498 write_memory (sp
- 8, &buffer
, sizeof(REGISTER_TYPE
));
499 buffer
= read_register (LO_REGNUM
);
500 write_memory (sp
- 12, &buffer
, sizeof(REGISTER_TYPE
));
501 buffer
= read_register (FCRCS_REGNUM
);
502 write_memory (sp
- 16, &buffer
, sizeof(REGISTER_TYPE
));
503 sp
-= 4 * (GEN_REG_SAVE_COUNT
+FLOAT_REG_SAVE_COUNT
+SPECIAL_REG_SAVE_COUNT
);
504 write_register (SP_REGNUM
, sp
);
505 PROC_LOW_ADDR(proc_desc
) = sp
- CALL_DUMMY_SIZE
+ CALL_DUMMY_START_OFFSET
;
506 PROC_HIGH_ADDR(proc_desc
) = sp
;
507 SET_PROC_DESC_IS_DUMMY(proc_desc
);
508 PROC_PC_REG(proc_desc
) = RA_REGNUM
;
513 { register int regnum
;
514 FRAME frame
= get_current_frame ();
515 CORE_ADDR new_sp
= frame
->frame
;
516 mips_extra_func_info_t proc_desc
= (mips_extra_func_info_t
)frame
->proc_desc
;
517 if (PROC_DESC_IS_DUMMY(proc_desc
))
519 struct linked_proc_info
**ptr
= &linked_proc_desc_table
;;
520 for (; &ptr
[0]->info
!= proc_desc
; ptr
= &ptr
[0]->next
)
521 if (ptr
[0] == NULL
) abort();
524 write_register (HI_REGNUM
, read_memory_integer(new_sp
- 8, 4));
525 write_register (LO_REGNUM
, read_memory_integer(new_sp
- 12, 4));
526 write_register (FCRCS_REGNUM
, read_memory_integer(new_sp
- 16, 4));
528 write_register (PC_REGNUM
, FRAME_SAVED_PC(frame
));
529 if (frame
->proc_desc
) {
530 for (regnum
= 32; --regnum
>= 0; )
531 if (PROC_REG_MASK(proc_desc
) & (1 << regnum
))
532 write_register (regnum
,
533 read_memory_integer (frame
->saved_regs
->regs
[regnum
], 4));
534 for (regnum
= 64; --regnum
>= 32; )
535 if (PROC_FREG_MASK(proc_desc
) & (1 << regnum
))
536 write_register (regnum
,
537 read_memory_integer (frame
->saved_regs
->regs
[regnum
], 4));
539 write_register (SP_REGNUM
, new_sp
);
540 flush_cached_frames ();
541 set_current_frame (create_new_frame (new_sp
, read_pc ()));
545 mips_print_register(regnum
, all
)
548 unsigned char raw_buffer
[8];
551 read_relative_register_raw_bytes (regnum
, raw_buffer
);
553 if (!(regnum
& 1) && regnum
>= FP0_REGNUM
&& regnum
< FP0_REGNUM
+32) {
554 read_relative_register_raw_bytes (regnum
+1, raw_buffer
+4);
555 printf_filtered ("(d%d: ", regnum
&31);
556 val_print (builtin_type_double
, raw_buffer
, 0,
557 stdout
, 0, 1, 0, Val_pretty_default
);
558 printf_filtered ("); ", regnum
&31);
560 fputs_filtered (reg_names
[regnum
], stdout
);
561 #ifndef NUMERIC_REG_NAMES
563 printf_filtered ("(r%d): ", regnum
);
566 printf_filtered (": ");
568 /* If virtual format is floating, print it that way. */
569 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum
)) == TYPE_CODE_FLT
570 && ! INVALID_FLOAT (raw_buffer
, REGISTER_VIRTUAL_SIZE(regnum
))) {
571 val_print (REGISTER_VIRTUAL_TYPE (regnum
), raw_buffer
, 0,
572 stdout
, 0, 1, 0, Val_pretty_default
);
574 /* Else print as integer in hex. */
579 bcopy (raw_buffer
, &val
, sizeof (long));
581 printf_filtered ("0");
583 printf_filtered (local_hex_format(), val
);
585 printf_filtered ("%s=%d", local_hex_string(val
), val
);
589 /* Replacement for generic do_registers_info. */
590 mips_do_registers_info (regnum
, fpregs
)
595 mips_print_register (regnum
, 0);
596 printf_filtered ("\n");
599 for (regnum
= 0; regnum
< NUM_REGS
; ) {
600 if ((!fpregs
) && regnum
>= FP0_REGNUM
&& regnum
<= FCRIR_REGNUM
) {
604 mips_print_register (regnum
, 1);
606 if ((regnum
& 3) == 0 || regnum
== NUM_REGS
)
607 printf_filtered (";\n");
609 printf_filtered ("; ");
613 /* Return number of args passed to a frame. described by FIP.
614 Can return -1, meaning no way to tell. */
616 mips_frame_num_args(fip
)
620 struct chain_info_t
*p
;
622 p
= mips_find_cached_frame(FRAME_FP(fip
));
624 return p
->the_info
.numargs
;
630 /* Bad floats: Returns 0 if P points to a valid IEEE floating point number,
631 1 if P points to a denormalized number or a NaN. LEN says whether this is
632 a single-precision or double-precision float */
633 #define SINGLE_EXP_BITS 8
634 #define DOUBLE_EXP_BITS 11
643 exponent
= exponent
<< 1 >> (32 - SINGLE_EXP_BITS
- 1);
644 return ((exponent
== -1) || (! exponent
&& *p
));
649 exponent
= exponent
<< 1 >> (32 - DOUBLE_EXP_BITS
- 1);
650 return ((exponent
== -1) || (! exponent
&& *p
* *(p
+1)));
655 /* To skip prologues, I use this predicate. Returns either PC
656 itself if the code at PC does not look like a function prologue,
657 PC+4 if it does (our caller does not need anything more fancy). */
659 CORE_ADDR
mips_skip_prologue(pc
)
666 /* For -g modules and most functions anyways the
667 first instruction adjusts the stack. */
668 inst
= read_memory_integer(pc
, 4);
669 if ((inst
& 0xffff0000) == 0x27bd0000)
672 /* Well, it looks like a frameless. Let's make sure.
673 Note that we are not called on the current PC,
674 but on the function`s start PC, and I have definitely
675 seen optimized code that adjusts the SP quite later */
676 b
= block_for_pc(pc
);
679 f
= lookup_symbol(".gdbinfo.", b
, LABEL_NAMESPACE
, 0, NULL
);
681 /* Ideally, I would like to use the adjusted info
682 from mips_frame_info(), but for all practical
683 purposes it will not matter (and it would require
684 a different definition of SKIP_PROLOGUE())
686 Actually, it would not hurt to skip the storing
687 of arguments on the stack as well. */
688 if (((struct mips_extra_func_info
*)f
->value
.value
)->framesize
)