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"
106 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
111 #include <sys/utsname.h>
116 #include <sys/farptr.h>
117 #include <debug/v2load.h>
118 #include <debug/dbgcom.h>
119 #if __DJGPP_MINOR__ > 2
120 #include <debug/redir.h>
123 #include <langinfo.h>
125 #if __DJGPP_MINOR__ < 3
126 /* This code will be provided from DJGPP 2.03 on. Until then I code it
134 unsigned short exponent
:15;
135 unsigned short sign
:1;
141 unsigned int control
;
146 unsigned int dataptr
;
147 unsigned int datasel
;
154 static void save_npx (void); /* Save the FPU of the debugged program. */
155 static void load_npx (void); /* Restore the FPU of the debugged program. */
157 /* ------------------------------------------------------------------------- */
158 /* Store the contents of the NPX in the global variable `npx'. */
164 asm ("inb $0xa0, %%al \n\
165 testb $0x20, %%al \n\
183 /* ------------------------------------------------------------------------- */
184 /* Reload the contents of the NPX from the global variable `npx'. */
189 asm ("frstor %0":"=m" (npx
));
191 /* ------------------------------------------------------------------------- */
192 /* Stubs for the missing redirection functions. */
199 redir_cmdline_delete (cmdline_t
*ptr
)
205 redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
211 redir_to_child (cmdline_t
*ptr
)
217 redir_to_debugger (cmdline_t
*ptr
)
223 redir_debug_init (cmdline_t
*ptr
)
227 #endif /* __DJGPP_MINOR < 3 */
229 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
231 /* This holds the current reference counts for each debug register. */
232 static int dr_ref_count
[4];
236 static int prog_has_started
= 0;
237 static void go32_mourn_inferior (struct target_ops
*ops
);
239 static struct target_ops go32_ops
;
241 #define r_ofs(x) (offsetof(TSS,x))
250 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
251 {r_ofs (tss_ecx
), 4},
252 {r_ofs (tss_edx
), 4},
253 {r_ofs (tss_ebx
), 4},
254 {r_ofs (tss_esp
), 4},
255 {r_ofs (tss_ebp
), 4},
256 {r_ofs (tss_esi
), 4},
257 {r_ofs (tss_edi
), 4},
258 {r_ofs (tss_eip
), 4},
259 {r_ofs (tss_eflags
), 4},
266 {0, 10}, /* 8 FP registers, from npx.reg[] */
274 /* The order of the next 7 registers must be consistent
275 with their numbering in config/i386/tm-i386.h, which see. */
276 {0, 2}, /* control word, from npx */
277 {4, 2}, /* status word, from npx */
278 {8, 2}, /* tag word, from npx */
279 {16, 2}, /* last FP exception CS from npx */
280 {12, 4}, /* last FP exception EIP from npx */
281 {24, 2}, /* last FP exception operand selector from npx */
282 {20, 4}, /* last FP exception operand offset from npx */
283 {18, 2} /* last FP opcode from npx */
289 enum gdb_signal gdb_sig
;
294 {1, GDB_SIGNAL_TRAP
},
295 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
296 but I think SIGBUS is better, since the NMI is usually activated
297 as a result of a memory parity check failure. */
299 {3, GDB_SIGNAL_TRAP
},
301 {5, GDB_SIGNAL_SEGV
},
303 {7, GDB_SIGNAL_EMT
}, /* no-coprocessor exception */
304 {8, GDB_SIGNAL_SEGV
},
305 {9, GDB_SIGNAL_SEGV
},
306 {10, GDB_SIGNAL_BUS
},
307 {11, GDB_SIGNAL_SEGV
},
308 {12, GDB_SIGNAL_SEGV
},
309 {13, GDB_SIGNAL_SEGV
},
310 {14, GDB_SIGNAL_SEGV
},
311 {16, GDB_SIGNAL_FPE
},
312 {17, GDB_SIGNAL_BUS
},
313 {31, GDB_SIGNAL_ILL
},
314 {0x1b, GDB_SIGNAL_INT
},
315 {0x75, GDB_SIGNAL_FPE
},
316 {0x78, GDB_SIGNAL_ALRM
},
317 {0x79, GDB_SIGNAL_INT
},
318 {0x7a, GDB_SIGNAL_QUIT
},
319 {-1, GDB_SIGNAL_LAST
}
323 enum gdb_signal gdb_sig
;
327 {GDB_SIGNAL_ILL
, 6}, /* Invalid Opcode */
328 {GDB_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
329 {GDB_SIGNAL_SEGV
, 13}, /* GPF */
330 {GDB_SIGNAL_BUS
, 17}, /* Alignment Check */
331 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
333 {GDB_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
334 {GDB_SIGNAL_FPE
, 0x75},
335 {GDB_SIGNAL_INT
, 0x79},
336 {GDB_SIGNAL_QUIT
, 0x7a},
337 {GDB_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
338 {GDB_SIGNAL_PROF
, 0x78},
339 {GDB_SIGNAL_LAST
, -1}
343 go32_open (char *name
, int from_tty
)
345 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
349 go32_close (struct target_ops
*self
)
354 go32_attach (struct target_ops
*ops
, char *args
, int from_tty
)
357 You cannot attach to a running program on this platform.\n\
358 Use the `run' command to run DJGPP programs."));
362 go32_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
366 static int resume_is_step
;
367 static int resume_signal
= -1;
370 go32_resume (struct target_ops
*ops
,
371 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
375 resume_is_step
= step
;
377 if (siggnal
!= GDB_SIGNAL_0
&& siggnal
!= GDB_SIGNAL_TRAP
)
379 for (i
= 0, resume_signal
= -1;
380 excepn_map
[i
].gdb_sig
!= GDB_SIGNAL_LAST
; i
++)
381 if (excepn_map
[i
].gdb_sig
== siggnal
)
383 resume_signal
= excepn_map
[i
].djgpp_excepno
;
386 if (resume_signal
== -1)
387 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
388 gdb_signal_to_name (siggnal
));
392 static char child_cwd
[FILENAME_MAX
];
395 go32_wait (struct target_ops
*ops
,
396 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
399 unsigned char saved_opcode
;
400 unsigned long INT3_addr
= 0;
401 int stepping_over_INT
= 0;
403 a_tss
.tss_eflags
&= 0xfeff; /* Reset the single-step flag (TF). */
406 /* If the next instruction is INT xx or INTO, we need to handle
407 them specially. Intel manuals say that these instructions
408 reset the single-step flag (a.k.a. TF). However, it seems
409 that, at least in the DPMI environment, and at least when
410 stepping over the DPMI interrupt 31h, the problem is having
411 TF set at all when INT 31h is executed: the debuggee either
412 crashes (and takes the system with it) or is killed by a
415 So we need to emulate single-step mode: we put an INT3 opcode
416 right after the INT xx instruction, let the debuggee run
417 until it hits INT3 and stops, then restore the original
418 instruction which we overwrote with the INT3 opcode, and back
419 up the debuggee's EIP to that instruction. */
420 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
421 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
423 unsigned char INT3_opcode
= 0xCC;
426 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
427 stepping_over_INT
= 1;
428 read_child (INT3_addr
, &saved_opcode
, 1);
429 write_child (INT3_addr
, &INT3_opcode
, 1);
432 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
435 /* The special value FFFFh in tss_trap indicates to run_child that
436 tss_irqn holds a signal to be delivered to the debuggee. */
437 if (resume_signal
<= -1)
440 a_tss
.tss_irqn
= 0xff;
444 a_tss
.tss_trap
= 0xffff; /* run_child looks for this. */
445 a_tss
.tss_irqn
= resume_signal
;
448 /* The child might change working directory behind our back. The
449 GDB users won't like the side effects of that when they work with
450 relative file names, and GDB might be confused by its current
451 directory not being in sync with the truth. So we always make a
452 point of changing back to where GDB thinks is its cwd, when we
453 return control to the debugger, but restore child's cwd before we
455 /* Initialize child_cwd, before the first call to run_child and not
456 in the initialization, so the child get also the changed directory
457 set with the gdb-command "cd ..." */
459 /* Initialize child's cwd with the current one. */
460 getcwd (child_cwd
, sizeof (child_cwd
));
464 #if __DJGPP_MINOR__ < 3
468 #if __DJGPP_MINOR__ < 3
472 /* Did we step over an INT xx instruction? */
473 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
475 /* Restore the original opcode. */
476 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction. */
477 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
478 /* Simulate a TRAP exception. */
480 a_tss
.tss_eflags
|= 0x0100;
483 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
484 chdir (current_directory
);
486 if (a_tss
.tss_irqn
== 0x21)
488 status
->kind
= TARGET_WAITKIND_EXITED
;
489 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
493 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
494 status
->kind
= TARGET_WAITKIND_STOPPED
;
495 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
497 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
499 #if __DJGPP_MINOR__ < 3
500 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
502 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
504 status
->value
.sig
= sig_map
[i
].gdb_sig
;
510 return pid_to_ptid (SOME_PID
);
514 fetch_register (struct regcache
*regcache
, int regno
)
516 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
517 if (regno
< gdbarch_fp0_regnum (gdbarch
))
518 regcache_raw_supply (regcache
, regno
,
519 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
520 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
522 i387_supply_fsave (regcache
, regno
, &npx
);
524 internal_error (__FILE__
, __LINE__
,
525 _("Invalid register no. %d in fetch_register."), regno
);
529 go32_fetch_registers (struct target_ops
*ops
,
530 struct regcache
*regcache
, int regno
)
533 fetch_register (regcache
, regno
);
537 regno
< gdbarch_fp0_regnum (get_regcache_arch (regcache
));
539 fetch_register (regcache
, regno
);
540 i387_supply_fsave (regcache
, -1, &npx
);
545 store_register (const struct regcache
*regcache
, int regno
)
547 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
548 if (regno
< gdbarch_fp0_regnum (gdbarch
))
549 regcache_raw_collect (regcache
, regno
,
550 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
551 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
553 i387_collect_fsave (regcache
, regno
, &npx
);
555 internal_error (__FILE__
, __LINE__
,
556 _("Invalid register no. %d in store_register."), regno
);
560 go32_store_registers (struct target_ops
*ops
,
561 struct regcache
*regcache
, int regno
)
566 store_register (regcache
, regno
);
569 for (r
= 0; r
< gdbarch_fp0_regnum (get_regcache_arch (regcache
)); r
++)
570 store_register (regcache
, r
);
571 i387_collect_fsave (regcache
, -1, &npx
);
576 go32_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
581 /* Const-correct version of DJGPP's write_child, which unfortunately
582 takes a non-const buffer pointer. */
585 my_write_child (unsigned child_addr
, const void *buf
, unsigned len
)
587 static void *buffer
= NULL
;
588 static unsigned buffer_len
= 0;
591 if (buffer_len
< len
)
593 buffer
= xrealloc (buffer
, len
);
597 memcpy (buffer
, buf
, len
);
598 res
= write_child (child_addr
, buffer
, len
);
602 /* Helper for go32_xfer_partial that handles memory transfers.
603 Arguments are like target_xfer_partial. */
605 static enum target_xfer_status
606 go32_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
607 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
611 if (writebuf
!= NULL
)
612 res
= my_write_child (memaddr
, writebuf
, len
);
614 res
= read_child (memaddr
, readbuf
, len
);
617 return TARGET_XFER_E_IO
;
620 return TARGET_XFER_OK
;
623 /* Target to_xfer_partial implementation. */
625 static enum target_xfer_status
626 go32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
627 const char *annex
, gdb_byte
*readbuf
,
628 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
629 ULONGEST
*xfered_len
)
633 case TARGET_OBJECT_MEMORY
:
634 return go32_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
637 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
638 readbuf
, writebuf
, offset
, len
,
643 static cmdline_t child_cmd
; /* Parsed child's command line kept here. */
646 go32_files_info (struct target_ops
*target
)
648 printf_unfiltered ("You are running a DJGPP V2 program.\n");
652 go32_kill_inferior (struct target_ops
*ops
)
654 go32_mourn_inferior (ops
);
658 go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
659 char *args
, char **env
, int from_tty
)
661 extern char **environ
;
664 char **env_save
= environ
;
666 struct inferior
*inf
;
668 /* If no exec file handed to us, get it from the exec-file command -- with
669 a good, common error message if none is specified. */
671 exec_file
= get_exec_file (1);
676 /* Initialize child's cwd as empty to be initialized when starting
680 /* Init command line storage. */
681 if (redir_debug_init (&child_cmd
) == -1)
682 internal_error (__FILE__
, __LINE__
,
683 _("Cannot allocate redirection storage: "
684 "not enough memory.\n"));
686 /* Parse the command line and create redirections. */
687 if (strpbrk (args
, "<>"))
689 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
690 args
= child_cmd
.command
;
692 error (_("Syntax error in command line."));
695 child_cmd
.command
= xstrdup (args
);
697 cmdlen
= strlen (args
);
698 /* v2loadimage passes command lines via DOS memory, so it cannot
699 possibly handle commands longer than 1MB. */
700 if (cmdlen
> 1024*1024)
701 error (_("Command line too long."));
703 cmdline
= xmalloc (cmdlen
+ 4);
704 strcpy (cmdline
+ 1, args
);
705 /* If the command-line length fits into DOS 126-char limits, use the
706 DOS command tail format; otherwise, tell v2loadimage to pass it
707 through a buffer in conventional memory. */
710 cmdline
[0] = strlen (args
);
711 cmdline
[cmdlen
+ 1] = 13;
714 cmdline
[0] = 0xff; /* Signal v2loadimage it's a long command. */
718 if (v2loadimage (exec_file
, cmdline
, start_state
))
721 printf_unfiltered ("Load failed for image %s\n", exec_file
);
727 edi_init (start_state
);
728 #if __DJGPP_MINOR__ < 3
732 inferior_ptid
= pid_to_ptid (SOME_PID
);
733 inf
= current_inferior ();
734 inferior_appeared (inf
, SOME_PID
);
736 push_target (&go32_ops
);
738 add_thread_silent (inferior_ptid
);
740 clear_proceed_status ();
741 insert_breakpoints ();
742 prog_has_started
= 1;
746 go32_mourn_inferior (struct target_ops
*ops
)
750 redir_cmdline_delete (&child_cmd
);
756 /* We need to make sure all the breakpoint enable bits in the DR7
757 register are reset when the inferior exits. Otherwise, if they
758 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
759 failure to set more watchpoints, and other calamities. It would
760 be nice if GDB itself would take care to remove all breakpoints
761 at all times, but it doesn't, probably under an assumption that
762 the OS cleans up when the debuggee exits. */
763 i386_cleanup_dregs ();
765 ptid
= inferior_ptid
;
766 inferior_ptid
= null_ptid
;
767 delete_thread_silent (ptid
);
768 prog_has_started
= 0;
771 generic_mourn_inferior ();
775 go32_can_run (struct target_ops
*self
)
780 /* Hardware watchpoint support. */
782 #define D_REGS edi.dr
783 #define CONTROL D_REGS[7]
784 #define STATUS D_REGS[6]
786 /* Pass the address ADDR to the inferior in the I'th debug register.
787 Here we just store the address in D_REGS, the watchpoint will be
788 actually set up when go32_wait runs the debuggee. */
790 go32_set_dr (int i
, CORE_ADDR addr
)
793 internal_error (__FILE__
, __LINE__
,
794 _("Invalid register %d in go32_set_dr.\n"), i
);
798 /* Pass the value VAL to the inferior in the DR7 debug control
799 register. Here we just store the address in D_REGS, the watchpoint
800 will be actually set up when go32_wait runs the debuggee. */
802 go32_set_dr7 (unsigned long val
)
807 /* Get the value of the DR6 debug status register from the inferior.
808 Here we just return the value stored in D_REGS, as we've got it
809 from the last go32_wait call. */
816 /* Get the value of the DR7 debug status register from the inferior.
817 Here we just return the value stored in D_REGS, as we've got it
818 from the last go32_wait call. */
826 /* Get the value of the DR debug register I from the inferior. Here
827 we just return the value stored in D_REGS, as we've got it from the
828 last go32_wait call. */
834 internal_error (__FILE__
, __LINE__
,
835 _("Invalid register %d in go32_get_dr.\n"), i
);
839 /* Put the device open on handle FD into either raw or cooked
840 mode, return 1 if it was in raw mode, zero otherwise. */
843 device_mode (int fd
, int raw_p
)
845 int oldmode
, newmode
;
850 __dpmi_int (0x21, ®s
);
851 if (regs
.x
.flags
& 1)
853 newmode
= oldmode
= regs
.x
.dx
;
860 if (oldmode
& 0x80) /* Only for character dev. */
864 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails. */
865 __dpmi_int (0x21, ®s
);
866 if (regs
.x
.flags
& 1)
869 return (oldmode
& 0x20) == 0x20;
873 static int inf_mode_valid
= 0;
874 static int inf_terminal_mode
;
876 /* This semaphore is needed because, amazingly enough, GDB calls
877 target.to_terminal_ours more than once after the inferior stops.
878 But we need the information from the first call only, since the
879 second call will always see GDB's own cooked terminal. */
880 static int terminal_is_ours
= 1;
883 go32_terminal_init (struct target_ops
*self
)
885 inf_mode_valid
= 0; /* Reinitialize, in case they are restarting child. */
886 terminal_is_ours
= 1;
890 go32_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
892 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
894 ? "default" : inf_terminal_mode
? "raw" : "cooked");
896 #if __DJGPP_MINOR__ > 2
897 if (child_cmd
.redirection
)
901 for (i
= 0; i
< DBG_HANDLES
; i
++)
903 if (child_cmd
.redirection
[i
]->file_name
)
904 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
905 i
, child_cmd
.redirection
[i
]->file_name
);
906 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
908 ("\tFile handle %d appears to be closed by inferior.\n", i
);
909 /* Mask off the raw/cooked bit when comparing device info words. */
910 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
911 != (_get_dev_info (i
) & 0xdf))
913 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
920 go32_terminal_inferior (struct target_ops
*self
)
922 /* Redirect standard handles as child wants them. */
924 if (redir_to_child (&child_cmd
) == -1)
926 redir_to_debugger (&child_cmd
);
927 error (_("Cannot redirect standard handles for program: %s."),
928 safe_strerror (errno
));
930 /* Set the console device of the inferior to whatever mode
931 (raw or cooked) we found it last time. */
932 if (terminal_is_ours
)
935 device_mode (0, inf_terminal_mode
);
936 terminal_is_ours
= 0;
941 go32_terminal_ours (struct target_ops
*self
)
943 /* Switch to cooked mode on the gdb terminal and save the inferior
944 terminal mode to be restored when it is resumed. */
945 if (!terminal_is_ours
)
947 inf_terminal_mode
= device_mode (0, 0);
948 if (inf_terminal_mode
!= -1)
951 /* If device_mode returned -1, we don't know what happens with
952 handle 0 anymore, so make the info invalid. */
954 terminal_is_ours
= 1;
956 /* Restore debugger's standard handles. */
958 if (redir_to_debugger (&child_cmd
) == -1)
960 redir_to_child (&child_cmd
);
961 error (_("Cannot redirect standard handles for debugger: %s."),
962 safe_strerror (errno
));
968 go32_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
970 return !ptid_equal (inferior_ptid
, null_ptid
);
974 go32_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
976 return normal_pid_to_str (ptid
);
982 go32_ops
.to_shortname
= "djgpp";
983 go32_ops
.to_longname
= "djgpp target process";
985 "Program loaded by djgpp, when gdb is used as an external debugger";
986 go32_ops
.to_open
= go32_open
;
987 go32_ops
.to_close
= go32_close
;
988 go32_ops
.to_attach
= go32_attach
;
989 go32_ops
.to_detach
= go32_detach
;
990 go32_ops
.to_resume
= go32_resume
;
991 go32_ops
.to_wait
= go32_wait
;
992 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
993 go32_ops
.to_store_registers
= go32_store_registers
;
994 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
995 go32_ops
.to_xfer_partial
= go32_xfer_partial
;
996 go32_ops
.to_files_info
= go32_files_info
;
997 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
998 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
999 go32_ops
.to_terminal_init
= go32_terminal_init
;
1000 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
1001 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
1002 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
1003 go32_ops
.to_terminal_info
= go32_terminal_info
;
1004 go32_ops
.to_kill
= go32_kill_inferior
;
1005 go32_ops
.to_create_inferior
= go32_create_inferior
;
1006 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
1007 go32_ops
.to_can_run
= go32_can_run
;
1008 go32_ops
.to_thread_alive
= go32_thread_alive
;
1009 go32_ops
.to_pid_to_str
= go32_pid_to_str
;
1010 go32_ops
.to_stratum
= process_stratum
;
1011 go32_ops
.to_has_all_memory
= default_child_has_all_memory
;
1012 go32_ops
.to_has_memory
= default_child_has_memory
;
1013 go32_ops
.to_has_stack
= default_child_has_stack
;
1014 go32_ops
.to_has_registers
= default_child_has_registers
;
1015 go32_ops
.to_has_execution
= default_child_has_execution
;
1017 i386_use_watchpoints (&go32_ops
);
1020 i386_dr_low
.set_control
= go32_set_dr7
;
1021 i386_dr_low
.set_addr
= go32_set_dr
;
1022 i386_dr_low
.get_status
= go32_get_dr6
;
1023 i386_dr_low
.get_control
= go32_get_dr7
;
1024 i386_dr_low
.get_addr
= go32_get_dr
;
1025 i386_set_debug_register_length (4);
1027 go32_ops
.to_magic
= OPS_MAGIC
;
1029 /* Initialize child's cwd as empty to be initialized when starting
1033 /* Initialize child's command line storage. */
1034 if (redir_debug_init (&child_cmd
) == -1)
1035 internal_error (__FILE__
, __LINE__
,
1036 _("Cannot allocate redirection storage: "
1037 "not enough memory.\n"));
1039 /* We are always processing GCC-compiled programs. */
1040 processing_gcc_compilation
= 2;
1043 /* Return the current DOS codepage number. */
1050 __dpmi_int (0x21, ®s
);
1051 if (!(regs
.x
.flags
& 1))
1052 return regs
.x
.bx
& 0xffff;
1054 return 437; /* default */
1057 /* Limited emulation of `nl_langinfo', for charset.c. */
1059 nl_langinfo (nl_item item
)
1067 /* 8 is enough for SHORT_MAX + "CP" + null. */
1069 int blen
= sizeof (buf
);
1070 int needed
= snprintf (buf
, blen
, "CP%d", dos_codepage ());
1072 if (needed
> blen
) /* Should never happen. */
1074 retval
= xstrdup (buf
);
1078 retval
= xstrdup ("");
1084 unsigned short windows_major
, windows_minor
;
1086 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
1088 go32_get_windows_version(void)
1093 __dpmi_int(0x2f, &r
);
1094 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
1095 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
1097 windows_major
= r
.h
.al
;
1098 windows_minor
= r
.h
.ah
;
1101 windows_major
= 0xff; /* meaning no Windows */
1104 /* A subroutine of go32_sysinfo to display memory info. */
1106 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
1108 if (datum
!= 0xffffffffUL
)
1112 puts_filtered (header
);
1115 printf_filtered ("%lu KB", datum
>> 10);
1116 if (datum
> 1024 * 1024)
1117 printf_filtered (" (%lu MB)", datum
>> 20);
1120 printf_filtered ("%lu Bytes", datum
);
1121 puts_filtered ("\n");
1125 /* Display assorted information about the underlying OS. */
1127 go32_sysinfo (char *arg
, int from_tty
)
1129 static const char test_pattern
[] =
1130 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1131 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1132 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1134 char cpuid_vendor
[13];
1135 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
1136 unsigned true_dos_version
= _get_dos_version (1);
1137 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
1139 char dpmi_vendor_info
[129];
1140 int dpmi_vendor_available
;
1141 __dpmi_version_ret dpmi_version_data
;
1143 __dpmi_free_mem_info mem_info
;
1146 cpuid_vendor
[0] = '\0';
1148 strcpy (u
.machine
, "Unknown x86");
1149 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
1151 /* CPUID with EAX = 0 returns the Vendor ID. */
1153 /* Ideally we would use i386_cpuid(), but it needs someone to run
1154 native tests first to make sure things actually work. They should.
1155 http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html */
1156 unsigned int eax
, ebx
, ecx
, edx
;
1158 if (i386_cpuid (0, &eax
, &ebx
, &ecx
, &edx
))
1161 memcpy (&vendor
[0], &ebx
, 4);
1162 memcpy (&vendor
[4], &ecx
, 4);
1163 memcpy (&vendor
[8], &edx
, 4);
1164 cpuid_vendor
[12] = '\0';
1167 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1168 "xorl %%ecx, %%ecx;"
1169 "xorl %%edx, %%edx;"
1176 : "=m" (cpuid_vendor
[0]),
1177 "=m" (cpuid_vendor
[4]),
1178 "=m" (cpuid_vendor
[8]),
1181 : "%eax", "%ebx", "%ecx", "%edx");
1182 cpuid_vendor
[12] = '\0';
1186 printf_filtered ("CPU Type.......................%s", u
.machine
);
1187 if (cpuid_vendor
[0])
1188 printf_filtered (" (%s)", cpuid_vendor
);
1189 puts_filtered ("\n");
1191 /* CPUID with EAX = 1 returns processor signature and features. */
1194 static char *brand_name
[] = {
1202 char cpu_string
[80];
1205 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1206 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1207 unsigned cpu_family
, cpu_model
;
1210 /* See comment above about cpuid usage. */
1211 i386_cpuid (1, &cpuid_eax
, &cpuid_ebx
, NULL
, &cpuid_edx
);
1213 __asm__
__volatile__ ("movl $1, %%eax;"
1221 brand_idx
= cpuid_ebx
& 0xff;
1222 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1223 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1224 cpu_brand
[0] = '\0';
1228 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1229 && *brand_name
[brand_idx
])
1230 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1231 else if (cpu_family
== 5)
1233 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1234 strcpy (cpu_brand
, " MMX");
1235 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1236 strcpy (cpu_brand
, " OverDrive");
1237 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1238 strcpy (cpu_brand
, " Dual");
1240 else if (cpu_family
== 6 && cpu_model
< 8)
1245 strcpy (cpu_brand
, " Pro");
1248 strcpy (cpu_brand
, " II");
1251 strcpy (cpu_brand
, " II Xeon");
1254 strcpy (cpu_brand
, " Celeron");
1257 strcpy (cpu_brand
, " III");
1267 strcpy (cpu_brand
, "486/5x86");
1276 strcpy (cpu_brand
, "-K5");
1280 strcpy (cpu_brand
, "-K6");
1283 strcpy (cpu_brand
, "-K6-2");
1286 strcpy (cpu_brand
, "-K6-III");
1296 strcpy (cpu_brand
, " Athlon");
1299 strcpy (cpu_brand
, " Duron");
1305 xsnprintf (cpu_string
, sizeof (cpu_string
), "%s%s Model %d Stepping %d",
1306 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1307 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1308 printfi_filtered (31, "%s\n", cpu_string
);
1309 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1310 || ((cpuid_edx
& 1) == 0)
1311 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1313 puts_filtered ("CPU Features...................");
1314 /* We only list features which might be useful in the DPMI
1316 if ((cpuid_edx
& 1) == 0)
1317 puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
1318 if ((cpuid_edx
& (1 << 1)) != 0)
1319 puts_filtered ("VME ");
1320 if ((cpuid_edx
& (1 << 2)) != 0)
1321 puts_filtered ("DE ");
1322 if ((cpuid_edx
& (1 << 4)) != 0)
1323 puts_filtered ("TSC ");
1324 if ((cpuid_edx
& (1 << 23)) != 0)
1325 puts_filtered ("MMX ");
1326 if ((cpuid_edx
& (1 << 25)) != 0)
1327 puts_filtered ("SSE ");
1328 if ((cpuid_edx
& (1 << 26)) != 0)
1329 puts_filtered ("SSE2 ");
1332 if ((cpuid_edx
& (1 << 31)) != 0)
1333 puts_filtered ("3DNow! ");
1334 if ((cpuid_edx
& (1 << 30)) != 0)
1335 puts_filtered ("3DNow!Ext");
1337 puts_filtered ("\n");
1340 puts_filtered ("\n");
1341 printf_filtered ("DOS Version....................%s %s.%s",
1342 _os_flavor
, u
.release
, u
.version
);
1343 if (true_dos_version
!= advertized_dos_version
)
1344 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1345 puts_filtered ("\n");
1347 go32_get_windows_version ();
1348 if (windows_major
!= 0xff)
1350 const char *windows_flavor
;
1352 printf_filtered ("Windows Version................%d.%02d (Windows ",
1353 windows_major
, windows_minor
);
1354 switch (windows_major
)
1357 windows_flavor
= "3.X";
1360 switch (windows_minor
)
1363 windows_flavor
= "95, 95A, or 95B";
1366 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1369 windows_flavor
= "98 or 98 SE";
1372 windows_flavor
= "ME";
1375 windows_flavor
= "9X";
1380 windows_flavor
= "??";
1383 printf_filtered ("%s)\n", windows_flavor
);
1385 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1386 printf_filtered ("Windows Version................"
1387 "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1388 puts_filtered ("\n");
1389 /* On some versions of Windows, __dpmi_get_capabilities returns
1390 zero, but the buffer is not filled with info, so we fill the
1391 buffer with a known pattern and test for it afterwards. */
1392 memcpy (dpmi_vendor_info
, test_pattern
, sizeof(dpmi_vendor_info
));
1393 dpmi_vendor_available
=
1394 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
1395 if (dpmi_vendor_available
== 0
1396 && memcmp (dpmi_vendor_info
, test_pattern
,
1397 sizeof(dpmi_vendor_info
)) != 0)
1399 /* The DPMI spec says the vendor string should be ASCIIZ, but
1400 I don't trust the vendors to follow that... */
1401 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1402 dpmi_vendor_info
[128] = '\0';
1403 printf_filtered ("DPMI Host......................"
1404 "%s v%d.%d (capabilities: %#x)\n",
1405 &dpmi_vendor_info
[2],
1406 (unsigned)dpmi_vendor_info
[0],
1407 (unsigned)dpmi_vendor_info
[1],
1408 ((unsigned)dpmi_flags
& 0x7f));
1411 printf_filtered ("DPMI Host......................(Info not available)\n");
1412 __dpmi_get_version (&dpmi_version_data
);
1413 printf_filtered ("DPMI Version...................%d.%02d\n",
1414 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1415 printf_filtered ("DPMI Info......................"
1416 "%s-bit DPMI, with%s Virtual Memory support\n",
1417 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1418 (dpmi_version_data
.flags
& 4) ? "" : "out");
1419 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1420 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1421 printfi_filtered (31, "Processor type: i%d86\n",
1422 dpmi_version_data
.cpu
);
1423 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1424 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1426 /* a_tss is only initialized when the debuggee is first run. */
1427 if (prog_has_started
)
1429 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1430 printf_filtered ("Protection....................."
1431 "Ring %d (in %s), with%s I/O protection\n",
1432 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1433 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1435 puts_filtered ("\n");
1436 __dpmi_get_free_memory_information (&mem_info
);
1437 print_mem (mem_info
.total_number_of_physical_pages
,
1438 "DPMI Total Physical Memory.....", 1);
1439 print_mem (mem_info
.total_number_of_free_pages
,
1440 "DPMI Free Physical Memory......", 1);
1441 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1442 "DPMI Swap Space................", 1);
1443 print_mem (mem_info
.linear_address_space_size_in_pages
,
1444 "DPMI Total Linear Address Size.", 1);
1445 print_mem (mem_info
.free_linear_address_space_in_pages
,
1446 "DPMI Free Linear Address Size..", 1);
1447 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1448 "DPMI Largest Free Memory Block.", 0);
1452 __dpmi_int (0x21, ®s
);
1453 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1455 __dpmi_int (0x21, ®s
);
1456 if ((regs
.x
.flags
& 1) == 0)
1458 static const char *dos_hilo
[] = {
1459 "Low", "", "", "", "High", "", "", "", "High, then Low"
1461 static const char *dos_fit
[] = {
1462 "First", "Best", "Last"
1464 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1465 int fit_idx
= regs
.x
.ax
& 0x0f;
1471 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1472 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1474 __dpmi_int (0x21, ®s
);
1475 if ((regs
.x
.flags
& 1) != 0)
1477 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1478 regs
.h
.al
== 0 ? "not " : "");
1483 unsigned short limit0
;
1484 unsigned short base0
;
1485 unsigned char base1
;
1490 unsigned available
:1;
1493 unsigned page_granular
:1;
1494 unsigned char base2
;
1495 } __attribute__ ((packed
));
1498 unsigned short offset0
;
1499 unsigned short selector
;
1500 unsigned param_count
:5;
1505 unsigned short offset1
;
1506 } __attribute__ ((packed
));
1508 /* Read LEN bytes starting at logical address ADDR, and put the result
1509 into DEST. Return 1 if success, zero if not. */
1511 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1513 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1516 /* For the low memory, we can simply use _dos_ds. */
1517 if (addr
<= dos_ds_limit
- len
)
1518 dosmemget (addr
, len
, dest
);
1521 /* For memory above 1MB we need to set up a special segment to
1522 be able to access that memory. */
1523 int sel
= __dpmi_allocate_ldt_descriptors (1);
1529 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1530 size_t segment_limit
= len
- 1;
1532 /* Make sure the crucial bits in the descriptor access
1533 rights are set correctly. Some DPMI providers might barf
1534 if we set the segment limit to something that is not an
1535 integral multiple of 4KB pages if the granularity bit is
1536 not set to byte-granular, even though the DPMI spec says
1537 it's the host's responsibility to set that bit correctly. */
1538 if (len
> 1024 * 1024)
1540 access_rights
|= 0x8000;
1541 /* Page-granular segments should have the low 12 bits of
1543 segment_limit
|= 0xfff;
1546 access_rights
&= ~0x8000;
1548 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1549 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1550 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1551 /* W2K silently fails to set the segment limit, leaving
1552 it at zero; this test avoids the resulting crash. */
1553 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1554 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1558 __dpmi_free_ldt_descriptor (sel
);
1564 /* Get a segment descriptor stored at index IDX in the descriptor
1565 table whose base address is TABLE_BASE. Return the descriptor
1566 type, or -1 if failure. */
1568 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1570 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1572 if (read_memory_region (addr
, descr
, 8))
1573 return (int)((struct seg_descr
*)descr
)->stype
;
1578 unsigned short limit
__attribute__((packed
));
1579 unsigned long base
__attribute__((packed
));
1582 /* Display a segment descriptor stored at index IDX in a descriptor
1583 table whose type is TYPE and whose base address is BASE_ADDR. If
1584 FORCE is non-zero, display even invalid descriptors. */
1586 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1588 struct seg_descr descr
;
1589 struct gate_descr gate
;
1591 /* Get the descriptor from the table. */
1592 if (idx
== 0 && type
== 0)
1593 puts_filtered ("0x000: null descriptor\n");
1594 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1596 /* For each type of descriptor table, this has a bit set if the
1597 corresponding type of selectors is valid in that table. */
1598 static unsigned allowed_descriptors
[] = {
1599 0xffffdafeL
, /* GDT */
1600 0x0000c0e0L
, /* IDT */
1601 0xffffdafaL
/* LDT */
1604 /* If the program hasn't started yet, assume the debuggee will
1605 have the same CPL as the debugger. */
1606 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1607 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1610 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1612 printf_filtered ("0x%03x: ",
1614 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1615 if (descr
.page_granular
)
1616 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1617 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1618 || descr
.stype
== 9 || descr
.stype
== 11
1619 || (descr
.stype
>= 16 && descr
.stype
< 32))
1620 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1621 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1623 switch (descr
.stype
)
1627 printf_filtered (" 16-bit TSS (task %sactive)",
1628 descr
.stype
== 3 ? "" : "in");
1631 puts_filtered (" LDT");
1634 memcpy (&gate
, &descr
, sizeof gate
);
1635 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1636 gate
.selector
, gate
.offset1
, gate
.offset0
);
1637 printf_filtered (" 16-bit Call Gate (params=%d)",
1641 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1642 printfi_filtered (16, "Task Gate");
1646 memcpy (&gate
, &descr
, sizeof gate
);
1647 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1648 gate
.selector
, gate
.offset1
, gate
.offset0
);
1649 printf_filtered (" 16-bit %s Gate",
1650 descr
.stype
== 6 ? "Interrupt" : "Trap");
1654 printf_filtered (" 32-bit TSS (task %sactive)",
1655 descr
.stype
== 3 ? "" : "in");
1658 memcpy (&gate
, &descr
, sizeof gate
);
1659 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1660 gate
.selector
, gate
.offset1
, gate
.offset0
);
1661 printf_filtered (" 32-bit Call Gate (params=%d)",
1666 memcpy (&gate
, &descr
, sizeof gate
);
1667 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1668 gate
.selector
, gate
.offset1
, gate
.offset0
);
1669 printf_filtered (" 32-bit %s Gate",
1670 descr
.stype
== 14 ? "Interrupt" : "Trap");
1672 case 16: /* data segments */
1680 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1681 descr
.bit32
? "32" : "16",
1683 ? "Read/Write," : "Read-Only, ",
1684 descr
.stype
& 4 ? "down" : "up",
1685 descr
.stype
& 1 ? "" : ", N.Acc");
1687 case 24: /* code segments */
1695 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1696 descr
.bit32
? "32" : "16",
1697 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1698 descr
.stype
& 4 ? "" : "N.",
1699 descr
.stype
& 1 ? "" : ", N.Acc");
1702 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1705 puts_filtered ("\n");
1709 printf_filtered ("0x%03x: ",
1711 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1713 puts_filtered ("Segment not present\n");
1715 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1720 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1724 go32_sldt (char *arg
, int from_tty
)
1726 struct dtr_reg gdtr
;
1727 unsigned short ldtr
= 0;
1729 struct seg_descr ldt_descr
;
1730 long ldt_entry
= -1L;
1731 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1735 arg
= skip_spaces (arg
);
1739 ldt_entry
= parse_and_eval_long (arg
);
1741 || (ldt_entry
& 4) == 0
1742 || (ldt_entry
& 3) != (cpl
& 3))
1743 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1747 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1748 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1751 puts_filtered ("There is no LDT.\n");
1752 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1753 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1754 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1756 | (ldt_descr
.base1
<< 16)
1757 | (ldt_descr
.base2
<< 24));
1762 | (ldt_descr
.base1
<< 16)
1763 | (ldt_descr
.base2
<< 24);
1764 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1767 if (ldt_descr
.page_granular
)
1768 /* Page-granular segments must have the low 12 bits of their
1770 limit
= (limit
<< 12) | 0xfff;
1771 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1776 max_entry
= (limit
+ 1) / 8;
1780 if (ldt_entry
> limit
)
1781 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1782 (unsigned long)ldt_entry
, limit
);
1784 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1790 for (i
= 0; i
< max_entry
; i
++)
1791 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1797 go32_sgdt (char *arg
, int from_tty
)
1799 struct dtr_reg gdtr
;
1800 long gdt_entry
= -1L;
1805 arg
= skip_spaces (arg
);
1809 gdt_entry
= parse_and_eval_long (arg
);
1810 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1811 error (_("Invalid GDT entry 0x%03lx: "
1812 "not an integral multiple of 8."),
1813 (unsigned long)gdt_entry
);
1817 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1818 max_entry
= (gdtr
.limit
+ 1) / 8;
1822 if (gdt_entry
> gdtr
.limit
)
1823 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1824 (unsigned long)gdt_entry
, gdtr
.limit
);
1826 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1832 for (i
= 0; i
< max_entry
; i
++)
1833 display_descriptor (0, gdtr
.base
, i
, 0);
1838 go32_sidt (char *arg
, int from_tty
)
1840 struct dtr_reg idtr
;
1841 long idt_entry
= -1L;
1846 arg
= skip_spaces (arg
);
1850 idt_entry
= parse_and_eval_long (arg
);
1852 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1856 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1857 max_entry
= (idtr
.limit
+ 1) / 8;
1858 if (max_entry
> 0x100) /* No more than 256 entries. */
1863 if (idt_entry
> idtr
.limit
)
1864 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1865 (unsigned long)idt_entry
, idtr
.limit
);
1867 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1873 for (i
= 0; i
< max_entry
; i
++)
1874 display_descriptor (1, idtr
.base
, i
, 0);
1878 /* Cached linear address of the base of the page directory. For
1879 now, available only under CWSDPMI. Code based on ideas and
1880 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1881 static unsigned long pdbr
;
1883 static unsigned long
1888 unsigned long taskbase
, cr3
;
1889 struct dtr_reg gdtr
;
1891 if (pdbr
> 0 && pdbr
<= 0xfffff)
1894 /* Get the linear address of GDT and the Task Register. */
1895 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1896 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1898 /* Task Register is a segment selector for the TSS of the current
1899 task. Therefore, it can be used as an index into the GDT to get
1900 at the segment descriptor for the TSS. To get the index, reset
1901 the low 3 bits of the selector (which give the CPL). Add 2 to the
1902 offset to point to the 3 low bytes of the base address. */
1903 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1906 /* CWSDPMI's task base is always under the 1MB mark. */
1907 if (offset
> 0xfffff)
1910 _farsetsel (_dos_ds
);
1911 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1912 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1913 if (taskbase
> 0xfffff)
1916 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1917 offset 1Ch in the TSS. */
1918 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1921 #if 0 /* Not fullly supported yet. */
1922 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1923 the first Page Table right below the Page Directory. Thus,
1924 the first Page Table's entry for its own address and the Page
1925 Directory entry for that Page Table will hold the same
1926 physical address. The loop below searches the entire UMB
1927 range of addresses for such an occurence. */
1928 unsigned long addr
, pte_idx
;
1930 for (addr
= 0xb0000, pte_idx
= 0xb0;
1932 addr
+= 0x1000, pte_idx
++)
1934 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1935 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1936 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1938 cr3
= addr
+ 0x1000;
1951 /* Return the N'th Page Directory entry. */
1952 static unsigned long
1955 unsigned long pde
= 0;
1957 if (pdbr
&& n
>= 0 && n
< 1024)
1959 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1964 /* Return the N'th entry of the Page Table whose Page Directory entry
1966 static unsigned long
1967 get_pte (unsigned long pde
, int n
)
1969 unsigned long pte
= 0;
1971 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1972 page tables, for now. */
1973 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1975 pde
&= ~0xfff; /* Clear non-address bits. */
1976 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1981 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1982 says this is a Page Directory entry. If FORCE is non-zero, display
1983 the entry even if its Present flag is off. OFF is the offset of the
1984 address from the page's base address. */
1986 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1988 if ((entry
& 1) != 0)
1990 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1991 if ((entry
& 0x100) && !is_dir
)
1992 puts_filtered (" Global");
1993 if ((entry
& 0x40) && !is_dir
)
1994 puts_filtered (" Dirty");
1995 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1996 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1997 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1998 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1999 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
2001 printf_filtered (" +0x%x", off
);
2002 puts_filtered ("\n");
2005 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
2006 is_dir
? " Table" : "", entry
>> 1);
2010 go32_pde (char *arg
, int from_tty
)
2012 long pde_idx
= -1, i
;
2016 arg
= skip_spaces (arg
);
2020 pde_idx
= parse_and_eval_long (arg
);
2021 if (pde_idx
< 0 || pde_idx
>= 1024)
2022 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2028 puts_filtered ("Access to Page Directories is "
2029 "not supported on this system.\n");
2030 else if (pde_idx
>= 0)
2031 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
2033 for (i
= 0; i
< 1024; i
++)
2034 display_ptable_entry (get_pde (i
), 1, 0, 0);
2037 /* A helper function to display entries in a Page Table pointed to by
2038 the N'th entry in the Page Directory. If FORCE is non-zero, say
2039 something even if the Page Table is not accessible. */
2041 display_page_table (long n
, int force
)
2043 unsigned long pde
= get_pde (n
);
2049 printf_filtered ("Page Table pointed to by "
2050 "Page Directory entry 0x%lx:\n", n
);
2051 for (i
= 0; i
< 1024; i
++)
2052 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
2053 puts_filtered ("\n");
2056 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
2060 go32_pte (char *arg
, int from_tty
)
2062 long pde_idx
= -1L, i
;
2066 arg
= skip_spaces (arg
);
2070 pde_idx
= parse_and_eval_long (arg
);
2071 if (pde_idx
< 0 || pde_idx
>= 1024)
2072 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2078 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2079 else if (pde_idx
>= 0)
2080 display_page_table (pde_idx
, 1);
2082 for (i
= 0; i
< 1024; i
++)
2083 display_page_table (i
, 0);
2087 go32_pte_for_address (char *arg
, int from_tty
)
2089 CORE_ADDR addr
= 0, i
;
2093 arg
= skip_spaces (arg
);
2096 addr
= parse_and_eval_address (arg
);
2099 error_no_arg (_("linear address"));
2103 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2106 int pde_idx
= (addr
>> 22) & 0x3ff;
2107 int pte_idx
= (addr
>> 12) & 0x3ff;
2108 unsigned offs
= addr
& 0xfff;
2110 printf_filtered ("Page Table entry for address %s:\n",
2112 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
2116 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
2119 go32_info_dos_command (char *args
, int from_tty
)
2121 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
2124 /* -Wmissing-prototypes */
2125 extern initialize_file_ftype _initialize_go32_nat
;
2128 _initialize_go32_nat (void)
2131 add_target (&go32_ops
);
2133 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
2134 Print information specific to DJGPP (aka MS-DOS) debugging."),
2135 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
2137 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
2138 Display information about the target system, including CPU, OS, DPMI, etc."),
2140 add_cmd ("ldt", class_info
, go32_sldt
, _("\
2141 Display entries in the LDT (Local Descriptor Table).\n\
2142 Entry number (an expression) as an argument means display only that entry."),
2144 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
2145 Display entries in the GDT (Global Descriptor Table).\n\
2146 Entry number (an expression) as an argument means display only that entry."),
2148 add_cmd ("idt", class_info
, go32_sidt
, _("\
2149 Display entries in the IDT (Interrupt Descriptor Table).\n\
2150 Entry number (an expression) as an argument means display only that entry."),
2152 add_cmd ("pde", class_info
, go32_pde
, _("\
2153 Display entries in the Page Directory.\n\
2154 Entry number (an expression) as an argument means display only that entry."),
2156 add_cmd ("pte", class_info
, go32_pte
, _("\
2157 Display entries in Page Tables.\n\
2158 Entry number (an expression) as an argument means display only entries\n\
2159 from the Page Table pointed to by the specified Page Directory entry."),
2161 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
2162 Display a Page Table entry for a linear address.\n\
2163 The address argument must be a linear address, after adding to\n\
2164 it the base address of the appropriate segment.\n\
2165 The base address of variables and functions in the debuggee's data\n\
2166 or code segment is stored in the variable __djgpp_base_address,\n\
2167 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2168 For other segments, look up their base address in the output of\n\
2169 the `info dos ldt' command."),
2183 tcsetpgrp (int fd
, pid_t pgid
)
2185 if (isatty (fd
) && pgid
== SOME_PID
)
2187 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;