/* Native debugging support for Intel x86 running DJGPP.
- Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008, 2009
+ Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
Written by Robert Hoehne.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
+/* 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 <fcntl.h>
#include "defs.h"
+#include "i386-nat.h"
#include "inferior.h"
#include "gdbthread.h"
#include "gdb_wait.h"
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 ptid_t
go32_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *status)
+ ptid_t ptid, struct target_waitstatus *status, int options)
{
int i;
unsigned char saved_opcode;
printf_unfiltered ("You are running a DJGPP V2 program.\n");
}
-static 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 (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);
+ go32_mourn_inferior (ops);
}
static void
char *cmdline;
char **env_save = environ;
size_t cmdlen;
+ struct inferior *inf;
/* 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;
#endif
inferior_ptid = pid_to_ptid (SOME_PID);
- add_inferior_silent (SOME_PID);
+ inf = current_inferior ();
+ inferior_appeared (inf, SOME_PID);
push_target (&go32_ops);
static void
go32_mourn_inferior (struct target_ops *ops)
{
+ 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,
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);
+
+ ptid = inferior_ptid;
+ inferior_ptid = null_ptid;
+ delete_thread_silent (ptid);
+ prog_has_started = 0;
+
+ unpush_target (ops);
generic_mourn_inferior ();
}
/* 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;
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;
+ go32_ops.to_has_all_memory = default_child_has_all_memory;
+ go32_ops.to_has_memory = default_child_has_memory;
+ go32_ops.to_has_stack = default_child_has_stack;
+ go32_ops.to_has_registers = default_child_has_registers;
+ go32_ops.to_has_execution = default_child_has_execution;
i386_use_watchpoints (&go32_ops);
+
+ i386_dr_low.set_control = go32_set_dr7;
+ i386_dr_low.set_addr = go32_set_dr;
+ i386_dr_low.reset_addr = NULL;
+ i386_dr_low.get_status = go32_get_dr6;
+ i386_set_debug_register_length (4);
+
go32_ops.to_magic = OPS_MAGIC;
/* Initialize child's cwd as empty to be initialized when starting
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);
}
}
projects / deliverable / binutils-gdb.git / blobdiff