gdb/go32-nat.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Native debugging support for Intel x86 running DJGPP.
  2.    Copyright (C) 1997-2015 Free Software Foundation, Inc.
  3.    Written by Robert Hoehne.

  5.    This file is part of GDB.

  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 3 of the License, or
  10.    (at your option) any later version.

  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.

  17.    You should have received a copy of the GNU General Public License
  18.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  20. /* To whomever it may concern, here's a general description of how
  21.    debugging in DJGPP works, and the special quirks GDB does to
  22.    support that.

  24.    When the DJGPP port of GDB is debugging a DJGPP program natively,
  25.    there aren't 2 separate processes, the debuggee and GDB itself, as
  26.    on other systems.  (This is DOS, where there can only be one active
  27.    process at any given time, remember?)  Instead, GDB and the
  28.    debuggee live in the same process.  So when GDB calls
  29.    go32_create_inferior below, and that function calls edi_init from
  30.    the DJGPP debug support library libdbg.a, we load the debuggee's
  31.    executable file into GDB's address space, set it up for execution
  32.    as the stub loader (a short real-mode program prepended to each
  33.    DJGPP executable) normally would, and do a lot of preparations for
  34.    swapping between GDB's and debuggee's internal state, primarily wrt
  35.    the exception handlers.  This swapping happens every time we resume
  36.    the debuggee or switch back to GDB's code, and it includes:

  38.     . swapping all the segment registers
  39.     . swapping the PSP (the Program Segment Prefix)
  40.     . swapping the signal handlers
  41.     . swapping the exception handlers
  42.     . swapping the FPU status
  43.     . swapping the 3 standard file handles (more about this below)

  45.    Then running the debuggee simply means longjmp into it where its PC
  46.    is and let it run until it stops for some reason.  When it stops,
  47.    GDB catches the exception that stopped it and longjmp's back into
  48.    its own code.  All the possible exit points of the debuggee are
  49.    watched; for example, the normal exit point is recognized because a
  50.    DOS program issues a special system call to exit.  If one of those
  51.    exit points is hit, we mourn the inferior and clean up after it.
  52.    Cleaning up is very important, even if the process exits normally,
  53.    because otherwise we might leave behind traces of previous
  54.    execution, and in several cases GDB itself might be left hosed,
  55.    because all the exception handlers were not restored.

  57.    Swapping of the standard handles (in redir_to_child and
  58.    redir_to_debugger) is needed because, since both GDB and the
  59.    debuggee live in the same process, as far as the OS is concerned,
  60.    the share the same file table.  This means that the standard
  61.    handles 0, 1, and 2 point to the same file table entries, and thus
  62.    are connected to the same devices.  Therefore, if the debugger
  63.    redirects its standard output, the standard output of the debuggee
  64.    is also automagically redirected to the same file/device!
  65.    Similarly, if the debuggee redirects its stdout to a file, you
  66.    won't be able to see debugger's output (it will go to the same file
  67.    where the debuggee has its output); and if the debuggee closes its
  68.    standard input, you will lose the ability to talk to debugger!

  70.    For this reason, every time the debuggee is about to be resumed, we
  71.    call redir_to_child, which redirects the standard handles to where
  72.    the debuggee expects them to be.  When the debuggee stops and GDB
  73.    regains control, we call redir_to_debugger, which redirects those 3
  74.    handles back to where GDB expects.

  76.    Note that only the first 3 handles are swapped, so if the debuggee
  77.    redirects or closes any other handles, GDB will not notice.  In
  78.    particular, the exit code of a DJGPP program forcibly closes all
  79.    file handles beyond the first 3 ones, so when the debuggee exits,
  80.    GDB currently loses its stdaux and stdprn streams.  Fortunately,
  81.    GDB does not use those as of this writing, and will never need
  82.    to.  */

  84. #include "defs.h"

  86. #include <fcntl.h>

  88. #include "x86-nat.h"
  89. #include "inferior.h"
  90. #include "infrun.h"
  91. #include "gdbthread.h"
  92. #include "gdb_wait.h"
  93. #include "gdbcore.h"
  94. #include "command.h"
  95. #include "gdbcmd.h"
  96. #include "floatformat.h"
  97. #include "buildsym.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"

  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

  121. #include <langinfo.h>

  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;

  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;

  150. ‌static NPX npx;

  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.  */

  155. /* ------------------------------------------------------------------------- */
  156. /* Store the contents of the NPX in the global variable `npx'.  */
  157. /* *INDENT-OFF* */

  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. }

  178. /* *INDENT-ON* */


  181. /* ------------------------------------------------------------------------- */
  182. /* Reload the contents of the NPX from the global variable `npx'.  */

  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;

  196. void
  197. ‌redir_cmdline_delete (cmdline_t *ptr)
  198. {
  199.   ptr->redirected = 0;
  200. }

  202. int
  203. ‌redir_cmdline_parse (const char *args, cmdline_t *ptr)
  204. {
  205.   return -1;
  206. }

  208. int
  209. ‌redir_to_child (cmdline_t *ptr)
  210. {
  211.   return 1;
  212. }

  214. int
  215. ‌redir_to_debugger (cmdline_t *ptr)
  216. {
  217.   return 1;
  218. }

  220. int
  221. ‌redir_debug_init (cmdline_t *ptr)
  222. {
  223.   return 0;
  224. }
  225. #endif /* __DJGPP_MINOR < 3 */

  227. ‌typedef enum { wp_insert, wp_remove, wp_count } wp_op;

  229. /* This holds the current reference counts for each debug register.  */
  230. ‌static int dr_ref_count[4];

  232. ‌#define SOME_PID 42

  234. ‌static int prog_has_started = 0;
  235. static void go32_mourn_inferior (struct target_ops *ops);

  237. ‌#define r_ofs(x) (offsetof(TSS,x))

  239. static struct
  240. {
  241.   size_t tss_ofs;
  242.   size_t size;
  243. }
  244. ‌regno_mapping[] =
  245. {
  246.   {r_ofs (tss_eax), 4},        /* normal registers, from a_tss */
  247.   {r_ofs (tss_ecx), 4},
  248.   {r_ofs (tss_edx), 4},
  249.   {r_ofs (tss_ebx), 4},
  250.   {r_ofs (tss_esp), 4},
  251.   {r_ofs (tss_ebp), 4},
  252.   {r_ofs (tss_esi), 4},
  253.   {r_ofs (tss_edi), 4},
  254.   {r_ofs (tss_eip), 4},
  255.   {r_ofs (tss_eflags), 4},
  256.   {r_ofs (tss_cs), 2},
  257.   {r_ofs (tss_ss), 2},
  258.   {r_ofs (tss_ds), 2},
  259.   {r_ofs (tss_es), 2},
  260.   {r_ofs (tss_fs), 2},
  261.   {r_ofs (tss_gs), 2},
  262.   {0, 10},                /* 8 FP registers, from npx.reg[] */
  263.   {1, 10},
  264.   {2, 10},
  265.   {3, 10},
  266.   {4, 10},
  267.   {5, 10},
  268.   {6, 10},
  269.   {7, 10},
  270.         /* The order of the next 7 registers must be consistent
  271.            with their numbering in config/i386/tm-i386.h, which see.  */
  272.   {0, 2},                /* control word, from npx */
  273.   {4, 2},                /* status word, from npx */
  274.   {8, 2},                /* tag word, from npx */
  275.   {16, 2},                /* last FP exception CS from npx */
  276.   {12, 4},                /* last FP exception EIP from npx */
  277.   {24, 2},                /* last FP exception operand selector from npx */
  278.   {20, 4},                /* last FP exception operand offset from npx */
  279.   {18, 2}                /* last FP opcode from npx */
  280. };

  282. static struct
  283.   {
  284.     int go32_sig;
  285.     enum gdb_signal gdb_sig;
  286.   }
  287. ‌sig_map[] =
  288. {
  289.   {0, GDB_SIGNAL_FPE},
  290.   {1, GDB_SIGNAL_TRAP},
  291.   /* Exception 2 is triggered by the NMI.  DJGPP handles it as SIGILL,
  292.      but I think SIGBUS is better, since the NMI is usually activated
  293.      as a result of a memory parity check failure.  */
  294.   {2, GDB_SIGNAL_BUS},
  295.   {3, GDB_SIGNAL_TRAP},
  296.   {4, GDB_SIGNAL_FPE},
  297.   {5, GDB_SIGNAL_SEGV},
  298.   {6, GDB_SIGNAL_ILL},
  299.   {7, GDB_SIGNAL_EMT},        /* no-coprocessor exception */
  300.   {8, GDB_SIGNAL_SEGV},
  301.   {9, GDB_SIGNAL_SEGV},
  302.   {10, GDB_SIGNAL_BUS},
  303.   {11, GDB_SIGNAL_SEGV},
  304.   {12, GDB_SIGNAL_SEGV},
  305.   {13, GDB_SIGNAL_SEGV},
  306.   {14, GDB_SIGNAL_SEGV},
  307.   {16, GDB_SIGNAL_FPE},
  308.   {17, GDB_SIGNAL_BUS},
  309.   {31, GDB_SIGNAL_ILL},
  310.   {0x1b, GDB_SIGNAL_INT},
  311.   {0x75, GDB_SIGNAL_FPE},
  312.   {0x78, GDB_SIGNAL_ALRM},
  313.   {0x79, GDB_SIGNAL_INT},
  314.   {0x7a, GDB_SIGNAL_QUIT},
  315.   {-1, GDB_SIGNAL_LAST}
  316. };

  318. static struct {
  319.   enum gdb_signal gdb_sig;
  320.   int djgpp_excepno;
  321. ‌} excepn_map[] = {
  322.   {GDB_SIGNAL_0, -1},
  323.   {GDB_SIGNAL_ILL, 6},        /* Invalid Opcode */
  324.   {GDB_SIGNAL_EMT, 7},        /* triggers SIGNOFP */
  325.   {GDB_SIGNAL_SEGV, 13},        /* GPF */
  326.   {GDB_SIGNAL_BUS, 17},        /* Alignment Check */
  327.   /* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
  328.      details.  */
  329.   {GDB_SIGNAL_TERM, 0x1b},        /* triggers Ctrl-Break type of SIGINT */
  330.   {GDB_SIGNAL_FPE, 0x75},
  331.   {GDB_SIGNAL_INT, 0x79},
  332.   {GDB_SIGNAL_QUIT, 0x7a},
  333.   {GDB_SIGNAL_ALRM, 0x78},        /* triggers SIGTIMR */
  334.   {GDB_SIGNAL_PROF, 0x78},
  335.   {GDB_SIGNAL_LAST, -1}
  336. };

  338. static void
  339. ‌go32_attach (struct target_ops *ops, const char *args, int from_tty)
  340. {
  341.   error (_("\
  342. You cannot attach to a running program on this platform.\n\
  343. Use the `run' command to run DJGPP programs."));
  344. }

  346. ‌static int resume_is_step;
  347. ‌static int resume_signal = -1;

  349. static void
  350. ‌go32_resume (struct target_ops *ops,
  351.              ptid_t ptid, int step, enum gdb_signal siggnal)
  352. {
  353.   int i;

  355.   resume_is_step = step;

  357.   if (siggnal != GDB_SIGNAL_0 && siggnal != GDB_SIGNAL_TRAP)
  358.   {
  359.     for (i = 0, resume_signal = -1;
  360.          excepn_map[i].gdb_sig != GDB_SIGNAL_LAST; i++)
  361.       if (excepn_map[i].gdb_sig == siggnal)
  362.       {
  363.         resume_signal = excepn_map[i].djgpp_excepno;
  364.         break;
  365.       }
  366.     if (resume_signal == -1)
  367.       printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
  368.                          gdb_signal_to_name (siggnal));
  369.   }
  370. }

  372. ‌static char child_cwd[FILENAME_MAX];

  374. static ptid_t
  375. ‌go32_wait (struct target_ops *ops,
  376.            ptid_t ptid, struct target_waitstatus *status, int options)
  377. {
  378.   int i;
  379.   unsigned char saved_opcode;
  380.   unsigned long INT3_addr = 0;
  381.   int stepping_over_INT = 0;

  383.   a_tss.tss_eflags &= 0xfeff;        /* Reset the single-step flag (TF).  */
  384.   if (resume_is_step)
  385.     {
  386.       /* If the next instruction is INT xx or INTO, we need to handle
  387.          them specially.  Intel manuals say that these instructions
  388.          reset the single-step flag (a.k.a. TF).  However, it seems
  389.          that, at least in the DPMI environment, and at least when
  390.          stepping over the DPMI interrupt 31h, the problem is having
  391.          TF set at all when INT 31h is executed: the debuggee either
  392.          crashes (and takes the system with it) or is killed by a
  393.          SIGTRAP.

  395.          So we need to emulate single-step mode: we put an INT3 opcode
  396.          right after the INT xx instruction, let the debuggee run
  397.          until it hits INT3 and stops, then restore the original
  398.          instruction which we overwrote with the INT3 opcode, and back
  399.          up the debuggee's EIP to that instruction.  */
  400.       read_child (a_tss.tss_eip, &saved_opcode, 1);
  401.       if (saved_opcode == 0xCD || saved_opcode == 0xCE)
  402.         {
  403.           unsigned char INT3_opcode = 0xCC;

  405.           INT3_addr
  406.             = saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
  407.           stepping_over_INT = 1;
  408.           read_child (INT3_addr, &saved_opcode, 1);
  409.           write_child (INT3_addr, &INT3_opcode, 1);
  410.         }
  411.       else
  412.         a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
  413.     }

  415.   /* The special value FFFFh in tss_trap indicates to run_child that
  416.      tss_irqn holds a signal to be delivered to the debuggee.  */
  417.   if (resume_signal <= -1)
  418.     {
  419.       a_tss.tss_trap = 0;
  420.       a_tss.tss_irqn = 0xff;
  421.     }
  422.   else
  423.     {
  424.       a_tss.tss_trap = 0xffff;        /* run_child looks for this.  */
  425.       a_tss.tss_irqn = resume_signal;
  426.     }

  428.   /* The child might change working directory behind our back.  The
  429.      GDB users won't like the side effects of that when they work with
  430.      relative file names, and GDB might be confused by its current
  431.      directory not being in sync with the truth.  So we always make a
  432.      point of changing back to where GDB thinks is its cwd, when we
  433.      return control to the debugger, but restore child's cwd before we
  434.      run it.  */
  435.   /* Initialize child_cwd, before the first call to run_child and not
  436.      in the initialization, so the child get also the changed directory
  437.      set with the gdb-command "cd ..."  */
  438.   if (!*child_cwd)
  439.     /* Initialize child's cwd with the current one.  */
  440.     getcwd (child_cwd, sizeof (child_cwd));

  442.   chdir (child_cwd);

  444. #if __DJGPP_MINOR__ < 3
  445.   load_npx ();
  446. #endif
  447.   run_child ();
  448. #if __DJGPP_MINOR__ < 3
  449.   save_npx ();
  450. #endif

  452.   /* Did we step over an INT xx instruction?  */
  453.   if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
  454.     {
  455.       /* Restore the original opcode.  */
  456.       a_tss.tss_eip--;        /* EIP points *after* the INT3 instruction.  */
  457.       write_child (a_tss.tss_eip, &saved_opcode, 1);
  458.       /* Simulate a TRAP exception.  */
  459.       a_tss.tss_irqn = 1;
  460.       a_tss.tss_eflags |= 0x0100;
  461.     }

  463.   getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
  464.   chdir (current_directory);

  466.   if (a_tss.tss_irqn == 0x21)
  467.     {
  468.       status->kind = TARGET_WAITKIND_EXITED;
  469.       status->value.integer = a_tss.tss_eax & 0xff;
  470.     }
  471.   else
  472.     {
  473.       status->value.sig = GDB_SIGNAL_UNKNOWN;
  474.       status->kind = TARGET_WAITKIND_STOPPED;
  475.       for (i = 0; sig_map[i].go32_sig != -1; i++)
  476.         {
  477.           if (a_tss.tss_irqn == sig_map[i].go32_sig)
  478.             {
  479. #if __DJGPP_MINOR__ < 3
  480.               if ((status->value.sig = sig_map[i].gdb_sig) !=
  481.                   GDB_SIGNAL_TRAP)
  482.                 status->kind = TARGET_WAITKIND_SIGNALLED;
  483. #else
  484.               status->value.sig = sig_map[i].gdb_sig;
  485. #endif
  486.               break;
  487.             }
  488.         }
  489.     }
  490.   return pid_to_ptid (SOME_PID);
  491. }

  493. static void
  494. ‌fetch_register (struct regcache *regcache, int regno)
  495. {
  496.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  497.   if (regno < gdbarch_fp0_regnum (gdbarch))
  498.     regcache_raw_supply (regcache, regno,
  499.                          (char *) &a_tss + regno_mapping[regno].tss_ofs);
  500.   else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch,
  501.                                                                    regno))
  502.     i387_supply_fsave (regcache, regno, &npx);
  503.   else
  504.     internal_error (__FILE__, __LINE__,
  505.                     _("Invalid register no. %d in fetch_register."), regno);
  506. }

  508. static void
  509. ‌go32_fetch_registers (struct target_ops *ops,
  510.                       struct regcache *regcache, int regno)
  511. {
  512.   if (regno >= 0)
  513.     fetch_register (regcache, regno);
  514.   else
  515.     {
  516.       for (regno = 0;
  517.            regno < gdbarch_fp0_regnum (get_regcache_arch (regcache));
  518.            regno++)
  519.         fetch_register (regcache, regno);
  520.       i387_supply_fsave (regcache, -1, &npx);
  521.     }
  522. }

  524. static void
  525. ‌store_register (const struct regcache *regcache, int regno)
  526. {
  527.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  528.   if (regno < gdbarch_fp0_regnum (gdbarch))
  529.     regcache_raw_collect (regcache, regno,
  530.                           (char *) &a_tss + regno_mapping[regno].tss_ofs);
  531.   else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch,
  532.                                                                    regno))
  533.     i387_collect_fsave (regcache, regno, &npx);
  534.   else
  535.     internal_error (__FILE__, __LINE__,
  536.                     _("Invalid register no. %d in store_register."), regno);
  537. }

  539. static void
  540. ‌go32_store_registers (struct target_ops *ops,
  541.                       struct regcache *regcache, int regno)
  542. {
  543.   unsigned r;

  545.   if (regno >= 0)
  546.     store_register (regcache, regno);
  547.   else
  548.     {
  549.       for (r = 0; r < gdbarch_fp0_regnum (get_regcache_arch (regcache)); r++)
  550.         store_register (regcache, r);
  551.       i387_collect_fsave (regcache, -1, &npx);
  552.     }
  553. }

  555. /* Const-correct version of DJGPP's write_child, which unfortunately
  556.    takes a non-const buffer pointer.  */

  558. static int
  559. ‌my_write_child (unsigned child_addr, const void *buf, unsigned len)
  560. {
  561.   static void *buffer = NULL;
  562.   static unsigned buffer_len = 0;
  563.   int res;

  565.   if (buffer_len < len)
  566.     {
  567.       buffer = xrealloc (buffer, len);
  568.       buffer_len = len;
  569.     }

  571.   memcpy (buffer, buf, len);
  572.   res = write_child (child_addr, buffer, len);
  573.   return res;
  574. }

  576. /* Helper for go32_xfer_partial that handles memory transfers.
  577.    Arguments are like target_xfer_partial.  */

  579. static enum target_xfer_status
  580. ‌go32_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
  581.                   ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
  582. {
  583.   int res;

  585.   if (writebuf != NULL)
  586.     res = my_write_child (memaddr, writebuf, len);
  587.   else
  588.     res = read_child (memaddr, readbuf, len);

  590.   if (res <= 0)
  591.     return TARGET_XFER_E_IO;

  593.   *xfered_len = res;
  594.   return TARGET_XFER_OK;
  595. }

  597. /* Target to_xfer_partial implementation.  */

  599. static enum target_xfer_status
  600. ‌go32_xfer_partial (struct target_ops *ops, enum target_object object,
  601.                    const char *annex, gdb_byte *readbuf,
  602.                    const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
  603.                    ULONGEST *xfered_len)
  604. {
  605.   switch (object)
  606.     {
  607.     case TARGET_OBJECT_MEMORY:
  608.       return go32_xfer_memory (readbuf, writebuf, offset, len, xfered_len);

  610.     default:
  611.       return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
  612.                                             readbuf, writebuf, offset, len,
  613.                                             xfered_len);
  614.     }
  615. }

  617. ‌static cmdline_t child_cmd;        /* Parsed child's command line kept here.  */

  619. static void
  620. ‌go32_files_info (struct target_ops *target)
  621. {
  622.   printf_unfiltered ("You are running a DJGPP V2 program.\n");
  623. }

  625. static void
  626. ‌go32_kill_inferior (struct target_ops *ops)
  627. {
  628.   go32_mourn_inferior (ops);
  629. }

  631. static void
  632. ‌go32_create_inferior (struct target_ops *ops, char *exec_file,
  633.                       char *args, char **env, int from_tty)
  634. {
  635.   extern char **environ;
  636.   jmp_buf start_state;
  637.   char *cmdline;
  638.   char **env_save = environ;
  639.   size_t cmdlen;
  640.   struct inferior *inf;
  641.   int result;

  643.   /* If no exec file handed to us, get it from the exec-file command -- with
  644.      a good, common error message if none is specified.  */
  645.   if (exec_file == 0)
  646.     exec_file = get_exec_file (1);

  648.   resume_signal = -1;
  649.   resume_is_step = 0;

  651.   /* Initialize child's cwd as empty to be initialized when starting
  652.      the child.  */
  653.   *child_cwd = 0;

  655.   /* Init command line storage.  */
  656.   if (redir_debug_init (&child_cmd) == -1)
  657.     internal_error (__FILE__, __LINE__,
  658.                     _("Cannot allocate redirection storage: "
  659.                       "not enough memory.\n"));

  661.   /* Parse the command line and create redirections.  */
  662.   if (strpbrk (args, "<>"))
  663.     {
  664.       if (redir_cmdline_parse (args, &child_cmd) == 0)
  665.         args = child_cmd.command;
  666.       else
  667.         error (_("Syntax error in command line."));
  668.     }
  669.   else
  670.     child_cmd.command = xstrdup (args);

  672.   cmdlen = strlen (args);
  673.   /* v2loadimage passes command lines via DOS memory, so it cannot
  674.      possibly handle commands longer than 1MB.  */
  675.   if (cmdlen > 1024*1024)
  676.     error (_("Command line too long."));

  678.   cmdline = xmalloc (cmdlen + 4);
  679.   strcpy (cmdline + 1, args);
  680.   /* If the command-line length fits into DOS 126-char limits, use the
  681.      DOS command tail format; otherwise, tell v2loadimage to pass it
  682.      through a buffer in conventional memory.  */
  683.   if (cmdlen < 127)
  684.     {
  685.       cmdline[0] = strlen (args);
  686.       cmdline[cmdlen + 1] = 13;
  687.     }
  688.   else
  689.     cmdline[0] = 0xff;        /* Signal v2loadimage it's a long command.  */

  691.   environ = env;

  693.   result = v2loadimage (exec_file, cmdline, start_state);

  695.   environ = env_save;
  696.   xfree (cmdline);

  698.   if (result != 0)
  699.     error (_("Load failed for image %s"), exec_file);

  701.   edi_init (start_state);
  702. #if __DJGPP_MINOR__ < 3
  703.   save_npx ();
  704. #endif

  706.   inferior_ptid = pid_to_ptid (SOME_PID);
  707.   inf = current_inferior ();
  708.   inferior_appeared (inf, SOME_PID);

  710.   if (!target_is_pushed (ops))
  711.     push_target (ops);

  713.   add_thread_silent (inferior_ptid);

  715.   clear_proceed_status (0);
  716.   insert_breakpoints ();
  717.   prog_has_started = 1;
  718. }

  720. static void
  721. ‌go32_mourn_inferior (struct target_ops *ops)
  722. {
  723.   ptid_t ptid;

  725.   redir_cmdline_delete (&child_cmd);
  726.   resume_signal = -1;
  727.   resume_is_step = 0;

  729.   cleanup_client ();

  731.   /* We need to make sure all the breakpoint enable bits in the DR7
  732.      register are reset when the inferior exits.  Otherwise, if they
  733.      rerun the inferior, the uncleared bits may cause random SIGTRAPs,
  734.      failure to set more watchpoints, and other calamities.  It would
  735.      be nice if GDB itself would take care to remove all breakpoints
  736.      at all times, but it doesn't, probably under an assumption that
  737.      the OS cleans up when the debuggee exits.  */
  738.   x86_cleanup_dregs ();

  740.   ptid = inferior_ptid;
  741.   inferior_ptid = null_ptid;
  742.   delete_thread_silent (ptid);
  743.   prog_has_started = 0;

  745.   generic_mourn_inferior ();
  746.   inf_child_maybe_unpush_target (ops);
  747. }

  749. /* Hardware watchpoint support.  */

  751. ‌#define D_REGS edi.dr
  752. ‌#define CONTROL D_REGS[7]
  753. ‌#define STATUS D_REGS[6]

  755. /* Pass the address ADDR to the inferior in the I'th debug register.
  756.    Here we just store the address in D_REGS, the watchpoint will be
  757.    actually set up when go32_wait runs the debuggee.  */
  758. static void
  759. ‌go32_set_dr (int i, CORE_ADDR addr)
  760. {
  761.   if (i < 0 || i > 3)
  762.     internal_error (__FILE__, __LINE__,
  763.                     _("Invalid register %d in go32_set_dr.\n"), i);
  764.   D_REGS[i] = addr;
  765. }

  767. /* Pass the value VAL to the inferior in the DR7 debug control
  768.    register.  Here we just store the address in D_REGS, the watchpoint
  769.    will be actually set up when go32_wait runs the debuggee.  */
  770. static void
  771. ‌go32_set_dr7 (unsigned long val)
  772. {
  773.   CONTROL = val;
  774. }

  776. /* Get the value of the DR6 debug status register from the inferior.
  777.    Here we just return the value stored in D_REGS, as we've got it
  778.    from the last go32_wait call.  */
  779. static unsigned long
  780. ‌go32_get_dr6 (void)
  781. {
  782.   return STATUS;
  783. }

  785. /* Get the value of the DR7 debug status register from the inferior.
  786.    Here we just return the value stored in D_REGS, as we've got it
  787.    from the last go32_wait call.  */

  789. static unsigned long
  790. ‌go32_get_dr7 (void)
  791. {
  792.   return CONTROL;
  793. }

  795. /* Get the value of the DR debug register I from the inferior.  Here
  796.    we just return the value stored in D_REGS, as we've got it from the
  797.    last go32_wait call.  */

  799. static CORE_ADDR
  800. ‌go32_get_dr (int i)
  801. {
  802.   if (i < 0 || i > 3)
  803.     internal_error (__FILE__, __LINE__,
  804.                     _("Invalid register %d in go32_get_dr.\n"), i);
  805.   return D_REGS[i];
  806. }

  808. /* Put the device open on handle FD into either raw or cooked
  809.    mode, return 1 if it was in raw mode, zero otherwise.  */

  811. static int
  812. ‌device_mode (int fd, int raw_p)
  813. {
  814.   int oldmode, newmode;
  815.   __dpmi_regs regs;

  817.   regs.x.ax = 0x4400;
  818.   regs.x.bx = fd;
  819.   __dpmi_int (0x21, &regs);
  820.   if (regs.x.flags & 1)
  821.     return -1;
  822.   newmode = oldmode = regs.x.dx;

  824.   if (raw_p)
  825.     newmode |= 0x20;
  826.   else
  827.     newmode &= ~0x20;

  829.   if (oldmode & 0x80)        /* Only for character dev.  */
  830.   {
  831.     regs.x.ax = 0x4401;
  832.     regs.x.bx = fd;
  833.     regs.x.dx = newmode & 0xff;   /* Force upper byte zero, else it fails.  */
  834.     __dpmi_int (0x21, &regs);
  835.     if (regs.x.flags & 1)
  836.       return -1;
  837.   }
  838.   return (oldmode & 0x20) == 0x20;
  839. }


  842. ‌static int inf_mode_valid = 0;
  843. ‌static int inf_terminal_mode;

  845. /* This semaphore is needed because, amazingly enough, GDB calls
  846.    target.to_terminal_ours more than once after the inferior stops.
  847.    But we need the information from the first call only, since the
  848.    second call will always see GDB's own cooked terminal.  */
  849. ‌static int terminal_is_ours = 1;

  851. static void
  852. ‌go32_terminal_init (struct target_ops *self)
  853. {
  854.   inf_mode_valid = 0;        /* Reinitialize, in case they are restarting child.  */
  855.   terminal_is_ours = 1;
  856. }

  858. static void
  859. ‌go32_terminal_info (struct target_ops *self, const char *args, int from_tty)
  860. {
  861.   printf_unfiltered ("Inferior's terminal is in %s mode.\n",
  862.                      !inf_mode_valid
  863.                      ? "default" : inf_terminal_mode ? "raw" : "cooked");

  865. #if __DJGPP_MINOR__ > 2
  866.   if (child_cmd.redirection)
  867.   {
  868.     int i;

  870.     for (i = 0; i < DBG_HANDLES; i++)
  871.     {
  872.       if (child_cmd.redirection[i]->file_name)
  873.         printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
  874.                            i, child_cmd.redirection[i]->file_name);
  875.       else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
  876.         printf_unfiltered
  877.           ("\tFile handle %d appears to be closed by inferior.\n", i);
  878.       /* Mask off the raw/cooked bit when comparing device info words.  */
  879.       else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
  880.                != (_get_dev_info (i) & 0xdf))
  881.         printf_unfiltered
  882.           ("\tFile handle %d appears to be redirected by inferior.\n", i);
  883.     }
  884.   }
  885. #endif
  886. }

  888. static void
  889. ‌go32_terminal_inferior (struct target_ops *self)
  890. {
  891.   /* Redirect standard handles as child wants them.  */
  892.   errno = 0;
  893.   if (redir_to_child (&child_cmd) == -1)
  894.   {
  895.     redir_to_debugger (&child_cmd);
  896.     error (_("Cannot redirect standard handles for program: %s."),
  897.            safe_strerror (errno));
  898.   }
  899.   /* Set the console device of the inferior to whatever mode
  900.      (raw or cooked) we found it last time.  */
  901.   if (terminal_is_ours)
  902.   {
  903.     if (inf_mode_valid)
  904.       device_mode (0, inf_terminal_mode);
  905.     terminal_is_ours = 0;
  906.   }
  907. }

  909. static void
  910. ‌go32_terminal_ours (struct target_ops *self)
  911. {
  912.   /* Switch to cooked mode on the gdb terminal and save the inferior
  913.      terminal mode to be restored when it is resumed.  */
  914.   if (!terminal_is_ours)
  915.   {
  916.     inf_terminal_mode = device_mode (0, 0);
  917.     if (inf_terminal_mode != -1)
  918.       inf_mode_valid = 1;
  919.     else
  920.       /* If device_mode returned -1, we don't know what happens with
  921.          handle 0 anymore, so make the info invalid.  */
  922.       inf_mode_valid = 0;
  923.     terminal_is_ours = 1;

  925.     /* Restore debugger's standard handles.  */
  926.     errno = 0;
  927.     if (redir_to_debugger (&child_cmd) == -1)
  928.     {
  929.       redir_to_child (&child_cmd);
  930.       error (_("Cannot redirect standard handles for debugger: %s."),
  931.              safe_strerror (errno));
  932.     }
  933.   }
  934. }

  936. static int
  937. ‌go32_thread_alive (struct target_ops *ops, ptid_t ptid)
  938. {
  939.   return !ptid_equal (inferior_ptid, null_ptid);
  940. }

  942. static char *
  943. ‌go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
  944. {
  945.   return normal_pid_to_str (ptid);
  946. }

  948. /* Create a go32 target.  */

  950. static struct target_ops *
  951. ‌go32_target (void)
  952. {
  953.   struct target_ops *t = inf_child_target ();

  955.   t->to_attach = go32_attach;
  956.   t->to_resume = go32_resume;
  957.   t->to_wait = go32_wait;
  958.   t->to_fetch_registers = go32_fetch_registers;
  959.   t->to_store_registers = go32_store_registers;
  960.   t->to_xfer_partial = go32_xfer_partial;
  961.   t->to_files_info = go32_files_info;
  962.   t->to_terminal_init = go32_terminal_init;
  963.   t->to_terminal_inferior = go32_terminal_inferior;
  964.   t->to_terminal_ours_for_output = go32_terminal_ours;
  965.   t->to_terminal_ours = go32_terminal_ours;
  966.   t->to_terminal_info = go32_terminal_info;
  967.   t->to_kill = go32_kill_inferior;
  968.   t->to_create_inferior = go32_create_inferior;
  969.   t->to_mourn_inferior = go32_mourn_inferior;
  970.   t->to_thread_alive = go32_thread_alive;
  971.   t->to_pid_to_str = go32_pid_to_str;

  973.   return t;
  974. }

  976. /* Return the current DOS codepage number.  */
  977. static int
  978. ‌dos_codepage (void)
  979. {
  980.   __dpmi_regs regs;

  982.   regs.x.ax = 0x6601;
  983.   __dpmi_int (0x21, &regs);
  984.   if (!(regs.x.flags & 1))
  985.     return regs.x.bx & 0xffff;
  986.   else
  987.     return 437;        /* default */
  988. }

  990. /* Limited emulation of `nl_langinfo', for charset.c.  */
  991. char *
  992. ‌nl_langinfo (nl_item item)
  993. {
  994.   char *retval;

  996.   switch (item)
  997.     {
  998.       case CODESET:
  999.         {
  1000.           /* 8 is enough for SHORT_MAX + "CP" + null.  */
  1001.           char buf[8];
  1002.           int blen = sizeof (buf);
  1003.           int needed = snprintf (buf, blen, "CP%d", dos_codepage ());

  1005.           if (needed > blen)        /* Should never happen.  */
  1006.             buf[0] = 0;
  1007.           retval = xstrdup (buf);
  1008.         }
  1009.         break;
  1010.       default:
  1011.         retval = xstrdup ("");
  1012.         break;
  1013.     }
  1014.   return retval;
  1015. }

  1017. ‌‌unsigned short windows_major, windows_minor;

  1019. /* Compute the version Windows reports via Int 2Fh/AX=1600h.  */
  1020. static void
  1021. ‌go32_get_windows_version(void)
  1022. {
  1023.   __dpmi_regs r;

  1025.   r.x.ax = 0x1600;
  1026.   __dpmi_int(0x2f, &r);
  1027.   if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
  1028.       && (r.h.al > 3 || r.h.ah > 0))
  1029.     {
  1030.       windows_major = r.h.al;
  1031.       windows_minor = r.h.ah;
  1032.     }
  1033.   else
  1034.     windows_major = 0xff;        /* meaning no Windows */
  1035. }

  1037. /* A subroutine of go32_sysinfo to display memory info.  */
  1038. static void
  1039. ‌print_mem (unsigned long datum, const char *header, int in_pages_p)
  1040. {
  1041.   if (datum != 0xffffffffUL)
  1042.     {
  1043.       if (in_pages_p)
  1044.         datum <<= 12;
  1045.       puts_filtered (header);
  1046.       if (datum > 1024)
  1047.         {
  1048.           printf_filtered ("%lu KB", datum >> 10);
  1049.           if (datum > 1024 * 1024)
  1050.             printf_filtered (" (%lu MB)", datum >> 20);
  1051.         }
  1052.       else
  1053.         printf_filtered ("%lu Bytes", datum);
  1054.       puts_filtered ("\n");
  1055.     }
  1056. }

  1058. /* Display assorted information about the underlying OS.  */
  1059. static void
  1060. ‌go32_sysinfo (char *arg, int from_tty)
  1061. {
  1062.   static const char test_pattern[] =
  1063.     "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
  1064.     "deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
  1065.     "deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
  1066.   struct utsname u;
  1067.   char cpuid_vendor[13];
  1068.   unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
  1069.   unsigned true_dos_version = _get_dos_version (1);
  1070.   unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
  1071.   int dpmi_flags;
  1072.   char dpmi_vendor_info[129];
  1073.   int dpmi_vendor_available;
  1074.   __dpmi_version_ret dpmi_version_data;
  1075.   long eflags;
  1076.   __dpmi_free_mem_info mem_info;
  1077.   __dpmi_regs regs;

  1079.   cpuid_vendor[0] = '\0';
  1080.   if (uname (&u))
  1081.     strcpy (u.machine, "Unknown x86");
  1082.   else if (u.machine[0] == 'i' && u.machine[1] > 4)
  1083.     {
  1084.       /* CPUID with EAX = 0 returns the Vendor ID.  */
  1085. #if 0
  1086.       /* Ideally we would use x86_cpuid(), but it needs someone to run
  1087.          native tests first to make sure things actually work.  They should.
  1088.          http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html  */
  1089.       unsigned int eax, ebx, ecx, edx;

  1091.       if (x86_cpuid (0, &eax, &ebx, &ecx, &edx))
  1092.         {
  1093.           cpuid_max = eax;
  1094.           memcpy (&vendor[0], &ebx, 4);
  1095.           memcpy (&vendor[4], &ecx, 4);
  1096.           memcpy (&vendor[8], &edx, 4);
  1097.           cpuid_vendor[12] = '\0';
  1098.         }
  1099. #else
  1100.       __asm__ __volatile__ ("xorl   %%ebx, %%ebx;"
  1101.                             "xorl   %%ecx, %%ecx;"
  1102.                             "xorl   %%edx, %%edx;"
  1103.                             "movl   $0,    %%eax;"
  1104.                             "cpuid;"
  1105.                             "movl   %%ebx,  %0;"
  1106.                             "movl   %%edx,  %1;"
  1107.                             "movl   %%ecx,  %2;"
  1108.                             "movl   %%eax,  %3;"
  1109.                             : "=m" (cpuid_vendor[0]),
  1110.                               "=m" (cpuid_vendor[4]),
  1111.                               "=m" (cpuid_vendor[8]),
  1112.                               "=m" (cpuid_max)
  1113.                             :
  1114.                             : "%eax", "%ebx", "%ecx", "%edx");
  1115.       cpuid_vendor[12] = '\0';
  1116. #endif
  1117.     }

  1119.   printf_filtered ("CPU Type.......................%s", u.machine);
  1120.   if (cpuid_vendor[0])
  1121.     printf_filtered (" (%s)", cpuid_vendor);
  1122.   puts_filtered ("\n");

  1124.   /* CPUID with EAX = 1 returns processor signature and features.  */
  1125.   if (cpuid_max >= 1)
  1126.     {
  1127.       static char *brand_name[] = {
  1128.         "",
  1129.         " Celeron",
  1130.         " III",
  1131.         " III Xeon",
  1132.         "", "", "", "",
  1133.         " 4"
  1134.       };
  1135.       char cpu_string[80];
  1136.       char cpu_brand[20];
  1137.       unsigned brand_idx;
  1138.       int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
  1139.       int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
  1140.       unsigned cpu_family, cpu_model;

  1142. #if 0
  1143.       /* See comment above about cpuid usage.  */
  1144.       x86_cpuid (1, &cpuid_eax, &cpuid_ebx, NULL, &cpuid_edx);
  1145. #else
  1146.       __asm__ __volatile__ ("movl   $1, %%eax;"
  1147.                             "cpuid;"
  1148.                             : "=a" (cpuid_eax),
  1149.                               "=b" (cpuid_ebx),
  1150.                               "=d" (cpuid_edx)
  1151.                             :
  1152.                             : "%ecx");
  1153. #endif
  1154.       brand_idx = cpuid_ebx & 0xff;
  1155.       cpu_family = (cpuid_eax >> 8) & 0xf;
  1156.       cpu_model  = (cpuid_eax >> 4) & 0xf;
  1157.       cpu_brand[0] = '\0';
  1158.       if (intel_p)
  1159.         {
  1160.           if (brand_idx > 0
  1161.               && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
  1162.               && *brand_name[brand_idx])
  1163.             strcpy (cpu_brand, brand_name[brand_idx]);
  1164.           else if (cpu_family == 5)
  1165.             {
  1166.               if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
  1167.                 strcpy (cpu_brand, " MMX");
  1168.               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
  1169.                 strcpy (cpu_brand, " OverDrive");
  1170.               else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
  1171.                 strcpy (cpu_brand, " Dual");
  1172.             }
  1173.           else if (cpu_family == 6 && cpu_model < 8)
  1174.             {
  1175.               switch (cpu_model)
  1176.                 {
  1177.                   case 1:
  1178.                     strcpy (cpu_brand, " Pro");
  1179.                     break;
  1180.                   case 3:
  1181.                     strcpy (cpu_brand, " II");
  1182.                     break;
  1183.                   case 5:
  1184.                     strcpy (cpu_brand, " II Xeon");
  1185.                     break;
  1186.                   case 6:
  1187.                     strcpy (cpu_brand, " Celeron");
  1188.                     break;
  1189.                   case 7:
  1190.                     strcpy (cpu_brand, " III");
  1191.                     break;
  1192.                 }
  1193.             }
  1194.         }
  1195.       else if (amd_p)
  1196.         {
  1197.           switch (cpu_family)
  1198.             {
  1199.               case 4:
  1200.                 strcpy (cpu_brand, "486/5x86");
  1201.                 break;
  1202.               case 5:
  1203.                 switch (cpu_model)
  1204.                   {
  1205.                     case 0:
  1206.                     case 1:
  1207.                     case 2:
  1208.                     case 3:
  1209.                       strcpy (cpu_brand, "-K5");
  1210.                       break;
  1211.                     case 6:
  1212.                     case 7:
  1213.                       strcpy (cpu_brand, "-K6");
  1214.                       break;
  1215.                     case 8:
  1216.                       strcpy (cpu_brand, "-K6-2");
  1217.                       break;
  1218.                     case 9:
  1219.                       strcpy (cpu_brand, "-K6-III");
  1220.                       break;
  1221.                   }
  1222.                 break;
  1223.               case 6:
  1224.                 switch (cpu_model)
  1225.                   {
  1226.                     case 1:
  1227.                     case 2:
  1228.                     case 4:
  1229.                       strcpy (cpu_brand, " Athlon");
  1230.                       break;
  1231.                     case 3:
  1232.                       strcpy (cpu_brand, " Duron");
  1233.                       break;
  1234.                   }
  1235.                 break;
  1236.             }
  1237.         }
  1238.       xsnprintf (cpu_string, sizeof (cpu_string), "%s%s Model %d Stepping %d",
  1239.                  intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
  1240.                  cpu_brand, cpu_model, cpuid_eax & 0xf);
  1241.       printfi_filtered (31, "%s\n", cpu_string);
  1242.       if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
  1243.           || ((cpuid_edx & 1) == 0)
  1244.           || (amd_p && (cpuid_edx & (3 << 30)) != 0))
  1245.         {
  1246.           puts_filtered ("CPU Features...................");
  1247.           /* We only list features which might be useful in the DPMI
  1248.              environment.  */
  1249.           if ((cpuid_edx & 1) == 0)
  1250.             puts_filtered ("No FPU "); /* It's unusual to not have an FPU.  */
  1251.           if ((cpuid_edx & (1 << 1)) != 0)
  1252.             puts_filtered ("VME ");
  1253.           if ((cpuid_edx & (1 << 2)) != 0)
  1254.             puts_filtered ("DE ");
  1255.           if ((cpuid_edx & (1 << 4)) != 0)
  1256.             puts_filtered ("TSC ");
  1257.           if ((cpuid_edx & (1 << 23)) != 0)
  1258.             puts_filtered ("MMX ");
  1259.           if ((cpuid_edx & (1 << 25)) != 0)
  1260.             puts_filtered ("SSE ");
  1261.           if ((cpuid_edx & (1 << 26)) != 0)
  1262.             puts_filtered ("SSE2 ");
  1263.           if (amd_p)
  1264.             {
  1265.               if ((cpuid_edx & (1 << 31)) != 0)
  1266.                 puts_filtered ("3DNow! ");
  1267.               if ((cpuid_edx & (1 << 30)) != 0)
  1268.                 puts_filtered ("3DNow!Ext");
  1269.             }
  1270.           puts_filtered ("\n");
  1271.         }
  1272.     }
  1273.   puts_filtered ("\n");
  1274.   printf_filtered ("DOS Version....................%s %s.%s",
  1275.                    _os_flavor, u.release, u.version);
  1276.   if (true_dos_version != advertized_dos_version)
  1277.     printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
  1278.   puts_filtered ("\n");
  1279.   if (!windows_major)
  1280.     go32_get_windows_version ();
  1281.   if (windows_major != 0xff)
  1282.     {
  1283.       const char *windows_flavor;

  1285.       printf_filtered ("Windows Version................%d.%02d (Windows ",
  1286.                        windows_major, windows_minor);
  1287.       switch (windows_major)
  1288.         {
  1289.           case 3:
  1290.             windows_flavor = "3.X";
  1291.             break;
  1292.           case 4:
  1293.             switch (windows_minor)
  1294.               {
  1295.                 case 0:
  1296.                   windows_flavor = "95, 95A, or 95B";
  1297.                   break;
  1298.                 case 3:
  1299.                   windows_flavor = "95B OSR2.1 or 95C OSR2.5";
  1300.                   break;
  1301.                 case 10:
  1302.                   windows_flavor = "98 or 98 SE";
  1303.                   break;
  1304.                 case 90:
  1305.                   windows_flavor = "ME";
  1306.                   break;
  1307.                 default:
  1308.                   windows_flavor = "9X";
  1309.                   break;
  1310.               }
  1311.             break;
  1312.           default:
  1313.             windows_flavor = "??";
  1314.             break;
  1315.         }
  1316.       printf_filtered ("%s)\n", windows_flavor);
  1317.     }
  1318.   else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
  1319.     printf_filtered ("Windows Version................"
  1320.                      "Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
  1321.   puts_filtered ("\n");
  1322.   /* On some versions of Windows, __dpmi_get_capabilities returns
  1323.      zero, but the buffer is not filled with info, so we fill the
  1324.      buffer with a known pattern and test for it afterwards.  */
  1325.   memcpy (dpmi_vendor_info, test_pattern, sizeof(dpmi_vendor_info));
  1326.   dpmi_vendor_available =
  1327.     __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
  1328.   if (dpmi_vendor_available == 0
  1329.       && memcmp (dpmi_vendor_info, test_pattern,
  1330.                  sizeof(dpmi_vendor_info)) != 0)
  1331.     {
  1332.       /* The DPMI spec says the vendor string should be ASCIIZ, but
  1333.          I don't trust the vendors to follow that...  */
  1334.       if (!memchr (&dpmi_vendor_info[2], 0, 126))
  1335.         dpmi_vendor_info[128] = '\0';
  1336.       printf_filtered ("DPMI Host......................"
  1337.                        "%s v%d.%d (capabilities: %#x)\n",
  1338.                        &dpmi_vendor_info[2],
  1339.                        (unsigned)dpmi_vendor_info[0],
  1340.                        (unsigned)dpmi_vendor_info[1],
  1341.                        ((unsigned)dpmi_flags & 0x7f));
  1342.     }
  1343.   else
  1344.     printf_filtered ("DPMI Host......................(Info not available)\n");
  1345.   __dpmi_get_version (&dpmi_version_data);
  1346.   printf_filtered ("DPMI Version...................%d.%02d\n",
  1347.                    dpmi_version_data.major, dpmi_version_data.minor);
  1348.   printf_filtered ("DPMI Info......................"
  1349.                    "%s-bit DPMI, with%s Virtual Memory support\n",
  1350.                    (dpmi_version_data.flags & 1) ? "32" : "16",
  1351.                    (dpmi_version_data.flags & 4) ? "" : "out");
  1352.   printfi_filtered (31, "Interrupts reflected to %s mode\n",
  1353.                    (dpmi_version_data.flags & 2) ? "V86" : "Real");
  1354.   printfi_filtered (31, "Processor type: i%d86\n",
  1355.                    dpmi_version_data.cpu);
  1356.   printfi_filtered (31, "PIC base interrupt: Master: %#x  Slave: %#x\n",
  1357.                    dpmi_version_data.master_pic, dpmi_version_data.slave_pic);

  1359.   /* a_tss is only initialized when the debuggee is first run.  */
  1360.   if (prog_has_started)
  1361.     {
  1362.       __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
  1363.       printf_filtered ("Protection....................."
  1364.                        "Ring %d (in %s), with%s I/O protection\n",
  1365.                        a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
  1366.                        (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
  1367.     }
  1368.   puts_filtered ("\n");
  1369.   __dpmi_get_free_memory_information (&mem_info);
  1370.   print_mem (mem_info.total_number_of_physical_pages,
  1371.              "DPMI Total Physical Memory.....", 1);
  1372.   print_mem (mem_info.total_number_of_free_pages,
  1373.              "DPMI Free Physical Memory......", 1);
  1374.   print_mem (mem_info.size_of_paging_file_partition_in_pages,
  1375.              "DPMI Swap Space................", 1);
  1376.   print_mem (mem_info.linear_address_space_size_in_pages,
  1377.              "DPMI Total Linear Address Size.", 1);
  1378.   print_mem (mem_info.free_linear_address_space_in_pages,
  1379.              "DPMI Free Linear Address Size..", 1);
  1380.   print_mem (mem_info.largest_available_free_block_in_bytes,
  1381.              "DPMI Largest Free Memory Block.", 0);

  1383.   regs.h.ah = 0x48;
  1384.   regs.x.bx = 0xffff;
  1385.   __dpmi_int (0x21, &regs);
  1386.   print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
  1387.   regs.x.ax = 0x5800;
  1388.   __dpmi_int (0x21, &regs);
  1389.   if ((regs.x.flags & 1) == 0)
  1390.     {
  1391.       static const char *dos_hilo[] = {
  1392.         "Low", "", "", "", "High", "", "", "", "High, then Low"
  1393.       };
  1394.       static const char *dos_fit[] = {
  1395.         "First", "Best", "Last"
  1396.       };
  1397.       int hilo_idx = (regs.x.ax >> 4) & 0x0f;
  1398.       int fit_idx  = regs.x.ax & 0x0f;

  1400.       if (hilo_idx > 8)
  1401.         hilo_idx = 0;
  1402.       if (fit_idx > 2)
  1403.         fit_idx = 0;
  1404.       printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
  1405.                        dos_hilo[hilo_idx], dos_fit[fit_idx]);
  1406.       regs.x.ax = 0x5802;
  1407.       __dpmi_int (0x21, &regs);
  1408.       if ((regs.x.flags & 1) != 0)
  1409.         regs.h.al = 0;
  1410.       printfi_filtered (31, "UMBs %sin DOS memory chain\n",
  1411.                         regs.h.al == 0 ? "not " : "");
  1412.     }
  1413. }

  1415. ‌struct seg_descr {
  1416.   unsigned short limit0;
  1417.   unsigned short base0;
  1418.   unsigned char  base1;
  1419.   unsigned       stype:5;
  1420.   unsigned       dpl:2;
  1421.   unsigned       present:1;
  1422.   unsigned       limit1:4;
  1423.   unsigned       available:1;
  1424.   unsigned       dummy:1;
  1425.   unsigned       bit32:1;
  1426.   unsigned       page_granular:1;
  1427.   unsigned char  base2;
  1428. } __attribute__ ((packed));

  1430. ‌struct gate_descr {
  1431.   unsigned short offset0;
  1432.   unsigned short selector;
  1433.   unsigned       param_count:5;
  1434.   unsigned       dummy:3;
  1435.   unsigned       stype:5;
  1436.   unsigned       dpl:2;
  1437.   unsigned       present:1;
  1438.   unsigned short offset1;
  1439. } __attribute__ ((packed));

  1441. /* Read LEN bytes starting at logical address ADDR, and put the result
  1442.    into DEST.  Return 1 if success, zero if not.  */
  1443. static int
  1444. ‌read_memory_region (unsigned long addr, void *dest, size_t len)
  1445. {
  1446.   unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
  1447.   int retval = 1;

  1449.   /* For the low memory, we can simply use _dos_ds.  */
  1450.   if (addr <= dos_ds_limit - len)
  1451.     dosmemget (addr, len, dest);
  1452.   else
  1453.     {
  1454.       /* For memory above 1MB we need to set up a special segment to
  1455.          be able to access that memory.  */
  1456.       int sel = __dpmi_allocate_ldt_descriptors (1);

  1458.       if (sel <= 0)
  1459.         retval = 0;
  1460.       else
  1461.         {
  1462.           int access_rights = __dpmi_get_descriptor_access_rights (sel);
  1463.           size_t segment_limit = len - 1;

  1465.           /* Make sure the crucial bits in the descriptor access
  1466.              rights are set correctly.  Some DPMI providers might barf
  1467.              if we set the segment limit to something that is not an
  1468.              integral multiple of 4KB pages if the granularity bit is
  1469.              not set to byte-granular, even though the DPMI spec says
  1470.              it's the host's responsibility to set that bit correctly.  */
  1471.           if (len > 1024 * 1024)
  1472.             {
  1473.               access_rights |= 0x8000;
  1474.               /* Page-granular segments should have the low 12 bits of
  1475.                  the limit set.  */
  1476.               segment_limit |= 0xfff;
  1477.             }
  1478.           else
  1479.             access_rights &= ~0x8000;

  1481.           if (__dpmi_set_segment_base_address (sel, addr) != -1
  1482.               && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
  1483.               && __dpmi_set_segment_limit (sel, segment_limit) != -1
  1484.               /* W2K silently fails to set the segment limit, leaving
  1485.                  it at zero; this test avoids the resulting crash.  */
  1486.               && __dpmi_get_segment_limit (sel) >= segment_limit)
  1487.             movedata (sel, 0, _my_ds (), (unsigned)dest, len);
  1488.           else
  1489.             retval = 0;

  1491.           __dpmi_free_ldt_descriptor (sel);
  1492.         }
  1493.     }
  1494.   return retval;
  1495. }

  1497. /* Get a segment descriptor stored at index IDX in the descriptor
  1498.    table whose base address is TABLE_BASE.  Return the descriptor
  1499.    type, or -1 if failure.  */
  1500. static int
  1501. ‌get_descriptor (unsigned long table_base, int idx, void *descr)
  1502. {
  1503.   unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */

  1505.   if (read_memory_region (addr, descr, 8))
  1506.     return (int)((struct seg_descr *)descr)->stype;
  1507.   return -1;
  1508. }

  1510. ‌struct dtr_reg {
  1511.   unsigned short limit __attribute__((packed));
  1512.   unsigned long  base  __attribute__((packed));
  1513. };

  1515. /* Display a segment descriptor stored at index IDX in a descriptor
  1516.    table whose type is TYPE and whose base address is BASE_ADDR.  If
  1517.    FORCE is non-zero, display even invalid descriptors.  */
  1518. static void
  1519. ‌display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
  1520. {
  1521.   struct seg_descr descr;
  1522.   struct gate_descr gate;

  1524.   /* Get the descriptor from the table.  */
  1525.   if (idx == 0 && type == 0)
  1526.     puts_filtered ("0x000: null descriptor\n");
  1527.   else if (get_descriptor (base_addr, idx, &descr) != -1)
  1528.     {
  1529.       /* For each type of descriptor table, this has a bit set if the
  1530.          corresponding type of selectors is valid in that table.  */
  1531.       static unsigned allowed_descriptors[] = {
  1532.           0xffffdafeL,   /* GDT */
  1533.           0x0000c0e0L,   /* IDT */
  1534.           0xffffdafaL    /* LDT */
  1535.       };

  1537.       /* If the program hasn't started yet, assume the debuggee will
  1538.          have the same CPL as the debugger.  */
  1539.       int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
  1540.       unsigned long limit = (descr.limit1 << 16) | descr.limit0;

  1542.       if (descr.present
  1543.           && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
  1544.         {
  1545.           printf_filtered ("0x%03x: ",
  1546.                            type == 1
  1547.                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
  1548.           if (descr.page_granular)
  1549.             limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
  1550.           if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
  1551.               || descr.stype == 9 || descr.stype == 11
  1552.               || (descr.stype >= 16 && descr.stype < 32))
  1553.             printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
  1554.                              descr.base2, descr.base1, descr.base0, limit);

  1556.           switch (descr.stype)
  1557.             {
  1558.               case 1:
  1559.               case 3:
  1560.                 printf_filtered (" 16-bit TSS  (task %sactive)",
  1561.                                  descr.stype == 3 ? "" : "in");
  1562.                 break;
  1563.               case 2:
  1564.                 puts_filtered (" LDT");
  1565.                 break;
  1566.               case 4:
  1567.                 memcpy (&gate, &descr, sizeof gate);
  1568.                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
  1569.                                  gate.selector, gate.offset1, gate.offset0);
  1570.                 printf_filtered (" 16-bit Call Gate (params=%d)",
  1571.                                  gate.param_count);
  1572.                 break;
  1573.               case 5:
  1574.                 printf_filtered ("TSS selector=0x%04x", descr.base0);
  1575.                 printfi_filtered (16, "Task Gate");
  1576.                 break;
  1577.               case 6:
  1578.               case 7:
  1579.                 memcpy (&gate, &descr, sizeof gate);
  1580.                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
  1581.                                  gate.selector, gate.offset1, gate.offset0);
  1582.                 printf_filtered (" 16-bit %s Gate",
  1583.                                  descr.stype == 6 ? "Interrupt" : "Trap");
  1584.                 break;
  1585.               case 9:
  1586.               case 11:
  1587.                 printf_filtered (" 32-bit TSS (task %sactive)",
  1588.                                  descr.stype == 3 ? "" : "in");
  1589.                 break;
  1590.               case 12:
  1591.                 memcpy (&gate, &descr, sizeof gate);
  1592.                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
  1593.                                  gate.selector, gate.offset1, gate.offset0);
  1594.                 printf_filtered (" 32-bit Call Gate (params=%d)",
  1595.                                  gate.param_count);
  1596.                 break;
  1597.               case 14:
  1598.               case 15:
  1599.                 memcpy (&gate, &descr, sizeof gate);
  1600.                 printf_filtered ("selector=0x%04x  offs=0x%04x%04x",
  1601.                                  gate.selector, gate.offset1, gate.offset0);
  1602.                 printf_filtered (" 32-bit %s Gate",
  1603.                                  descr.stype == 14 ? "Interrupt" : "Trap");
  1604.                 break;
  1605.               case 16:                /* data segments */
  1606.               case 17:
  1607.               case 18:
  1608.               case 19:
  1609.               case 20:
  1610.               case 21:
  1611.               case 22:
  1612.               case 23:
  1613.                 printf_filtered (" %s-bit Data (%s Exp-%s%s)",
  1614.                                  descr.bit32 ? "32" : "16",
  1615.                                  descr.stype & 2
  1616.                                  ? "Read/Write," : "Read-Only, ",
  1617.                                  descr.stype & 4 ? "down" : "up",
  1618.                                  descr.stype & 1 ? "" : ", N.Acc");
  1619.                 break;
  1620.               case 24:                /* code segments */
  1621.               case 25:
  1622.               case 26:
  1623.               case 27:
  1624.               case 28:
  1625.               case 29:
  1626.               case 30:
  1627.               case 31:
  1628.                 printf_filtered (" %s-bit Code (%s,  %sConf%s)",
  1629.                                  descr.bit32 ? "32" : "16",
  1630.                                  descr.stype & 2 ? "Exec/Read" : "Exec-Only",
  1631.                                  descr.stype & 4 ? "" : "N.",
  1632.                                  descr.stype & 1 ? "" : ", N.Acc");
  1633.                 break;
  1634.               default:
  1635.                 printf_filtered ("Unknown type 0x%02x", descr.stype);
  1636.                 break;
  1637.             }
  1638.           puts_filtered ("\n");
  1639.         }
  1640.       else if (force)
  1641.         {
  1642.           printf_filtered ("0x%03x: ",
  1643.                            type == 1
  1644.                            ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
  1645.           if (!descr.present)
  1646.             puts_filtered ("Segment not present\n");
  1647.           else
  1648.             printf_filtered ("Segment type 0x%02x is invalid in this table\n",
  1649.                              descr.stype);
  1650.         }
  1651.     }
  1652.   else if (force)
  1653.     printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
  1654. }

  1656. static void
  1657. ‌go32_sldt (char *arg, int from_tty)
  1658. {
  1659.   struct dtr_reg gdtr;
  1660.   unsigned short ldtr = 0;
  1661.   int ldt_idx;
  1662.   struct seg_descr ldt_descr;
  1663.   long ldt_entry = -1L;
  1664.   int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;

  1666.   if (arg && *arg)
  1667.     {
  1668.       arg = skip_spaces (arg);

  1670.       if (*arg)
  1671.         {
  1672.           ldt_entry = parse_and_eval_long (arg);
  1673.           if (ldt_entry < 0
  1674.               || (ldt_entry & 4) == 0
  1675.               || (ldt_entry & 3) != (cpl & 3))
  1676.             error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
  1677.         }
  1678.     }

  1680.   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
  1681.   __asm__ __volatile__ ("sldt   %0" : "=m" (ldtr) : /* no inputs */ );
  1682.   ldt_idx = ldtr / 8;
  1683.   if (ldt_idx == 0)
  1684.     puts_filtered ("There is no LDT.\n");
  1685.   /* LDT's entry in the GDT must have the type LDT, which is 2.  */
  1686.   else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
  1687.     printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
  1688.                      ldt_descr.base0
  1689.                      | (ldt_descr.base1 << 16)
  1690.                      | (ldt_descr.base2 << 24));
  1691.   else
  1692.     {
  1693.       unsigned base =
  1694.         ldt_descr.base0
  1695.         | (ldt_descr.base1 << 16)
  1696.         | (ldt_descr.base2 << 24);
  1697.       unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
  1698.       int max_entry;

  1700.       if (ldt_descr.page_granular)
  1701.         /* Page-granular segments must have the low 12 bits of their
  1702.            limit set.  */
  1703.         limit = (limit << 12) | 0xfff;
  1704.       /* LDT cannot have more than 8K 8-byte entries, i.e. more than
  1705.          64KB.  */
  1706.       if (limit > 0xffff)
  1707.         limit = 0xffff;

  1709.       max_entry = (limit + 1) / 8;

  1711.       if (ldt_entry >= 0)
  1712.         {
  1713.           if (ldt_entry > limit)
  1714.             error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
  1715.                    (unsigned long)ldt_entry, limit);

  1717.           display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
  1718.         }
  1719.       else
  1720.         {
  1721.           int i;

  1723.           for (i = 0; i < max_entry; i++)
  1724.             display_descriptor (ldt_descr.stype, base, i, 0);
  1725.         }
  1726.     }
  1727. }

  1729. static void
  1730. ‌go32_sgdt (char *arg, int from_tty)
  1731. {
  1732.   struct dtr_reg gdtr;
  1733.   long gdt_entry = -1L;
  1734.   int max_entry;

  1736.   if (arg && *arg)
  1737.     {
  1738.       arg = skip_spaces (arg);

  1740.       if (*arg)
  1741.         {
  1742.           gdt_entry = parse_and_eval_long (arg);
  1743.           if (gdt_entry < 0 || (gdt_entry & 7) != 0)
  1744.             error (_("Invalid GDT entry 0x%03lx: "
  1745.                      "not an integral multiple of 8."),
  1746.                    (unsigned long)gdt_entry);
  1747.         }
  1748.     }

  1750.   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
  1751.   max_entry = (gdtr.limit + 1) / 8;

  1753.   if (gdt_entry >= 0)
  1754.     {
  1755.       if (gdt_entry > gdtr.limit)
  1756.         error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
  1757.                (unsigned long)gdt_entry, gdtr.limit);

  1759.       display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
  1760.     }
  1761.   else
  1762.     {
  1763.       int i;

  1765.       for (i = 0; i < max_entry; i++)
  1766.         display_descriptor (0, gdtr.base, i, 0);
  1767.     }
  1768. }

  1770. static void
  1771. ‌go32_sidt (char *arg, int from_tty)
  1772. {
  1773.   struct dtr_reg idtr;
  1774.   long idt_entry = -1L;
  1775.   int max_entry;

  1777.   if (arg && *arg)
  1778.     {
  1779.       arg = skip_spaces (arg);

  1781.       if (*arg)
  1782.         {
  1783.           idt_entry = parse_and_eval_long (arg);
  1784.           if (idt_entry < 0)
  1785.             error (_("Invalid (negative) IDT entry %ld."), idt_entry);
  1786.         }
  1787.     }

  1789.   __asm__ __volatile__ ("sidt   %0" : "=m" (idtr) : /* no inputs */ );
  1790.   max_entry = (idtr.limit + 1) / 8;
  1791.   if (max_entry > 0x100)        /* No more than 256 entries.  */
  1792.     max_entry = 0x100;

  1794.   if (idt_entry >= 0)
  1795.     {
  1796.       if (idt_entry > idtr.limit)
  1797.         error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
  1798.                (unsigned long)idt_entry, idtr.limit);

  1800.       display_descriptor (1, idtr.base, idt_entry, 1);
  1801.     }
  1802.   else
  1803.     {
  1804.       int i;

  1806.       for (i = 0; i < max_entry; i++)
  1807.         display_descriptor (1, idtr.base, i, 0);
  1808.     }
  1809. }

  1811. /* Cached linear address of the base of the page directory.  For
  1812.    now, available only under CWSDPMI.  Code based on ideas and
  1813.    suggestions from Charles Sandmann <sandmann@clio.rice.edu>.  */
  1814. ‌static unsigned long pdbr;

  1816. static unsigned long
  1817. ‌get_cr3 (void)
  1818. {
  1819.   unsigned offset;
  1820.   unsigned taskreg;
  1821.   unsigned long taskbase, cr3;
  1822.   struct dtr_reg gdtr;

  1824.   if (pdbr > 0 && pdbr <= 0xfffff)
  1825.     return pdbr;

  1827.   /* Get the linear address of GDT and the Task Register.  */
  1828.   __asm__ __volatile__ ("sgdt   %0" : "=m" (gdtr) : /* no inputs */ );
  1829.   __asm__ __volatile__ ("str    %0" : "=m" (taskreg) : /* no inputs */ );

  1831.   /* Task Register is a segment selector for the TSS of the current
  1832.      task.  Therefore, it can be used as an index into the GDT to get
  1833.      at the segment descriptor for the TSS.  To get the index, reset
  1834.      the low 3 bits of the selector (which give the CPL).  Add 2 to the
  1835.      offset to point to the 3 low bytes of the base address.  */
  1836.   offset = gdtr.base + (taskreg & 0xfff8) + 2;


  1839.   /* CWSDPMI's task base is always under the 1MB mark.  */
  1840.   if (offset > 0xfffff)
  1841.     return 0;

  1843.   _farsetsel (_dos_ds);
  1844.   taskbase  = _farnspeekl (offset) & 0xffffffU;
  1845.   taskbase += _farnspeekl (offset + 2) & 0xff000000U;
  1846.   if (taskbase > 0xfffff)
  1847.     return 0;

  1849.   /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
  1850.      offset 1Ch in the TSS.  */
  1851.   cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
  1852.   if (cr3 > 0xfffff)
  1853.     {
  1854. #if 0  /* Not fullly supported yet.  */
  1855.       /* The Page Directory is in UMBs.  In that case, CWSDPMI puts
  1856.          the first Page Table right below the Page Directory.  Thus,
  1857.          the first Page Table's entry for its own address and the Page
  1858.          Directory entry for that Page Table will hold the same
  1859.          physical address.  The loop below searches the entire UMB
  1860.          range of addresses for such an occurence.  */
  1861.       unsigned long addr, pte_idx;

  1863.       for (addr = 0xb0000, pte_idx = 0xb0;
  1864.            pte_idx < 0xff;
  1865.            addr += 0x1000, pte_idx++)
  1866.         {
  1867.           if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
  1868.                (_farnspeekl (addr + 0x1000) & 0xfffff027))
  1869.               && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
  1870.             {
  1871.               cr3 = addr + 0x1000;
  1872.               break;
  1873.             }
  1874.         }
  1875. #endif

  1877.       if (cr3 > 0xfffff)
  1878.         cr3 = 0;
  1879.     }

  1881.   return cr3;
  1882. }

  1884. /* Return the N'th Page Directory entry.  */
  1885. static unsigned long
  1886. ‌get_pde (int n)
  1887. {
  1888.   unsigned long pde = 0;

  1890.   if (pdbr && n >= 0 && n < 1024)
  1891.     {
  1892.       pde = _farpeekl (_dos_ds, pdbr + 4*n);
  1893.     }
  1894.   return pde;
  1895. }

  1897. /* Return the N'th entry of the Page Table whose Page Directory entry
  1898.    is PDE.  */
  1899. static unsigned long
  1900. ‌get_pte (unsigned long pde, int n)
  1901. {
  1902.   unsigned long pte = 0;

  1904.   /* pde & 0x80 tests the 4MB page bit.  We don't support 4MB
  1905.      page tables, for now.  */
  1906.   if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
  1907.     {
  1908.       pde &= ~0xfff;        /* Clear non-address bits.  */
  1909.       pte = _farpeekl (_dos_ds, pde + 4*n);
  1910.     }
  1911.   return pte;
  1912. }

  1914. /* Display a Page Directory or Page Table entry.  IS_DIR, if non-zero,
  1915.    says this is a Page Directory entry.  If FORCE is non-zero, display
  1916.    the entry even if its Present flag is off.  OFF is the offset of the
  1917.    address from the page's base address.  */
  1918. static void
  1919. ‌display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
  1920. {
  1921.   if ((entry & 1) != 0)
  1922.     {
  1923.       printf_filtered ("Base=0x%05lx000", entry >> 12);
  1924.       if ((entry & 0x100) && !is_dir)
  1925.         puts_filtered (" Global");
  1926.       if ((entry & 0x40) && !is_dir)
  1927.         puts_filtered (" Dirty");
  1928.       printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
  1929.       printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
  1930.       printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
  1931.       printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
  1932.       printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
  1933.       if (off)
  1934.         printf_filtered (" +0x%x", off);
  1935.       puts_filtered ("\n");
  1936.     }
  1937.   else if (force)
  1938.     printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
  1939.                      is_dir ? " Table" : "", entry >> 1);
  1940. }

  1942. static void
  1943. ‌go32_pde (char *arg, int from_tty)
  1944. {
  1945.   long pde_idx = -1, i;

  1947.   if (arg && *arg)
  1948.     {
  1949.       arg = skip_spaces (arg);

  1951.       if (*arg)
  1952.         {
  1953.           pde_idx = parse_and_eval_long (arg);
  1954.           if (pde_idx < 0 || pde_idx >= 1024)
  1955.             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
  1956.         }
  1957.     }

  1959.   pdbr = get_cr3 ();
  1960.   if (!pdbr)
  1961.     puts_filtered ("Access to Page Directories is "
  1962.                    "not supported on this system.\n");
  1963.   else if (pde_idx >= 0)
  1964.     display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
  1965.   else
  1966.     for (i = 0; i < 1024; i++)
  1967.       display_ptable_entry (get_pde (i), 1, 0, 0);
  1968. }

  1970. /* A helper function to display entries in a Page Table pointed to by
  1971.    the N'th entry in the Page Directory.  If FORCE is non-zero, say
  1972.    something even if the Page Table is not accessible.  */
  1973. static void
  1974. ‌display_page_table (long n, int force)
  1975. {
  1976.   unsigned long pde = get_pde (n);

  1978.   if ((pde & 1) != 0)
  1979.     {
  1980.       int i;

  1982.       printf_filtered ("Page Table pointed to by "
  1983.                        "Page Directory entry 0x%lx:\n", n);
  1984.       for (i = 0; i < 1024; i++)
  1985.         display_ptable_entry (get_pte (pde, i), 0, 0, 0);
  1986.       puts_filtered ("\n");
  1987.     }
  1988.   else if (force)
  1989.     printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
  1990. }

  1992. static void
  1993. ‌go32_pte (char *arg, int from_tty)
  1994. {
  1995.   long pde_idx = -1L, i;

  1997.   if (arg && *arg)
  1998.     {
  1999.       arg = skip_spaces (arg);

  2001.       if (*arg)
  2002.         {
  2003.           pde_idx = parse_and_eval_long (arg);
  2004.           if (pde_idx < 0 || pde_idx >= 1024)
  2005.             error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
  2006.         }
  2007.     }

  2009.   pdbr = get_cr3 ();
  2010.   if (!pdbr)
  2011.     puts_filtered ("Access to Page Tables is not supported on this system.\n");
  2012.   else if (pde_idx >= 0)
  2013.     display_page_table (pde_idx, 1);
  2014.   else
  2015.     for (i = 0; i < 1024; i++)
  2016.       display_page_table (i, 0);
  2017. }

  2019. static void
  2020. ‌go32_pte_for_address (char *arg, int from_tty)
  2021. {
  2022.   CORE_ADDR addr = 0, i;

  2024.   if (arg && *arg)
  2025.     {
  2026.       arg = skip_spaces (arg);

  2028.       if (*arg)
  2029.         addr = parse_and_eval_address (arg);
  2030.     }
  2031.   if (!addr)
  2032.     error_no_arg (_("linear address"));

  2034.   pdbr = get_cr3 ();
  2035.   if (!pdbr)
  2036.     puts_filtered ("Access to Page Tables is not supported on this system.\n");
  2037.   else
  2038.     {
  2039.       int pde_idx = (addr >> 22) & 0x3ff;
  2040.       int pte_idx = (addr >> 12) & 0x3ff;
  2041.       unsigned offs = addr & 0xfff;

  2043.       printf_filtered ("Page Table entry for address %s:\n",
  2044.                        hex_string(addr));
  2045.       display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
  2046.     }
  2047. }

  2049. ‌static struct cmd_list_element *info_dos_cmdlist = NULL;

  2051. static void
  2052. ‌go32_info_dos_command (char *args, int from_tty)
  2053. {
  2054.   help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
  2055. }

  2057. /* -Wmissing-prototypes */
  2058. extern initialize_file_ftype _initialize_go32_nat;

  2060. void
  2061. ‌_initialize_go32_nat (void)
  2062. {
  2063.   struct target_ops *t = go32_target ();

  2065.   x86_dr_low.set_control = go32_set_dr7;
  2066.   x86_dr_low.set_addr = go32_set_dr;
  2067.   x86_dr_low.get_status = go32_get_dr6;
  2068.   x86_dr_low.get_control = go32_get_dr7;
  2069.   x86_dr_low.get_addr = go32_get_dr;
  2070.   x86_set_debug_register_length (4);

  2072.   x86_use_watchpoints (t);
  2073.   add_target (t);

  2075.   /* Initialize child's cwd as empty to be initialized when starting
  2076.      the child.  */
  2077.   *child_cwd = 0;

  2079.   /* Initialize child's command line storage.  */
  2080.   if (redir_debug_init (&child_cmd) == -1)
  2081.     internal_error (__FILE__, __LINE__,
  2082.                     _("Cannot allocate redirection storage: "
  2083.                       "not enough memory.\n"));

  2085.   /* We are always processing GCC-compiled programs.  */
  2086.   processing_gcc_compilation = 2;

  2088.   add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
  2089. Print information specific to DJGPP (aka MS-DOS) debugging."),
  2090.                   &info_dos_cmdlist, "info dos ", 0, &infolist);

  2092.   add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
  2093. Display information about the target system, including CPU, OS, DPMI, etc."),
  2094.            &info_dos_cmdlist);
  2095.   add_cmd ("ldt", class_info, go32_sldt, _("\
  2096. Display entries in the LDT (Local Descriptor Table).\n\
  2097. Entry number (an expression) as an argument means display only that entry."),
  2098.            &info_dos_cmdlist);
  2099.   add_cmd ("gdt", class_info, go32_sgdt, _("\
  2100. Display entries in the GDT (Global Descriptor Table).\n\
  2101. Entry number (an expression) as an argument means display only that entry."),
  2102.            &info_dos_cmdlist);
  2103.   add_cmd ("idt", class_info, go32_sidt, _("\
  2104. Display entries in the IDT (Interrupt Descriptor Table).\n\
  2105. Entry number (an expression) as an argument means display only that entry."),
  2106.            &info_dos_cmdlist);
  2107.   add_cmd ("pde", class_info, go32_pde, _("\
  2108. Display entries in the Page Directory.\n\
  2109. Entry number (an expression) as an argument means display only that entry."),
  2110.            &info_dos_cmdlist);
  2111.   add_cmd ("pte", class_info, go32_pte, _("\
  2112. Display entries in Page Tables.\n\
  2113. Entry number (an expression) as an argument means display only entries\n\
  2114. from the Page Table pointed to by the specified Page Directory entry."),
  2115.            &info_dos_cmdlist);
  2116.   add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
  2117. Display a Page Table entry for a linear address.\n\
  2118. The address argument must be a linear address, after adding to\n\
  2119. it the base address of the appropriate segment.\n\
  2120. The base address of variables and functions in the debuggee's data\n\
  2121. or code segment is stored in the variable __djgpp_base_address,\n\
  2122. so use `__djgpp_base_address + (char *)&var' as the argument.\n\
  2123. For other segments, look up their base address in the output of\n\
  2124. the `info dos ldt' command."),
  2125.            &info_dos_cmdlist);
  2126. }

  2128. pid_t
  2129. ‌tcgetpgrp (int fd)
  2130. {
  2131.   if (isatty (fd))
  2132.     return SOME_PID;
  2133.   errno = ENOTTY;
  2134.   return -1;
  2135. }

  2137. int
  2138. ‌tcsetpgrp (int fd, pid_t pgid)
  2139. {
  2140.   if (isatty (fd) && pgid == SOME_PID)
  2141.     return 0;
  2142.   errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
  2143.   return -1;
  2144. }