/* Intel 386 target-dependent stuff.
- Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
+ Copyright (C) 1988, 1989, 1991, 1994, 1995, 1996, 1998
+ Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-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. */
+ 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., 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"
+#include "command.h"
-#ifdef USE_PROC_FS /* Target dependent support for /proc */
-#include <sys/procfs.h>
-#endif
+static long i386_get_frame_setup PARAMS ((CORE_ADDR));
-static long
-i386_get_frame_setup PARAMS ((int));
+static void i386_follow_jump PARAMS ((void));
-static void
-i386_follow_jump PARAMS ((void));
+static void codestream_read PARAMS ((unsigned char *, int));
-static void
-codestream_read PARAMS ((unsigned char *, int));
+static void codestream_seek PARAMS ((CORE_ADDR));
-static void
-codestream_seek PARAMS ((int));
+static unsigned char codestream_fill PARAMS ((int));
-static unsigned char
-codestream_fill PARAMS ((int));
+CORE_ADDR skip_trampoline_code PARAMS ((CORE_ADDR, char *));
+
+static int gdb_print_insn_i386 (bfd_vma, disassemble_info *);
+
+void _initialize_i386_tdep PARAMS ((void));
+
+/* This is the variable the is set with "set disassembly-flavor",
+ and its legitimate values. */
+static char att_flavor[] = "att";
+static char intel_flavor[] = "intel";
+static char *valid_flavors[] =
+{
+ att_flavor,
+ intel_flavor,
+ NULL
+};
+static char *disassembly_flavor = att_flavor;
-/* helper functions for tm-i386.h */
+/* This is used to keep the bfd arch_info in sync with the disassembly flavor. */
+static void set_disassembly_flavor_sfunc PARAMS ((char *, int, struct cmd_list_element *));
+static void set_disassembly_flavor ();
+
+void (*disassembly_flavor_hook) PARAMS ((char *args, int from_tty));
/* Stdio style buffering was used to minimize calls to ptrace, but this
buffering did not take into account that the code section being accessed
#define codestream_get() (codestream_cnt-- == 0 ? \
codestream_fill(0) : codestream_buf[codestream_off++])
-static unsigned char
+static unsigned char
codestream_fill (peek_flag)
- int peek_flag;
+ int peek_flag;
{
codestream_addr = codestream_next_addr;
codestream_next_addr += CODESTREAM_BUFSIZ;
codestream_off = 0;
codestream_cnt = CODESTREAM_BUFSIZ;
- read_memory (codestream_addr,
- (unsigned char *)codestream_buf,
- CODESTREAM_BUFSIZ);
-
+ read_memory (codestream_addr, (char *) codestream_buf, CODESTREAM_BUFSIZ);
+
if (peek_flag)
- return (codestream_peek());
+ return (codestream_peek ());
else
- return (codestream_get());
+ return (codestream_get ());
}
static void
codestream_seek (place)
- int place;
+ CORE_ADDR place;
{
codestream_next_addr = place / CODESTREAM_BUFSIZ;
codestream_next_addr *= CODESTREAM_BUFSIZ;
codestream_cnt = 0;
codestream_fill (1);
- while (codestream_tell() != place)
+ while (codestream_tell () != place)
codestream_get ();
}
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 */
{
/*
* this function must start with
*
- * popl %eax 0x58
+ * popl %eax 0x58
* xchgl %eax, (%esp) 0x87 0x04 0x24
* or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00
*
*/
int pos;
unsigned char buf[4];
- static unsigned char proto1[3] = { 0x87,0x04,0x24 };
- static unsigned char proto2[4] = { 0x87,0x44,0x24,0x00 };
+ static unsigned char proto1[3] =
+ {0x87, 0x04, 0x24};
+ static unsigned char proto2[4] =
+ {0x87, 0x44, 0x24, 0x00};
pos = codestream_tell ();
codestream_read (buf, 4);
if (memcmp (buf, proto1, 3) == 0)
pos += 3;
else if (memcmp (buf, proto2, 4) == 0)
pos += 4;
-
+
codestream_seek (pos);
- op = codestream_get (); /* update next opcode */
+ op = codestream_get (); /* update next opcode */
}
-
+
+ if (op == 0x68 || op == 0x6a)
+ {
+ /*
+ * this function may start with
+ *
+ * pushl constant
+ * call _probe
+ * addl $4, %esp
+ * followed by
+ * pushl %ebp
+ * etc.
+ */
+ int pos;
+ unsigned char buf[8];
+
+ /* Skip past the pushl instruction; it has either a one-byte
+ or a four-byte operand, depending on the opcode. */
+ pos = codestream_tell ();
+ if (op == 0x68)
+ pos += 4;
+ else
+ pos += 1;
+ codestream_seek (pos);
+
+ /* Read the following 8 bytes, which should be "call _probe" (6 bytes)
+ followed by "addl $4,%esp" (2 bytes). */
+ codestream_read (buf, sizeof (buf));
+ if (buf[0] == 0xe8 && buf[6] == 0xc4 && buf[7] == 0x4)
+ pos += sizeof (buf);
+ codestream_seek (pos);
+ op = codestream_get (); /* update next opcode */
+ }
+
if (op == 0x55) /* pushl %ebp */
- {
+ {
/* check for movl %esp, %ebp - can be written two ways */
switch (codestream_get ())
{
return (-1);
}
/* check for stack adjustment
- *
+
* subl $XXX, %esp
*
* note: you can't subtract a 16 bit immediate
/* subl with signed byte immediate
* (though it wouldn't make sense to be negative)
*/
- return (codestream_get());
+ return (codestream_get ());
}
else if (op == 0x81)
{
- /* subl with 32 bit immed */
- int locals;
- codestream_get();
+ char buf[4];
+ /* Maybe it is subl with 32 bit immedediate. */
+ codestream_get ();
if (codestream_get () != 0xec)
/* Some instruction starting with 0x81 other than subl. */
{
codestream_seek (codestream_tell () - 2);
return 0;
}
- /* subl with 32 bit immediate */
- codestream_read ((unsigned char *)&locals, 4);
- SWAP_TARGET_AND_HOST (&locals, 4);
- return (locals);
+ /* It is subl with 32 bit immediate. */
+ codestream_read ((unsigned char *) buf, 4);
+ return extract_signed_integer (buf, 4);
}
else
{
}
else if (op == 0xc8)
{
+ char buf[2];
/* enter instruction: arg is 16 bit unsigned immed */
- unsigned short slocals;
- codestream_read ((unsigned char *)&slocals, 2);
- SWAP_TARGET_AND_HOST (&slocals, 2);
- codestream_get (); /* flush final byte of enter instruction */
- return (slocals);
+ codestream_read ((unsigned char *) buf, 2);
+ codestream_get (); /* flush final byte of enter instruction */
+ return extract_unsigned_integer (buf, 2);
}
return (-1);
}
/* Return number of args passed to a frame.
Can return -1, meaning no way to tell. */
-/* on the 386, the instruction following the call could be:
- * popl %ecx - one arg
- * addl $imm, %esp - imm/4 args; imm may be 8 or 32 bits
- * anything else - zero args
- */
-
int
i386_frame_num_args (fi)
struct frame_info *fi;
{
- int retpc;
- unsigned char op;
+#if 1
+ return -1;
+#else
+ /* This loses because not only might the compiler not be popping the
+ args right after the function call, it might be popping args from both
+ this call and a previous one, and we would say there are more args
+ than there really are. */
+
+ int retpc;
+ unsigned char op;
struct frame_info *pfi;
+ /* on the 386, the instruction following the call could be:
+ popl %ecx - one arg
+ addl $imm, %esp - imm/4 args; imm may be 8 or 32 bits
+ anything else - zero args */
+
int frameless;
- FRAMELESS_FUNCTION_INVOCATION (fi, frameless);
+ frameless = FRAMELESS_FUNCTION_INVOCATION (fi);
if (frameless)
/* In the absence of a frame pointer, GDB doesn't get correct values
for nameless arguments. Return -1, so it doesn't print any
nameless arguments. */
return -1;
- pfi = get_prev_frame_info (fi);
+ pfi = get_prev_frame (fi);
if (pfi == 0)
{
/* Note: this can happen if we are looking at the frame for
- main, because FRAME_CHAIN_VALID won't let us go into
- start. If we have debugging symbols, that's not really
- a big deal; it just means it will only show as many arguments
- to main as are declared. */
+ main, because FRAME_CHAIN_VALID won't let us go into
+ start. If we have debugging symbols, that's not really
+ a big deal; it just means it will only show as many arguments
+ to main as are declared. */
return -1;
}
else
{
- retpc = pfi->pc;
- op = read_memory_integer (retpc, 1);
- if (op == 0x59)
- /* pop %ecx */
- return 1;
+ retpc = pfi->pc;
+ op = read_memory_integer (retpc, 1);
+ if (op == 0x59)
+ /* pop %ecx */
+ return 1;
else if (op == 0x83)
{
- op = read_memory_integer (retpc+1, 1);
- if (op == 0xc4)
- /* addl $<signed imm 8 bits>, %esp */
- return (read_memory_integer (retpc+2,1)&0xff)/4;
+ op = read_memory_integer (retpc + 1, 1);
+ if (op == 0xc4)
+ /* addl $<signed imm 8 bits>, %esp */
+ return (read_memory_integer (retpc + 2, 1) & 0xff) / 4;
else
return 0;
}
else if (op == 0x81)
- { /* add with 32 bit immediate */
- op = read_memory_integer (retpc+1, 1);
- if (op == 0xc4)
- /* addl $<imm 32>, %esp */
- return read_memory_integer (retpc+2, 4) / 4;
+ { /* add with 32 bit immediate */
+ op = read_memory_integer (retpc + 1, 1);
+ if (op == 0xc4)
+ /* addl $<imm 32>, %esp */
+ return read_memory_integer (retpc + 2, 4) / 4;
else
return 0;
}
return 0;
}
}
+#endif
}
/*
struct frame_info *fip;
struct frame_saved_regs *fsrp;
{
- long locals;
+ long locals = -1;
unsigned char op;
CORE_ADDR dummy_bottom;
CORE_ADDR adr;
+ CORE_ADDR pc;
int i;
-
- (void) memset (fsrp, 0, sizeof *fsrp);
-
+
+ memset (fsrp, 0, sizeof *fsrp);
+
/* if frame is the end of a dummy, compute where the
* beginning would be
*/
dummy_bottom = fip->frame - 4 - REGISTER_BYTES - CALL_DUMMY_LENGTH;
-
+
/* check if the PC is in the stack, in a dummy frame */
- if (dummy_bottom <= fip->pc && fip->pc <= fip->frame)
+ if (dummy_bottom <= fip->pc && fip->pc <= fip->frame)
{
/* all regs were saved by push_call_dummy () */
adr = fip->frame;
- for (i = 0; i < NUM_REGS; i++)
+ for (i = 0; i < NUM_REGS; i++)
{
adr -= REGISTER_RAW_SIZE (i);
fsrp->regs[i] = adr;
}
return;
}
-
- locals = i386_get_frame_setup (get_pc_function_start (fip->pc));
-
- if (locals >= 0)
+
+ pc = get_pc_function_start (fip->pc);
+ if (pc != 0)
+ locals = i386_get_frame_setup (pc);
+
+ if (locals >= 0)
{
adr = fip->frame - 4 - locals;
- for (i = 0; i < 8; i++)
+ for (i = 0; i < 8; i++)
{
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;
}
}
-
+
fsrp->regs[PC_REGNUM] = fip->frame + 4;
fsrp->regs[FP_REGNUM] = fip->frame;
}
{
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);
-
+
/* found valid frame setup - codestream now points to
* start of push instructions for saving registers
*/
-
+
/* skip over register saves */
for (i = 0; i < 8; i++)
{
op = codestream_peek ();
/* break if not pushl inst */
- if (op < 0x50 || op > 0x57)
+ if (op < 0x50 || op > 0x57)
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 ();
-
+
return (codestream_tell ());
}
CORE_ADDR sp = read_register (SP_REGNUM);
int regnum;
char regbuf[MAX_REGISTER_RAW_SIZE];
-
+
sp = push_word (sp, read_register (PC_REGNUM));
sp = push_word (sp, read_register (FP_REGNUM));
write_register (FP_REGNUM, sp);
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);
- for (regnum = 0; regnum < NUM_REGS; regnum++)
+
+ fp = FRAME_FP (frame);
+ get_frame_saved_regs (frame, &fsr);
+ for (regnum = 0; regnum < NUM_REGS; regnum++)
{
CORE_ADDR adr;
adr = fsr.regs[regnum];
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 USE_PROC_FS /* Target dependent support for /proc */
-
-/* The /proc interface divides the target machine's register set up into
- two different sets, the general register set (gregset) and the floating
- point register set (fpregset). For each set, there is an ioctl to get
- the current register set and another ioctl to set the current values.
-
- The actual structure passed through the ioctl interface is, of course,
- naturally machine dependent, and is different for each set of registers.
- For the i386 for example, the general register set is typically defined
- by:
-
- typedef int gregset_t[19]; (in <sys/regset.h>)
-
- #define GS 0 (in <sys/reg.h>)
- #define FS 1
- ...
- #define UESP 17
- #define SS 18
-
- and the floating point set by:
-
- typedef struct fpregset
- {
- union
- {
- struct fpchip_state // fp extension state //
- {
- int state[27]; // 287/387 saved state //
- int status; // status word saved at exception //
- } fpchip_state;
- struct fp_emul_space // for emulators //
- {
- char fp_emul[246];
- char fp_epad[2];
- } fp_emul_space;
- int f_fpregs[62]; // union of the above //
- } fp_reg_set;
- long f_wregs[33]; // saved weitek state //
- } fpregset_t;
-
- These routines provide the packing and unpacking of gregset_t and
- fpregset_t formatted data.
-
- */
+#ifdef GET_LONGJMP_TARGET
-/* This is a duplicate of the table in i386-xdep.c. */
+/* Figure out where the longjmp will land. Slurp the args out of the stack.
+ We expect the first arg to be a pointer to the jmp_buf structure from which
+ we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
+ This routine returns true on success. */
-static int regmap[] =
+int
+get_longjmp_target (pc)
+ CORE_ADDR *pc;
{
- EAX, ECX, EDX, EBX,
- UESP, EBP, ESI, EDI,
- EIP, EFL, CS, SS,
- DS, ES, FS, GS,
-};
+ char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
+ CORE_ADDR sp, jb_addr;
+
+ sp = read_register (SP_REGNUM);
+
+ if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
+ buf,
+ TARGET_PTR_BIT / TARGET_CHAR_BIT))
+ return 0;
+
+ jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
+
+ if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
+ TARGET_PTR_BIT / TARGET_CHAR_BIT))
+ return 0;
+ *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
-/* Given a pointer to a general register set in /proc format (gregset_t *),
- unpack the register contents and supply them as gdb's idea of the current
- register values. */
+ return 1;
+}
+
+#endif /* GET_LONGJMP_TARGET */
void
-supply_gregset (gregsetp)
- gregset_t *gregsetp;
+i386_extract_return_value (type, regbuf, valbuf)
+ struct type *type;
+ char regbuf[REGISTER_BYTES];
+ char *valbuf;
{
- register int regno;
- register greg_t *regp = (greg_t *) gregsetp;
- extern int regmap[];
-
- for (regno = 0 ; regno < NUM_REGS ; regno++)
+/* On AIX, floating point values are returned in floating point registers. */
+#ifdef I386_AIX_TARGET
+ if (TYPE_CODE_FLT == TYPE_CODE (type))
{
- supply_register (regno, (char *) (regp + regmap[regno]));
+ double d;
+ /* 387 %st(0), gcc uses this */
+ 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));
}
}
-void
-fill_gregset (gregsetp, regno)
- gregset_t *gregsetp;
- int regno;
+#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;
{
- int regi;
- register greg_t *regp = (greg_t *) gregsetp;
- extern char registers[];
- extern int regmap[];
+ CORE_ADDR saved_pc_offset = 4;
+ char *name = NULL;
- for (regi = 0 ; regi < NUM_REGS ; regi++)
+ find_pc_partial_function (frame->pc, &name, NULL, NULL);
+ if (name)
{
- if ((regno == -1) || (regno == regi))
- {
- *(regp + regmap[regno]) = *(int *) ®isters[REGISTER_BYTE (regi)];
- }
+ 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 defined (FP0_REGNUM)
+ 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 */
-/* Given a pointer to a floating point register set in /proc format
- (fpregset_t *), unpack the register contents and supply them as gdb's
- idea of the current floating point register values. */
+#ifdef STATIC_TRANSFORM_NAME
+/* SunPRO encodes the static variables. This is not related to C++ mangling,
+ it is done for C too. */
-void
-supply_fpregset (fpregsetp)
- fpregset_t *fpregsetp;
+char *
+sunpro_static_transform_name (name)
+ char *name;
{
- register int regno;
-
- /* FIXME: see m68k-tdep.c for an example, for the m68k. */
+ char *p;
+ if (IS_STATIC_TRANSFORM_NAME (name))
+ {
+ /* For file-local statics there will be a period, a bunch
+ of junk (the contents of which match a string given in the
+ N_OPT), a period and the name. For function-local statics
+ there will be a bunch of junk (which seems to change the
+ second character from 'A' to 'B'), a period, the name of the
+ function, and the name. So just skip everything before the
+ last period. */
+ p = strrchr (name, '.');
+ if (p != NULL)
+ name = p + 1;
+ }
+ return name;
}
+#endif /* STATIC_TRANSFORM_NAME */
-/* Given a pointer to a floating point register set in /proc format
- (fpregset_t *), update the register specified by REGNO from gdb's idea
- of the current floating point register set. If REGNO is -1, update
- them all. */
-void
-fill_fpregset (fpregsetp, regno)
- fpregset_t *fpregsetp;
- int regno;
+
+/* Stuff for WIN32 PE style DLL's but is pretty generic really. */
+
+CORE_ADDR
+skip_trampoline_code (pc, name)
+ CORE_ADDR pc;
+ char *name;
{
- int regi;
- char *to;
- char *from;
- extern char registers[];
+ 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;
- /* FIXME: see m68k-tdep.c for an example, for the m68k. */
+ 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 */
}
-#endif /* defined (FP0_REGNUM) */
+static int
+gdb_print_insn_i386 (memaddr, info)
+ bfd_vma memaddr;
+ disassemble_info *info;
+{
+ if (disassembly_flavor == att_flavor)
+ return print_insn_i386_att (memaddr, info);
+ else if (disassembly_flavor == intel_flavor)
+ return print_insn_i386_intel (memaddr, info);
+ /* Never reached - disassembly_flavour is always either att_flavor
+ or intel_flavor */
+ abort ();
+}
-#endif /* USE_PROC_FS */
+/* If the disassembly mode is intel, we have to also switch the
+ bfd mach_type. This function is run in the set disassembly_flavor
+ command, and does that. */
-#ifdef GET_LONGJMP_TARGET
+static void
+set_disassembly_flavor_sfunc (args, from_tty, c)
+ char *args;
+ int from_tty;
+ struct cmd_list_element *c;
+{
+ set_disassembly_flavor ();
-/* Figure out where the longjmp will land. Slurp the args out of the stack.
- We expect the first arg to be a pointer to the jmp_buf structure from which
- we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
- This routine returns true on success. */
+ if (disassembly_flavor_hook != NULL)
+ disassembly_flavor_hook (args, from_tty);
+}
-int
-get_longjmp_target(pc)
- CORE_ADDR *pc;
+static void
+set_disassembly_flavor ()
{
- CORE_ADDR sp, jb_addr;
+ if (disassembly_flavor == att_flavor)
+ set_architecture_from_arch_mach (bfd_arch_i386, bfd_mach_i386_i386);
+ else if (disassembly_flavor == intel_flavor)
+ set_architecture_from_arch_mach (bfd_arch_i386, bfd_mach_i386_i386_intel_syntax);
+}
- sp = read_register(SP_REGNUM);
+void
+_initialize_i386_tdep ()
+{
+ struct cmd_list_element *new_cmd;
- if (target_read_memory(sp + SP_ARG0, /* Offset of first arg on stack */
- (char *) &jb_addr,
- sizeof(CORE_ADDR)))
- return 0;
+ tm_print_insn = gdb_print_insn_i386;
+ tm_print_insn_info.mach = bfd_lookup_arch (bfd_arch_i386, 0)->mach;
+ /* Add the variable that controls the disassembly flavor */
- SWAP_TARGET_AND_HOST(&jb_addr, sizeof(CORE_ADDR));
+ new_cmd = add_set_enum_cmd ("disassembly-flavor", no_class,
+ valid_flavors,
+ (char *) &disassembly_flavor,
+ "Set the disassembly flavor, the valid values are \"att\" and \"intel\", \
+and the default value is \"att\".",
+ &setlist);
+ new_cmd->function.sfunc = set_disassembly_flavor_sfunc;
+ add_show_from_set (new_cmd, &showlist);
- if (target_read_memory(jb_addr + JB_PC * JB_ELEMENT_SIZE, (char *) pc,
- sizeof(CORE_ADDR)))
- return 0;
+ /* Finally, initialize the disassembly flavor to the default given
+ in the disassembly_flavor variable */
- SWAP_TARGET_AND_HOST(pc, sizeof(CORE_ADDR));
+ set_disassembly_flavor ();
- return 1;
}
-
-#endif /* GET_LONGJMP_TARGET */
projects / binutils.git / blobdiff