1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright (C) 1997-2014 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 3 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, see <http://www.gnu.org/licenses/>. */
20 /* To whomever it may concern, here's a general description of how
21 debugging in DJGPP works, and the special quirks GDB does to
24 When the DJGPP port of GDB is debugging a DJGPP program natively,
25 there aren't 2 separate processes, the debuggee and GDB itself, as
26 on other systems. (This is DOS, where there can only be one active
27 process at any given time, remember?) Instead, GDB and the
28 debuggee live in the same process. So when GDB calls
29 go32_create_inferior below, and that function calls edi_init from
30 the DJGPP debug support library libdbg.a, we load the debuggee's
31 executable file into GDB's address space, set it up for execution
32 as the stub loader (a short real-mode program prepended to each
33 DJGPP executable) normally would, and do a lot of preparations for
34 swapping between GDB's and debuggee's internal state, primarily wrt
35 the exception handlers. This swapping happens every time we resume
36 the debuggee or switch back to GDB's code, and it includes:
38 . swapping all the segment registers
39 . swapping the PSP (the Program Segment Prefix)
40 . swapping the signal handlers
41 . swapping the exception handlers
42 . swapping the FPU status
43 . swapping the 3 standard file handles (more about this below)
45 Then running the debuggee simply means longjmp into it where its PC
46 is and let it run until it stops for some reason. When it stops,
47 GDB catches the exception that stopped it and longjmp's back into
48 its own code. All the possible exit points of the debuggee are
49 watched; for example, the normal exit point is recognized because a
50 DOS program issues a special system call to exit. If one of those
51 exit points is hit, we mourn the inferior and clean up after it.
52 Cleaning up is very important, even if the process exits normally,
53 because otherwise we might leave behind traces of previous
54 execution, and in several cases GDB itself might be left hosed,
55 because all the exception handlers were not restored.
57 Swapping of the standard handles (in redir_to_child and
58 redir_to_debugger) is needed because, since both GDB and the
59 debuggee live in the same process, as far as the OS is concerned,
60 the share the same file table. This means that the standard
61 handles 0, 1, and 2 point to the same file table entries, and thus
62 are connected to the same devices. Therefore, if the debugger
63 redirects its standard output, the standard output of the debuggee
64 is also automagically redirected to the same file/device!
65 Similarly, if the debuggee redirects its stdout to a file, you
66 won't be able to see debugger's output (it will go to the same file
67 where the debuggee has its output); and if the debuggee closes its
68 standard input, you will lose the ability to talk to debugger!
70 For this reason, every time the debuggee is about to be resumed, we
71 call redir_to_child, which redirects the standard handles to where
72 the debuggee expects them to be. When the debuggee stops and GDB
73 regains control, we call redir_to_debugger, which redirects those 3
74 handles back to where GDB expects.
76 Note that only the first 3 handles are swapped, so if the debuggee
77 redirects or closes any other handles, GDB will not notice. In
78 particular, the exit code of a DJGPP program forcibly closes all
79 file handles beyond the first 3 ones, so when the debuggee exits,
80 GDB currently loses its stdaux and stdprn streams. Fortunately,
81 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"
99 #include "i386-cpuid.h"
101 #include "regcache.h"
104 #include "cli/cli-utils.h"
105 #include "inf-child.h"
107 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
112 #include <sys/utsname.h>
117 #include <sys/farptr.h>
118 #include <debug/v2load.h>
119 #include <debug/dbgcom.h>
120 #if __DJGPP_MINOR__ > 2
121 #include <debug/redir.h>
124 #include <langinfo.h>
126 #if __DJGPP_MINOR__ < 3
127 /* This code will be provided from DJGPP 2.03 on. Until then I code it
135 unsigned short exponent
:15;
136 unsigned short sign
:1;
142 unsigned int control
;
147 unsigned int dataptr
;
148 unsigned int datasel
;
155 static void save_npx (void); /* Save the FPU of the debugged program. */
156 static void load_npx (void); /* Restore the FPU of the debugged program. */
158 /* ------------------------------------------------------------------------- */
159 /* Store the contents of the NPX in the global variable `npx'. */
165 asm ("inb $0xa0, %%al \n\
166 testb $0x20, %%al \n\
184 /* ------------------------------------------------------------------------- */
185 /* Reload the contents of the NPX from the global variable `npx'. */
190 asm ("frstor %0":"=m" (npx
));
192 /* ------------------------------------------------------------------------- */
193 /* Stubs for the missing redirection functions. */
200 redir_cmdline_delete (cmdline_t
*ptr
)
206 redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
212 redir_to_child (cmdline_t
*ptr
)
218 redir_to_debugger (cmdline_t
*ptr
)
224 redir_debug_init (cmdline_t
*ptr
)
228 #endif /* __DJGPP_MINOR < 3 */
230 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
232 /* This holds the current reference counts for each debug register. */
233 static int dr_ref_count
[4];
237 static int prog_has_started
= 0;
238 static void go32_mourn_inferior (struct target_ops
*ops
);
240 #define r_ofs(x) (offsetof(TSS,x))
249 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
250 {r_ofs (tss_ecx
), 4},
251 {r_ofs (tss_edx
), 4},
252 {r_ofs (tss_ebx
), 4},
253 {r_ofs (tss_esp
), 4},
254 {r_ofs (tss_ebp
), 4},
255 {r_ofs (tss_esi
), 4},
256 {r_ofs (tss_edi
), 4},
257 {r_ofs (tss_eip
), 4},
258 {r_ofs (tss_eflags
), 4},
265 {0, 10}, /* 8 FP registers, from npx.reg[] */
273 /* The order of the next 7 registers must be consistent
274 with their numbering in config/i386/tm-i386.h, which see. */
275 {0, 2}, /* control word, from npx */
276 {4, 2}, /* status word, from npx */
277 {8, 2}, /* tag word, from npx */
278 {16, 2}, /* last FP exception CS from npx */
279 {12, 4}, /* last FP exception EIP from npx */
280 {24, 2}, /* last FP exception operand selector from npx */
281 {20, 4}, /* last FP exception operand offset from npx */
282 {18, 2} /* last FP opcode from npx */
288 enum gdb_signal gdb_sig
;
293 {1, GDB_SIGNAL_TRAP
},
294 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
295 but I think SIGBUS is better, since the NMI is usually activated
296 as a result of a memory parity check failure. */
298 {3, GDB_SIGNAL_TRAP
},
300 {5, GDB_SIGNAL_SEGV
},
302 {7, GDB_SIGNAL_EMT
}, /* no-coprocessor exception */
303 {8, GDB_SIGNAL_SEGV
},
304 {9, GDB_SIGNAL_SEGV
},
305 {10, GDB_SIGNAL_BUS
},
306 {11, GDB_SIGNAL_SEGV
},
307 {12, GDB_SIGNAL_SEGV
},
308 {13, GDB_SIGNAL_SEGV
},
309 {14, GDB_SIGNAL_SEGV
},
310 {16, GDB_SIGNAL_FPE
},
311 {17, GDB_SIGNAL_BUS
},
312 {31, GDB_SIGNAL_ILL
},
313 {0x1b, GDB_SIGNAL_INT
},
314 {0x75, GDB_SIGNAL_FPE
},
315 {0x78, GDB_SIGNAL_ALRM
},
316 {0x79, GDB_SIGNAL_INT
},
317 {0x7a, GDB_SIGNAL_QUIT
},
318 {-1, GDB_SIGNAL_LAST
}
322 enum gdb_signal gdb_sig
;
326 {GDB_SIGNAL_ILL
, 6}, /* Invalid Opcode */
327 {GDB_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
328 {GDB_SIGNAL_SEGV
, 13}, /* GPF */
329 {GDB_SIGNAL_BUS
, 17}, /* Alignment Check */
330 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
332 {GDB_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
333 {GDB_SIGNAL_FPE
, 0x75},
334 {GDB_SIGNAL_INT
, 0x79},
335 {GDB_SIGNAL_QUIT
, 0x7a},
336 {GDB_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
337 {GDB_SIGNAL_PROF
, 0x78},
338 {GDB_SIGNAL_LAST
, -1}
342 go32_open (char *name
, int from_tty
)
344 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
348 go32_attach (struct target_ops
*ops
, char *args
, int from_tty
)
351 You cannot attach to a running program on this platform.\n\
352 Use the `run' command to run DJGPP programs."));
355 static int resume_is_step
;
356 static int resume_signal
= -1;
359 go32_resume (struct target_ops
*ops
,
360 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
364 resume_is_step
= step
;
366 if (siggnal
!= GDB_SIGNAL_0
&& siggnal
!= GDB_SIGNAL_TRAP
)
368 for (i
= 0, resume_signal
= -1;
369 excepn_map
[i
].gdb_sig
!= GDB_SIGNAL_LAST
; i
++)
370 if (excepn_map
[i
].gdb_sig
== siggnal
)
372 resume_signal
= excepn_map
[i
].djgpp_excepno
;
375 if (resume_signal
== -1)
376 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
377 gdb_signal_to_name (siggnal
));
381 static char child_cwd
[FILENAME_MAX
];
384 go32_wait (struct target_ops
*ops
,
385 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
388 unsigned char saved_opcode
;
389 unsigned long INT3_addr
= 0;
390 int stepping_over_INT
= 0;
392 a_tss
.tss_eflags
&= 0xfeff; /* Reset the single-step flag (TF). */
395 /* If the next instruction is INT xx or INTO, we need to handle
396 them specially. Intel manuals say that these instructions
397 reset the single-step flag (a.k.a. TF). However, it seems
398 that, at least in the DPMI environment, and at least when
399 stepping over the DPMI interrupt 31h, the problem is having
400 TF set at all when INT 31h is executed: the debuggee either
401 crashes (and takes the system with it) or is killed by a
404 So we need to emulate single-step mode: we put an INT3 opcode
405 right after the INT xx instruction, let the debuggee run
406 until it hits INT3 and stops, then restore the original
407 instruction which we overwrote with the INT3 opcode, and back
408 up the debuggee's EIP to that instruction. */
409 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
410 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
412 unsigned char INT3_opcode
= 0xCC;
415 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
416 stepping_over_INT
= 1;
417 read_child (INT3_addr
, &saved_opcode
, 1);
418 write_child (INT3_addr
, &INT3_opcode
, 1);
421 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
424 /* The special value FFFFh in tss_trap indicates to run_child that
425 tss_irqn holds a signal to be delivered to the debuggee. */
426 if (resume_signal
<= -1)
429 a_tss
.tss_irqn
= 0xff;
433 a_tss
.tss_trap
= 0xffff; /* run_child looks for this. */
434 a_tss
.tss_irqn
= resume_signal
;
437 /* The child might change working directory behind our back. The
438 GDB users won't like the side effects of that when they work with
439 relative file names, and GDB might be confused by its current
440 directory not being in sync with the truth. So we always make a
441 point of changing back to where GDB thinks is its cwd, when we
442 return control to the debugger, but restore child's cwd before we
444 /* Initialize child_cwd, before the first call to run_child and not
445 in the initialization, so the child get also the changed directory
446 set with the gdb-command "cd ..." */
448 /* Initialize child's cwd with the current one. */
449 getcwd (child_cwd
, sizeof (child_cwd
));
453 #if __DJGPP_MINOR__ < 3
457 #if __DJGPP_MINOR__ < 3
461 /* Did we step over an INT xx instruction? */
462 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
464 /* Restore the original opcode. */
465 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction. */
466 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
467 /* Simulate a TRAP exception. */
469 a_tss
.tss_eflags
|= 0x0100;
472 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
473 chdir (current_directory
);
475 if (a_tss
.tss_irqn
== 0x21)
477 status
->kind
= TARGET_WAITKIND_EXITED
;
478 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
482 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
483 status
->kind
= TARGET_WAITKIND_STOPPED
;
484 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
486 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
488 #if __DJGPP_MINOR__ < 3
489 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
491 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
493 status
->value
.sig
= sig_map
[i
].gdb_sig
;
499 return pid_to_ptid (SOME_PID
);
503 fetch_register (struct regcache
*regcache
, int regno
)
505 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
506 if (regno
< gdbarch_fp0_regnum (gdbarch
))
507 regcache_raw_supply (regcache
, regno
,
508 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
509 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
511 i387_supply_fsave (regcache
, regno
, &npx
);
513 internal_error (__FILE__
, __LINE__
,
514 _("Invalid register no. %d in fetch_register."), regno
);
518 go32_fetch_registers (struct target_ops
*ops
,
519 struct regcache
*regcache
, int regno
)
522 fetch_register (regcache
, regno
);
526 regno
< gdbarch_fp0_regnum (get_regcache_arch (regcache
));
528 fetch_register (regcache
, regno
);
529 i387_supply_fsave (regcache
, -1, &npx
);
534 store_register (const struct regcache
*regcache
, int regno
)
536 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
537 if (regno
< gdbarch_fp0_regnum (gdbarch
))
538 regcache_raw_collect (regcache
, regno
,
539 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
540 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
542 i387_collect_fsave (regcache
, regno
, &npx
);
544 internal_error (__FILE__
, __LINE__
,
545 _("Invalid register no. %d in store_register."), regno
);
549 go32_store_registers (struct target_ops
*ops
,
550 struct regcache
*regcache
, int regno
)
555 store_register (regcache
, regno
);
558 for (r
= 0; r
< gdbarch_fp0_regnum (get_regcache_arch (regcache
)); r
++)
559 store_register (regcache
, r
);
560 i387_collect_fsave (regcache
, -1, &npx
);
564 /* Const-correct version of DJGPP's write_child, which unfortunately
565 takes a non-const buffer pointer. */
568 my_write_child (unsigned child_addr
, const void *buf
, unsigned len
)
570 static void *buffer
= NULL
;
571 static unsigned buffer_len
= 0;
574 if (buffer_len
< len
)
576 buffer
= xrealloc (buffer
, len
);
580 memcpy (buffer
, buf
, len
);
581 res
= write_child (child_addr
, buffer
, len
);
585 /* Helper for go32_xfer_partial that handles memory transfers.
586 Arguments are like target_xfer_partial. */
588 static enum target_xfer_status
589 go32_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
590 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
594 if (writebuf
!= NULL
)
595 res
= my_write_child (memaddr
, writebuf
, len
);
597 res
= read_child (memaddr
, readbuf
, len
);
600 return TARGET_XFER_E_IO
;
603 return TARGET_XFER_OK
;
606 /* Target to_xfer_partial implementation. */
608 static enum target_xfer_status
609 go32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
610 const char *annex
, gdb_byte
*readbuf
,
611 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
612 ULONGEST
*xfered_len
)
616 case TARGET_OBJECT_MEMORY
:
617 return go32_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
620 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
621 readbuf
, writebuf
, offset
, len
,
626 static cmdline_t child_cmd
; /* Parsed child's command line kept here. */
629 go32_files_info (struct target_ops
*target
)
631 printf_unfiltered ("You are running a DJGPP V2 program.\n");
635 go32_kill_inferior (struct target_ops
*ops
)
637 go32_mourn_inferior (ops
);
641 go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
642 char *args
, char **env
, int from_tty
)
644 extern char **environ
;
647 char **env_save
= environ
;
649 struct inferior
*inf
;
651 /* If no exec file handed to us, get it from the exec-file command -- with
652 a good, common error message if none is specified. */
654 exec_file
= get_exec_file (1);
659 /* Initialize child's cwd as empty to be initialized when starting
663 /* Init command line storage. */
664 if (redir_debug_init (&child_cmd
) == -1)
665 internal_error (__FILE__
, __LINE__
,
666 _("Cannot allocate redirection storage: "
667 "not enough memory.\n"));
669 /* Parse the command line and create redirections. */
670 if (strpbrk (args
, "<>"))
672 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
673 args
= child_cmd
.command
;
675 error (_("Syntax error in command line."));
678 child_cmd
.command
= xstrdup (args
);
680 cmdlen
= strlen (args
);
681 /* v2loadimage passes command lines via DOS memory, so it cannot
682 possibly handle commands longer than 1MB. */
683 if (cmdlen
> 1024*1024)
684 error (_("Command line too long."));
686 cmdline
= xmalloc (cmdlen
+ 4);
687 strcpy (cmdline
+ 1, args
);
688 /* If the command-line length fits into DOS 126-char limits, use the
689 DOS command tail format; otherwise, tell v2loadimage to pass it
690 through a buffer in conventional memory. */
693 cmdline
[0] = strlen (args
);
694 cmdline
[cmdlen
+ 1] = 13;
697 cmdline
[0] = 0xff; /* Signal v2loadimage it's a long command. */
701 if (v2loadimage (exec_file
, cmdline
, start_state
))
704 printf_unfiltered ("Load failed for image %s\n", exec_file
);
710 edi_init (start_state
);
711 #if __DJGPP_MINOR__ < 3
715 inferior_ptid
= pid_to_ptid (SOME_PID
);
716 inf
= current_inferior ();
717 inferior_appeared (inf
, SOME_PID
);
721 add_thread_silent (inferior_ptid
);
723 clear_proceed_status ();
724 insert_breakpoints ();
725 prog_has_started
= 1;
729 go32_mourn_inferior (struct target_ops
*ops
)
733 redir_cmdline_delete (&child_cmd
);
739 /* We need to make sure all the breakpoint enable bits in the DR7
740 register are reset when the inferior exits. Otherwise, if they
741 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
742 failure to set more watchpoints, and other calamities. It would
743 be nice if GDB itself would take care to remove all breakpoints
744 at all times, but it doesn't, probably under an assumption that
745 the OS cleans up when the debuggee exits. */
746 i386_cleanup_dregs ();
748 ptid
= inferior_ptid
;
749 inferior_ptid
= null_ptid
;
750 delete_thread_silent (ptid
);
751 prog_has_started
= 0;
754 generic_mourn_inferior ();
757 /* Hardware watchpoint support. */
759 #define D_REGS edi.dr
760 #define CONTROL D_REGS[7]
761 #define STATUS D_REGS[6]
763 /* Pass the address ADDR to the inferior in the I'th debug register.
764 Here we just store the address in D_REGS, the watchpoint will be
765 actually set up when go32_wait runs the debuggee. */
767 go32_set_dr (int i
, CORE_ADDR addr
)
770 internal_error (__FILE__
, __LINE__
,
771 _("Invalid register %d in go32_set_dr.\n"), i
);
775 /* Pass the value VAL to the inferior in the DR7 debug control
776 register. Here we just store the address in D_REGS, the watchpoint
777 will be actually set up when go32_wait runs the debuggee. */
779 go32_set_dr7 (unsigned long val
)
784 /* Get the value of the DR6 debug status register from the inferior.
785 Here we just return the value stored in D_REGS, as we've got it
786 from the last go32_wait call. */
793 /* Get the value of the DR7 debug status register from the inferior.
794 Here we just return the value stored in D_REGS, as we've got it
795 from the last go32_wait call. */
803 /* Get the value of the DR debug register I from the inferior. Here
804 we just return the value stored in D_REGS, as we've got it from the
805 last go32_wait call. */
811 internal_error (__FILE__
, __LINE__
,
812 _("Invalid register %d in go32_get_dr.\n"), i
);
816 /* Put the device open on handle FD into either raw or cooked
817 mode, return 1 if it was in raw mode, zero otherwise. */
820 device_mode (int fd
, int raw_p
)
822 int oldmode
, newmode
;
827 __dpmi_int (0x21, ®s
);
828 if (regs
.x
.flags
& 1)
830 newmode
= oldmode
= regs
.x
.dx
;
837 if (oldmode
& 0x80) /* Only for character dev. */
841 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails. */
842 __dpmi_int (0x21, ®s
);
843 if (regs
.x
.flags
& 1)
846 return (oldmode
& 0x20) == 0x20;
850 static int inf_mode_valid
= 0;
851 static int inf_terminal_mode
;
853 /* This semaphore is needed because, amazingly enough, GDB calls
854 target.to_terminal_ours more than once after the inferior stops.
855 But we need the information from the first call only, since the
856 second call will always see GDB's own cooked terminal. */
857 static int terminal_is_ours
= 1;
860 go32_terminal_init (struct target_ops
*self
)
862 inf_mode_valid
= 0; /* Reinitialize, in case they are restarting child. */
863 terminal_is_ours
= 1;
867 go32_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
869 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
871 ? "default" : inf_terminal_mode
? "raw" : "cooked");
873 #if __DJGPP_MINOR__ > 2
874 if (child_cmd
.redirection
)
878 for (i
= 0; i
< DBG_HANDLES
; i
++)
880 if (child_cmd
.redirection
[i
]->file_name
)
881 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
882 i
, child_cmd
.redirection
[i
]->file_name
);
883 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
885 ("\tFile handle %d appears to be closed by inferior.\n", i
);
886 /* Mask off the raw/cooked bit when comparing device info words. */
887 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
888 != (_get_dev_info (i
) & 0xdf))
890 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
897 go32_terminal_inferior (struct target_ops
*self
)
899 /* Redirect standard handles as child wants them. */
901 if (redir_to_child (&child_cmd
) == -1)
903 redir_to_debugger (&child_cmd
);
904 error (_("Cannot redirect standard handles for program: %s."),
905 safe_strerror (errno
));
907 /* Set the console device of the inferior to whatever mode
908 (raw or cooked) we found it last time. */
909 if (terminal_is_ours
)
912 device_mode (0, inf_terminal_mode
);
913 terminal_is_ours
= 0;
918 go32_terminal_ours (struct target_ops
*self
)
920 /* Switch to cooked mode on the gdb terminal and save the inferior
921 terminal mode to be restored when it is resumed. */
922 if (!terminal_is_ours
)
924 inf_terminal_mode
= device_mode (0, 0);
925 if (inf_terminal_mode
!= -1)
928 /* If device_mode returned -1, we don't know what happens with
929 handle 0 anymore, so make the info invalid. */
931 terminal_is_ours
= 1;
933 /* Restore debugger's standard handles. */
935 if (redir_to_debugger (&child_cmd
) == -1)
937 redir_to_child (&child_cmd
);
938 error (_("Cannot redirect standard handles for debugger: %s."),
939 safe_strerror (errno
));
945 go32_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
947 return !ptid_equal (inferior_ptid
, null_ptid
);
951 go32_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
953 return normal_pid_to_str (ptid
);
956 /* Create a go32 target. */
958 static struct target_ops
*
961 struct target_ops
*t
= inf_child_target ();
963 t
->to_shortname
= "djgpp";
964 t
->to_longname
= "djgpp target process";
966 = "Program loaded by djgpp, when gdb is used as an external debugger";
967 t
->to_open
= go32_open
;
968 t
->to_attach
= go32_attach
;
969 t
->to_resume
= go32_resume
;
970 t
->to_wait
= go32_wait
;
971 t
->to_fetch_registers
= go32_fetch_registers
;
972 t
->to_store_registers
= go32_store_registers
;
973 t
->to_xfer_partial
= go32_xfer_partial
;
974 t
->to_files_info
= go32_files_info
;
975 t
->to_terminal_init
= go32_terminal_init
;
976 t
->to_terminal_inferior
= go32_terminal_inferior
;
977 t
->to_terminal_ours_for_output
= go32_terminal_ours
;
978 t
->to_terminal_ours
= go32_terminal_ours
;
979 t
->to_terminal_info
= go32_terminal_info
;
980 t
->to_kill
= go32_kill_inferior
;
981 t
->to_create_inferior
= go32_create_inferior
;
982 t
->to_mourn_inferior
= go32_mourn_inferior
;
983 t
->to_thread_alive
= go32_thread_alive
;
984 t
->to_pid_to_str
= go32_pid_to_str
;
989 /* Return the current DOS codepage number. */
996 __dpmi_int (0x21, ®s
);
997 if (!(regs
.x
.flags
& 1))
998 return regs
.x
.bx
& 0xffff;
1000 return 437; /* default */
1003 /* Limited emulation of `nl_langinfo', for charset.c. */
1005 nl_langinfo (nl_item item
)
1013 /* 8 is enough for SHORT_MAX + "CP" + null. */
1015 int blen
= sizeof (buf
);
1016 int needed
= snprintf (buf
, blen
, "CP%d", dos_codepage ());
1018 if (needed
> blen
) /* Should never happen. */
1020 retval
= xstrdup (buf
);
1024 retval
= xstrdup ("");
1030 unsigned short windows_major
, windows_minor
;
1032 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
1034 go32_get_windows_version(void)
1039 __dpmi_int(0x2f, &r
);
1040 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
1041 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
1043 windows_major
= r
.h
.al
;
1044 windows_minor
= r
.h
.ah
;
1047 windows_major
= 0xff; /* meaning no Windows */
1050 /* A subroutine of go32_sysinfo to display memory info. */
1052 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
1054 if (datum
!= 0xffffffffUL
)
1058 puts_filtered (header
);
1061 printf_filtered ("%lu KB", datum
>> 10);
1062 if (datum
> 1024 * 1024)
1063 printf_filtered (" (%lu MB)", datum
>> 20);
1066 printf_filtered ("%lu Bytes", datum
);
1067 puts_filtered ("\n");
1071 /* Display assorted information about the underlying OS. */
1073 go32_sysinfo (char *arg
, int from_tty
)
1075 static const char test_pattern
[] =
1076 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1077 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1078 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1080 char cpuid_vendor
[13];
1081 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
1082 unsigned true_dos_version
= _get_dos_version (1);
1083 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
1085 char dpmi_vendor_info
[129];
1086 int dpmi_vendor_available
;
1087 __dpmi_version_ret dpmi_version_data
;
1089 __dpmi_free_mem_info mem_info
;
1092 cpuid_vendor
[0] = '\0';
1094 strcpy (u
.machine
, "Unknown x86");
1095 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
1097 /* CPUID with EAX = 0 returns the Vendor ID. */
1099 /* Ideally we would use i386_cpuid(), but it needs someone to run
1100 native tests first to make sure things actually work. They should.
1101 http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html */
1102 unsigned int eax
, ebx
, ecx
, edx
;
1104 if (i386_cpuid (0, &eax
, &ebx
, &ecx
, &edx
))
1107 memcpy (&vendor
[0], &ebx
, 4);
1108 memcpy (&vendor
[4], &ecx
, 4);
1109 memcpy (&vendor
[8], &edx
, 4);
1110 cpuid_vendor
[12] = '\0';
1113 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1114 "xorl %%ecx, %%ecx;"
1115 "xorl %%edx, %%edx;"
1122 : "=m" (cpuid_vendor
[0]),
1123 "=m" (cpuid_vendor
[4]),
1124 "=m" (cpuid_vendor
[8]),
1127 : "%eax", "%ebx", "%ecx", "%edx");
1128 cpuid_vendor
[12] = '\0';
1132 printf_filtered ("CPU Type.......................%s", u
.machine
);
1133 if (cpuid_vendor
[0])
1134 printf_filtered (" (%s)", cpuid_vendor
);
1135 puts_filtered ("\n");
1137 /* CPUID with EAX = 1 returns processor signature and features. */
1140 static char *brand_name
[] = {
1148 char cpu_string
[80];
1151 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1152 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1153 unsigned cpu_family
, cpu_model
;
1156 /* See comment above about cpuid usage. */
1157 i386_cpuid (1, &cpuid_eax
, &cpuid_ebx
, NULL
, &cpuid_edx
);
1159 __asm__
__volatile__ ("movl $1, %%eax;"
1167 brand_idx
= cpuid_ebx
& 0xff;
1168 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1169 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1170 cpu_brand
[0] = '\0';
1174 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1175 && *brand_name
[brand_idx
])
1176 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1177 else if (cpu_family
== 5)
1179 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1180 strcpy (cpu_brand
, " MMX");
1181 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1182 strcpy (cpu_brand
, " OverDrive");
1183 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1184 strcpy (cpu_brand
, " Dual");
1186 else if (cpu_family
== 6 && cpu_model
< 8)
1191 strcpy (cpu_brand
, " Pro");
1194 strcpy (cpu_brand
, " II");
1197 strcpy (cpu_brand
, " II Xeon");
1200 strcpy (cpu_brand
, " Celeron");
1203 strcpy (cpu_brand
, " III");
1213 strcpy (cpu_brand
, "486/5x86");
1222 strcpy (cpu_brand
, "-K5");
1226 strcpy (cpu_brand
, "-K6");
1229 strcpy (cpu_brand
, "-K6-2");
1232 strcpy (cpu_brand
, "-K6-III");
1242 strcpy (cpu_brand
, " Athlon");
1245 strcpy (cpu_brand
, " Duron");
1251 xsnprintf (cpu_string
, sizeof (cpu_string
), "%s%s Model %d Stepping %d",
1252 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1253 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1254 printfi_filtered (31, "%s\n", cpu_string
);
1255 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1256 || ((cpuid_edx
& 1) == 0)
1257 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1259 puts_filtered ("CPU Features...................");
1260 /* We only list features which might be useful in the DPMI
1262 if ((cpuid_edx
& 1) == 0)
1263 puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
1264 if ((cpuid_edx
& (1 << 1)) != 0)
1265 puts_filtered ("VME ");
1266 if ((cpuid_edx
& (1 << 2)) != 0)
1267 puts_filtered ("DE ");
1268 if ((cpuid_edx
& (1 << 4)) != 0)
1269 puts_filtered ("TSC ");
1270 if ((cpuid_edx
& (1 << 23)) != 0)
1271 puts_filtered ("MMX ");
1272 if ((cpuid_edx
& (1 << 25)) != 0)
1273 puts_filtered ("SSE ");
1274 if ((cpuid_edx
& (1 << 26)) != 0)
1275 puts_filtered ("SSE2 ");
1278 if ((cpuid_edx
& (1 << 31)) != 0)
1279 puts_filtered ("3DNow! ");
1280 if ((cpuid_edx
& (1 << 30)) != 0)
1281 puts_filtered ("3DNow!Ext");
1283 puts_filtered ("\n");
1286 puts_filtered ("\n");
1287 printf_filtered ("DOS Version....................%s %s.%s",
1288 _os_flavor
, u
.release
, u
.version
);
1289 if (true_dos_version
!= advertized_dos_version
)
1290 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1291 puts_filtered ("\n");
1293 go32_get_windows_version ();
1294 if (windows_major
!= 0xff)
1296 const char *windows_flavor
;
1298 printf_filtered ("Windows Version................%d.%02d (Windows ",
1299 windows_major
, windows_minor
);
1300 switch (windows_major
)
1303 windows_flavor
= "3.X";
1306 switch (windows_minor
)
1309 windows_flavor
= "95, 95A, or 95B";
1312 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1315 windows_flavor
= "98 or 98 SE";
1318 windows_flavor
= "ME";
1321 windows_flavor
= "9X";
1326 windows_flavor
= "??";
1329 printf_filtered ("%s)\n", windows_flavor
);
1331 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1332 printf_filtered ("Windows Version................"
1333 "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1334 puts_filtered ("\n");
1335 /* On some versions of Windows, __dpmi_get_capabilities returns
1336 zero, but the buffer is not filled with info, so we fill the
1337 buffer with a known pattern and test for it afterwards. */
1338 memcpy (dpmi_vendor_info
, test_pattern
, sizeof(dpmi_vendor_info
));
1339 dpmi_vendor_available
=
1340 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
1341 if (dpmi_vendor_available
== 0
1342 && memcmp (dpmi_vendor_info
, test_pattern
,
1343 sizeof(dpmi_vendor_info
)) != 0)
1345 /* The DPMI spec says the vendor string should be ASCIIZ, but
1346 I don't trust the vendors to follow that... */
1347 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1348 dpmi_vendor_info
[128] = '\0';
1349 printf_filtered ("DPMI Host......................"
1350 "%s v%d.%d (capabilities: %#x)\n",
1351 &dpmi_vendor_info
[2],
1352 (unsigned)dpmi_vendor_info
[0],
1353 (unsigned)dpmi_vendor_info
[1],
1354 ((unsigned)dpmi_flags
& 0x7f));
1357 printf_filtered ("DPMI Host......................(Info not available)\n");
1358 __dpmi_get_version (&dpmi_version_data
);
1359 printf_filtered ("DPMI Version...................%d.%02d\n",
1360 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1361 printf_filtered ("DPMI Info......................"
1362 "%s-bit DPMI, with%s Virtual Memory support\n",
1363 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1364 (dpmi_version_data
.flags
& 4) ? "" : "out");
1365 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1366 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1367 printfi_filtered (31, "Processor type: i%d86\n",
1368 dpmi_version_data
.cpu
);
1369 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1370 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1372 /* a_tss is only initialized when the debuggee is first run. */
1373 if (prog_has_started
)
1375 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1376 printf_filtered ("Protection....................."
1377 "Ring %d (in %s), with%s I/O protection\n",
1378 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1379 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1381 puts_filtered ("\n");
1382 __dpmi_get_free_memory_information (&mem_info
);
1383 print_mem (mem_info
.total_number_of_physical_pages
,
1384 "DPMI Total Physical Memory.....", 1);
1385 print_mem (mem_info
.total_number_of_free_pages
,
1386 "DPMI Free Physical Memory......", 1);
1387 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1388 "DPMI Swap Space................", 1);
1389 print_mem (mem_info
.linear_address_space_size_in_pages
,
1390 "DPMI Total Linear Address Size.", 1);
1391 print_mem (mem_info
.free_linear_address_space_in_pages
,
1392 "DPMI Free Linear Address Size..", 1);
1393 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1394 "DPMI Largest Free Memory Block.", 0);
1398 __dpmi_int (0x21, ®s
);
1399 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1401 __dpmi_int (0x21, ®s
);
1402 if ((regs
.x
.flags
& 1) == 0)
1404 static const char *dos_hilo
[] = {
1405 "Low", "", "", "", "High", "", "", "", "High, then Low"
1407 static const char *dos_fit
[] = {
1408 "First", "Best", "Last"
1410 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1411 int fit_idx
= regs
.x
.ax
& 0x0f;
1417 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1418 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1420 __dpmi_int (0x21, ®s
);
1421 if ((regs
.x
.flags
& 1) != 0)
1423 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1424 regs
.h
.al
== 0 ? "not " : "");
1429 unsigned short limit0
;
1430 unsigned short base0
;
1431 unsigned char base1
;
1436 unsigned available
:1;
1439 unsigned page_granular
:1;
1440 unsigned char base2
;
1441 } __attribute__ ((packed
));
1444 unsigned short offset0
;
1445 unsigned short selector
;
1446 unsigned param_count
:5;
1451 unsigned short offset1
;
1452 } __attribute__ ((packed
));
1454 /* Read LEN bytes starting at logical address ADDR, and put the result
1455 into DEST. Return 1 if success, zero if not. */
1457 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1459 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1462 /* For the low memory, we can simply use _dos_ds. */
1463 if (addr
<= dos_ds_limit
- len
)
1464 dosmemget (addr
, len
, dest
);
1467 /* For memory above 1MB we need to set up a special segment to
1468 be able to access that memory. */
1469 int sel
= __dpmi_allocate_ldt_descriptors (1);
1475 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1476 size_t segment_limit
= len
- 1;
1478 /* Make sure the crucial bits in the descriptor access
1479 rights are set correctly. Some DPMI providers might barf
1480 if we set the segment limit to something that is not an
1481 integral multiple of 4KB pages if the granularity bit is
1482 not set to byte-granular, even though the DPMI spec says
1483 it's the host's responsibility to set that bit correctly. */
1484 if (len
> 1024 * 1024)
1486 access_rights
|= 0x8000;
1487 /* Page-granular segments should have the low 12 bits of
1489 segment_limit
|= 0xfff;
1492 access_rights
&= ~0x8000;
1494 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1495 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1496 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1497 /* W2K silently fails to set the segment limit, leaving
1498 it at zero; this test avoids the resulting crash. */
1499 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1500 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1504 __dpmi_free_ldt_descriptor (sel
);
1510 /* Get a segment descriptor stored at index IDX in the descriptor
1511 table whose base address is TABLE_BASE. Return the descriptor
1512 type, or -1 if failure. */
1514 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1516 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1518 if (read_memory_region (addr
, descr
, 8))
1519 return (int)((struct seg_descr
*)descr
)->stype
;
1524 unsigned short limit
__attribute__((packed
));
1525 unsigned long base
__attribute__((packed
));
1528 /* Display a segment descriptor stored at index IDX in a descriptor
1529 table whose type is TYPE and whose base address is BASE_ADDR. If
1530 FORCE is non-zero, display even invalid descriptors. */
1532 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1534 struct seg_descr descr
;
1535 struct gate_descr gate
;
1537 /* Get the descriptor from the table. */
1538 if (idx
== 0 && type
== 0)
1539 puts_filtered ("0x000: null descriptor\n");
1540 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1542 /* For each type of descriptor table, this has a bit set if the
1543 corresponding type of selectors is valid in that table. */
1544 static unsigned allowed_descriptors
[] = {
1545 0xffffdafeL
, /* GDT */
1546 0x0000c0e0L
, /* IDT */
1547 0xffffdafaL
/* LDT */
1550 /* If the program hasn't started yet, assume the debuggee will
1551 have the same CPL as the debugger. */
1552 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1553 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1556 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1558 printf_filtered ("0x%03x: ",
1560 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1561 if (descr
.page_granular
)
1562 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1563 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1564 || descr
.stype
== 9 || descr
.stype
== 11
1565 || (descr
.stype
>= 16 && descr
.stype
< 32))
1566 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1567 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1569 switch (descr
.stype
)
1573 printf_filtered (" 16-bit TSS (task %sactive)",
1574 descr
.stype
== 3 ? "" : "in");
1577 puts_filtered (" LDT");
1580 memcpy (&gate
, &descr
, sizeof gate
);
1581 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1582 gate
.selector
, gate
.offset1
, gate
.offset0
);
1583 printf_filtered (" 16-bit Call Gate (params=%d)",
1587 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1588 printfi_filtered (16, "Task Gate");
1592 memcpy (&gate
, &descr
, sizeof gate
);
1593 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1594 gate
.selector
, gate
.offset1
, gate
.offset0
);
1595 printf_filtered (" 16-bit %s Gate",
1596 descr
.stype
== 6 ? "Interrupt" : "Trap");
1600 printf_filtered (" 32-bit TSS (task %sactive)",
1601 descr
.stype
== 3 ? "" : "in");
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 (" 32-bit Call Gate (params=%d)",
1612 memcpy (&gate
, &descr
, sizeof gate
);
1613 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1614 gate
.selector
, gate
.offset1
, gate
.offset0
);
1615 printf_filtered (" 32-bit %s Gate",
1616 descr
.stype
== 14 ? "Interrupt" : "Trap");
1618 case 16: /* data segments */
1626 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1627 descr
.bit32
? "32" : "16",
1629 ? "Read/Write," : "Read-Only, ",
1630 descr
.stype
& 4 ? "down" : "up",
1631 descr
.stype
& 1 ? "" : ", N.Acc");
1633 case 24: /* code segments */
1641 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1642 descr
.bit32
? "32" : "16",
1643 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1644 descr
.stype
& 4 ? "" : "N.",
1645 descr
.stype
& 1 ? "" : ", N.Acc");
1648 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1651 puts_filtered ("\n");
1655 printf_filtered ("0x%03x: ",
1657 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1659 puts_filtered ("Segment not present\n");
1661 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1666 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1670 go32_sldt (char *arg
, int from_tty
)
1672 struct dtr_reg gdtr
;
1673 unsigned short ldtr
= 0;
1675 struct seg_descr ldt_descr
;
1676 long ldt_entry
= -1L;
1677 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1681 arg
= skip_spaces (arg
);
1685 ldt_entry
= parse_and_eval_long (arg
);
1687 || (ldt_entry
& 4) == 0
1688 || (ldt_entry
& 3) != (cpl
& 3))
1689 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1693 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1694 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1697 puts_filtered ("There is no LDT.\n");
1698 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1699 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1700 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1702 | (ldt_descr
.base1
<< 16)
1703 | (ldt_descr
.base2
<< 24));
1708 | (ldt_descr
.base1
<< 16)
1709 | (ldt_descr
.base2
<< 24);
1710 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1713 if (ldt_descr
.page_granular
)
1714 /* Page-granular segments must have the low 12 bits of their
1716 limit
= (limit
<< 12) | 0xfff;
1717 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1722 max_entry
= (limit
+ 1) / 8;
1726 if (ldt_entry
> limit
)
1727 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1728 (unsigned long)ldt_entry
, limit
);
1730 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1736 for (i
= 0; i
< max_entry
; i
++)
1737 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1743 go32_sgdt (char *arg
, int from_tty
)
1745 struct dtr_reg gdtr
;
1746 long gdt_entry
= -1L;
1751 arg
= skip_spaces (arg
);
1755 gdt_entry
= parse_and_eval_long (arg
);
1756 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1757 error (_("Invalid GDT entry 0x%03lx: "
1758 "not an integral multiple of 8."),
1759 (unsigned long)gdt_entry
);
1763 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1764 max_entry
= (gdtr
.limit
+ 1) / 8;
1768 if (gdt_entry
> gdtr
.limit
)
1769 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1770 (unsigned long)gdt_entry
, gdtr
.limit
);
1772 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1778 for (i
= 0; i
< max_entry
; i
++)
1779 display_descriptor (0, gdtr
.base
, i
, 0);
1784 go32_sidt (char *arg
, int from_tty
)
1786 struct dtr_reg idtr
;
1787 long idt_entry
= -1L;
1792 arg
= skip_spaces (arg
);
1796 idt_entry
= parse_and_eval_long (arg
);
1798 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1802 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1803 max_entry
= (idtr
.limit
+ 1) / 8;
1804 if (max_entry
> 0x100) /* No more than 256 entries. */
1809 if (idt_entry
> idtr
.limit
)
1810 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1811 (unsigned long)idt_entry
, idtr
.limit
);
1813 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1819 for (i
= 0; i
< max_entry
; i
++)
1820 display_descriptor (1, idtr
.base
, i
, 0);
1824 /* Cached linear address of the base of the page directory. For
1825 now, available only under CWSDPMI. Code based on ideas and
1826 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1827 static unsigned long pdbr
;
1829 static unsigned long
1834 unsigned long taskbase
, cr3
;
1835 struct dtr_reg gdtr
;
1837 if (pdbr
> 0 && pdbr
<= 0xfffff)
1840 /* Get the linear address of GDT and the Task Register. */
1841 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1842 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1844 /* Task Register is a segment selector for the TSS of the current
1845 task. Therefore, it can be used as an index into the GDT to get
1846 at the segment descriptor for the TSS. To get the index, reset
1847 the low 3 bits of the selector (which give the CPL). Add 2 to the
1848 offset to point to the 3 low bytes of the base address. */
1849 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1852 /* CWSDPMI's task base is always under the 1MB mark. */
1853 if (offset
> 0xfffff)
1856 _farsetsel (_dos_ds
);
1857 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1858 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1859 if (taskbase
> 0xfffff)
1862 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1863 offset 1Ch in the TSS. */
1864 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1867 #if 0 /* Not fullly supported yet. */
1868 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1869 the first Page Table right below the Page Directory. Thus,
1870 the first Page Table's entry for its own address and the Page
1871 Directory entry for that Page Table will hold the same
1872 physical address. The loop below searches the entire UMB
1873 range of addresses for such an occurence. */
1874 unsigned long addr
, pte_idx
;
1876 for (addr
= 0xb0000, pte_idx
= 0xb0;
1878 addr
+= 0x1000, pte_idx
++)
1880 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1881 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1882 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1884 cr3
= addr
+ 0x1000;
1897 /* Return the N'th Page Directory entry. */
1898 static unsigned long
1901 unsigned long pde
= 0;
1903 if (pdbr
&& n
>= 0 && n
< 1024)
1905 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1910 /* Return the N'th entry of the Page Table whose Page Directory entry
1912 static unsigned long
1913 get_pte (unsigned long pde
, int n
)
1915 unsigned long pte
= 0;
1917 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1918 page tables, for now. */
1919 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1921 pde
&= ~0xfff; /* Clear non-address bits. */
1922 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1927 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1928 says this is a Page Directory entry. If FORCE is non-zero, display
1929 the entry even if its Present flag is off. OFF is the offset of the
1930 address from the page's base address. */
1932 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1934 if ((entry
& 1) != 0)
1936 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1937 if ((entry
& 0x100) && !is_dir
)
1938 puts_filtered (" Global");
1939 if ((entry
& 0x40) && !is_dir
)
1940 puts_filtered (" Dirty");
1941 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1942 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1943 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1944 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1945 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1947 printf_filtered (" +0x%x", off
);
1948 puts_filtered ("\n");
1951 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1952 is_dir
? " Table" : "", entry
>> 1);
1956 go32_pde (char *arg
, int from_tty
)
1958 long pde_idx
= -1, i
;
1962 arg
= skip_spaces (arg
);
1966 pde_idx
= parse_and_eval_long (arg
);
1967 if (pde_idx
< 0 || pde_idx
>= 1024)
1968 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1974 puts_filtered ("Access to Page Directories is "
1975 "not supported on this system.\n");
1976 else if (pde_idx
>= 0)
1977 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
1979 for (i
= 0; i
< 1024; i
++)
1980 display_ptable_entry (get_pde (i
), 1, 0, 0);
1983 /* A helper function to display entries in a Page Table pointed to by
1984 the N'th entry in the Page Directory. If FORCE is non-zero, say
1985 something even if the Page Table is not accessible. */
1987 display_page_table (long n
, int force
)
1989 unsigned long pde
= get_pde (n
);
1995 printf_filtered ("Page Table pointed to by "
1996 "Page Directory entry 0x%lx:\n", n
);
1997 for (i
= 0; i
< 1024; i
++)
1998 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
1999 puts_filtered ("\n");
2002 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
2006 go32_pte (char *arg
, int from_tty
)
2008 long pde_idx
= -1L, i
;
2012 arg
= skip_spaces (arg
);
2016 pde_idx
= parse_and_eval_long (arg
);
2017 if (pde_idx
< 0 || pde_idx
>= 1024)
2018 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2024 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2025 else if (pde_idx
>= 0)
2026 display_page_table (pde_idx
, 1);
2028 for (i
= 0; i
< 1024; i
++)
2029 display_page_table (i
, 0);
2033 go32_pte_for_address (char *arg
, int from_tty
)
2035 CORE_ADDR addr
= 0, i
;
2039 arg
= skip_spaces (arg
);
2042 addr
= parse_and_eval_address (arg
);
2045 error_no_arg (_("linear address"));
2049 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2052 int pde_idx
= (addr
>> 22) & 0x3ff;
2053 int pte_idx
= (addr
>> 12) & 0x3ff;
2054 unsigned offs
= addr
& 0xfff;
2056 printf_filtered ("Page Table entry for address %s:\n",
2058 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
2062 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
2065 go32_info_dos_command (char *args
, int from_tty
)
2067 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
2070 /* -Wmissing-prototypes */
2071 extern initialize_file_ftype _initialize_go32_nat
;
2074 _initialize_go32_nat (void)
2076 struct target_ops
*t
= go32_target ();
2078 i386_dr_low
.set_control
= go32_set_dr7
;
2079 i386_dr_low
.set_addr
= go32_set_dr
;
2080 i386_dr_low
.get_status
= go32_get_dr6
;
2081 i386_dr_low
.get_control
= go32_get_dr7
;
2082 i386_dr_low
.get_addr
= go32_get_dr
;
2083 i386_set_debug_register_length (4);
2085 i386_use_watchpoints (t
);
2088 /* Initialize child's cwd as empty to be initialized when starting
2092 /* Initialize child's command line storage. */
2093 if (redir_debug_init (&child_cmd
) == -1)
2094 internal_error (__FILE__
, __LINE__
,
2095 _("Cannot allocate redirection storage: "
2096 "not enough memory.\n"));
2098 /* We are always processing GCC-compiled programs. */
2099 processing_gcc_compilation
= 2;
2101 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
2102 Print information specific to DJGPP (aka MS-DOS) debugging."),
2103 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
2105 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
2106 Display information about the target system, including CPU, OS, DPMI, etc."),
2108 add_cmd ("ldt", class_info
, go32_sldt
, _("\
2109 Display entries in the LDT (Local Descriptor Table).\n\
2110 Entry number (an expression) as an argument means display only that entry."),
2112 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
2113 Display entries in the GDT (Global Descriptor Table).\n\
2114 Entry number (an expression) as an argument means display only that entry."),
2116 add_cmd ("idt", class_info
, go32_sidt
, _("\
2117 Display entries in the IDT (Interrupt Descriptor Table).\n\
2118 Entry number (an expression) as an argument means display only that entry."),
2120 add_cmd ("pde", class_info
, go32_pde
, _("\
2121 Display entries in the Page Directory.\n\
2122 Entry number (an expression) as an argument means display only that entry."),
2124 add_cmd ("pte", class_info
, go32_pte
, _("\
2125 Display entries in Page Tables.\n\
2126 Entry number (an expression) as an argument means display only entries\n\
2127 from the Page Table pointed to by the specified Page Directory entry."),
2129 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
2130 Display a Page Table entry for a linear address.\n\
2131 The address argument must be a linear address, after adding to\n\
2132 it the base address of the appropriate segment.\n\
2133 The base address of variables and functions in the debuggee's data\n\
2134 or code segment is stored in the variable __djgpp_base_address,\n\
2135 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2136 For other segments, look up their base address in the output of\n\
2137 the `info dos ldt' command."),
2151 tcsetpgrp (int fd
, pid_t pgid
)
2153 if (isatty (fd
) && pgid
== SOME_PID
)
2155 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;