1 /* Native debugging support for Intel x86 running DJGPP. 2 Copyright (C) 1997-2023 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 "gdbsupport/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 *, target_wait_flags) 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 std::string 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 target_wait_flags 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 if (current_directory != NULL) 511 chdir (current_directory); 512 513 if (a_tss.tss_irqn == 0x21) 514 status->set_exited (a_tss.tss_eax & 0xff); 515 else 516 { 517 status->set_stopped (GDB_SIGNAL_UNKNOWN); 518 for (i = 0; sig_map[i].go32_sig != -1; i++) 519 { 520 if (a_tss.tss_irqn == sig_map[i].go32_sig) 521 { 522 #if __DJGPP_MINOR__ < 3 523 status->set_stopped (sig_map[i].gdb_sig); 524 if (status->sig () != GDB_SIGNAL_TRAP) 525 status->set_signalled (status->sig ()); 526 #else 527 status->set_stopped (sig_map[i].gdb_sig); 528 #endif 529 break; 530 } 531 } 532 } 533 return ptid_t (SOME_PID); 534 } 535 536 static void 537 fetch_register (struct regcache *regcache, int regno) 538 { 539 struct gdbarch *gdbarch = regcache->arch (); 540 if (regno < gdbarch_fp0_regnum (gdbarch)) 541 regcache->raw_supply (regno, 542 (char *) &a_tss + regno_mapping[regno].tss_ofs); 543 else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, 544 regno)) 545 i387_supply_fsave (regcache, regno, &npx); 546 else 547 internal_error (_("Invalid register no. %d in fetch_register."), regno); 548 } 549 550 void 551 go32_nat_target::fetch_registers (struct regcache *regcache, int regno) 552 { 553 if (regno >= 0) 554 fetch_register (regcache, regno); 555 else 556 { 557 for (regno = 0; 558 regno < gdbarch_fp0_regnum (regcache->arch ()); 559 regno++) 560 fetch_register (regcache, regno); 561 i387_supply_fsave (regcache, -1, &npx); 562 } 563 } 564 565 static void 566 store_register (const struct regcache *regcache, int regno) 567 { 568 struct gdbarch *gdbarch = regcache->arch (); 569 if (regno < gdbarch_fp0_regnum (gdbarch)) 570 regcache->raw_collect (regno, 571 (char *) &a_tss + regno_mapping[regno].tss_ofs); 572 else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, 573 regno)) 574 i387_collect_fsave (regcache, regno, &npx); 575 else 576 internal_error (_("Invalid register no. %d in store_register."), regno); 577 } 578 579 void 580 go32_nat_target::store_registers (struct regcache *regcache, int regno) 581 { 582 unsigned r; 583 584 if (regno >= 0) 585 store_register (regcache, regno); 586 else 587 { 588 for (r = 0; r < gdbarch_fp0_regnum (regcache->arch ()); r++) 589 store_register (regcache, r); 590 i387_collect_fsave (regcache, -1, &npx); 591 } 592 } 593 594 /* Const-correct version of DJGPP's write_child, which unfortunately 595 takes a non-const buffer pointer. */ 596 597 static int 598 my_write_child (unsigned child_addr, const void *buf, unsigned len) 599 { 600 static void *buffer = NULL; 601 static unsigned buffer_len = 0; 602 int res; 603 604 if (buffer_len < len) 605 { 606 buffer = xrealloc (buffer, len); 607 buffer_len = len; 608 } 609 610 memcpy (buffer, buf, len); 611 res = write_child (child_addr, buffer, len); 612 return res; 613 } 614 615 /* Helper for go32_xfer_partial that handles memory transfers. 616 Arguments are like target_xfer_partial. */ 617 618 static enum target_xfer_status 619 go32_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf, 620 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len) 621 { 622 int res; 623 624 if (writebuf != NULL) 625 res = my_write_child (memaddr, writebuf, len); 626 else 627 res = read_child (memaddr, readbuf, len); 628 629 /* read_child and write_child return zero on success, non-zero on 630 failure. */ 631 if (res != 0) 632 return TARGET_XFER_E_IO; 633 634 *xfered_len = len; 635 return TARGET_XFER_OK; 636 } 637 638 /* Target to_xfer_partial implementation. */ 639 640 enum target_xfer_status 641 go32_nat_target::xfer_partial (enum target_object object, 642 const char *annex, gdb_byte *readbuf, 643 const gdb_byte *writebuf, ULONGEST offset, 644 ULONGEST len, 645 ULONGEST *xfered_len) 646 { 647 switch (object) 648 { 649 case TARGET_OBJECT_MEMORY: 650 return go32_xfer_memory (readbuf, writebuf, offset, len, xfered_len); 651 652 default: 653 return this->beneath ()->xfer_partial (object, annex, 654 readbuf, writebuf, offset, len, 655 xfered_len); 656 } 657 } 658 659 static cmdline_t child_cmd; /* Parsed child's command line kept here. */ 660 661 void 662 go32_nat_target::files_info () 663 { 664 gdb_printf ("You are running a DJGPP V2 program.\n"); 665 } 666 667 void 668 go32_nat_target::kill_inferior () 669 { 670 mourn_inferior (); 671 } 672 673 void 674 go32_nat_target::create_inferior (const char *exec_file, 675 const std::string &allargs, 676 char **env, int from_tty) 677 { 678 extern char **environ; 679 jmp_buf start_state; 680 char *cmdline; 681 char **env_save = environ; 682 size_t cmdlen; 683 struct inferior *inf; 684 int result; 685 const char *args = allargs.c_str (); 686 687 /* If no exec file handed to us, get it from the exec-file command -- with 688 a good, common error message if none is specified. */ 689 if (exec_file == 0) 690 exec_file = get_exec_file (1); 691 692 resume_signal = -1; 693 resume_is_step = 0; 694 695 /* Initialize child's cwd as empty to be initialized when starting 696 the child. */ 697 *child_cwd = 0; 698 699 /* Init command line storage. */ 700 if (redir_debug_init (&child_cmd) == -1) 701 internal_error (_("Cannot allocate redirection storage: " 702 "not enough memory.\n")); 703 704 /* Parse the command line and create redirections. */ 705 if (strpbrk (args, "<>")) 706 { 707 if (redir_cmdline_parse (args, &child_cmd) == 0) 708 args = child_cmd.command; 709 else 710 error (_("Syntax error in command line.")); 711 } 712 else 713 child_cmd.command = xstrdup (args); 714 715 cmdlen = strlen (args); 716 /* v2loadimage passes command lines via DOS memory, so it cannot 717 possibly handle commands longer than 1MB. */ 718 if (cmdlen > 1024*1024) 719 error (_("Command line too long.")); 720 721 cmdline = (char *) xmalloc (cmdlen + 4); 722 strcpy (cmdline + 1, args); 723 /* If the command-line length fits into DOS 126-char limits, use the 724 DOS command tail format; otherwise, tell v2loadimage to pass it 725 through a buffer in conventional memory. */ 726 if (cmdlen < 127) 727 { 728 cmdline[0] = strlen (args); 729 cmdline[cmdlen + 1] = 13; 730 } 731 else 732 cmdline[0] = 0xff; /* Signal v2loadimage it's a long command. */ 733 734 environ = env; 735 736 result = v2loadimage (exec_file, cmdline, start_state); 737 738 environ = env_save; 739 xfree (cmdline); 740 741 if (result != 0) 742 error (_("Load failed for image %s"), exec_file); 743 744 edi_init (start_state); 745 #if __DJGPP_MINOR__ < 3 746 save_npx (); 747 #endif 748 749 inf = current_inferior (); 750 inferior_appeared (inf, SOME_PID); 751 752 if (!inf->target_is_pushed (this)) 753 inf->push_target (this); 754 755 thread_info *thr = add_thread_silent (ptid_t (SOME_PID)); 756 switch_to_thread (thr); 757 758 clear_proceed_status (0); 759 insert_breakpoints (); 760 prog_has_started = 1; 761 } 762 763 void 764 go32_nat_target::mourn_inferior () 765 { 766 redir_cmdline_delete (&child_cmd); 767 resume_signal = -1; 768 resume_is_step = 0; 769 770 cleanup_client (); 771 772 /* We need to make sure all the breakpoint enable bits in the DR7 773 register are reset when the inferior exits. Otherwise, if they 774 rerun the inferior, the uncleared bits may cause random SIGTRAPs, 775 failure to set more watchpoints, and other calamities. It would 776 be nice if GDB itself would take care to remove all breakpoints 777 at all times, but it doesn't, probably under an assumption that 778 the OS cleans up when the debuggee exits. */ 779 x86_cleanup_dregs (); 780 781 prog_has_started = 0; 782 783 generic_mourn_inferior (); 784 maybe_unpush_target (); 785 } 786 787 /* Hardware watchpoint support. */ 788 789 #define D_REGS edi.dr 790 #define CONTROL D_REGS[7] 791 #define STATUS D_REGS[6] 792 793 /* Pass the address ADDR to the inferior in the I'th debug register. 794 Here we just store the address in D_REGS, the watchpoint will be 795 actually set up when go32_wait runs the debuggee. */ 796 static void 797 go32_set_dr (int i, CORE_ADDR addr) 798 { 799 if (i < 0 || i > 3) 800 internal_error (_("Invalid register %d in go32_set_dr.\n"), i); 801 D_REGS[i] = addr; 802 } 803 804 /* Pass the value VAL to the inferior in the DR7 debug control 805 register. Here we just store the address in D_REGS, the watchpoint 806 will be actually set up when go32_wait runs the debuggee. */ 807 static void 808 go32_set_dr7 (unsigned long val) 809 { 810 CONTROL = val; 811 } 812 813 /* Get the value of the DR6 debug status register from the inferior. 814 Here we just return the value stored in D_REGS, as we've got it 815 from the last go32_wait call. */ 816 static unsigned long 817 go32_get_dr6 (void) 818 { 819 return STATUS; 820 } 821 822 /* Get the value of the DR7 debug status register from the inferior. 823 Here we just return the value stored in D_REGS, as we've got it 824 from the last go32_wait call. */ 825 826 static unsigned long 827 go32_get_dr7 (void) 828 { 829 return CONTROL; 830 } 831 832 /* Get the value of the DR debug register I from the inferior. Here 833 we just return the value stored in D_REGS, as we've got it from the 834 last go32_wait call. */ 835 836 static CORE_ADDR 837 go32_get_dr (int i) 838 { 839 if (i < 0 || i > 3) 840 internal_error (_("Invalid register %d in go32_get_dr.\n"), i); 841 return D_REGS[i]; 842 } 843 844 /* Put the device open on handle FD into either raw or cooked 845 mode, return 1 if it was in raw mode, zero otherwise. */ 846 847 static int 848 device_mode (int fd, int raw_p) 849 { 850 int oldmode, newmode; 851 __dpmi_regs regs; 852 853 regs.x.ax = 0x4400; 854 regs.x.bx = fd; 855 __dpmi_int (0x21, ®s); 856 if (regs.x.flags & 1) 857 return -1; 858 newmode = oldmode = regs.x.dx; 859 860 if (raw_p) 861 newmode |= 0x20; 862 else 863 newmode &= ~0x20; 864 865 if (oldmode & 0x80) /* Only for character dev. */ 866 { 867 regs.x.ax = 0x4401; 868 regs.x.bx = fd; 869 regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails. */ 870 __dpmi_int (0x21, ®s); 871 if (regs.x.flags & 1) 872 return -1; 873 } 874 return (oldmode & 0x20) == 0x20; 875 } 876 877 878 static int inf_mode_valid = 0; 879 static int inf_terminal_mode; 880 881 /* This semaphore is needed because, amazingly enough, GDB calls 882 target.to_terminal_ours more than once after the inferior stops. 883 But we need the information from the first call only, since the 884 second call will always see GDB's own cooked terminal. */ 885 static int terminal_is_ours = 1; 886 887 void 888 go32_nat_target::terminal_init () 889 { 890 inf_mode_valid = 0; /* Reinitialize, in case they are restarting child. */ 891 terminal_is_ours = 1; 892 } 893 894 void 895 go32_nat_target::terminal_info (const char *args, int from_tty) 896 { 897 gdb_printf ("Inferior's terminal is in %s mode.\n", 898 !inf_mode_valid 899 ? "default" : inf_terminal_mode ? "raw" : "cooked"); 900 901 #if __DJGPP_MINOR__ > 2 902 if (child_cmd.redirection) 903 { 904 int i; 905 906 for (i = 0; i < DBG_HANDLES; i++) 907 { 908 if (child_cmd.redirection[i]->file_name) 909 gdb_printf ("\tFile handle %d is redirected to `%s'.\n", 910 i, child_cmd.redirection[i]->file_name); 911 else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1) 912 gdb_printf 913 ("\tFile handle %d appears to be closed by inferior.\n", i); 914 /* Mask off the raw/cooked bit when comparing device info words. */ 915 else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf) 916 != (_get_dev_info (i) & 0xdf)) 917 gdb_printf 918 ("\tFile handle %d appears to be redirected by inferior.\n", i); 919 } 920 } 921 #endif 922 } 923 924 void 925 go32_nat_target::terminal_inferior () 926 { 927 /* Redirect standard handles as child wants them. */ 928 errno = 0; 929 if (redir_to_child (&child_cmd) == -1) 930 { 931 redir_to_debugger (&child_cmd); 932 error (_("Cannot redirect standard handles for program: %s."), 933 safe_strerror (errno)); 934 } 935 /* Set the console device of the inferior to whatever mode 936 (raw or cooked) we found it last time. */ 937 if (terminal_is_ours) 938 { 939 if (inf_mode_valid) 940 device_mode (0, inf_terminal_mode); 941 terminal_is_ours = 0; 942 } 943 } 944 945 void 946 go32_nat_target::terminal_ours () 947 { 948 /* Switch to cooked mode on the gdb terminal and save the inferior 949 terminal mode to be restored when it is resumed. */ 950 if (!terminal_is_ours) 951 { 952 inf_terminal_mode = device_mode (0, 0); 953 if (inf_terminal_mode != -1) 954 inf_mode_valid = 1; 955 else 956 /* If device_mode returned -1, we don't know what happens with 957 handle 0 anymore, so make the info invalid. */ 958 inf_mode_valid = 0; 959 terminal_is_ours = 1; 960 961 /* Restore debugger's standard handles. */ 962 errno = 0; 963 if (redir_to_debugger (&child_cmd) == -1) 964 { 965 redir_to_child (&child_cmd); 966 error (_("Cannot redirect standard handles for debugger: %s."), 967 safe_strerror (errno)); 968 } 969 } 970 } 971 972 void 973 go32_nat_target::pass_ctrlc () 974 { 975 } 976 977 bool 978 go32_nat_target::thread_alive (ptid_t ptid) 979 { 980 return ptid != null_ptid; 981 } 982 983 std::string 984 go32_nat_target::pid_to_str (ptid_t ptid) 985 { 986 return normal_pid_to_str (ptid); 987 } 988 989 /* Return the current DOS codepage number. */ 990 static int 991 dos_codepage (void) 992 { 993 __dpmi_regs regs; 994 995 regs.x.ax = 0x6601; 996 __dpmi_int (0x21, ®s); 997 if (!(regs.x.flags & 1)) 998 return regs.x.bx & 0xffff; 999 else 1000 return 437; /* default */ 1001 } 1002 1003 /* Limited emulation of `nl_langinfo', for charset.c. */ 1004 char * 1005 nl_langinfo (nl_item item) 1006 { 1007 char *retval; 1008 1009 switch (item) 1010 { 1011 case CODESET: 1012 { 1013 /* 8 is enough for SHORT_MAX + "CP" + null. */ 1014 char buf[8]; 1015 int blen = sizeof (buf); 1016 int needed = snprintf (buf, blen, "CP%d", dos_codepage ()); 1017 1018 if (needed > blen) /* Should never happen. */ 1019 buf[0] = 0; 1020 retval = xstrdup (buf); 1021 } 1022 break; 1023 default: 1024 retval = xstrdup (""); 1025 break; 1026 } 1027 return retval; 1028 } 1029 1030 unsigned short windows_major, windows_minor; 1031 1032 /* Compute the version Windows reports via Int 2Fh/AX=1600h. */ 1033 static void 1034 go32_get_windows_version(void) 1035 { 1036 __dpmi_regs r; 1037 1038 r.x.ax = 0x1600; 1039 __dpmi_int(0x2f, &r); 1040 if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff 1041 && (r.h.al > 3 || r.h.ah > 0)) 1042 { 1043 windows_major = r.h.al; 1044 windows_minor = r.h.ah; 1045 } 1046 else 1047 windows_major = 0xff; /* meaning no Windows */ 1048 } 1049 1050 /* A subroutine of go32_sysinfo to display memory info. */ 1051 static void 1052 print_mem (unsigned long datum, const char *header, int in_pages_p) 1053 { 1054 if (datum != 0xffffffffUL) 1055 { 1056 if (in_pages_p) 1057 datum <<= 12; 1058 gdb_puts (header); 1059 if (datum > 1024) 1060 { 1061 gdb_printf ("%lu KB", datum >> 10); 1062 if (datum > 1024 * 1024) 1063 gdb_printf (" (%lu MB)", datum >> 20); 1064 } 1065 else 1066 gdb_printf ("%lu Bytes", datum); 1067 gdb_puts ("\n"); 1068 } 1069 } 1070 1071 /* Display assorted information about the underlying OS. */ 1072 static void 1073 go32_sysinfo (const char *arg, int from_tty) 1074 { 1075 static const char test_pattern[] = 1076 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf" 1077 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf" 1078 "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"; 1079 struct utsname u; 1080 char cpuid_vendor[13]; 1081 unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx; 1082 unsigned true_dos_version = _get_dos_version (1); 1083 unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor; 1084 int dpmi_flags; 1085 char dpmi_vendor_info[129]; 1086 int dpmi_vendor_available; 1087 __dpmi_version_ret dpmi_version_data; 1088 long eflags; 1089 __dpmi_free_mem_info mem_info; 1090 __dpmi_regs regs; 1091 1092 cpuid_vendor[0] = '\0'; 1093 if (uname (&u)) 1094 strcpy (u.machine, "Unknown x86"); 1095 else if (u.machine[0] == 'i' && u.machine[1] > 4) 1096 { 1097 /* CPUID with EAX = 0 returns the Vendor ID. */ 1098 #if 0 1099 /* Ideally we would use x86_cpuid(), but it needs someone to run 1100 native tests first to make sure things actually work. They should. 1101 http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html */ 1102 unsigned int eax, ebx, ecx, edx; 1103 1104 if (x86_cpuid (0, &eax, &ebx, &ecx, &edx)) 1105 { 1106 cpuid_max = eax; 1107 memcpy (&vendor[0], &ebx, 4); 1108 memcpy (&vendor[4], &ecx, 4); 1109 memcpy (&vendor[8], &edx, 4); 1110 cpuid_vendor[12] = '\0'; 1111 } 1112 #else 1113 __asm__ __volatile__ ("xorl %%ebx, %%ebx;" 1114 "xorl %%ecx, %%ecx;" 1115 "xorl %%edx, %%edx;" 1116 "movl $0, %%eax;" 1117 "cpuid;" 1118 "movl %%ebx, %0;" 1119 "movl %%edx, %1;" 1120 "movl %%ecx, %2;" 1121 "movl %%eax, %3;" 1122 : "=m" (cpuid_vendor[0]), 1123 "=m" (cpuid_vendor[4]), 1124 "=m" (cpuid_vendor[8]), 1125 "=m" (cpuid_max) 1126 : 1127 : "%eax", "%ebx", "%ecx", "%edx"); 1128 cpuid_vendor[12] = '\0'; 1129 #endif 1130 } 1131 1132 gdb_printf ("CPU Type.......................%s", u.machine); 1133 if (cpuid_vendor[0]) 1134 gdb_printf (" (%s)", cpuid_vendor); 1135 gdb_puts ("\n"); 1136 1137 /* CPUID with EAX = 1 returns processor signature and features. */ 1138 if (cpuid_max >= 1) 1139 { 1140 static const char *brand_name[] = { 1141 "", 1142 " Celeron", 1143 " III", 1144 " III Xeon", 1145 "", "", "", "", 1146 " 4" 1147 }; 1148 char cpu_string[80]; 1149 char cpu_brand[20]; 1150 unsigned brand_idx; 1151 int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0; 1152 int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0; 1153 int hygon_p = strcmp (cpuid_vendor, "HygonGenuine") == 0; 1154 unsigned cpu_family, cpu_model; 1155 1156 #if 0 1157 /* See comment above about cpuid usage. */ 1158 x86_cpuid (1, &cpuid_eax, &cpuid_ebx, NULL, &cpuid_edx); 1159 #else 1160 __asm__ __volatile__ ("movl $1, %%eax;" 1161 "cpuid;" 1162 : "=a" (cpuid_eax), 1163 "=b" (cpuid_ebx), 1164 "=d" (cpuid_edx) 1165 : 1166 : "%ecx"); 1167 #endif 1168 brand_idx = cpuid_ebx & 0xff; 1169 cpu_family = (cpuid_eax >> 8) & 0xf; 1170 cpu_model = (cpuid_eax >> 4) & 0xf; 1171 cpu_brand[0] = '\0'; 1172 if (intel_p) 1173 { 1174 if (brand_idx > 0 1175 && brand_idx < sizeof(brand_name)/sizeof(brand_name[0]) 1176 && *brand_name[brand_idx]) 1177 strcpy (cpu_brand, brand_name[brand_idx]); 1178 else if (cpu_family == 5) 1179 { 1180 if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4) 1181 strcpy (cpu_brand, " MMX"); 1182 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1) 1183 strcpy (cpu_brand, " OverDrive"); 1184 else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2) 1185 strcpy (cpu_brand, " Dual"); 1186 } 1187 else if (cpu_family == 6 && cpu_model < 8) 1188 { 1189 switch (cpu_model) 1190 { 1191 case 1: 1192 strcpy (cpu_brand, " Pro"); 1193 break; 1194 case 3: 1195 strcpy (cpu_brand, " II"); 1196 break; 1197 case 5: 1198 strcpy (cpu_brand, " II Xeon"); 1199 break; 1200 case 6: 1201 strcpy (cpu_brand, " Celeron"); 1202 break; 1203 case 7: 1204 strcpy (cpu_brand, " III"); 1205 break; 1206 } 1207 } 1208 } 1209 else if (amd_p) 1210 { 1211 switch (cpu_family) 1212 { 1213 case 4: 1214 strcpy (cpu_brand, "486/5x86"); 1215 break; 1216 case 5: 1217 switch (cpu_model) 1218 { 1219 case 0: 1220 case 1: 1221 case 2: 1222 case 3: 1223 strcpy (cpu_brand, "-K5"); 1224 break; 1225 case 6: 1226 case 7: 1227 strcpy (cpu_brand, "-K6"); 1228 break; 1229 case 8: 1230 strcpy (cpu_brand, "-K6-2"); 1231 break; 1232 case 9: 1233 strcpy (cpu_brand, "-K6-III"); 1234 break; 1235 } 1236 break; 1237 case 6: 1238 switch (cpu_model) 1239 { 1240 case 1: 1241 case 2: 1242 case 4: 1243 strcpy (cpu_brand, " Athlon"); 1244 break; 1245 case 3: 1246 strcpy (cpu_brand, " Duron"); 1247 break; 1248 } 1249 break; 1250 } 1251 } 1252 xsnprintf (cpu_string, sizeof (cpu_string), "%s%s Model %d Stepping %d", 1253 intel_p ? "Pentium" : (amd_p ? "AMD" : (hygon_p ? "Hygon" : "ix86")), 1254 cpu_brand, cpu_model, cpuid_eax & 0xf); 1255 gdb_printf ("%*s%s\n", 31, "", cpu_string); 1256 if (((cpuid_edx & (6 | (0x0d << 23))) != 0) 1257 || ((cpuid_edx & 1) == 0) 1258 || ((amd_p || hygon_p) && (cpuid_edx & (3 << 30)) != 0)) 1259 { 1260 gdb_puts ("CPU Features..................."); 1261 /* We only list features which might be useful in the DPMI 1262 environment. */ 1263 if ((cpuid_edx & 1) == 0) 1264 gdb_puts ("No FPU "); /* It's unusual to not have an FPU. */ 1265 if ((cpuid_edx & (1 << 1)) != 0) 1266 gdb_puts ("VME "); 1267 if ((cpuid_edx & (1 << 2)) != 0) 1268 gdb_puts ("DE "); 1269 if ((cpuid_edx & (1 << 4)) != 0) 1270 gdb_puts ("TSC "); 1271 if ((cpuid_edx & (1 << 23)) != 0) 1272 gdb_puts ("MMX "); 1273 if ((cpuid_edx & (1 << 25)) != 0) 1274 gdb_puts ("SSE "); 1275 if ((cpuid_edx & (1 << 26)) != 0) 1276 gdb_puts ("SSE2 "); 1277 if (amd_p || hygon_p) 1278 { 1279 if ((cpuid_edx & (1 << 31)) != 0) 1280 gdb_puts ("3DNow! "); 1281 if ((cpuid_edx & (1 << 30)) != 0) 1282 gdb_puts ("3DNow!Ext"); 1283 } 1284 gdb_puts ("\n"); 1285 } 1286 } 1287 gdb_puts ("\n"); 1288 gdb_printf ("DOS Version....................%s %s.%s", 1289 _os_flavor, u.release, u.version); 1290 if (true_dos_version != advertized_dos_version) 1291 gdb_printf (" (disguised as v%d.%d)", _osmajor, _osminor); 1292 gdb_puts ("\n"); 1293 if (!windows_major) 1294 go32_get_windows_version (); 1295 if (windows_major != 0xff) 1296 { 1297 const char *windows_flavor; 1298 1299 gdb_printf ("Windows Version................%d.%02d (Windows ", 1300 windows_major, windows_minor); 1301 switch (windows_major) 1302 { 1303 case 3: 1304 windows_flavor = "3.X"; 1305 break; 1306 case 4: 1307 switch (windows_minor) 1308 { 1309 case 0: 1310 windows_flavor = "95, 95A, or 95B"; 1311 break; 1312 case 3: 1313 windows_flavor = "95B OSR2.1 or 95C OSR2.5"; 1314 break; 1315 case 10: 1316 windows_flavor = "98 or 98 SE"; 1317 break; 1318 case 90: 1319 windows_flavor = "ME"; 1320 break; 1321 default: 1322 windows_flavor = "9X"; 1323 break; 1324 } 1325 break; 1326 default: 1327 windows_flavor = "??"; 1328 break; 1329 } 1330 gdb_printf ("%s)\n", windows_flavor); 1331 } 1332 else if (true_dos_version == 0x532 && advertized_dos_version == 0x500) 1333 gdb_printf ("Windows Version................" 1334 "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n"); 1335 gdb_puts ("\n"); 1336 /* On some versions of Windows, __dpmi_get_capabilities returns 1337 zero, but the buffer is not filled with info, so we fill the 1338 buffer with a known pattern and test for it afterwards. */ 1339 memcpy (dpmi_vendor_info, test_pattern, sizeof(dpmi_vendor_info)); 1340 dpmi_vendor_available = 1341 __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info); 1342 if (dpmi_vendor_available == 0 1343 && memcmp (dpmi_vendor_info, test_pattern, 1344 sizeof(dpmi_vendor_info)) != 0) 1345 { 1346 /* The DPMI spec says the vendor string should be ASCIIZ, but 1347 I don't trust the vendors to follow that... */ 1348 if (!memchr (&dpmi_vendor_info[2], 0, 126)) 1349 dpmi_vendor_info[128] = '\0'; 1350 gdb_printf ("DPMI Host......................" 1351 "%s v%d.%d (capabilities: %#x)\n", 1352 &dpmi_vendor_info[2], 1353 (unsigned)dpmi_vendor_info[0], 1354 (unsigned)dpmi_vendor_info[1], 1355 ((unsigned)dpmi_flags & 0x7f)); 1356 } 1357 else 1358 gdb_printf ("DPMI Host......................(Info not available)\n"); 1359 __dpmi_get_version (&dpmi_version_data); 1360 gdb_printf ("DPMI Version...................%d.%02d\n", 1361 dpmi_version_data.major, dpmi_version_data.minor); 1362 gdb_printf ("DPMI Info......................" 1363 "%s-bit DPMI, with%s Virtual Memory support\n", 1364 (dpmi_version_data.flags & 1) ? "32" : "16", 1365 (dpmi_version_data.flags & 4) ? "" : "out"); 1366 gdb_printf ("%*sInterrupts reflected to %s mode\n", 31, "", 1367 (dpmi_version_data.flags & 2) ? "V86" : "Real"); 1368 gdb_printf ("%*sProcessor type: i%d86\n", 31, "", 1369 dpmi_version_data.cpu); 1370 gdb_printf ("%*sPIC base interrupt: Master: %#x Slave: %#x\n", 31, "", 1371 dpmi_version_data.master_pic, dpmi_version_data.slave_pic); 1372 1373 /* a_tss is only initialized when the debuggee is first run. */ 1374 if (prog_has_started) 1375 { 1376 __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags)); 1377 gdb_printf ("Protection....................." 1378 "Ring %d (in %s), with%s I/O protection\n", 1379 a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT", 1380 (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out"); 1381 } 1382 gdb_puts ("\n"); 1383 __dpmi_get_free_memory_information (&mem_info); 1384 print_mem (mem_info.total_number_of_physical_pages, 1385 "DPMI Total Physical Memory.....", 1); 1386 print_mem (mem_info.total_number_of_free_pages, 1387 "DPMI Free Physical Memory......", 1); 1388 print_mem (mem_info.size_of_paging_file_partition_in_pages, 1389 "DPMI Swap Space................", 1); 1390 print_mem (mem_info.linear_address_space_size_in_pages, 1391 "DPMI Total Linear Address Size.", 1); 1392 print_mem (mem_info.free_linear_address_space_in_pages, 1393 "DPMI Free Linear Address Size..", 1); 1394 print_mem (mem_info.largest_available_free_block_in_bytes, 1395 "DPMI Largest Free Memory Block.", 0); 1396 1397 regs.h.ah = 0x48; 1398 regs.x.bx = 0xffff; 1399 __dpmi_int (0x21, ®s); 1400 print_mem (regs.x.bx << 4, "Free DOS Memory................", 0); 1401 regs.x.ax = 0x5800; 1402 __dpmi_int (0x21, ®s); 1403 if ((regs.x.flags & 1) == 0) 1404 { 1405 static const char *dos_hilo[] = { 1406 "Low", "", "", "", "High", "", "", "", "High, then Low" 1407 }; 1408 static const char *dos_fit[] = { 1409 "First", "Best", "Last" 1410 }; 1411 int hilo_idx = (regs.x.ax >> 4) & 0x0f; 1412 int fit_idx = regs.x.ax & 0x0f; 1413 1414 if (hilo_idx > 8) 1415 hilo_idx = 0; 1416 if (fit_idx > 2) 1417 fit_idx = 0; 1418 gdb_printf ("DOS Memory Allocation..........%s memory, %s fit\n", 1419 dos_hilo[hilo_idx], dos_fit[fit_idx]); 1420 regs.x.ax = 0x5802; 1421 __dpmi_int (0x21, ®s); 1422 if ((regs.x.flags & 1) != 0) 1423 regs.h.al = 0; 1424 gdb_printf ("%*sUMBs %sin DOS memory chain\n", 31, "", 1425 regs.h.al == 0 ? "not " : ""); 1426 } 1427 } 1428 1429 struct seg_descr { 1430 unsigned short limit0; 1431 unsigned short base0; 1432 unsigned char base1; 1433 unsigned stype:5; 1434 unsigned dpl:2; 1435 unsigned present:1; 1436 unsigned limit1:4; 1437 unsigned available:1; 1438 unsigned dummy:1; 1439 unsigned bit32:1; 1440 unsigned page_granular:1; 1441 unsigned char base2; 1442 } __attribute__ ((packed)); 1443 1444 struct gate_descr { 1445 unsigned short offset0; 1446 unsigned short selector; 1447 unsigned param_count:5; 1448 unsigned dummy:3; 1449 unsigned stype:5; 1450 unsigned dpl:2; 1451 unsigned present:1; 1452 unsigned short offset1; 1453 } __attribute__ ((packed)); 1454 1455 /* Read LEN bytes starting at logical address ADDR, and put the result 1456 into DEST. Return 1 if success, zero if not. */ 1457 static int 1458 read_memory_region (unsigned long addr, void *dest, size_t len) 1459 { 1460 unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds); 1461 int retval = 1; 1462 1463 /* For the low memory, we can simply use _dos_ds. */ 1464 if (addr <= dos_ds_limit - len) 1465 dosmemget (addr, len, dest); 1466 else 1467 { 1468 /* For memory above 1MB we need to set up a special segment to 1469 be able to access that memory. */ 1470 int sel = __dpmi_allocate_ldt_descriptors (1); 1471 1472 if (sel <= 0) 1473 retval = 0; 1474 else 1475 { 1476 int access_rights = __dpmi_get_descriptor_access_rights (sel); 1477 size_t segment_limit = len - 1; 1478 1479 /* Make sure the crucial bits in the descriptor access 1480 rights are set correctly. Some DPMI providers might barf 1481 if we set the segment limit to something that is not an 1482 integral multiple of 4KB pages if the granularity bit is 1483 not set to byte-granular, even though the DPMI spec says 1484 it's the host's responsibility to set that bit correctly. */ 1485 if (len > 1024 * 1024) 1486 { 1487 access_rights |= 0x8000; 1488 /* Page-granular segments should have the low 12 bits of 1489 the limit set. */ 1490 segment_limit |= 0xfff; 1491 } 1492 else 1493 access_rights &= ~0x8000; 1494 1495 if (__dpmi_set_segment_base_address (sel, addr) != -1 1496 && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1 1497 && __dpmi_set_segment_limit (sel, segment_limit) != -1 1498 /* W2K silently fails to set the segment limit, leaving 1499 it at zero; this test avoids the resulting crash. */ 1500 && __dpmi_get_segment_limit (sel) >= segment_limit) 1501 movedata (sel, 0, _my_ds (), (unsigned)dest, len); 1502 else 1503 retval = 0; 1504 1505 __dpmi_free_ldt_descriptor (sel); 1506 } 1507 } 1508 return retval; 1509 } 1510 1511 /* Get a segment descriptor stored at index IDX in the descriptor 1512 table whose base address is TABLE_BASE. Return the descriptor 1513 type, or -1 if failure. */ 1514 static int 1515 get_descriptor (unsigned long table_base, int idx, void *descr) 1516 { 1517 unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */ 1518 1519 if (read_memory_region (addr, descr, 8)) 1520 return (int)((struct seg_descr *)descr)->stype; 1521 return -1; 1522 } 1523 1524 struct dtr_reg { 1525 unsigned short limit __attribute__((packed)); 1526 unsigned long base __attribute__((packed)); 1527 }; 1528 1529 /* Display a segment descriptor stored at index IDX in a descriptor 1530 table whose type is TYPE and whose base address is BASE_ADDR. If 1531 FORCE is non-zero, display even invalid descriptors. */ 1532 static void 1533 display_descriptor (unsigned type, unsigned long base_addr, int idx, int force) 1534 { 1535 struct seg_descr descr; 1536 struct gate_descr gate; 1537 1538 /* Get the descriptor from the table. */ 1539 if (idx == 0 && type == 0) 1540 gdb_puts ("0x000: null descriptor\n"); 1541 else if (get_descriptor (base_addr, idx, &descr) != -1) 1542 { 1543 /* For each type of descriptor table, this has a bit set if the 1544 corresponding type of selectors is valid in that table. */ 1545 static unsigned allowed_descriptors[] = { 1546 0xffffdafeL, /* GDT */ 1547 0x0000c0e0L, /* IDT */ 1548 0xffffdafaL /* LDT */ 1549 }; 1550 1551 /* If the program hasn't started yet, assume the debuggee will 1552 have the same CPL as the debugger. */ 1553 int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3; 1554 unsigned long limit = (descr.limit1 << 16) | descr.limit0; 1555 1556 if (descr.present 1557 && (allowed_descriptors[type] & (1 << descr.stype)) != 0) 1558 { 1559 gdb_printf ("0x%03x: ", 1560 type == 1 1561 ? idx : (idx * 8) | (type ? (cpl | 4) : 0)); 1562 if (descr.page_granular) 1563 limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */ 1564 if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3 1565 || descr.stype == 9 || descr.stype == 11 1566 || (descr.stype >= 16 && descr.stype < 32)) 1567 gdb_printf ("base=0x%02x%02x%04x limit=0x%08lx", 1568 descr.base2, descr.base1, descr.base0, limit); 1569 1570 switch (descr.stype) 1571 { 1572 case 1: 1573 case 3: 1574 gdb_printf (" 16-bit TSS (task %sactive)", 1575 descr.stype == 3 ? "" : "in"); 1576 break; 1577 case 2: 1578 gdb_puts (" LDT"); 1579 break; 1580 case 4: 1581 memcpy (&gate, &descr, sizeof gate); 1582 gdb_printf ("selector=0x%04x offs=0x%04x%04x", 1583 gate.selector, gate.offset1, gate.offset0); 1584 gdb_printf (" 16-bit Call Gate (params=%d)", 1585 gate.param_count); 1586 break; 1587 case 5: 1588 gdb_printf ("TSS selector=0x%04x", descr.base0); 1589 gdb_printf ("%*sTask Gate", 16, ""); 1590 break; 1591 case 6: 1592 case 7: 1593 memcpy (&gate, &descr, sizeof gate); 1594 gdb_printf ("selector=0x%04x offs=0x%04x%04x", 1595 gate.selector, gate.offset1, gate.offset0); 1596 gdb_printf (" 16-bit %s Gate", 1597 descr.stype == 6 ? "Interrupt" : "Trap"); 1598 break; 1599 case 9: 1600 case 11: 1601 gdb_printf (" 32-bit TSS (task %sactive)", 1602 descr.stype == 3 ? "" : "in"); 1603 break; 1604 case 12: 1605 memcpy (&gate, &descr, sizeof gate); 1606 gdb_printf ("selector=0x%04x offs=0x%04x%04x", 1607 gate.selector, gate.offset1, gate.offset0); 1608 gdb_printf (" 32-bit Call Gate (params=%d)", 1609 gate.param_count); 1610 break; 1611 case 14: 1612 case 15: 1613 memcpy (&gate, &descr, sizeof gate); 1614 gdb_printf ("selector=0x%04x offs=0x%04x%04x", 1615 gate.selector, gate.offset1, gate.offset0); 1616 gdb_printf (" 32-bit %s Gate", 1617 descr.stype == 14 ? "Interrupt" : "Trap"); 1618 break; 1619 case 16: /* data segments */ 1620 case 17: 1621 case 18: 1622 case 19: 1623 case 20: 1624 case 21: 1625 case 22: 1626 case 23: 1627 gdb_printf (" %s-bit Data (%s Exp-%s%s)", 1628 descr.bit32 ? "32" : "16", 1629 descr.stype & 2 1630 ? "Read/Write," : "Read-Only, ", 1631 descr.stype & 4 ? "down" : "up", 1632 descr.stype & 1 ? "" : ", N.Acc"); 1633 break; 1634 case 24: /* code segments */ 1635 case 25: 1636 case 26: 1637 case 27: 1638 case 28: 1639 case 29: 1640 case 30: 1641 case 31: 1642 gdb_printf (" %s-bit Code (%s, %sConf%s)", 1643 descr.bit32 ? "32" : "16", 1644 descr.stype & 2 ? "Exec/Read" : "Exec-Only", 1645 descr.stype & 4 ? "" : "N.", 1646 descr.stype & 1 ? "" : ", N.Acc"); 1647 break; 1648 default: 1649 gdb_printf ("Unknown type 0x%02x", descr.stype); 1650 break; 1651 } 1652 gdb_puts ("\n"); 1653 } 1654 else if (force) 1655 { 1656 gdb_printf ("0x%03x: ", 1657 type == 1 1658 ? idx : (idx * 8) | (type ? (cpl | 4) : 0)); 1659 if (!descr.present) 1660 gdb_puts ("Segment not present\n"); 1661 else 1662 gdb_printf ("Segment type 0x%02x is invalid in this table\n", 1663 descr.stype); 1664 } 1665 } 1666 else if (force) 1667 gdb_printf ("0x%03x: Cannot read this descriptor\n", idx); 1668 } 1669 1670 static void 1671 go32_sldt (const char *arg, int from_tty) 1672 { 1673 struct dtr_reg gdtr; 1674 unsigned short ldtr = 0; 1675 int ldt_idx; 1676 struct seg_descr ldt_descr; 1677 long ldt_entry = -1L; 1678 int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3; 1679 1680 if (arg && *arg) 1681 { 1682 arg = skip_spaces (arg); 1683 1684 if (*arg) 1685 { 1686 ldt_entry = parse_and_eval_long (arg); 1687 if (ldt_entry < 0 1688 || (ldt_entry & 4) == 0 1689 || (ldt_entry & 3) != (cpl & 3)) 1690 error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry); 1691 } 1692 } 1693 1694 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ ); 1695 __asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ ); 1696 ldt_idx = ldtr / 8; 1697 if (ldt_idx == 0) 1698 gdb_puts ("There is no LDT.\n"); 1699 /* LDT's entry in the GDT must have the type LDT, which is 2. */ 1700 else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2) 1701 gdb_printf ("LDT is present (at %#x), but unreadable by GDB.\n", 1702 ldt_descr.base0 1703 | (ldt_descr.base1 << 16) 1704 | (ldt_descr.base2 << 24)); 1705 else 1706 { 1707 unsigned base = 1708 ldt_descr.base0 1709 | (ldt_descr.base1 << 16) 1710 | (ldt_descr.base2 << 24); 1711 unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16); 1712 int max_entry; 1713 1714 if (ldt_descr.page_granular) 1715 /* Page-granular segments must have the low 12 bits of their 1716 limit set. */ 1717 limit = (limit << 12) | 0xfff; 1718 /* LDT cannot have more than 8K 8-byte entries, i.e. more than 1719 64KB. */ 1720 if (limit > 0xffff) 1721 limit = 0xffff; 1722 1723 max_entry = (limit + 1) / 8; 1724 1725 if (ldt_entry >= 0) 1726 { 1727 if (ldt_entry > limit) 1728 error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"), 1729 (unsigned long)ldt_entry, limit); 1730 1731 display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1); 1732 } 1733 else 1734 { 1735 int i; 1736 1737 for (i = 0; i < max_entry; i++) 1738 display_descriptor (ldt_descr.stype, base, i, 0); 1739 } 1740 } 1741 } 1742 1743 static void 1744 go32_sgdt (const char *arg, int from_tty) 1745 { 1746 struct dtr_reg gdtr; 1747 long gdt_entry = -1L; 1748 int max_entry; 1749 1750 if (arg && *arg) 1751 { 1752 arg = skip_spaces (arg); 1753 1754 if (*arg) 1755 { 1756 gdt_entry = parse_and_eval_long (arg); 1757 if (gdt_entry < 0 || (gdt_entry & 7) != 0) 1758 error (_("Invalid GDT entry 0x%03lx: " 1759 "not an integral multiple of 8."), 1760 (unsigned long)gdt_entry); 1761 } 1762 } 1763 1764 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ ); 1765 max_entry = (gdtr.limit + 1) / 8; 1766 1767 if (gdt_entry >= 0) 1768 { 1769 if (gdt_entry > gdtr.limit) 1770 error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"), 1771 (unsigned long)gdt_entry, gdtr.limit); 1772 1773 display_descriptor (0, gdtr.base, gdt_entry / 8, 1); 1774 } 1775 else 1776 { 1777 int i; 1778 1779 for (i = 0; i < max_entry; i++) 1780 display_descriptor (0, gdtr.base, i, 0); 1781 } 1782 } 1783 1784 static void 1785 go32_sidt (const char *arg, int from_tty) 1786 { 1787 struct dtr_reg idtr; 1788 long idt_entry = -1L; 1789 int max_entry; 1790 1791 if (arg && *arg) 1792 { 1793 arg = skip_spaces (arg); 1794 1795 if (*arg) 1796 { 1797 idt_entry = parse_and_eval_long (arg); 1798 if (idt_entry < 0) 1799 error (_("Invalid (negative) IDT entry %ld."), idt_entry); 1800 } 1801 } 1802 1803 __asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ ); 1804 max_entry = (idtr.limit + 1) / 8; 1805 if (max_entry > 0x100) /* No more than 256 entries. */ 1806 max_entry = 0x100; 1807 1808 if (idt_entry >= 0) 1809 { 1810 if (idt_entry > idtr.limit) 1811 error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"), 1812 (unsigned long)idt_entry, idtr.limit); 1813 1814 display_descriptor (1, idtr.base, idt_entry, 1); 1815 } 1816 else 1817 { 1818 int i; 1819 1820 for (i = 0; i < max_entry; i++) 1821 display_descriptor (1, idtr.base, i, 0); 1822 } 1823 } 1824 1825 /* Cached linear address of the base of the page directory. For 1826 now, available only under CWSDPMI. Code based on ideas and 1827 suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */ 1828 static unsigned long pdbr; 1829 1830 static unsigned long 1831 get_cr3 (void) 1832 { 1833 unsigned offset; 1834 unsigned taskreg; 1835 unsigned long taskbase, cr3; 1836 struct dtr_reg gdtr; 1837 1838 if (pdbr > 0 && pdbr <= 0xfffff) 1839 return pdbr; 1840 1841 /* Get the linear address of GDT and the Task Register. */ 1842 __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ ); 1843 __asm__ __volatile__ ("str %0" : "=m" (taskreg) : /* no inputs */ ); 1844 1845 /* Task Register is a segment selector for the TSS of the current 1846 task. Therefore, it can be used as an index into the GDT to get 1847 at the segment descriptor for the TSS. To get the index, reset 1848 the low 3 bits of the selector (which give the CPL). Add 2 to the 1849 offset to point to the 3 low bytes of the base address. */ 1850 offset = gdtr.base + (taskreg & 0xfff8) + 2; 1851 1852 1853 /* CWSDPMI's task base is always under the 1MB mark. */ 1854 if (offset > 0xfffff) 1855 return 0; 1856 1857 _farsetsel (_dos_ds); 1858 taskbase = _farnspeekl (offset) & 0xffffffU; 1859 taskbase += _farnspeekl (offset + 2) & 0xff000000U; 1860 if (taskbase > 0xfffff) 1861 return 0; 1862 1863 /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at 1864 offset 1Ch in the TSS. */ 1865 cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff; 1866 if (cr3 > 0xfffff) 1867 { 1868 #if 0 /* Not fully supported yet. */ 1869 /* The Page Directory is in UMBs. In that case, CWSDPMI puts 1870 the first Page Table right below the Page Directory. Thus, 1871 the first Page Table's entry for its own address and the Page 1872 Directory entry for that Page Table will hold the same 1873 physical address. The loop below searches the entire UMB 1874 range of addresses for such an occurrence. */ 1875 unsigned long addr, pte_idx; 1876 1877 for (addr = 0xb0000, pte_idx = 0xb0; 1878 pte_idx < 0xff; 1879 addr += 0x1000, pte_idx++) 1880 { 1881 if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) == 1882 (_farnspeekl (addr + 0x1000) & 0xfffff027)) 1883 && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3)) 1884 { 1885 cr3 = addr + 0x1000; 1886 break; 1887 } 1888 } 1889 #endif 1890 1891 if (cr3 > 0xfffff) 1892 cr3 = 0; 1893 } 1894 1895 return cr3; 1896 } 1897 1898 /* Return the N'th Page Directory entry. */ 1899 static unsigned long 1900 get_pde (int n) 1901 { 1902 unsigned long pde = 0; 1903 1904 if (pdbr && n >= 0 && n < 1024) 1905 { 1906 pde = _farpeekl (_dos_ds, pdbr + 4*n); 1907 } 1908 return pde; 1909 } 1910 1911 /* Return the N'th entry of the Page Table whose Page Directory entry 1912 is PDE. */ 1913 static unsigned long 1914 get_pte (unsigned long pde, int n) 1915 { 1916 unsigned long pte = 0; 1917 1918 /* pde & 0x80 tests the 4MB page bit. We don't support 4MB 1919 page tables, for now. */ 1920 if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024) 1921 { 1922 pde &= ~0xfff; /* Clear non-address bits. */ 1923 pte = _farpeekl (_dos_ds, pde + 4*n); 1924 } 1925 return pte; 1926 } 1927 1928 /* Display a Page Directory or Page Table entry. IS_DIR, if non-zero, 1929 says this is a Page Directory entry. If FORCE is non-zero, display 1930 the entry even if its Present flag is off. OFF is the offset of the 1931 address from the page's base address. */ 1932 static void 1933 display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off) 1934 { 1935 if ((entry & 1) != 0) 1936 { 1937 gdb_printf ("Base=0x%05lx000", entry >> 12); 1938 if ((entry & 0x100) && !is_dir) 1939 gdb_puts (" Global"); 1940 if ((entry & 0x40) && !is_dir) 1941 gdb_puts (" Dirty"); 1942 gdb_printf (" %sAcc.", (entry & 0x20) ? "" : "Not-"); 1943 gdb_printf (" %sCached", (entry & 0x10) ? "" : "Not-"); 1944 gdb_printf (" Write-%s", (entry & 8) ? "Thru" : "Back"); 1945 gdb_printf (" %s", (entry & 4) ? "Usr" : "Sup"); 1946 gdb_printf (" Read-%s", (entry & 2) ? "Write" : "Only"); 1947 if (off) 1948 gdb_printf (" +0x%x", off); 1949 gdb_puts ("\n"); 1950 } 1951 else if (force) 1952 gdb_printf ("Page%s not present or not supported; value=0x%lx.\n", 1953 is_dir ? " Table" : "", entry >> 1); 1954 } 1955 1956 static void 1957 go32_pde (const char *arg, int from_tty) 1958 { 1959 long pde_idx = -1, i; 1960 1961 if (arg && *arg) 1962 { 1963 arg = skip_spaces (arg); 1964 1965 if (*arg) 1966 { 1967 pde_idx = parse_and_eval_long (arg); 1968 if (pde_idx < 0 || pde_idx >= 1024) 1969 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx); 1970 } 1971 } 1972 1973 pdbr = get_cr3 (); 1974 if (!pdbr) 1975 gdb_puts ("Access to Page Directories is " 1976 "not supported on this system.\n"); 1977 else if (pde_idx >= 0) 1978 display_ptable_entry (get_pde (pde_idx), 1, 1, 0); 1979 else 1980 for (i = 0; i < 1024; i++) 1981 display_ptable_entry (get_pde (i), 1, 0, 0); 1982 } 1983 1984 /* A helper function to display entries in a Page Table pointed to by 1985 the N'th entry in the Page Directory. If FORCE is non-zero, say 1986 something even if the Page Table is not accessible. */ 1987 static void 1988 display_page_table (long n, int force) 1989 { 1990 unsigned long pde = get_pde (n); 1991 1992 if ((pde & 1) != 0) 1993 { 1994 int i; 1995 1996 gdb_printf ("Page Table pointed to by " 1997 "Page Directory entry 0x%lx:\n", n); 1998 for (i = 0; i < 1024; i++) 1999 display_ptable_entry (get_pte (pde, i), 0, 0, 0); 2000 gdb_puts ("\n"); 2001 } 2002 else if (force) 2003 gdb_printf ("Page Table not present; value=0x%lx.\n", pde >> 1); 2004 } 2005 2006 static void 2007 go32_pte (const char *arg, int from_tty) 2008 { 2009 long pde_idx = -1L, i; 2010 2011 if (arg && *arg) 2012 { 2013 arg = skip_spaces (arg); 2014 2015 if (*arg) 2016 { 2017 pde_idx = parse_and_eval_long (arg); 2018 if (pde_idx < 0 || pde_idx >= 1024) 2019 error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx); 2020 } 2021 } 2022 2023 pdbr = get_cr3 (); 2024 if (!pdbr) 2025 gdb_puts ("Access to Page Tables is not supported on this system.\n"); 2026 else if (pde_idx >= 0) 2027 display_page_table (pde_idx, 1); 2028 else 2029 for (i = 0; i < 1024; i++) 2030 display_page_table (i, 0); 2031 } 2032 2033 static void 2034 go32_pte_for_address (const char *arg, int from_tty) 2035 { 2036 CORE_ADDR addr = 0, i; 2037 2038 if (arg && *arg) 2039 { 2040 arg = skip_spaces (arg); 2041 2042 if (*arg) 2043 addr = parse_and_eval_address (arg); 2044 } 2045 if (!addr) 2046 error_no_arg (_("linear address")); 2047 2048 pdbr = get_cr3 (); 2049 if (!pdbr) 2050 gdb_puts ("Access to Page Tables is not supported on this system.\n"); 2051 else 2052 { 2053 int pde_idx = (addr >> 22) & 0x3ff; 2054 int pte_idx = (addr >> 12) & 0x3ff; 2055 unsigned offs = addr & 0xfff; 2056 2057 gdb_printf ("Page Table entry for address %s:\n", 2058 hex_string(addr)); 2059 display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs); 2060 } 2061 } 2062 2063 static struct cmd_list_element *info_dos_cmdlist = NULL; 2064 2065 void _initialize_go32_nat (); 2066 void 2067 _initialize_go32_nat () 2068 { 2069 x86_dr_low.set_control = go32_set_dr7; 2070 x86_dr_low.set_addr = go32_set_dr; 2071 x86_dr_low.get_status = go32_get_dr6; 2072 x86_dr_low.get_control = go32_get_dr7; 2073 x86_dr_low.get_addr = go32_get_dr; 2074 x86_set_debug_register_length (4); 2075 2076 add_inf_child_target (&the_go32_nat_target); 2077 2078 /* Initialize child's cwd as empty to be initialized when starting 2079 the child. */ 2080 *child_cwd = 0; 2081 2082 /* Initialize child's command line storage. */ 2083 if (redir_debug_init (&child_cmd) == -1) 2084 internal_error (_("Cannot allocate redirection storage: " 2085 "not enough memory.\n")); 2086 2087 /* We are always processing GCC-compiled programs. */ 2088 processing_gcc_compilation = 2; 2089 2090 add_basic_prefix_cmd ("dos", class_info, _("\ 2091 Print information specific to DJGPP (aka MS-DOS) debugging."), 2092 &info_dos_cmdlist, 0, &infolist); 2093 2094 add_cmd ("sysinfo", class_info, go32_sysinfo, _("\ 2095 Display information about the target system, including CPU, OS, DPMI, etc."), 2096 &info_dos_cmdlist); 2097 add_cmd ("ldt", class_info, go32_sldt, _("\ 2098 Display entries in the LDT (Local Descriptor Table).\n\ 2099 Entry number (an expression) as an argument means display only that entry."), 2100 &info_dos_cmdlist); 2101 add_cmd ("gdt", class_info, go32_sgdt, _("\ 2102 Display entries in the GDT (Global Descriptor Table).\n\ 2103 Entry number (an expression) as an argument means display only that entry."), 2104 &info_dos_cmdlist); 2105 add_cmd ("idt", class_info, go32_sidt, _("\ 2106 Display entries in the IDT (Interrupt Descriptor Table).\n\ 2107 Entry number (an expression) as an argument means display only that entry."), 2108 &info_dos_cmdlist); 2109 add_cmd ("pde", class_info, go32_pde, _("\ 2110 Display entries in the Page Directory.\n\ 2111 Entry number (an expression) as an argument means display only that entry."), 2112 &info_dos_cmdlist); 2113 add_cmd ("pte", class_info, go32_pte, _("\ 2114 Display entries in Page Tables.\n\ 2115 Entry number (an expression) as an argument means display only entries\n\ 2116 from the Page Table pointed to by the specified Page Directory entry."), 2117 &info_dos_cmdlist); 2118 add_cmd ("address-pte", class_info, go32_pte_for_address, _("\ 2119 Display a Page Table entry for a linear address.\n\ 2120 The address argument must be a linear address, after adding to\n\ 2121 it the base address of the appropriate segment.\n\ 2122 The base address of variables and functions in the debuggee's data\n\ 2123 or code segment is stored in the variable __djgpp_base_address,\n\ 2124 so use `__djgpp_base_address + (char *)&var' as the argument.\n\ 2125 For other segments, look up their base address in the output of\n\ 2126 the `info dos ldt' command."), 2127 &info_dos_cmdlist); 2128 } 2129 2130 pid_t 2131 tcgetpgrp (int fd) 2132 { 2133 if (isatty (fd)) 2134 return SOME_PID; 2135 errno = ENOTTY; 2136 return -1; 2137 } 2138 2139 int 2140 tcsetpgrp (int fd, pid_t pgid) 2141 { 2142 if (isatty (fd) && pgid == SOME_PID) 2143 return 0; 2144 errno = pgid == SOME_PID ? ENOTTY : ENOSYS; 2145 return -1; 2146 } 2147