1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright 1997, 1999, 2000, 2001 Free Software Foundation, Inc.
3 Written by Robert Hoehne.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
29 #include "floatformat.h"
34 #include "gdb_string.h"
36 #include <stdio.h> /* required for __DJGPP_MINOR__ */
42 #include <debug/v2load.h>
43 #include <debug/dbgcom.h>
44 #if __DJGPP_MINOR__ > 2
45 #include <debug/redir.h>
48 #if __DJGPP_MINOR__ < 3
49 /* This code will be provided from DJGPP 2.03 on. Until then I code it
57 unsigned short exponent:15;
58 unsigned short sign:1;
77 static void save_npx (void); /* Save the FPU of the debugged program */
78 static void load_npx (void); /* Restore the FPU of the debugged program */
80 /* ------------------------------------------------------------------------- */
81 /* Store the contents of the NPX in the global variable `npx'. */
109 /* ------------------------------------------------------------------------- */
110 /* Reload the contents of the NPX from the global variable `npx'. */
115 asm ("frstor %0":"=m" (npx));
117 /* ------------------------------------------------------------------------- */
118 /* Stubs for the missing redirection functions. */
125 redir_cmdline_delete (cmdline_t *ptr)
131 redir_cmdline_parse (const char *args, cmdline_t *ptr)
137 redir_to_child (cmdline_t *ptr)
143 redir_to_debugger (cmdline_t *ptr)
149 redir_debug_init (cmdline_t *ptr)
153 #endif /* __DJGPP_MINOR < 3 */
155 typedef enum { wp_insert, wp_remove, wp_count } wp_op;
157 /* This holds the current reference counts for each debug register. */
158 static int dr_ref_count[4];
162 static int prog_has_started = 0;
163 static void go32_open (char *name, int from_tty);
164 static void go32_close (int quitting);
165 static void go32_attach (char *args, int from_tty);
166 static void go32_detach (char *args, int from_tty);
167 static void go32_resume (ptid_t ptid, int step,
168 enum target_signal siggnal);
169 static ptid_t go32_wait (ptid_t ptid,
170 struct target_waitstatus *status);
171 static void go32_fetch_registers (int regno);
172 static void store_register (int regno);
173 static void go32_store_registers (int regno);
174 static void go32_prepare_to_store (void);
175 static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
177 struct mem_attrib *attrib,
178 struct target_ops *target);
179 static void go32_files_info (struct target_ops *target);
180 static void go32_stop (void);
181 static void go32_kill_inferior (void);
182 static void go32_create_inferior (char *exec_file, char *args, char **env);
183 static void go32_mourn_inferior (void);
184 static int go32_can_run (void);
186 static struct target_ops go32_ops;
187 static void go32_terminal_init (void);
188 static void go32_terminal_inferior (void);
189 static void go32_terminal_ours (void);
191 #define r_ofs(x) (offsetof(TSS,x))
200 {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
201 {r_ofs (tss_ecx), 4},
202 {r_ofs (tss_edx), 4},
203 {r_ofs (tss_ebx), 4},
204 {r_ofs (tss_esp), 4},
205 {r_ofs (tss_ebp), 4},
206 {r_ofs (tss_esi), 4},
207 {r_ofs (tss_edi), 4},
208 {r_ofs (tss_eip), 4},
209 {r_ofs (tss_eflags), 4},
216 {0, 10}, /* 8 FP registers, from npx.reg[] */
224 /* The order of the next 7 registers must be consistent
225 with their numbering in config/i386/tm-i386.h, which see. */
226 {0, 2}, /* control word, from npx */
227 {4, 2}, /* status word, from npx */
228 {8, 2}, /* tag word, from npx */
229 {16, 2}, /* last FP exception CS from npx */
230 {12, 4}, /* last FP exception EIP from npx */
231 {24, 2}, /* last FP exception operand selector from npx */
232 {20, 4}, /* last FP exception operand offset from npx */
233 {18, 2} /* last FP opcode from npx */
239 enum target_signal gdb_sig;
243 {0, TARGET_SIGNAL_FPE},
244 {1, TARGET_SIGNAL_TRAP},
245 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
246 but I think SIGBUS is better, since the NMI is usually activated
247 as a result of a memory parity check failure. */
248 {2, TARGET_SIGNAL_BUS},
249 {3, TARGET_SIGNAL_TRAP},
250 {4, TARGET_SIGNAL_FPE},
251 {5, TARGET_SIGNAL_SEGV},
252 {6, TARGET_SIGNAL_ILL},
253 {7, TARGET_SIGNAL_EMT}, /* no-coprocessor exception */
254 {8, TARGET_SIGNAL_SEGV},
255 {9, TARGET_SIGNAL_SEGV},
256 {10, TARGET_SIGNAL_BUS},
257 {11, TARGET_SIGNAL_SEGV},
258 {12, TARGET_SIGNAL_SEGV},
259 {13, TARGET_SIGNAL_SEGV},
260 {14, TARGET_SIGNAL_SEGV},
261 {16, TARGET_SIGNAL_FPE},
262 {17, TARGET_SIGNAL_BUS},
263 {31, TARGET_SIGNAL_ILL},
264 {0x1b, TARGET_SIGNAL_INT},
265 {0x75, TARGET_SIGNAL_FPE},
266 {0x78, TARGET_SIGNAL_ALRM},
267 {0x79, TARGET_SIGNAL_INT},
268 {0x7a, TARGET_SIGNAL_QUIT},
269 {-1, TARGET_SIGNAL_LAST}
273 enum target_signal gdb_sig;
276 {TARGET_SIGNAL_0, -1},
277 {TARGET_SIGNAL_ILL, 6}, /* Invalid Opcode */
278 {TARGET_SIGNAL_EMT, 7}, /* triggers SIGNOFP */
279 {TARGET_SIGNAL_SEGV, 13}, /* GPF */
280 {TARGET_SIGNAL_BUS, 17}, /* Alignment Check */
281 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
283 {TARGET_SIGNAL_TERM, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
284 {TARGET_SIGNAL_FPE, 0x75},
285 {TARGET_SIGNAL_INT, 0x79},
286 {TARGET_SIGNAL_QUIT, 0x7a},
287 {TARGET_SIGNAL_ALRM, 0x78}, /* triggers SIGTIMR */
288 {TARGET_SIGNAL_PROF, 0x78},
289 {TARGET_SIGNAL_LAST, -1}
293 go32_open (char *name, int from_tty)
295 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
299 go32_close (int quitting)
304 go32_attach (char *args, int from_tty)
307 You cannot attach to a running program on this platform.\n\
308 Use the `run' command to run DJGPP programs.");
312 go32_detach (char *args, int from_tty)
316 static int resume_is_step;
317 static int resume_signal = -1;
320 go32_resume (ptid_t ptid, int step, enum target_signal siggnal)
324 resume_is_step = step;
326 if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
328 for (i = 0, resume_signal = -1;
329 excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
330 if (excepn_map[i].gdb_sig == siggnal)
332 resume_signal = excepn_map[i].djgpp_excepno;
335 if (resume_signal == -1)
336 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
337 target_signal_to_name (siggnal));
341 static char child_cwd[FILENAME_MAX];
344 go32_wait (ptid_t ptid, struct target_waitstatus *status)
347 unsigned char saved_opcode;
348 unsigned long INT3_addr = 0;
349 int stepping_over_INT = 0;
351 a_tss.tss_eflags &= 0xfeff; /* reset the single-step flag (TF) */
354 /* If the next instruction is INT xx or INTO, we need to handle
355 them specially. Intel manuals say that these instructions
356 reset the single-step flag (a.k.a. TF). However, it seems
357 that, at least in the DPMI environment, and at least when
358 stepping over the DPMI interrupt 31h, the problem is having
359 TF set at all when INT 31h is executed: the debuggee either
360 crashes (and takes the system with it) or is killed by a
363 So we need to emulate single-step mode: we put an INT3 opcode
364 right after the INT xx instruction, let the debuggee run
365 until it hits INT3 and stops, then restore the original
366 instruction which we overwrote with the INT3 opcode, and back
367 up the debuggee's EIP to that instruction. */
368 read_child (a_tss.tss_eip, &saved_opcode, 1);
369 if (saved_opcode == 0xCD || saved_opcode == 0xCE)
371 unsigned char INT3_opcode = 0xCC;
374 = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
375 stepping_over_INT = 1;
376 read_child (INT3_addr, &saved_opcode, 1);
377 write_child (INT3_addr, &INT3_opcode, 1);
380 a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
383 /* The special value FFFFh in tss_trap indicates to run_child that
384 tss_irqn holds a signal to be delivered to the debuggee. */
385 if (resume_signal <= -1)
388 a_tss.tss_irqn = 0xff;
392 a_tss.tss_trap = 0xffff; /* run_child looks for this */
393 a_tss.tss_irqn = resume_signal;
396 /* The child might change working directory behind our back. The
397 GDB users won't like the side effects of that when they work with
398 relative file names, and GDB might be confused by its current
399 directory not being in sync with the truth. So we always make a
400 point of changing back to where GDB thinks is its cwd, when we
401 return control to the debugger, but restore child's cwd before we
403 /* Initialize child_cwd, before the first call to run_child and not
404 in the initialization, so the child get also the changed directory
405 set with the gdb-command "cd ..." */
407 /* Initialize child's cwd with the current one. */
408 getcwd (child_cwd, sizeof (child_cwd));
412 #if __DJGPP_MINOR__ < 3
416 #if __DJGPP_MINOR__ < 3
420 /* Did we step over an INT xx instruction? */
421 if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
423 /* Restore the original opcode. */
424 a_tss.tss_eip--; /* EIP points *after* the INT3 instruction */
425 write_child (a_tss.tss_eip, &saved_opcode, 1);
426 /* Simulate a TRAP exception. */
428 a_tss.tss_eflags |= 0x0100;
431 getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
432 chdir (current_directory);
434 if (a_tss.tss_irqn == 0x21)
436 status->kind = TARGET_WAITKIND_EXITED;
437 status->value.integer = a_tss.tss_eax & 0xff;
441 status->value.sig = TARGET_SIGNAL_UNKNOWN;
442 status->kind = TARGET_WAITKIND_STOPPED;
443 for (i = 0; sig_map[i].go32_sig != -1; i++)
445 if (a_tss.tss_irqn == sig_map[i].go32_sig)
447 #if __DJGPP_MINOR__ < 3
448 if ((status->value.sig = sig_map[i].gdb_sig) !=
450 status->kind = TARGET_WAITKIND_SIGNALLED;
452 status->value.sig = sig_map[i].gdb_sig;
462 fetch_register (int regno)
464 if (regno < FP0_REGNUM)
465 supply_register (regno, (char *) &a_tss + regno_mapping[regno].tss_ofs);
466 else if (regno <= LAST_FPU_CTRL_REGNUM)
467 i387_supply_register (regno, (char *) &npx);
469 internal_error (__FILE__, __LINE__,
470 "Invalid register no. %d in fetch_register.", regno);
474 go32_fetch_registers (int regno)
477 fetch_register (regno);
480 for (regno = 0; regno < FP0_REGNUM; regno++)
481 fetch_register (regno);
482 i387_supply_fsave ((char *) &npx);
487 store_register (int regno)
490 void *v = (void *) register_buffer (regno);
492 if (regno < FP0_REGNUM)
493 memcpy ((char *) &a_tss + regno_mapping[regno].tss_ofs,
494 v, regno_mapping[regno].size);
495 else if (regno <= LAST_FPU_CTRL_REGNUM)
496 i387_fill_fsave ((char *)&npx, regno);
498 internal_error (__FILE__, __LINE__,
499 "Invalid register no. %d in store_register.", regno);
503 go32_store_registers (int regno)
508 store_register (regno);
511 for (r = 0; r < FP0_REGNUM; r++)
513 i387_fill_fsave ((char *) &npx, -1);
518 go32_prepare_to_store (void)
523 go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
524 struct mem_attrib *attrib, struct target_ops *target)
528 if (write_child (memaddr, myaddr, len))
539 if (read_child (memaddr, myaddr, len))
550 static cmdline_t child_cmd; /* parsed child's command line kept here */
553 go32_files_info (struct target_ops *target)
555 printf_unfiltered ("You are running a DJGPP V2 program.\n");
563 inferior_ptid = null_ptid;
564 prog_has_started = 0;
568 go32_kill_inferior (void)
570 redir_cmdline_delete (&child_cmd);
573 unpush_target (&go32_ops);
577 go32_create_inferior (char *exec_file, char *args, char **env)
579 extern char **environ;
582 char **env_save = environ;
584 /* If no exec file handed to us, get it from the exec-file command -- with
585 a good, common error message if none is specified. */
587 exec_file = get_exec_file (1);
589 if (prog_has_started)
592 go32_kill_inferior ();
597 /* Initialize child's cwd as empty to be initialized when starting
601 /* Init command line storage. */
602 if (redir_debug_init (&child_cmd) == -1)
603 internal_error (__FILE__, __LINE__,
604 "Cannot allocate redirection storage: not enough memory.\n");
606 /* Parse the command line and create redirections. */
607 if (strpbrk (args, "<>"))
609 if (redir_cmdline_parse (args, &child_cmd) == 0)
610 args = child_cmd.command;
612 error ("Syntax error in command line.");
615 child_cmd.command = xstrdup (args);
617 cmdline = (char *) alloca (strlen (args) + 4);
618 cmdline[0] = strlen (args);
619 strcpy (cmdline + 1, args);
620 cmdline[strlen (args) + 1] = 13;
624 if (v2loadimage (exec_file, cmdline, start_state))
627 printf_unfiltered ("Load failed for image %s\n", exec_file);
632 edi_init (start_state);
633 #if __DJGPP_MINOR__ < 3
637 inferior_ptid = pid_to_ptid (SOME_PID);
638 push_target (&go32_ops);
639 clear_proceed_status ();
640 insert_breakpoints ();
641 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
642 prog_has_started = 1;
646 go32_mourn_inferior (void)
648 /* We need to make sure all the breakpoint enable bits in the DR7
649 register are reset when the inferior exits. Otherwise, if they
650 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
651 failure to set more watchpoints, and other calamities. It would
652 be nice if GDB itself would take care to remove all breakpoints
653 at all times, but it doesn't, probably under an assumption that
654 the OS cleans up when the debuggee exits. */
655 i386_cleanup_dregs ();
656 go32_kill_inferior ();
657 generic_mourn_inferior ();
666 /* Hardware watchpoint support. */
668 #define D_REGS edi.dr
669 #define CONTROL D_REGS[7]
670 #define STATUS D_REGS[6]
672 /* Pass the address ADDR to the inferior in the I'th debug register.
673 Here we just store the address in D_REGS, the watchpoint will be
674 actually set up when go32_wait runs the debuggee. */
676 go32_set_dr (int i, CORE_ADDR addr)
679 internal_error (__FILE__, __LINE__,
680 "Invalid register %d in go32_set_dr.\n", i);
684 /* Pass the value VAL to the inferior in the DR7 debug control
685 register. Here we just store the address in D_REGS, the watchpoint
686 will be actually set up when go32_wait runs the debuggee. */
688 go32_set_dr7 (unsigned val)
693 /* Get the value of the DR6 debug status register from the inferior.
694 Here we just return the value stored in D_REGS, as we've got it
695 from the last go32_wait call. */
702 /* Put the device open on handle FD into either raw or cooked
703 mode, return 1 if it was in raw mode, zero otherwise. */
706 device_mode (int fd, int raw_p)
708 int oldmode, newmode;
713 __dpmi_int (0x21, ®s);
714 if (regs.x.flags & 1)
716 newmode = oldmode = regs.x.dx;
723 if (oldmode & 0x80) /* Only for character dev */
727 regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails */
728 __dpmi_int (0x21, ®s);
729 if (regs.x.flags & 1)
732 return (oldmode & 0x20) == 0x20;
736 static int inf_mode_valid = 0;
737 static int inf_terminal_mode;
739 /* This semaphore is needed because, amazingly enough, GDB calls
740 target.to_terminal_ours more than once after the inferior stops.
741 But we need the information from the first call only, since the
742 second call will always see GDB's own cooked terminal. */
743 static int terminal_is_ours = 1;
746 go32_terminal_init (void)
748 inf_mode_valid = 0; /* reinitialize, in case they are restarting child */
749 terminal_is_ours = 1;
753 go32_terminal_info (char *args, int from_tty)
755 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
757 ? "default" : inf_terminal_mode ? "raw" : "cooked");
759 #if __DJGPP_MINOR__ > 2
760 if (child_cmd.redirection)
764 for (i = 0; i < DBG_HANDLES; i++)
766 if (child_cmd.redirection[i]->file_name)
767 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
768 i, child_cmd.redirection[i]->file_name);
769 else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
771 ("\tFile handle %d appears to be closed by inferior.\n", i);
772 /* Mask off the raw/cooked bit when comparing device info words. */
773 else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
774 != (_get_dev_info (i) & 0xdf))
776 ("\tFile handle %d appears to be redirected by inferior.\n", i);
783 go32_terminal_inferior (void)
785 /* Redirect standard handles as child wants them. */
787 if (redir_to_child (&child_cmd) == -1)
789 redir_to_debugger (&child_cmd);
790 error ("Cannot redirect standard handles for program: %s.",
793 /* set the console device of the inferior to whatever mode
794 (raw or cooked) we found it last time */
795 if (terminal_is_ours)
798 device_mode (0, inf_terminal_mode);
799 terminal_is_ours = 0;
804 go32_terminal_ours (void)
806 /* Switch to cooked mode on the gdb terminal and save the inferior
807 terminal mode to be restored when it is resumed */
808 if (!terminal_is_ours)
810 inf_terminal_mode = device_mode (0, 0);
811 if (inf_terminal_mode != -1)
814 /* If device_mode returned -1, we don't know what happens with
815 handle 0 anymore, so make the info invalid. */
817 terminal_is_ours = 1;
819 /* Restore debugger's standard handles. */
821 if (redir_to_debugger (&child_cmd) == -1)
823 redir_to_child (&child_cmd);
824 error ("Cannot redirect standard handles for debugger: %s.",
833 go32_ops.to_shortname = "djgpp";
834 go32_ops.to_longname = "djgpp target process";
836 "Program loaded by djgpp, when gdb is used as an external debugger";
837 go32_ops.to_open = go32_open;
838 go32_ops.to_close = go32_close;
839 go32_ops.to_attach = go32_attach;
840 go32_ops.to_detach = go32_detach;
841 go32_ops.to_resume = go32_resume;
842 go32_ops.to_wait = go32_wait;
843 go32_ops.to_fetch_registers = go32_fetch_registers;
844 go32_ops.to_store_registers = go32_store_registers;
845 go32_ops.to_prepare_to_store = go32_prepare_to_store;
846 go32_ops.to_xfer_memory = go32_xfer_memory;
847 go32_ops.to_files_info = go32_files_info;
848 go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
849 go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
850 go32_ops.to_terminal_init = go32_terminal_init;
851 go32_ops.to_terminal_inferior = go32_terminal_inferior;
852 go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
853 go32_ops.to_terminal_ours = go32_terminal_ours;
854 go32_ops.to_terminal_info = go32_terminal_info;
855 go32_ops.to_kill = go32_kill_inferior;
856 go32_ops.to_create_inferior = go32_create_inferior;
857 go32_ops.to_mourn_inferior = go32_mourn_inferior;
858 go32_ops.to_can_run = go32_can_run;
859 go32_ops.to_stop = go32_stop;
860 go32_ops.to_stratum = process_stratum;
861 go32_ops.to_has_all_memory = 1;
862 go32_ops.to_has_memory = 1;
863 go32_ops.to_has_stack = 1;
864 go32_ops.to_has_registers = 1;
865 go32_ops.to_has_execution = 1;
866 go32_ops.to_magic = OPS_MAGIC;
868 /* Initialize child's cwd as empty to be initialized when starting
872 /* Initialize child's command line storage. */
873 if (redir_debug_init (&child_cmd) == -1)
874 internal_error (__FILE__, __LINE__,
875 "Cannot allocate redirection storage: not enough memory.\n");
877 /* We are always processing GCC-compiled programs. */
878 processing_gcc_compilation = 2;
882 _initialize_go32_nat (void)
885 add_target (&go32_ops);
898 tcsetpgrp (int fd, pid_t pgid)
900 if (isatty (fd) && pgid == SOME_PID)
902 errno = pgid == SOME_PID ? ENOTTY : ENOSYS;