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