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
91 #include "gdbthread.h"
96 #include "floatformat.h"
98 #include "i387-tdep.h"
99 #include "i386-tdep.h"
100 #include "nat/i386-cpuid.h"
102 #include "regcache.h"
104 #include "cli/cli-utils.h"
105 #include "inf-child.h"
110 #include <sys/utsname.h>
115 #include <sys/farptr.h>
116 #include <debug/v2load.h>
117 #include <debug/dbgcom.h>
118 #if __DJGPP_MINOR__ > 2
119 #include <debug/redir.h>
122 #include <langinfo.h>
124 #if __DJGPP_MINOR__ < 3
125 /* This code will be provided from DJGPP 2.03 on. Until then I code it
133 unsigned short exponent
:15;
134 unsigned short sign
:1;
140 unsigned int control
;
145 unsigned int dataptr
;
146 unsigned int datasel
;
153 static void save_npx (void); /* Save the FPU of the debugged program. */
154 static void load_npx (void); /* Restore the FPU of the debugged program. */
156 /* ------------------------------------------------------------------------- */
157 /* Store the contents of the NPX in the global variable `npx'. */
163 asm ("inb $0xa0, %%al \n\
164 testb $0x20, %%al \n\
182 /* ------------------------------------------------------------------------- */
183 /* Reload the contents of the NPX from the global variable `npx'. */
188 asm ("frstor %0":"=m" (npx
));
190 /* ------------------------------------------------------------------------- */
191 /* Stubs for the missing redirection functions. */
198 redir_cmdline_delete (cmdline_t
*ptr
)
204 redir_cmdline_parse (const char *args
, cmdline_t
*ptr
)
210 redir_to_child (cmdline_t
*ptr
)
216 redir_to_debugger (cmdline_t
*ptr
)
222 redir_debug_init (cmdline_t
*ptr
)
226 #endif /* __DJGPP_MINOR < 3 */
228 typedef enum { wp_insert
, wp_remove
, wp_count
} wp_op
;
230 /* This holds the current reference counts for each debug register. */
231 static int dr_ref_count
[4];
235 static int prog_has_started
= 0;
236 static void go32_mourn_inferior (struct target_ops
*ops
);
238 #define r_ofs(x) (offsetof(TSS,x))
247 {r_ofs (tss_eax
), 4}, /* normal registers, from a_tss */
248 {r_ofs (tss_ecx
), 4},
249 {r_ofs (tss_edx
), 4},
250 {r_ofs (tss_ebx
), 4},
251 {r_ofs (tss_esp
), 4},
252 {r_ofs (tss_ebp
), 4},
253 {r_ofs (tss_esi
), 4},
254 {r_ofs (tss_edi
), 4},
255 {r_ofs (tss_eip
), 4},
256 {r_ofs (tss_eflags
), 4},
263 {0, 10}, /* 8 FP registers, from npx.reg[] */
271 /* The order of the next 7 registers must be consistent
272 with their numbering in config/i386/tm-i386.h, which see. */
273 {0, 2}, /* control word, from npx */
274 {4, 2}, /* status word, from npx */
275 {8, 2}, /* tag word, from npx */
276 {16, 2}, /* last FP exception CS from npx */
277 {12, 4}, /* last FP exception EIP from npx */
278 {24, 2}, /* last FP exception operand selector from npx */
279 {20, 4}, /* last FP exception operand offset from npx */
280 {18, 2} /* last FP opcode from npx */
286 enum gdb_signal gdb_sig
;
291 {1, GDB_SIGNAL_TRAP
},
292 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
293 but I think SIGBUS is better, since the NMI is usually activated
294 as a result of a memory parity check failure. */
296 {3, GDB_SIGNAL_TRAP
},
298 {5, GDB_SIGNAL_SEGV
},
300 {7, GDB_SIGNAL_EMT
}, /* no-coprocessor exception */
301 {8, GDB_SIGNAL_SEGV
},
302 {9, GDB_SIGNAL_SEGV
},
303 {10, GDB_SIGNAL_BUS
},
304 {11, GDB_SIGNAL_SEGV
},
305 {12, GDB_SIGNAL_SEGV
},
306 {13, GDB_SIGNAL_SEGV
},
307 {14, GDB_SIGNAL_SEGV
},
308 {16, GDB_SIGNAL_FPE
},
309 {17, GDB_SIGNAL_BUS
},
310 {31, GDB_SIGNAL_ILL
},
311 {0x1b, GDB_SIGNAL_INT
},
312 {0x75, GDB_SIGNAL_FPE
},
313 {0x78, GDB_SIGNAL_ALRM
},
314 {0x79, GDB_SIGNAL_INT
},
315 {0x7a, GDB_SIGNAL_QUIT
},
316 {-1, GDB_SIGNAL_LAST
}
320 enum gdb_signal gdb_sig
;
324 {GDB_SIGNAL_ILL
, 6}, /* Invalid Opcode */
325 {GDB_SIGNAL_EMT
, 7}, /* triggers SIGNOFP */
326 {GDB_SIGNAL_SEGV
, 13}, /* GPF */
327 {GDB_SIGNAL_BUS
, 17}, /* Alignment Check */
328 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
330 {GDB_SIGNAL_TERM
, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
331 {GDB_SIGNAL_FPE
, 0x75},
332 {GDB_SIGNAL_INT
, 0x79},
333 {GDB_SIGNAL_QUIT
, 0x7a},
334 {GDB_SIGNAL_ALRM
, 0x78}, /* triggers SIGTIMR */
335 {GDB_SIGNAL_PROF
, 0x78},
336 {GDB_SIGNAL_LAST
, -1}
340 go32_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
343 You cannot attach to a running program on this platform.\n\
344 Use the `run' command to run DJGPP programs."));
347 static int resume_is_step
;
348 static int resume_signal
= -1;
351 go32_resume (struct target_ops
*ops
,
352 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
356 resume_is_step
= step
;
358 if (siggnal
!= GDB_SIGNAL_0
&& siggnal
!= GDB_SIGNAL_TRAP
)
360 for (i
= 0, resume_signal
= -1;
361 excepn_map
[i
].gdb_sig
!= GDB_SIGNAL_LAST
; i
++)
362 if (excepn_map
[i
].gdb_sig
== siggnal
)
364 resume_signal
= excepn_map
[i
].djgpp_excepno
;
367 if (resume_signal
== -1)
368 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
369 gdb_signal_to_name (siggnal
));
373 static char child_cwd
[FILENAME_MAX
];
376 go32_wait (struct target_ops
*ops
,
377 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
380 unsigned char saved_opcode
;
381 unsigned long INT3_addr
= 0;
382 int stepping_over_INT
= 0;
384 a_tss
.tss_eflags
&= 0xfeff; /* Reset the single-step flag (TF). */
387 /* If the next instruction is INT xx or INTO, we need to handle
388 them specially. Intel manuals say that these instructions
389 reset the single-step flag (a.k.a. TF). However, it seems
390 that, at least in the DPMI environment, and at least when
391 stepping over the DPMI interrupt 31h, the problem is having
392 TF set at all when INT 31h is executed: the debuggee either
393 crashes (and takes the system with it) or is killed by a
396 So we need to emulate single-step mode: we put an INT3 opcode
397 right after the INT xx instruction, let the debuggee run
398 until it hits INT3 and stops, then restore the original
399 instruction which we overwrote with the INT3 opcode, and back
400 up the debuggee's EIP to that instruction. */
401 read_child (a_tss
.tss_eip
, &saved_opcode
, 1);
402 if (saved_opcode
== 0xCD || saved_opcode
== 0xCE)
404 unsigned char INT3_opcode
= 0xCC;
407 = saved_opcode
== 0xCD ? a_tss
.tss_eip
+ 2 : a_tss
.tss_eip
+ 1;
408 stepping_over_INT
= 1;
409 read_child (INT3_addr
, &saved_opcode
, 1);
410 write_child (INT3_addr
, &INT3_opcode
, 1);
413 a_tss
.tss_eflags
|= 0x0100; /* normal instruction: set TF */
416 /* The special value FFFFh in tss_trap indicates to run_child that
417 tss_irqn holds a signal to be delivered to the debuggee. */
418 if (resume_signal
<= -1)
421 a_tss
.tss_irqn
= 0xff;
425 a_tss
.tss_trap
= 0xffff; /* run_child looks for this. */
426 a_tss
.tss_irqn
= resume_signal
;
429 /* The child might change working directory behind our back. The
430 GDB users won't like the side effects of that when they work with
431 relative file names, and GDB might be confused by its current
432 directory not being in sync with the truth. So we always make a
433 point of changing back to where GDB thinks is its cwd, when we
434 return control to the debugger, but restore child's cwd before we
436 /* Initialize child_cwd, before the first call to run_child and not
437 in the initialization, so the child get also the changed directory
438 set with the gdb-command "cd ..." */
440 /* Initialize child's cwd with the current one. */
441 getcwd (child_cwd
, sizeof (child_cwd
));
445 #if __DJGPP_MINOR__ < 3
449 #if __DJGPP_MINOR__ < 3
453 /* Did we step over an INT xx instruction? */
454 if (stepping_over_INT
&& a_tss
.tss_eip
== INT3_addr
+ 1)
456 /* Restore the original opcode. */
457 a_tss
.tss_eip
--; /* EIP points *after* the INT3 instruction. */
458 write_child (a_tss
.tss_eip
, &saved_opcode
, 1);
459 /* Simulate a TRAP exception. */
461 a_tss
.tss_eflags
|= 0x0100;
464 getcwd (child_cwd
, sizeof (child_cwd
)); /* in case it has changed */
465 chdir (current_directory
);
467 if (a_tss
.tss_irqn
== 0x21)
469 status
->kind
= TARGET_WAITKIND_EXITED
;
470 status
->value
.integer
= a_tss
.tss_eax
& 0xff;
474 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
475 status
->kind
= TARGET_WAITKIND_STOPPED
;
476 for (i
= 0; sig_map
[i
].go32_sig
!= -1; i
++)
478 if (a_tss
.tss_irqn
== sig_map
[i
].go32_sig
)
480 #if __DJGPP_MINOR__ < 3
481 if ((status
->value
.sig
= sig_map
[i
].gdb_sig
) !=
483 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
485 status
->value
.sig
= sig_map
[i
].gdb_sig
;
491 return pid_to_ptid (SOME_PID
);
495 fetch_register (struct regcache
*regcache
, int regno
)
497 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
498 if (regno
< gdbarch_fp0_regnum (gdbarch
))
499 regcache_raw_supply (regcache
, regno
,
500 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
501 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
503 i387_supply_fsave (regcache
, regno
, &npx
);
505 internal_error (__FILE__
, __LINE__
,
506 _("Invalid register no. %d in fetch_register."), regno
);
510 go32_fetch_registers (struct target_ops
*ops
,
511 struct regcache
*regcache
, int regno
)
514 fetch_register (regcache
, regno
);
518 regno
< gdbarch_fp0_regnum (get_regcache_arch (regcache
));
520 fetch_register (regcache
, regno
);
521 i387_supply_fsave (regcache
, -1, &npx
);
526 store_register (const struct regcache
*regcache
, int regno
)
528 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
529 if (regno
< gdbarch_fp0_regnum (gdbarch
))
530 regcache_raw_collect (regcache
, regno
,
531 (char *) &a_tss
+ regno_mapping
[regno
].tss_ofs
);
532 else if (i386_fp_regnum_p (gdbarch
, regno
) || i386_fpc_regnum_p (gdbarch
,
534 i387_collect_fsave (regcache
, regno
, &npx
);
536 internal_error (__FILE__
, __LINE__
,
537 _("Invalid register no. %d in store_register."), regno
);
541 go32_store_registers (struct target_ops
*ops
,
542 struct regcache
*regcache
, int regno
)
547 store_register (regcache
, regno
);
550 for (r
= 0; r
< gdbarch_fp0_regnum (get_regcache_arch (regcache
)); r
++)
551 store_register (regcache
, r
);
552 i387_collect_fsave (regcache
, -1, &npx
);
556 /* Const-correct version of DJGPP's write_child, which unfortunately
557 takes a non-const buffer pointer. */
560 my_write_child (unsigned child_addr
, const void *buf
, unsigned len
)
562 static void *buffer
= NULL
;
563 static unsigned buffer_len
= 0;
566 if (buffer_len
< len
)
568 buffer
= xrealloc (buffer
, len
);
572 memcpy (buffer
, buf
, len
);
573 res
= write_child (child_addr
, buffer
, len
);
577 /* Helper for go32_xfer_partial that handles memory transfers.
578 Arguments are like target_xfer_partial. */
580 static enum target_xfer_status
581 go32_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
582 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
586 if (writebuf
!= NULL
)
587 res
= my_write_child (memaddr
, writebuf
, len
);
589 res
= read_child (memaddr
, readbuf
, len
);
592 return TARGET_XFER_E_IO
;
595 return TARGET_XFER_OK
;
598 /* Target to_xfer_partial implementation. */
600 static enum target_xfer_status
601 go32_xfer_partial (struct target_ops
*ops
, enum target_object object
,
602 const char *annex
, gdb_byte
*readbuf
,
603 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
604 ULONGEST
*xfered_len
)
608 case TARGET_OBJECT_MEMORY
:
609 return go32_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
612 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
613 readbuf
, writebuf
, offset
, len
,
618 static cmdline_t child_cmd
; /* Parsed child's command line kept here. */
621 go32_files_info (struct target_ops
*target
)
623 printf_unfiltered ("You are running a DJGPP V2 program.\n");
627 go32_kill_inferior (struct target_ops
*ops
)
629 go32_mourn_inferior (ops
);
633 go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
634 char *args
, char **env
, int from_tty
)
636 extern char **environ
;
639 char **env_save
= environ
;
641 struct inferior
*inf
;
643 /* If no exec file handed to us, get it from the exec-file command -- with
644 a good, common error message if none is specified. */
646 exec_file
= get_exec_file (1);
651 /* Initialize child's cwd as empty to be initialized when starting
655 /* Init command line storage. */
656 if (redir_debug_init (&child_cmd
) == -1)
657 internal_error (__FILE__
, __LINE__
,
658 _("Cannot allocate redirection storage: "
659 "not enough memory.\n"));
661 /* Parse the command line and create redirections. */
662 if (strpbrk (args
, "<>"))
664 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
665 args
= child_cmd
.command
;
667 error (_("Syntax error in command line."));
670 child_cmd
.command
= xstrdup (args
);
672 cmdlen
= strlen (args
);
673 /* v2loadimage passes command lines via DOS memory, so it cannot
674 possibly handle commands longer than 1MB. */
675 if (cmdlen
> 1024*1024)
676 error (_("Command line too long."));
678 cmdline
= xmalloc (cmdlen
+ 4);
679 strcpy (cmdline
+ 1, args
);
680 /* If the command-line length fits into DOS 126-char limits, use the
681 DOS command tail format; otherwise, tell v2loadimage to pass it
682 through a buffer in conventional memory. */
685 cmdline
[0] = strlen (args
);
686 cmdline
[cmdlen
+ 1] = 13;
689 cmdline
[0] = 0xff; /* Signal v2loadimage it's a long command. */
693 if (v2loadimage (exec_file
, cmdline
, start_state
))
696 printf_unfiltered ("Load failed for image %s\n", exec_file
);
702 edi_init (start_state
);
703 #if __DJGPP_MINOR__ < 3
707 inferior_ptid
= pid_to_ptid (SOME_PID
);
708 inf
= current_inferior ();
709 inferior_appeared (inf
, SOME_PID
);
711 if (!target_is_pushed (ops
))
714 add_thread_silent (inferior_ptid
);
716 clear_proceed_status (0);
717 insert_breakpoints ();
718 prog_has_started
= 1;
722 go32_mourn_inferior (struct target_ops
*ops
)
726 redir_cmdline_delete (&child_cmd
);
732 /* We need to make sure all the breakpoint enable bits in the DR7
733 register are reset when the inferior exits. Otherwise, if they
734 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
735 failure to set more watchpoints, and other calamities. It would
736 be nice if GDB itself would take care to remove all breakpoints
737 at all times, but it doesn't, probably under an assumption that
738 the OS cleans up when the debuggee exits. */
739 i386_cleanup_dregs ();
741 ptid
= inferior_ptid
;
742 inferior_ptid
= null_ptid
;
743 delete_thread_silent (ptid
);
744 prog_has_started
= 0;
746 generic_mourn_inferior ();
747 inf_child_maybe_unpush_target (ops
);
750 /* Hardware watchpoint support. */
752 #define D_REGS edi.dr
753 #define CONTROL D_REGS[7]
754 #define STATUS D_REGS[6]
756 /* Pass the address ADDR to the inferior in the I'th debug register.
757 Here we just store the address in D_REGS, the watchpoint will be
758 actually set up when go32_wait runs the debuggee. */
760 go32_set_dr (int i
, CORE_ADDR addr
)
763 internal_error (__FILE__
, __LINE__
,
764 _("Invalid register %d in go32_set_dr.\n"), i
);
768 /* Pass the value VAL to the inferior in the DR7 debug control
769 register. Here we just store the address in D_REGS, the watchpoint
770 will be actually set up when go32_wait runs the debuggee. */
772 go32_set_dr7 (unsigned long val
)
777 /* Get the value of the DR6 debug status register from the inferior.
778 Here we just return the value stored in D_REGS, as we've got it
779 from the last go32_wait call. */
786 /* Get the value of the DR7 debug status register from the inferior.
787 Here we just return the value stored in D_REGS, as we've got it
788 from the last go32_wait call. */
796 /* Get the value of the DR debug register I from the inferior. Here
797 we just return the value stored in D_REGS, as we've got it from the
798 last go32_wait call. */
804 internal_error (__FILE__
, __LINE__
,
805 _("Invalid register %d in go32_get_dr.\n"), i
);
809 /* Put the device open on handle FD into either raw or cooked
810 mode, return 1 if it was in raw mode, zero otherwise. */
813 device_mode (int fd
, int raw_p
)
815 int oldmode
, newmode
;
820 __dpmi_int (0x21, ®s
);
821 if (regs
.x
.flags
& 1)
823 newmode
= oldmode
= regs
.x
.dx
;
830 if (oldmode
& 0x80) /* Only for character dev. */
834 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails. */
835 __dpmi_int (0x21, ®s
);
836 if (regs
.x
.flags
& 1)
839 return (oldmode
& 0x20) == 0x20;
843 static int inf_mode_valid
= 0;
844 static int inf_terminal_mode
;
846 /* This semaphore is needed because, amazingly enough, GDB calls
847 target.to_terminal_ours more than once after the inferior stops.
848 But we need the information from the first call only, since the
849 second call will always see GDB's own cooked terminal. */
850 static int terminal_is_ours
= 1;
853 go32_terminal_init (struct target_ops
*self
)
855 inf_mode_valid
= 0; /* Reinitialize, in case they are restarting child. */
856 terminal_is_ours
= 1;
860 go32_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
862 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
864 ? "default" : inf_terminal_mode
? "raw" : "cooked");
866 #if __DJGPP_MINOR__ > 2
867 if (child_cmd
.redirection
)
871 for (i
= 0; i
< DBG_HANDLES
; i
++)
873 if (child_cmd
.redirection
[i
]->file_name
)
874 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
875 i
, child_cmd
.redirection
[i
]->file_name
);
876 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
878 ("\tFile handle %d appears to be closed by inferior.\n", i
);
879 /* Mask off the raw/cooked bit when comparing device info words. */
880 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
881 != (_get_dev_info (i
) & 0xdf))
883 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
890 go32_terminal_inferior (struct target_ops
*self
)
892 /* Redirect standard handles as child wants them. */
894 if (redir_to_child (&child_cmd
) == -1)
896 redir_to_debugger (&child_cmd
);
897 error (_("Cannot redirect standard handles for program: %s."),
898 safe_strerror (errno
));
900 /* Set the console device of the inferior to whatever mode
901 (raw or cooked) we found it last time. */
902 if (terminal_is_ours
)
905 device_mode (0, inf_terminal_mode
);
906 terminal_is_ours
= 0;
911 go32_terminal_ours (struct target_ops
*self
)
913 /* Switch to cooked mode on the gdb terminal and save the inferior
914 terminal mode to be restored when it is resumed. */
915 if (!terminal_is_ours
)
917 inf_terminal_mode
= device_mode (0, 0);
918 if (inf_terminal_mode
!= -1)
921 /* If device_mode returned -1, we don't know what happens with
922 handle 0 anymore, so make the info invalid. */
924 terminal_is_ours
= 1;
926 /* Restore debugger's standard handles. */
928 if (redir_to_debugger (&child_cmd
) == -1)
930 redir_to_child (&child_cmd
);
931 error (_("Cannot redirect standard handles for debugger: %s."),
932 safe_strerror (errno
));
938 go32_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
940 return !ptid_equal (inferior_ptid
, null_ptid
);
944 go32_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
946 return normal_pid_to_str (ptid
);
949 /* Create a go32 target. */
951 static struct target_ops
*
954 struct target_ops
*t
= inf_child_target ();
956 t
->to_attach
= go32_attach
;
957 t
->to_resume
= go32_resume
;
958 t
->to_wait
= go32_wait
;
959 t
->to_fetch_registers
= go32_fetch_registers
;
960 t
->to_store_registers
= go32_store_registers
;
961 t
->to_xfer_partial
= go32_xfer_partial
;
962 t
->to_files_info
= go32_files_info
;
963 t
->to_terminal_init
= go32_terminal_init
;
964 t
->to_terminal_inferior
= go32_terminal_inferior
;
965 t
->to_terminal_ours_for_output
= go32_terminal_ours
;
966 t
->to_terminal_ours
= go32_terminal_ours
;
967 t
->to_terminal_info
= go32_terminal_info
;
968 t
->to_kill
= go32_kill_inferior
;
969 t
->to_create_inferior
= go32_create_inferior
;
970 t
->to_mourn_inferior
= go32_mourn_inferior
;
971 t
->to_thread_alive
= go32_thread_alive
;
972 t
->to_pid_to_str
= go32_pid_to_str
;
977 /* Return the current DOS codepage number. */
984 __dpmi_int (0x21, ®s
);
985 if (!(regs
.x
.flags
& 1))
986 return regs
.x
.bx
& 0xffff;
988 return 437; /* default */
991 /* Limited emulation of `nl_langinfo', for charset.c. */
993 nl_langinfo (nl_item item
)
1001 /* 8 is enough for SHORT_MAX + "CP" + null. */
1003 int blen
= sizeof (buf
);
1004 int needed
= snprintf (buf
, blen
, "CP%d", dos_codepage ());
1006 if (needed
> blen
) /* Should never happen. */
1008 retval
= xstrdup (buf
);
1012 retval
= xstrdup ("");
1018 unsigned short windows_major
, windows_minor
;
1020 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
1022 go32_get_windows_version(void)
1027 __dpmi_int(0x2f, &r
);
1028 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
1029 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
1031 windows_major
= r
.h
.al
;
1032 windows_minor
= r
.h
.ah
;
1035 windows_major
= 0xff; /* meaning no Windows */
1038 /* A subroutine of go32_sysinfo to display memory info. */
1040 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
1042 if (datum
!= 0xffffffffUL
)
1046 puts_filtered (header
);
1049 printf_filtered ("%lu KB", datum
>> 10);
1050 if (datum
> 1024 * 1024)
1051 printf_filtered (" (%lu MB)", datum
>> 20);
1054 printf_filtered ("%lu Bytes", datum
);
1055 puts_filtered ("\n");
1059 /* Display assorted information about the underlying OS. */
1061 go32_sysinfo (char *arg
, int from_tty
)
1063 static const char test_pattern
[] =
1064 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1065 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1066 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1068 char cpuid_vendor
[13];
1069 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
1070 unsigned true_dos_version
= _get_dos_version (1);
1071 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
1073 char dpmi_vendor_info
[129];
1074 int dpmi_vendor_available
;
1075 __dpmi_version_ret dpmi_version_data
;
1077 __dpmi_free_mem_info mem_info
;
1080 cpuid_vendor
[0] = '\0';
1082 strcpy (u
.machine
, "Unknown x86");
1083 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
1085 /* CPUID with EAX = 0 returns the Vendor ID. */
1087 /* Ideally we would use i386_cpuid(), but it needs someone to run
1088 native tests first to make sure things actually work. They should.
1089 http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html */
1090 unsigned int eax
, ebx
, ecx
, edx
;
1092 if (i386_cpuid (0, &eax
, &ebx
, &ecx
, &edx
))
1095 memcpy (&vendor
[0], &ebx
, 4);
1096 memcpy (&vendor
[4], &ecx
, 4);
1097 memcpy (&vendor
[8], &edx
, 4);
1098 cpuid_vendor
[12] = '\0';
1101 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1102 "xorl %%ecx, %%ecx;"
1103 "xorl %%edx, %%edx;"
1110 : "=m" (cpuid_vendor
[0]),
1111 "=m" (cpuid_vendor
[4]),
1112 "=m" (cpuid_vendor
[8]),
1115 : "%eax", "%ebx", "%ecx", "%edx");
1116 cpuid_vendor
[12] = '\0';
1120 printf_filtered ("CPU Type.......................%s", u
.machine
);
1121 if (cpuid_vendor
[0])
1122 printf_filtered (" (%s)", cpuid_vendor
);
1123 puts_filtered ("\n");
1125 /* CPUID with EAX = 1 returns processor signature and features. */
1128 static char *brand_name
[] = {
1136 char cpu_string
[80];
1139 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1140 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1141 unsigned cpu_family
, cpu_model
;
1144 /* See comment above about cpuid usage. */
1145 i386_cpuid (1, &cpuid_eax
, &cpuid_ebx
, NULL
, &cpuid_edx
);
1147 __asm__
__volatile__ ("movl $1, %%eax;"
1155 brand_idx
= cpuid_ebx
& 0xff;
1156 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1157 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1158 cpu_brand
[0] = '\0';
1162 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1163 && *brand_name
[brand_idx
])
1164 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1165 else if (cpu_family
== 5)
1167 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1168 strcpy (cpu_brand
, " MMX");
1169 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1170 strcpy (cpu_brand
, " OverDrive");
1171 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1172 strcpy (cpu_brand
, " Dual");
1174 else if (cpu_family
== 6 && cpu_model
< 8)
1179 strcpy (cpu_brand
, " Pro");
1182 strcpy (cpu_brand
, " II");
1185 strcpy (cpu_brand
, " II Xeon");
1188 strcpy (cpu_brand
, " Celeron");
1191 strcpy (cpu_brand
, " III");
1201 strcpy (cpu_brand
, "486/5x86");
1210 strcpy (cpu_brand
, "-K5");
1214 strcpy (cpu_brand
, "-K6");
1217 strcpy (cpu_brand
, "-K6-2");
1220 strcpy (cpu_brand
, "-K6-III");
1230 strcpy (cpu_brand
, " Athlon");
1233 strcpy (cpu_brand
, " Duron");
1239 xsnprintf (cpu_string
, sizeof (cpu_string
), "%s%s Model %d Stepping %d",
1240 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1241 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1242 printfi_filtered (31, "%s\n", cpu_string
);
1243 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1244 || ((cpuid_edx
& 1) == 0)
1245 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1247 puts_filtered ("CPU Features...................");
1248 /* We only list features which might be useful in the DPMI
1250 if ((cpuid_edx
& 1) == 0)
1251 puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
1252 if ((cpuid_edx
& (1 << 1)) != 0)
1253 puts_filtered ("VME ");
1254 if ((cpuid_edx
& (1 << 2)) != 0)
1255 puts_filtered ("DE ");
1256 if ((cpuid_edx
& (1 << 4)) != 0)
1257 puts_filtered ("TSC ");
1258 if ((cpuid_edx
& (1 << 23)) != 0)
1259 puts_filtered ("MMX ");
1260 if ((cpuid_edx
& (1 << 25)) != 0)
1261 puts_filtered ("SSE ");
1262 if ((cpuid_edx
& (1 << 26)) != 0)
1263 puts_filtered ("SSE2 ");
1266 if ((cpuid_edx
& (1 << 31)) != 0)
1267 puts_filtered ("3DNow! ");
1268 if ((cpuid_edx
& (1 << 30)) != 0)
1269 puts_filtered ("3DNow!Ext");
1271 puts_filtered ("\n");
1274 puts_filtered ("\n");
1275 printf_filtered ("DOS Version....................%s %s.%s",
1276 _os_flavor
, u
.release
, u
.version
);
1277 if (true_dos_version
!= advertized_dos_version
)
1278 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1279 puts_filtered ("\n");
1281 go32_get_windows_version ();
1282 if (windows_major
!= 0xff)
1284 const char *windows_flavor
;
1286 printf_filtered ("Windows Version................%d.%02d (Windows ",
1287 windows_major
, windows_minor
);
1288 switch (windows_major
)
1291 windows_flavor
= "3.X";
1294 switch (windows_minor
)
1297 windows_flavor
= "95, 95A, or 95B";
1300 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1303 windows_flavor
= "98 or 98 SE";
1306 windows_flavor
= "ME";
1309 windows_flavor
= "9X";
1314 windows_flavor
= "??";
1317 printf_filtered ("%s)\n", windows_flavor
);
1319 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1320 printf_filtered ("Windows Version................"
1321 "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1322 puts_filtered ("\n");
1323 /* On some versions of Windows, __dpmi_get_capabilities returns
1324 zero, but the buffer is not filled with info, so we fill the
1325 buffer with a known pattern and test for it afterwards. */
1326 memcpy (dpmi_vendor_info
, test_pattern
, sizeof(dpmi_vendor_info
));
1327 dpmi_vendor_available
=
1328 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
1329 if (dpmi_vendor_available
== 0
1330 && memcmp (dpmi_vendor_info
, test_pattern
,
1331 sizeof(dpmi_vendor_info
)) != 0)
1333 /* The DPMI spec says the vendor string should be ASCIIZ, but
1334 I don't trust the vendors to follow that... */
1335 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1336 dpmi_vendor_info
[128] = '\0';
1337 printf_filtered ("DPMI Host......................"
1338 "%s v%d.%d (capabilities: %#x)\n",
1339 &dpmi_vendor_info
[2],
1340 (unsigned)dpmi_vendor_info
[0],
1341 (unsigned)dpmi_vendor_info
[1],
1342 ((unsigned)dpmi_flags
& 0x7f));
1345 printf_filtered ("DPMI Host......................(Info not available)\n");
1346 __dpmi_get_version (&dpmi_version_data
);
1347 printf_filtered ("DPMI Version...................%d.%02d\n",
1348 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1349 printf_filtered ("DPMI Info......................"
1350 "%s-bit DPMI, with%s Virtual Memory support\n",
1351 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1352 (dpmi_version_data
.flags
& 4) ? "" : "out");
1353 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1354 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1355 printfi_filtered (31, "Processor type: i%d86\n",
1356 dpmi_version_data
.cpu
);
1357 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1358 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1360 /* a_tss is only initialized when the debuggee is first run. */
1361 if (prog_has_started
)
1363 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1364 printf_filtered ("Protection....................."
1365 "Ring %d (in %s), with%s I/O protection\n",
1366 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1367 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1369 puts_filtered ("\n");
1370 __dpmi_get_free_memory_information (&mem_info
);
1371 print_mem (mem_info
.total_number_of_physical_pages
,
1372 "DPMI Total Physical Memory.....", 1);
1373 print_mem (mem_info
.total_number_of_free_pages
,
1374 "DPMI Free Physical Memory......", 1);
1375 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1376 "DPMI Swap Space................", 1);
1377 print_mem (mem_info
.linear_address_space_size_in_pages
,
1378 "DPMI Total Linear Address Size.", 1);
1379 print_mem (mem_info
.free_linear_address_space_in_pages
,
1380 "DPMI Free Linear Address Size..", 1);
1381 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1382 "DPMI Largest Free Memory Block.", 0);
1386 __dpmi_int (0x21, ®s
);
1387 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1389 __dpmi_int (0x21, ®s
);
1390 if ((regs
.x
.flags
& 1) == 0)
1392 static const char *dos_hilo
[] = {
1393 "Low", "", "", "", "High", "", "", "", "High, then Low"
1395 static const char *dos_fit
[] = {
1396 "First", "Best", "Last"
1398 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1399 int fit_idx
= regs
.x
.ax
& 0x0f;
1405 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1406 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1408 __dpmi_int (0x21, ®s
);
1409 if ((regs
.x
.flags
& 1) != 0)
1411 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1412 regs
.h
.al
== 0 ? "not " : "");
1417 unsigned short limit0
;
1418 unsigned short base0
;
1419 unsigned char base1
;
1424 unsigned available
:1;
1427 unsigned page_granular
:1;
1428 unsigned char base2
;
1429 } __attribute__ ((packed
));
1432 unsigned short offset0
;
1433 unsigned short selector
;
1434 unsigned param_count
:5;
1439 unsigned short offset1
;
1440 } __attribute__ ((packed
));
1442 /* Read LEN bytes starting at logical address ADDR, and put the result
1443 into DEST. Return 1 if success, zero if not. */
1445 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1447 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1450 /* For the low memory, we can simply use _dos_ds. */
1451 if (addr
<= dos_ds_limit
- len
)
1452 dosmemget (addr
, len
, dest
);
1455 /* For memory above 1MB we need to set up a special segment to
1456 be able to access that memory. */
1457 int sel
= __dpmi_allocate_ldt_descriptors (1);
1463 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1464 size_t segment_limit
= len
- 1;
1466 /* Make sure the crucial bits in the descriptor access
1467 rights are set correctly. Some DPMI providers might barf
1468 if we set the segment limit to something that is not an
1469 integral multiple of 4KB pages if the granularity bit is
1470 not set to byte-granular, even though the DPMI spec says
1471 it's the host's responsibility to set that bit correctly. */
1472 if (len
> 1024 * 1024)
1474 access_rights
|= 0x8000;
1475 /* Page-granular segments should have the low 12 bits of
1477 segment_limit
|= 0xfff;
1480 access_rights
&= ~0x8000;
1482 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1483 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1484 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1485 /* W2K silently fails to set the segment limit, leaving
1486 it at zero; this test avoids the resulting crash. */
1487 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1488 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1492 __dpmi_free_ldt_descriptor (sel
);
1498 /* Get a segment descriptor stored at index IDX in the descriptor
1499 table whose base address is TABLE_BASE. Return the descriptor
1500 type, or -1 if failure. */
1502 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1504 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1506 if (read_memory_region (addr
, descr
, 8))
1507 return (int)((struct seg_descr
*)descr
)->stype
;
1512 unsigned short limit
__attribute__((packed
));
1513 unsigned long base
__attribute__((packed
));
1516 /* Display a segment descriptor stored at index IDX in a descriptor
1517 table whose type is TYPE and whose base address is BASE_ADDR. If
1518 FORCE is non-zero, display even invalid descriptors. */
1520 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1522 struct seg_descr descr
;
1523 struct gate_descr gate
;
1525 /* Get the descriptor from the table. */
1526 if (idx
== 0 && type
== 0)
1527 puts_filtered ("0x000: null descriptor\n");
1528 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1530 /* For each type of descriptor table, this has a bit set if the
1531 corresponding type of selectors is valid in that table. */
1532 static unsigned allowed_descriptors
[] = {
1533 0xffffdafeL
, /* GDT */
1534 0x0000c0e0L
, /* IDT */
1535 0xffffdafaL
/* LDT */
1538 /* If the program hasn't started yet, assume the debuggee will
1539 have the same CPL as the debugger. */
1540 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1541 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1544 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1546 printf_filtered ("0x%03x: ",
1548 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1549 if (descr
.page_granular
)
1550 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1551 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1552 || descr
.stype
== 9 || descr
.stype
== 11
1553 || (descr
.stype
>= 16 && descr
.stype
< 32))
1554 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1555 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1557 switch (descr
.stype
)
1561 printf_filtered (" 16-bit TSS (task %sactive)",
1562 descr
.stype
== 3 ? "" : "in");
1565 puts_filtered (" LDT");
1568 memcpy (&gate
, &descr
, sizeof gate
);
1569 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1570 gate
.selector
, gate
.offset1
, gate
.offset0
);
1571 printf_filtered (" 16-bit Call Gate (params=%d)",
1575 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1576 printfi_filtered (16, "Task Gate");
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 %s Gate",
1584 descr
.stype
== 6 ? "Interrupt" : "Trap");
1588 printf_filtered (" 32-bit TSS (task %sactive)",
1589 descr
.stype
== 3 ? "" : "in");
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 (" 32-bit Call Gate (params=%d)",
1600 memcpy (&gate
, &descr
, sizeof gate
);
1601 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1602 gate
.selector
, gate
.offset1
, gate
.offset0
);
1603 printf_filtered (" 32-bit %s Gate",
1604 descr
.stype
== 14 ? "Interrupt" : "Trap");
1606 case 16: /* data segments */
1614 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1615 descr
.bit32
? "32" : "16",
1617 ? "Read/Write," : "Read-Only, ",
1618 descr
.stype
& 4 ? "down" : "up",
1619 descr
.stype
& 1 ? "" : ", N.Acc");
1621 case 24: /* code segments */
1629 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1630 descr
.bit32
? "32" : "16",
1631 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1632 descr
.stype
& 4 ? "" : "N.",
1633 descr
.stype
& 1 ? "" : ", N.Acc");
1636 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1639 puts_filtered ("\n");
1643 printf_filtered ("0x%03x: ",
1645 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1647 puts_filtered ("Segment not present\n");
1649 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1654 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1658 go32_sldt (char *arg
, int from_tty
)
1660 struct dtr_reg gdtr
;
1661 unsigned short ldtr
= 0;
1663 struct seg_descr ldt_descr
;
1664 long ldt_entry
= -1L;
1665 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1669 arg
= skip_spaces (arg
);
1673 ldt_entry
= parse_and_eval_long (arg
);
1675 || (ldt_entry
& 4) == 0
1676 || (ldt_entry
& 3) != (cpl
& 3))
1677 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1681 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1682 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1685 puts_filtered ("There is no LDT.\n");
1686 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1687 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1688 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1690 | (ldt_descr
.base1
<< 16)
1691 | (ldt_descr
.base2
<< 24));
1696 | (ldt_descr
.base1
<< 16)
1697 | (ldt_descr
.base2
<< 24);
1698 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1701 if (ldt_descr
.page_granular
)
1702 /* Page-granular segments must have the low 12 bits of their
1704 limit
= (limit
<< 12) | 0xfff;
1705 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1710 max_entry
= (limit
+ 1) / 8;
1714 if (ldt_entry
> limit
)
1715 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1716 (unsigned long)ldt_entry
, limit
);
1718 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1724 for (i
= 0; i
< max_entry
; i
++)
1725 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1731 go32_sgdt (char *arg
, int from_tty
)
1733 struct dtr_reg gdtr
;
1734 long gdt_entry
= -1L;
1739 arg
= skip_spaces (arg
);
1743 gdt_entry
= parse_and_eval_long (arg
);
1744 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1745 error (_("Invalid GDT entry 0x%03lx: "
1746 "not an integral multiple of 8."),
1747 (unsigned long)gdt_entry
);
1751 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1752 max_entry
= (gdtr
.limit
+ 1) / 8;
1756 if (gdt_entry
> gdtr
.limit
)
1757 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1758 (unsigned long)gdt_entry
, gdtr
.limit
);
1760 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1766 for (i
= 0; i
< max_entry
; i
++)
1767 display_descriptor (0, gdtr
.base
, i
, 0);
1772 go32_sidt (char *arg
, int from_tty
)
1774 struct dtr_reg idtr
;
1775 long idt_entry
= -1L;
1780 arg
= skip_spaces (arg
);
1784 idt_entry
= parse_and_eval_long (arg
);
1786 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1790 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1791 max_entry
= (idtr
.limit
+ 1) / 8;
1792 if (max_entry
> 0x100) /* No more than 256 entries. */
1797 if (idt_entry
> idtr
.limit
)
1798 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1799 (unsigned long)idt_entry
, idtr
.limit
);
1801 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1807 for (i
= 0; i
< max_entry
; i
++)
1808 display_descriptor (1, idtr
.base
, i
, 0);
1812 /* Cached linear address of the base of the page directory. For
1813 now, available only under CWSDPMI. Code based on ideas and
1814 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1815 static unsigned long pdbr
;
1817 static unsigned long
1822 unsigned long taskbase
, cr3
;
1823 struct dtr_reg gdtr
;
1825 if (pdbr
> 0 && pdbr
<= 0xfffff)
1828 /* Get the linear address of GDT and the Task Register. */
1829 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1830 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1832 /* Task Register is a segment selector for the TSS of the current
1833 task. Therefore, it can be used as an index into the GDT to get
1834 at the segment descriptor for the TSS. To get the index, reset
1835 the low 3 bits of the selector (which give the CPL). Add 2 to the
1836 offset to point to the 3 low bytes of the base address. */
1837 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1840 /* CWSDPMI's task base is always under the 1MB mark. */
1841 if (offset
> 0xfffff)
1844 _farsetsel (_dos_ds
);
1845 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1846 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1847 if (taskbase
> 0xfffff)
1850 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1851 offset 1Ch in the TSS. */
1852 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1855 #if 0 /* Not fullly supported yet. */
1856 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1857 the first Page Table right below the Page Directory. Thus,
1858 the first Page Table's entry for its own address and the Page
1859 Directory entry for that Page Table will hold the same
1860 physical address. The loop below searches the entire UMB
1861 range of addresses for such an occurence. */
1862 unsigned long addr
, pte_idx
;
1864 for (addr
= 0xb0000, pte_idx
= 0xb0;
1866 addr
+= 0x1000, pte_idx
++)
1868 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1869 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1870 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1872 cr3
= addr
+ 0x1000;
1885 /* Return the N'th Page Directory entry. */
1886 static unsigned long
1889 unsigned long pde
= 0;
1891 if (pdbr
&& n
>= 0 && n
< 1024)
1893 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1898 /* Return the N'th entry of the Page Table whose Page Directory entry
1900 static unsigned long
1901 get_pte (unsigned long pde
, int n
)
1903 unsigned long pte
= 0;
1905 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1906 page tables, for now. */
1907 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1909 pde
&= ~0xfff; /* Clear non-address bits. */
1910 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1915 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1916 says this is a Page Directory entry. If FORCE is non-zero, display
1917 the entry even if its Present flag is off. OFF is the offset of the
1918 address from the page's base address. */
1920 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1922 if ((entry
& 1) != 0)
1924 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1925 if ((entry
& 0x100) && !is_dir
)
1926 puts_filtered (" Global");
1927 if ((entry
& 0x40) && !is_dir
)
1928 puts_filtered (" Dirty");
1929 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1930 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1931 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1932 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1933 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1935 printf_filtered (" +0x%x", off
);
1936 puts_filtered ("\n");
1939 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1940 is_dir
? " Table" : "", entry
>> 1);
1944 go32_pde (char *arg
, int from_tty
)
1946 long pde_idx
= -1, i
;
1950 arg
= skip_spaces (arg
);
1954 pde_idx
= parse_and_eval_long (arg
);
1955 if (pde_idx
< 0 || pde_idx
>= 1024)
1956 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1962 puts_filtered ("Access to Page Directories is "
1963 "not supported on this system.\n");
1964 else if (pde_idx
>= 0)
1965 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
1967 for (i
= 0; i
< 1024; i
++)
1968 display_ptable_entry (get_pde (i
), 1, 0, 0);
1971 /* A helper function to display entries in a Page Table pointed to by
1972 the N'th entry in the Page Directory. If FORCE is non-zero, say
1973 something even if the Page Table is not accessible. */
1975 display_page_table (long n
, int force
)
1977 unsigned long pde
= get_pde (n
);
1983 printf_filtered ("Page Table pointed to by "
1984 "Page Directory entry 0x%lx:\n", n
);
1985 for (i
= 0; i
< 1024; i
++)
1986 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
1987 puts_filtered ("\n");
1990 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
1994 go32_pte (char *arg
, int from_tty
)
1996 long pde_idx
= -1L, i
;
2000 arg
= skip_spaces (arg
);
2004 pde_idx
= parse_and_eval_long (arg
);
2005 if (pde_idx
< 0 || pde_idx
>= 1024)
2006 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2012 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2013 else if (pde_idx
>= 0)
2014 display_page_table (pde_idx
, 1);
2016 for (i
= 0; i
< 1024; i
++)
2017 display_page_table (i
, 0);
2021 go32_pte_for_address (char *arg
, int from_tty
)
2023 CORE_ADDR addr
= 0, i
;
2027 arg
= skip_spaces (arg
);
2030 addr
= parse_and_eval_address (arg
);
2033 error_no_arg (_("linear address"));
2037 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2040 int pde_idx
= (addr
>> 22) & 0x3ff;
2041 int pte_idx
= (addr
>> 12) & 0x3ff;
2042 unsigned offs
= addr
& 0xfff;
2044 printf_filtered ("Page Table entry for address %s:\n",
2046 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
2050 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
2053 go32_info_dos_command (char *args
, int from_tty
)
2055 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
2058 /* -Wmissing-prototypes */
2059 extern initialize_file_ftype _initialize_go32_nat
;
2062 _initialize_go32_nat (void)
2064 struct target_ops
*t
= go32_target ();
2066 i386_dr_low
.set_control
= go32_set_dr7
;
2067 i386_dr_low
.set_addr
= go32_set_dr
;
2068 i386_dr_low
.get_status
= go32_get_dr6
;
2069 i386_dr_low
.get_control
= go32_get_dr7
;
2070 i386_dr_low
.get_addr
= go32_get_dr
;
2071 i386_set_debug_register_length (4);
2073 i386_use_watchpoints (t
);
2076 /* Initialize child's cwd as empty to be initialized when starting
2080 /* Initialize child's command line storage. */
2081 if (redir_debug_init (&child_cmd
) == -1)
2082 internal_error (__FILE__
, __LINE__
,
2083 _("Cannot allocate redirection storage: "
2084 "not enough memory.\n"));
2086 /* We are always processing GCC-compiled programs. */
2087 processing_gcc_compilation
= 2;
2089 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
2090 Print information specific to DJGPP (aka MS-DOS) debugging."),
2091 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
2093 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
2094 Display information about the target system, including CPU, OS, DPMI, etc."),
2096 add_cmd ("ldt", class_info
, go32_sldt
, _("\
2097 Display entries in the LDT (Local Descriptor Table).\n\
2098 Entry number (an expression) as an argument means display only that entry."),
2100 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
2101 Display entries in the GDT (Global Descriptor Table).\n\
2102 Entry number (an expression) as an argument means display only that entry."),
2104 add_cmd ("idt", class_info
, go32_sidt
, _("\
2105 Display entries in the IDT (Interrupt Descriptor Table).\n\
2106 Entry number (an expression) as an argument means display only that entry."),
2108 add_cmd ("pde", class_info
, go32_pde
, _("\
2109 Display entries in the Page Directory.\n\
2110 Entry number (an expression) as an argument means display only that entry."),
2112 add_cmd ("pte", class_info
, go32_pte
, _("\
2113 Display entries in Page Tables.\n\
2114 Entry number (an expression) as an argument means display only entries\n\
2115 from the Page Table pointed to by the specified Page Directory entry."),
2117 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
2118 Display a Page Table entry for a linear address.\n\
2119 The address argument must be a linear address, after adding to\n\
2120 it the base address of the appropriate segment.\n\
2121 The base address of variables and functions in the debuggee's data\n\
2122 or code segment is stored in the variable __djgpp_base_address,\n\
2123 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2124 For other segments, look up their base address in the output of\n\
2125 the `info dos ldt' command."),
2139 tcsetpgrp (int fd
, pid_t pgid
)
2141 if (isatty (fd
) && pgid
== SOME_PID
)
2143 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;