/* Native debugging support for Intel x86 running DJGPP.
- Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006
+ Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
Written by Robert Hoehne.
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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
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., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <fcntl.h>
#include "defs.h"
#include "inferior.h"
+#include "gdbthread.h"
#include "gdb_wait.h"
#include "gdbcore.h"
#include "command.h"
static void go32_close (int quitting);
static void go32_attach (char *args, int from_tty);
static void go32_detach (char *args, int from_tty);
-static void go32_resume (ptid_t ptid, int step,
- enum target_signal siggnal);
-static ptid_t go32_wait (ptid_t ptid,
- struct target_waitstatus *status);
-static void go32_fetch_registers (int regno);
-static void store_register (int regno);
-static void go32_store_registers (int regno);
-static void go32_prepare_to_store (void);
-static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+static void go32_resume (struct target_ops *ops,
+ ptid_t ptid, int step,
+ enum target_signal siggnal);
+static void go32_fetch_registers (struct target_ops *ops,
+ struct regcache *, int regno);
+static void store_register (const struct regcache *, int regno);
+static void go32_store_registers (struct target_ops *ops,
+ struct regcache *, int regno);
+static void go32_prepare_to_store (struct regcache *);
+static int go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
int write,
struct mem_attrib *attrib,
struct target_ops *target);
static void go32_files_info (struct target_ops *target);
-static void go32_stop (void);
-static void go32_kill_inferior (void);
-static void go32_create_inferior (char *exec_file, char *args, char **env, int from_tty);
-static void go32_mourn_inferior (void);
+static void go32_stop (ptid_t);
+static void go32_kill_inferior (struct target_ops *ops);
+static void go32_create_inferior (struct target_ops *ops, char *exec_file,
+ char *args, char **env, int from_tty);
+static void go32_mourn_inferior (struct target_ops *ops);
static int go32_can_run (void);
static struct target_ops go32_ops;
}
static void
-go32_attach (char *args, int from_tty)
+go32_attach (struct target_ops *ops, char *args, int from_tty)
{
error (_("\
You cannot attach to a running program on this platform.\n\
}
static void
-go32_detach (char *args, int from_tty)
+go32_detach (struct target_ops *ops, char *args, int from_tty)
{
}
static int resume_signal = -1;
static void
-go32_resume (ptid_t ptid, int step, enum target_signal siggnal)
+go32_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal siggnal)
{
int i;
static char child_cwd[FILENAME_MAX];
static ptid_t
-go32_wait (ptid_t ptid, struct target_waitstatus *status)
+go32_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
int i;
unsigned char saved_opcode;
}
static void
-fetch_register (int regno)
+fetch_register (struct regcache *regcache, int regno)
{
- if (regno < FP0_REGNUM)
- regcache_raw_supply (current_regcache, regno,
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ if (regno < gdbarch_fp0_regnum (gdbarch))
+ regcache_raw_supply (regcache, regno,
(char *) &a_tss + regno_mapping[regno].tss_ofs);
- else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
- i387_supply_fsave (current_regcache, regno, &npx);
+ else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
+ i387_supply_fsave (regcache, regno, &npx);
else
internal_error (__FILE__, __LINE__,
_("Invalid register no. %d in fetch_register."), regno);
}
static void
-go32_fetch_registers (int regno)
+go32_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
if (regno >= 0)
- fetch_register (regno);
+ fetch_register (regcache, regno);
else
{
- for (regno = 0; regno < FP0_REGNUM; regno++)
- fetch_register (regno);
- i387_supply_fsave (current_regcache, -1, &npx);
+ for (regno = 0;
+ regno < gdbarch_fp0_regnum (get_regcache_arch (regcache));
+ regno++)
+ fetch_register (regcache, regno);
+ i387_supply_fsave (regcache, -1, &npx);
}
}
static void
-store_register (int regno)
+store_register (const struct regcache *regcache, int regno)
{
- if (regno < FP0_REGNUM)
- regcache_raw_collect (current_regcache, regno,
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ if (regno < gdbarch_fp0_regnum (gdbarch))
+ regcache_raw_collect (regcache, regno,
(char *) &a_tss + regno_mapping[regno].tss_ofs);
- else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
- i387_fill_fsave ((char *) &npx, regno);
+ else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
+ i387_collect_fsave (regcache, regno, &npx);
else
internal_error (__FILE__, __LINE__,
_("Invalid register no. %d in store_register."), regno);
}
static void
-go32_store_registers (int regno)
+go32_store_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
unsigned r;
if (regno >= 0)
- store_register (regno);
+ store_register (regcache, regno);
else
{
- for (r = 0; r < FP0_REGNUM; r++)
- store_register (r);
- i387_fill_fsave ((char *) &npx, -1);
+ for (r = 0; r < gdbarch_fp0_regnum (get_regcache_arch (regcache)); r++)
+ store_register (regcache, r);
+ i387_collect_fsave (regcache, -1, &npx);
}
}
static void
-go32_prepare_to_store (void)
+go32_prepare_to_store (struct regcache *regcache)
{
}
static int
-go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
struct mem_attrib *attrib, struct target_ops *target)
{
if (write)
}
static void
-go32_stop (void)
+go32_stop (ptid_t ptid)
{
normal_stop ();
cleanup_client ();
+ ptid = inferior_ptid;
inferior_ptid = null_ptid;
+ delete_thread_silent (ptid);
prog_has_started = 0;
}
static void
-go32_kill_inferior (void)
+go32_kill_inferior (struct target_ops *ops)
{
redir_cmdline_delete (&child_cmd);
resume_signal = -1;
resume_is_step = 0;
+ if (!ptid_equal (inferior_ptid, null_ptid))
+ delete_thread_silent (inferior_ptid);
unpush_target (&go32_ops);
}
static void
-go32_create_inferior (char *exec_file, char *args, char **env, int from_tty)
+go32_create_inferior (struct target_ops *ops, char *exec_file,
+ char *args, char **env, int from_tty)
{
extern char **environ;
jmp_buf start_state;
if (prog_has_started)
{
- go32_stop ();
- go32_kill_inferior ();
+ go32_stop (inferior_ptid);
+ go32_kill_inferior (ops);
}
resume_signal = -1;
resume_is_step = 0;
#endif
inferior_ptid = pid_to_ptid (SOME_PID);
+ add_inferior_silent (SOME_PID);
+
push_target (&go32_ops);
+
+ add_thread_silent (inferior_ptid);
+
clear_proceed_status ();
insert_breakpoints ();
prog_has_started = 1;
}
static void
-go32_mourn_inferior (void)
+go32_mourn_inferior (struct target_ops *ops)
{
/* We need to make sure all the breakpoint enable bits in the DR7
register are reset when the inferior exits. Otherwise, if they
at all times, but it doesn't, probably under an assumption that
the OS cleans up when the debuggee exits. */
i386_cleanup_dregs ();
- go32_kill_inferior ();
+ go32_kill_inferior (ops);
generic_mourn_inferior ();
}
}
}
+static int
+go32_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
+ return 1;
+}
+
+static char *
+go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+ static char buf[64];
+ xsnprintf (buf, sizeof buf, "Thread <main>");
+ return buf;
+}
+
static void
init_go32_ops (void)
{
go32_ops.to_mourn_inferior = go32_mourn_inferior;
go32_ops.to_can_run = go32_can_run;
go32_ops.to_stop = go32_stop;
+ go32_ops.to_thread_alive = go32_thread_alive;
+ go32_ops.to_pid_to_str = go32_pid_to_str;
go32_ops.to_stratum = process_stratum;
go32_ops.to_has_all_memory = 1;
go32_ops.to_has_memory = 1;
go32_ops.to_has_stack = 1;
go32_ops.to_has_registers = 1;
go32_ops.to_has_execution = 1;
+
+ i386_use_watchpoints (&go32_ops);
+
go32_ops.to_magic = OPS_MAGIC;
/* Initialize child's cwd as empty to be initialized when starting
}
struct seg_descr {
- unsigned short limit0 __attribute__((packed));
- unsigned short base0 __attribute__((packed));
- unsigned char base1 __attribute__((packed));
- unsigned stype:5 __attribute__((packed));
- unsigned dpl:2 __attribute__((packed));
- unsigned present:1 __attribute__((packed));
- unsigned limit1:4 __attribute__((packed));
- unsigned available:1 __attribute__((packed));
- unsigned dummy:1 __attribute__((packed));
- unsigned bit32:1 __attribute__((packed));
- unsigned page_granular:1 __attribute__((packed));
- unsigned char base2 __attribute__((packed));
-};
+ unsigned short limit0;
+ unsigned short base0;
+ unsigned char base1;
+ unsigned stype:5;
+ unsigned dpl:2;
+ unsigned present:1;
+ unsigned limit1:4;
+ unsigned available:1;
+ unsigned dummy:1;
+ unsigned bit32:1;
+ unsigned page_granular:1;
+ unsigned char base2;
+} __attribute__ ((packed));
struct gate_descr {
- unsigned short offset0 __attribute__((packed));
- unsigned short selector __attribute__((packed));
- unsigned param_count:5 __attribute__((packed));
- unsigned dummy:3 __attribute__((packed));
- unsigned stype:5 __attribute__((packed));
- unsigned dpl:2 __attribute__((packed));
- unsigned present:1 __attribute__((packed));
- unsigned short offset1 __attribute__((packed));
-};
+ unsigned short offset0;
+ unsigned short selector;
+ unsigned param_count:5;
+ unsigned dummy:3;
+ unsigned stype:5;
+ unsigned dpl:2;
+ unsigned present:1;
+ unsigned short offset1;
+} __attribute__ ((packed));
/* Read LEN bytes starting at logical address ADDR, and put the result
into DEST. Return 1 if success, zero if not. */
projects / deliverable / binutils-gdb.git / blobdiff