/* Intel 386 target-dependent stuff.
- Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
+ Copyright (C) 1988, 1989, 1991, 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "defs.h"
+#include "gdb_string.h"
#include "frame.h"
#include "inferior.h"
#include "gdbcore.h"
#include "target.h"
+#include "floatformat.h"
+#include "symtab.h"
+#include "gdbcmd.h"
-static long
-i386_get_frame_setup PARAMS ((int));
-
-static void
-i386_follow_jump PARAMS ((void));
+static long i386_get_frame_setup PARAMS ((CORE_ADDR));
-static void
-codestream_read PARAMS ((unsigned char *, int));
+static void i386_follow_jump PARAMS ((void));
-static void
-codestream_seek PARAMS ((int));
+static void codestream_read PARAMS ((unsigned char *, int));
-static unsigned char
-codestream_fill PARAMS ((int));
+static void codestream_seek PARAMS ((CORE_ADDR));
-/* helper functions for tm-i386.h */
+static unsigned char codestream_fill PARAMS ((int));
/* Stdio style buffering was used to minimize calls to ptrace, but this
buffering did not take into account that the code section being accessed
static void
codestream_seek (place)
- int place;
+ CORE_ADDR place;
{
codestream_next_addr = place / CODESTREAM_BUFSIZ;
codestream_next_addr *= CODESTREAM_BUFSIZ;
static void
i386_follow_jump ()
{
- int long_delta;
- short short_delta;
- char byte_delta;
+ unsigned char buf[4];
+ long delta;
+
int data16;
- int pos;
-
+ CORE_ADDR pos;
+
pos = codestream_tell ();
-
+
data16 = 0;
if (codestream_peek () == 0x66)
{
codestream_get ();
data16 = 1;
}
-
+
switch (codestream_get ())
{
case 0xe9:
/* relative jump: if data16 == 0, disp32, else disp16 */
if (data16)
{
- codestream_read ((unsigned char *)&short_delta, 2);
+ codestream_read (buf, 2);
+ delta = extract_signed_integer (buf, 2);
/* include size of jmp inst (including the 0x66 prefix). */
- pos += short_delta + 4;
+ pos += delta + 4;
}
else
{
- codestream_read ((unsigned char *)&long_delta, 4);
- pos += long_delta + 5;
+ codestream_read (buf, 4);
+ delta = extract_signed_integer (buf, 4);
+
+ pos += delta + 5;
}
break;
case 0xeb:
/* relative jump, disp8 (ignore data16) */
- codestream_read ((unsigned char *)&byte_delta, 1);
- pos += byte_delta + 2;
+ codestream_read (buf, 1);
+ /* Sign-extend it. */
+ delta = extract_signed_integer (buf, 1);
+
+ pos += delta + 2;
break;
}
codestream_seek (pos);
static long
i386_get_frame_setup (pc)
- int pc;
+ CORE_ADDR pc;
{
unsigned char op;
-
+
codestream_seek (pc);
-
+
i386_follow_jump ();
-
+
op = codestream_get ();
-
+
if (op == 0x58) /* popl %eax */
{
/*
pos += 3;
else if (memcmp (buf, proto2, 4) == 0)
pos += 4;
-
+
codestream_seek (pos);
op = codestream_get (); /* update next opcode */
}
-
+
if (op == 0x55) /* pushl %ebp */
{
/* check for movl %esp, %ebp - can be written two ways */
op = codestream_get ();
if (op < 0x50 || op > 0x57)
break;
+#ifdef I386_REGNO_TO_SYMMETRY
+ /* Dynix uses different internal numbering. Ick. */
+ fsrp->regs[I386_REGNO_TO_SYMMETRY(op - 0x50)] = adr;
+#else
fsrp->regs[op - 0x50] = adr;
+#endif
adr -= 4;
}
}
{
unsigned char op;
int i;
+ static unsigned char pic_pat[6] = { 0xe8, 0, 0, 0, 0, /* call 0x0 */
+ 0x5b, /* popl %ebx */
+ };
+ CORE_ADDR pos;
if (i386_get_frame_setup (pc) < 0)
return (pc);
break;
codestream_get ();
}
+
+ /* The native cc on SVR4 in -K PIC mode inserts the following code to get
+ the address of the global offset table (GOT) into register %ebx.
+ call 0x0
+ popl %ebx
+ movl %ebx,x(%ebp) (optional)
+ addl y,%ebx
+ This code is with the rest of the prologue (at the end of the
+ function), so we have to skip it to get to the first real
+ instruction at the start of the function. */
+
+ pos = codestream_tell ();
+ for (i = 0; i < 6; i++)
+ {
+ op = codestream_get ();
+ if (pic_pat [i] != op)
+ break;
+ }
+ if (i == 6)
+ {
+ unsigned char buf[4];
+ long delta = 6;
+
+ op = codestream_get ();
+ if (op == 0x89) /* movl %ebx, x(%ebp) */
+ {
+ op = codestream_get ();
+ if (op == 0x5d) /* one byte offset from %ebp */
+ {
+ delta += 3;
+ codestream_read (buf, 1);
+ }
+ else if (op == 0x9d) /* four byte offset from %ebp */
+ {
+ delta += 6;
+ codestream_read (buf, 4);
+ }
+ else /* unexpected instruction */
+ delta = -1;
+ op = codestream_get ();
+ }
+ /* addl y,%ebx */
+ if (delta > 0 && op == 0x81 && codestream_get () == 0xc3)
+ {
+ pos += delta + 6;
+ }
+ }
+ codestream_seek (pos);
i386_follow_jump ();
void
i386_pop_frame ()
{
- FRAME frame = get_current_frame ();
+ struct frame_info *frame = get_current_frame ();
CORE_ADDR fp;
int regnum;
struct frame_saved_regs fsr;
- struct frame_info *fi;
char regbuf[MAX_REGISTER_RAW_SIZE];
- fi = get_frame_info (frame);
- fp = fi->frame;
- get_frame_saved_regs (fi, &fsr);
+ fp = FRAME_FP (frame);
+ get_frame_saved_regs (frame, &fsr);
for (regnum = 0; regnum < NUM_REGS; regnum++)
{
CORE_ADDR adr;
write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
write_register (SP_REGNUM, fp + 8);
flush_cached_frames ();
- set_current_frame ( create_new_frame (read_register (FP_REGNUM),
- read_pc ()));
}
#ifdef GET_LONGJMP_TARGET
#endif /* GET_LONGJMP_TARGET */
-#ifdef I386_AIX_TARGET
-/* On AIX, floating point values are returned in floating point registers. */
-
void
i386_extract_return_value(type, regbuf, valbuf)
struct type *type;
char regbuf[REGISTER_BYTES];
char *valbuf;
{
+/* On AIX, floating point values are returned in floating point registers. */
+#ifdef I386_AIX_TARGET
if (TYPE_CODE_FLT == TYPE_CODE(type))
{
- extern struct ext_format ext_format_i387;
double d;
/* 387 %st(0), gcc uses this */
- ieee_extended_to_double (&ext_format_i387,
- ®buf[REGISTER_BYTE(FP0_REGNUM)],
- &d);
- switch (TYPE_LENGTH(type))
- {
- case 4: /* float */
- {
- float f = (float) d;
- memcpy (valbuf, &f, 4);
- break;
- }
- case 8: /* double */
- memcpy (valbuf, &d, 8);
- break;
- default:
- error("Unknown floating point size");
- break;
- }
+ floatformat_to_double (&floatformat_i387_ext,
+ ®buf[REGISTER_BYTE(FP0_REGNUM)],
+ &d);
+ store_floating (valbuf, TYPE_LENGTH (type), d);
}
else
+#endif /* I386_AIX_TARGET */
{
memcpy (valbuf, regbuf, TYPE_LENGTH (type));
}
}
-#endif /* I386_AIX_TARGET */
+
+#ifdef I386V4_SIGTRAMP_SAVED_PC
+/* Get saved user PC for sigtramp from the pushed ucontext on the stack
+ for all three variants of SVR4 sigtramps. */
+
+CORE_ADDR
+i386v4_sigtramp_saved_pc (frame)
+ struct frame_info *frame;
+{
+ CORE_ADDR saved_pc_offset = 4;
+ char *name = NULL;
+
+ find_pc_partial_function (frame->pc, &name, NULL, NULL);
+ if (name)
+ {
+ if (STREQ (name, "_sigreturn"))
+ saved_pc_offset = 132 + 14 * 4;
+ else if (STREQ (name, "_sigacthandler"))
+ saved_pc_offset = 80 + 14 * 4;
+ else if (STREQ (name, "sigvechandler"))
+ saved_pc_offset = 120 + 14 * 4;
+ }
+
+ if (frame->next)
+ return read_memory_integer (frame->next->frame + saved_pc_offset, 4);
+ return read_memory_integer (read_register (SP_REGNUM) + saved_pc_offset, 4);
+}
+#endif /* I386V4_SIGTRAMP_SAVED_PC */
+
+
+
+/* Stuff for WIN32 PE style DLL's but is pretty generic really. */
+
+CORE_ADDR
+skip_trampoline_code (pc, name)
+ CORE_ADDR pc;
+ char *name;
+{
+ if (pc && read_memory_unsigned_integer (pc, 2) == 0x25ff) /* jmp *(dest) */
+ {
+ unsigned long indirect = read_memory_unsigned_integer (pc+2, 4);
+ struct minimal_symbol *indsym =
+ indirect ? lookup_minimal_symbol_by_pc (indirect) : 0;
+ char *symname = indsym ? SYMBOL_NAME(indsym) : 0;
+
+ if (symname)
+ {
+ if (strncmp (symname,"__imp_", 6) == 0
+ || strncmp (symname,"_imp_", 5) == 0)
+ return name ? 1 : read_memory_unsigned_integer (indirect, 4);
+ }
+ }
+ return 0; /* not a trampoline */
+}
+
+static char *x86_assembly_types[] = {"i386", "i8086", NULL};
+static char *x86_assembly_result = "i386";
+
+static void
+set_assembly_language_command (ignore, from_tty, c)
+ char *ignore;
+ int from_tty;
+ struct cmd_list_element *c;
+{
+ if (strcmp (x86_assembly_result, "i386") == 0)
+ tm_print_insn = print_insn_i386;
+ else
+ tm_print_insn = print_insn_i8086;
+}
+
+void
+_initialize_i386_tdep ()
+{
+ struct cmd_list_element *cmd;
+
+ tm_print_insn = print_insn_i386;
+
+ cmd = add_set_enum_cmd ("assembly-language", class_obscure,
+ x86_assembly_types, (char *)&x86_assembly_result,
+ "Set x86 instruction set to use for disassembly.\n\
+This value can be set to either i386 or i8086 to change how instructions are disassembled.",
+ &setlist);
+ add_show_from_set (cmd, &showlist);
+
+ cmd->function.sfunc = set_assembly_language_command;
+}