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 (int pid
, int step
, enum target_signal siggnal
);
168 static int go32_wait (int pid
, struct target_waitstatus
*status
);
169 static void go32_fetch_registers (int regno
);
170 static void store_register (int regno
);
171 static void go32_store_registers (int regno
);
172 static void go32_prepare_to_store (void);
173 static int go32_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
175 struct mem_attrib
*attrib
,
176 struct target_ops
*target
);
177 static void go32_files_info (struct target_ops
*target
);
178 static void go32_stop (void);
179 static void go32_kill_inferior (void);
180 static void go32_create_inferior (char *exec_file
, char *args
, char **env
);
181 static void go32_mourn_inferior (void);
182 static int go32_can_run (void);
184 static struct target_ops go32_ops
;
185 static void go32_terminal_init (void);
186 static void go32_terminal_inferior (void);
187 static void go32_terminal_ours (void);
189 #define r_ofs(x) (offsetof(TSS,x))
198 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
199 {r_ofs (tss_ecx
), 4},
200 {r_ofs (tss_edx
), 4},
201 {r_ofs (tss_ebx
), 4},
202 {r_ofs (tss_esp
), 4},
203 {r_ofs (tss_ebp
), 4},
204 {r_ofs (tss_esi
), 4},
205 {r_ofs (tss_edi
), 4},
206 {r_ofs (tss_eip
), 4},
207 {r_ofs (tss_eflags
), 4},
214 {0, 10}, /* 8 FP registers, from npx.reg[] */
222 /* The order of the next 7 registers must be consistent
223 with their numbering in config/i386/tm-i386.h, which see. */
224 {0, 2}, /* control word, from npx */
225 {4, 2}, /* status word, from npx */
226 {8, 2}, /* tag word, from npx */
227 {16, 2}, /* last FP exception CS from npx */
228 {12, 4}, /* last FP exception EIP from npx */
229 {24, 2}, /* last FP exception operand selector from npx */
230 {20, 4}, /* last FP exception operand offset from npx */
231 {18, 2} /* last FP opcode from npx */
237 enum target_signal gdb_sig
;
241 {0, TARGET_SIGNAL_FPE
},
242 {1, TARGET_SIGNAL_TRAP
},
243 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
244 but I think SIGBUS is better, since the NMI is usually activated
245 as a result of a memory parity check failure. */
246 {2, TARGET_SIGNAL_BUS
},
247 {3, TARGET_SIGNAL_TRAP
},
248 {4, TARGET_SIGNAL_FPE
},
249 {5, TARGET_SIGNAL_SEGV
},
250 {6, TARGET_SIGNAL_ILL
},
251 {7, TARGET_SIGNAL_EMT
}, /* no-coprocessor exception */
252 {8, TARGET_SIGNAL_SEGV
},
253 {9, TARGET_SIGNAL_SEGV
},
254 {10, TARGET_SIGNAL_BUS
},
255 {11, TARGET_SIGNAL_SEGV
},
256 {12, TARGET_SIGNAL_SEGV
},
257 {13, TARGET_SIGNAL_SEGV
},
258 {14, TARGET_SIGNAL_SEGV
},
259 {16, TARGET_SIGNAL_FPE
},
260 {17, TARGET_SIGNAL_BUS
},
261 {31, TARGET_SIGNAL_ILL
},
262 {0x1b, TARGET_SIGNAL_INT
},
263 {0x75, TARGET_SIGNAL_FPE
},
264 {0x78, TARGET_SIGNAL_ALRM
},
265 {0x79, TARGET_SIGNAL_INT
},
266 {0x7a, TARGET_SIGNAL_QUIT
},
267 {-1, TARGET_SIGNAL_LAST
}
271 enum target_signal gdb_sig
;
274 {TARGET_SIGNAL_0
, -1},
275 {TARGET_SIGNAL_ILL
, 6}, /* Invalid Opcode */
276 {TARGET_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
277 {TARGET_SIGNAL_SEGV
, 13}, /* GPF */
278 {TARGET_SIGNAL_BUS
, 17}, /* Alignment Check */
279 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
281 {TARGET_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
282 {TARGET_SIGNAL_FPE
, 0x75},
283 {TARGET_SIGNAL_INT
, 0x79},
284 {TARGET_SIGNAL_QUIT
, 0x7a},
285 {TARGET_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
286 {TARGET_SIGNAL_PROF
, 0x78},
287 {TARGET_SIGNAL_LAST
, -1}
291 go32_open (char *name
, int from_tty
)
293 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
297 go32_close (int quitting
)
302 go32_attach (char *args
, int from_tty
)
305 You cannot attach to a running program on this platform.\n\
306 Use the `run' command to run DJGPP programs.");
310 go32_detach (char *args
, int from_tty
)
314 static int resume_is_step
;
315 static int resume_signal
= -1;
318 go32_resume (int pid
, int step
, enum target_signal siggnal
)
322 resume_is_step
= step
;
324 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= TARGET_SIGNAL_TRAP
)
326 for (i
= 0, resume_signal
= -1;
327 excepn_map
[i
].gdb_sig
!= TARGET_SIGNAL_LAST
; i
++)
328 if (excepn_map
[i
].gdb_sig
== siggnal
)
330 resume_signal
= excepn_map
[i
].djgpp_excepno
;
333 if (resume_signal
== -1)
334 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
335 target_signal_to_name (siggnal
));
339 static char child_cwd
[FILENAME_MAX
];
342 go32_wait (int pid
, struct target_waitstatus
*status
)
345 unsigned char saved_opcode
;
346 unsigned long INT3_addr
= 0;
347 int stepping_over_INT
= 0;
349 a_tss
.tss_eflags
&= 0xfeff; /* reset the single-step flag (TF) */
352 /* If the next instruction is INT xx or INTO, we need to handle
353 them specially. Intel manuals say that these instructions
354 reset the single-step flag (a.k.a. TF). However, it seems
355 that, at least in the DPMI environment, and at least when
356 stepping over the DPMI interrupt 31h, the problem is having
357 TF set at all when INT 31h is executed: the debuggee either
358 crashes (and takes the system with it) or is killed by a
361 So we need to emulate single-step mode: we put an INT3 opcode
362 right after the INT xx instruction, let the debuggee run
363 until it hits INT3 and stops, then restore the original
364 instruction which we overwrote with the INT3 opcode, and back
365 up the debuggee's EIP to that instruction. */
366 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
367 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
369 unsigned char INT3_opcode
= 0xCC;
372 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
373 stepping_over_INT
= 1;
374 read_child (INT3_addr
, &saved_opcode
, 1);
375 write_child (INT3_addr
, &INT3_opcode
, 1);
378 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
381 /* The special value FFFFh in tss_trap indicates to run_child that
382 tss_irqn holds a signal to be delivered to the debuggee. */
383 if (resume_signal
<= -1)
386 a_tss
.tss_irqn
= 0xff;
390 a_tss
.tss_trap
= 0xffff; /* run_child looks for this */
391 a_tss
.tss_irqn
= resume_signal
;
394 /* The child might change working directory behind our back. The
395 GDB users won't like the side effects of that when they work with
396 relative file names, and GDB might be confused by its current
397 directory not being in sync with the truth. So we always make a
398 point of changing back to where GDB thinks is its cwd, when we
399 return control to the debugger, but restore child's cwd before we
401 /* Initialize child_cwd, before the first call to run_child and not
402 in the initialization, so the child get also the changed directory
403 set with the gdb-command "cd ..." */
405 /* Initialize child's cwd with the current one. */
406 getcwd (child_cwd
, sizeof (child_cwd
));
410 #if __DJGPP_MINOR__ < 3
414 #if __DJGPP_MINOR__ < 3
418 /* Did we step over an INT xx instruction? */
419 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
421 /* Restore the original opcode. */
422 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction */
423 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
424 /* Simulate a TRAP exception. */
426 a_tss
.tss_eflags
|= 0x0100;
429 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
430 chdir (current_directory
);
432 if (a_tss
.tss_irqn
== 0x21)
434 status
->kind
= TARGET_WAITKIND_EXITED
;
435 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
439 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
440 status
->kind
= TARGET_WAITKIND_STOPPED
;
441 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
443 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
445 #if __DJGPP_MINOR__ < 3
446 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
448 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
450 status
->value
.sig
= sig_map
[i
].gdb_sig
;
460 fetch_register (int regno
)
462 if (regno
< FP0_REGNUM
)
463 supply_register (regno
, (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
464 else if (regno
<= LAST_FPU_CTRL_REGNUM
)
465 i387_supply_register (regno
, (char *) &npx
);
467 internal_error (__FILE__
, __LINE__
,
468 "Invalid register no. %d in fetch_register.", regno
);
472 go32_fetch_registers (int regno
)
475 fetch_register (regno
);
478 for (regno
= 0; regno
< FP0_REGNUM
; regno
++)
479 fetch_register (regno
);
480 i387_supply_fsave ((char *) &npx
);
485 store_register (int regno
)
488 void *v
= (void *) register_buffer (regno
);
490 if (regno
< FP0_REGNUM
)
491 memcpy ((char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
,
492 v
, regno_mapping
[regno
].size
);
493 else if (regno
<= LAST_FPU_CTRL_REGNUM
)
494 i387_fill_fsave ((char *)&npx
, regno
);
496 internal_error (__FILE__
, __LINE__
,
497 "Invalid register no. %d in store_register.", regno
);
501 go32_store_registers (int regno
)
506 store_register (regno
);
509 for (r
= 0; r
< FP0_REGNUM
; r
++)
511 i387_fill_fsave ((char *) &npx
, -1);
516 go32_prepare_to_store (void)
521 go32_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
522 struct mem_attrib
*attrib
, struct target_ops
*target
)
526 if (write_child (memaddr
, myaddr
, len
))
537 if (read_child (memaddr
, myaddr
, len
))
548 static cmdline_t child_cmd
; /* parsed child's command line kept here */
551 go32_files_info (struct target_ops
*target
)
553 printf_unfiltered ("You are running a DJGPP V2 program.\n");
562 prog_has_started
= 0;
566 go32_kill_inferior (void)
568 redir_cmdline_delete (&child_cmd
);
571 unpush_target (&go32_ops
);
575 go32_create_inferior (char *exec_file
, char *args
, char **env
)
577 extern char **environ
;
580 char **env_save
= environ
;
582 /* If no exec file handed to us, get it from the exec-file command -- with
583 a good, common error message if none is specified. */
585 exec_file
= get_exec_file (1);
587 if (prog_has_started
)
590 go32_kill_inferior ();
595 /* Initialize child's cwd as empty to be initialized when starting
599 /* Init command line storage. */
600 if (redir_debug_init (&child_cmd
) == -1)
601 internal_error (__FILE__
, __LINE__
,
602 "Cannot allocate redirection storage: not enough memory.\n");
604 /* Parse the command line and create redirections. */
605 if (strpbrk (args
, "<>"))
607 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
608 args
= child_cmd
.command
;
610 error ("Syntax error in command line.");
613 child_cmd
.command
= xstrdup (args
);
615 cmdline
= (char *) alloca (strlen (args
) + 4);
616 cmdline
[0] = strlen (args
);
617 strcpy (cmdline
+ 1, args
);
618 cmdline
[strlen (args
) + 1] = 13;
622 if (v2loadimage (exec_file
, cmdline
, start_state
))
625 printf_unfiltered ("Load failed for image %s\n", exec_file
);
630 edi_init (start_state
);
631 #if __DJGPP_MINOR__ < 3
635 inferior_pid
= SOME_PID
;
636 push_target (&go32_ops
);
637 clear_proceed_status ();
638 insert_breakpoints ();
639 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
640 prog_has_started
= 1;
644 go32_mourn_inferior (void)
646 /* We need to make sure all the breakpoint enable bits in the DR7
647 register are reset when the inferior exits. Otherwise, if they
648 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
649 failure to set more watchpoints, and other calamities. It would
650 be nice if GDB itself would take care to remove all breakpoints
651 at all times, but it doesn't, probably under an assumption that
652 the OS cleans up when the debuggee exits. */
653 i386_cleanup_dregs ();
654 go32_kill_inferior ();
655 generic_mourn_inferior ();
664 /* Hardware watchpoint support. */
666 #define D_REGS edi.dr
667 #define CONTROL D_REGS[7]
668 #define STATUS D_REGS[6]
670 /* Pass the address ADDR to the inferior in the I'th debug register.
671 Here we just store the address in D_REGS, the watchpoint will be
672 actually set up when go32_wait runs the debuggee. */
674 go32_set_dr (int i
, CORE_ADDR addr
)
677 internal_error (__FILE__
, __LINE__
,
678 "Invalid register %d in go32_set_dr.\n", i
);
682 /* Pass the value VAL to the inferior in the DR7 debug control
683 register. Here we just store the address in D_REGS, the watchpoint
684 will be actually set up when go32_wait runs the debuggee. */
686 go32_set_dr7 (unsigned val
)
691 /* Get the value of the DR6 debug status register from the inferior.
692 Here we just return the value stored in D_REGS, as we've got it
693 from the last go32_wait call. */
700 /* Put the device open on handle FD into either raw or cooked
701 mode, return 1 if it was in raw mode, zero otherwise. */
704 device_mode (int fd
, int raw_p
)
706 int oldmode
, newmode
;
711 __dpmi_int (0x21, ®s
);
712 if (regs
.x
.flags
& 1)
714 newmode
= oldmode
= regs
.x
.dx
;
721 if (oldmode
& 0x80) /* Only for character dev */
725 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails */
726 __dpmi_int (0x21, ®s
);
727 if (regs
.x
.flags
& 1)
730 return (oldmode
& 0x20) == 0x20;
734 static int inf_mode_valid
= 0;
735 static int inf_terminal_mode
;
737 /* This semaphore is needed because, amazingly enough, GDB calls
738 target.to_terminal_ours more than once after the inferior stops.
739 But we need the information from the first call only, since the
740 second call will always see GDB's own cooked terminal. */
741 static int terminal_is_ours
= 1;
744 go32_terminal_init (void)
746 inf_mode_valid
= 0; /* reinitialize, in case they are restarting child */
747 terminal_is_ours
= 1;
751 go32_terminal_info (char *args
, int from_tty
)
753 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
755 ? "default" : inf_terminal_mode
? "raw" : "cooked");
757 #if __DJGPP_MINOR__ > 2
758 if (child_cmd
.redirection
)
762 for (i
= 0; i
< DBG_HANDLES
; i
++)
764 if (child_cmd
.redirection
[i
]->file_name
)
765 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
766 i
, child_cmd
.redirection
[i
]->file_name
);
767 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
769 ("\tFile handle %d appears to be closed by inferior.\n", i
);
770 /* Mask off the raw/cooked bit when comparing device info words. */
771 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
772 != (_get_dev_info (i
) & 0xdf))
774 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
781 go32_terminal_inferior (void)
783 /* Redirect standard handles as child wants them. */
785 if (redir_to_child (&child_cmd
) == -1)
787 redir_to_debugger (&child_cmd
);
788 error ("Cannot redirect standard handles for program: %s.",
791 /* set the console device of the inferior to whatever mode
792 (raw or cooked) we found it last time */
793 if (terminal_is_ours
)
796 device_mode (0, inf_terminal_mode
);
797 terminal_is_ours
= 0;
802 go32_terminal_ours (void)
804 /* Switch to cooked mode on the gdb terminal and save the inferior
805 terminal mode to be restored when it is resumed */
806 if (!terminal_is_ours
)
808 inf_terminal_mode
= device_mode (0, 0);
809 if (inf_terminal_mode
!= -1)
812 /* If device_mode returned -1, we don't know what happens with
813 handle 0 anymore, so make the info invalid. */
815 terminal_is_ours
= 1;
817 /* Restore debugger's standard handles. */
819 if (redir_to_debugger (&child_cmd
) == -1)
821 redir_to_child (&child_cmd
);
822 error ("Cannot redirect standard handles for debugger: %s.",
831 go32_ops
.to_shortname
= "djgpp";
832 go32_ops
.to_longname
= "djgpp target process";
834 "Program loaded by djgpp, when gdb is used as an external debugger";
835 go32_ops
.to_open
= go32_open
;
836 go32_ops
.to_close
= go32_close
;
837 go32_ops
.to_attach
= go32_attach
;
838 go32_ops
.to_detach
= go32_detach
;
839 go32_ops
.to_resume
= go32_resume
;
840 go32_ops
.to_wait
= go32_wait
;
841 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
842 go32_ops
.to_store_registers
= go32_store_registers
;
843 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
844 go32_ops
.to_xfer_memory
= go32_xfer_memory
;
845 go32_ops
.to_files_info
= go32_files_info
;
846 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
847 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
848 go32_ops
.to_terminal_init
= go32_terminal_init
;
849 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
850 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
851 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
852 go32_ops
.to_terminal_info
= go32_terminal_info
;
853 go32_ops
.to_kill
= go32_kill_inferior
;
854 go32_ops
.to_create_inferior
= go32_create_inferior
;
855 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
856 go32_ops
.to_can_run
= go32_can_run
;
857 go32_ops
.to_stop
= go32_stop
;
858 go32_ops
.to_stratum
= process_stratum
;
859 go32_ops
.to_has_all_memory
= 1;
860 go32_ops
.to_has_memory
= 1;
861 go32_ops
.to_has_stack
= 1;
862 go32_ops
.to_has_registers
= 1;
863 go32_ops
.to_has_execution
= 1;
864 go32_ops
.to_magic
= OPS_MAGIC
;
866 /* Initialize child's cwd as empty to be initialized when starting
870 /* Initialize child's command line storage. */
871 if (redir_debug_init (&child_cmd
) == -1)
872 internal_error (__FILE__
, __LINE__
,
873 "Cannot allocate redirection storage: not enough memory.\n");
875 /* We are always processing GCC-compiled programs. */
876 processing_gcc_compilation
= 2;
880 _initialize_go32_nat (void)
883 add_target (&go32_ops
);
896 tcsetpgrp (int fd
, pid_t pgid
)
898 if (isatty (fd
) && pgid
== SOME_PID
)
900 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;