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
) {ptr
->redirected
= 0;}
128 redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
133 redir_to_child (cmdline_t
*ptr
)
138 redir_to_debugger (cmdline_t
*ptr
)
143 redir_debug_init (cmdline_t
*ptr
) { return 0; }
144 #endif /* __DJGPP_MINOR < 3 */
146 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
148 /* This holds the current reference counts for each debug register. */
149 static int dr_ref_count
[4];
153 static int prog_has_started
= 0;
154 static void go32_open (char *name
, int from_tty
);
155 static void go32_close (int quitting
);
156 static void go32_attach (char *args
, int from_tty
);
157 static void go32_detach (char *args
, int from_tty
);
158 static void go32_resume (int pid
, int step
, enum target_signal siggnal
);
159 static int go32_wait (int pid
, struct target_waitstatus
*status
);
160 static void go32_fetch_registers (int regno
);
161 static void store_register (int regno
);
162 static void go32_store_registers (int regno
);
163 static void go32_prepare_to_store (void);
164 static int go32_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
166 struct mem_attrib
*attrib
,
167 struct target_ops
*target
);
168 static void go32_files_info (struct target_ops
*target
);
169 static void go32_stop (void);
170 static void go32_kill_inferior (void);
171 static void go32_create_inferior (char *exec_file
, char *args
, char **env
);
172 static void go32_mourn_inferior (void);
173 static int go32_can_run (void);
175 static struct target_ops go32_ops
;
176 static void go32_terminal_init (void);
177 static void go32_terminal_inferior (void);
178 static void go32_terminal_ours (void);
180 #define r_ofs(x) (offsetof(TSS,x))
189 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
190 {r_ofs (tss_ecx
), 4},
191 {r_ofs (tss_edx
), 4},
192 {r_ofs (tss_ebx
), 4},
193 {r_ofs (tss_esp
), 4},
194 {r_ofs (tss_ebp
), 4},
195 {r_ofs (tss_esi
), 4},
196 {r_ofs (tss_edi
), 4},
197 {r_ofs (tss_eip
), 4},
198 {r_ofs (tss_eflags
), 4},
205 {0, 10}, /* 8 FP registers, from npx.reg[] */
213 /* The order of the next 7 registers must be consistent
214 with their numbering in config/i386/tm-i386.h, which see. */
215 {0, 2}, /* control word, from npx */
216 {4, 2}, /* status word, from npx */
217 {8, 2}, /* tag word, from npx */
218 {16, 2}, /* last FP exception CS from npx */
219 {12, 4}, /* last FP exception EIP from npx */
220 {24, 2}, /* last FP exception operand selector from npx */
221 {20, 4}, /* last FP exception operand offset from npx */
222 {18, 2} /* last FP opcode from npx */
228 enum target_signal gdb_sig
;
232 {0, TARGET_SIGNAL_FPE
},
233 {1, TARGET_SIGNAL_TRAP
},
234 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
235 but I think SIGBUS is better, since the NMI is usually activated
236 as a result of a memory parity check failure. */
237 {2, TARGET_SIGNAL_BUS
},
238 {3, TARGET_SIGNAL_TRAP
},
239 {4, TARGET_SIGNAL_FPE
},
240 {5, TARGET_SIGNAL_SEGV
},
241 {6, TARGET_SIGNAL_ILL
},
242 {7, TARGET_SIGNAL_EMT
}, /* no-coprocessor exception */
243 {8, TARGET_SIGNAL_SEGV
},
244 {9, TARGET_SIGNAL_SEGV
},
245 {10, TARGET_SIGNAL_BUS
},
246 {11, TARGET_SIGNAL_SEGV
},
247 {12, TARGET_SIGNAL_SEGV
},
248 {13, TARGET_SIGNAL_SEGV
},
249 {14, TARGET_SIGNAL_SEGV
},
250 {16, TARGET_SIGNAL_FPE
},
251 {17, TARGET_SIGNAL_BUS
},
252 {31, TARGET_SIGNAL_ILL
},
253 {0x1b, TARGET_SIGNAL_INT
},
254 {0x75, TARGET_SIGNAL_FPE
},
255 {0x78, TARGET_SIGNAL_ALRM
},
256 {0x79, TARGET_SIGNAL_INT
},
257 {0x7a, TARGET_SIGNAL_QUIT
},
258 {-1, TARGET_SIGNAL_LAST
}
262 enum target_signal gdb_sig
;
265 {TARGET_SIGNAL_0
, -1},
266 {TARGET_SIGNAL_ILL
, 6}, /* Invalid Opcode */
267 {TARGET_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
268 {TARGET_SIGNAL_SEGV
, 13}, /* GPF */
269 {TARGET_SIGNAL_BUS
, 17}, /* Alignment Check */
270 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
272 {TARGET_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
273 {TARGET_SIGNAL_FPE
, 0x75},
274 {TARGET_SIGNAL_INT
, 0x79},
275 {TARGET_SIGNAL_QUIT
, 0x7a},
276 {TARGET_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
277 {TARGET_SIGNAL_PROF
, 0x78},
278 {TARGET_SIGNAL_LAST
, -1}
282 go32_open (char *name
, int from_tty
)
284 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
288 go32_close (int quitting
)
293 go32_attach (char *args
, int from_tty
)
296 You cannot attach to a running program on this platform.\n\
297 Use the `run' command to run DJGPP programs.");
301 go32_detach (char *args
, int from_tty
)
305 static int resume_is_step
;
306 static int resume_signal
= -1;
309 go32_resume (int pid
, int step
, enum target_signal siggnal
)
313 resume_is_step
= step
;
315 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= TARGET_SIGNAL_TRAP
)
317 for (i
= 0, resume_signal
= -1;
318 excepn_map
[i
].gdb_sig
!= TARGET_SIGNAL_LAST
; i
++)
319 if (excepn_map
[i
].gdb_sig
== siggnal
)
321 resume_signal
= excepn_map
[i
].djgpp_excepno
;
324 if (resume_signal
== -1)
325 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
326 target_signal_to_name (siggnal
));
330 static char child_cwd
[FILENAME_MAX
];
333 go32_wait (int pid
, struct target_waitstatus
*status
)
336 unsigned char saved_opcode
;
337 unsigned long INT3_addr
= 0;
338 int stepping_over_INT
= 0;
340 a_tss
.tss_eflags
&= 0xfeff; /* reset the single-step flag (TF) */
343 /* If the next instruction is INT xx or INTO, we need to handle
344 them specially. Intel manuals say that these instructions
345 reset the single-step flag (a.k.a. TF). However, it seems
346 that, at least in the DPMI environment, and at least when
347 stepping over the DPMI interrupt 31h, the problem is having
348 TF set at all when INT 31h is executed: the debuggee either
349 crashes (and takes the system with it) or is killed by a
352 So we need to emulate single-step mode: we put an INT3 opcode
353 right after the INT xx instruction, let the debuggee run
354 until it hits INT3 and stops, then restore the original
355 instruction which we overwrote with the INT3 opcode, and back
356 up the debuggee's EIP to that instruction. */
357 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
358 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
360 unsigned char INT3_opcode
= 0xCC;
363 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
364 stepping_over_INT
= 1;
365 read_child (INT3_addr
, &saved_opcode
, 1);
366 write_child (INT3_addr
, &INT3_opcode
, 1);
369 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
372 /* The special value FFFFh in tss_trap indicates to run_child that
373 tss_irqn holds a signal to be delivered to the debuggee. */
374 if (resume_signal
<= -1)
377 a_tss
.tss_irqn
= 0xff;
381 a_tss
.tss_trap
= 0xffff; /* run_child looks for this */
382 a_tss
.tss_irqn
= resume_signal
;
385 /* The child might change working directory behind our back. The
386 GDB users won't like the side effects of that when they work with
387 relative file names, and GDB might be confused by its current
388 directory not being in sync with the truth. So we always make a
389 point of changing back to where GDB thinks is its cwd, when we
390 return control to the debugger, but restore child's cwd before we
392 /* Initialize child_cwd, before the first call to run_child and not
393 in the initialization, so the child get also the changed directory
394 set with the gdb-command "cd ..." */
396 /* Initialize child's cwd with the current one. */
397 getcwd (child_cwd
, sizeof (child_cwd
));
401 #if __DJGPP_MINOR__ < 3
405 #if __DJGPP_MINOR__ < 3
409 /* Did we step over an INT xx instruction? */
410 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
412 /* Restore the original opcode. */
413 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction */
414 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
415 /* Simulate a TRAP exception. */
417 a_tss
.tss_eflags
|= 0x0100;
420 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
421 chdir (current_directory
);
423 if (a_tss
.tss_irqn
== 0x21)
425 status
->kind
= TARGET_WAITKIND_EXITED
;
426 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
430 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
431 status
->kind
= TARGET_WAITKIND_STOPPED
;
432 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
434 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
436 #if __DJGPP_MINOR__ < 3
437 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
439 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
441 status
->value
.sig
= sig_map
[i
].gdb_sig
;
451 fetch_register (int regno
)
453 if (regno
< FP0_REGNUM
)
454 supply_register (regno
, (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
455 else if (regno
<= LAST_FPU_CTRL_REGNUM
)
456 i387_supply_register (regno
, (char *) &npx
);
458 internal_error (__FILE__
, __LINE__
,
459 "Invalid register no. %d in fetch_register.", regno
);
463 go32_fetch_registers (int regno
)
466 fetch_register (regno
);
469 for (regno
= 0; regno
< FP0_REGNUM
; regno
++)
470 fetch_register (regno
);
471 i387_supply_fsave ((char *) &npx
);
476 store_register (int regno
)
479 void *v
= (void *) register_buffer (regno
);
481 if (regno
< FP0_REGNUM
)
482 memcpy ((char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
,
483 v
, regno_mapping
[regno
].size
);
484 else if (regno
<= LAST_FPU_CTRL_REGNUM
)
485 i387_fill_fsave ((char *)&npx
, regno
);
487 internal_error (__FILE__
, __LINE__
,
488 "Invalid register no. %d in store_register.", regno
);
492 go32_store_registers (int regno
)
497 store_register (regno
);
500 for (r
= 0; r
< FP0_REGNUM
; r
++)
502 i387_fill_fsave ((char *) &npx
, -1);
507 go32_prepare_to_store (void)
512 go32_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
513 struct mem_attrib
*attrib
, struct target_ops
*target
)
517 if (write_child (memaddr
, myaddr
, len
))
528 if (read_child (memaddr
, myaddr
, len
))
539 static cmdline_t child_cmd
; /* parsed child's command line kept here */
542 go32_files_info (struct target_ops
*target
)
544 printf_unfiltered ("You are running a DJGPP V2 program.\n");
553 prog_has_started
= 0;
557 go32_kill_inferior (void)
559 redir_cmdline_delete (&child_cmd
);
562 unpush_target (&go32_ops
);
566 go32_create_inferior (char *exec_file
, char *args
, char **env
)
568 extern char **environ
;
571 char **env_save
= environ
;
573 /* If no exec file handed to us, get it from the exec-file command -- with
574 a good, common error message if none is specified. */
576 exec_file
= get_exec_file (1);
578 if (prog_has_started
)
581 go32_kill_inferior ();
586 /* Initialize child's cwd as empty to be initialized when starting
590 /* Init command line storage. */
591 if (redir_debug_init (&child_cmd
) == -1)
592 internal_error (__FILE__
, __LINE__
,
593 "Cannot allocate redirection storage: not enough memory.\n");
595 /* Parse the command line and create redirections. */
596 if (strpbrk (args
, "<>"))
598 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
599 args
= child_cmd
.command
;
601 error ("Syntax error in command line.");
604 child_cmd
.command
= xstrdup (args
);
606 cmdline
= (char *) alloca (strlen (args
) + 4);
607 cmdline
[0] = strlen (args
);
608 strcpy (cmdline
+ 1, args
);
609 cmdline
[strlen (args
) + 1] = 13;
613 if (v2loadimage (exec_file
, cmdline
, start_state
))
616 printf_unfiltered ("Load failed for image %s\n", exec_file
);
621 edi_init (start_state
);
622 #if __DJGPP_MINOR__ < 3
626 inferior_pid
= SOME_PID
;
627 push_target (&go32_ops
);
628 clear_proceed_status ();
629 insert_breakpoints ();
630 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
631 prog_has_started
= 1;
635 go32_mourn_inferior (void)
637 /* We need to make sure all the breakpoint enable bits in the DR7
638 register are reset when the inferior exits. Otherwise, if they
639 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
640 failure to set more watchpoints, and other calamities. It would
641 be nice if GDB itself would take care to remove all breakpoints
642 at all times, but it doesn't, probably under an assumption that
643 the OS cleans up when the debuggee exits. */
644 i386_cleanup_dregs ();
645 go32_kill_inferior ();
646 generic_mourn_inferior ();
655 /* Hardware watchpoint support. */
657 #define D_REGS edi.dr
658 #define CONTROL D_REGS[7]
659 #define STATUS D_REGS[6]
661 /* Pass the address ADDR to the inferior in the I'th debug register.
662 Here we just store the address in D_REGS, the watchpoint will be
663 actually set up when go32_wait runs the debuggee. */
665 go32_set_dr (int i
, CORE_ADDR addr
)
668 internal_error (__FILE__
, __LINE__
,
669 "Invalid register %d in go32_set_dr.\n", i
);
673 /* Pass the value VAL to the inferior in the DR7 debug control
674 register. Here we just store the address in D_REGS, the watchpoint
675 will be actually set up when go32_wait runs the debuggee. */
677 go32_set_dr7 (unsigned val
)
682 /* Get the value of the DR6 debug status register from the inferior.
683 Here we just return the value stored in D_REGS, as we've got it
684 from the last go32_wait call. */
691 /* Put the device open on handle FD into either raw or cooked
692 mode, return 1 if it was in raw mode, zero otherwise. */
695 device_mode (int fd
, int raw_p
)
697 int oldmode
, newmode
;
702 __dpmi_int (0x21, ®s
);
703 if (regs
.x
.flags
& 1)
705 newmode
= oldmode
= regs
.x
.dx
;
712 if (oldmode
& 0x80) /* Only for character dev */
716 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails */
717 __dpmi_int (0x21, ®s
);
718 if (regs
.x
.flags
& 1)
721 return (oldmode
& 0x20) == 0x20;
725 static int inf_mode_valid
= 0;
726 static int inf_terminal_mode
;
728 /* This semaphore is needed because, amazingly enough, GDB calls
729 target.to_terminal_ours more than once after the inferior stops.
730 But we need the information from the first call only, since the
731 second call will always see GDB's own cooked terminal. */
732 static int terminal_is_ours
= 1;
735 go32_terminal_init (void)
737 inf_mode_valid
= 0; /* reinitialize, in case they are restarting child */
738 terminal_is_ours
= 1;
742 go32_terminal_info (char *args
, int from_tty
)
744 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
746 ? "default" : inf_terminal_mode
? "raw" : "cooked");
748 #if __DJGPP_MINOR__ > 2
749 if (child_cmd
.redirection
)
753 for (i
= 0; i
< DBG_HANDLES
; i
++)
755 if (child_cmd
.redirection
[i
]->file_name
)
756 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
757 i
, child_cmd
.redirection
[i
]->file_name
);
758 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
760 ("\tFile handle %d appears to be closed by inferior.\n", i
);
761 /* Mask off the raw/cooked bit when comparing device info words. */
762 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
763 != (_get_dev_info (i
) & 0xdf))
765 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
772 go32_terminal_inferior (void)
774 /* Redirect standard handles as child wants them. */
776 if (redir_to_child (&child_cmd
) == -1)
778 redir_to_debugger (&child_cmd
);
779 error ("Cannot redirect standard handles for program: %s.",
782 /* set the console device of the inferior to whatever mode
783 (raw or cooked) we found it last time */
784 if (terminal_is_ours
)
787 device_mode (0, inf_terminal_mode
);
788 terminal_is_ours
= 0;
793 go32_terminal_ours (void)
795 /* Switch to cooked mode on the gdb terminal and save the inferior
796 terminal mode to be restored when it is resumed */
797 if (!terminal_is_ours
)
799 inf_terminal_mode
= device_mode (0, 0);
800 if (inf_terminal_mode
!= -1)
803 /* If device_mode returned -1, we don't know what happens with
804 handle 0 anymore, so make the info invalid. */
806 terminal_is_ours
= 1;
808 /* Restore debugger's standard handles. */
810 if (redir_to_debugger (&child_cmd
) == -1)
812 redir_to_child (&child_cmd
);
813 error ("Cannot redirect standard handles for debugger: %s.",
822 go32_ops
.to_shortname
= "djgpp";
823 go32_ops
.to_longname
= "djgpp target process";
825 "Program loaded by djgpp, when gdb is used as an external debugger";
826 go32_ops
.to_open
= go32_open
;
827 go32_ops
.to_close
= go32_close
;
828 go32_ops
.to_attach
= go32_attach
;
829 go32_ops
.to_detach
= go32_detach
;
830 go32_ops
.to_resume
= go32_resume
;
831 go32_ops
.to_wait
= go32_wait
;
832 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
833 go32_ops
.to_store_registers
= go32_store_registers
;
834 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
835 go32_ops
.to_xfer_memory
= go32_xfer_memory
;
836 go32_ops
.to_files_info
= go32_files_info
;
837 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
838 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
839 go32_ops
.to_terminal_init
= go32_terminal_init
;
840 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
841 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
842 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
843 go32_ops
.to_terminal_info
= go32_terminal_info
;
844 go32_ops
.to_kill
= go32_kill_inferior
;
845 go32_ops
.to_create_inferior
= go32_create_inferior
;
846 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
847 go32_ops
.to_can_run
= go32_can_run
;
848 go32_ops
.to_stop
= go32_stop
;
849 go32_ops
.to_stratum
= process_stratum
;
850 go32_ops
.to_has_all_memory
= 1;
851 go32_ops
.to_has_memory
= 1;
852 go32_ops
.to_has_stack
= 1;
853 go32_ops
.to_has_registers
= 1;
854 go32_ops
.to_has_execution
= 1;
855 go32_ops
.to_magic
= OPS_MAGIC
;
857 /* Initialize child's cwd as empty to be initialized when starting
861 /* Initialize child's command line storage. */
862 if (redir_debug_init (&child_cmd
) == -1)
863 internal_error (__FILE__
, __LINE__
,
864 "Cannot allocate redirection storage: not enough memory.\n");
866 /* We are always processing GCC-compiled programs. */
867 processing_gcc_compilation
= 2;
871 _initialize_go32_nat (void)
874 add_target (&go32_ops
);
887 tcsetpgrp (int fd
, pid_t pgid
)
889 if (isatty (fd
) && pgid
== SOME_PID
)
891 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;