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 go32_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
582 struct mem_attrib
*attrib
, struct target_ops
*target
)
586 if (write_child (memaddr
, myaddr
, len
))
597 if (read_child (memaddr
, myaddr
, len
))
608 static cmdline_t child_cmd
; /* Parsed child's command line kept here. */
611 go32_files_info (struct target_ops
*target
)
613 printf_unfiltered ("You are running a DJGPP V2 program.\n");
617 go32_kill_inferior (struct target_ops
*ops
)
619 go32_mourn_inferior (ops
);
623 go32_create_inferior (struct target_ops
*ops
, char *exec_file
,
624 char *args
, char **env
, int from_tty
)
626 extern char **environ
;
629 char **env_save
= environ
;
631 struct inferior
*inf
;
633 /* If no exec file handed to us, get it from the exec-file command -- with
634 a good, common error message if none is specified. */
636 exec_file
= get_exec_file (1);
641 /* Initialize child's cwd as empty to be initialized when starting
645 /* Init command line storage. */
646 if (redir_debug_init (&child_cmd
) == -1)
647 internal_error (__FILE__
, __LINE__
,
648 _("Cannot allocate redirection storage: "
649 "not enough memory.\n"));
651 /* Parse the command line and create redirections. */
652 if (strpbrk (args
, "<>"))
654 if (redir_cmdline_parse (args
, &child_cmd
) == 0)
655 args
= child_cmd
.command
;
657 error (_("Syntax error in command line."));
660 child_cmd
.command
= xstrdup (args
);
662 cmdlen
= strlen (args
);
663 /* v2loadimage passes command lines via DOS memory, so it cannot
664 possibly handle commands longer than 1MB. */
665 if (cmdlen
> 1024*1024)
666 error (_("Command line too long."));
668 cmdline
= xmalloc (cmdlen
+ 4);
669 strcpy (cmdline
+ 1, args
);
670 /* If the command-line length fits into DOS 126-char limits, use the
671 DOS command tail format; otherwise, tell v2loadimage to pass it
672 through a buffer in conventional memory. */
675 cmdline
[0] = strlen (args
);
676 cmdline
[cmdlen
+ 1] = 13;
679 cmdline
[0] = 0xff; /* Signal v2loadimage it's a long command. */
683 if (v2loadimage (exec_file
, cmdline
, start_state
))
686 printf_unfiltered ("Load failed for image %s\n", exec_file
);
692 edi_init (start_state
);
693 #if __DJGPP_MINOR__ < 3
697 inferior_ptid
= pid_to_ptid (SOME_PID
);
698 inf
= current_inferior ();
699 inferior_appeared (inf
, SOME_PID
);
701 push_target (&go32_ops
);
703 add_thread_silent (inferior_ptid
);
705 clear_proceed_status ();
706 insert_breakpoints ();
707 prog_has_started
= 1;
711 go32_mourn_inferior (struct target_ops
*ops
)
715 redir_cmdline_delete (&child_cmd
);
721 /* We need to make sure all the breakpoint enable bits in the DR7
722 register are reset when the inferior exits. Otherwise, if they
723 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
724 failure to set more watchpoints, and other calamities. It would
725 be nice if GDB itself would take care to remove all breakpoints
726 at all times, but it doesn't, probably under an assumption that
727 the OS cleans up when the debuggee exits. */
728 i386_cleanup_dregs ();
730 ptid
= inferior_ptid
;
731 inferior_ptid
= null_ptid
;
732 delete_thread_silent (ptid
);
733 prog_has_started
= 0;
736 generic_mourn_inferior ();
745 /* Hardware watchpoint support. */
747 #define D_REGS edi.dr
748 #define CONTROL D_REGS[7]
749 #define STATUS D_REGS[6]
751 /* Pass the address ADDR to the inferior in the I'th debug register.
752 Here we just store the address in D_REGS, the watchpoint will be
753 actually set up when go32_wait runs the debuggee. */
755 go32_set_dr (int i
, CORE_ADDR addr
)
758 internal_error (__FILE__
, __LINE__
,
759 _("Invalid register %d in go32_set_dr.\n"), i
);
763 /* Pass the value VAL to the inferior in the DR7 debug control
764 register. Here we just store the address in D_REGS, the watchpoint
765 will be actually set up when go32_wait runs the debuggee. */
767 go32_set_dr7 (unsigned long val
)
772 /* Get the value of the DR6 debug status register from the inferior.
773 Here we just return the value stored in D_REGS, as we've got it
774 from the last go32_wait call. */
781 /* Get the value of the DR7 debug status register from the inferior.
782 Here we just return the value stored in D_REGS, as we've got it
783 from the last go32_wait call. */
791 /* Get the value of the DR debug register I from the inferior. Here
792 we just return the value stored in D_REGS, as we've got it from the
793 last go32_wait call. */
799 internal_error (__FILE__
, __LINE__
,
800 _("Invalid register %d in go32_get_dr.\n"), i
);
804 /* Put the device open on handle FD into either raw or cooked
805 mode, return 1 if it was in raw mode, zero otherwise. */
808 device_mode (int fd
, int raw_p
)
810 int oldmode
, newmode
;
815 __dpmi_int (0x21, ®s
);
816 if (regs
.x
.flags
& 1)
818 newmode
= oldmode
= regs
.x
.dx
;
825 if (oldmode
& 0x80) /* Only for character dev. */
829 regs
.x
.dx
= newmode
& 0xff; /* Force upper byte zero, else it fails. */
830 __dpmi_int (0x21, ®s
);
831 if (regs
.x
.flags
& 1)
834 return (oldmode
& 0x20) == 0x20;
838 static int inf_mode_valid
= 0;
839 static int inf_terminal_mode
;
841 /* This semaphore is needed because, amazingly enough, GDB calls
842 target.to_terminal_ours more than once after the inferior stops.
843 But we need the information from the first call only, since the
844 second call will always see GDB's own cooked terminal. */
845 static int terminal_is_ours
= 1;
848 go32_terminal_init (struct target_ops
*self
)
850 inf_mode_valid
= 0; /* Reinitialize, in case they are restarting child. */
851 terminal_is_ours
= 1;
855 go32_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
857 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
859 ? "default" : inf_terminal_mode
? "raw" : "cooked");
861 #if __DJGPP_MINOR__ > 2
862 if (child_cmd
.redirection
)
866 for (i
= 0; i
< DBG_HANDLES
; i
++)
868 if (child_cmd
.redirection
[i
]->file_name
)
869 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
870 i
, child_cmd
.redirection
[i
]->file_name
);
871 else if (_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) == -1)
873 ("\tFile handle %d appears to be closed by inferior.\n", i
);
874 /* Mask off the raw/cooked bit when comparing device info words. */
875 else if ((_get_dev_info (child_cmd
.redirection
[i
]->inf_handle
) & 0xdf)
876 != (_get_dev_info (i
) & 0xdf))
878 ("\tFile handle %d appears to be redirected by inferior.\n", i
);
885 go32_terminal_inferior (struct target_ops
*self
)
887 /* Redirect standard handles as child wants them. */
889 if (redir_to_child (&child_cmd
) == -1)
891 redir_to_debugger (&child_cmd
);
892 error (_("Cannot redirect standard handles for program: %s."),
893 safe_strerror (errno
));
895 /* Set the console device of the inferior to whatever mode
896 (raw or cooked) we found it last time. */
897 if (terminal_is_ours
)
900 device_mode (0, inf_terminal_mode
);
901 terminal_is_ours
= 0;
906 go32_terminal_ours (struct target_ops
*self
)
908 /* Switch to cooked mode on the gdb terminal and save the inferior
909 terminal mode to be restored when it is resumed. */
910 if (!terminal_is_ours
)
912 inf_terminal_mode
= device_mode (0, 0);
913 if (inf_terminal_mode
!= -1)
916 /* If device_mode returned -1, we don't know what happens with
917 handle 0 anymore, so make the info invalid. */
919 terminal_is_ours
= 1;
921 /* Restore debugger's standard handles. */
923 if (redir_to_debugger (&child_cmd
) == -1)
925 redir_to_child (&child_cmd
);
926 error (_("Cannot redirect standard handles for debugger: %s."),
927 safe_strerror (errno
));
933 go32_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
935 return !ptid_equal (inferior_ptid
, null_ptid
);
939 go32_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
941 return normal_pid_to_str (ptid
);
947 go32_ops
.to_shortname
= "djgpp";
948 go32_ops
.to_longname
= "djgpp target process";
950 "Program loaded by djgpp, when gdb is used as an external debugger";
951 go32_ops
.to_open
= go32_open
;
952 go32_ops
.to_close
= go32_close
;
953 go32_ops
.to_attach
= go32_attach
;
954 go32_ops
.to_detach
= go32_detach
;
955 go32_ops
.to_resume
= go32_resume
;
956 go32_ops
.to_wait
= go32_wait
;
957 go32_ops
.to_fetch_registers
= go32_fetch_registers
;
958 go32_ops
.to_store_registers
= go32_store_registers
;
959 go32_ops
.to_prepare_to_store
= go32_prepare_to_store
;
960 go32_ops
.deprecated_xfer_memory
= go32_xfer_memory
;
961 go32_ops
.to_files_info
= go32_files_info
;
962 go32_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
963 go32_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
964 go32_ops
.to_terminal_init
= go32_terminal_init
;
965 go32_ops
.to_terminal_inferior
= go32_terminal_inferior
;
966 go32_ops
.to_terminal_ours_for_output
= go32_terminal_ours
;
967 go32_ops
.to_terminal_ours
= go32_terminal_ours
;
968 go32_ops
.to_terminal_info
= go32_terminal_info
;
969 go32_ops
.to_kill
= go32_kill_inferior
;
970 go32_ops
.to_create_inferior
= go32_create_inferior
;
971 go32_ops
.to_mourn_inferior
= go32_mourn_inferior
;
972 go32_ops
.to_can_run
= go32_can_run
;
973 go32_ops
.to_thread_alive
= go32_thread_alive
;
974 go32_ops
.to_pid_to_str
= go32_pid_to_str
;
975 go32_ops
.to_stratum
= process_stratum
;
976 go32_ops
.to_has_all_memory
= default_child_has_all_memory
;
977 go32_ops
.to_has_memory
= default_child_has_memory
;
978 go32_ops
.to_has_stack
= default_child_has_stack
;
979 go32_ops
.to_has_registers
= default_child_has_registers
;
980 go32_ops
.to_has_execution
= default_child_has_execution
;
982 i386_use_watchpoints (&go32_ops
);
985 i386_dr_low
.set_control
= go32_set_dr7
;
986 i386_dr_low
.set_addr
= go32_set_dr
;
987 i386_dr_low
.get_status
= go32_get_dr6
;
988 i386_dr_low
.get_control
= go32_get_dr7
;
989 i386_dr_low
.get_addr
= go32_get_dr
;
990 i386_set_debug_register_length (4);
992 go32_ops
.to_magic
= OPS_MAGIC
;
994 /* Initialize child's cwd as empty to be initialized when starting
998 /* Initialize child's command line storage. */
999 if (redir_debug_init (&child_cmd
) == -1)
1000 internal_error (__FILE__
, __LINE__
,
1001 _("Cannot allocate redirection storage: "
1002 "not enough memory.\n"));
1004 /* We are always processing GCC-compiled programs. */
1005 processing_gcc_compilation
= 2;
1008 /* Return the current DOS codepage number. */
1015 __dpmi_int (0x21, ®s
);
1016 if (!(regs
.x
.flags
& 1))
1017 return regs
.x
.bx
& 0xffff;
1019 return 437; /* default */
1022 /* Limited emulation of `nl_langinfo', for charset.c. */
1024 nl_langinfo (nl_item item
)
1032 /* 8 is enough for SHORT_MAX + "CP" + null. */
1034 int blen
= sizeof (buf
);
1035 int needed
= snprintf (buf
, blen
, "CP%d", dos_codepage ());
1037 if (needed
> blen
) /* Should never happen. */
1039 retval
= xstrdup (buf
);
1043 retval
= xstrdup ("");
1049 unsigned short windows_major
, windows_minor
;
1051 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
1053 go32_get_windows_version(void)
1058 __dpmi_int(0x2f, &r
);
1059 if (r
.h
.al
> 2 && r
.h
.al
!= 0x80 && r
.h
.al
!= 0xff
1060 && (r
.h
.al
> 3 || r
.h
.ah
> 0))
1062 windows_major
= r
.h
.al
;
1063 windows_minor
= r
.h
.ah
;
1066 windows_major
= 0xff; /* meaning no Windows */
1069 /* A subroutine of go32_sysinfo to display memory info. */
1071 print_mem (unsigned long datum
, const char *header
, int in_pages_p
)
1073 if (datum
!= 0xffffffffUL
)
1077 puts_filtered (header
);
1080 printf_filtered ("%lu KB", datum
>> 10);
1081 if (datum
> 1024 * 1024)
1082 printf_filtered (" (%lu MB)", datum
>> 20);
1085 printf_filtered ("%lu Bytes", datum
);
1086 puts_filtered ("\n");
1090 /* Display assorted information about the underlying OS. */
1092 go32_sysinfo (char *arg
, int from_tty
)
1094 static const char test_pattern
[] =
1095 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1096 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
1097 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
1099 char cpuid_vendor
[13];
1100 unsigned cpuid_max
= 0, cpuid_eax
, cpuid_ebx
, cpuid_ecx
, cpuid_edx
;
1101 unsigned true_dos_version
= _get_dos_version (1);
1102 unsigned advertized_dos_version
= ((unsigned int)_osmajor
<< 8) | _osminor
;
1104 char dpmi_vendor_info
[129];
1105 int dpmi_vendor_available
;
1106 __dpmi_version_ret dpmi_version_data
;
1108 __dpmi_free_mem_info mem_info
;
1111 cpuid_vendor
[0] = '\0';
1113 strcpy (u
.machine
, "Unknown x86");
1114 else if (u
.machine
[0] == 'i' && u
.machine
[1] > 4)
1116 /* CPUID with EAX = 0 returns the Vendor ID. */
1118 /* Ideally we would use i386_cpuid(), but it needs someone to run
1119 native tests first to make sure things actually work. They should.
1120 http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html */
1121 unsigned int eax
, ebx
, ecx
, edx
;
1123 if (i386_cpuid (0, &eax
, &ebx
, &ecx
, &edx
))
1126 memcpy (&vendor
[0], &ebx
, 4);
1127 memcpy (&vendor
[4], &ecx
, 4);
1128 memcpy (&vendor
[8], &edx
, 4);
1129 cpuid_vendor
[12] = '\0';
1132 __asm__
__volatile__ ("xorl %%ebx, %%ebx;"
1133 "xorl %%ecx, %%ecx;"
1134 "xorl %%edx, %%edx;"
1141 : "=m" (cpuid_vendor
[0]),
1142 "=m" (cpuid_vendor
[4]),
1143 "=m" (cpuid_vendor
[8]),
1146 : "%eax", "%ebx", "%ecx", "%edx");
1147 cpuid_vendor
[12] = '\0';
1151 printf_filtered ("CPU Type.......................%s", u
.machine
);
1152 if (cpuid_vendor
[0])
1153 printf_filtered (" (%s)", cpuid_vendor
);
1154 puts_filtered ("\n");
1156 /* CPUID with EAX = 1 returns processor signature and features. */
1159 static char *brand_name
[] = {
1167 char cpu_string
[80];
1170 int intel_p
= strcmp (cpuid_vendor
, "GenuineIntel") == 0;
1171 int amd_p
= strcmp (cpuid_vendor
, "AuthenticAMD") == 0;
1172 unsigned cpu_family
, cpu_model
;
1175 /* See comment above about cpuid usage. */
1176 i386_cpuid (1, &cpuid_eax
, &cpuid_ebx
, NULL
, &cpuid_edx
);
1178 __asm__
__volatile__ ("movl $1, %%eax;"
1186 brand_idx
= cpuid_ebx
& 0xff;
1187 cpu_family
= (cpuid_eax
>> 8) & 0xf;
1188 cpu_model
= (cpuid_eax
>> 4) & 0xf;
1189 cpu_brand
[0] = '\0';
1193 && brand_idx
< sizeof(brand_name
)/sizeof(brand_name
[0])
1194 && *brand_name
[brand_idx
])
1195 strcpy (cpu_brand
, brand_name
[brand_idx
]);
1196 else if (cpu_family
== 5)
1198 if (((cpuid_eax
>> 12) & 3) == 0 && cpu_model
== 4)
1199 strcpy (cpu_brand
, " MMX");
1200 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 1)
1201 strcpy (cpu_brand
, " OverDrive");
1202 else if (cpu_model
> 1 && ((cpuid_eax
>> 12) & 3) == 2)
1203 strcpy (cpu_brand
, " Dual");
1205 else if (cpu_family
== 6 && cpu_model
< 8)
1210 strcpy (cpu_brand
, " Pro");
1213 strcpy (cpu_brand
, " II");
1216 strcpy (cpu_brand
, " II Xeon");
1219 strcpy (cpu_brand
, " Celeron");
1222 strcpy (cpu_brand
, " III");
1232 strcpy (cpu_brand
, "486/5x86");
1241 strcpy (cpu_brand
, "-K5");
1245 strcpy (cpu_brand
, "-K6");
1248 strcpy (cpu_brand
, "-K6-2");
1251 strcpy (cpu_brand
, "-K6-III");
1261 strcpy (cpu_brand
, " Athlon");
1264 strcpy (cpu_brand
, " Duron");
1270 xsnprintf (cpu_string
, sizeof (cpu_string
), "%s%s Model %d Stepping %d",
1271 intel_p
? "Pentium" : (amd_p
? "AMD" : "ix86"),
1272 cpu_brand
, cpu_model
, cpuid_eax
& 0xf);
1273 printfi_filtered (31, "%s\n", cpu_string
);
1274 if (((cpuid_edx
& (6 | (0x0d << 23))) != 0)
1275 || ((cpuid_edx
& 1) == 0)
1276 || (amd_p
&& (cpuid_edx
& (3 << 30)) != 0))
1278 puts_filtered ("CPU Features...................");
1279 /* We only list features which might be useful in the DPMI
1281 if ((cpuid_edx
& 1) == 0)
1282 puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
1283 if ((cpuid_edx
& (1 << 1)) != 0)
1284 puts_filtered ("VME ");
1285 if ((cpuid_edx
& (1 << 2)) != 0)
1286 puts_filtered ("DE ");
1287 if ((cpuid_edx
& (1 << 4)) != 0)
1288 puts_filtered ("TSC ");
1289 if ((cpuid_edx
& (1 << 23)) != 0)
1290 puts_filtered ("MMX ");
1291 if ((cpuid_edx
& (1 << 25)) != 0)
1292 puts_filtered ("SSE ");
1293 if ((cpuid_edx
& (1 << 26)) != 0)
1294 puts_filtered ("SSE2 ");
1297 if ((cpuid_edx
& (1 << 31)) != 0)
1298 puts_filtered ("3DNow! ");
1299 if ((cpuid_edx
& (1 << 30)) != 0)
1300 puts_filtered ("3DNow!Ext");
1302 puts_filtered ("\n");
1305 puts_filtered ("\n");
1306 printf_filtered ("DOS Version....................%s %s.%s",
1307 _os_flavor
, u
.release
, u
.version
);
1308 if (true_dos_version
!= advertized_dos_version
)
1309 printf_filtered (" (disguised as v%d.%d)", _osmajor
, _osminor
);
1310 puts_filtered ("\n");
1312 go32_get_windows_version ();
1313 if (windows_major
!= 0xff)
1315 const char *windows_flavor
;
1317 printf_filtered ("Windows Version................%d.%02d (Windows ",
1318 windows_major
, windows_minor
);
1319 switch (windows_major
)
1322 windows_flavor
= "3.X";
1325 switch (windows_minor
)
1328 windows_flavor
= "95, 95A, or 95B";
1331 windows_flavor
= "95B OSR2.1 or 95C OSR2.5";
1334 windows_flavor
= "98 or 98 SE";
1337 windows_flavor
= "ME";
1340 windows_flavor
= "9X";
1345 windows_flavor
= "??";
1348 printf_filtered ("%s)\n", windows_flavor
);
1350 else if (true_dos_version
== 0x532 && advertized_dos_version
== 0x500)
1351 printf_filtered ("Windows Version................"
1352 "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
1353 puts_filtered ("\n");
1354 /* On some versions of Windows, __dpmi_get_capabilities returns
1355 zero, but the buffer is not filled with info, so we fill the
1356 buffer with a known pattern and test for it afterwards. */
1357 memcpy (dpmi_vendor_info
, test_pattern
, sizeof(dpmi_vendor_info
));
1358 dpmi_vendor_available
=
1359 __dpmi_get_capabilities (&dpmi_flags
, dpmi_vendor_info
);
1360 if (dpmi_vendor_available
== 0
1361 && memcmp (dpmi_vendor_info
, test_pattern
,
1362 sizeof(dpmi_vendor_info
)) != 0)
1364 /* The DPMI spec says the vendor string should be ASCIIZ, but
1365 I don't trust the vendors to follow that... */
1366 if (!memchr (&dpmi_vendor_info
[2], 0, 126))
1367 dpmi_vendor_info
[128] = '\0';
1368 printf_filtered ("DPMI Host......................"
1369 "%s v%d.%d (capabilities: %#x)\n",
1370 &dpmi_vendor_info
[2],
1371 (unsigned)dpmi_vendor_info
[0],
1372 (unsigned)dpmi_vendor_info
[1],
1373 ((unsigned)dpmi_flags
& 0x7f));
1376 printf_filtered ("DPMI Host......................(Info not available)\n");
1377 __dpmi_get_version (&dpmi_version_data
);
1378 printf_filtered ("DPMI Version...................%d.%02d\n",
1379 dpmi_version_data
.major
, dpmi_version_data
.minor
);
1380 printf_filtered ("DPMI Info......................"
1381 "%s-bit DPMI, with%s Virtual Memory support\n",
1382 (dpmi_version_data
.flags
& 1) ? "32" : "16",
1383 (dpmi_version_data
.flags
& 4) ? "" : "out");
1384 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1385 (dpmi_version_data
.flags
& 2) ? "V86" : "Real");
1386 printfi_filtered (31, "Processor type: i%d86\n",
1387 dpmi_version_data
.cpu
);
1388 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1389 dpmi_version_data
.master_pic
, dpmi_version_data
.slave_pic
);
1391 /* a_tss is only initialized when the debuggee is first run. */
1392 if (prog_has_started
)
1394 __asm__
__volatile__ ("pushfl ; popl %0" : "=g" (eflags
));
1395 printf_filtered ("Protection....................."
1396 "Ring %d (in %s), with%s I/O protection\n",
1397 a_tss
.tss_cs
& 3, (a_tss
.tss_cs
& 4) ? "LDT" : "GDT",
1398 (a_tss
.tss_cs
& 3) > ((eflags
>> 12) & 3) ? "" : "out");
1400 puts_filtered ("\n");
1401 __dpmi_get_free_memory_information (&mem_info
);
1402 print_mem (mem_info
.total_number_of_physical_pages
,
1403 "DPMI Total Physical Memory.....", 1);
1404 print_mem (mem_info
.total_number_of_free_pages
,
1405 "DPMI Free Physical Memory......", 1);
1406 print_mem (mem_info
.size_of_paging_file_partition_in_pages
,
1407 "DPMI Swap Space................", 1);
1408 print_mem (mem_info
.linear_address_space_size_in_pages
,
1409 "DPMI Total Linear Address Size.", 1);
1410 print_mem (mem_info
.free_linear_address_space_in_pages
,
1411 "DPMI Free Linear Address Size..", 1);
1412 print_mem (mem_info
.largest_available_free_block_in_bytes
,
1413 "DPMI Largest Free Memory Block.", 0);
1417 __dpmi_int (0x21, ®s
);
1418 print_mem (regs
.x
.bx
<< 4, "Free DOS Memory................", 0);
1420 __dpmi_int (0x21, ®s
);
1421 if ((regs
.x
.flags
& 1) == 0)
1423 static const char *dos_hilo
[] = {
1424 "Low", "", "", "", "High", "", "", "", "High, then Low"
1426 static const char *dos_fit
[] = {
1427 "First", "Best", "Last"
1429 int hilo_idx
= (regs
.x
.ax
>> 4) & 0x0f;
1430 int fit_idx
= regs
.x
.ax
& 0x0f;
1436 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1437 dos_hilo
[hilo_idx
], dos_fit
[fit_idx
]);
1439 __dpmi_int (0x21, ®s
);
1440 if ((regs
.x
.flags
& 1) != 0)
1442 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1443 regs
.h
.al
== 0 ? "not " : "");
1448 unsigned short limit0
;
1449 unsigned short base0
;
1450 unsigned char base1
;
1455 unsigned available
:1;
1458 unsigned page_granular
:1;
1459 unsigned char base2
;
1460 } __attribute__ ((packed
));
1463 unsigned short offset0
;
1464 unsigned short selector
;
1465 unsigned param_count
:5;
1470 unsigned short offset1
;
1471 } __attribute__ ((packed
));
1473 /* Read LEN bytes starting at logical address ADDR, and put the result
1474 into DEST. Return 1 if success, zero if not. */
1476 read_memory_region (unsigned long addr
, void *dest
, size_t len
)
1478 unsigned long dos_ds_limit
= __dpmi_get_segment_limit (_dos_ds
);
1481 /* For the low memory, we can simply use _dos_ds. */
1482 if (addr
<= dos_ds_limit
- len
)
1483 dosmemget (addr
, len
, dest
);
1486 /* For memory above 1MB we need to set up a special segment to
1487 be able to access that memory. */
1488 int sel
= __dpmi_allocate_ldt_descriptors (1);
1494 int access_rights
= __dpmi_get_descriptor_access_rights (sel
);
1495 size_t segment_limit
= len
- 1;
1497 /* Make sure the crucial bits in the descriptor access
1498 rights are set correctly. Some DPMI providers might barf
1499 if we set the segment limit to something that is not an
1500 integral multiple of 4KB pages if the granularity bit is
1501 not set to byte-granular, even though the DPMI spec says
1502 it's the host's responsibility to set that bit correctly. */
1503 if (len
> 1024 * 1024)
1505 access_rights
|= 0x8000;
1506 /* Page-granular segments should have the low 12 bits of
1508 segment_limit
|= 0xfff;
1511 access_rights
&= ~0x8000;
1513 if (__dpmi_set_segment_base_address (sel
, addr
) != -1
1514 && __dpmi_set_descriptor_access_rights (sel
, access_rights
) != -1
1515 && __dpmi_set_segment_limit (sel
, segment_limit
) != -1
1516 /* W2K silently fails to set the segment limit, leaving
1517 it at zero; this test avoids the resulting crash. */
1518 && __dpmi_get_segment_limit (sel
) >= segment_limit
)
1519 movedata (sel
, 0, _my_ds (), (unsigned)dest
, len
);
1523 __dpmi_free_ldt_descriptor (sel
);
1529 /* Get a segment descriptor stored at index IDX in the descriptor
1530 table whose base address is TABLE_BASE. Return the descriptor
1531 type, or -1 if failure. */
1533 get_descriptor (unsigned long table_base
, int idx
, void *descr
)
1535 unsigned long addr
= table_base
+ idx
* 8; /* 8 bytes per entry */
1537 if (read_memory_region (addr
, descr
, 8))
1538 return (int)((struct seg_descr
*)descr
)->stype
;
1543 unsigned short limit
__attribute__((packed
));
1544 unsigned long base
__attribute__((packed
));
1547 /* Display a segment descriptor stored at index IDX in a descriptor
1548 table whose type is TYPE and whose base address is BASE_ADDR. If
1549 FORCE is non-zero, display even invalid descriptors. */
1551 display_descriptor (unsigned type
, unsigned long base_addr
, int idx
, int force
)
1553 struct seg_descr descr
;
1554 struct gate_descr gate
;
1556 /* Get the descriptor from the table. */
1557 if (idx
== 0 && type
== 0)
1558 puts_filtered ("0x000: null descriptor\n");
1559 else if (get_descriptor (base_addr
, idx
, &descr
) != -1)
1561 /* For each type of descriptor table, this has a bit set if the
1562 corresponding type of selectors is valid in that table. */
1563 static unsigned allowed_descriptors
[] = {
1564 0xffffdafeL
, /* GDT */
1565 0x0000c0e0L
, /* IDT */
1566 0xffffdafaL
/* LDT */
1569 /* If the program hasn't started yet, assume the debuggee will
1570 have the same CPL as the debugger. */
1571 int cpl
= prog_has_started
? (a_tss
.tss_cs
& 3) : _my_cs () & 3;
1572 unsigned long limit
= (descr
.limit1
<< 16) | descr
.limit0
;
1575 && (allowed_descriptors
[type
] & (1 << descr
.stype
)) != 0)
1577 printf_filtered ("0x%03x: ",
1579 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1580 if (descr
.page_granular
)
1581 limit
= (limit
<< 12) | 0xfff; /* big segment: low 12 bit set */
1582 if (descr
.stype
== 1 || descr
.stype
== 2 || descr
.stype
== 3
1583 || descr
.stype
== 9 || descr
.stype
== 11
1584 || (descr
.stype
>= 16 && descr
.stype
< 32))
1585 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1586 descr
.base2
, descr
.base1
, descr
.base0
, limit
);
1588 switch (descr
.stype
)
1592 printf_filtered (" 16-bit TSS (task %sactive)",
1593 descr
.stype
== 3 ? "" : "in");
1596 puts_filtered (" LDT");
1599 memcpy (&gate
, &descr
, sizeof gate
);
1600 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1601 gate
.selector
, gate
.offset1
, gate
.offset0
);
1602 printf_filtered (" 16-bit Call Gate (params=%d)",
1606 printf_filtered ("TSS selector=0x%04x", descr
.base0
);
1607 printfi_filtered (16, "Task Gate");
1611 memcpy (&gate
, &descr
, sizeof gate
);
1612 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1613 gate
.selector
, gate
.offset1
, gate
.offset0
);
1614 printf_filtered (" 16-bit %s Gate",
1615 descr
.stype
== 6 ? "Interrupt" : "Trap");
1619 printf_filtered (" 32-bit TSS (task %sactive)",
1620 descr
.stype
== 3 ? "" : "in");
1623 memcpy (&gate
, &descr
, sizeof gate
);
1624 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1625 gate
.selector
, gate
.offset1
, gate
.offset0
);
1626 printf_filtered (" 32-bit Call Gate (params=%d)",
1631 memcpy (&gate
, &descr
, sizeof gate
);
1632 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1633 gate
.selector
, gate
.offset1
, gate
.offset0
);
1634 printf_filtered (" 32-bit %s Gate",
1635 descr
.stype
== 14 ? "Interrupt" : "Trap");
1637 case 16: /* data segments */
1645 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1646 descr
.bit32
? "32" : "16",
1648 ? "Read/Write," : "Read-Only, ",
1649 descr
.stype
& 4 ? "down" : "up",
1650 descr
.stype
& 1 ? "" : ", N.Acc");
1652 case 24: /* code segments */
1660 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1661 descr
.bit32
? "32" : "16",
1662 descr
.stype
& 2 ? "Exec/Read" : "Exec-Only",
1663 descr
.stype
& 4 ? "" : "N.",
1664 descr
.stype
& 1 ? "" : ", N.Acc");
1667 printf_filtered ("Unknown type 0x%02x", descr
.stype
);
1670 puts_filtered ("\n");
1674 printf_filtered ("0x%03x: ",
1676 ? idx
: (idx
* 8) | (type
? (cpl
| 4) : 0));
1678 puts_filtered ("Segment not present\n");
1680 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1685 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx
);
1689 go32_sldt (char *arg
, int from_tty
)
1691 struct dtr_reg gdtr
;
1692 unsigned short ldtr
= 0;
1694 struct seg_descr ldt_descr
;
1695 long ldt_entry
= -1L;
1696 int cpl
= (prog_has_started
? a_tss
.tss_cs
: _my_cs ()) & 3;
1700 arg
= skip_spaces (arg
);
1704 ldt_entry
= parse_and_eval_long (arg
);
1706 || (ldt_entry
& 4) == 0
1707 || (ldt_entry
& 3) != (cpl
& 3))
1708 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry
);
1712 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1713 __asm__
__volatile__ ("sldt %0" : "=m" (ldtr
) : /* no inputs */ );
1716 puts_filtered ("There is no LDT.\n");
1717 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1718 else if (get_descriptor (gdtr
.base
, ldt_idx
, &ldt_descr
) != 2)
1719 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1721 | (ldt_descr
.base1
<< 16)
1722 | (ldt_descr
.base2
<< 24));
1727 | (ldt_descr
.base1
<< 16)
1728 | (ldt_descr
.base2
<< 24);
1729 unsigned limit
= ldt_descr
.limit0
| (ldt_descr
.limit1
<< 16);
1732 if (ldt_descr
.page_granular
)
1733 /* Page-granular segments must have the low 12 bits of their
1735 limit
= (limit
<< 12) | 0xfff;
1736 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1741 max_entry
= (limit
+ 1) / 8;
1745 if (ldt_entry
> limit
)
1746 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
1747 (unsigned long)ldt_entry
, limit
);
1749 display_descriptor (ldt_descr
.stype
, base
, ldt_entry
/ 8, 1);
1755 for (i
= 0; i
< max_entry
; i
++)
1756 display_descriptor (ldt_descr
.stype
, base
, i
, 0);
1762 go32_sgdt (char *arg
, int from_tty
)
1764 struct dtr_reg gdtr
;
1765 long gdt_entry
= -1L;
1770 arg
= skip_spaces (arg
);
1774 gdt_entry
= parse_and_eval_long (arg
);
1775 if (gdt_entry
< 0 || (gdt_entry
& 7) != 0)
1776 error (_("Invalid GDT entry 0x%03lx: "
1777 "not an integral multiple of 8."),
1778 (unsigned long)gdt_entry
);
1782 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1783 max_entry
= (gdtr
.limit
+ 1) / 8;
1787 if (gdt_entry
> gdtr
.limit
)
1788 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
1789 (unsigned long)gdt_entry
, gdtr
.limit
);
1791 display_descriptor (0, gdtr
.base
, gdt_entry
/ 8, 1);
1797 for (i
= 0; i
< max_entry
; i
++)
1798 display_descriptor (0, gdtr
.base
, i
, 0);
1803 go32_sidt (char *arg
, int from_tty
)
1805 struct dtr_reg idtr
;
1806 long idt_entry
= -1L;
1811 arg
= skip_spaces (arg
);
1815 idt_entry
= parse_and_eval_long (arg
);
1817 error (_("Invalid (negative) IDT entry %ld."), idt_entry
);
1821 __asm__
__volatile__ ("sidt %0" : "=m" (idtr
) : /* no inputs */ );
1822 max_entry
= (idtr
.limit
+ 1) / 8;
1823 if (max_entry
> 0x100) /* No more than 256 entries. */
1828 if (idt_entry
> idtr
.limit
)
1829 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
1830 (unsigned long)idt_entry
, idtr
.limit
);
1832 display_descriptor (1, idtr
.base
, idt_entry
, 1);
1838 for (i
= 0; i
< max_entry
; i
++)
1839 display_descriptor (1, idtr
.base
, i
, 0);
1843 /* Cached linear address of the base of the page directory. For
1844 now, available only under CWSDPMI. Code based on ideas and
1845 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1846 static unsigned long pdbr
;
1848 static unsigned long
1853 unsigned long taskbase
, cr3
;
1854 struct dtr_reg gdtr
;
1856 if (pdbr
> 0 && pdbr
<= 0xfffff)
1859 /* Get the linear address of GDT and the Task Register. */
1860 __asm__
__volatile__ ("sgdt %0" : "=m" (gdtr
) : /* no inputs */ );
1861 __asm__
__volatile__ ("str %0" : "=m" (taskreg
) : /* no inputs */ );
1863 /* Task Register is a segment selector for the TSS of the current
1864 task. Therefore, it can be used as an index into the GDT to get
1865 at the segment descriptor for the TSS. To get the index, reset
1866 the low 3 bits of the selector (which give the CPL). Add 2 to the
1867 offset to point to the 3 low bytes of the base address. */
1868 offset
= gdtr
.base
+ (taskreg
& 0xfff8) + 2;
1871 /* CWSDPMI's task base is always under the 1MB mark. */
1872 if (offset
> 0xfffff)
1875 _farsetsel (_dos_ds
);
1876 taskbase
= _farnspeekl (offset
) & 0xffffffU
;
1877 taskbase
+= _farnspeekl (offset
+ 2) & 0xff000000U
;
1878 if (taskbase
> 0xfffff)
1881 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1882 offset 1Ch in the TSS. */
1883 cr3
= _farnspeekl (taskbase
+ 0x1c) & ~0xfff;
1886 #if 0 /* Not fullly supported yet. */
1887 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1888 the first Page Table right below the Page Directory. Thus,
1889 the first Page Table's entry for its own address and the Page
1890 Directory entry for that Page Table will hold the same
1891 physical address. The loop below searches the entire UMB
1892 range of addresses for such an occurence. */
1893 unsigned long addr
, pte_idx
;
1895 for (addr
= 0xb0000, pte_idx
= 0xb0;
1897 addr
+= 0x1000, pte_idx
++)
1899 if (((_farnspeekl (addr
+ 4 * pte_idx
) & 0xfffff027) ==
1900 (_farnspeekl (addr
+ 0x1000) & 0xfffff027))
1901 && ((_farnspeekl (addr
+ 4 * pte_idx
+ 4) & 0xfffff000) == cr3
))
1903 cr3
= addr
+ 0x1000;
1916 /* Return the N'th Page Directory entry. */
1917 static unsigned long
1920 unsigned long pde
= 0;
1922 if (pdbr
&& n
>= 0 && n
< 1024)
1924 pde
= _farpeekl (_dos_ds
, pdbr
+ 4*n
);
1929 /* Return the N'th entry of the Page Table whose Page Directory entry
1931 static unsigned long
1932 get_pte (unsigned long pde
, int n
)
1934 unsigned long pte
= 0;
1936 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1937 page tables, for now. */
1938 if ((pde
& 1) && !(pde
& 0x80) && n
>= 0 && n
< 1024)
1940 pde
&= ~0xfff; /* Clear non-address bits. */
1941 pte
= _farpeekl (_dos_ds
, pde
+ 4*n
);
1946 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1947 says this is a Page Directory entry. If FORCE is non-zero, display
1948 the entry even if its Present flag is off. OFF is the offset of the
1949 address from the page's base address. */
1951 display_ptable_entry (unsigned long entry
, int is_dir
, int force
, unsigned off
)
1953 if ((entry
& 1) != 0)
1955 printf_filtered ("Base=0x%05lx000", entry
>> 12);
1956 if ((entry
& 0x100) && !is_dir
)
1957 puts_filtered (" Global");
1958 if ((entry
& 0x40) && !is_dir
)
1959 puts_filtered (" Dirty");
1960 printf_filtered (" %sAcc.", (entry
& 0x20) ? "" : "Not-");
1961 printf_filtered (" %sCached", (entry
& 0x10) ? "" : "Not-");
1962 printf_filtered (" Write-%s", (entry
& 8) ? "Thru" : "Back");
1963 printf_filtered (" %s", (entry
& 4) ? "Usr" : "Sup");
1964 printf_filtered (" Read-%s", (entry
& 2) ? "Write" : "Only");
1966 printf_filtered (" +0x%x", off
);
1967 puts_filtered ("\n");
1970 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1971 is_dir
? " Table" : "", entry
>> 1);
1975 go32_pde (char *arg
, int from_tty
)
1977 long pde_idx
= -1, i
;
1981 arg
= skip_spaces (arg
);
1985 pde_idx
= parse_and_eval_long (arg
);
1986 if (pde_idx
< 0 || pde_idx
>= 1024)
1987 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
1993 puts_filtered ("Access to Page Directories is "
1994 "not supported on this system.\n");
1995 else if (pde_idx
>= 0)
1996 display_ptable_entry (get_pde (pde_idx
), 1, 1, 0);
1998 for (i
= 0; i
< 1024; i
++)
1999 display_ptable_entry (get_pde (i
), 1, 0, 0);
2002 /* A helper function to display entries in a Page Table pointed to by
2003 the N'th entry in the Page Directory. If FORCE is non-zero, say
2004 something even if the Page Table is not accessible. */
2006 display_page_table (long n
, int force
)
2008 unsigned long pde
= get_pde (n
);
2014 printf_filtered ("Page Table pointed to by "
2015 "Page Directory entry 0x%lx:\n", n
);
2016 for (i
= 0; i
< 1024; i
++)
2017 display_ptable_entry (get_pte (pde
, i
), 0, 0, 0);
2018 puts_filtered ("\n");
2021 printf_filtered ("Page Table not present; value=0x%lx.\n", pde
>> 1);
2025 go32_pte (char *arg
, int from_tty
)
2027 long pde_idx
= -1L, i
;
2031 arg
= skip_spaces (arg
);
2035 pde_idx
= parse_and_eval_long (arg
);
2036 if (pde_idx
< 0 || pde_idx
>= 1024)
2037 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx
);
2043 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2044 else if (pde_idx
>= 0)
2045 display_page_table (pde_idx
, 1);
2047 for (i
= 0; i
< 1024; i
++)
2048 display_page_table (i
, 0);
2052 go32_pte_for_address (char *arg
, int from_tty
)
2054 CORE_ADDR addr
= 0, i
;
2058 arg
= skip_spaces (arg
);
2061 addr
= parse_and_eval_address (arg
);
2064 error_no_arg (_("linear address"));
2068 puts_filtered ("Access to Page Tables is not supported on this system.\n");
2071 int pde_idx
= (addr
>> 22) & 0x3ff;
2072 int pte_idx
= (addr
>> 12) & 0x3ff;
2073 unsigned offs
= addr
& 0xfff;
2075 printf_filtered ("Page Table entry for address %s:\n",
2077 display_ptable_entry (get_pte (get_pde (pde_idx
), pte_idx
), 0, 1, offs
);
2081 static struct cmd_list_element
*info_dos_cmdlist
= NULL
;
2084 go32_info_dos_command (char *args
, int from_tty
)
2086 help_list (info_dos_cmdlist
, "info dos ", class_info
, gdb_stdout
);
2089 /* -Wmissing-prototypes */
2090 extern initialize_file_ftype _initialize_go32_nat
;
2093 _initialize_go32_nat (void)
2096 add_target (&go32_ops
);
2098 add_prefix_cmd ("dos", class_info
, go32_info_dos_command
, _("\
2099 Print information specific to DJGPP (aka MS-DOS) debugging."),
2100 &info_dos_cmdlist
, "info dos ", 0, &infolist
);
2102 add_cmd ("sysinfo", class_info
, go32_sysinfo
, _("\
2103 Display information about the target system, including CPU, OS, DPMI, etc."),
2105 add_cmd ("ldt", class_info
, go32_sldt
, _("\
2106 Display entries in the LDT (Local Descriptor Table).\n\
2107 Entry number (an expression) as an argument means display only that entry."),
2109 add_cmd ("gdt", class_info
, go32_sgdt
, _("\
2110 Display entries in the GDT (Global Descriptor Table).\n\
2111 Entry number (an expression) as an argument means display only that entry."),
2113 add_cmd ("idt", class_info
, go32_sidt
, _("\
2114 Display entries in the IDT (Interrupt Descriptor Table).\n\
2115 Entry number (an expression) as an argument means display only that entry."),
2117 add_cmd ("pde", class_info
, go32_pde
, _("\
2118 Display entries in the Page Directory.\n\
2119 Entry number (an expression) as an argument means display only that entry."),
2121 add_cmd ("pte", class_info
, go32_pte
, _("\
2122 Display entries in Page Tables.\n\
2123 Entry number (an expression) as an argument means display only entries\n\
2124 from the Page Table pointed to by the specified Page Directory entry."),
2126 add_cmd ("address-pte", class_info
, go32_pte_for_address
, _("\
2127 Display a Page Table entry for a linear address.\n\
2128 The address argument must be a linear address, after adding to\n\
2129 it the base address of the appropriate segment.\n\
2130 The base address of variables and functions in the debuggee's data\n\
2131 or code segment is stored in the variable __djgpp_base_address,\n\
2132 so use `__djgpp_base_address + (char *)&var' as the argument.\n\
2133 For other segments, look up their base address in the output of\n\
2134 the `info dos ldt' command."),
2148 tcsetpgrp (int fd
, pid_t pgid
)
2150 if (isatty (fd
) && pgid
== SOME_PID
)
2152 errno
= pgid
== SOME_PID
? ENOTTY
: ENOSYS
;