1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright 1997, 1999 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"
32 #include <stdio.h> /* required for __DJGPP_MINOR__ */
39 #include <debug/v2load.h>
40 #include <debug/dbgcom.h>
41 #if __DJGPP_MINOR__ > 2
42 #include <debug/redir.h>
45 #if __DJGPP_MINOR__ < 3
46 /* This code will be provided from DJGPP 2.03 on. Until then I code it
54 unsigned short exponent:15;
55 unsigned short sign:1;
74 static void save_npx (void); /* Save the FPU of the debugged program */
75 static void load_npx (void); /* Restore the FPU of the debugged program */
77 /* ------------------------------------------------------------------------- */
78 /* Store the contents of the NPX in the global variable `npx'. */
106 /* ------------------------------------------------------------------------- */
107 /* Reload the contents of the NPX from the global variable `npx'. */
112 asm ("frstor %0":"=m" (npx));
114 /* ------------------------------------------------------------------------- */
115 /* Stubs for the missing redirection functions. */
121 void redir_cmdline_delete (cmdline_t *ptr) {ptr->redirected = 0;}
122 int redir_cmdline_parse (const char *args, cmdline_t *ptr)
126 int redir_to_child (cmdline_t *ptr)
130 int redir_to_debugger (cmdline_t *ptr)
134 int redir_debug_init (cmdline_t *ptr) { return 0; }
135 #endif /* __DJGPP_MINOR < 3 */
137 extern void _initialize_go32_nat (void);
139 typedef enum { wp_insert, wp_remove, wp_count } wp_op;
141 /* This holds the current reference counts for each debug register. */
142 static int dr_ref_count[4];
144 extern char **environ;
148 static int prog_has_started = 0;
149 static void go32_open (char *name, int from_tty);
150 static void go32_close (int quitting);
151 static void go32_attach (char *args, int from_tty);
152 static void go32_detach (char *args, int from_tty);
153 static void go32_resume (int pid, int step, enum target_signal siggnal);
154 static int go32_wait (int pid, struct target_waitstatus *status);
155 static void go32_fetch_registers (int regno);
156 static void store_register (int regno);
157 static void go32_store_registers (int regno);
158 static void go32_prepare_to_store (void);
159 static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
160 int write, struct target_ops *target);
161 static void go32_files_info (struct target_ops *target);
162 static void go32_stop (void);
163 static void go32_kill_inferior (void);
164 static void go32_create_inferior (char *exec_file, char *args, char **env);
165 static void cleanup_dregs (void);
166 static void go32_mourn_inferior (void);
167 static int go32_can_run (void);
168 static int go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
170 static int go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
172 static int go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr,
173 CORE_ADDR addr, int len, int rw);
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 ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
284 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
288 go32_close (int quitting ATTRIBUTE_UNUSED)
293 go32_attach (char *args ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
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 ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
305 static int resume_is_step;
306 static int resume_signal = -1;
309 go32_resume (int pid ATTRIBUTE_UNUSED, 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 ATTRIBUTE_UNUSED, 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
394 #if __DJGPP_MINOR__ < 3
398 #if __DJGPP_MINOR__ < 3
402 /* Did we step over an INT xx instruction? */
403 if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
405 /* Restore the original opcode. */
406 a_tss.tss_eip--; /* EIP points *after* the INT3 instruction */
407 write_child (a_tss.tss_eip, &saved_opcode, 1);
408 /* Simulate a TRAP exception. */
410 a_tss.tss_eflags |= 0x0100;
413 getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
414 chdir (current_directory);
416 if (a_tss.tss_irqn == 0x21)
418 status->kind = TARGET_WAITKIND_EXITED;
419 status->value.integer = a_tss.tss_eax & 0xff;
423 status->value.sig = TARGET_SIGNAL_UNKNOWN;
424 status->kind = TARGET_WAITKIND_STOPPED;
425 for (i = 0; sig_map[i].go32_sig != -1; i++)
427 if (a_tss.tss_irqn == sig_map[i].go32_sig)
429 #if __DJGPP_MINOR__ < 3
430 if ((status->value.sig = sig_map[i].gdb_sig) !=
432 status->kind = TARGET_WAITKIND_SIGNALLED;
434 status->value.sig = sig_map[i].gdb_sig;
444 go32_fetch_registers (int regno)
447 int end_reg = regno + 1; /* just one reg initially */
449 if (regno < 0) /* do the all registers */
451 regno = 0; /* start at first register */
452 /* # regs in table */
453 end_reg = sizeof (regno_mapping) / sizeof (regno_mapping[0]);
456 for (; regno < end_reg; regno++)
459 supply_register (regno,
460 (char *) &a_tss + regno_mapping[regno].tss_ofs);
462 supply_register (regno,
463 (char *) &npx.reg[regno_mapping[regno].tss_ofs]);
468 switch (regno_mapping[regno].size)
471 regval = *(unsigned short *)
472 ((char *) &npx + regno_mapping[regno].tss_ofs);
474 if (regno == FOP_REGNUM && regval)
475 /* Feature: restore the 5 bits of the opcode
476 stripped by FSAVE/FNSAVE. */
480 regval = *(unsigned *)
481 ((char *) &npx + regno_mapping[regno].tss_ofs);
485 Invalid native size for register no. %d in go32_fetch_register.", regno);
487 supply_register (regno, (char *) ®val);
490 internal_error ("Invalid register no. %d in go32_fetch_register.",
496 store_register (int regno)
499 void *v = (void *) ®isters[REGISTER_BYTE (regno)];
502 rp = (char *) &a_tss + regno_mapping[regno].tss_ofs;
504 rp = (char *) &npx.reg[regno_mapping[regno].tss_ofs];
506 rp = (char *) &npx + regno_mapping[regno].tss_ofs;
508 internal_error ("Invalid register no. %d in store_register.", regno);
509 memcpy (rp, v, regno_mapping[regno].size);
510 if (regno == FOP_REGNUM)
511 *(short *)rp &= 0x07ff; /* strip high 5 bits, in case they added them */
515 go32_store_registers (int regno)
520 store_register (regno);
523 for (r = 0; r < sizeof (regno_mapping) / sizeof (regno_mapping[0]); r++)
529 go32_prepare_to_store (void)
534 go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
535 struct target_ops *target ATTRIBUTE_UNUSED)
539 if (write_child (memaddr, myaddr, len))
550 if (read_child (memaddr, myaddr, len))
561 static cmdline_t child_cmd; /* parsed child's command line kept here */
564 go32_files_info (struct target_ops *target ATTRIBUTE_UNUSED)
566 printf_unfiltered ("You are running a DJGPP V2 program.\n");
575 prog_has_started = 0;
579 go32_kill_inferior (void)
581 redir_cmdline_delete (&child_cmd);
584 unpush_target (&go32_ops);
588 go32_create_inferior (char *exec_file, char *args, char **env)
592 char **env_save = environ;
594 /* If no exec file handed to us, get it from the exec-file command -- with
595 a good, common error message if none is specified. */
597 exec_file = get_exec_file (1);
599 if (prog_has_started)
602 go32_kill_inferior ();
606 /* Init command line storage. */
607 if (redir_debug_init (&child_cmd) == -1)
608 internal_error ("Cannot allocate redirection storage: not enough memory.\n");
610 /* Parse the command line and create redirections. */
611 if (strpbrk (args, "<>"))
613 if (redir_cmdline_parse (args, &child_cmd) == 0)
614 args = child_cmd.command;
616 error ("Syntax error in command line.");
619 child_cmd.command = xstrdup (args);
621 cmdline = (char *) alloca (strlen (args) + 4);
622 cmdline[0] = strlen (args);
623 strcpy (cmdline + 1, args);
624 cmdline[strlen (args) + 1] = 13;
628 if (v2loadimage (exec_file, cmdline, start_state))
631 printf_unfiltered ("Load failed for image %s\n", exec_file);
636 edi_init (start_state);
637 #if __DJGPP_MINOR__ < 3
641 inferior_pid = SOME_PID;
642 push_target (&go32_ops);
643 clear_proceed_status ();
644 insert_breakpoints ();
645 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
646 prog_has_started = 1;
650 go32_mourn_inferior (void)
652 /* We need to make sure all the breakpoint enable bits in the DR7
653 register are reset when the inferior exits. Otherwise, if they
654 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
655 failure to set more watchpoints, and other calamities. It would
656 be nice if GDB itself would take care to remove all breakpoints
657 at all times, but it doesn't, probably under an assumption that
658 the OS cleans up when the debuggee exits. */
660 go32_kill_inferior ();
661 generic_mourn_inferior ();
670 /* Hardware watchpoint support. */
674 #define DR_ENABLE_SIZE 2
675 #define DR_LOCAL_ENABLE_SHIFT 0
676 #define DR_GLOBAL_ENABLE_SHIFT 1
677 #define DR_LOCAL_SLOWDOWN 0x100
678 #define DR_GLOBAL_SLOWDOWN 0x200
679 #define DR_CONTROL_SHIFT 16
680 #define DR_CONTROL_SIZE 4
681 #define DR_RW_READWRITE 0x3
682 #define DR_RW_WRITE 0x1
683 #define DR_CONTROL_MASK 0xf
684 #define DR_ENABLE_MASK 0x3
689 #define D_REGS edi.dr
690 #define CONTROL D_REGS[DR_CONTROL]
691 #define STATUS D_REGS[DR_STATUS]
693 #define IS_REG_FREE(index) \
694 (!(CONTROL & (3 << (DR_ENABLE_SIZE * (index)))))
696 #define LOCAL_ENABLE_REG(index) \
697 (CONTROL |= (1 << (DR_LOCAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
699 #define GLOBAL_ENABLE_REG(index) \
700 (CONTROL |= (1 << (DR_GLOBAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
702 #define DISABLE_REG(index) \
703 (CONTROL &= ~(3 << (DR_ENABLE_SIZE * (index))))
705 #define SET_LOCAL_EXACT() \
706 (CONTROL |= DR_LOCAL_SLOWDOWN)
708 #define SET_GLOBAL_EXACT() \
709 (CONTROL |= DR_GLOBAL_SLOWDOWN)
711 #define RESET_LOCAL_EXACT() \
712 (CONTROL &= ~(DR_LOCAL_SLOWDOWN))
714 #define RESET_GLOBAL_EXACT() \
715 (CONTROL &= ~(DR_GLOBAL_SLOWDOWN))
717 #define SET_BREAK(index,address) \
719 CONTROL &= ~(DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index)));\
720 D_REGS[index] = address;\
721 dr_ref_count[index]++;\
724 #define SET_WATCH(index,address,rw,len) \
726 SET_BREAK(index,address);\
727 CONTROL |= ((len)|(rw)) << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index));\
730 #define IS_WATCH(index) \
731 (CONTROL & (DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE*(index))))
733 #define WATCH_HIT(index) ((STATUS & (1 << (index))) && IS_WATCH(index))
735 #define DR_DEF(index) \
736 ((CONTROL >> (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index))) & 0x0f)
739 #if 0 /* use debugging macro */
740 #define SHOW_DR(text,len) \
742 if (!getenv ("GDB_SHOW_DR")) break; \
743 fprintf(stderr,"%08x %08x ",edi.dr[7],edi.dr[6]); \
744 fprintf(stderr,"%08x %d %08x %d ", \
745 edi.dr[0],dr_ref_count[0],edi.dr[1],dr_ref_count[1]); \
746 fprintf(stderr,"%08x %d %08x %d ", \
747 edi.dr[2],dr_ref_count[2],edi.dr[3],dr_ref_count[3]); \
748 fprintf(stderr,(len)?"(%s:%d)\n":"(%s)\n",#text,len); \
751 #define SHOW_DR(text,len) do {} while (0)
761 for (i = 0; i < 4; i++)
768 /* Insert a watchpoint. */
771 go32_insert_watchpoint (int pid ATTRIBUTE_UNUSED, CORE_ADDR addr,
774 int ret = go32_insert_aligned_watchpoint (addr, addr, len, rw);
776 SHOW_DR (insert_watch, len);
781 go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
785 int read_write_bits, len_bits;
787 /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
788 However, x86 doesn't support read-only data breakpoints. */
789 read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE;
803 /* The debug registers only have 2 bits for the length, so
804 so this value will always fail the loop below. */
808 /* Look for an occupied debug register with the same address and the
809 same RW and LEN definitions. If we find one, we can use it for
810 this watchpoint as well (and save a register). */
811 for (i = 0; i < 4; i++)
813 if (!IS_REG_FREE (i) && D_REGS[i] == addr
814 && DR_DEF (i) == (unsigned)(len_bits | read_write_bits))
821 /* Look for a free debug register. */
822 for (i = 0; i <= 3; i++)
828 /* No more debug registers! */
835 return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr,
841 return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr,
845 return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr, len, rw);
847 SET_WATCH (i, addr, read_write_bits, len_bits);
848 LOCAL_ENABLE_REG (i);
855 go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr, CORE_ADDR addr,
860 int rv = 0, status = 0;
862 static int size_try_array[16] =
864 1, 1, 1, 1, /* trying size one */
865 2, 1, 2, 1, /* trying size two */
866 2, 1, 2, 1, /* trying size three */
867 4, 1, 2, 1 /* trying size four */
873 /* Four is the maximum length for 386. */
874 size = (len > 4) ? 3 : len - 1;
875 size = size_try_array[size * 4 + align];
876 if (what == wp_insert)
877 status = go32_insert_aligned_watchpoint (waddr, addr, size, rw);
878 else if (what == wp_remove)
879 status = go32_remove_aligned_watchpoint (waddr, addr, size, rw);
880 else if (what == wp_count)
884 /* We keep the loop going even after a failure, because some of
885 the other aligned watchpoints might still succeed, e.g. if
886 they watch addresses that are already watched, and thus just
887 increment the reference counts of occupied debug registers.
888 If we break out of the loop too early, we could cause those
889 addresses watched by other watchpoints to be disabled when
890 GDB reacts to our failure to insert this watchpoint and tries
900 /* Remove a watchpoint. */
903 go32_remove_watchpoint (int pid ATTRIBUTE_UNUSED, CORE_ADDR addr,
906 int ret = go32_remove_aligned_watchpoint (addr, addr, len, rw);
908 SHOW_DR (remove_watch, len);
913 go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
917 int read_write_bits, len_bits;
919 /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
920 However, x86 doesn't support read-only data breakpoints. */
921 read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE;
935 /* The debug registers only have 2 bits for the length, so
936 so this value will always fail the loop below. */
943 return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
949 return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
953 return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr, len, rw);
955 for (i = 0; i <= 3; i++)
957 if (!IS_REG_FREE (i) && D_REGS[i] == addr
958 && DR_DEF (i) == (unsigned)(len_bits | read_write_bits))
961 if (dr_ref_count[i] == 0)
965 RESET_LOCAL_EXACT ();
966 RESET_GLOBAL_EXACT ();
971 /* Can we use debug registers to watch a region whose address is ADDR
972 and whose length is LEN bytes? */
975 go32_region_ok_for_watchpoint (CORE_ADDR addr, int len)
977 /* Compute how many aligned watchpoints we would need to cover this
979 int nregs = go32_handle_nonaligned_watchpoint (wp_count, addr, addr, len, 0);
981 return nregs <= 4 ? 1 : 0;
984 /* Check if stopped by a data watchpoint. If so, return the address
985 whose access triggered the watchpoint. */
988 go32_stopped_by_watchpoint (int pid ATTRIBUTE_UNUSED, int data_watchpoint)
993 status = edi.dr[DR_STATUS];
994 SHOW_DR (stopped_by, 0);
995 for (i = 0; i <= 3; i++)
997 if (WATCH_HIT (i) && data_watchpoint)
1007 /* Remove a breakpoint. */
1010 go32_remove_hw_breakpoint (CORE_ADDR addr, void *shadow ATTRIBUTE_UNUSED)
1013 for (i = 0; i <= 3; i++)
1015 if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
1018 if (dr_ref_count[i] == 0)
1022 SHOW_DR (remove_hw, 0);
1027 go32_insert_hw_breakpoint (CORE_ADDR addr, void *shadow ATTRIBUTE_UNUSED)
1031 /* Look for an occupied debug register with the same address and the
1032 same RW and LEN definitions. If we find one, we can use it for
1033 this breakpoint as well (and save a register). */
1034 for (i = 0; i < 4; i++)
1036 if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
1039 SHOW_DR (insert_hw, 0);
1044 /* Look for a free debug register. */
1045 for (i = 0; i <= 3; i++)
1047 if (IS_REG_FREE (i))
1051 /* No more debug registers? */
1054 SET_BREAK (i, addr);
1055 LOCAL_ENABLE_REG (i);
1057 SHOW_DR (insert_hw, 0);
1059 return i < 4 ? 0 : -1;
1062 /* Put the device open on handle FD into either raw or cooked
1063 mode, return 1 if it was in raw mode, zero otherwise. */
1066 device_mode (int fd, int raw_p)
1068 int oldmode, newmode;
1073 __dpmi_int (0x21, ®s);
1074 if (regs.x.flags & 1)
1076 newmode = oldmode = regs.x.dx;
1083 if (oldmode & 0x80) /* Only for character dev */
1087 regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails */
1088 __dpmi_int (0x21, ®s);
1089 if (regs.x.flags & 1)
1092 return (oldmode & 0x20) == 0x20;
1096 static int inf_mode_valid = 0;
1097 static int inf_terminal_mode;
1099 /* This semaphore is needed because, amazingly enough, GDB calls
1100 target.to_terminal_ours more than once after the inferior stops.
1101 But we need the information from the first call only, since the
1102 second call will always see GDB's own cooked terminal. */
1103 static int terminal_is_ours = 1;
1106 go32_terminal_init (void)
1108 inf_mode_valid = 0; /* reinitialize, in case they are restarting child */
1109 terminal_is_ours = 1;
1113 go32_terminal_info (char *args ATTRIBUTE_UNUSED, int from_tty ATTRIBUTE_UNUSED)
1115 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
1117 ? "default" : inf_terminal_mode ? "raw" : "cooked");
1119 #if __DJGPP_MINOR__ > 2
1120 if (child_cmd.redirection)
1124 for (i = 0; i < DBG_HANDLES; i++)
1126 if (child_cmd.redirection[i]->file_name)
1127 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
1128 i, child_cmd.redirection[i]->file_name);
1129 else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
1131 ("\tFile handle %d appears to be closed by inferior.\n", i);
1132 /* Mask off the raw/cooked bit when comparing device info words. */
1133 else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
1134 != (_get_dev_info (i) & 0xdf))
1136 ("\tFile handle %d appears to be redirected by inferior.\n", i);
1143 go32_terminal_inferior (void)
1145 /* Redirect standard handles as child wants them. */
1147 if (redir_to_child (&child_cmd) == -1)
1149 redir_to_debugger (&child_cmd);
1150 error ("Cannot redirect standard handles for program: %s.",
1153 /* set the console device of the inferior to whatever mode
1154 (raw or cooked) we found it last time */
1155 if (terminal_is_ours)
1158 device_mode (0, inf_terminal_mode);
1159 terminal_is_ours = 0;
1164 go32_terminal_ours (void)
1166 /* Switch to cooked mode on the gdb terminal and save the inferior
1167 terminal mode to be restored when it is resumed */
1168 if (!terminal_is_ours)
1170 inf_terminal_mode = device_mode (0, 0);
1171 if (inf_terminal_mode != -1)
1174 /* If device_mode returned -1, we don't know what happens with
1175 handle 0 anymore, so make the info invalid. */
1177 terminal_is_ours = 1;
1179 /* Restore debugger's standard handles. */
1181 if (redir_to_debugger (&child_cmd) == -1)
1183 redir_to_child (&child_cmd);
1184 error ("Cannot redirect standard handles for debugger: %s.",
1191 init_go32_ops (void)
1193 go32_ops.to_shortname = "djgpp";
1194 go32_ops.to_longname = "djgpp target process";
1196 "Program loaded by djgpp, when gdb is used as an external debugger";
1197 go32_ops.to_open = go32_open;
1198 go32_ops.to_close = go32_close;
1199 go32_ops.to_attach = go32_attach;
1200 go32_ops.to_detach = go32_detach;
1201 go32_ops.to_resume = go32_resume;
1202 go32_ops.to_wait = go32_wait;
1203 go32_ops.to_fetch_registers = go32_fetch_registers;
1204 go32_ops.to_store_registers = go32_store_registers;
1205 go32_ops.to_prepare_to_store = go32_prepare_to_store;
1206 go32_ops.to_xfer_memory = go32_xfer_memory;
1207 go32_ops.to_files_info = go32_files_info;
1208 go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
1209 go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
1210 go32_ops.to_terminal_init = go32_terminal_init;
1211 go32_ops.to_terminal_inferior = go32_terminal_inferior;
1212 go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
1213 go32_ops.to_terminal_ours = go32_terminal_ours;
1214 go32_ops.to_terminal_info = go32_terminal_info;
1215 go32_ops.to_kill = go32_kill_inferior;
1216 go32_ops.to_create_inferior = go32_create_inferior;
1217 go32_ops.to_mourn_inferior = go32_mourn_inferior;
1218 go32_ops.to_can_run = go32_can_run;
1219 go32_ops.to_stop = go32_stop;
1220 go32_ops.to_stratum = process_stratum;
1221 go32_ops.to_has_all_memory = 1;
1222 go32_ops.to_has_memory = 1;
1223 go32_ops.to_has_stack = 1;
1224 go32_ops.to_has_registers = 1;
1225 go32_ops.to_has_execution = 1;
1226 go32_ops.to_magic = OPS_MAGIC;
1228 /* Initialize child's cwd with the current one. */
1229 getcwd (child_cwd, sizeof (child_cwd));
1231 /* Initialize child's command line storage. */
1232 if (redir_debug_init (&child_cmd) == -1)
1233 internal_error ("Cannot allocate redirection storage: not enough memory.\n");
1235 /* We are always processing GCC-compiled programs. */
1236 processing_gcc_compilation = 2;
1240 _initialize_go32_nat (void)
1243 add_target (&go32_ops);
1256 tcsetpgrp (int fd, pid_t pgid)
1258 if (isatty (fd) && pgid == SOME_PID)
1260 errno = pgid == SOME_PID ? ENOTTY : ENOSYS;