96472b33640e2bd0b23275b3d410fad21baef86e
[deliverable/binutils-gdb.git] / gdb / go32-nat.c
1 /* Native debugging support for Intel x86 running DJGPP.
2 Copyright 1997, 1999, 2000, 2001 Free Software Foundation, Inc.
3 Written by Robert Hoehne.
4
5 This file is part of GDB.
6
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 2 of the License, or
10 (at your option) any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include <fcntl.h>
23
24 #include "defs.h"
25 #include "inferior.h"
26 #include "gdb_wait.h"
27 #include "gdbcore.h"
28 #include "command.h"
29 #include "gdbcmd.h"
30 #include "floatformat.h"
31 #include "buildsym.h"
32 #include "i387-tdep.h"
33 #include "i386-tdep.h"
34 #include "value.h"
35 #include "regcache.h"
36 #include "gdb_string.h"
37
38 #include <stdio.h> /* might be required for __DJGPP_MINOR__ */
39 #include <stdlib.h>
40 #include <ctype.h>
41 #include <errno.h>
42 #include <unistd.h>
43 #include <sys/utsname.h>
44 #include <io.h>
45 #include <dos.h>
46 #include <dpmi.h>
47 #include <go32.h>
48 #include <sys/farptr.h>
49 #include <debug/v2load.h>
50 #include <debug/dbgcom.h>
51 #if __DJGPP_MINOR__ > 2
52 #include <debug/redir.h>
53 #endif
54
55 #if __DJGPP_MINOR__ < 3
56 /* This code will be provided from DJGPP 2.03 on. Until then I code it
57 here */
58 typedef struct
59 {
60 unsigned short sig0;
61 unsigned short sig1;
62 unsigned short sig2;
63 unsigned short sig3;
64 unsigned short exponent:15;
65 unsigned short sign:1;
66 }
67 NPXREG;
68
69 typedef struct
70 {
71 unsigned int control;
72 unsigned int status;
73 unsigned int tag;
74 unsigned int eip;
75 unsigned int cs;
76 unsigned int dataptr;
77 unsigned int datasel;
78 NPXREG reg[8];
79 }
80 NPX;
81
82 static NPX npx;
83
84 static void save_npx (void); /* Save the FPU of the debugged program */
85 static void load_npx (void); /* Restore the FPU of the debugged program */
86
87 /* ------------------------------------------------------------------------- */
88 /* Store the contents of the NPX in the global variable `npx'. */
89 /* *INDENT-OFF* */
90
91 static void
92 save_npx (void)
93 {
94 asm ("inb $0xa0, %%al \n\
95 testb $0x20, %%al \n\
96 jz 1f \n\
97 xorb %%al, %%al \n\
98 outb %%al, $0xf0 \n\
99 movb $0x20, %%al \n\
100 outb %%al, $0xa0 \n\
101 outb %%al, $0x20 \n\
102 1: \n\
103 fnsave %0 \n\
104 fwait "
105 : "=m" (npx)
106 : /* No input */
107 : "%eax");
108 }
109
110 /* *INDENT-ON* */
111
112
113 /* ------------------------------------------------------------------------- */
114 /* Reload the contents of the NPX from the global variable `npx'. */
115
116 static void
117 load_npx (void)
118 {
119 asm ("frstor %0":"=m" (npx));
120 }
121 /* ------------------------------------------------------------------------- */
122 /* Stubs for the missing redirection functions. */
123 typedef struct {
124 char *command;
125 int redirected;
126 } cmdline_t;
127
128 void
129 redir_cmdline_delete (cmdline_t *ptr)
130 {
131 ptr->redirected = 0;
132 }
133
134 int
135 redir_cmdline_parse (const char *args, cmdline_t *ptr)
136 {
137 return -1;
138 }
139
140 int
141 redir_to_child (cmdline_t *ptr)
142 {
143 return 1;
144 }
145
146 int
147 redir_to_debugger (cmdline_t *ptr)
148 {
149 return 1;
150 }
151
152 int
153 redir_debug_init (cmdline_t *ptr)
154 {
155 return 0;
156 }
157 #endif /* __DJGPP_MINOR < 3 */
158
159 typedef enum { wp_insert, wp_remove, wp_count } wp_op;
160
161 /* This holds the current reference counts for each debug register. */
162 static int dr_ref_count[4];
163
164 #define SOME_PID 42
165
166 static int prog_has_started = 0;
167 static void go32_open (char *name, int from_tty);
168 static void go32_close (int quitting);
169 static void go32_attach (char *args, int from_tty);
170 static void go32_detach (char *args, int from_tty);
171 static void go32_resume (ptid_t ptid, int step,
172 enum target_signal siggnal);
173 static ptid_t go32_wait (ptid_t ptid,
174 struct target_waitstatus *status);
175 static void go32_fetch_registers (int regno);
176 static void store_register (int regno);
177 static void go32_store_registers (int regno);
178 static void go32_prepare_to_store (void);
179 static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
180 int write,
181 struct mem_attrib *attrib,
182 struct target_ops *target);
183 static void go32_files_info (struct target_ops *target);
184 static void go32_stop (void);
185 static void go32_kill_inferior (void);
186 static void go32_create_inferior (char *exec_file, char *args, char **env, int from_tty);
187 static void go32_mourn_inferior (void);
188 static int go32_can_run (void);
189
190 static struct target_ops go32_ops;
191 static void go32_terminal_init (void);
192 static void go32_terminal_inferior (void);
193 static void go32_terminal_ours (void);
194
195 #define r_ofs(x) (offsetof(TSS,x))
196
197 static struct
198 {
199 size_t tss_ofs;
200 size_t size;
201 }
202 regno_mapping[] =
203 {
204 {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
205 {r_ofs (tss_ecx), 4},
206 {r_ofs (tss_edx), 4},
207 {r_ofs (tss_ebx), 4},
208 {r_ofs (tss_esp), 4},
209 {r_ofs (tss_ebp), 4},
210 {r_ofs (tss_esi), 4},
211 {r_ofs (tss_edi), 4},
212 {r_ofs (tss_eip), 4},
213 {r_ofs (tss_eflags), 4},
214 {r_ofs (tss_cs), 2},
215 {r_ofs (tss_ss), 2},
216 {r_ofs (tss_ds), 2},
217 {r_ofs (tss_es), 2},
218 {r_ofs (tss_fs), 2},
219 {r_ofs (tss_gs), 2},
220 {0, 10}, /* 8 FP registers, from npx.reg[] */
221 {1, 10},
222 {2, 10},
223 {3, 10},
224 {4, 10},
225 {5, 10},
226 {6, 10},
227 {7, 10},
228 /* The order of the next 7 registers must be consistent
229 with their numbering in config/i386/tm-i386.h, which see. */
230 {0, 2}, /* control word, from npx */
231 {4, 2}, /* status word, from npx */
232 {8, 2}, /* tag word, from npx */
233 {16, 2}, /* last FP exception CS from npx */
234 {12, 4}, /* last FP exception EIP from npx */
235 {24, 2}, /* last FP exception operand selector from npx */
236 {20, 4}, /* last FP exception operand offset from npx */
237 {18, 2} /* last FP opcode from npx */
238 };
239
240 static struct
241 {
242 int go32_sig;
243 enum target_signal gdb_sig;
244 }
245 sig_map[] =
246 {
247 {0, TARGET_SIGNAL_FPE},
248 {1, TARGET_SIGNAL_TRAP},
249 /* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
250 but I think SIGBUS is better, since the NMI is usually activated
251 as a result of a memory parity check failure. */
252 {2, TARGET_SIGNAL_BUS},
253 {3, TARGET_SIGNAL_TRAP},
254 {4, TARGET_SIGNAL_FPE},
255 {5, TARGET_SIGNAL_SEGV},
256 {6, TARGET_SIGNAL_ILL},
257 {7, TARGET_SIGNAL_EMT}, /* no-coprocessor exception */
258 {8, TARGET_SIGNAL_SEGV},
259 {9, TARGET_SIGNAL_SEGV},
260 {10, TARGET_SIGNAL_BUS},
261 {11, TARGET_SIGNAL_SEGV},
262 {12, TARGET_SIGNAL_SEGV},
263 {13, TARGET_SIGNAL_SEGV},
264 {14, TARGET_SIGNAL_SEGV},
265 {16, TARGET_SIGNAL_FPE},
266 {17, TARGET_SIGNAL_BUS},
267 {31, TARGET_SIGNAL_ILL},
268 {0x1b, TARGET_SIGNAL_INT},
269 {0x75, TARGET_SIGNAL_FPE},
270 {0x78, TARGET_SIGNAL_ALRM},
271 {0x79, TARGET_SIGNAL_INT},
272 {0x7a, TARGET_SIGNAL_QUIT},
273 {-1, TARGET_SIGNAL_LAST}
274 };
275
276 static struct {
277 enum target_signal gdb_sig;
278 int djgpp_excepno;
279 } excepn_map[] = {
280 {TARGET_SIGNAL_0, -1},
281 {TARGET_SIGNAL_ILL, 6}, /* Invalid Opcode */
282 {TARGET_SIGNAL_EMT, 7}, /* triggers SIGNOFP */
283 {TARGET_SIGNAL_SEGV, 13}, /* GPF */
284 {TARGET_SIGNAL_BUS, 17}, /* Alignment Check */
285 /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
286 details. */
287 {TARGET_SIGNAL_TERM, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
288 {TARGET_SIGNAL_FPE, 0x75},
289 {TARGET_SIGNAL_INT, 0x79},
290 {TARGET_SIGNAL_QUIT, 0x7a},
291 {TARGET_SIGNAL_ALRM, 0x78}, /* triggers SIGTIMR */
292 {TARGET_SIGNAL_PROF, 0x78},
293 {TARGET_SIGNAL_LAST, -1}
294 };
295
296 static void
297 go32_open (char *name, int from_tty)
298 {
299 printf_unfiltered ("Done. Use the \"run\" command to run the program.\n");
300 }
301
302 static void
303 go32_close (int quitting)
304 {
305 }
306
307 static void
308 go32_attach (char *args, int from_tty)
309 {
310 error ("\
311 You cannot attach to a running program on this platform.\n\
312 Use the `run' command to run DJGPP programs.");
313 }
314
315 static void
316 go32_detach (char *args, int from_tty)
317 {
318 }
319
320 static int resume_is_step;
321 static int resume_signal = -1;
322
323 static void
324 go32_resume (ptid_t ptid, int step, enum target_signal siggnal)
325 {
326 int i;
327
328 resume_is_step = step;
329
330 if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
331 {
332 for (i = 0, resume_signal = -1;
333 excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
334 if (excepn_map[i].gdb_sig == siggnal)
335 {
336 resume_signal = excepn_map[i].djgpp_excepno;
337 break;
338 }
339 if (resume_signal == -1)
340 printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
341 target_signal_to_name (siggnal));
342 }
343 }
344
345 static char child_cwd[FILENAME_MAX];
346
347 static ptid_t
348 go32_wait (ptid_t ptid, struct target_waitstatus *status)
349 {
350 int i;
351 unsigned char saved_opcode;
352 unsigned long INT3_addr = 0;
353 int stepping_over_INT = 0;
354
355 a_tss.tss_eflags &= 0xfeff; /* reset the single-step flag (TF) */
356 if (resume_is_step)
357 {
358 /* If the next instruction is INT xx or INTO, we need to handle
359 them specially. Intel manuals say that these instructions
360 reset the single-step flag (a.k.a. TF). However, it seems
361 that, at least in the DPMI environment, and at least when
362 stepping over the DPMI interrupt 31h, the problem is having
363 TF set at all when INT 31h is executed: the debuggee either
364 crashes (and takes the system with it) or is killed by a
365 SIGTRAP.
366
367 So we need to emulate single-step mode: we put an INT3 opcode
368 right after the INT xx instruction, let the debuggee run
369 until it hits INT3 and stops, then restore the original
370 instruction which we overwrote with the INT3 opcode, and back
371 up the debuggee's EIP to that instruction. */
372 read_child (a_tss.tss_eip, &saved_opcode, 1);
373 if (saved_opcode == 0xCD || saved_opcode == 0xCE)
374 {
375 unsigned char INT3_opcode = 0xCC;
376
377 INT3_addr
378 = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
379 stepping_over_INT = 1;
380 read_child (INT3_addr, &saved_opcode, 1);
381 write_child (INT3_addr, &INT3_opcode, 1);
382 }
383 else
384 a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
385 }
386
387 /* The special value FFFFh in tss_trap indicates to run_child that
388 tss_irqn holds a signal to be delivered to the debuggee. */
389 if (resume_signal <= -1)
390 {
391 a_tss.tss_trap = 0;
392 a_tss.tss_irqn = 0xff;
393 }
394 else
395 {
396 a_tss.tss_trap = 0xffff; /* run_child looks for this */
397 a_tss.tss_irqn = resume_signal;
398 }
399
400 /* The child might change working directory behind our back. The
401 GDB users won't like the side effects of that when they work with
402 relative file names, and GDB might be confused by its current
403 directory not being in sync with the truth. So we always make a
404 point of changing back to where GDB thinks is its cwd, when we
405 return control to the debugger, but restore child's cwd before we
406 run it. */
407 /* Initialize child_cwd, before the first call to run_child and not
408 in the initialization, so the child get also the changed directory
409 set with the gdb-command "cd ..." */
410 if (!*child_cwd)
411 /* Initialize child's cwd with the current one. */
412 getcwd (child_cwd, sizeof (child_cwd));
413
414 chdir (child_cwd);
415
416 #if __DJGPP_MINOR__ < 3
417 load_npx ();
418 #endif
419 run_child ();
420 #if __DJGPP_MINOR__ < 3
421 save_npx ();
422 #endif
423
424 /* Did we step over an INT xx instruction? */
425 if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
426 {
427 /* Restore the original opcode. */
428 a_tss.tss_eip--; /* EIP points *after* the INT3 instruction */
429 write_child (a_tss.tss_eip, &saved_opcode, 1);
430 /* Simulate a TRAP exception. */
431 a_tss.tss_irqn = 1;
432 a_tss.tss_eflags |= 0x0100;
433 }
434
435 getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
436 chdir (current_directory);
437
438 if (a_tss.tss_irqn == 0x21)
439 {
440 status->kind = TARGET_WAITKIND_EXITED;
441 status->value.integer = a_tss.tss_eax & 0xff;
442 }
443 else
444 {
445 status->value.sig = TARGET_SIGNAL_UNKNOWN;
446 status->kind = TARGET_WAITKIND_STOPPED;
447 for (i = 0; sig_map[i].go32_sig != -1; i++)
448 {
449 if (a_tss.tss_irqn == sig_map[i].go32_sig)
450 {
451 #if __DJGPP_MINOR__ < 3
452 if ((status->value.sig = sig_map[i].gdb_sig) !=
453 TARGET_SIGNAL_TRAP)
454 status->kind = TARGET_WAITKIND_SIGNALLED;
455 #else
456 status->value.sig = sig_map[i].gdb_sig;
457 #endif
458 break;
459 }
460 }
461 }
462 return pid_to_ptid (SOME_PID);
463 }
464
465 static void
466 fetch_register (int regno)
467 {
468 if (regno < FP0_REGNUM)
469 regcache_raw_supply (current_regcache, regno,
470 (char *) &a_tss + regno_mapping[regno].tss_ofs);
471 else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
472 i387_supply_fsave (current_regcache, regno, &npx);
473 else
474 internal_error (__FILE__, __LINE__,
475 "Invalid register no. %d in fetch_register.", regno);
476 }
477
478 static void
479 go32_fetch_registers (int regno)
480 {
481 if (regno >= 0)
482 fetch_register (regno);
483 else
484 {
485 for (regno = 0; regno < FP0_REGNUM; regno++)
486 fetch_register (regno);
487 i387_supply_fsave (current_regcache, -1, &npx);
488 }
489 }
490
491 static void
492 store_register (int regno)
493 {
494 if (regno < FP0_REGNUM)
495 regcache_collect (regno, (char *) &a_tss + regno_mapping[regno].tss_ofs);
496 else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
497 i387_fill_fsave ((char *) &npx, regno);
498 else
499 internal_error (__FILE__, __LINE__,
500 "Invalid register no. %d in store_register.", regno);
501 }
502
503 static void
504 go32_store_registers (int regno)
505 {
506 unsigned r;
507
508 if (regno >= 0)
509 store_register (regno);
510 else
511 {
512 for (r = 0; r < FP0_REGNUM; r++)
513 store_register (r);
514 i387_fill_fsave ((char *) &npx, -1);
515 }
516 }
517
518 static void
519 go32_prepare_to_store (void)
520 {
521 }
522
523 static int
524 go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
525 struct mem_attrib *attrib, struct target_ops *target)
526 {
527 if (write)
528 {
529 if (write_child (memaddr, myaddr, len))
530 {
531 return 0;
532 }
533 else
534 {
535 return len;
536 }
537 }
538 else
539 {
540 if (read_child (memaddr, myaddr, len))
541 {
542 return 0;
543 }
544 else
545 {
546 return len;
547 }
548 }
549 }
550
551 static cmdline_t child_cmd; /* parsed child's command line kept here */
552
553 static void
554 go32_files_info (struct target_ops *target)
555 {
556 printf_unfiltered ("You are running a DJGPP V2 program.\n");
557 }
558
559 static void
560 go32_stop (void)
561 {
562 normal_stop ();
563 cleanup_client ();
564 inferior_ptid = null_ptid;
565 prog_has_started = 0;
566 }
567
568 static void
569 go32_kill_inferior (void)
570 {
571 redir_cmdline_delete (&child_cmd);
572 resume_signal = -1;
573 resume_is_step = 0;
574 unpush_target (&go32_ops);
575 }
576
577 static void
578 go32_create_inferior (char *exec_file, char *args, char **env, int from_tty)
579 {
580 extern char **environ;
581 jmp_buf start_state;
582 char *cmdline;
583 char **env_save = environ;
584 size_t cmdlen;
585
586 /* If no exec file handed to us, get it from the exec-file command -- with
587 a good, common error message if none is specified. */
588 if (exec_file == 0)
589 exec_file = get_exec_file (1);
590
591 if (prog_has_started)
592 {
593 go32_stop ();
594 go32_kill_inferior ();
595 }
596 resume_signal = -1;
597 resume_is_step = 0;
598
599 /* Initialize child's cwd as empty to be initialized when starting
600 the child. */
601 *child_cwd = 0;
602
603 /* Init command line storage. */
604 if (redir_debug_init (&child_cmd) == -1)
605 internal_error (__FILE__, __LINE__,
606 "Cannot allocate redirection storage: not enough memory.\n");
607
608 /* Parse the command line and create redirections. */
609 if (strpbrk (args, "<>"))
610 {
611 if (redir_cmdline_parse (args, &child_cmd) == 0)
612 args = child_cmd.command;
613 else
614 error ("Syntax error in command line.");
615 }
616 else
617 child_cmd.command = xstrdup (args);
618
619 cmdlen = strlen (args);
620 /* v2loadimage passes command lines via DOS memory, so it cannot
621 possibly handle commands longer than 1MB. */
622 if (cmdlen > 1024*1024)
623 error ("Command line too long.");
624
625 cmdline = xmalloc (cmdlen + 4);
626 strcpy (cmdline + 1, args);
627 /* If the command-line length fits into DOS 126-char limits, use the
628 DOS command tail format; otherwise, tell v2loadimage to pass it
629 through a buffer in conventional memory. */
630 if (cmdlen < 127)
631 {
632 cmdline[0] = strlen (args);
633 cmdline[cmdlen + 1] = 13;
634 }
635 else
636 cmdline[0] = 0xff; /* signal v2loadimage it's a long command */
637
638 environ = env;
639
640 if (v2loadimage (exec_file, cmdline, start_state))
641 {
642 environ = env_save;
643 printf_unfiltered ("Load failed for image %s\n", exec_file);
644 exit (1);
645 }
646 environ = env_save;
647 xfree (cmdline);
648
649 edi_init (start_state);
650 #if __DJGPP_MINOR__ < 3
651 save_npx ();
652 #endif
653
654 inferior_ptid = pid_to_ptid (SOME_PID);
655 push_target (&go32_ops);
656 clear_proceed_status ();
657 insert_breakpoints ();
658 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
659 prog_has_started = 1;
660 }
661
662 static void
663 go32_mourn_inferior (void)
664 {
665 /* We need to make sure all the breakpoint enable bits in the DR7
666 register are reset when the inferior exits. Otherwise, if they
667 rerun the inferior, the uncleared bits may cause random SIGTRAPs,
668 failure to set more watchpoints, and other calamities. It would
669 be nice if GDB itself would take care to remove all breakpoints
670 at all times, but it doesn't, probably under an assumption that
671 the OS cleans up when the debuggee exits. */
672 i386_cleanup_dregs ();
673 go32_kill_inferior ();
674 generic_mourn_inferior ();
675 }
676
677 static int
678 go32_can_run (void)
679 {
680 return 1;
681 }
682
683 /* Hardware watchpoint support. */
684
685 #define D_REGS edi.dr
686 #define CONTROL D_REGS[7]
687 #define STATUS D_REGS[6]
688
689 /* Pass the address ADDR to the inferior in the I'th debug register.
690 Here we just store the address in D_REGS, the watchpoint will be
691 actually set up when go32_wait runs the debuggee. */
692 void
693 go32_set_dr (int i, CORE_ADDR addr)
694 {
695 if (i < 0 || i > 3)
696 internal_error (__FILE__, __LINE__,
697 "Invalid register %d in go32_set_dr.\n", i);
698 D_REGS[i] = addr;
699 }
700
701 /* Pass the value VAL to the inferior in the DR7 debug control
702 register. Here we just store the address in D_REGS, the watchpoint
703 will be actually set up when go32_wait runs the debuggee. */
704 void
705 go32_set_dr7 (unsigned val)
706 {
707 CONTROL = val;
708 }
709
710 /* Get the value of the DR6 debug status register from the inferior.
711 Here we just return the value stored in D_REGS, as we've got it
712 from the last go32_wait call. */
713 unsigned
714 go32_get_dr6 (void)
715 {
716 return STATUS;
717 }
718
719 /* Put the device open on handle FD into either raw or cooked
720 mode, return 1 if it was in raw mode, zero otherwise. */
721
722 static int
723 device_mode (int fd, int raw_p)
724 {
725 int oldmode, newmode;
726 __dpmi_regs regs;
727
728 regs.x.ax = 0x4400;
729 regs.x.bx = fd;
730 __dpmi_int (0x21, &regs);
731 if (regs.x.flags & 1)
732 return -1;
733 newmode = oldmode = regs.x.dx;
734
735 if (raw_p)
736 newmode |= 0x20;
737 else
738 newmode &= ~0x20;
739
740 if (oldmode & 0x80) /* Only for character dev */
741 {
742 regs.x.ax = 0x4401;
743 regs.x.bx = fd;
744 regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails */
745 __dpmi_int (0x21, &regs);
746 if (regs.x.flags & 1)
747 return -1;
748 }
749 return (oldmode & 0x20) == 0x20;
750 }
751
752
753 static int inf_mode_valid = 0;
754 static int inf_terminal_mode;
755
756 /* This semaphore is needed because, amazingly enough, GDB calls
757 target.to_terminal_ours more than once after the inferior stops.
758 But we need the information from the first call only, since the
759 second call will always see GDB's own cooked terminal. */
760 static int terminal_is_ours = 1;
761
762 static void
763 go32_terminal_init (void)
764 {
765 inf_mode_valid = 0; /* reinitialize, in case they are restarting child */
766 terminal_is_ours = 1;
767 }
768
769 static void
770 go32_terminal_info (char *args, int from_tty)
771 {
772 printf_unfiltered ("Inferior's terminal is in %s mode.\n",
773 !inf_mode_valid
774 ? "default" : inf_terminal_mode ? "raw" : "cooked");
775
776 #if __DJGPP_MINOR__ > 2
777 if (child_cmd.redirection)
778 {
779 int i;
780
781 for (i = 0; i < DBG_HANDLES; i++)
782 {
783 if (child_cmd.redirection[i]->file_name)
784 printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
785 i, child_cmd.redirection[i]->file_name);
786 else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
787 printf_unfiltered
788 ("\tFile handle %d appears to be closed by inferior.\n", i);
789 /* Mask off the raw/cooked bit when comparing device info words. */
790 else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
791 != (_get_dev_info (i) & 0xdf))
792 printf_unfiltered
793 ("\tFile handle %d appears to be redirected by inferior.\n", i);
794 }
795 }
796 #endif
797 }
798
799 static void
800 go32_terminal_inferior (void)
801 {
802 /* Redirect standard handles as child wants them. */
803 errno = 0;
804 if (redir_to_child (&child_cmd) == -1)
805 {
806 redir_to_debugger (&child_cmd);
807 error ("Cannot redirect standard handles for program: %s.",
808 safe_strerror (errno));
809 }
810 /* set the console device of the inferior to whatever mode
811 (raw or cooked) we found it last time */
812 if (terminal_is_ours)
813 {
814 if (inf_mode_valid)
815 device_mode (0, inf_terminal_mode);
816 terminal_is_ours = 0;
817 }
818 }
819
820 static void
821 go32_terminal_ours (void)
822 {
823 /* Switch to cooked mode on the gdb terminal and save the inferior
824 terminal mode to be restored when it is resumed */
825 if (!terminal_is_ours)
826 {
827 inf_terminal_mode = device_mode (0, 0);
828 if (inf_terminal_mode != -1)
829 inf_mode_valid = 1;
830 else
831 /* If device_mode returned -1, we don't know what happens with
832 handle 0 anymore, so make the info invalid. */
833 inf_mode_valid = 0;
834 terminal_is_ours = 1;
835
836 /* Restore debugger's standard handles. */
837 errno = 0;
838 if (redir_to_debugger (&child_cmd) == -1)
839 {
840 redir_to_child (&child_cmd);
841 error ("Cannot redirect standard handles for debugger: %s.",
842 safe_strerror (errno));
843 }
844 }
845 }
846
847 static void
848 init_go32_ops (void)
849 {
850 go32_ops.to_shortname = "djgpp";
851 go32_ops.to_longname = "djgpp target process";
852 go32_ops.to_doc =
853 "Program loaded by djgpp, when gdb is used as an external debugger";
854 go32_ops.to_open = go32_open;
855 go32_ops.to_close = go32_close;
856 go32_ops.to_attach = go32_attach;
857 go32_ops.to_detach = go32_detach;
858 go32_ops.to_resume = go32_resume;
859 go32_ops.to_wait = go32_wait;
860 go32_ops.to_fetch_registers = go32_fetch_registers;
861 go32_ops.to_store_registers = go32_store_registers;
862 go32_ops.to_prepare_to_store = go32_prepare_to_store;
863 go32_ops.to_xfer_memory = go32_xfer_memory;
864 go32_ops.to_files_info = go32_files_info;
865 go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
866 go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
867 go32_ops.to_terminal_init = go32_terminal_init;
868 go32_ops.to_terminal_inferior = go32_terminal_inferior;
869 go32_ops.to_terminal_ours_for_output = go32_terminal_ours;
870 go32_ops.to_terminal_ours = go32_terminal_ours;
871 go32_ops.to_terminal_info = go32_terminal_info;
872 go32_ops.to_kill = go32_kill_inferior;
873 go32_ops.to_create_inferior = go32_create_inferior;
874 go32_ops.to_mourn_inferior = go32_mourn_inferior;
875 go32_ops.to_can_run = go32_can_run;
876 go32_ops.to_stop = go32_stop;
877 go32_ops.to_stratum = process_stratum;
878 go32_ops.to_has_all_memory = 1;
879 go32_ops.to_has_memory = 1;
880 go32_ops.to_has_stack = 1;
881 go32_ops.to_has_registers = 1;
882 go32_ops.to_has_execution = 1;
883 go32_ops.to_magic = OPS_MAGIC;
884
885 /* Initialize child's cwd as empty to be initialized when starting
886 the child. */
887 *child_cwd = 0;
888
889 /* Initialize child's command line storage. */
890 if (redir_debug_init (&child_cmd) == -1)
891 internal_error (__FILE__, __LINE__,
892 "Cannot allocate redirection storage: not enough memory.\n");
893
894 /* We are always processing GCC-compiled programs. */
895 processing_gcc_compilation = 2;
896 }
897
898 unsigned short windows_major, windows_minor;
899
900 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */
901 static void
902 go32_get_windows_version(void)
903 {
904 __dpmi_regs r;
905
906 r.x.ax = 0x1600;
907 __dpmi_int(0x2f, &r);
908 if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
909 && (r.h.al > 3 || r.h.ah > 0))
910 {
911 windows_major = r.h.al;
912 windows_minor = r.h.ah;
913 }
914 else
915 windows_major = 0xff; /* meaning no Windows */
916 }
917
918 /* A subroutine of go32_sysinfo to display memory info. */
919 static void
920 print_mem (unsigned long datum, const char *header, int in_pages_p)
921 {
922 if (datum != 0xffffffffUL)
923 {
924 if (in_pages_p)
925 datum <<= 12;
926 puts_filtered (header);
927 if (datum > 1024)
928 {
929 printf_filtered ("%lu KB", datum >> 10);
930 if (datum > 1024 * 1024)
931 printf_filtered (" (%lu MB)", datum >> 20);
932 }
933 else
934 printf_filtered ("%lu Bytes", datum);
935 puts_filtered ("\n");
936 }
937 }
938
939 /* Display assorted information about the underlying OS. */
940 static void
941 go32_sysinfo (char *arg, int from_tty)
942 {
943 struct utsname u;
944 char cpuid_vendor[13];
945 unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
946 unsigned true_dos_version = _get_dos_version (1);
947 unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
948 int dpmi_flags;
949 char dpmi_vendor_info[129];
950 int dpmi_vendor_available =
951 __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
952 __dpmi_version_ret dpmi_version_data;
953 long eflags;
954 __dpmi_free_mem_info mem_info;
955 __dpmi_regs regs;
956
957 cpuid_vendor[0] = '\0';
958 if (uname (&u))
959 strcpy (u.machine, "Unknown x86");
960 else if (u.machine[0] == 'i' && u.machine[1] > 4)
961 {
962 /* CPUID with EAX = 0 returns the Vendor ID. */
963 __asm__ __volatile__ ("xorl %%ebx, %%ebx;"
964 "xorl %%ecx, %%ecx;"
965 "xorl %%edx, %%edx;"
966 "movl $0, %%eax;"
967 "cpuid;"
968 "movl %%ebx, %0;"
969 "movl %%edx, %1;"
970 "movl %%ecx, %2;"
971 "movl %%eax, %3;"
972 : "=m" (cpuid_vendor[0]),
973 "=m" (cpuid_vendor[4]),
974 "=m" (cpuid_vendor[8]),
975 "=m" (cpuid_max)
976 :
977 : "%eax", "%ebx", "%ecx", "%edx");
978 cpuid_vendor[12] = '\0';
979 }
980
981 printf_filtered ("CPU Type.......................%s", u.machine);
982 if (cpuid_vendor[0])
983 printf_filtered (" (%s)", cpuid_vendor);
984 puts_filtered ("\n");
985
986 /* CPUID with EAX = 1 returns processor signature and features. */
987 if (cpuid_max >= 1)
988 {
989 static char *brand_name[] = {
990 "",
991 " Celeron",
992 " III",
993 " III Xeon",
994 "", "", "", "",
995 " 4"
996 };
997 char cpu_string[80];
998 char cpu_brand[20];
999 unsigned brand_idx;
1000 int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
1001 int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
1002 unsigned cpu_family, cpu_model;
1003
1004 __asm__ __volatile__ ("movl $1, %%eax;"
1005 "cpuid;"
1006 : "=a" (cpuid_eax),
1007 "=b" (cpuid_ebx),
1008 "=d" (cpuid_edx)
1009 :
1010 : "%ecx");
1011 brand_idx = cpuid_ebx & 0xff;
1012 cpu_family = (cpuid_eax >> 8) & 0xf;
1013 cpu_model = (cpuid_eax >> 4) & 0xf;
1014 cpu_brand[0] = '\0';
1015 if (intel_p)
1016 {
1017 if (brand_idx > 0
1018 && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
1019 && *brand_name[brand_idx])
1020 strcpy (cpu_brand, brand_name[brand_idx]);
1021 else if (cpu_family == 5)
1022 {
1023 if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
1024 strcpy (cpu_brand, " MMX");
1025 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
1026 strcpy (cpu_brand, " OverDrive");
1027 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
1028 strcpy (cpu_brand, " Dual");
1029 }
1030 else if (cpu_family == 6 && cpu_model < 8)
1031 {
1032 switch (cpu_model)
1033 {
1034 case 1:
1035 strcpy (cpu_brand, " Pro");
1036 break;
1037 case 3:
1038 strcpy (cpu_brand, " II");
1039 break;
1040 case 5:
1041 strcpy (cpu_brand, " II Xeon");
1042 break;
1043 case 6:
1044 strcpy (cpu_brand, " Celeron");
1045 break;
1046 case 7:
1047 strcpy (cpu_brand, " III");
1048 break;
1049 }
1050 }
1051 }
1052 else if (amd_p)
1053 {
1054 switch (cpu_family)
1055 {
1056 case 4:
1057 strcpy (cpu_brand, "486/5x86");
1058 break;
1059 case 5:
1060 switch (cpu_model)
1061 {
1062 case 0:
1063 case 1:
1064 case 2:
1065 case 3:
1066 strcpy (cpu_brand, "-K5");
1067 break;
1068 case 6:
1069 case 7:
1070 strcpy (cpu_brand, "-K6");
1071 break;
1072 case 8:
1073 strcpy (cpu_brand, "-K6-2");
1074 break;
1075 case 9:
1076 strcpy (cpu_brand, "-K6-III");
1077 break;
1078 }
1079 break;
1080 case 6:
1081 switch (cpu_model)
1082 {
1083 case 1:
1084 case 2:
1085 case 4:
1086 strcpy (cpu_brand, " Athlon");
1087 break;
1088 case 3:
1089 strcpy (cpu_brand, " Duron");
1090 break;
1091 }
1092 break;
1093 }
1094 }
1095 sprintf (cpu_string, "%s%s Model %d Stepping %d",
1096 intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
1097 cpu_brand, cpu_model, cpuid_eax & 0xf);
1098 printfi_filtered (31, "%s\n", cpu_string);
1099 if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
1100 || ((cpuid_edx & 1) == 0)
1101 || (amd_p && (cpuid_edx & (3 << 30)) != 0))
1102 {
1103 puts_filtered ("CPU Features...................");
1104 /* We only list features which might be useful in the DPMI
1105 environment. */
1106 if ((cpuid_edx & 1) == 0)
1107 puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
1108 if ((cpuid_edx & (1 << 1)) != 0)
1109 puts_filtered ("VME ");
1110 if ((cpuid_edx & (1 << 2)) != 0)
1111 puts_filtered ("DE ");
1112 if ((cpuid_edx & (1 << 4)) != 0)
1113 puts_filtered ("TSC ");
1114 if ((cpuid_edx & (1 << 23)) != 0)
1115 puts_filtered ("MMX ");
1116 if ((cpuid_edx & (1 << 25)) != 0)
1117 puts_filtered ("SSE ");
1118 if ((cpuid_edx & (1 << 26)) != 0)
1119 puts_filtered ("SSE2 ");
1120 if (amd_p)
1121 {
1122 if ((cpuid_edx & (1 << 31)) != 0)
1123 puts_filtered ("3DNow! ");
1124 if ((cpuid_edx & (1 << 30)) != 0)
1125 puts_filtered ("3DNow!Ext");
1126 }
1127 puts_filtered ("\n");
1128 }
1129 }
1130 puts_filtered ("\n");
1131 printf_filtered ("DOS Version....................%s %s.%s",
1132 _os_flavor, u.release, u.version);
1133 if (true_dos_version != advertized_dos_version)
1134 printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
1135 puts_filtered ("\n");
1136 if (!windows_major)
1137 go32_get_windows_version ();
1138 if (windows_major != 0xff)
1139 {
1140 const char *windows_flavor;
1141
1142 printf_filtered ("Windows Version................%d.%02d (Windows ",
1143 windows_major, windows_minor);
1144 switch (windows_major)
1145 {
1146 case 3:
1147 windows_flavor = "3.X";
1148 break;
1149 case 4:
1150 switch (windows_minor)
1151 {
1152 case 0:
1153 windows_flavor = "95, 95A, or 95B";
1154 break;
1155 case 3:
1156 windows_flavor = "95B OSR2.1 or 95C OSR2.5";
1157 break;
1158 case 10:
1159 windows_flavor = "98 or 98 SE";
1160 break;
1161 case 90:
1162 windows_flavor = "ME";
1163 break;
1164 default:
1165 windows_flavor = "9X";
1166 break;
1167 }
1168 break;
1169 default:
1170 windows_flavor = "??";
1171 break;
1172 }
1173 printf_filtered ("%s)\n", windows_flavor);
1174 }
1175 else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
1176 printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
1177 puts_filtered ("\n");
1178 if (dpmi_vendor_available == 0)
1179 {
1180 /* The DPMI spec says the vendor string should be ASCIIZ, but
1181 I don't trust the vendors to follow that... */
1182 if (!memchr (&dpmi_vendor_info[2], 0, 126))
1183 dpmi_vendor_info[128] = '\0';
1184 printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
1185 &dpmi_vendor_info[2],
1186 (unsigned)dpmi_vendor_info[0],
1187 (unsigned)dpmi_vendor_info[1],
1188 ((unsigned)dpmi_flags & 0x7f));
1189 }
1190 __dpmi_get_version (&dpmi_version_data);
1191 printf_filtered ("DPMI Version...................%d.%02d\n",
1192 dpmi_version_data.major, dpmi_version_data.minor);
1193 printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
1194 (dpmi_version_data.flags & 1) ? "32" : "16",
1195 (dpmi_version_data.flags & 4) ? "" : "out");
1196 printfi_filtered (31, "Interrupts reflected to %s mode\n",
1197 (dpmi_version_data.flags & 2) ? "V86" : "Real");
1198 printfi_filtered (31, "Processor type: i%d86\n",
1199 dpmi_version_data.cpu);
1200 printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
1201 dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
1202
1203 /* a_tss is only initialized when the debuggee is first run. */
1204 if (prog_has_started)
1205 {
1206 __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
1207 printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
1208 a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
1209 (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
1210 }
1211 puts_filtered ("\n");
1212 __dpmi_get_free_memory_information (&mem_info);
1213 print_mem (mem_info.total_number_of_physical_pages,
1214 "DPMI Total Physical Memory.....", 1);
1215 print_mem (mem_info.total_number_of_free_pages,
1216 "DPMI Free Physical Memory......", 1);
1217 print_mem (mem_info.size_of_paging_file_partition_in_pages,
1218 "DPMI Swap Space................", 1);
1219 print_mem (mem_info.linear_address_space_size_in_pages,
1220 "DPMI Total Linear Address Size.", 1);
1221 print_mem (mem_info.free_linear_address_space_in_pages,
1222 "DPMI Free Linear Address Size..", 1);
1223 print_mem (mem_info.largest_available_free_block_in_bytes,
1224 "DPMI Largest Free Memory Block.", 0);
1225
1226 regs.h.ah = 0x48;
1227 regs.x.bx = 0xffff;
1228 __dpmi_int (0x21, &regs);
1229 print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
1230 regs.x.ax = 0x5800;
1231 __dpmi_int (0x21, &regs);
1232 if ((regs.x.flags & 1) == 0)
1233 {
1234 static const char *dos_hilo[] = {
1235 "Low", "", "", "", "High", "", "", "", "High, then Low"
1236 };
1237 static const char *dos_fit[] = {
1238 "First", "Best", "Last"
1239 };
1240 int hilo_idx = (regs.x.ax >> 4) & 0x0f;
1241 int fit_idx = regs.x.ax & 0x0f;
1242
1243 if (hilo_idx > 8)
1244 hilo_idx = 0;
1245 if (fit_idx > 2)
1246 fit_idx = 0;
1247 printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
1248 dos_hilo[hilo_idx], dos_fit[fit_idx]);
1249 regs.x.ax = 0x5802;
1250 __dpmi_int (0x21, &regs);
1251 if ((regs.x.flags & 1) != 0)
1252 regs.h.al = 0;
1253 printfi_filtered (31, "UMBs %sin DOS memory chain\n",
1254 regs.h.al == 0 ? "not " : "");
1255 }
1256 }
1257
1258 struct seg_descr {
1259 unsigned short limit0 __attribute__((packed));
1260 unsigned short base0 __attribute__((packed));
1261 unsigned char base1 __attribute__((packed));
1262 unsigned stype:5 __attribute__((packed));
1263 unsigned dpl:2 __attribute__((packed));
1264 unsigned present:1 __attribute__((packed));
1265 unsigned limit1:4 __attribute__((packed));
1266 unsigned available:1 __attribute__((packed));
1267 unsigned dummy:1 __attribute__((packed));
1268 unsigned bit32:1 __attribute__((packed));
1269 unsigned page_granular:1 __attribute__((packed));
1270 unsigned char base2 __attribute__((packed));
1271 };
1272
1273 struct gate_descr {
1274 unsigned short offset0 __attribute__((packed));
1275 unsigned short selector __attribute__((packed));
1276 unsigned param_count:5 __attribute__((packed));
1277 unsigned dummy:3 __attribute__((packed));
1278 unsigned stype:5 __attribute__((packed));
1279 unsigned dpl:2 __attribute__((packed));
1280 unsigned present:1 __attribute__((packed));
1281 unsigned short offset1 __attribute__((packed));
1282 };
1283
1284 /* Read LEN bytes starting at logical address ADDR, and put the result
1285 into DEST. Return 1 if success, zero if not. */
1286 static int
1287 read_memory_region (unsigned long addr, void *dest, size_t len)
1288 {
1289 unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
1290 int retval = 1;
1291
1292 /* For the low memory, we can simply use _dos_ds. */
1293 if (addr <= dos_ds_limit - len)
1294 dosmemget (addr, len, dest);
1295 else
1296 {
1297 /* For memory above 1MB we need to set up a special segment to
1298 be able to access that memory. */
1299 int sel = __dpmi_allocate_ldt_descriptors (1);
1300
1301 if (sel <= 0)
1302 retval = 0;
1303 else
1304 {
1305 int access_rights = __dpmi_get_descriptor_access_rights (sel);
1306 size_t segment_limit = len - 1;
1307
1308 /* Make sure the crucial bits in the descriptor access
1309 rights are set correctly. Some DPMI providers might barf
1310 if we set the segment limit to something that is not an
1311 integral multiple of 4KB pages if the granularity bit is
1312 not set to byte-granular, even though the DPMI spec says
1313 it's the host's responsibility to set that bit correctly. */
1314 if (len > 1024 * 1024)
1315 {
1316 access_rights |= 0x8000;
1317 /* Page-granular segments should have the low 12 bits of
1318 the limit set. */
1319 segment_limit |= 0xfff;
1320 }
1321 else
1322 access_rights &= ~0x8000;
1323
1324 if (__dpmi_set_segment_base_address (sel, addr) != -1
1325 && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
1326 && __dpmi_set_segment_limit (sel, segment_limit) != -1
1327 /* W2K silently fails to set the segment limit, leaving
1328 it at zero; this test avoids the resulting crash. */
1329 && __dpmi_get_segment_limit (sel) >= segment_limit)
1330 movedata (sel, 0, _my_ds (), (unsigned)dest, len);
1331 else
1332 retval = 0;
1333
1334 __dpmi_free_ldt_descriptor (sel);
1335 }
1336 }
1337 return retval;
1338 }
1339
1340 /* Get a segment descriptor stored at index IDX in the descriptor
1341 table whose base address is TABLE_BASE. Return the descriptor
1342 type, or -1 if failure. */
1343 static int
1344 get_descriptor (unsigned long table_base, int idx, void *descr)
1345 {
1346 unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
1347
1348 if (read_memory_region (addr, descr, 8))
1349 return (int)((struct seg_descr *)descr)->stype;
1350 return -1;
1351 }
1352
1353 struct dtr_reg {
1354 unsigned short limit __attribute__((packed));
1355 unsigned long base __attribute__((packed));
1356 };
1357
1358 /* Display a segment descriptor stored at index IDX in a descriptor
1359 table whose type is TYPE and whose base address is BASE_ADDR. If
1360 FORCE is non-zero, display even invalid descriptors. */
1361 static void
1362 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
1363 {
1364 struct seg_descr descr;
1365 struct gate_descr gate;
1366
1367 /* Get the descriptor from the table. */
1368 if (idx == 0 && type == 0)
1369 puts_filtered ("0x000: null descriptor\n");
1370 else if (get_descriptor (base_addr, idx, &descr) != -1)
1371 {
1372 /* For each type of descriptor table, this has a bit set if the
1373 corresponding type of selectors is valid in that table. */
1374 static unsigned allowed_descriptors[] = {
1375 0xffffdafeL, /* GDT */
1376 0x0000c0e0L, /* IDT */
1377 0xffffdafaL /* LDT */
1378 };
1379
1380 /* If the program hasn't started yet, assume the debuggee will
1381 have the same CPL as the debugger. */
1382 int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
1383 unsigned long limit = (descr.limit1 << 16) | descr.limit0;
1384
1385 if (descr.present
1386 && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
1387 {
1388 printf_filtered ("0x%03x: ",
1389 type == 1
1390 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1391 if (descr.page_granular)
1392 limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
1393 if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
1394 || descr.stype == 9 || descr.stype == 11
1395 || (descr.stype >= 16 && descr.stype < 32))
1396 printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
1397 descr.base2, descr.base1, descr.base0, limit);
1398
1399 switch (descr.stype)
1400 {
1401 case 1:
1402 case 3:
1403 printf_filtered (" 16-bit TSS (task %sactive)",
1404 descr.stype == 3 ? "" : "in");
1405 break;
1406 case 2:
1407 puts_filtered (" LDT");
1408 break;
1409 case 4:
1410 memcpy (&gate, &descr, sizeof gate);
1411 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1412 gate.selector, gate.offset1, gate.offset0);
1413 printf_filtered (" 16-bit Call Gate (params=%d)",
1414 gate.param_count);
1415 break;
1416 case 5:
1417 printf_filtered ("TSS selector=0x%04x", descr.base0);
1418 printfi_filtered (16, "Task Gate");
1419 break;
1420 case 6:
1421 case 7:
1422 memcpy (&gate, &descr, sizeof gate);
1423 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1424 gate.selector, gate.offset1, gate.offset0);
1425 printf_filtered (" 16-bit %s Gate",
1426 descr.stype == 6 ? "Interrupt" : "Trap");
1427 break;
1428 case 9:
1429 case 11:
1430 printf_filtered (" 32-bit TSS (task %sactive)",
1431 descr.stype == 3 ? "" : "in");
1432 break;
1433 case 12:
1434 memcpy (&gate, &descr, sizeof gate);
1435 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1436 gate.selector, gate.offset1, gate.offset0);
1437 printf_filtered (" 32-bit Call Gate (params=%d)",
1438 gate.param_count);
1439 break;
1440 case 14:
1441 case 15:
1442 memcpy (&gate, &descr, sizeof gate);
1443 printf_filtered ("selector=0x%04x offs=0x%04x%04x",
1444 gate.selector, gate.offset1, gate.offset0);
1445 printf_filtered (" 32-bit %s Gate",
1446 descr.stype == 14 ? "Interrupt" : "Trap");
1447 break;
1448 case 16: /* data segments */
1449 case 17:
1450 case 18:
1451 case 19:
1452 case 20:
1453 case 21:
1454 case 22:
1455 case 23:
1456 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
1457 descr.bit32 ? "32" : "16",
1458 descr.stype & 2 ? "Read/Write," : "Read-Only, ",
1459 descr.stype & 4 ? "down" : "up",
1460 descr.stype & 1 ? "" : ", N.Acc");
1461 break;
1462 case 24: /* code segments */
1463 case 25:
1464 case 26:
1465 case 27:
1466 case 28:
1467 case 29:
1468 case 30:
1469 case 31:
1470 printf_filtered (" %s-bit Code (%s, %sConf%s)",
1471 descr.bit32 ? "32" : "16",
1472 descr.stype & 2 ? "Exec/Read" : "Exec-Only",
1473 descr.stype & 4 ? "" : "N.",
1474 descr.stype & 1 ? "" : ", N.Acc");
1475 break;
1476 default:
1477 printf_filtered ("Unknown type 0x%02x", descr.stype);
1478 break;
1479 }
1480 puts_filtered ("\n");
1481 }
1482 else if (force)
1483 {
1484 printf_filtered ("0x%03x: ",
1485 type == 1
1486 ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
1487 if (!descr.present)
1488 puts_filtered ("Segment not present\n");
1489 else
1490 printf_filtered ("Segment type 0x%02x is invalid in this table\n",
1491 descr.stype);
1492 }
1493 }
1494 else if (force)
1495 printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
1496 }
1497
1498 static void
1499 go32_sldt (char *arg, int from_tty)
1500 {
1501 struct dtr_reg gdtr;
1502 unsigned short ldtr = 0;
1503 int ldt_idx;
1504 struct seg_descr ldt_descr;
1505 long ldt_entry = -1L;
1506 int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
1507
1508 if (arg && *arg)
1509 {
1510 while (*arg && isspace(*arg))
1511 arg++;
1512
1513 if (*arg)
1514 {
1515 ldt_entry = parse_and_eval_long (arg);
1516 if (ldt_entry < 0
1517 || (ldt_entry & 4) == 0
1518 || (ldt_entry & 3) != (cpl & 3))
1519 error ("Invalid LDT entry 0x%03lx.", (unsigned long)ldt_entry);
1520 }
1521 }
1522
1523 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1524 __asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ );
1525 ldt_idx = ldtr / 8;
1526 if (ldt_idx == 0)
1527 puts_filtered ("There is no LDT.\n");
1528 /* LDT's entry in the GDT must have the type LDT, which is 2. */
1529 else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
1530 printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
1531 ldt_descr.base0
1532 | (ldt_descr.base1 << 16)
1533 | (ldt_descr.base2 << 24));
1534 else
1535 {
1536 unsigned base =
1537 ldt_descr.base0
1538 | (ldt_descr.base1 << 16)
1539 | (ldt_descr.base2 << 24);
1540 unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
1541 int max_entry;
1542
1543 if (ldt_descr.page_granular)
1544 /* Page-granular segments must have the low 12 bits of their
1545 limit set. */
1546 limit = (limit << 12) | 0xfff;
1547 /* LDT cannot have more than 8K 8-byte entries, i.e. more than
1548 64KB. */
1549 if (limit > 0xffff)
1550 limit = 0xffff;
1551
1552 max_entry = (limit + 1) / 8;
1553
1554 if (ldt_entry >= 0)
1555 {
1556 if (ldt_entry > limit)
1557 error ("Invalid LDT entry %#lx: outside valid limits [0..%#x]",
1558 (unsigned long)ldt_entry, limit);
1559
1560 display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
1561 }
1562 else
1563 {
1564 int i;
1565
1566 for (i = 0; i < max_entry; i++)
1567 display_descriptor (ldt_descr.stype, base, i, 0);
1568 }
1569 }
1570 }
1571
1572 static void
1573 go32_sgdt (char *arg, int from_tty)
1574 {
1575 struct dtr_reg gdtr;
1576 long gdt_entry = -1L;
1577 int max_entry;
1578
1579 if (arg && *arg)
1580 {
1581 while (*arg && isspace(*arg))
1582 arg++;
1583
1584 if (*arg)
1585 {
1586 gdt_entry = parse_and_eval_long (arg);
1587 if (gdt_entry < 0 || (gdt_entry & 7) != 0)
1588 error ("Invalid GDT entry 0x%03lx: not an integral multiple of 8.",
1589 (unsigned long)gdt_entry);
1590 }
1591 }
1592
1593 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1594 max_entry = (gdtr.limit + 1) / 8;
1595
1596 if (gdt_entry >= 0)
1597 {
1598 if (gdt_entry > gdtr.limit)
1599 error ("Invalid GDT entry %#lx: outside valid limits [0..%#x]",
1600 (unsigned long)gdt_entry, gdtr.limit);
1601
1602 display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
1603 }
1604 else
1605 {
1606 int i;
1607
1608 for (i = 0; i < max_entry; i++)
1609 display_descriptor (0, gdtr.base, i, 0);
1610 }
1611 }
1612
1613 static void
1614 go32_sidt (char *arg, int from_tty)
1615 {
1616 struct dtr_reg idtr;
1617 long idt_entry = -1L;
1618 int max_entry;
1619
1620 if (arg && *arg)
1621 {
1622 while (*arg && isspace(*arg))
1623 arg++;
1624
1625 if (*arg)
1626 {
1627 idt_entry = parse_and_eval_long (arg);
1628 if (idt_entry < 0)
1629 error ("Invalid (negative) IDT entry %ld.", idt_entry);
1630 }
1631 }
1632
1633 __asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ );
1634 max_entry = (idtr.limit + 1) / 8;
1635 if (max_entry > 0x100) /* no more than 256 entries */
1636 max_entry = 0x100;
1637
1638 if (idt_entry >= 0)
1639 {
1640 if (idt_entry > idtr.limit)
1641 error ("Invalid IDT entry %#lx: outside valid limits [0..%#x]",
1642 (unsigned long)idt_entry, idtr.limit);
1643
1644 display_descriptor (1, idtr.base, idt_entry, 1);
1645 }
1646 else
1647 {
1648 int i;
1649
1650 for (i = 0; i < max_entry; i++)
1651 display_descriptor (1, idtr.base, i, 0);
1652 }
1653 }
1654
1655 /* Cached linear address of the base of the page directory. For
1656 now, available only under CWSDPMI. Code based on ideas and
1657 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
1658 static unsigned long pdbr;
1659
1660 static unsigned long
1661 get_cr3 (void)
1662 {
1663 unsigned offset;
1664 unsigned taskreg;
1665 unsigned long taskbase, cr3;
1666 struct dtr_reg gdtr;
1667
1668 if (pdbr > 0 && pdbr <= 0xfffff)
1669 return pdbr;
1670
1671 /* Get the linear address of GDT and the Task Register. */
1672 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
1673 __asm__ __volatile__ ("str %0" : "=m" (taskreg) : /* no inputs */ );
1674
1675 /* Task Register is a segment selector for the TSS of the current
1676 task. Therefore, it can be used as an index into the GDT to get
1677 at the segment descriptor for the TSS. To get the index, reset
1678 the low 3 bits of the selector (which give the CPL). Add 2 to the
1679 offset to point to the 3 low bytes of the base address. */
1680 offset = gdtr.base + (taskreg & 0xfff8) + 2;
1681
1682
1683 /* CWSDPMI's task base is always under the 1MB mark. */
1684 if (offset > 0xfffff)
1685 return 0;
1686
1687 _farsetsel (_dos_ds);
1688 taskbase = _farnspeekl (offset) & 0xffffffU;
1689 taskbase += _farnspeekl (offset + 2) & 0xff000000U;
1690 if (taskbase > 0xfffff)
1691 return 0;
1692
1693 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
1694 offset 1Ch in the TSS. */
1695 cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
1696 if (cr3 > 0xfffff)
1697 {
1698 #if 0 /* not fullly supported yet */
1699 /* The Page Directory is in UMBs. In that case, CWSDPMI puts
1700 the first Page Table right below the Page Directory. Thus,
1701 the first Page Table's entry for its own address and the Page
1702 Directory entry for that Page Table will hold the same
1703 physical address. The loop below searches the entire UMB
1704 range of addresses for such an occurence. */
1705 unsigned long addr, pte_idx;
1706
1707 for (addr = 0xb0000, pte_idx = 0xb0;
1708 pte_idx < 0xff;
1709 addr += 0x1000, pte_idx++)
1710 {
1711 if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
1712 (_farnspeekl (addr + 0x1000) & 0xfffff027))
1713 && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
1714 {
1715 cr3 = addr + 0x1000;
1716 break;
1717 }
1718 }
1719 #endif
1720
1721 if (cr3 > 0xfffff)
1722 cr3 = 0;
1723 }
1724
1725 return cr3;
1726 }
1727
1728 /* Return the N'th Page Directory entry. */
1729 static unsigned long
1730 get_pde (int n)
1731 {
1732 unsigned long pde = 0;
1733
1734 if (pdbr && n >= 0 && n < 1024)
1735 {
1736 pde = _farpeekl (_dos_ds, pdbr + 4*n);
1737 }
1738 return pde;
1739 }
1740
1741 /* Return the N'th entry of the Page Table whose Page Directory entry
1742 is PDE. */
1743 static unsigned long
1744 get_pte (unsigned long pde, int n)
1745 {
1746 unsigned long pte = 0;
1747
1748 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
1749 page tables, for now. */
1750 if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
1751 {
1752 pde &= ~0xfff; /* clear non-address bits */
1753 pte = _farpeekl (_dos_ds, pde + 4*n);
1754 }
1755 return pte;
1756 }
1757
1758 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
1759 says this is a Page Directory entry. If FORCE is non-zero, display
1760 the entry even if its Present flag is off. OFF is the offset of the
1761 address from the page's base address. */
1762 static void
1763 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
1764 {
1765 if ((entry & 1) != 0)
1766 {
1767 printf_filtered ("Base=0x%05lx000", entry >> 12);
1768 if ((entry & 0x100) && !is_dir)
1769 puts_filtered (" Global");
1770 if ((entry & 0x40) && !is_dir)
1771 puts_filtered (" Dirty");
1772 printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
1773 printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
1774 printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
1775 printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
1776 printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
1777 if (off)
1778 printf_filtered (" +0x%x", off);
1779 puts_filtered ("\n");
1780 }
1781 else if (force)
1782 printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
1783 is_dir ? " Table" : "", entry >> 1);
1784 }
1785
1786 static void
1787 go32_pde (char *arg, int from_tty)
1788 {
1789 long pde_idx = -1, i;
1790
1791 if (arg && *arg)
1792 {
1793 while (*arg && isspace(*arg))
1794 arg++;
1795
1796 if (*arg)
1797 {
1798 pde_idx = parse_and_eval_long (arg);
1799 if (pde_idx < 0 || pde_idx >= 1024)
1800 error ("Entry %ld is outside valid limits [0..1023].", pde_idx);
1801 }
1802 }
1803
1804 pdbr = get_cr3 ();
1805 if (!pdbr)
1806 puts_filtered ("Access to Page Directories is not supported on this system.\n");
1807 else if (pde_idx >= 0)
1808 display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
1809 else
1810 for (i = 0; i < 1024; i++)
1811 display_ptable_entry (get_pde (i), 1, 0, 0);
1812 }
1813
1814 /* A helper function to display entries in a Page Table pointed to by
1815 the N'th entry in the Page Directory. If FORCE is non-zero, say
1816 something even if the Page Table is not accessible. */
1817 static void
1818 display_page_table (long n, int force)
1819 {
1820 unsigned long pde = get_pde (n);
1821
1822 if ((pde & 1) != 0)
1823 {
1824 int i;
1825
1826 printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
1827 for (i = 0; i < 1024; i++)
1828 display_ptable_entry (get_pte (pde, i), 0, 0, 0);
1829 puts_filtered ("\n");
1830 }
1831 else if (force)
1832 printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
1833 }
1834
1835 static void
1836 go32_pte (char *arg, int from_tty)
1837 {
1838 long pde_idx = -1L, i;
1839
1840 if (arg && *arg)
1841 {
1842 while (*arg && isspace(*arg))
1843 arg++;
1844
1845 if (*arg)
1846 {
1847 pde_idx = parse_and_eval_long (arg);
1848 if (pde_idx < 0 || pde_idx >= 1024)
1849 error ("Entry %ld is outside valid limits [0..1023].", pde_idx);
1850 }
1851 }
1852
1853 pdbr = get_cr3 ();
1854 if (!pdbr)
1855 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1856 else if (pde_idx >= 0)
1857 display_page_table (pde_idx, 1);
1858 else
1859 for (i = 0; i < 1024; i++)
1860 display_page_table (i, 0);
1861 }
1862
1863 static void
1864 go32_pte_for_address (char *arg, int from_tty)
1865 {
1866 CORE_ADDR addr = 0, i;
1867
1868 if (arg && *arg)
1869 {
1870 while (*arg && isspace(*arg))
1871 arg++;
1872
1873 if (*arg)
1874 addr = parse_and_eval_address (arg);
1875 }
1876 if (!addr)
1877 error_no_arg ("linear address");
1878
1879 pdbr = get_cr3 ();
1880 if (!pdbr)
1881 puts_filtered ("Access to Page Tables is not supported on this system.\n");
1882 else
1883 {
1884 int pde_idx = (addr >> 22) & 0x3ff;
1885 int pte_idx = (addr >> 12) & 0x3ff;
1886 unsigned offs = addr & 0xfff;
1887
1888 printf_filtered ("Page Table entry for address 0x%llx:\n",
1889 (unsigned long long)addr);
1890 display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
1891 }
1892 }
1893
1894 static struct cmd_list_element *info_dos_cmdlist = NULL;
1895
1896 static void
1897 go32_info_dos_command (char *args, int from_tty)
1898 {
1899 help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
1900 }
1901
1902 void
1903 _initialize_go32_nat (void)
1904 {
1905 init_go32_ops ();
1906 add_target (&go32_ops);
1907
1908 add_prefix_cmd ("dos", class_info, go32_info_dos_command,
1909 "Print information specific to DJGPP (aka MS-DOS) debugging.",
1910 &info_dos_cmdlist, "info dos ", 0, &infolist);
1911
1912 add_cmd ("sysinfo", class_info, go32_sysinfo,
1913 "Display information about the target system, including CPU, OS, DPMI, etc.",
1914 &info_dos_cmdlist);
1915 add_cmd ("ldt", class_info, go32_sldt,
1916 "Display entries in the LDT (Local Descriptor Table).\n"
1917 "Entry number (an expression) as an argument means display only that entry.",
1918 &info_dos_cmdlist);
1919 add_cmd ("gdt", class_info, go32_sgdt,
1920 "Display entries in the GDT (Global Descriptor Table).\n"
1921 "Entry number (an expression) as an argument means display only that entry.",
1922 &info_dos_cmdlist);
1923 add_cmd ("idt", class_info, go32_sidt,
1924 "Display entries in the IDT (Interrupt Descriptor Table).\n"
1925 "Entry number (an expression) as an argument means display only that entry.",
1926 &info_dos_cmdlist);
1927 add_cmd ("pde", class_info, go32_pde,
1928 "Display entries in the Page Directory.\n"
1929 "Entry number (an expression) as an argument means display only that entry.",
1930 &info_dos_cmdlist);
1931 add_cmd ("pte", class_info, go32_pte,
1932 "Display entries in Page Tables.\n"
1933 "Entry number (an expression) as an argument means display only entries\n"
1934 "from the Page Table pointed to by the specified Page Directory entry.",
1935 &info_dos_cmdlist);
1936 add_cmd ("address-pte", class_info, go32_pte_for_address,
1937 "Display a Page Table entry for a linear address.\n"
1938 "The address argument must be a linear address, after adding to\n"
1939 "it the base address of the appropriate segment.\n"
1940 "The base address of variables and functions in the debuggee's data\n"
1941 "or code segment is stored in the variable __djgpp_base_address,\n"
1942 "so use `__djgpp_base_address + (char *)&var' as the argument.\n"
1943 "For other segments, look up their base address in the output of\n"
1944 "the `info dos ldt' command.",
1945 &info_dos_cmdlist);
1946 }
1947
1948 pid_t
1949 tcgetpgrp (int fd)
1950 {
1951 if (isatty (fd))
1952 return SOME_PID;
1953 errno = ENOTTY;
1954 return -1;
1955 }
1956
1957 int
1958 tcsetpgrp (int fd, pid_t pgid)
1959 {
1960 if (isatty (fd) && pgid == SOME_PID)
1961 return 0;
1962 errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
1963 return -1;
1964 }
This page took 0.067686 seconds and 3 git commands to generate.