#endif
#include <sys/param.h>
-#include <sys/dir.h>
#include <signal.h>
#include <sys/ioctl.h>
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)
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)) {
int offset;
/* 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.
- rich@cygnus.com 12mar93. */
+ 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
+ decstation). 22apr93 rich@cygnus.com. */
+ 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))
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 ("); ");
}
continue; /* reg != $zero */
else if (inst == 0x03A0F021) /* move $s8,$sp */
continue;
+ else if ((inst & 0xFF9F07FF) == 0x00800021) /* move reg,$a0-$a3 */
+ continue;
else
break;
}
#endif
}
-/* Let the user turn off floating point. */
+/* 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 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);
}