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. */
25 #include "frame.h" /* required by inferior.h */
31 #include "floatformat.h"
33 #include <stdio.h> /* required for __DJGPP_MINOR__ */
40 #include <debug/v2load.h>
41 #include <debug/dbgcom.h>
42 #if __DJGPP_MINOR__ > 2
43 #include <debug/redir.h>
46 #if __DJGPP_MINOR__ < 3
47 /* This code will be provided from DJGPP 2.03 on. Until then I code it
55 unsigned short exponent
:15;
56 unsigned short sign
:1;
75 static void save_npx (void); /* Save the FPU of the debugged program */
76 static void load_npx (void); /* Restore the FPU of the debugged program */
78 /* ------------------------------------------------------------------------- */
79 /* Store the contents of the NPX in the global variable `npx'. */
107 /* ------------------------------------------------------------------------- */
108 /* Reload the contents of the NPX from the global variable `npx'. */
113 asm ("frstor %0":"=m" (npx
));
115 /* ------------------------------------------------------------------------- */
116 /* Stubs for the missing redirection functions. */
122 void redir_cmdline_delete (cmdline_t
*ptr
) {ptr
->redirected
= 0;}
123 int redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
127 int redir_to_child (cmdline_t
*ptr
)
131 int redir_to_debugger (cmdline_t
*ptr
)
135 int redir_debug_init (cmdline_t
*ptr
) { return 0; }
136 #endif /* __DJGPP_MINOR < 3 */
138 extern void _initialize_go32_nat (void);
142 unsigned short control
;
144 unsigned short status
;
149 unsigned short code_seg
;
150 unsigned short opcode
;
151 unsigned long operand
;
152 unsigned short operand_seg
;
154 unsigned char regs
[8][10];
157 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
159 /* This holds the current reference counts for each debug register. */
160 static int dr_ref_count
[4];
162 extern char **environ
;
166 static int prog_has_started
= 0;
167 static void print_387_status (unsigned short status
, struct env387
*ep
);
168 static void go32_open (char *name
, int from_tty
);
169 static void go32_close (int quitting
);
170 static void go32_attach (char *args
, int from_tty
);
171 static void go32_detach (char *args
, int from_tty
);
172 static void go32_resume (int pid
, int step
, enum target_signal siggnal
);
173 static int go32_wait (int pid
, struct target_waitstatus
*status
);
174 static void go32_fetch_registers (int regno
);
175 static void store_register (int regno
);
176 static void go32_store_registers (int regno
);
177 static void go32_prepare_to_store (void);
178 static int go32_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
179 int write
, struct target_ops
*target
);
180 static void go32_files_info (struct target_ops
*target
);
181 static void go32_stop (void);
182 static void go32_kill_inferior (void);
183 static void go32_create_inferior (char *exec_file
, char *args
, char **env
);
184 static void cleanup_dregs (void);
185 static void go32_mourn_inferior (void);
186 static int go32_can_run (void);
187 static void ignore (void);
188 static void ignore2 (char *a
, int b
);
189 static int go32_insert_aligned_watchpoint (CORE_ADDR waddr
, CORE_ADDR addr
,
191 static int go32_remove_aligned_watchpoint (CORE_ADDR waddr
, CORE_ADDR addr
,
193 static int go32_handle_nonaligned_watchpoint (wp_op what
, CORE_ADDR waddr
,
194 CORE_ADDR addr
, int len
, int rw
);
196 static struct target_ops go32_ops
;
197 static void go32_terminal_init (void);
198 static void go32_terminal_inferior (void);
199 static void go32_terminal_ours (void);
202 print_387_status (unsigned short status
, struct env387
*ep
)
209 bothstatus
= ((status
!= 0) && (ep
->status
!= 0));
213 printf_unfiltered ("u: ");
214 print_387_status_word (status
);
220 printf_unfiltered ("e: ");
221 print_387_status_word (ep
->status
);
224 print_387_control_word (ep
->control
& 0xffff);
225 /* Other platforms say "last exception", but that's not true: the
226 FPU stores the last non-control instruction there. */
227 printf_unfiltered ("last FP instruction: ");
228 /* The ORing with D800h restores the upper 5 bits of the opcode that
229 are not stored by the FPU (since these bits are the same for all
230 floating-point instructions). */
231 printf_unfiltered ("opcode %s; ",
232 local_hex_string (ep
->opcode
? (ep
->opcode
|0xd800) : 0));
233 printf_unfiltered ("pc %s:", local_hex_string (ep
->code_seg
));
234 printf_unfiltered ("%s; ", local_hex_string (ep
->eip
));
235 printf_unfiltered ("operand %s", local_hex_string (ep
->operand_seg
));
236 printf_unfiltered (":%s\n", local_hex_string (ep
->operand
));
238 top
= (ep
->status
>> 11) & 7;
240 printf_unfiltered ("regno tag msb lsb value\n");
241 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
243 /* FNSAVE saves the FP registers in their logical TOP-relative
244 order, beginning with ST(0). Since we need to print them in
245 their physical order, we have to remap them. */
246 int regno
= fpreg
- top
;
252 printf_unfiltered ("%s %d: ", fpreg
== top
? "=>" : " ", fpreg
);
254 switch ((ep
->tag
>> (fpreg
* 2)) & 3)
257 printf_unfiltered ("valid ");
260 printf_unfiltered ("zero ");
263 /* All other versions of print_387_status use TRAP here, but I
264 think this is misleading, since Intel manuals say SPECIAL. */
265 printf_unfiltered ("special ");
268 printf_unfiltered ("empty ");
271 for (i
= 9; i
>= 0; i
--)
272 printf_unfiltered ("%02x", ep
->regs
[regno
][i
]);
274 REGISTER_CONVERT_TO_VIRTUAL (FP0_REGNUM
+regno
, builtin_type_long_double
,
275 &ep
->regs
[regno
], &val
);
277 printf_unfiltered (" %.19LG\n", val
);
282 i386_go32_float_info (void)
284 print_387_status (0, (struct env387
*) &npx
);
287 #define r_ofs(x) (offsetof(TSS,x))
296 r_ofs (tss_eax
), 4, /* normal registers, from a_tss */
305 r_ofs (tss_eflags
), 4,
312 0, 10, /* 8 FP registers, from npx.reg[] */
320 /* The order of the next 7 registers must be consistent
321 with their numbering in config/i386/tm-go32.h, which see. */
322 0, 2, /* control word, from npx */
323 4, 2, /* status word, from npx */
324 8, 2, /* tag word, from npx */
325 16, 2, /* last FP exception CS from npx */
326 24, 2, /* last FP exception operand selector from npx */
327 12, 4, /* last FP exception EIP from npx */
328 20, 4 /* last FP exception operand offset from npx */
338 0, TARGET_SIGNAL_FPE
,
339 1, TARGET_SIGNAL_TRAP
,
340 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
341 but I think SIGBUS is better, since the NMI is usually activated
342 as a result of a memory parity check failure. */
343 2, TARGET_SIGNAL_BUS
,
344 3, TARGET_SIGNAL_TRAP
,
345 4, TARGET_SIGNAL_FPE
,
346 5, TARGET_SIGNAL_SEGV
,
347 6, TARGET_SIGNAL_ILL
,
348 7, TARGET_SIGNAL_FPE
,
349 8, TARGET_SIGNAL_SEGV
,
350 9, TARGET_SIGNAL_SEGV
,
351 10, TARGET_SIGNAL_BUS
,
352 11, TARGET_SIGNAL_SEGV
,
353 12, TARGET_SIGNAL_SEGV
,
354 13, TARGET_SIGNAL_SEGV
,
355 14, TARGET_SIGNAL_SEGV
,
356 16, TARGET_SIGNAL_FPE
,
357 17, TARGET_SIGNAL_BUS
,
358 31, TARGET_SIGNAL_ILL
,
359 0x1b, TARGET_SIGNAL_INT
,
360 0x75, TARGET_SIGNAL_FPE
,
361 0x78, TARGET_SIGNAL_ALRM
,
362 0x79, TARGET_SIGNAL_INT
,
363 0x7a, TARGET_SIGNAL_QUIT
,
368 enum target_signal gdb_sig
;
372 TARGET_SIGNAL_ILL
, 6, /* Invalid Opcode */
373 TARGET_SIGNAL_EMT
, 7, /* triggers SIGNOFP */
374 TARGET_SIGNAL_SEGV
, 13, /* GPF */
375 TARGET_SIGNAL_BUS
, 17, /* Alignment Check */
376 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
378 TARGET_SIGNAL_TERM
, 0x1b, /* triggers Ctrl-Break type of SIGINT */
379 TARGET_SIGNAL_FPE
, 0x75,
380 TARGET_SIGNAL_INT
, 0x79,
381 TARGET_SIGNAL_QUIT
, 0x7a,
382 TARGET_SIGNAL_ALRM
, 0x78, /* triggers SIGTIMR */
383 TARGET_SIGNAL_PROF
, 0x78,
388 go32_open (char *name
, int from_tty
)
390 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
394 go32_close (int quitting
)
399 go32_attach (char *args
, int from_tty
)
402 You cannot attach to a running program on this platform.\n\
403 Use the `run' command to run DJGPP programs.");
407 go32_detach (char *args
, int from_tty
)
411 static int resume_is_step
;
412 static int resume_signal
= -1;
415 go32_resume (int pid
, int step
, enum target_signal siggnal
)
419 resume_is_step
= step
;
421 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= TARGET_SIGNAL_TRAP
)
423 for (i
= 0, resume_signal
= -1; excepn_map
[i
].gdb_sig
!= -1; i
++)
424 if (excepn_map
[i
].gdb_sig
== siggnal
)
426 resume_signal
= excepn_map
[i
].djgpp_excepno
;
429 if (resume_signal
== -1)
430 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
431 target_signal_to_name (siggnal
));
435 static char child_cwd
[FILENAME_MAX
];
438 go32_wait (int pid
, struct target_waitstatus
*status
)
441 unsigned char saved_opcode
;
442 unsigned long INT3_addr
;
443 int stepping_over_INT
= 0;
445 a_tss
.tss_eflags
&= 0xfeff; /* reset the single-step flag (TF) */
448 /* If the next instruction is INT xx or INTO, we need to handle
449 them specially. Intel manuals say that these instructions
450 reset the single-step flag (a.k.a. TF). However, it seems
451 that, at least in the DPMI environment, and at least when
452 stepping over the DPMI interrupt 31h, the problem is having
453 TF set at all when INT 31h is executed: the debuggee either
454 crashes (and takes the system with it) or is killed by a
457 So we need to emulate single-step mode: we put an INT3 opcode
458 right after the INT xx instruction, let the debuggee run
459 until it hits INT3 and stops, then restore the original
460 instruction which we overwrote with the INT3 opcode, and back
461 up the debuggee's EIP to that instruction. */
462 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
463 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
465 unsigned char INT3_opcode
= 0xCC;
468 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
469 stepping_over_INT
= 1;
470 read_child (INT3_addr
, &saved_opcode
, 1);
471 write_child (INT3_addr
, &INT3_opcode
, 1);
474 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
477 /* The special value FFFFh in tss_trap indicates to run_child that
478 tss_irqn holds a signal to be delivered to the debuggee. */
479 if (resume_signal
<= -1)
482 a_tss
.tss_irqn
= 0xff;
486 a_tss
.tss_trap
= 0xffff; /* run_child looks for this */
487 a_tss
.tss_irqn
= resume_signal
;
490 /* The child might change working directory behind our back. The
491 GDB users won't like the side effects of that when they work with
492 relative file names, and GDB might be confused by its current
493 directory not being in sync with the truth. So we always make a
494 point of changing back to where GDB thinks is its cwd, when we
495 return control to the debugger, but restore child's cwd before we
499 #if __DJGPP_MINOR__ < 3
503 #if __DJGPP_MINOR__ < 3
507 /* Did we step over an INT xx instruction? */
508 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
510 /* Restore the original opcode. */
511 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction */
512 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
513 /* Simulate a TRAP exception. */
515 a_tss
.tss_eflags
|= 0x0100;
518 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
519 chdir (current_directory
);
521 if (a_tss
.tss_irqn
== 0x21)
523 status
->kind
= TARGET_WAITKIND_EXITED
;
524 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
528 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
529 status
->kind
= TARGET_WAITKIND_STOPPED
;
530 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
532 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
534 #if __DJGPP_MINOR__ < 3
535 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
537 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
539 status
->value
.sig
= sig_map
[i
].gdb_sig
;
549 go32_fetch_registers (int regno
)
552 int end_reg
= regno
+ 1; /* just one reg initially */
554 if (regno
< 0) /* do the all registers */
556 regno
= 0; /* start at first register */
557 /* # regs in table */
558 end_reg
= sizeof (regno_mapping
) / sizeof (regno_mapping
[0]);
561 for (; regno
< end_reg
; regno
++)
564 supply_register (regno
,
565 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
567 supply_register (regno
,
568 (char *) &npx
.reg
[regno_mapping
[regno
].tss_ofs
]);
570 supply_register (regno
,
571 (char *) &npx
+ regno_mapping
[regno
].tss_ofs
);
573 fatal ("Invalid register no. %d in go32_fetch_register.", regno
);
578 store_register (int regno
)
581 void *v
= (void *) ®isters
[REGISTER_BYTE (regno
)];
584 rp
= (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
;
586 rp
= (char *) &npx
.reg
[regno_mapping
[regno
].tss_ofs
];
588 rp
= (char *) &npx
+ regno_mapping
[regno
].tss_ofs
;
590 fatal ("Invalid register no. %d in store_register.", regno
);
591 memcpy (rp
, v
, regno_mapping
[regno
].size
);
595 go32_store_registers (int regno
)
600 store_register (regno
);
603 for (r
= 0; r
< sizeof (regno_mapping
) / sizeof (regno_mapping
[0]); r
++)
609 go32_prepare_to_store (void)
614 go32_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
615 struct target_ops
*target
)
619 if (write_child (memaddr
, myaddr
, len
))
630 if (read_child (memaddr
, myaddr
, len
))
641 static cmdline_t child_cmd
; /* parsed child's command line kept here */
644 go32_files_info (struct target_ops
*target
)
646 printf_unfiltered ("You are running a DJGPP V2 program.\n");
655 prog_has_started
= 0;
659 go32_kill_inferior (void)
661 redir_cmdline_delete (&child_cmd
);
664 unpush_target (&go32_ops
);
668 go32_create_inferior (char *exec_file
, char *args
, char **env
)
672 char **env_save
= environ
;
674 if (prog_has_started
)
677 go32_kill_inferior ();
681 /* Init command line storage. */
682 if (redir_debug_init (&child_cmd
) == -1)
683 fatal ("Cannot allocate redirection storage: not enough memory.\n");
685 /* Parse the command line and create redirections. */
686 if (strpbrk (args
, "<>"))
688 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
689 args
= child_cmd
.command
;
691 error ("Syntax error in command line.");
694 child_cmd
.command
= strdup (args
);
696 cmdline
= (char *) alloca (strlen (args
) + 4);
697 cmdline
[0] = strlen (args
);
698 strcpy (cmdline
+ 1, args
);
699 cmdline
[strlen (args
) + 1] = 13;
703 if (v2loadimage (exec_file
, cmdline
, start_state
))
706 printf_unfiltered ("Load failed for image %s\n", exec_file
);
711 edi_init (start_state
);
712 #if __DJGPP_MINOR__ < 3
716 inferior_pid
= SOME_PID
;
717 push_target (&go32_ops
);
718 clear_proceed_status ();
719 insert_breakpoints ();
720 proceed ((CORE_ADDR
) - 1, TARGET_SIGNAL_0
, 0);
721 prog_has_started
= 1;
725 go32_mourn_inferior (void)
727 /* We need to make sure all the breakpoint enable bits in the DR7
728 register are reset when the inferior exits. Otherwise, if they
729 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
730 failure to set more watchpoints, and other calamities. It would
731 be nice if GDB itself would take care to remove all breakpoints
732 at all times, but it doesn't, probably under an assumption that
733 the OS cleans up when the debuggee exits. */
735 go32_kill_inferior ();
736 generic_mourn_inferior ();
750 /* Hardware watchpoint support. */
754 #define DR_ENABLE_SIZE 2
755 #define DR_LOCAL_ENABLE_SHIFT 0
756 #define DR_GLOBAL_ENABLE_SHIFT 1
757 #define DR_LOCAL_SLOWDOWN 0x100
758 #define DR_GLOBAL_SLOWDOWN 0x200
759 #define DR_CONTROL_SHIFT 16
760 #define DR_CONTROL_SIZE 4
761 #define DR_RW_READWRITE 0x3
762 #define DR_RW_WRITE 0x1
763 #define DR_CONTROL_MASK 0xf
764 #define DR_ENABLE_MASK 0x3
769 #define D_REGS edi.dr
770 #define CONTROL D_REGS[DR_CONTROL]
771 #define STATUS D_REGS[DR_STATUS]
773 #define IS_REG_FREE(index) \
774 (!(CONTROL & (3 << (DR_ENABLE_SIZE * (index)))))
776 #define LOCAL_ENABLE_REG(index) \
777 (CONTROL |= (1 << (DR_LOCAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
779 #define GLOBAL_ENABLE_REG(index) \
780 (CONTROL |= (1 << (DR_GLOBAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
782 #define DISABLE_REG(index) \
783 (CONTROL &= ~(3 << (DR_ENABLE_SIZE * (index))))
785 #define SET_LOCAL_EXACT() \
786 (CONTROL |= DR_LOCAL_SLOWDOWN)
788 #define SET_GLOBAL_EXACT() \
789 (CONTROL |= DR_GLOBAL_SLOWDOWN)
791 #define RESET_LOCAL_EXACT() \
792 (CONTROL &= ~(DR_LOCAL_SLOWDOWN))
794 #define RESET_GLOBAL_EXACT() \
795 (CONTROL &= ~(DR_GLOBAL_SLOWDOWN))
797 #define SET_BREAK(index,address) \
799 CONTROL &= ~(DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index)));\
800 D_REGS[index] = address;\
803 #define SET_WATCH(index,address,rw,len) \
805 SET_BREAK(index,address);\
806 CONTROL |= ((len)|(rw)) << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index));\
809 #define IS_WATCH(index) \
810 (CONTROL & (DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE*(index))))
812 #define WATCH_HIT(index) \
814 (STATUS & (1 << index)) && \
815 (CONTROL & (DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * index)))\
818 #define DR_DEF(index) \
819 ((CONTROL >> (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index))) & 0x0f)
822 #if 0 /* use debugging macro */
823 #define SHOW_DR(text,len) \
825 if (!getenv ("GDB_SHOW_DR")) break; \
826 fprintf(stderr,"%08x %08x ",edi.dr[7],edi.dr[6]); \
827 fprintf(stderr,"%08x %d %08x %d ", \
828 edi.dr[0],dr_ref_count[0],edi.dr[1],dr_ref_count[1]); \
829 fprintf(stderr,"%08x %d %08x %d ", \
830 edi.dr[2],dr_ref_count[2],edi.dr[3],dr_ref_count[3]); \
831 fprintf(stderr,(len)?"(%s:%d)\n":"(%s)\n",#text,len); \
834 #define SHOW_DR(text,len) do {} while (0)
844 for (i
= 0; i
< 4; i
++)
851 /* Insert a watchpoint. */
854 go32_insert_watchpoint (int pid
, CORE_ADDR addr
, int len
, int rw
)
856 int ret
= go32_insert_aligned_watchpoint (addr
, addr
, len
, rw
);
858 SHOW_DR (insert_watch
, len
);
863 go32_insert_aligned_watchpoint (CORE_ADDR waddr
, CORE_ADDR addr
,
867 int read_write_bits
, len_bits
;
869 /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
870 However, x86 doesn't support read-only data breakpoints. */
871 read_write_bits
= rw
? DR_RW_READWRITE
: DR_RW_WRITE
;
885 /* The debug registers only have 2 bits for the length, so
886 so this value will always fail the loop below. */
890 /* Look for an occupied debug register with the same address and the
891 same RW and LEN definitions. If we find one, we can use it for
892 this watchpoint as well (and save a register). */
893 for (i
= 0; i
< 4; i
++)
895 if (!IS_REG_FREE (i
) && D_REGS
[i
] == addr
896 && DR_DEF (i
) == (len_bits
| read_write_bits
))
903 /* Look for a free debug register. */
904 for (i
= 0; i
<= 3; i
++)
910 /* No more debug registers! */
917 return go32_handle_nonaligned_watchpoint (wp_insert
, waddr
, addr
,
923 return go32_handle_nonaligned_watchpoint (wp_insert
, waddr
, addr
,
927 return go32_handle_nonaligned_watchpoint (wp_insert
, waddr
, addr
, len
, rw
);
929 SET_WATCH (i
, addr
, read_write_bits
, len_bits
);
930 LOCAL_ENABLE_REG (i
);
937 go32_handle_nonaligned_watchpoint (wp_op what
, CORE_ADDR waddr
, CORE_ADDR addr
,
942 int rv
= 0, status
= 0;
944 static int size_try_array
[16] =
946 1, 1, 1, 1, /* trying size one */
947 2, 1, 2, 1, /* trying size two */
948 2, 1, 2, 1, /* trying size three */
949 4, 1, 2, 1 /* trying size four */
955 /* Four is the maximum length for 386. */
956 size
= (len
> 4) ? 3 : len
- 1;
957 size
= size_try_array
[size
* 4 + align
];
958 if (what
== wp_insert
)
959 status
= go32_insert_aligned_watchpoint (waddr
, addr
, size
, rw
);
960 else if (what
== wp_remove
)
961 status
= go32_remove_aligned_watchpoint (waddr
, addr
, size
, rw
);
962 else if (what
== wp_count
)
966 /* We keep the loop going even after a failure, because some of
967 the other aligned watchpoints might still succeed, e.g. if
968 they watch addresses that are already watched, and thus just
969 increment the reference counts of occupied debug registers.
970 If we break out of the loop too early, we could cause those
971 addresses watched by other watchpoints to be disabled when
972 GDB reacts to our failure to insert this watchpoint and tries
982 /* Remove a watchpoint. */
985 go32_remove_watchpoint (int pid
, CORE_ADDR addr
, int len
, int rw
)
987 int ret
= go32_remove_aligned_watchpoint (addr
, addr
, len
, rw
);
989 SHOW_DR (remove_watch
, len
);
994 go32_remove_aligned_watchpoint (CORE_ADDR waddr
, CORE_ADDR addr
,
998 int read_write_bits
, len_bits
;
1000 /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
1001 However, x86 doesn't support read-only data breakpoints. */
1002 read_write_bits
= rw
? DR_RW_READWRITE
: DR_RW_WRITE
;
1007 len_bits
= DR_LEN_4
;
1010 len_bits
= DR_LEN_2
;
1013 len_bits
= DR_LEN_1
;
1016 /* The debug registers only have 2 bits for the length, so
1017 so this value will always fail the loop below. */
1024 return go32_handle_nonaligned_watchpoint (wp_remove
, waddr
, addr
,
1030 return go32_handle_nonaligned_watchpoint (wp_remove
, waddr
, addr
,
1034 return go32_handle_nonaligned_watchpoint (wp_remove
, waddr
, addr
, len
, rw
);
1036 for (i
= 0; i
<= 3; i
++)
1038 if (!IS_REG_FREE (i
) && D_REGS
[i
] == addr
1039 && DR_DEF (i
) == (len_bits
| read_write_bits
))
1042 if (dr_ref_count
[i
] == 0)
1046 RESET_LOCAL_EXACT ();
1047 RESET_GLOBAL_EXACT ();
1052 /* Can we use debug registers to watch a region whose address is ADDR
1053 and whose length is LEN bytes? */
1056 go32_region_ok_for_watchpoint (CORE_ADDR addr
, int len
)
1058 /* Compute how many aligned watchpoints we would need to cover this
1060 int nregs
= go32_handle_nonaligned_watchpoint (wp_count
, addr
, addr
, len
, 0);
1062 return nregs
<= 4 ? 1 : 0;
1065 /* Check if stopped by a data watchpoint. If so, return the address
1066 whose access triggered the watchpoint. */
1069 go32_stopped_by_watchpoint (int pid
, int data_watchpoint
)
1074 status
= edi
.dr
[DR_STATUS
];
1075 SHOW_DR (stopped_by
, 0);
1076 for (i
= 0; i
<= 3; i
++)
1078 if (WATCH_HIT (i
) && data_watchpoint
)
1080 SHOW_DR (WP_HIT
, 0);
1088 /* Remove a breakpoint. */
1091 go32_remove_hw_breakpoint (CORE_ADDR addr
, CORE_ADDR shadow
)
1094 for (i
= 0; i
<= 3; i
++)
1096 if (!IS_REG_FREE (i
) && D_REGS
[i
] == addr
&& DR_DEF (i
) == 0)
1099 if (dr_ref_count
[i
] == 0)
1103 SHOW_DR (remove_hw
, 0);
1108 go32_insert_hw_breakpoint (CORE_ADDR addr
, CORE_ADDR shadow
)
1111 int read_write_bits
, len_bits
;
1112 int free_debug_register
;
1113 int register_number
;
1115 /* Look for an occupied debug register with the same address and the
1116 same RW and LEN definitions. If we find one, we can use it for
1117 this breakpoint as well (and save a register). */
1118 for (i
= 0; i
< 4; i
++)
1120 if (!IS_REG_FREE (i
) && D_REGS
[i
] == addr
&& DR_DEF (i
) == 0)
1123 SHOW_DR (insert_hw
, 0);
1128 /* Look for a free debug register. */
1129 for (i
= 0; i
<= 3; i
++)
1131 if (IS_REG_FREE (i
))
1135 /* No more debug registers? */
1138 SET_BREAK (i
, addr
);
1139 LOCAL_ENABLE_REG (i
);
1141 SHOW_DR (insert_hw
, 0);
1143 return i
< 4 ? 0 : -1;
1146 static int inf_flags_valid
= 0;
1147 static int inf_in_flag
;
1148 static int inf_out_flag
;
1150 /* Put the device open on handle FD into either raw or cooked
1151 mode, return 1 if it was in raw mode, zero otherwise. */
1154 device_mode (int fd
, int raw_p
)
1156 int oldmode
, newmode
;
1161 __dpmi_int (0x21, ®s
);
1162 if (regs
.x
.flags
& 1)
1164 newmode
= oldmode
= regs
.x
.dx
;
1171 if (oldmode
& 0x80) /* Only for character dev */
1175 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails */
1176 __dpmi_int (0x21, ®s
);
1177 if (regs
.x
.flags
& 1)
1180 return (oldmode
& 0x20) == 0x20;
1184 static int inf_mode_valid
= 0;
1185 static int inf_terminal_mode
;
1187 /* This semaphore is needed because, amazingly enough, GDB calls
1188 target.to_terminal_ours more than once after the inferior stops.
1189 But we need the information from the first call only, since the
1190 second call will always see GDB's own cooked terminal. */
1191 static int terminal_is_ours
= 1;
1194 go32_terminal_init (void)
1196 inf_mode_valid
= 0; /* reinitialize, in case they are restarting child */
1197 terminal_is_ours
= 1;
1201 go32_terminal_info (char *args
, int from_tty
)
1203 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
1205 ? "default" : inf_terminal_mode
? "raw" : "cooked");
1207 #if __DJGPP_MINOR__ > 2
1208 if (child_cmd
.redirection
)
1212 for (i
= 0; i
< DBG_HANDLES
; i
++)
1214 if (child_cmd
.redirection
[i
]->file_name
)
1215 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
1216 i
, child_cmd
.redirection
[i
]->file_name
);
1217 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
1219 ("\tFile handle %d appears to be closed by inferior.\n", i
);
1220 /* Mask off the raw/cooked bit when comparing device info words. */
1221 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
1222 != (_get_dev_info (i
) & 0xdf))
1224 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
1231 go32_terminal_inferior (void)
1233 /* Redirect standard handles as child wants them. */
1235 if (redir_to_child (&child_cmd
) == -1)
1237 redir_to_debugger (&child_cmd
);
1238 error ("Cannot redirect standard handles for program: %s.",
1241 /* set the console device of the inferior to whatever mode
1242 (raw or cooked) we found it last time */
1243 if (terminal_is_ours
)
1246 device_mode (0, inf_terminal_mode
);
1247 terminal_is_ours
= 0;
1252 go32_terminal_ours (void)
1254 /* Switch to cooked mode on the gdb terminal and save the inferior
1255 terminal mode to be restored when it is resumed */
1256 if (!terminal_is_ours
)
1258 inf_terminal_mode
= device_mode (0, 0);
1259 if (inf_terminal_mode
!= -1)
1262 /* If device_mode returned -1, we don't know what happens with
1263 handle 0 anymore, so make the info invalid. */
1265 terminal_is_ours
= 1;
1267 /* Restore debugger's standard handles. */
1269 if (redir_to_debugger (&child_cmd
) == -1)
1271 redir_to_child (&child_cmd
);
1272 error ("Cannot redirect standard handles for debugger: %s.",
1279 init_go32_ops (void)
1281 go32_ops
.to_shortname
= "djgpp";
1282 go32_ops
.to_longname
= "djgpp target process";
1284 "Program loaded by djgpp, when gdb is used as an external debugger";
1285 go32_ops
.to_open
= go32_open
;
1286 go32_ops
.to_close
= go32_close
;
1287 go32_ops
.to_attach
= go32_attach
;
1288 go32_ops
.to_detach
= go32_detach
;
1289 go32_ops
.to_resume
= go32_resume
;
1290 go32_ops
.to_wait
= go32_wait
;
1291 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
1292 go32_ops
.to_store_registers
= go32_store_registers
;
1293 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
1294 go32_ops
.to_xfer_memory
= go32_xfer_memory
;
1295 go32_ops
.to_files_info
= go32_files_info
;
1296 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1297 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1298 go32_ops
.to_terminal_init
= go32_terminal_init
;
1299 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
1300 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
1301 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
1302 go32_ops
.to_terminal_info
= go32_terminal_info
;
1303 go32_ops
.to_kill
= go32_kill_inferior
;
1304 go32_ops
.to_create_inferior
= go32_create_inferior
;
1305 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
1306 go32_ops
.to_can_run
= go32_can_run
;
1307 go32_ops
.to_stop
= go32_stop
;
1308 go32_ops
.to_stratum
= process_stratum
;
1309 go32_ops
.to_has_all_memory
= 1;
1310 go32_ops
.to_has_memory
= 1;
1311 go32_ops
.to_has_stack
= 1;
1312 go32_ops
.to_has_registers
= 1;
1313 go32_ops
.to_has_execution
= 1;
1314 go32_ops
.to_magic
= OPS_MAGIC
;
1316 /* Initialize child's cwd with the current one. */
1317 getcwd (child_cwd
, sizeof (child_cwd
));
1319 /* Initialize child's command line storage. */
1320 if (redir_debug_init (&child_cmd
) == -1)
1321 fatal ("Cannot allocate redirection storage: not enough memory.\n");
1325 _initialize_go32_nat (void)
1328 add_target (&go32_ops
);
1341 tcsetpgrp (int fd
, pid_t pgid
)
1343 if (isatty (fd
) && pgid
== SOME_PID
)
1345 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;