#include "value.h"
#include "gdbcmd.h"
#include "language.h"
-
-#ifdef USG
-#include <sys/types.h>
-#endif
-
-#include <sys/param.h>
-#include <sys/dir.h>
-#include <signal.h>
-#include <sys/ioctl.h>
-
#include "gdbcore.h"
#include "symfile.h"
#include "objfiles.h"
-#ifndef MIPSMAGIC
-#ifdef MIPSEL
-#define MIPSMAGIC MIPSELMAGIC
-#else
-#define MIPSMAGIC MIPSEBMAGIC
-#endif
-#endif
-
#define VM_MIN_ADDRESS (unsigned)0x400000
-
-#include <sys/user.h> /* After a.out.h */
-#include <sys/file.h>
-#include <sys/stat.h>
-
\f
/* Some MIPS boards don't support floating point, so we permit the
user to turn it off. */
int mips_fpu = 1;
+/* Heuristic_proc_start may hunt through the text section for a long
+ time across a 2400 baud serial line. Allows the user to limit this
+ search. */
+static unsigned int heuristic_fence_post = 0;
+
#define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
#define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
#define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
FRAME fi;
int regno;
{
-#define SIGFRAME_BASE sizeof(struct sigcontext)
-#define SIGFRAME_PC_OFF (-SIGFRAME_BASE+ 2*sizeof(int))
-#define SIGFRAME_SP_OFF (-SIGFRAME_BASE+32*sizeof(int))
-#define SIGFRAME_RA_OFF (-SIGFRAME_BASE+34*sizeof(int))
+ /* If it is the frame for sigtramp we have a complete sigcontext
+ immediately below the frame and we get the saved registers from there.
+ If the stack layout for sigtramp changes we might have to change these
+ constants and the companion fixup_sigtramp in mipsread.c */
+#ifndef SIGFRAME_BASE
+#define SIGFRAME_BASE 0x12c /* sizeof(sigcontext) */
+#define SIGFRAME_PC_OFF (-SIGFRAME_BASE + 2 * 4)
+#define SIGFRAME_REGSAVE_OFF (-SIGFRAME_BASE + 3 * 4)
+#endif
for (; fi; fi = fi->next)
if (in_sigtramp(fi->pc, 0)) {
- /* No idea if this code works. --PB. */
int offset;
if (regno == PC_REGNUM) offset = SIGFRAME_PC_OFF;
- else if (regno == RA_REGNUM) offset = SIGFRAME_RA_OFF;
- else if (regno == SP_REGNUM) offset = SIGFRAME_SP_OFF;
+ else if (regno < 32) offset = SIGFRAME_REGSAVE_OFF + regno * 4;
else return 0;
return read_memory_integer(fi->frame + offset, 4);
}
/* This fencepost looks highly suspicious to me. Removing it also
seems suspicious as it could affect remote debugging across serial
- lines. At the very least, this needs a warning message.
+ lines. */
static CORE_ADDR
heuristic_proc_start(pc)
CORE_ADDR pc;
{
CORE_ADDR start_pc = pc;
- CORE_ADDR fence = start_pc - 200;
+ CORE_ADDR fence = start_pc - heuristic_fence_post;
if (start_pc == 0) return 0;
- if (fence < VM_MIN_ADDRESS) fence = VM_MIN_ADDRESS;
+
+ if (heuristic_fence_post == UINT_MAX
+ || fence < VM_MIN_ADDRESS)
+ fence = VM_MIN_ADDRESS;
/* search back for previous return */
for (start_pc -= 4; ; start_pc -= 4)
if (start_pc < fence)
{
- warning("Cannot find enclosing function for pc 0x%x", pc);
+ /* It's not clear to me why we reach this point when
+ stop_soon_quietly, but with this test, at least we
+ don't print out warnings for every child forked (eg, on
+ if (!stop_soon_quietly)
+ {
+ if (fence == VM_MIN_ADDRESS)
+ warning("Hit beginning of text section without finding");
+ else
+ warning("Hit heuristic-fence-post without finding");
+
+ warning("enclosing function for pc 0x%x", pc);
+ }
+
return 0;
}
else if (ABOUT_TO_RETURN(start_pc))
write_memory (save_address, (char *)&buffer, sizeof(REGISTER_TYPE));
save_address -= 4;
}
- /* save floating-points registers */
- save_address = sp + PROC_FREG_OFFSET(proc_desc);
+ /* save floating-points registers starting with high order word */
+ save_address = sp + PROC_FREG_OFFSET(proc_desc) + 4;
for (ireg = 32; --ireg >= 0; )
if (PROC_FREG_MASK(proc_desc) & (1 << ireg))
{
mips_print_register (regnum, all)
int regnum, all;
{
- unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE * 2]; /* *2 for doubles */
+ unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
REGISTER_TYPE val;
/* Get the data in raw format. */
/* If an even floating pointer register, also print as double. */
if (regnum >= FP0_REGNUM && regnum < FP0_REGNUM+32
&& !((regnum-FP0_REGNUM) & 1)) {
- read_relative_register_raw_bytes (regnum+1, raw_buffer+4);
+ char dbuffer[MAX_REGISTER_RAW_SIZE];
+
+ read_relative_register_raw_bytes (regnum, dbuffer);
+ read_relative_register_raw_bytes (regnum+1, dbuffer+4);
+#ifdef REGISTER_CONVERT_TO_TYPE
+ REGISTER_CONVERT_TO_TYPE(regnum, builtin_type_double, dbuffer);
+#endif
printf_filtered ("(d%d: ", regnum-FP0_REGNUM);
- val_print (builtin_type_double, raw_buffer, 0,
+ val_print (builtin_type_double, dbuffer, 0,
stdout, 0, 1, 0, Val_pretty_default);
printf_filtered ("); ");
}
{
exponent = *p;
exponent = exponent << 1 >> (32 - SINGLE_EXP_BITS - 1);
- return ((exponent == -1) || (! exponent && *p));
+ return ((exponent == -1) || (exponent == 0 && ((*p << 1) != 0)));
}
else if (len == 8)
{
else return 1;
}
\f
-/* To skip prologues, I use this predicate. Returns either PC
- itself if the code at PC does not look like a function prologue,
- PC+4 if it does (our caller does not need anything more fancy). */
+/* To skip prologues, I use this predicate. Returns either PC
+ itself if the code at PC does not look like a function prologue;
+ otherwise returns an address that (if we're lucky) follows
+ the prologue. */
CORE_ADDR
mips_skip_prologue(pc)
struct block *b;
unsigned long inst;
int offset;
+ int seen_sp_adjust = 0;
- /* For -g modules and most functions anyways the
- first instruction adjusts the stack.
- But we allow some number of stores before the stack adjustment.
- (These are emitted by varags functions compiled by gcc-2.0. */
+ /* Skip the typical prologue instructions. These are the stack adjustment
+ instruction and the instructions that save registers on the stack
+ or in the gcc frame. */
for (offset = 0; offset < 100; offset += 4) {
inst = read_memory_integer(pc + offset, 4);
- if ((inst & 0xffff0000) == 0x27bd0000) /* addiu $sp,$sp,offset */
- return pc + offset + 4;
- if ((inst & 0xFFE00000) != 0xAFA00000) /* sw reg,n($sp) */
+ if ((inst & 0xffff0000) == 0x27bd0000) /* addiu $sp,$sp,offset */
+ seen_sp_adjust = 1;
+ else if ((inst & 0xFFE00000) == 0xAFA00000 && (inst & 0x001F0000))
+ continue; /* sw reg,n($sp) */
+ /* reg != $zero */
+ else if ((inst & 0xFFE00000) == 0xE7A00000) /* swc1 freg,n($sp) */
+ continue;
+ else if ((inst & 0xF3E00000) == 0xA3C00000 && (inst & 0x001F0000))
+ /* sx reg,n($s8) */
+ continue; /* reg != $zero */
+ else if (inst == 0x03A0F021) /* move $s8,$sp */
+ continue;
+ else if ((inst & 0xFF9F07FF) == 0x00800021) /* move reg,$a0-$a3 */
+ continue;
+ else
break;
}
+ return pc + offset;
+
+/* FIXME schauer. The following code seems no longer necessary if we
+ always skip the typical prologue instructions. */
+
+#if 0
+ if (seen_sp_adjust)
+ return pc + offset;
/* Well, it looks like a frameless. Let's make sure.
Note that we are not called on the current PC,
return pc + 4;
return pc;
+#endif
+}
+
+/* Given a return value in `regbuf' with a type `valtype',
+ extract and copy its value into `valbuf'. */
+void
+mips_extract_return_value (valtype, regbuf, valbuf)
+ struct type *valtype;
+ char regbuf[REGISTER_BYTES];
+ char *valbuf;
+{
+ int regnum;
+
+ regnum = TYPE_CODE (valtype) == TYPE_CODE_FLT && mips_fpu ? FP0_REGNUM : 2;
+
+ memcpy (valbuf, regbuf + REGISTER_BYTE (regnum), TYPE_LENGTH (valtype));
+#ifdef REGISTER_CONVERT_TO_TYPE
+ REGISTER_CONVERT_TO_TYPE(regnum, valtype, valbuf);
+#endif
+}
+
+/* Given a return value in `regbuf' with a type `valtype',
+ write it's value into the appropriate register. */
+void
+mips_store_return_value (valtype, valbuf)
+ struct type *valtype;
+ char *valbuf;
+{
+ int regnum;
+ char raw_buffer[MAX_REGISTER_RAW_SIZE];
+
+ regnum = TYPE_CODE (valtype) == TYPE_CODE_FLT && mips_fpu ? FP0_REGNUM : 2;
+ memcpy(raw_buffer, valbuf, TYPE_LENGTH (valtype));
+
+#ifdef REGISTER_CONVERT_FROM_TYPE
+ REGISTER_CONVERT_FROM_TYPE(regnum, valtype, raw_buffer);
+#endif
+
+ write_register_bytes(REGISTER_BYTE (regnum), raw_buffer, TYPE_LENGTH (valtype));
}
-/* Let the user turn off floating point. */
+/* Let the user turn off floating point and set the fence post for
+ heuristic_proc_start. */
void
_initialize_mips_tdep ()
Turn off to avoid using floating point instructions when calling functions\n\
or dealing with return values.", &setlist),
&showlist);
+
+ add_show_from_set
+ (add_set_cmd ("heuristic-fence-post", class_support, var_uinteger,
+ (char *) &heuristic_fence_post,
+ "Set the distance searched for the start of a function.\n\
+Set number of bytes to be searched backward to find the beginning of a\n\
+function without symbols.", &setlist),
+ &showlist);
}
projects / binutils.git / blobdiff