/* Native debugging support for Intel x86 running DJGPP.
- Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 1997-2020 Free Software Foundation, Inc.
Written by Robert Hoehne.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
-#include <fcntl.h>
+/* To whomever it may concern, here's a general description of how
+ debugging in DJGPP works, and the special quirks GDB does to
+ support that.
+
+ When the DJGPP port of GDB is debugging a DJGPP program natively,
+ there aren't 2 separate processes, the debuggee and GDB itself, as
+ on other systems. (This is DOS, where there can only be one active
+ process at any given time, remember?) Instead, GDB and the
+ debuggee live in the same process. So when GDB calls
+ go32_create_inferior below, and that function calls edi_init from
+ the DJGPP debug support library libdbg.a, we load the debuggee's
+ executable file into GDB's address space, set it up for execution
+ as the stub loader (a short real-mode program prepended to each
+ DJGPP executable) normally would, and do a lot of preparations for
+ swapping between GDB's and debuggee's internal state, primarily wrt
+ the exception handlers. This swapping happens every time we resume
+ the debuggee or switch back to GDB's code, and it includes:
+
+ . swapping all the segment registers
+ . swapping the PSP (the Program Segment Prefix)
+ . swapping the signal handlers
+ . swapping the exception handlers
+ . swapping the FPU status
+ . swapping the 3 standard file handles (more about this below)
+
+ Then running the debuggee simply means longjmp into it where its PC
+ is and let it run until it stops for some reason. When it stops,
+ GDB catches the exception that stopped it and longjmp's back into
+ its own code. All the possible exit points of the debuggee are
+ watched; for example, the normal exit point is recognized because a
+ DOS program issues a special system call to exit. If one of those
+ exit points is hit, we mourn the inferior and clean up after it.
+ Cleaning up is very important, even if the process exits normally,
+ because otherwise we might leave behind traces of previous
+ execution, and in several cases GDB itself might be left hosed,
+ because all the exception handlers were not restored.
+
+ Swapping of the standard handles (in redir_to_child and
+ redir_to_debugger) is needed because, since both GDB and the
+ debuggee live in the same process, as far as the OS is concerned,
+ the share the same file table. This means that the standard
+ handles 0, 1, and 2 point to the same file table entries, and thus
+ are connected to the same devices. Therefore, if the debugger
+ redirects its standard output, the standard output of the debuggee
+ is also automagically redirected to the same file/device!
+ Similarly, if the debuggee redirects its stdout to a file, you
+ won't be able to see debugger's output (it will go to the same file
+ where the debuggee has its output); and if the debuggee closes its
+ standard input, you will lose the ability to talk to debugger!
+
+ For this reason, every time the debuggee is about to be resumed, we
+ call redir_to_child, which redirects the standard handles to where
+ the debuggee expects them to be. When the debuggee stops and GDB
+ regains control, we call redir_to_debugger, which redirects those 3
+ handles back to where GDB expects.
+
+ Note that only the first 3 handles are swapped, so if the debuggee
+ redirects or closes any other handles, GDB will not notice. In
+ particular, the exit code of a DJGPP program forcibly closes all
+ file handles beyond the first 3 ones, so when the debuggee exits,
+ GDB currently loses its stdaux and stdprn streams. Fortunately,
+ GDB does not use those as of this writing, and will never need
+ to. */
#include "defs.h"
+
+#include <fcntl.h>
+
+#include "x86-nat.h"
#include "inferior.h"
+#include "infrun.h"
#include "gdbthread.h"
-#include "gdb_wait.h"
+#include "gdbsupport/gdb_wait.h"
#include "gdbcore.h"
#include "command.h"
#include "gdbcmd.h"
#include "floatformat.h"
-#include "buildsym.h"
+#include "buildsym-legacy.h"
#include "i387-tdep.h"
#include "i386-tdep.h"
+#include "nat/x86-cpuid.h"
#include "value.h"
#include "regcache.h"
-#include "gdb_string.h"
#include "top.h"
+#include "cli/cli-utils.h"
+#include "inf-child.h"
-#include <stdio.h> /* might be required for __DJGPP_MINOR__ */
-#include <stdlib.h>
#include <ctype.h>
-#include <errno.h>
#include <unistd.h>
#include <sys/utsname.h>
#include <io.h>
#include <debug/redir.h>
#endif
+#include <langinfo.h>
+
#if __DJGPP_MINOR__ < 3
-/* This code will be provided from DJGPP 2.03 on. Until then I code it
- here */
+/* This code will be provided from DJGPP 2.03 on. Until then I code it
+ here. */
typedef struct
{
unsigned short sig0;
static NPX npx;
-static void save_npx (void); /* Save the FPU of the debugged program */
-static void load_npx (void); /* Restore the FPU of the debugged program */
+static void save_npx (void); /* Save the FPU of the debugged program. */
+static void load_npx (void); /* Restore the FPU of the debugged program. */
/* ------------------------------------------------------------------------- */
/* Store the contents of the NPX in the global variable `npx'. */
#define SOME_PID 42
static int prog_has_started = 0;
-static void go32_open (char *name, int from_tty);
-static void go32_close (int quitting);
-static void go32_attach (struct target_ops *ops, char *args, int from_tty);
-static void go32_detach (struct target_ops *ops, char *args, int from_tty);
-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 (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_terminal_init (void);
-static void go32_terminal_inferior (void);
-static void go32_terminal_ours (void);
#define r_ofs(x) (offsetof(TSS,x))
static struct
{
int go32_sig;
- enum target_signal gdb_sig;
+ enum gdb_signal gdb_sig;
}
sig_map[] =
{
- {0, TARGET_SIGNAL_FPE},
- {1, TARGET_SIGNAL_TRAP},
+ {0, GDB_SIGNAL_FPE},
+ {1, GDB_SIGNAL_TRAP},
/* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
but I think SIGBUS is better, since the NMI is usually activated
as a result of a memory parity check failure. */
- {2, TARGET_SIGNAL_BUS},
- {3, TARGET_SIGNAL_TRAP},
- {4, TARGET_SIGNAL_FPE},
- {5, TARGET_SIGNAL_SEGV},
- {6, TARGET_SIGNAL_ILL},
- {7, TARGET_SIGNAL_EMT}, /* no-coprocessor exception */
- {8, TARGET_SIGNAL_SEGV},
- {9, TARGET_SIGNAL_SEGV},
- {10, TARGET_SIGNAL_BUS},
- {11, TARGET_SIGNAL_SEGV},
- {12, TARGET_SIGNAL_SEGV},
- {13, TARGET_SIGNAL_SEGV},
- {14, TARGET_SIGNAL_SEGV},
- {16, TARGET_SIGNAL_FPE},
- {17, TARGET_SIGNAL_BUS},
- {31, TARGET_SIGNAL_ILL},
- {0x1b, TARGET_SIGNAL_INT},
- {0x75, TARGET_SIGNAL_FPE},
- {0x78, TARGET_SIGNAL_ALRM},
- {0x79, TARGET_SIGNAL_INT},
- {0x7a, TARGET_SIGNAL_QUIT},
- {-1, TARGET_SIGNAL_LAST}
+ {2, GDB_SIGNAL_BUS},
+ {3, GDB_SIGNAL_TRAP},
+ {4, GDB_SIGNAL_FPE},
+ {5, GDB_SIGNAL_SEGV},
+ {6, GDB_SIGNAL_ILL},
+ {7, GDB_SIGNAL_EMT}, /* no-coprocessor exception */
+ {8, GDB_SIGNAL_SEGV},
+ {9, GDB_SIGNAL_SEGV},
+ {10, GDB_SIGNAL_BUS},
+ {11, GDB_SIGNAL_SEGV},
+ {12, GDB_SIGNAL_SEGV},
+ {13, GDB_SIGNAL_SEGV},
+ {14, GDB_SIGNAL_SEGV},
+ {16, GDB_SIGNAL_FPE},
+ {17, GDB_SIGNAL_BUS},
+ {31, GDB_SIGNAL_ILL},
+ {0x1b, GDB_SIGNAL_INT},
+ {0x75, GDB_SIGNAL_FPE},
+ {0x78, GDB_SIGNAL_ALRM},
+ {0x79, GDB_SIGNAL_INT},
+ {0x7a, GDB_SIGNAL_QUIT},
+ {-1, GDB_SIGNAL_LAST}
};
static struct {
- enum target_signal gdb_sig;
+ enum gdb_signal gdb_sig;
int djgpp_excepno;
} excepn_map[] = {
- {TARGET_SIGNAL_0, -1},
- {TARGET_SIGNAL_ILL, 6}, /* Invalid Opcode */
- {TARGET_SIGNAL_EMT, 7}, /* triggers SIGNOFP */
- {TARGET_SIGNAL_SEGV, 13}, /* GPF */
- {TARGET_SIGNAL_BUS, 17}, /* Alignment Check */
+ {GDB_SIGNAL_0, -1},
+ {GDB_SIGNAL_ILL, 6}, /* Invalid Opcode */
+ {GDB_SIGNAL_EMT, 7}, /* triggers SIGNOFP */
+ {GDB_SIGNAL_SEGV, 13}, /* GPF */
+ {GDB_SIGNAL_BUS, 17}, /* Alignment Check */
/* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
details. */
- {TARGET_SIGNAL_TERM, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
- {TARGET_SIGNAL_FPE, 0x75},
- {TARGET_SIGNAL_INT, 0x79},
- {TARGET_SIGNAL_QUIT, 0x7a},
- {TARGET_SIGNAL_ALRM, 0x78}, /* triggers SIGTIMR */
- {TARGET_SIGNAL_PROF, 0x78},
- {TARGET_SIGNAL_LAST, -1}
+ {GDB_SIGNAL_TERM, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
+ {GDB_SIGNAL_FPE, 0x75},
+ {GDB_SIGNAL_INT, 0x79},
+ {GDB_SIGNAL_QUIT, 0x7a},
+ {GDB_SIGNAL_ALRM, 0x78}, /* triggers SIGTIMR */
+ {GDB_SIGNAL_PROF, 0x78},
+ {GDB_SIGNAL_LAST, -1}
};
-static void
-go32_open (char *name, int from_tty)
-{
- printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
-}
+/* The go32 target. */
-static void
-go32_close (int quitting)
+struct go32_nat_target final : public x86_nat_target<inf_child_target>
{
-}
+ void attach (const char *, int) override;
-static void
-go32_attach (struct target_ops *ops, char *args, int from_tty)
+ void resume (ptid_t, int, enum gdb_signal) override;
+
+ ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+
+ void fetch_registers (struct regcache *, int) override;
+ void store_registers (struct regcache *, int) override;
+
+ enum target_xfer_status xfer_partial (enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len) override;
+
+ void files_info () override;
+
+ void terminal_init () override;
+
+ void terminal_inferior () override;
+
+ void terminal_ours_for_output () override;
+
+ void terminal_ours () override;
+
+ void terminal_info (const char *, int) override;
+
+ void pass_ctrlc () override;
+
+ void kill () override;
+
+ void create_inferior (const char *, const std::string &,
+ char **, int) override;
+
+ void mourn_inferior () override;
+
+ bool thread_alive (ptid_t ptid) override;
+
+ std::string pid_to_str (ptid_t) override;
+};
+
+static go32_nat_target the_go32_nat_target;
+
+void
+go32_nat_target::attach (const char *args, int from_tty)
{
error (_("\
You cannot attach to a running program on this platform.\n\
Use the `run' command to run DJGPP programs."));
}
-static void
-go32_detach (struct target_ops *ops, char *args, int from_tty)
-{
-}
-
static int resume_is_step;
static int resume_signal = -1;
-static void
-go32_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum target_signal siggnal)
+void
+go32_nat_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal)
{
int i;
resume_is_step = step;
- if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
+ if (siggnal != GDB_SIGNAL_0 && siggnal != GDB_SIGNAL_TRAP)
{
for (i = 0, resume_signal = -1;
- excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
+ excepn_map[i].gdb_sig != GDB_SIGNAL_LAST; i++)
if (excepn_map[i].gdb_sig == siggnal)
{
resume_signal = excepn_map[i].djgpp_excepno;
}
if (resume_signal == -1)
printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
- target_signal_to_name (siggnal));
+ gdb_signal_to_name (siggnal));
}
}
static char child_cwd[FILENAME_MAX];
-static ptid_t
-go32_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *status)
+ptid_t
+go32_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,
+ int options)
{
int i;
unsigned char saved_opcode;
unsigned long INT3_addr = 0;
int stepping_over_INT = 0;
- a_tss.tss_eflags &= 0xfeff; /* reset the single-step flag (TF) */
+ a_tss.tss_eflags &= 0xfeff; /* Reset the single-step flag (TF). */
if (resume_is_step)
{
/* If the next instruction is INT xx or INTO, we need to handle
}
else
{
- a_tss.tss_trap = 0xffff; /* run_child looks for this */
+ a_tss.tss_trap = 0xffff; /* run_child looks for this. */
a_tss.tss_irqn = resume_signal;
}
run it. */
/* Initialize child_cwd, before the first call to run_child and not
in the initialization, so the child get also the changed directory
- set with the gdb-command "cd ..." */
+ set with the gdb-command "cd ..." */
if (!*child_cwd)
/* Initialize child's cwd with the current one. */
getcwd (child_cwd, sizeof (child_cwd));
if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
{
/* Restore the original opcode. */
- a_tss.tss_eip--; /* EIP points *after* the INT3 instruction */
+ a_tss.tss_eip--; /* EIP points *after* the INT3 instruction. */
write_child (a_tss.tss_eip, &saved_opcode, 1);
/* Simulate a TRAP exception. */
a_tss.tss_irqn = 1;
}
getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
- chdir (current_directory);
+ if (current_directory != NULL)
+ chdir (current_directory);
if (a_tss.tss_irqn == 0x21)
{
}
else
{
- status->value.sig = TARGET_SIGNAL_UNKNOWN;
+ status->value.sig = GDB_SIGNAL_UNKNOWN;
status->kind = TARGET_WAITKIND_STOPPED;
for (i = 0; sig_map[i].go32_sig != -1; i++)
{
{
#if __DJGPP_MINOR__ < 3
if ((status->value.sig = sig_map[i].gdb_sig) !=
- TARGET_SIGNAL_TRAP)
+ GDB_SIGNAL_TRAP)
status->kind = TARGET_WAITKIND_SIGNALLED;
#else
status->value.sig = sig_map[i].gdb_sig;
}
}
}
- return pid_to_ptid (SOME_PID);
+ return ptid_t (SOME_PID);
}
static void
fetch_register (struct regcache *regcache, int regno)
{
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch *gdbarch = regcache->arch ();
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 (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
+ regcache->raw_supply (regno,
+ (char *) &a_tss + regno_mapping[regno].tss_ofs);
+ 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 (struct target_ops *ops,
- struct regcache *regcache, int regno)
+void
+go32_nat_target::fetch_registers (struct regcache *regcache, int regno)
{
if (regno >= 0)
fetch_register (regcache, regno);
else
{
for (regno = 0;
- regno < gdbarch_fp0_regnum (get_regcache_arch (regcache));
+ regno < gdbarch_fp0_regnum (regcache->arch ());
regno++)
fetch_register (regcache, regno);
i387_supply_fsave (regcache, -1, &npx);
static void
store_register (const struct regcache *regcache, int regno)
{
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch *gdbarch = regcache->arch ();
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 (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
+ regcache->raw_collect (regno,
+ (char *) &a_tss + regno_mapping[regno].tss_ofs);
+ 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 (struct target_ops *ops,
- struct regcache *regcache, int regno)
+void
+go32_nat_target::store_registers (struct regcache *regcache, int regno)
{
unsigned r;
store_register (regcache, regno);
else
{
- for (r = 0; r < gdbarch_fp0_regnum (get_regcache_arch (regcache)); r++)
+ for (r = 0; r < gdbarch_fp0_regnum (regcache->arch ()); r++)
store_register (regcache, r);
i387_collect_fsave (regcache, -1, &npx);
}
}
-static void
-go32_prepare_to_store (struct regcache *regcache)
-{
-}
+/* Const-correct version of DJGPP's write_child, which unfortunately
+ takes a non-const buffer pointer. */
static int
-go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
- struct mem_attrib *attrib, struct target_ops *target)
+my_write_child (unsigned child_addr, const void *buf, unsigned len)
{
- if (write)
+ static void *buffer = NULL;
+ static unsigned buffer_len = 0;
+ int res;
+
+ if (buffer_len < len)
{
- if (write_child (memaddr, myaddr, len))
- {
- return 0;
- }
- else
- {
- return len;
- }
+ buffer = xrealloc (buffer, len);
+ buffer_len = len;
}
+
+ memcpy (buffer, buf, len);
+ res = write_child (child_addr, buffer, len);
+ return res;
+}
+
+/* Helper for go32_xfer_partial that handles memory transfers.
+ Arguments are like target_xfer_partial. */
+
+static enum target_xfer_status
+go32_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
+{
+ int res;
+
+ if (writebuf != NULL)
+ res = my_write_child (memaddr, writebuf, len);
else
- {
- if (read_child (memaddr, myaddr, len))
- {
- return 0;
- }
- else
- {
- return len;
- }
- }
+ res = read_child (memaddr, readbuf, len);
+
+ /* read_child and write_child return zero on success, non-zero on
+ failure. */
+ if (res != 0)
+ return TARGET_XFER_E_IO;
+
+ *xfered_len = len;
+ return TARGET_XFER_OK;
}
-static cmdline_t child_cmd; /* parsed child's command line kept here */
+/* Target to_xfer_partial implementation. */
-static void
-go32_files_info (struct target_ops *target)
+enum target_xfer_status
+go32_nat_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset,
+ ULONGEST len,
+ ULONGEST *xfered_len)
{
- printf_unfiltered ("You are running a DJGPP V2 program.\n");
+ switch (object)
+ {
+ case TARGET_OBJECT_MEMORY:
+ return go32_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
+
+ default:
+ return this->beneath ()->xfer_partial (object, annex,
+ readbuf, writebuf, offset, len,
+ xfered_len);
+ }
}
-static void
-go32_stop (ptid_t ptid)
+static cmdline_t child_cmd; /* Parsed child's command line kept here. */
+
+void
+go32_nat_target::files_info ()
{
- normal_stop ();
- cleanup_client ();
- ptid = inferior_ptid;
- inferior_ptid = null_ptid;
- delete_thread_silent (ptid);
- prog_has_started = 0;
+ printf_unfiltered ("You are running a DJGPP V2 program.\n");
}
-static void
-go32_kill_inferior (struct target_ops *ops)
+void
+go32_nat_target::kill_inferior ()
{
- 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);
+ mourn_inferior ();
}
-static void
-go32_create_inferior (struct target_ops *ops, char *exec_file,
- char *args, char **env, int from_tty)
+void
+go32_nat_target::create_inferior (const char *exec_file,
+ const std::string &allargs,
+ char **env, int from_tty)
{
extern char **environ;
jmp_buf start_state;
char *cmdline;
char **env_save = environ;
size_t cmdlen;
+ struct inferior *inf;
+ int result;
+ const char *args = allargs.c_str ();
/* If no exec file handed to us, get it from the exec-file command -- with
a good, common error message if none is specified. */
if (exec_file == 0)
exec_file = get_exec_file (1);
- if (prog_has_started)
- {
- go32_stop (inferior_ptid);
- go32_kill_inferior (ops);
- }
resume_signal = -1;
resume_is_step = 0;
/* Init command line storage. */
if (redir_debug_init (&child_cmd) == -1)
internal_error (__FILE__, __LINE__,
- _("Cannot allocate redirection storage: not enough memory.\n"));
+ _("Cannot allocate redirection storage: "
+ "not enough memory.\n"));
/* Parse the command line and create redirections. */
if (strpbrk (args, "<>"))
if (cmdlen > 1024*1024)
error (_("Command line too long."));
- cmdline = xmalloc (cmdlen + 4);
+ cmdline = (char *) xmalloc (cmdlen + 4);
strcpy (cmdline + 1, args);
/* If the command-line length fits into DOS 126-char limits, use the
DOS command tail format; otherwise, tell v2loadimage to pass it
cmdline[cmdlen + 1] = 13;
}
else
- cmdline[0] = 0xff; /* signal v2loadimage it's a long command */
+ cmdline[0] = 0xff; /* Signal v2loadimage it's a long command. */
environ = env;
- if (v2loadimage (exec_file, cmdline, start_state))
- {
- environ = env_save;
- printf_unfiltered ("Load failed for image %s\n", exec_file);
- exit (1);
- }
+ result = v2loadimage (exec_file, cmdline, start_state);
+
environ = env_save;
xfree (cmdline);
+ if (result != 0)
+ error (_("Load failed for image %s"), exec_file);
+
edi_init (start_state);
#if __DJGPP_MINOR__ < 3
save_npx ();
#endif
- inferior_ptid = pid_to_ptid (SOME_PID);
- add_inferior_silent (SOME_PID);
+ inferior_ptid = ptid_t (SOME_PID);
+ inf = current_inferior ();
+ inferior_appeared (inf, SOME_PID);
- push_target (&go32_ops);
+ if (!target_is_pushed (this))
+ push_target (this);
add_thread_silent (inferior_ptid);
- clear_proceed_status ();
+ clear_proceed_status (0);
insert_breakpoints ();
prog_has_started = 1;
}
-static void
-go32_mourn_inferior (struct target_ops *ops)
+void
+go32_nat_target::mourn_inferior ()
{
+ ptid_t ptid;
+
+ redir_cmdline_delete (&child_cmd);
+ resume_signal = -1;
+ resume_is_step = 0;
+
+ cleanup_client ();
+
/* We need to make sure all the breakpoint enable bits in the DR7
register are reset when the inferior exits. Otherwise, if they
rerun the inferior, the uncleared bits may cause random SIGTRAPs,
be nice if GDB itself would take care to remove all breakpoints
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 (ops);
- generic_mourn_inferior ();
-}
+ x86_cleanup_dregs ();
-static int
-go32_can_run (void)
-{
- return 1;
+ ptid = inferior_ptid;
+ inferior_ptid = null_ptid;
+ prog_has_started = 0;
+
+ generic_mourn_inferior ();
+ maybe_unpush_target ();
}
/* Hardware watchpoint support. */
/* Pass the address ADDR to the inferior in the I'th debug register.
Here we just store the address in D_REGS, the watchpoint will be
actually set up when go32_wait runs the debuggee. */
-void
+static void
go32_set_dr (int i, CORE_ADDR addr)
{
if (i < 0 || i > 3)
/* Pass the value VAL to the inferior in the DR7 debug control
register. Here we just store the address in D_REGS, the watchpoint
will be actually set up when go32_wait runs the debuggee. */
-void
-go32_set_dr7 (unsigned val)
+static void
+go32_set_dr7 (unsigned long val)
{
CONTROL = val;
}
/* Get the value of the DR6 debug status register from the inferior.
Here we just return the value stored in D_REGS, as we've got it
from the last go32_wait call. */
-unsigned
+static unsigned long
go32_get_dr6 (void)
{
return STATUS;
}
+/* Get the value of the DR7 debug status register from the inferior.
+ Here we just return the value stored in D_REGS, as we've got it
+ from the last go32_wait call. */
+
+static unsigned long
+go32_get_dr7 (void)
+{
+ return CONTROL;
+}
+
+/* Get the value of the DR debug register I from the inferior. Here
+ we just return the value stored in D_REGS, as we've got it from the
+ last go32_wait call. */
+
+static CORE_ADDR
+go32_get_dr (int i)
+{
+ if (i < 0 || i > 3)
+ internal_error (__FILE__, __LINE__,
+ _("Invalid register %d in go32_get_dr.\n"), i);
+ return D_REGS[i];
+}
+
/* Put the device open on handle FD into either raw or cooked
mode, return 1 if it was in raw mode, zero otherwise. */
else
newmode &= ~0x20;
- if (oldmode & 0x80) /* Only for character dev */
+ if (oldmode & 0x80) /* Only for character dev. */
{
regs.x.ax = 0x4401;
regs.x.bx = fd;
- regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails */
+ regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails. */
__dpmi_int (0x21, ®s);
if (regs.x.flags & 1)
return -1;
second call will always see GDB's own cooked terminal. */
static int terminal_is_ours = 1;
-static void
-go32_terminal_init (void)
+void
+go32_nat_target::terminal_init ()
{
- inf_mode_valid = 0; /* reinitialize, in case they are restarting child */
+ inf_mode_valid = 0; /* Reinitialize, in case they are restarting child. */
terminal_is_ours = 1;
}
-static void
-go32_terminal_info (char *args, int from_tty)
+void
+go32_nat_target::terminal_info (const char *args, int from_tty)
{
printf_unfiltered ("Inferior's terminal is in %s mode.\n",
!inf_mode_valid
#endif
}
-static void
-go32_terminal_inferior (void)
+void
+go32_nat_target::terminal_inferior ()
{
/* Redirect standard handles as child wants them. */
errno = 0;
error (_("Cannot redirect standard handles for program: %s."),
safe_strerror (errno));
}
- /* set the console device of the inferior to whatever mode
- (raw or cooked) we found it last time */
+ /* Set the console device of the inferior to whatever mode
+ (raw or cooked) we found it last time. */
if (terminal_is_ours)
{
if (inf_mode_valid)
}
}
-static void
-go32_terminal_ours (void)
+void
+go32_nat_target::terminal_ours ()
{
/* Switch to cooked mode on the gdb terminal and save the inferior
- terminal mode to be restored when it is resumed */
+ terminal mode to be restored when it is resumed. */
if (!terminal_is_ours)
{
inf_terminal_mode = device_mode (0, 0);
}
}
-static int
-go32_thread_alive (struct target_ops *ops, ptid_t ptid)
+void
+go32_nat_target::pass_ctrlc ()
{
- return 1;
}
-static char *
-go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
+bool
+go32_nat_target::thread_alive (ptid_t ptid)
{
- static char buf[64];
- xsnprintf (buf, sizeof buf, "Thread <main>");
- return buf;
+ return ptid != null_ptid;
}
-static void
-init_go32_ops (void)
+std::string
+go32_nat_target::pid_to_str (ptid_t ptid)
{
- go32_ops.to_shortname = "djgpp";
- go32_ops.to_longname = "djgpp target process";
- go32_ops.to_doc =
- "Program loaded by djgpp, when gdb is used as an external debugger";
- go32_ops.to_open = go32_open;
- go32_ops.to_close = go32_close;
- go32_ops.to_attach = go32_attach;
- go32_ops.to_detach = go32_detach;
- go32_ops.to_resume = go32_resume;
- go32_ops.to_wait = go32_wait;
- go32_ops.to_fetch_registers = go32_fetch_registers;
- go32_ops.to_store_registers = go32_store_registers;
- go32_ops.to_prepare_to_store = go32_prepare_to_store;
- go32_ops.deprecated_xfer_memory = go32_xfer_memory;
- go32_ops.to_files_info = go32_files_info;
- go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
- go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
- go32_ops.to_terminal_init = go32_terminal_init;
- go32_ops.to_terminal_inferior = go32_terminal_inferior;
- go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
- go32_ops.to_terminal_ours = go32_terminal_ours;
- go32_ops.to_terminal_info = go32_terminal_info;
- go32_ops.to_kill = go32_kill_inferior;
- go32_ops.to_create_inferior = go32_create_inferior;
- 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;
+ return normal_pid_to_str (ptid);
+}
- /* Initialize child's cwd as empty to be initialized when starting
- the child. */
- *child_cwd = 0;
+/* Return the current DOS codepage number. */
+static int
+dos_codepage (void)
+{
+ __dpmi_regs regs;
- /* Initialize child's command line storage. */
- if (redir_debug_init (&child_cmd) == -1)
- internal_error (__FILE__, __LINE__,
- _("Cannot allocate redirection storage: not enough memory.\n"));
+ regs.x.ax = 0x6601;
+ __dpmi_int (0x21, ®s);
+ if (!(regs.x.flags & 1))
+ return regs.x.bx & 0xffff;
+ else
+ return 437; /* default */
+}
- /* We are always processing GCC-compiled programs. */
- processing_gcc_compilation = 2;
+/* Limited emulation of `nl_langinfo', for charset.c. */
+char *
+nl_langinfo (nl_item item)
+{
+ char *retval;
- /* Override the default name of the GDB init file. */
- strcpy (gdbinit, "gdb.ini");
+ switch (item)
+ {
+ case CODESET:
+ {
+ /* 8 is enough for SHORT_MAX + "CP" + null. */
+ char buf[8];
+ int blen = sizeof (buf);
+ int needed = snprintf (buf, blen, "CP%d", dos_codepage ());
+
+ if (needed > blen) /* Should never happen. */
+ buf[0] = 0;
+ retval = xstrdup (buf);
+ }
+ break;
+ default:
+ retval = xstrdup ("");
+ break;
+ }
+ return retval;
}
unsigned short windows_major, windows_minor;
/* Display assorted information about the underlying OS. */
static void
-go32_sysinfo (char *arg, int from_tty)
+go32_sysinfo (const char *arg, int from_tty)
{
+ static const char test_pattern[] =
+ "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
+ "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
+ "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
struct utsname u;
char cpuid_vendor[13];
unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
int dpmi_flags;
char dpmi_vendor_info[129];
- int dpmi_vendor_available =
- __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
+ int dpmi_vendor_available;
__dpmi_version_ret dpmi_version_data;
long eflags;
__dpmi_free_mem_info mem_info;
else if (u.machine[0] == 'i' && u.machine[1] > 4)
{
/* CPUID with EAX = 0 returns the Vendor ID. */
+#if 0
+ /* Ideally we would use x86_cpuid(), but it needs someone to run
+ native tests first to make sure things actually work. They should.
+ http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html */
+ unsigned int eax, ebx, ecx, edx;
+
+ if (x86_cpuid (0, &eax, &ebx, &ecx, &edx))
+ {
+ cpuid_max = eax;
+ memcpy (&vendor[0], &ebx, 4);
+ memcpy (&vendor[4], &ecx, 4);
+ memcpy (&vendor[8], &edx, 4);
+ cpuid_vendor[12] = '\0';
+ }
+#else
__asm__ __volatile__ ("xorl %%ebx, %%ebx;"
"xorl %%ecx, %%ecx;"
"xorl %%edx, %%edx;"
:
: "%eax", "%ebx", "%ecx", "%edx");
cpuid_vendor[12] = '\0';
+#endif
}
printf_filtered ("CPU Type.......................%s", u.machine);
/* CPUID with EAX = 1 returns processor signature and features. */
if (cpuid_max >= 1)
{
- static char *brand_name[] = {
+ static const char *brand_name[] = {
"",
" Celeron",
" III",
unsigned brand_idx;
int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
+ int hygon_p = strcmp (cpuid_vendor, "HygonGenuine") == 0;
unsigned cpu_family, cpu_model;
+#if 0
+ /* See comment above about cpuid usage. */
+ x86_cpuid (1, &cpuid_eax, &cpuid_ebx, NULL, &cpuid_edx);
+#else
__asm__ __volatile__ ("movl $1, %%eax;"
"cpuid;"
: "=a" (cpuid_eax),
"=d" (cpuid_edx)
:
: "%ecx");
+#endif
brand_idx = cpuid_ebx & 0xff;
cpu_family = (cpuid_eax >> 8) & 0xf;
cpu_model = (cpuid_eax >> 4) & 0xf;
break;
}
}
- sprintf (cpu_string, "%s%s Model %d Stepping %d",
- intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
- cpu_brand, cpu_model, cpuid_eax & 0xf);
+ xsnprintf (cpu_string, sizeof (cpu_string), "%s%s Model %d Stepping %d",
+ intel_p ? "Pentium" : (amd_p ? "AMD" : (hygon_p ? "Hygon" : "ix86")),
+ cpu_brand, cpu_model, cpuid_eax & 0xf);
printfi_filtered (31, "%s\n", cpu_string);
if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
|| ((cpuid_edx & 1) == 0)
- || (amd_p && (cpuid_edx & (3 << 30)) != 0))
+ || ((amd_p || hygon_p) && (cpuid_edx & (3 << 30)) != 0))
{
puts_filtered ("CPU Features...................");
/* We only list features which might be useful in the DPMI
environment. */
if ((cpuid_edx & 1) == 0)
- puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
+ puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
if ((cpuid_edx & (1 << 1)) != 0)
puts_filtered ("VME ");
if ((cpuid_edx & (1 << 2)) != 0)
puts_filtered ("SSE ");
if ((cpuid_edx & (1 << 26)) != 0)
puts_filtered ("SSE2 ");
- if (amd_p)
+ if (amd_p || hygon_p)
{
if ((cpuid_edx & (1 << 31)) != 0)
puts_filtered ("3DNow! ");
printf_filtered ("%s)\n", windows_flavor);
}
else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
- printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
+ printf_filtered ("Windows Version................"
+ "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
puts_filtered ("\n");
- if (dpmi_vendor_available == 0)
+ /* On some versions of Windows, __dpmi_get_capabilities returns
+ zero, but the buffer is not filled with info, so we fill the
+ buffer with a known pattern and test for it afterwards. */
+ memcpy (dpmi_vendor_info, test_pattern, sizeof(dpmi_vendor_info));
+ dpmi_vendor_available =
+ __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
+ if (dpmi_vendor_available == 0
+ && memcmp (dpmi_vendor_info, test_pattern,
+ sizeof(dpmi_vendor_info)) != 0)
{
/* The DPMI spec says the vendor string should be ASCIIZ, but
I don't trust the vendors to follow that... */
if (!memchr (&dpmi_vendor_info[2], 0, 126))
dpmi_vendor_info[128] = '\0';
- printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
+ printf_filtered ("DPMI Host......................"
+ "%s v%d.%d (capabilities: %#x)\n",
&dpmi_vendor_info[2],
(unsigned)dpmi_vendor_info[0],
(unsigned)dpmi_vendor_info[1],
((unsigned)dpmi_flags & 0x7f));
}
+ else
+ printf_filtered ("DPMI Host......................(Info not available)\n");
__dpmi_get_version (&dpmi_version_data);
printf_filtered ("DPMI Version...................%d.%02d\n",
dpmi_version_data.major, dpmi_version_data.minor);
- printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
+ printf_filtered ("DPMI Info......................"
+ "%s-bit DPMI, with%s Virtual Memory support\n",
(dpmi_version_data.flags & 1) ? "32" : "16",
(dpmi_version_data.flags & 4) ? "" : "out");
printfi_filtered (31, "Interrupts reflected to %s mode\n",
if (prog_has_started)
{
__asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
- printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
+ printf_filtered ("Protection....................."
+ "Ring %d (in %s), with%s I/O protection\n",
a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
(a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
}
case 23:
printf_filtered (" %s-bit Data (%s Exp-%s%s)",
descr.bit32 ? "32" : "16",
- descr.stype & 2 ? "Read/Write," : "Read-Only, ",
+ descr.stype & 2
+ ? "Read/Write," : "Read-Only, ",
descr.stype & 4 ? "down" : "up",
descr.stype & 1 ? "" : ", N.Acc");
break;
}
static void
-go32_sldt (char *arg, int from_tty)
+go32_sldt (const char *arg, int from_tty)
{
struct dtr_reg gdtr;
unsigned short ldtr = 0;
if (arg && *arg)
{
- while (*arg && isspace(*arg))
- arg++;
+ arg = skip_spaces (arg);
if (*arg)
{
}
static void
-go32_sgdt (char *arg, int from_tty)
+go32_sgdt (const char *arg, int from_tty)
{
struct dtr_reg gdtr;
long gdt_entry = -1L;
if (arg && *arg)
{
- while (*arg && isspace(*arg))
- arg++;
+ arg = skip_spaces (arg);
if (*arg)
{
gdt_entry = parse_and_eval_long (arg);
if (gdt_entry < 0 || (gdt_entry & 7) != 0)
- error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
+ error (_("Invalid GDT entry 0x%03lx: "
+ "not an integral multiple of 8."),
(unsigned long)gdt_entry);
}
}
}
static void
-go32_sidt (char *arg, int from_tty)
+go32_sidt (const char *arg, int from_tty)
{
struct dtr_reg idtr;
long idt_entry = -1L;
if (arg && *arg)
{
- while (*arg && isspace(*arg))
- arg++;
+ arg = skip_spaces (arg);
if (*arg)
{
__asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ );
max_entry = (idtr.limit + 1) / 8;
- if (max_entry > 0x100) /* no more than 256 entries */
+ if (max_entry > 0x100) /* No more than 256 entries. */
max_entry = 0x100;
if (idt_entry >= 0)
cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
if (cr3 > 0xfffff)
{
-#if 0 /* not fullly supported yet */
+#if 0 /* Not fully supported yet. */
/* The Page Directory is in UMBs. In that case, CWSDPMI puts
the first Page Table right below the Page Directory. Thus,
the first Page Table's entry for its own address and the Page
Directory entry for that Page Table will hold the same
physical address. The loop below searches the entire UMB
- range of addresses for such an occurence. */
+ range of addresses for such an occurrence. */
unsigned long addr, pte_idx;
for (addr = 0xb0000, pte_idx = 0xb0;
page tables, for now. */
if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
{
- pde &= ~0xfff; /* clear non-address bits */
+ pde &= ~0xfff; /* Clear non-address bits. */
pte = _farpeekl (_dos_ds, pde + 4*n);
}
return pte;
}
static void
-go32_pde (char *arg, int from_tty)
+go32_pde (const char *arg, int from_tty)
{
long pde_idx = -1, i;
if (arg && *arg)
{
- while (*arg && isspace(*arg))
- arg++;
+ arg = skip_spaces (arg);
if (*arg)
{
pdbr = get_cr3 ();
if (!pdbr)
- puts_filtered ("Access to Page Directories is not supported on this system.\n");
+ puts_filtered ("Access to Page Directories is "
+ "not supported on this system.\n");
else if (pde_idx >= 0)
display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
else
{
int i;
- printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
+ printf_filtered ("Page Table pointed to by "
+ "Page Directory entry 0x%lx:\n", n);
for (i = 0; i < 1024; i++)
display_ptable_entry (get_pte (pde, i), 0, 0, 0);
puts_filtered ("\n");
}
static void
-go32_pte (char *arg, int from_tty)
+go32_pte (const char *arg, int from_tty)
{
long pde_idx = -1L, i;
if (arg && *arg)
{
- while (*arg && isspace(*arg))
- arg++;
+ arg = skip_spaces (arg);
if (*arg)
{
}
static void
-go32_pte_for_address (char *arg, int from_tty)
+go32_pte_for_address (const char *arg, int from_tty)
{
CORE_ADDR addr = 0, i;
if (arg && *arg)
{
- while (*arg && isspace(*arg))
- arg++;
+ arg = skip_spaces (arg);
if (*arg)
addr = parse_and_eval_address (arg);
int pte_idx = (addr >> 12) & 0x3ff;
unsigned offs = addr & 0xfff;
- printf_filtered ("Page Table entry for address 0x%llx:\n",
- (unsigned long long)addr);
+ printf_filtered ("Page Table entry for address %s:\n",
+ hex_string(addr));
display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
}
}
static struct cmd_list_element *info_dos_cmdlist = NULL;
-static void
-go32_info_dos_command (char *args, int from_tty)
-{
- help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
-}
-
+void _initialize_go32_nat ();
void
-_initialize_go32_nat (void)
+_initialize_go32_nat ()
{
- init_go32_ops ();
- add_target (&go32_ops);
+ x86_dr_low.set_control = go32_set_dr7;
+ x86_dr_low.set_addr = go32_set_dr;
+ x86_dr_low.get_status = go32_get_dr6;
+ x86_dr_low.get_control = go32_get_dr7;
+ x86_dr_low.get_addr = go32_get_dr;
+ x86_set_debug_register_length (4);
+
+ add_inf_child_target (&the_go32_nat_target);
+
+ /* Initialize child's cwd as empty to be initialized when starting
+ the child. */
+ *child_cwd = 0;
+
+ /* Initialize child's command line storage. */
+ if (redir_debug_init (&child_cmd) == -1)
+ internal_error (__FILE__, __LINE__,
+ _("Cannot allocate redirection storage: "
+ "not enough memory.\n"));
+
+ /* We are always processing GCC-compiled programs. */
+ processing_gcc_compilation = 2;
- add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
+ add_basic_prefix_cmd ("dos", class_info, _("\
Print information specific to DJGPP (aka MS-DOS) debugging."),
- &info_dos_cmdlist, "info dos ", 0, &infolist);
+ &info_dos_cmdlist, "info dos ", 0, &infolist);
add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
Display information about the target system, including CPU, OS, DPMI, etc."),
projects / deliverable / binutils-gdb.git / blobdiff