1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997, 1999-2001, 2005-2012 Free Software Foundation,
4 Written by Robert Hoehne.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* To whomever it may concern, here's a general description of how
22 debugging in DJGPP works, and the special quirks GDB does to
25 When the DJGPP port of GDB is debugging a DJGPP program natively,
26 there aren't 2 separate processes, the debuggee and GDB itself, as
27 on other systems. (This is DOS, where there can only be one active
28 process at any given time, remember?) Instead, GDB and the
29 debuggee live in the same process. So when GDB calls
30 go32_create_inferior below, and that function calls edi_init from
31 the DJGPP debug support library libdbg.a, we load the debuggee's
32 executable file into GDB's address space, set it up for execution
33 as the stub loader (a short real-mode program prepended to each
34 DJGPP executable) normally would, and do a lot of preparations for
35 swapping between GDB's and debuggee's internal state, primarily wrt
36 the exception handlers. This swapping happens every time we resume
37 the debuggee or switch back to GDB's code, and it includes:
39 . swapping all the segment registers
40 . swapping the PSP (the Program Segment Prefix)
41 . swapping the signal handlers
42 . swapping the exception handlers
43 . swapping the FPU status
44 . swapping the 3 standard file handles (more about this below)
46 Then running the debuggee simply means longjmp into it where its PC
47 is and let it run until it stops for some reason. When it stops,
48 GDB catches the exception that stopped it and longjmp's back into
49 its own code. All the possible exit points of the debuggee are
50 watched; for example, the normal exit point is recognized because a
51 DOS program issues a special system call to exit. If one of those
52 exit points is hit, we mourn the inferior and clean up after it.
53 Cleaning up is very important, even if the process exits normally,
54 because otherwise we might leave behind traces of previous
55 execution, and in several cases GDB itself might be left hosed,
56 because all the exception handlers were not restored.
58 Swapping of the standard handles (in redir_to_child and
59 redir_to_debugger) is needed because, since both GDB and the
60 debuggee live in the same process, as far as the OS is concerned,
61 the share the same file table. This means that the standard
62 handles 0, 1, and 2 point to the same file table entries, and thus
63 are connected to the same devices. Therefore, if the debugger
64 redirects its standard output, the standard output of the debuggee
65 is also automagically redirected to the same file/device!
66 Similarly, if the debuggee redirects its stdout to a file, you
67 won't be able to see debugger's output (it will go to the same file
68 where the debuggee has its output); and if the debuggee closes its
69 standard input, you will lose the ability to talk to debugger!
71 For this reason, every time the debuggee is about to be resumed, we
72 call redir_to_child, which redirects the standard handles to where
73 the debuggee expects them to be. When the debuggee stops and GDB
74 regains control, we call redir_to_debugger, which redirects those 3
75 handles back to where GDB expects.
77 Note that only the first 3 handles are swapped, so if the debuggee
78 redirects or closes any other handles, GDB will not notice. In
79 particular, the exit code of a DJGPP program forcibly closes all
80 file handles beyond the first 3 ones, so when the debuggee exits,
81 GDB currently loses its stdaux and stdprn streams. Fortunately,
82 GDB does not use those as of this writing, and will never need
90 #include "gdbthread.h"
95 #include "floatformat.h"
97 #include "i387-tdep.h"
98 #include "i386-tdep.h"
100 #include "regcache.h"
101 #include "gdb_string.h"
104 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
109 #include <sys/utsname.h>
114 #include <sys/farptr.h>
115 #include <debug/v2load.h>
116 #include <debug/dbgcom.h>
117 #if __DJGPP_MINOR__ > 2
118 #include <debug/redir.h>
121 #include <langinfo.h>
123 #if __DJGPP_MINOR__ < 3
124 /* This code will be provided from DJGPP 2.03 on. Until then I code it
132 unsigned short exponent
:15;
133 unsigned short sign
:1;
139 unsigned int control
;
144 unsigned int dataptr
;
145 unsigned int datasel
;
152 static void save_npx (void); /* Save the FPU of the debugged program. */
153 static void load_npx (void); /* Restore the FPU of the debugged program. */
155 /* ------------------------------------------------------------------------- */
156 /* Store the contents of the NPX in the global variable `npx'. */
162 asm ("inb $0xa0, %%al \n\
163 testb $0x20, %%al \n\
181 /* ------------------------------------------------------------------------- */
182 /* Reload the contents of the NPX from the global variable `npx'. */
187 asm ("frstor %0":"=m" (npx
));
189 /* ------------------------------------------------------------------------- */
190 /* Stubs for the missing redirection functions. */
197 redir_cmdline_delete (cmdline_t
*ptr
)
203 redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
209 redir_to_child (cmdline_t
*ptr
)
215 redir_to_debugger (cmdline_t
*ptr
)
221 redir_debug_init (cmdline_t
*ptr
)
225 #endif /* __DJGPP_MINOR < 3 */
227 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
229 /* This holds the current reference counts for each debug register. */
230 static int dr_ref_count
[4];
234 static int prog_has_started
= 0;
235 static void go32_open (char *name
, int from_tty
);
236 static void go32_close (int quitting
);
237 static void go32_attach (struct target_ops
*ops
, char *args
, int from_tty
);
238 static void go32_detach (struct target_ops
*ops
, char *args
, int from_tty
);
239 static void go32_resume (struct target_ops
*ops
,
240 ptid_t ptid
, int step
,
241 enum target_signal siggnal
);
242 static void go32_fetch_registers (struct target_ops
*ops
,
243 struct regcache
*, int regno
);
244 static void store_register (const struct regcache
*, int regno
);
245 static void go32_store_registers (struct target_ops
*ops
,
246 struct regcache
*, int regno
);
247 static void go32_prepare_to_store (struct regcache
*);
248 static int go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
250 struct mem_attrib
*attrib
,
251 struct target_ops
*target
);
252 static void go32_files_info (struct target_ops
*target
);
253 static void go32_kill_inferior (struct target_ops
*ops
);
254 static void go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
255 char *args
, char **env
, int from_tty
);
256 static void go32_mourn_inferior (struct target_ops
*ops
);
257 static int go32_can_run (void);
259 static struct target_ops go32_ops
;
260 static void go32_terminal_init (void);
261 static void go32_terminal_inferior (void);
262 static void go32_terminal_ours (void);
264 #define r_ofs(x) (offsetof(TSS,x))
273 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
274 {r_ofs (tss_ecx
), 4},
275 {r_ofs (tss_edx
), 4},
276 {r_ofs (tss_ebx
), 4},
277 {r_ofs (tss_esp
), 4},
278 {r_ofs (tss_ebp
), 4},
279 {r_ofs (tss_esi
), 4},
280 {r_ofs (tss_edi
), 4},
281 {r_ofs (tss_eip
), 4},
282 {r_ofs (tss_eflags
), 4},
289 {0, 10}, /* 8 FP registers, from npx.reg[] */
297 /* The order of the next 7 registers must be consistent
298 with their numbering in config/i386/tm-i386.h, which see. */
299 {0, 2}, /* control word, from npx */
300 {4, 2}, /* status word, from npx */
301 {8, 2}, /* tag word, from npx */
302 {16, 2}, /* last FP exception CS from npx */
303 {12, 4}, /* last FP exception EIP from npx */
304 {24, 2}, /* last FP exception operand selector from npx */
305 {20, 4}, /* last FP exception operand offset from npx */
306 {18, 2} /* last FP opcode from npx */
312 enum target_signal gdb_sig
;
316 {0, TARGET_SIGNAL_FPE
},
317 {1, TARGET_SIGNAL_TRAP
},
318 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
319 but I think SIGBUS is better, since the NMI is usually activated
320 as a result of a memory parity check failure. */
321 {2, TARGET_SIGNAL_BUS
},
322 {3, TARGET_SIGNAL_TRAP
},
323 {4, TARGET_SIGNAL_FPE
},
324 {5, TARGET_SIGNAL_SEGV
},
325 {6, TARGET_SIGNAL_ILL
},
326 {7, TARGET_SIGNAL_EMT
}, /* no-coprocessor exception */
327 {8, TARGET_SIGNAL_SEGV
},
328 {9, TARGET_SIGNAL_SEGV
},
329 {10, TARGET_SIGNAL_BUS
},
330 {11, TARGET_SIGNAL_SEGV
},
331 {12, TARGET_SIGNAL_SEGV
},
332 {13, TARGET_SIGNAL_SEGV
},
333 {14, TARGET_SIGNAL_SEGV
},
334 {16, TARGET_SIGNAL_FPE
},
335 {17, TARGET_SIGNAL_BUS
},
336 {31, TARGET_SIGNAL_ILL
},
337 {0x1b, TARGET_SIGNAL_INT
},
338 {0x75, TARGET_SIGNAL_FPE
},
339 {0x78, TARGET_SIGNAL_ALRM
},
340 {0x79, TARGET_SIGNAL_INT
},
341 {0x7a, TARGET_SIGNAL_QUIT
},
342 {-1, TARGET_SIGNAL_LAST
}
346 enum target_signal gdb_sig
;
349 {TARGET_SIGNAL_0
, -1},
350 {TARGET_SIGNAL_ILL
, 6}, /* Invalid Opcode */
351 {TARGET_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
352 {TARGET_SIGNAL_SEGV
, 13}, /* GPF */
353 {TARGET_SIGNAL_BUS
, 17}, /* Alignment Check */
354 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
356 {TARGET_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
357 {TARGET_SIGNAL_FPE
, 0x75},
358 {TARGET_SIGNAL_INT
, 0x79},
359 {TARGET_SIGNAL_QUIT
, 0x7a},
360 {TARGET_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
361 {TARGET_SIGNAL_PROF
, 0x78},
362 {TARGET_SIGNAL_LAST
, -1}
366 go32_open (char *name
, int from_tty
)
368 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
372 go32_close (int quitting
)
377 go32_attach (struct target_ops
*ops
, char *args
, int from_tty
)
380 You cannot attach to a running program on this platform.\n\
381 Use the `run' command to run DJGPP programs."));
385 go32_detach (struct target_ops
*ops
, char *args
, int from_tty
)
389 static int resume_is_step
;
390 static int resume_signal
= -1;
393 go32_resume (struct target_ops
*ops
,
394 ptid_t ptid
, int step
, enum target_signal siggnal
)
398 resume_is_step
= step
;
400 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= TARGET_SIGNAL_TRAP
)
402 for (i
= 0, resume_signal
= -1;
403 excepn_map
[i
].gdb_sig
!= TARGET_SIGNAL_LAST
; i
++)
404 if (excepn_map
[i
].gdb_sig
== siggnal
)
406 resume_signal
= excepn_map
[i
].djgpp_excepno
;
409 if (resume_signal
== -1)
410 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
411 target_signal_to_name (siggnal
));
415 static char child_cwd
[FILENAME_MAX
];
418 go32_wait (struct target_ops
*ops
,
419 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
422 unsigned char saved_opcode
;
423 unsigned long INT3_addr
= 0;
424 int stepping_over_INT
= 0;
426 a_tss
.tss_eflags
&= 0xfeff; /* Reset the single-step flag (TF). */
429 /* If the next instruction is INT xx or INTO, we need to handle
430 them specially. Intel manuals say that these instructions
431 reset the single-step flag (a.k.a. TF). However, it seems
432 that, at least in the DPMI environment, and at least when
433 stepping over the DPMI interrupt 31h, the problem is having
434 TF set at all when INT 31h is executed: the debuggee either
435 crashes (and takes the system with it) or is killed by a
438 So we need to emulate single-step mode: we put an INT3 opcode
439 right after the INT xx instruction, let the debuggee run
440 until it hits INT3 and stops, then restore the original
441 instruction which we overwrote with the INT3 opcode, and back
442 up the debuggee's EIP to that instruction. */
443 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
444 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
446 unsigned char INT3_opcode
= 0xCC;
449 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
450 stepping_over_INT
= 1;
451 read_child (INT3_addr
, &saved_opcode
, 1);
452 write_child (INT3_addr
, &INT3_opcode
, 1);
455 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
458 /* The special value FFFFh in tss_trap indicates to run_child that
459 tss_irqn holds a signal to be delivered to the debuggee. */
460 if (resume_signal
<= -1)
463 a_tss
.tss_irqn
= 0xff;
467 a_tss
.tss_trap
= 0xffff; /* run_child looks for this. */
468 a_tss
.tss_irqn
= resume_signal
;
471 /* The child might change working directory behind our back. The
472 GDB users won't like the side effects of that when they work with
473 relative file names, and GDB might be confused by its current
474 directory not being in sync with the truth. So we always make a
475 point of changing back to where GDB thinks is its cwd, when we
476 return control to the debugger, but restore child's cwd before we
478 /* Initialize child_cwd, before the first call to run_child and not
479 in the initialization, so the child get also the changed directory
480 set with the gdb-command "cd ..." */
482 /* Initialize child's cwd with the current one. */
483 getcwd (child_cwd
, sizeof (child_cwd
));
487 #if __DJGPP_MINOR__ < 3
491 #if __DJGPP_MINOR__ < 3
495 /* Did we step over an INT xx instruction? */
496 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
498 /* Restore the original opcode. */
499 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction. */
500 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
501 /* Simulate a TRAP exception. */
503 a_tss
.tss_eflags
|= 0x0100;
506 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
507 chdir (current_directory
);
509 if (a_tss
.tss_irqn
== 0x21)
511 status
->kind
= TARGET_WAITKIND_EXITED
;
512 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
516 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
517 status
->kind
= TARGET_WAITKIND_STOPPED
;
518 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
520 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
522 #if __DJGPP_MINOR__ < 3
523 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
525 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
527 status
->value
.sig
= sig_map
[i
].gdb_sig
;
533 return pid_to_ptid (SOME_PID
);
537 fetch_register (struct regcache
*regcache
, int regno
)
539 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
540 if (regno
< gdbarch_fp0_regnum (gdbarch
))
541 regcache_raw_supply (regcache
, regno
,
542 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
543 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
545 i387_supply_fsave (regcache
, regno
, &npx
);
547 internal_error (__FILE__
, __LINE__
,
548 _("Invalid register no. %d in fetch_register."), regno
);
552 go32_fetch_registers (struct target_ops
*ops
,
553 struct regcache
*regcache
, int regno
)
556 fetch_register (regcache
, regno
);
560 regno
< gdbarch_fp0_regnum (get_regcache_arch (regcache
));
562 fetch_register (regcache
, regno
);
563 i387_supply_fsave (regcache
, -1, &npx
);
568 store_register (const struct regcache
*regcache
, int regno
)
570 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
571 if (regno
< gdbarch_fp0_regnum (gdbarch
))
572 regcache_raw_collect (regcache
, regno
,
573 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
574 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
576 i387_collect_fsave (regcache
, regno
, &npx
);
578 internal_error (__FILE__
, __LINE__
,
579 _("Invalid register no. %d in store_register."), regno
);
583 go32_store_registers (struct target_ops
*ops
,
584 struct regcache
*regcache
, int regno
)
589 store_register (regcache
, regno
);
592 for (r
= 0; r
< gdbarch_fp0_regnum (get_regcache_arch (regcache
)); r
++)
593 store_register (regcache
, r
);
594 i387_collect_fsave (regcache
, -1, &npx
);
599 go32_prepare_to_store (struct regcache
*regcache
)
604 go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
605 struct mem_attrib
*attrib
, struct target_ops
*target
)
609 if (write_child (memaddr
, myaddr
, len
))
620 if (read_child (memaddr
, myaddr
, len
))
631 static cmdline_t child_cmd
; /* Parsed child's command line kept here. */
634 go32_files_info (struct target_ops
*target
)
636 printf_unfiltered ("You are running a DJGPP V2 program.\n");
640 go32_kill_inferior (struct target_ops
*ops
)
642 go32_mourn_inferior (ops
);
646 go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
647 char *args
, char **env
, int from_tty
)
649 extern char **environ
;
652 char **env_save
= environ
;
654 struct inferior
*inf
;
656 /* If no exec file handed to us, get it from the exec-file command -- with
657 a good, common error message if none is specified. */
659 exec_file
= get_exec_file (1);
664 /* Initialize child's cwd as empty to be initialized when starting
668 /* Init command line storage. */
669 if (redir_debug_init (&child_cmd
) == -1)
670 internal_error (__FILE__
, __LINE__
,
671 _("Cannot allocate redirection storage: "
672 "not enough memory.\n"));
674 /* Parse the command line and create redirections. */
675 if (strpbrk (args
, "<>"))
677 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
678 args
= child_cmd
.command
;
680 error (_("Syntax error in command line."));
683 child_cmd
.command
= xstrdup (args
);
685 cmdlen
= strlen (args
);
686 /* v2loadimage passes command lines via DOS memory, so it cannot
687 possibly handle commands longer than 1MB. */
688 if (cmdlen
> 1024*1024)
689 error (_("Command line too long."));
691 cmdline
= xmalloc (cmdlen
+ 4);
692 strcpy (cmdline
+ 1, args
);
693 /* If the command-line length fits into DOS 126-char limits, use the
694 DOS command tail format; otherwise, tell v2loadimage to pass it
695 through a buffer in conventional memory. */
698 cmdline
[0] = strlen (args
);
699 cmdline
[cmdlen
+ 1] = 13;
702 cmdline
[0] = 0xff; /* Signal v2loadimage it's a long command. */
706 if (v2loadimage (exec_file
, cmdline
, start_state
))
709 printf_unfiltered ("Load failed for image %s\n", exec_file
);
715 edi_init (start_state
);
716 #if __DJGPP_MINOR__ < 3
720 inferior_ptid
= pid_to_ptid (SOME_PID
);
721 inf
= current_inferior ();
722 inferior_appeared (inf
, SOME_PID
);
724 push_target (&go32_ops
);
726 add_thread_silent (inferior_ptid
);
728 clear_proceed_status ();
729 insert_breakpoints ();
730 prog_has_started
= 1;
734 go32_mourn_inferior (struct target_ops
*ops
)
738 redir_cmdline_delete (&child_cmd
);
744 /* We need to make sure all the breakpoint enable bits in the DR7
745 register are reset when the inferior exits. Otherwise, if they
746 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
747 failure to set more watchpoints, and other calamities. It would
748 be nice if GDB itself would take care to remove all breakpoints
749 at all times, but it doesn't, probably under an assumption that
750 the OS cleans up when the debuggee exits. */
751 i386_cleanup_dregs ();
753 ptid
= inferior_ptid
;
754 inferior_ptid
= null_ptid
;
755 delete_thread_silent (ptid
);
756 prog_has_started
= 0;
759 generic_mourn_inferior ();
768 /* Hardware watchpoint support. */
770 #define D_REGS edi.dr
771 #define CONTROL D_REGS[7]
772 #define STATUS D_REGS[6]
774 /* Pass the address ADDR to the inferior in the I'th debug register.
775 Here we just store the address in D_REGS, the watchpoint will be
776 actually set up when go32_wait runs the debuggee. */
778 go32_set_dr (int i
, CORE_ADDR addr
)
781 internal_error (__FILE__
, __LINE__
,
782 _("Invalid register %d in go32_set_dr.\n"), i
);
786 /* Pass the value VAL to the inferior in the DR7 debug control
787 register. Here we just store the address in D_REGS, the watchpoint
788 will be actually set up when go32_wait runs the debuggee. */
790 go32_set_dr7 (unsigned long val
)
795 /* Get the value of the DR6 debug status register from the inferior.
796 Here we just return the value stored in D_REGS, as we've got it
797 from the last go32_wait call. */
804 /* Get the value of the DR7 debug status register from the inferior.
805 Here we just return the value stored in D_REGS, as we've got it
806 from the last go32_wait call. */
814 /* Get the value of the DR debug register I from the inferior. Here
815 we just return the value stored in D_REGS, as we've got it from the
816 last go32_wait call. */
822 internal_error (__FILE__
, __LINE__
,
823 _("Invalid register %d in go32_get_dr.\n"), i
);
827 /* Put the device open on handle FD into either raw or cooked
828 mode, return 1 if it was in raw mode, zero otherwise. */
831 device_mode (int fd
, int raw_p
)
833 int oldmode
, newmode
;
838 __dpmi_int (0x21, ®s
);
839 if (regs
.x
.flags
& 1)
841 newmode
= oldmode
= regs
.x
.dx
;
848 if (oldmode
& 0x80) /* Only for character dev. */
852 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails. */
853 __dpmi_int (0x21, ®s
);
854 if (regs
.x
.flags
& 1)
857 return (oldmode
& 0x20) == 0x20;
861 static int inf_mode_valid
= 0;
862 static int inf_terminal_mode
;
864 /* This semaphore is needed because, amazingly enough, GDB calls
865 target.to_terminal_ours more than once after the inferior stops.
866 But we need the information from the first call only, since the
867 second call will always see GDB's own cooked terminal. */
868 static int terminal_is_ours
= 1;
871 go32_terminal_init (void)
873 inf_mode_valid
= 0; /* Reinitialize, in case they are restarting child. */
874 terminal_is_ours
= 1;
878 go32_terminal_info (char *args
, int from_tty
)
880 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
882 ? "default" : inf_terminal_mode
? "raw" : "cooked");
884 #if __DJGPP_MINOR__ > 2
885 if (child_cmd
.redirection
)
889 for (i
= 0; i
< DBG_HANDLES
; i
++)
891 if (child_cmd
.redirection
[i
]->file_name
)
892 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
893 i
, child_cmd
.redirection
[i
]->file_name
);
894 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
896 ("\tFile handle %d appears to be closed by inferior.\n", i
);
897 /* Mask off the raw/cooked bit when comparing device info words. */
898 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
899 != (_get_dev_info (i
) & 0xdf))
901 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
908 go32_terminal_inferior (void)
910 /* Redirect standard handles as child wants them. */
912 if (redir_to_child (&child_cmd
) == -1)
914 redir_to_debugger (&child_cmd
);
915 error (_("Cannot redirect standard handles for program: %s."),
916 safe_strerror (errno
));
918 /* Set the console device of the inferior to whatever mode
919 (raw or cooked) we found it last time. */
920 if (terminal_is_ours
)
923 device_mode (0, inf_terminal_mode
);
924 terminal_is_ours
= 0;
929 go32_terminal_ours (void)
931 /* Switch to cooked mode on the gdb terminal and save the inferior
932 terminal mode to be restored when it is resumed. */
933 if (!terminal_is_ours
)
935 inf_terminal_mode
= device_mode (0, 0);
936 if (inf_terminal_mode
!= -1)
939 /* If device_mode returned -1, we don't know what happens with
940 handle 0 anymore, so make the info invalid. */
942 terminal_is_ours
= 1;
944 /* Restore debugger's standard handles. */
946 if (redir_to_debugger (&child_cmd
) == -1)
948 redir_to_child (&child_cmd
);
949 error (_("Cannot redirect standard handles for debugger: %s."),
950 safe_strerror (errno
));
956 go32_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
958 return !ptid_equal (inferior_ptid
, null_ptid
);
962 go32_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
964 return normal_pid_to_str (ptid
);
970 go32_ops
.to_shortname
= "djgpp";
971 go32_ops
.to_longname
= "djgpp target process";
973 "Program loaded by djgpp, when gdb is used as an external debugger";
974 go32_ops
.to_open
= go32_open
;
975 go32_ops
.to_close
= go32_close
;
976 go32_ops
.to_attach
= go32_attach
;
977 go32_ops
.to_detach
= go32_detach
;
978 go32_ops
.to_resume
= go32_resume
;
979 go32_ops
.to_wait
= go32_wait
;
980 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
981 go32_ops
.to_store_registers
= go32_store_registers
;
982 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
983 go32_ops
.deprecated_xfer_memory
= go32_xfer_memory
;
984 go32_ops
.to_files_info
= go32_files_info
;
985 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
986 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
987 go32_ops
.to_terminal_init
= go32_terminal_init
;
988 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
989 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
990 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
991 go32_ops
.to_terminal_info
= go32_terminal_info
;
992 go32_ops
.to_kill
= go32_kill_inferior
;
993 go32_ops
.to_create_inferior
= go32_create_inferior
;
994 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
995 go32_ops
.to_can_run
= go32_can_run
;
996 go32_ops
.to_thread_alive
= go32_thread_alive
;
997 go32_ops
.to_pid_to_str
= go32_pid_to_str
;
998 go32_ops
.to_stratum
= process_stratum
;
999 go32_ops
.to_has_all_memory
= default_child_has_all_memory
;
1000 go32_ops
.to_has_memory
= default_child_has_memory
;
1001 go32_ops
.to_has_stack
= default_child_has_stack
;
1002 go32_ops
.to_has_registers
= default_child_has_registers
;
1003 go32_ops
.to_has_execution
= default_child_has_execution
;
1005 i386_use_watchpoints (&go32_ops
);
1008 i386_dr_low
.set_control
= go32_set_dr7
;
1009 i386_dr_low
.set_addr
= go32_set_dr
;
1010 i386_dr_low
.get_status
= go32_get_dr6
;
1011 i386_dr_low
.get_control
= go32_get_dr7
;
1012 i386_dr_low
.get_addr
= go32_get_dr
;
1013 i386_set_debug_register_length (4);
1015 go32_ops
.to_magic
= OPS_MAGIC
;
1017 /* Initialize child's cwd as empty to be initialized when starting
1021 /* Initialize child's command line storage. */
1022 if (redir_debug_init (&child_cmd
) == -1)
1023 internal_error (__FILE__
, __LINE__
,
1024 _("Cannot allocate redirection storage: "
1025 "not enough memory.\n"));
1027 /* We are always processing GCC-compiled programs. */
1028 processing_gcc_compilation
= 2;
1030 /* Override the default name of the GDB init file. */
1031 strcpy (gdbinit
, "gdb.ini");
1034 /* Return the current DOS codepage number. */
1041 __dpmi_int (0x21, ®s
);
1042 if (!(regs
.x
.flags
& 1))
1043 return regs
.x
.bx
& 0xffff;
1045 return 437; /* default */
1048 /* Limited emulation of `nl_langinfo', for charset.c. */
1050 nl_langinfo (nl_item item
)
1058 /* 8 is enough for SHORT_MAX + "CP" + null. */
1060 int blen
= sizeof (buf
);
1061 int needed
= snprintf (buf
, blen
, "CP%d", dos_codepage ());
1063 if (needed
> blen
) /* Should never happen. */
1065 retval
= xstrdup (buf
);
1069 retval
= xstrdup ("");
1075 unsigned short windows_major
, windows_minor
;
1077 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
1079 go32_get_windows_version(void)
1084 __dpmi_int(0x2f, &r
);
1085 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
1086 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
1088 windows_major
= r
.h
.al
;
1089 windows_minor
= r
.h
.ah
;
1092 windows_major
= 0xff; /* meaning no Windows */
1095 /* A subroutine of go32_sysinfo to display memory info. */
1097 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
1099 if (datum
!= 0xffffffffUL
)
1103 puts_filtered (header
);
1106 printf_filtered ("%lu KB", datum
>> 10);
1107 if (datum
> 1024 * 1024)
1108 printf_filtered (" (%lu MB)", datum
>> 20);
1111 printf_filtered ("%lu Bytes", datum
);
1112 puts_filtered ("\n");
1116 /* Display assorted information about the underlying OS. */
1118 go32_sysinfo (char *arg
, int from_tty
)
1120 static const char test_pattern
[] =
1121 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1122 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1123 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1125 char cpuid_vendor
[13];
1126 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
1127 unsigned true_dos_version
= _get_dos_version (1);
1128 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
1130 char dpmi_vendor_info
[129];
1131 int dpmi_vendor_available
;
1132 __dpmi_version_ret dpmi_version_data
;
1134 __dpmi_free_mem_info mem_info
;
1137 cpuid_vendor
[0] = '\0';
1139 strcpy (u
.machine
, "Unknown x86");
1140 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
1142 /* CPUID with EAX = 0 returns the Vendor ID. */
1143 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1144 "xorl %%ecx, %%ecx;"
1145 "xorl %%edx, %%edx;"
1152 : "=m" (cpuid_vendor
[0]),
1153 "=m" (cpuid_vendor
[4]),
1154 "=m" (cpuid_vendor
[8]),
1157 : "%eax", "%ebx", "%ecx", "%edx");
1158 cpuid_vendor
[12] = '\0';
1161 printf_filtered ("CPU Type.......................%s", u
.machine
);
1162 if (cpuid_vendor
[0])
1163 printf_filtered (" (%s)", cpuid_vendor
);
1164 puts_filtered ("\n");
1166 /* CPUID with EAX = 1 returns processor signature and features. */
1169 static char *brand_name
[] = {
1177 char cpu_string
[80];
1180 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1181 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1182 unsigned cpu_family
, cpu_model
;
1184 __asm__
__volatile__ ("movl $1, %%eax;"
1191 brand_idx
= cpuid_ebx
& 0xff;
1192 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1193 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1194 cpu_brand
[0] = '\0';
1198 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1199 && *brand_name
[brand_idx
])
1200 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1201 else if (cpu_family
== 5)
1203 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1204 strcpy (cpu_brand
, " MMX");
1205 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1206 strcpy (cpu_brand
, " OverDrive");
1207 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1208 strcpy (cpu_brand
, " Dual");
1210 else if (cpu_family
== 6 && cpu_model
< 8)
1215 strcpy (cpu_brand
, " Pro");
1218 strcpy (cpu_brand
, " II");
1221 strcpy (cpu_brand
, " II Xeon");
1224 strcpy (cpu_brand
, " Celeron");
1227 strcpy (cpu_brand
, " III");
1237 strcpy (cpu_brand
, "486/5x86");
1246 strcpy (cpu_brand
, "-K5");
1250 strcpy (cpu_brand
, "-K6");
1253 strcpy (cpu_brand
, "-K6-2");
1256 strcpy (cpu_brand
, "-K6-III");
1266 strcpy (cpu_brand
, " Athlon");
1269 strcpy (cpu_brand
, " Duron");
1275 sprintf (cpu_string
, "%s%s Model %d Stepping %d",
1276 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1277 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1278 printfi_filtered (31, "%s\n", cpu_string
);
1279 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1280 || ((cpuid_edx
& 1) == 0)
1281 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1283 puts_filtered ("CPU Features...................");
1284 /* We only list features which might be useful in the DPMI
1286 if ((cpuid_edx
& 1) == 0)
1287 puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
1288 if ((cpuid_edx
& (1 << 1)) != 0)
1289 puts_filtered ("VME ");
1290 if ((cpuid_edx
& (1 << 2)) != 0)
1291 puts_filtered ("DE ");
1292 if ((cpuid_edx
& (1 << 4)) != 0)
1293 puts_filtered ("TSC ");
1294 if ((cpuid_edx
& (1 << 23)) != 0)
1295 puts_filtered ("MMX ");
1296 if ((cpuid_edx
& (1 << 25)) != 0)
1297 puts_filtered ("SSE ");
1298 if ((cpuid_edx
& (1 << 26)) != 0)
1299 puts_filtered ("SSE2 ");
1302 if ((cpuid_edx
& (1 << 31)) != 0)
1303 puts_filtered ("3DNow! ");
1304 if ((cpuid_edx
& (1 << 30)) != 0)
1305 puts_filtered ("3DNow!Ext");
1307 puts_filtered ("\n");
1310 puts_filtered ("\n");
1311 printf_filtered ("DOS Version....................%s %s.%s",
1312 _os_flavor
, u
.release
, u
.version
);
1313 if (true_dos_version
!= advertized_dos_version
)
1314 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1315 puts_filtered ("\n");
1317 go32_get_windows_version ();
1318 if (windows_major
!= 0xff)
1320 const char *windows_flavor
;
1322 printf_filtered ("Windows Version................%d.%02d (Windows ",
1323 windows_major
, windows_minor
);
1324 switch (windows_major
)
1327 windows_flavor
= "3.X";
1330 switch (windows_minor
)
1333 windows_flavor
= "95, 95A, or 95B";
1336 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1339 windows_flavor
= "98 or 98 SE";
1342 windows_flavor
= "ME";
1345 windows_flavor
= "9X";
1350 windows_flavor
= "??";
1353 printf_filtered ("%s)\n", windows_flavor
);
1355 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1356 printf_filtered ("Windows Version................"
1357 "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1358 puts_filtered ("\n");
1359 /* On some versions of Windows, __dpmi_get_capabilities returns
1360 zero, but the buffer is not filled with info, so we fill the
1361 buffer with a known pattern and test for it afterwards. */
1362 memcpy (dpmi_vendor_info
, test_pattern
, sizeof(dpmi_vendor_info
));
1363 dpmi_vendor_available
=
1364 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
1365 if (dpmi_vendor_available
== 0
1366 && memcmp (dpmi_vendor_info
, test_pattern
,
1367 sizeof(dpmi_vendor_info
)) != 0)
1369 /* The DPMI spec says the vendor string should be ASCIIZ, but
1370 I don't trust the vendors to follow that... */
1371 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1372 dpmi_vendor_info
[128] = '\0';
1373 printf_filtered ("DPMI Host......................"
1374 "%s v%d.%d (capabilities: %#x)\n",
1375 &dpmi_vendor_info
[2],
1376 (unsigned)dpmi_vendor_info
[0],
1377 (unsigned)dpmi_vendor_info
[1],
1378 ((unsigned)dpmi_flags
& 0x7f));
1381 printf_filtered ("DPMI Host......................(Info not available)\n");
1382 __dpmi_get_version (&dpmi_version_data
);
1383 printf_filtered ("DPMI Version...................%d.%02d\n",
1384 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1385 printf_filtered ("DPMI Info......................"
1386 "%s-bit DPMI, with%s Virtual Memory support\n",
1387 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1388 (dpmi_version_data
.flags
& 4) ? "" : "out");
1389 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1390 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1391 printfi_filtered (31, "Processor type: i%d86\n",
1392 dpmi_version_data
.cpu
);
1393 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1394 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1396 /* a_tss is only initialized when the debuggee is first run. */
1397 if (prog_has_started
)
1399 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1400 printf_filtered ("Protection....................."
1401 "Ring %d (in %s), with%s I/O protection\n",
1402 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1403 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1405 puts_filtered ("\n");
1406 __dpmi_get_free_memory_information (&mem_info
);
1407 print_mem (mem_info
.total_number_of_physical_pages
,
1408 "DPMI Total Physical Memory.....", 1);
1409 print_mem (mem_info
.total_number_of_free_pages
,
1410 "DPMI Free Physical Memory......", 1);
1411 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1412 "DPMI Swap Space................", 1);
1413 print_mem (mem_info
.linear_address_space_size_in_pages
,
1414 "DPMI Total Linear Address Size.", 1);
1415 print_mem (mem_info
.free_linear_address_space_in_pages
,
1416 "DPMI Free Linear Address Size..", 1);
1417 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1418 "DPMI Largest Free Memory Block.", 0);
1422 __dpmi_int (0x21, ®s
);
1423 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1425 __dpmi_int (0x21, ®s
);
1426 if ((regs
.x
.flags
& 1) == 0)
1428 static const char *dos_hilo
[] = {
1429 "Low", "", "", "", "High", "", "", "", "High, then Low"
1431 static const char *dos_fit
[] = {
1432 "First", "Best", "Last"
1434 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1435 int fit_idx
= regs
.x
.ax
& 0x0f;
1441 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1442 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1444 __dpmi_int (0x21, ®s
);
1445 if ((regs
.x
.flags
& 1) != 0)
1447 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1448 regs
.h
.al
== 0 ? "not " : "");
1453 unsigned short limit0
;
1454 unsigned short base0
;
1455 unsigned char base1
;
1460 unsigned available
:1;
1463 unsigned page_granular
:1;
1464 unsigned char base2
;
1465 } __attribute__ ((packed
));
1468 unsigned short offset0
;
1469 unsigned short selector
;
1470 unsigned param_count
:5;
1475 unsigned short offset1
;
1476 } __attribute__ ((packed
));
1478 /* Read LEN bytes starting at logical address ADDR, and put the result
1479 into DEST. Return 1 if success, zero if not. */
1481 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1483 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1486 /* For the low memory, we can simply use _dos_ds. */
1487 if (addr
<= dos_ds_limit
- len
)
1488 dosmemget (addr
, len
, dest
);
1491 /* For memory above 1MB we need to set up a special segment to
1492 be able to access that memory. */
1493 int sel
= __dpmi_allocate_ldt_descriptors (1);
1499 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1500 size_t segment_limit
= len
- 1;
1502 /* Make sure the crucial bits in the descriptor access
1503 rights are set correctly. Some DPMI providers might barf
1504 if we set the segment limit to something that is not an
1505 integral multiple of 4KB pages if the granularity bit is
1506 not set to byte-granular, even though the DPMI spec says
1507 it's the host's responsibility to set that bit correctly. */
1508 if (len
> 1024 * 1024)
1510 access_rights
|= 0x8000;
1511 /* Page-granular segments should have the low 12 bits of
1513 segment_limit
|= 0xfff;
1516 access_rights
&= ~0x8000;
1518 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1519 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1520 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1521 /* W2K silently fails to set the segment limit, leaving
1522 it at zero; this test avoids the resulting crash. */
1523 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1524 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1528 __dpmi_free_ldt_descriptor (sel
);
1534 /* Get a segment descriptor stored at index IDX in the descriptor
1535 table whose base address is TABLE_BASE. Return the descriptor
1536 type, or -1 if failure. */
1538 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1540 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1542 if (read_memory_region (addr
, descr
, 8))
1543 return (int)((struct seg_descr
*)descr
)->stype
;
1548 unsigned short limit
__attribute__((packed
));
1549 unsigned long base
__attribute__((packed
));
1552 /* Display a segment descriptor stored at index IDX in a descriptor
1553 table whose type is TYPE and whose base address is BASE_ADDR. If
1554 FORCE is non-zero, display even invalid descriptors. */
1556 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1558 struct seg_descr descr
;
1559 struct gate_descr gate
;
1561 /* Get the descriptor from the table. */
1562 if (idx
== 0 && type
== 0)
1563 puts_filtered ("0x000: null descriptor\n");
1564 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1566 /* For each type of descriptor table, this has a bit set if the
1567 corresponding type of selectors is valid in that table. */
1568 static unsigned allowed_descriptors
[] = {
1569 0xffffdafeL
, /* GDT */
1570 0x0000c0e0L
, /* IDT */
1571 0xffffdafaL
/* LDT */
1574 /* If the program hasn't started yet, assume the debuggee will
1575 have the same CPL as the debugger. */
1576 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1577 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1580 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1582 printf_filtered ("0x%03x: ",
1584 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1585 if (descr
.page_granular
)
1586 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1587 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1588 || descr
.stype
== 9 || descr
.stype
== 11
1589 || (descr
.stype
>= 16 && descr
.stype
< 32))
1590 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1591 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1593 switch (descr
.stype
)
1597 printf_filtered (" 16-bit TSS (task %sactive)",
1598 descr
.stype
== 3 ? "" : "in");
1601 puts_filtered (" LDT");
1604 memcpy (&gate
, &descr
, sizeof gate
);
1605 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1606 gate
.selector
, gate
.offset1
, gate
.offset0
);
1607 printf_filtered (" 16-bit Call Gate (params=%d)",
1611 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1612 printfi_filtered (16, "Task Gate");
1616 memcpy (&gate
, &descr
, sizeof gate
);
1617 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1618 gate
.selector
, gate
.offset1
, gate
.offset0
);
1619 printf_filtered (" 16-bit %s Gate",
1620 descr
.stype
== 6 ? "Interrupt" : "Trap");
1624 printf_filtered (" 32-bit TSS (task %sactive)",
1625 descr
.stype
== 3 ? "" : "in");
1628 memcpy (&gate
, &descr
, sizeof gate
);
1629 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1630 gate
.selector
, gate
.offset1
, gate
.offset0
);
1631 printf_filtered (" 32-bit Call Gate (params=%d)",
1636 memcpy (&gate
, &descr
, sizeof gate
);
1637 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1638 gate
.selector
, gate
.offset1
, gate
.offset0
);
1639 printf_filtered (" 32-bit %s Gate",
1640 descr
.stype
== 14 ? "Interrupt" : "Trap");
1642 case 16: /* data segments */
1650 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1651 descr
.bit32
? "32" : "16",
1653 ? "Read/Write," : "Read-Only, ",
1654 descr
.stype
& 4 ? "down" : "up",
1655 descr
.stype
& 1 ? "" : ", N.Acc");
1657 case 24: /* code segments */
1665 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1666 descr
.bit32
? "32" : "16",
1667 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1668 descr
.stype
& 4 ? "" : "N.",
1669 descr
.stype
& 1 ? "" : ", N.Acc");
1672 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1675 puts_filtered ("\n");
1679 printf_filtered ("0x%03x: ",
1681 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1683 puts_filtered ("Segment not present\n");
1685 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1690 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1694 go32_sldt (char *arg
, int from_tty
)
1696 struct dtr_reg gdtr
;
1697 unsigned short ldtr
= 0;
1699 struct seg_descr ldt_descr
;
1700 long ldt_entry
= -1L;
1701 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1705 while (*arg
&& isspace(*arg
))
1710 ldt_entry
= parse_and_eval_long (arg
);
1712 || (ldt_entry
& 4) == 0
1713 || (ldt_entry
& 3) != (cpl
& 3))
1714 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1718 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1719 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1722 puts_filtered ("There is no LDT.\n");
1723 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1724 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1725 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1727 | (ldt_descr
.base1
<< 16)
1728 | (ldt_descr
.base2
<< 24));
1733 | (ldt_descr
.base1
<< 16)
1734 | (ldt_descr
.base2
<< 24);
1735 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1738 if (ldt_descr
.page_granular
)
1739 /* Page-granular segments must have the low 12 bits of their
1741 limit
= (limit
<< 12) | 0xfff;
1742 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1747 max_entry
= (limit
+ 1) / 8;
1751 if (ldt_entry
> limit
)
1752 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1753 (unsigned long)ldt_entry
, limit
);
1755 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1761 for (i
= 0; i
< max_entry
; i
++)
1762 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1768 go32_sgdt (char *arg
, int from_tty
)
1770 struct dtr_reg gdtr
;
1771 long gdt_entry
= -1L;
1776 while (*arg
&& isspace(*arg
))
1781 gdt_entry
= parse_and_eval_long (arg
);
1782 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1783 error (_("Invalid GDT entry 0x%03lx: "
1784 "not an integral multiple of 8."),
1785 (unsigned long)gdt_entry
);
1789 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1790 max_entry
= (gdtr
.limit
+ 1) / 8;
1794 if (gdt_entry
> gdtr
.limit
)
1795 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1796 (unsigned long)gdt_entry
, gdtr
.limit
);
1798 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1804 for (i
= 0; i
< max_entry
; i
++)
1805 display_descriptor (0, gdtr
.base
, i
, 0);
1810 go32_sidt (char *arg
, int from_tty
)
1812 struct dtr_reg idtr
;
1813 long idt_entry
= -1L;
1818 while (*arg
&& isspace(*arg
))
1823 idt_entry
= parse_and_eval_long (arg
);
1825 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1829 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1830 max_entry
= (idtr
.limit
+ 1) / 8;
1831 if (max_entry
> 0x100) /* No more than 256 entries. */
1836 if (idt_entry
> idtr
.limit
)
1837 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1838 (unsigned long)idt_entry
, idtr
.limit
);
1840 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1846 for (i
= 0; i
< max_entry
; i
++)
1847 display_descriptor (1, idtr
.base
, i
, 0);
1851 /* Cached linear address of the base of the page directory. For
1852 now, available only under CWSDPMI. Code based on ideas and
1853 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1854 static unsigned long pdbr
;
1856 static unsigned long
1861 unsigned long taskbase
, cr3
;
1862 struct dtr_reg gdtr
;
1864 if (pdbr
> 0 && pdbr
<= 0xfffff)
1867 /* Get the linear address of GDT and the Task Register. */
1868 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1869 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1871 /* Task Register is a segment selector for the TSS of the current
1872 task. Therefore, it can be used as an index into the GDT to get
1873 at the segment descriptor for the TSS. To get the index, reset
1874 the low 3 bits of the selector (which give the CPL). Add 2 to the
1875 offset to point to the 3 low bytes of the base address. */
1876 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1879 /* CWSDPMI's task base is always under the 1MB mark. */
1880 if (offset
> 0xfffff)
1883 _farsetsel (_dos_ds
);
1884 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1885 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1886 if (taskbase
> 0xfffff)
1889 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1890 offset 1Ch in the TSS. */
1891 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1894 #if 0 /* Not fullly supported yet. */
1895 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1896 the first Page Table right below the Page Directory. Thus,
1897 the first Page Table's entry for its own address and the Page
1898 Directory entry for that Page Table will hold the same
1899 physical address. The loop below searches the entire UMB
1900 range of addresses for such an occurence. */
1901 unsigned long addr
, pte_idx
;
1903 for (addr
= 0xb0000, pte_idx
= 0xb0;
1905 addr
+= 0x1000, pte_idx
++)
1907 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1908 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1909 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1911 cr3
= addr
+ 0x1000;
1924 /* Return the N'th Page Directory entry. */
1925 static unsigned long
1928 unsigned long pde
= 0;
1930 if (pdbr
&& n
>= 0 && n
< 1024)
1932 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1937 /* Return the N'th entry of the Page Table whose Page Directory entry
1939 static unsigned long
1940 get_pte (unsigned long pde
, int n
)
1942 unsigned long pte
= 0;
1944 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1945 page tables, for now. */
1946 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1948 pde
&= ~0xfff; /* Clear non-address bits. */
1949 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1954 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1955 says this is a Page Directory entry. If FORCE is non-zero, display
1956 the entry even if its Present flag is off. OFF is the offset of the
1957 address from the page's base address. */
1959 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1961 if ((entry
& 1) != 0)
1963 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1964 if ((entry
& 0x100) && !is_dir
)
1965 puts_filtered (" Global");
1966 if ((entry
& 0x40) && !is_dir
)
1967 puts_filtered (" Dirty");
1968 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1969 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1970 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1971 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1972 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1974 printf_filtered (" +0x%x", off
);
1975 puts_filtered ("\n");
1978 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1979 is_dir
? " Table" : "", entry
>> 1);
1983 go32_pde (char *arg
, int from_tty
)
1985 long pde_idx
= -1, i
;
1989 while (*arg
&& isspace(*arg
))
1994 pde_idx
= parse_and_eval_long (arg
);
1995 if (pde_idx
< 0 || pde_idx
>= 1024)
1996 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2002 puts_filtered ("Access to Page Directories is "
2003 "not supported on this system.\n");
2004 else if (pde_idx
>= 0)
2005 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
2007 for (i
= 0; i
< 1024; i
++)
2008 display_ptable_entry (get_pde (i
), 1, 0, 0);
2011 /* A helper function to display entries in a Page Table pointed to by
2012 the N'th entry in the Page Directory. If FORCE is non-zero, say
2013 something even if the Page Table is not accessible. */
2015 display_page_table (long n
, int force
)
2017 unsigned long pde
= get_pde (n
);
2023 printf_filtered ("Page Table pointed to by "
2024 "Page Directory entry 0x%lx:\n", n
);
2025 for (i
= 0; i
< 1024; i
++)
2026 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
2027 puts_filtered ("\n");
2030 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
2034 go32_pte (char *arg
, int from_tty
)
2036 long pde_idx
= -1L, i
;
2040 while (*arg
&& isspace(*arg
))
2045 pde_idx
= parse_and_eval_long (arg
);
2046 if (pde_idx
< 0 || pde_idx
>= 1024)
2047 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2053 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2054 else if (pde_idx
>= 0)
2055 display_page_table (pde_idx
, 1);
2057 for (i
= 0; i
< 1024; i
++)
2058 display_page_table (i
, 0);
2062 go32_pte_for_address (char *arg
, int from_tty
)
2064 CORE_ADDR addr
= 0, i
;
2068 while (*arg
&& isspace(*arg
))
2072 addr
= parse_and_eval_address (arg
);
2075 error_no_arg (_("linear address"));
2079 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2082 int pde_idx
= (addr
>> 22) & 0x3ff;
2083 int pte_idx
= (addr
>> 12) & 0x3ff;
2084 unsigned offs
= addr
& 0xfff;
2086 printf_filtered ("Page Table entry for address %s:\n",
2088 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
2092 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
2095 go32_info_dos_command (char *args
, int from_tty
)
2097 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
2101 _initialize_go32_nat (void)
2104 add_target (&go32_ops
);
2106 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
2107 Print information specific to DJGPP (aka MS-DOS) debugging."),
2108 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
2110 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
2111 Display information about the target system, including CPU, OS, DPMI, etc."),
2113 add_cmd ("ldt", class_info
, go32_sldt
, _("\
2114 Display entries in the LDT (Local Descriptor Table).\n\
2115 Entry number (an expression) as an argument means display only that entry."),
2117 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
2118 Display entries in the GDT (Global Descriptor Table).\n\
2119 Entry number (an expression) as an argument means display only that entry."),
2121 add_cmd ("idt", class_info
, go32_sidt
, _("\
2122 Display entries in the IDT (Interrupt Descriptor Table).\n\
2123 Entry number (an expression) as an argument means display only that entry."),
2125 add_cmd ("pde", class_info
, go32_pde
, _("\
2126 Display entries in the Page Directory.\n\
2127 Entry number (an expression) as an argument means display only that entry."),
2129 add_cmd ("pte", class_info
, go32_pte
, _("\
2130 Display entries in Page Tables.\n\
2131 Entry number (an expression) as an argument means display only entries\n\
2132 from the Page Table pointed to by the specified Page Directory entry."),
2134 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
2135 Display a Page Table entry for a linear address.\n\
2136 The address argument must be a linear address, after adding to\n\
2137 it the base address of the appropriate segment.\n\
2138 The base address of variables and functions in the debuggee's data\n\
2139 or code segment is stored in the variable __djgpp_base_address,\n\
2140 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2141 For other segments, look up their base address in the output of\n\
2142 the `info dos ldt' command."),
2156 tcsetpgrp (int fd
, pid_t pgid
)
2158 if (isatty (fd
) && pgid
== SOME_PID
)
2160 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;