/* Native debugging support for Intel x86 running DJGPP.
- Copyright 1997, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1997, 1999, 2000, 2001, 2005, 2006, 2007, 2008, 2009
+ Free Software Foundation, Inc.
Written by Robert Hoehne.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <fcntl.h>
#include "defs.h"
-#include "frame.h" /* required by inferior.h */
#include "inferior.h"
-#include "target.h"
+#include "gdbthread.h"
#include "gdb_wait.h"
#include "gdbcore.h"
#include "command.h"
+#include "gdbcmd.h"
#include "floatformat.h"
-
-#include <stdio.h> /* required for __DJGPP_MINOR__ */
+#include "buildsym.h"
+#include "i387-tdep.h"
+#include "i386-tdep.h"
+#include "value.h"
+#include "regcache.h"
+#include "gdb_string.h"
+#include "top.h"
+
+#include <stdio.h> /* might be required for __DJGPP_MINOR__ */
#include <stdlib.h>
-#include <string.h>
+#include <ctype.h>
#include <errno.h>
#include <unistd.h>
+#include <sys/utsname.h>
#include <io.h>
+#include <dos.h>
#include <dpmi.h>
+#include <go32.h>
+#include <sys/farptr.h>
#include <debug/v2load.h>
#include <debug/dbgcom.h>
#if __DJGPP_MINOR__ > 2
static void
save_npx (void)
{
- asm ("inb $0xa0, %%al
- testb $0x20, %%al
- jz 1f
- xorb %% al, %%al
- outb %% al, $0xf0
- movb $0x20, %%al
- outb %% al, $0xa0
- outb %% al, $0x20
-1:
- fnsave % 0
+ asm ("inb $0xa0, %%al \n\
+ testb $0x20, %%al \n\
+ jz 1f \n\
+ xorb %%al, %%al \n\
+ outb %%al, $0xf0 \n\
+ movb $0x20, %%al \n\
+ outb %%al, $0xa0 \n\
+ outb %%al, $0x20 \n\
+1: \n\
+ fnsave %0 \n\
fwait "
: "=m" (npx)
: /* No input */
/* *INDENT-ON* */
-
-
-
/* ------------------------------------------------------------------------- */
/* Reload the contents of the NPX from the global variable `npx'. */
static void
load_npx (void)
{
-asm ("frstor %0":"=m" (npx));
+ asm ("frstor %0":"=m" (npx));
}
/* ------------------------------------------------------------------------- */
/* Stubs for the missing redirection functions. */
int redirected;
} cmdline_t;
-void redir_cmdline_delete (cmdline_t *ptr) {ptr->redirected = 0;}
-int redir_cmdline_parse (const char *args, cmdline_t *ptr)
+void
+redir_cmdline_delete (cmdline_t *ptr)
+{
+ ptr->redirected = 0;
+}
+
+int
+redir_cmdline_parse (const char *args, cmdline_t *ptr)
{
return -1;
}
-int redir_to_child (cmdline_t *ptr)
+
+int
+redir_to_child (cmdline_t *ptr)
{
return 1;
}
-int redir_to_debugger (cmdline_t *ptr)
+
+int
+redir_to_debugger (cmdline_t *ptr)
{
return 1;
}
-int redir_debug_init (cmdline_t *ptr) { return 0; }
-#endif /* __DJGPP_MINOR < 3 */
-
-extern void _initialize_go32_nat (void);
-struct env387
- {
- unsigned short control;
- unsigned short r0;
- unsigned short status;
- unsigned short r1;
- unsigned short tag;
- unsigned short r2;
- unsigned long eip;
- unsigned short code_seg;
- unsigned short opcode;
- unsigned long operand;
- unsigned short operand_seg;
- unsigned short r3;
- unsigned char regs[8][10];
- };
+int
+redir_debug_init (cmdline_t *ptr)
+{
+ return 0;
+}
+#endif /* __DJGPP_MINOR < 3 */
typedef enum { wp_insert, wp_remove, wp_count } wp_op;
/* This holds the current reference counts for each debug register. */
static int dr_ref_count[4];
-extern char **environ;
-
#define SOME_PID 42
static int prog_has_started = 0;
-static void print_387_status (unsigned short status, struct env387 *ep);
static void go32_open (char *name, int from_tty);
static void go32_close (int quitting);
static void go32_attach (char *args, int from_tty);
static void go32_detach (char *args, int from_tty);
-static void go32_resume (int pid, int step, enum target_signal siggnal);
-static int go32_wait (int pid, struct target_waitstatus *status);
-static void go32_fetch_registers (int regno);
-static void store_register (int regno);
-static void go32_store_registers (int regno);
-static void go32_prepare_to_store (void);
-static int go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
- int write, struct target_ops *target);
+static void go32_resume (struct target_ops *ops,
+ ptid_t ptid, int step,
+ enum target_signal siggnal);
+static void go32_fetch_registers (struct target_ops *ops,
+ struct regcache *, int regno);
+static void store_register (const struct regcache *, int regno);
+static void go32_store_registers (struct target_ops *ops,
+ struct regcache *, int regno);
+static void go32_prepare_to_store (struct regcache *);
+static int go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
+ int write,
+ struct mem_attrib *attrib,
+ struct target_ops *target);
static void go32_files_info (struct target_ops *target);
-static void go32_stop (void);
-static void go32_kill_inferior (void);
-static void go32_create_inferior (char *exec_file, char *args, char **env);
-static void cleanup_dregs (void);
-static void go32_mourn_inferior (void);
+static void go32_stop (ptid_t);
+static void go32_kill_inferior (struct target_ops *ops);
+static void go32_create_inferior (struct target_ops *ops, char *exec_file,
+ char *args, char **env, int from_tty);
+static void go32_mourn_inferior (struct target_ops *ops);
static int go32_can_run (void);
-static void ignore (void);
-static void ignore2 (char *a, int b);
-static int go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
- int len, int rw);
-static int go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
- int len, int rw);
-static int go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr,
- CORE_ADDR addr, int len, int rw);
static struct target_ops go32_ops;
static void go32_terminal_init (void);
static void go32_terminal_inferior (void);
static void go32_terminal_ours (void);
-static void
-print_387_status (unsigned short status, struct env387 *ep)
-{
- int i;
- int bothstatus;
- int top;
- int fpreg;
-
- bothstatus = ((status != 0) && (ep->status != 0));
- if (status != 0)
- {
- if (bothstatus)
- printf_unfiltered ("u: ");
- print_387_status_word (status);
- }
-
- if (ep->status != 0)
- {
- if (bothstatus)
- printf_unfiltered ("e: ");
- print_387_status_word (ep->status);
- }
-
- print_387_control_word (ep->control & 0xffff);
- /* Other platforms say "last exception", but that's not true: the
- FPU stores the last non-control instruction there. */
- printf_unfiltered ("last FP instruction: ");
- /* The ORing with D800h restores the upper 5 bits of the opcode that
- are not stored by the FPU (since these bits are the same for all
- floating-point instructions). */
- printf_unfiltered ("opcode %s; ",
- local_hex_string (ep->opcode ? (ep->opcode|0xd800) : 0));
- printf_unfiltered ("pc %s:", local_hex_string (ep->code_seg));
- printf_unfiltered ("%s; ", local_hex_string (ep->eip));
- printf_unfiltered ("operand %s", local_hex_string (ep->operand_seg));
- printf_unfiltered (":%s\n", local_hex_string (ep->operand));
-
- top = (ep->status >> 11) & 7;
-
- printf_unfiltered ("regno tag msb lsb value\n");
- for (fpreg = 7; fpreg >= 0; fpreg--)
- {
- /* FNSAVE saves the FP registers in their logical TOP-relative
- order, beginning with ST(0). Since we need to print them in
- their physical order, we have to remap them. */
- int regno = fpreg - top;
- long double val;
-
- if (regno < 0)
- regno += 8;
-
- printf_unfiltered ("%s %d: ", fpreg == top ? "=>" : " ", fpreg);
-
- switch ((ep->tag >> (fpreg * 2)) & 3)
- {
- case 0:
- printf_unfiltered ("valid ");
- break;
- case 1:
- printf_unfiltered ("zero ");
- break;
- case 2:
- /* All other versions of print_387_status use TRAP here, but I
- think this is misleading, since Intel manuals say SPECIAL. */
- printf_unfiltered ("special ");
- break;
- case 3:
- printf_unfiltered ("empty ");
- break;
- }
- for (i = 9; i >= 0; i--)
- printf_unfiltered ("%02x", ep->regs[regno][i]);
-
- REGISTER_CONVERT_TO_VIRTUAL (FP0_REGNUM+regno, builtin_type_long_double,
- &ep->regs[regno], &val);
-
- printf_unfiltered (" %.19LG\n", val);
- }
-}
-
-void
-i386_go32_float_info (void)
-{
- print_387_status (0, (struct env387 *) &npx);
-}
-
#define r_ofs(x) (offsetof(TSS,x))
static struct
}
regno_mapping[] =
{
- r_ofs (tss_eax), 4, /* normal registers, from a_tss */
- r_ofs (tss_ecx), 4,
- r_ofs (tss_edx), 4,
- r_ofs (tss_ebx), 4,
- r_ofs (tss_esp), 4,
- r_ofs (tss_ebp), 4,
- r_ofs (tss_esi), 4,
- r_ofs (tss_edi), 4,
- r_ofs (tss_eip), 4,
- r_ofs (tss_eflags), 4,
- r_ofs (tss_cs), 2,
- r_ofs (tss_ss), 2,
- r_ofs (tss_ds), 2,
- r_ofs (tss_es), 2,
- r_ofs (tss_fs), 2,
- r_ofs (tss_gs), 2,
- 0, 10, /* 8 FP registers, from npx.reg[] */
- 1, 10,
- 2, 10,
- 3, 10,
- 4, 10,
- 5, 10,
- 6, 10,
- 7, 10,
+ {r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
+ {r_ofs (tss_ecx), 4},
+ {r_ofs (tss_edx), 4},
+ {r_ofs (tss_ebx), 4},
+ {r_ofs (tss_esp), 4},
+ {r_ofs (tss_ebp), 4},
+ {r_ofs (tss_esi), 4},
+ {r_ofs (tss_edi), 4},
+ {r_ofs (tss_eip), 4},
+ {r_ofs (tss_eflags), 4},
+ {r_ofs (tss_cs), 2},
+ {r_ofs (tss_ss), 2},
+ {r_ofs (tss_ds), 2},
+ {r_ofs (tss_es), 2},
+ {r_ofs (tss_fs), 2},
+ {r_ofs (tss_gs), 2},
+ {0, 10}, /* 8 FP registers, from npx.reg[] */
+ {1, 10},
+ {2, 10},
+ {3, 10},
+ {4, 10},
+ {5, 10},
+ {6, 10},
+ {7, 10},
/* The order of the next 7 registers must be consistent
- with their numbering in config/i386/tm-go32.h, which see. */
- 0, 2, /* control word, from npx */
- 4, 2, /* status word, from npx */
- 8, 2, /* tag word, from npx */
- 16, 2, /* last FP exception CS from npx */
- 24, 2, /* last FP exception operand selector from npx */
- 12, 4, /* last FP exception EIP from npx */
- 20, 4 /* last FP exception operand offset from npx */
+ with their numbering in config/i386/tm-i386.h, which see. */
+ {0, 2}, /* control word, from npx */
+ {4, 2}, /* status word, from npx */
+ {8, 2}, /* tag word, from npx */
+ {16, 2}, /* last FP exception CS from npx */
+ {12, 4}, /* last FP exception EIP from npx */
+ {24, 2}, /* last FP exception operand selector from npx */
+ {20, 4}, /* last FP exception operand offset from npx */
+ {18, 2} /* last FP opcode from npx */
};
static struct
{
int go32_sig;
- int gdb_sig;
+ enum target_signal gdb_sig;
}
sig_map[] =
{
- 0, TARGET_SIGNAL_FPE,
- 1, TARGET_SIGNAL_TRAP,
+ {0, TARGET_SIGNAL_FPE},
+ {1, TARGET_SIGNAL_TRAP},
/* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
but I think SIGBUS is better, since the NMI is usually activated
as a result of a memory parity check failure. */
- 2, TARGET_SIGNAL_BUS,
- 3, TARGET_SIGNAL_TRAP,
- 4, TARGET_SIGNAL_FPE,
- 5, TARGET_SIGNAL_SEGV,
- 6, TARGET_SIGNAL_ILL,
- 7, TARGET_SIGNAL_EMT, /* no-coprocessor exception */
- 8, TARGET_SIGNAL_SEGV,
- 9, TARGET_SIGNAL_SEGV,
- 10, TARGET_SIGNAL_BUS,
- 11, TARGET_SIGNAL_SEGV,
- 12, TARGET_SIGNAL_SEGV,
- 13, TARGET_SIGNAL_SEGV,
- 14, TARGET_SIGNAL_SEGV,
- 16, TARGET_SIGNAL_FPE,
- 17, TARGET_SIGNAL_BUS,
- 31, TARGET_SIGNAL_ILL,
- 0x1b, TARGET_SIGNAL_INT,
- 0x75, TARGET_SIGNAL_FPE,
- 0x78, TARGET_SIGNAL_ALRM,
- 0x79, TARGET_SIGNAL_INT,
- 0x7a, TARGET_SIGNAL_QUIT,
- -1, -1
+ {2, TARGET_SIGNAL_BUS},
+ {3, TARGET_SIGNAL_TRAP},
+ {4, TARGET_SIGNAL_FPE},
+ {5, TARGET_SIGNAL_SEGV},
+ {6, TARGET_SIGNAL_ILL},
+ {7, TARGET_SIGNAL_EMT}, /* no-coprocessor exception */
+ {8, TARGET_SIGNAL_SEGV},
+ {9, TARGET_SIGNAL_SEGV},
+ {10, TARGET_SIGNAL_BUS},
+ {11, TARGET_SIGNAL_SEGV},
+ {12, TARGET_SIGNAL_SEGV},
+ {13, TARGET_SIGNAL_SEGV},
+ {14, TARGET_SIGNAL_SEGV},
+ {16, TARGET_SIGNAL_FPE},
+ {17, TARGET_SIGNAL_BUS},
+ {31, TARGET_SIGNAL_ILL},
+ {0x1b, TARGET_SIGNAL_INT},
+ {0x75, TARGET_SIGNAL_FPE},
+ {0x78, TARGET_SIGNAL_ALRM},
+ {0x79, TARGET_SIGNAL_INT},
+ {0x7a, TARGET_SIGNAL_QUIT},
+ {-1, TARGET_SIGNAL_LAST}
};
static struct {
enum target_signal gdb_sig;
int djgpp_excepno;
} excepn_map[] = {
- TARGET_SIGNAL_0, -1,
- TARGET_SIGNAL_ILL, 6, /* Invalid Opcode */
- TARGET_SIGNAL_EMT, 7, /* triggers SIGNOFP */
- TARGET_SIGNAL_SEGV, 13, /* GPF */
- TARGET_SIGNAL_BUS, 17, /* Alignment Check */
+ {TARGET_SIGNAL_0, -1},
+ {TARGET_SIGNAL_ILL, 6}, /* Invalid Opcode */
+ {TARGET_SIGNAL_EMT, 7}, /* triggers SIGNOFP */
+ {TARGET_SIGNAL_SEGV, 13}, /* GPF */
+ {TARGET_SIGNAL_BUS, 17}, /* Alignment Check */
/* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
details. */
- TARGET_SIGNAL_TERM, 0x1b, /* triggers Ctrl-Break type of SIGINT */
- TARGET_SIGNAL_FPE, 0x75,
- TARGET_SIGNAL_INT, 0x79,
- TARGET_SIGNAL_QUIT, 0x7a,
- TARGET_SIGNAL_ALRM, 0x78, /* triggers SIGTIMR */
- TARGET_SIGNAL_PROF, 0x78,
- -1, -1
+ {TARGET_SIGNAL_TERM, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
+ {TARGET_SIGNAL_FPE, 0x75},
+ {TARGET_SIGNAL_INT, 0x79},
+ {TARGET_SIGNAL_QUIT, 0x7a},
+ {TARGET_SIGNAL_ALRM, 0x78}, /* triggers SIGTIMR */
+ {TARGET_SIGNAL_PROF, 0x78},
+ {TARGET_SIGNAL_LAST, -1}
};
static void
}
static void
-go32_attach (char *args, int from_tty)
+go32_attach (struct target_ops *ops, char *args, int from_tty)
{
- error ("\
+ error (_("\
You cannot attach to a running program on this platform.\n\
-Use the `run' command to run DJGPP programs.");
+Use the `run' command to run DJGPP programs."));
}
static void
-go32_detach (char *args, int from_tty)
+go32_detach (struct target_ops *ops, char *args, int from_tty)
{
}
static int resume_signal = -1;
static void
-go32_resume (int pid, int step, enum target_signal siggnal)
+go32_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal siggnal)
{
int i;
if (siggnal != TARGET_SIGNAL_0 && siggnal != TARGET_SIGNAL_TRAP)
{
- for (i = 0, resume_signal = -1; excepn_map[i].gdb_sig != -1; i++)
+ for (i = 0, resume_signal = -1;
+ excepn_map[i].gdb_sig != TARGET_SIGNAL_LAST; i++)
if (excepn_map[i].gdb_sig == siggnal)
{
resume_signal = excepn_map[i].djgpp_excepno;
static char child_cwd[FILENAME_MAX];
-static int
-go32_wait (int pid, struct target_waitstatus *status)
+static ptid_t
+go32_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
int i;
unsigned char saved_opcode;
- unsigned long INT3_addr;
+ unsigned long INT3_addr = 0;
int stepping_over_INT = 0;
a_tss.tss_eflags &= 0xfeff; /* reset the single-step flag (TF) */
point of changing back to where GDB thinks is its cwd, when we
return control to the debugger, but restore child's cwd before we
run it. */
+ /* Initialize child_cwd, before the first call to run_child and not
+ in the initialization, so the child get also the changed directory
+ set with the gdb-command "cd ..." */
+ if (!*child_cwd)
+ /* Initialize child's cwd with the current one. */
+ getcwd (child_cwd, sizeof (child_cwd));
+
chdir (child_cwd);
#if __DJGPP_MINOR__ < 3
}
}
}
- return SOME_PID;
+ return pid_to_ptid (SOME_PID);
}
static void
-go32_fetch_registers (int regno)
+fetch_register (struct regcache *regcache, int regno)
{
- /*JHW */
- int end_reg = regno + 1; /* just one reg initially */
-
- if (regno < 0) /* do the all registers */
- {
- regno = 0; /* start at first register */
- /* # regs in table */
- end_reg = sizeof (regno_mapping) / sizeof (regno_mapping[0]);
- }
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ if (regno < gdbarch_fp0_regnum (gdbarch))
+ regcache_raw_supply (regcache, regno,
+ (char *) &a_tss + regno_mapping[regno].tss_ofs);
+ else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
+ i387_supply_fsave (regcache, regno, &npx);
+ else
+ internal_error (__FILE__, __LINE__,
+ _("Invalid register no. %d in fetch_register."), regno);
+}
- for (; regno < end_reg; regno++)
+static void
+go32_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
+{
+ if (regno >= 0)
+ fetch_register (regcache, regno);
+ else
{
- if (regno < 16)
- supply_register (regno,
- (char *) &a_tss + regno_mapping[regno].tss_ofs);
- else if (regno < 24)
- supply_register (regno,
- (char *) &npx.reg[regno_mapping[regno].tss_ofs]);
- else if (regno < 31)
- supply_register (regno,
- (char *) &npx + regno_mapping[regno].tss_ofs);
- else
- internal_error ("Invalid register no. %d in go32_fetch_register.",
- regno);
+ for (regno = 0;
+ regno < gdbarch_fp0_regnum (get_regcache_arch (regcache));
+ regno++)
+ fetch_register (regcache, regno);
+ i387_supply_fsave (regcache, -1, &npx);
}
}
static void
-store_register (int regno)
+store_register (const struct regcache *regcache, int regno)
{
- void *rp;
- void *v = (void *) ®isters[REGISTER_BYTE (regno)];
-
- if (regno < 16)
- rp = (char *) &a_tss + regno_mapping[regno].tss_ofs;
- else if (regno < 24)
- rp = (char *) &npx.reg[regno_mapping[regno].tss_ofs];
- else if (regno < 31)
- rp = (char *) &npx + regno_mapping[regno].tss_ofs;
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ if (regno < gdbarch_fp0_regnum (gdbarch))
+ regcache_raw_collect (regcache, regno,
+ (char *) &a_tss + regno_mapping[regno].tss_ofs);
+ else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch, regno))
+ i387_collect_fsave (regcache, regno, &npx);
else
- internal_error ("Invalid register no. %d in store_register.", regno);
- memcpy (rp, v, regno_mapping[regno].size);
+ internal_error (__FILE__, __LINE__,
+ _("Invalid register no. %d in store_register."), regno);
}
static void
-go32_store_registers (int regno)
+go32_store_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
- int r;
+ unsigned r;
if (regno >= 0)
- store_register (regno);
+ store_register (regcache, regno);
else
{
- for (r = 0; r < sizeof (regno_mapping) / sizeof (regno_mapping[0]); r++)
- store_register (r);
+ for (r = 0; r < gdbarch_fp0_regnum (get_regcache_arch (regcache)); r++)
+ store_register (regcache, r);
+ i387_collect_fsave (regcache, -1, &npx);
}
}
static void
-go32_prepare_to_store (void)
+go32_prepare_to_store (struct regcache *regcache)
{
}
static int
-go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct target_ops *target)
+go32_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
+ struct mem_attrib *attrib, struct target_ops *target)
{
if (write)
{
}
static void
-go32_stop (void)
+go32_stop (ptid_t ptid)
{
normal_stop ();
cleanup_client ();
- inferior_pid = 0;
+ ptid = inferior_ptid;
+ inferior_ptid = null_ptid;
+ delete_thread_silent (ptid);
prog_has_started = 0;
}
static void
-go32_kill_inferior (void)
+go32_kill_inferior (struct target_ops *ops)
{
redir_cmdline_delete (&child_cmd);
resume_signal = -1;
resume_is_step = 0;
+ if (!ptid_equal (inferior_ptid, null_ptid))
+ delete_thread_silent (inferior_ptid);
unpush_target (&go32_ops);
}
static void
-go32_create_inferior (char *exec_file, char *args, char **env)
+go32_create_inferior (struct target_ops *ops, char *exec_file,
+ char *args, char **env, int from_tty)
{
+ extern char **environ;
jmp_buf start_state;
char *cmdline;
char **env_save = environ;
+ size_t cmdlen;
+
+ /* If no exec file handed to us, get it from the exec-file command -- with
+ a good, common error message if none is specified. */
+ if (exec_file == 0)
+ exec_file = get_exec_file (1);
if (prog_has_started)
{
- go32_stop ();
- go32_kill_inferior ();
+ go32_stop (inferior_ptid);
+ go32_kill_inferior (ops);
}
resume_signal = -1;
resume_is_step = 0;
+
+ /* Initialize child's cwd as empty to be initialized when starting
+ the child. */
+ *child_cwd = 0;
+
/* Init command line storage. */
if (redir_debug_init (&child_cmd) == -1)
- internal_error ("Cannot allocate redirection storage: not enough memory.\n");
+ internal_error (__FILE__, __LINE__,
+ _("Cannot allocate redirection storage: not enough memory.\n"));
/* Parse the command line and create redirections. */
if (strpbrk (args, "<>"))
if (redir_cmdline_parse (args, &child_cmd) == 0)
args = child_cmd.command;
else
- error ("Syntax error in command line.");
+ error (_("Syntax error in command line."));
}
else
child_cmd.command = xstrdup (args);
- cmdline = (char *) alloca (strlen (args) + 4);
- cmdline[0] = strlen (args);
+ cmdlen = strlen (args);
+ /* v2loadimage passes command lines via DOS memory, so it cannot
+ possibly handle commands longer than 1MB. */
+ if (cmdlen > 1024*1024)
+ error (_("Command line too long."));
+
+ cmdline = xmalloc (cmdlen + 4);
strcpy (cmdline + 1, args);
- cmdline[strlen (args) + 1] = 13;
+ /* If the command-line length fits into DOS 126-char limits, use the
+ DOS command tail format; otherwise, tell v2loadimage to pass it
+ through a buffer in conventional memory. */
+ if (cmdlen < 127)
+ {
+ cmdline[0] = strlen (args);
+ cmdline[cmdlen + 1] = 13;
+ }
+ else
+ cmdline[0] = 0xff; /* signal v2loadimage it's a long command */
environ = env;
exit (1);
}
environ = env_save;
+ xfree (cmdline);
edi_init (start_state);
#if __DJGPP_MINOR__ < 3
save_npx ();
#endif
- inferior_pid = SOME_PID;
+ inferior_ptid = pid_to_ptid (SOME_PID);
+ add_inferior_silent (SOME_PID);
+
push_target (&go32_ops);
+
+ add_thread_silent (inferior_ptid);
+
clear_proceed_status ();
insert_breakpoints ();
- proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
prog_has_started = 1;
}
static void
-go32_mourn_inferior (void)
+go32_mourn_inferior (struct target_ops *ops)
{
/* We need to make sure all the breakpoint enable bits in the DR7
register are reset when the inferior exits. Otherwise, if they
be nice if GDB itself would take care to remove all breakpoints
at all times, but it doesn't, probably under an assumption that
the OS cleans up when the debuggee exits. */
- cleanup_dregs ();
- go32_kill_inferior ();
+ i386_cleanup_dregs ();
+ go32_kill_inferior (ops);
generic_mourn_inferior ();
}
return 1;
}
-static void
-ignore (void)
-{
-}
-
/* Hardware watchpoint support. */
-#define DR_STATUS 6
-#define DR_CONTROL 7
-#define DR_ENABLE_SIZE 2
-#define DR_LOCAL_ENABLE_SHIFT 0
-#define DR_GLOBAL_ENABLE_SHIFT 1
-#define DR_LOCAL_SLOWDOWN 0x100
-#define DR_GLOBAL_SLOWDOWN 0x200
-#define DR_CONTROL_SHIFT 16
-#define DR_CONTROL_SIZE 4
-#define DR_RW_READWRITE 0x3
-#define DR_RW_WRITE 0x1
-#define DR_CONTROL_MASK 0xf
-#define DR_ENABLE_MASK 0x3
-#define DR_LEN_1 0x0
-#define DR_LEN_2 0x4
-#define DR_LEN_4 0xc
-
#define D_REGS edi.dr
-#define CONTROL D_REGS[DR_CONTROL]
-#define STATUS D_REGS[DR_STATUS]
-
-#define IS_REG_FREE(index) \
- (!(CONTROL & (3 << (DR_ENABLE_SIZE * (index)))))
-
-#define LOCAL_ENABLE_REG(index) \
- (CONTROL |= (1 << (DR_LOCAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
-
-#define GLOBAL_ENABLE_REG(index) \
- (CONTROL |= (1 << (DR_GLOBAL_ENABLE_SHIFT + DR_ENABLE_SIZE * (index))))
-
-#define DISABLE_REG(index) \
- (CONTROL &= ~(3 << (DR_ENABLE_SIZE * (index))))
-
-#define SET_LOCAL_EXACT() \
- (CONTROL |= DR_LOCAL_SLOWDOWN)
-
-#define SET_GLOBAL_EXACT() \
- (CONTROL |= DR_GLOBAL_SLOWDOWN)
-
-#define RESET_LOCAL_EXACT() \
- (CONTROL &= ~(DR_LOCAL_SLOWDOWN))
-
-#define RESET_GLOBAL_EXACT() \
- (CONTROL &= ~(DR_GLOBAL_SLOWDOWN))
-
-#define SET_BREAK(index,address) \
- do {\
- CONTROL &= ~(DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index)));\
- D_REGS[index] = address;\
- dr_ref_count[index]++;\
- } while(0)
-
-#define SET_WATCH(index,address,rw,len) \
- do {\
- SET_BREAK(index,address);\
- CONTROL |= ((len)|(rw)) << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index));\
- } while (0)
-
-#define IS_WATCH(index) \
- (CONTROL & (DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE*(index))))
-
-#define WATCH_HIT(index) ((STATUS & (1 << (index))) && IS_WATCH(index))
-
-#define DR_DEF(index) \
- ((CONTROL >> (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * (index))) & 0x0f)
-
-
-#if 0 /* use debugging macro */
-#define SHOW_DR(text,len) \
-do { \
- if (!getenv ("GDB_SHOW_DR")) break; \
- fprintf(stderr,"%08x %08x ",edi.dr[7],edi.dr[6]); \
- fprintf(stderr,"%08x %d %08x %d ", \
- edi.dr[0],dr_ref_count[0],edi.dr[1],dr_ref_count[1]); \
- fprintf(stderr,"%08x %d %08x %d ", \
- edi.dr[2],dr_ref_count[2],edi.dr[3],dr_ref_count[3]); \
- fprintf(stderr,(len)?"(%s:%d)\n":"(%s)\n",#text,len); \
-} while (0)
-#else
-#define SHOW_DR(text,len) do {} while (0)
-#endif
-
-static void
-cleanup_dregs (void)
-{
- int i;
-
- CONTROL = 0;
- STATUS = 0;
- for (i = 0; i < 4; i++)
- {
- D_REGS[i] = 0;
- dr_ref_count[i] = 0;
- }
-}
-
-/* Insert a watchpoint. */
-
-int
-go32_insert_watchpoint (int pid, CORE_ADDR addr, int len, int rw)
-{
- int ret = go32_insert_aligned_watchpoint (addr, addr, len, rw);
-
- SHOW_DR (insert_watch, len);
- return ret;
-}
-
-static int
-go32_insert_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
- int len, int rw)
-{
- int i;
- int read_write_bits, len_bits;
-
- /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
- However, x86 doesn't support read-only data breakpoints. */
- read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE;
-
- switch (len)
- {
- case 4:
- len_bits = DR_LEN_4;
- break;
- case 2:
- len_bits = DR_LEN_2;
- break;
- case 1:
- len_bits = DR_LEN_1;
- break;
- default:
- /* The debug registers only have 2 bits for the length, so
- so this value will always fail the loop below. */
- len_bits = 0x10;
- }
-
- /* Look for an occupied debug register with the same address and the
- same RW and LEN definitions. If we find one, we can use it for
- this watchpoint as well (and save a register). */
- for (i = 0; i < 4; i++)
- {
- if (!IS_REG_FREE (i) && D_REGS[i] == addr
- && DR_DEF (i) == (len_bits | read_write_bits))
- {
- dr_ref_count[i]++;
- return 0;
- }
- }
-
- /* Look for a free debug register. */
- for (i = 0; i <= 3; i++)
- {
- if (IS_REG_FREE (i))
- break;
- }
-
- /* No more debug registers! */
- if (i > 3)
- return -1;
-
- if (len == 2)
- {
- if (addr % 2)
- return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr,
- len, rw);
- }
- else if (len == 4)
- {
- if (addr % 4)
- return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr,
- len, rw);
- }
- else if (len != 1)
- return go32_handle_nonaligned_watchpoint (wp_insert, waddr, addr, len, rw);
-
- SET_WATCH (i, addr, read_write_bits, len_bits);
- LOCAL_ENABLE_REG (i);
- SET_LOCAL_EXACT ();
- SET_GLOBAL_EXACT ();
- return 0;
-}
-
-static int
-go32_handle_nonaligned_watchpoint (wp_op what, CORE_ADDR waddr, CORE_ADDR addr,
- int len, int rw)
-{
- int align;
- int size;
- int rv = 0, status = 0;
-
- static int size_try_array[16] =
- {
- 1, 1, 1, 1, /* trying size one */
- 2, 1, 2, 1, /* trying size two */
- 2, 1, 2, 1, /* trying size three */
- 4, 1, 2, 1 /* trying size four */
- };
-
- while (len > 0)
- {
- align = addr % 4;
- /* Four is the maximum length for 386. */
- size = (len > 4) ? 3 : len - 1;
- size = size_try_array[size * 4 + align];
- if (what == wp_insert)
- status = go32_insert_aligned_watchpoint (waddr, addr, size, rw);
- else if (what == wp_remove)
- status = go32_remove_aligned_watchpoint (waddr, addr, size, rw);
- else if (what == wp_count)
- rv++;
- else
- status = -1;
- /* We keep the loop going even after a failure, because some of
- the other aligned watchpoints might still succeed, e.g. if
- they watch addresses that are already watched, and thus just
- increment the reference counts of occupied debug registers.
- If we break out of the loop too early, we could cause those
- addresses watched by other watchpoints to be disabled when
- GDB reacts to our failure to insert this watchpoint and tries
- to remove it. */
- if (status)
- rv = status;
- addr += size;
- len -= size;
- }
- return rv;
-}
+#define CONTROL D_REGS[7]
+#define STATUS D_REGS[6]
-/* Remove a watchpoint. */
-
-int
-go32_remove_watchpoint (int pid, CORE_ADDR addr, int len, int rw)
-{
- int ret = go32_remove_aligned_watchpoint (addr, addr, len, rw);
-
- SHOW_DR (remove_watch, len);
- return ret;
-}
-
-static int
-go32_remove_aligned_watchpoint (CORE_ADDR waddr, CORE_ADDR addr,
- int len, int rw)
-{
- int i;
- int read_write_bits, len_bits;
-
- /* Values of rw: 0 - write, 1 - read, 2 - access (read and write).
- However, x86 doesn't support read-only data breakpoints. */
- read_write_bits = rw ? DR_RW_READWRITE : DR_RW_WRITE;
-
- switch (len)
- {
- case 4:
- len_bits = DR_LEN_4;
- break;
- case 2:
- len_bits = DR_LEN_2;
- break;
- case 1:
- len_bits = DR_LEN_1;
- break;
- default:
- /* The debug registers only have 2 bits for the length, so
- so this value will always fail the loop below. */
- len_bits = 0x10;
- }
-
- if (len == 2)
- {
- if (addr % 2)
- return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
- len, rw);
- }
- else if (len == 4)
- {
- if (addr % 4)
- return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr,
- len, rw);
- }
- else if (len != 1)
- return go32_handle_nonaligned_watchpoint (wp_remove, waddr, addr, len, rw);
-
- for (i = 0; i <= 3; i++)
- {
- if (!IS_REG_FREE (i) && D_REGS[i] == addr
- && DR_DEF (i) == (len_bits | read_write_bits))
- {
- dr_ref_count[i]--;
- if (dr_ref_count[i] == 0)
- DISABLE_REG (i);
- }
- }
- RESET_LOCAL_EXACT ();
- RESET_GLOBAL_EXACT ();
-
- return 0;
-}
-
-/* Can we use debug registers to watch a region whose address is ADDR
- and whose length is LEN bytes? */
-
-int
-go32_region_ok_for_watchpoint (CORE_ADDR addr, int len)
+/* Pass the address ADDR to the inferior in the I'th debug register.
+ Here we just store the address in D_REGS, the watchpoint will be
+ actually set up when go32_wait runs the debuggee. */
+void
+go32_set_dr (int i, CORE_ADDR addr)
{
- /* Compute how many aligned watchpoints we would need to cover this
- region. */
- int nregs = go32_handle_nonaligned_watchpoint (wp_count, addr, addr, len, 0);
-
- return nregs <= 4 ? 1 : 0;
+ if (i < 0 || i > 3)
+ internal_error (__FILE__, __LINE__,
+ _("Invalid register %d in go32_set_dr.\n"), i);
+ D_REGS[i] = addr;
}
-/* Check if stopped by a data watchpoint. If so, return the address
- whose access triggered the watchpoint. */
-
-CORE_ADDR
-go32_stopped_by_watchpoint (int pid, int data_watchpoint)
-{
- int i, ret = 0;
- int status;
-
- status = edi.dr[DR_STATUS];
- SHOW_DR (stopped_by, 0);
- for (i = 0; i <= 3; i++)
- {
- if (WATCH_HIT (i) && data_watchpoint)
- {
- SHOW_DR (WP_HIT, 0);
- ret = D_REGS[i];
- }
- }
-
- return ret;
-}
-
-/* Remove a breakpoint. */
-
-int
-go32_remove_hw_breakpoint (CORE_ADDR addr, CORE_ADDR shadow)
+/* Pass the value VAL to the inferior in the DR7 debug control
+ register. Here we just store the address in D_REGS, the watchpoint
+ will be actually set up when go32_wait runs the debuggee. */
+void
+go32_set_dr7 (unsigned val)
{
- int i;
- for (i = 0; i <= 3; i++)
- {
- if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
- {
- dr_ref_count[i]--;
- if (dr_ref_count[i] == 0)
- DISABLE_REG (i);
- }
- }
- SHOW_DR (remove_hw, 0);
- return 0;
+ CONTROL = val;
}
-int
-go32_insert_hw_breakpoint (CORE_ADDR addr, CORE_ADDR shadow)
+/* Get the value of the DR6 debug status register from the inferior.
+ Here we just return the value stored in D_REGS, as we've got it
+ from the last go32_wait call. */
+unsigned
+go32_get_dr6 (void)
{
- int i;
- int read_write_bits, len_bits;
- int free_debug_register;
- int register_number;
-
- /* Look for an occupied debug register with the same address and the
- same RW and LEN definitions. If we find one, we can use it for
- this breakpoint as well (and save a register). */
- for (i = 0; i < 4; i++)
- {
- if (!IS_REG_FREE (i) && D_REGS[i] == addr && DR_DEF (i) == 0)
- {
- dr_ref_count[i]++;
- SHOW_DR (insert_hw, 0);
- return 0;
- }
- }
-
- /* Look for a free debug register. */
- for (i = 0; i <= 3; i++)
- {
- if (IS_REG_FREE (i))
- break;
- }
-
- /* No more debug registers? */
- if (i < 4)
- {
- SET_BREAK (i, addr);
- LOCAL_ENABLE_REG (i);
- }
- SHOW_DR (insert_hw, 0);
-
- return i < 4 ? 0 : -1;
+ return STATUS;
}
/* Put the device open on handle FD into either raw or cooked
if (redir_to_child (&child_cmd) == -1)
{
redir_to_debugger (&child_cmd);
- error ("Cannot redirect standard handles for program: %s.",
- strerror (errno));
+ error (_("Cannot redirect standard handles for program: %s."),
+ safe_strerror (errno));
}
/* set the console device of the inferior to whatever mode
(raw or cooked) we found it last time */
if (redir_to_debugger (&child_cmd) == -1)
{
redir_to_child (&child_cmd);
- error ("Cannot redirect standard handles for debugger: %s.",
- strerror (errno));
+ error (_("Cannot redirect standard handles for debugger: %s."),
+ safe_strerror (errno));
}
}
}
+static int
+go32_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
+ return 1;
+}
+
+static char *
+go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+ static char buf[64];
+ xsnprintf (buf, sizeof buf, "Thread <main>");
+ return buf;
+}
+
static void
init_go32_ops (void)
{
go32_ops.to_fetch_registers = go32_fetch_registers;
go32_ops.to_store_registers = go32_store_registers;
go32_ops.to_prepare_to_store = go32_prepare_to_store;
- go32_ops.to_xfer_memory = go32_xfer_memory;
+ go32_ops.deprecated_xfer_memory = go32_xfer_memory;
go32_ops.to_files_info = go32_files_info;
go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
go32_ops.to_mourn_inferior = go32_mourn_inferior;
go32_ops.to_can_run = go32_can_run;
go32_ops.to_stop = go32_stop;
+ go32_ops.to_thread_alive = go32_thread_alive;
+ go32_ops.to_pid_to_str = go32_pid_to_str;
go32_ops.to_stratum = process_stratum;
go32_ops.to_has_all_memory = 1;
go32_ops.to_has_memory = 1;
go32_ops.to_has_stack = 1;
go32_ops.to_has_registers = 1;
go32_ops.to_has_execution = 1;
+
+ i386_use_watchpoints (&go32_ops);
+
go32_ops.to_magic = OPS_MAGIC;
- /* Initialize child's cwd with the current one. */
- getcwd (child_cwd, sizeof (child_cwd));
+ /* Initialize child's cwd as empty to be initialized when starting
+ the child. */
+ *child_cwd = 0;
/* Initialize child's command line storage. */
if (redir_debug_init (&child_cmd) == -1)
- internal_error ("Cannot allocate redirection storage: not enough memory.\n");
+ internal_error (__FILE__, __LINE__,
+ _("Cannot allocate redirection storage: not enough memory.\n"));
+
+ /* We are always processing GCC-compiled programs. */
+ processing_gcc_compilation = 2;
+
+ /* Override the default name of the GDB init file. */
+ strcpy (gdbinit, "gdb.ini");
+}
+
+unsigned short windows_major, windows_minor;
+
+/* Compute the version Windows reports via Int 2Fh/AX=1600h. */
+static void
+go32_get_windows_version(void)
+{
+ __dpmi_regs r;
+
+ r.x.ax = 0x1600;
+ __dpmi_int(0x2f, &r);
+ if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
+ && (r.h.al > 3 || r.h.ah > 0))
+ {
+ windows_major = r.h.al;
+ windows_minor = r.h.ah;
+ }
+ else
+ windows_major = 0xff; /* meaning no Windows */
+}
+
+/* A subroutine of go32_sysinfo to display memory info. */
+static void
+print_mem (unsigned long datum, const char *header, int in_pages_p)
+{
+ if (datum != 0xffffffffUL)
+ {
+ if (in_pages_p)
+ datum <<= 12;
+ puts_filtered (header);
+ if (datum > 1024)
+ {
+ printf_filtered ("%lu KB", datum >> 10);
+ if (datum > 1024 * 1024)
+ printf_filtered (" (%lu MB)", datum >> 20);
+ }
+ else
+ printf_filtered ("%lu Bytes", datum);
+ puts_filtered ("\n");
+ }
+}
+
+/* Display assorted information about the underlying OS. */
+static void
+go32_sysinfo (char *arg, int from_tty)
+{
+ struct utsname u;
+ char cpuid_vendor[13];
+ unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
+ unsigned true_dos_version = _get_dos_version (1);
+ unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
+ int dpmi_flags;
+ char dpmi_vendor_info[129];
+ int dpmi_vendor_available =
+ __dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
+ __dpmi_version_ret dpmi_version_data;
+ long eflags;
+ __dpmi_free_mem_info mem_info;
+ __dpmi_regs regs;
+
+ cpuid_vendor[0] = '\0';
+ if (uname (&u))
+ strcpy (u.machine, "Unknown x86");
+ else if (u.machine[0] == 'i' && u.machine[1] > 4)
+ {
+ /* CPUID with EAX = 0 returns the Vendor ID. */
+ __asm__ __volatile__ ("xorl %%ebx, %%ebx;"
+ "xorl %%ecx, %%ecx;"
+ "xorl %%edx, %%edx;"
+ "movl $0, %%eax;"
+ "cpuid;"
+ "movl %%ebx, %0;"
+ "movl %%edx, %1;"
+ "movl %%ecx, %2;"
+ "movl %%eax, %3;"
+ : "=m" (cpuid_vendor[0]),
+ "=m" (cpuid_vendor[4]),
+ "=m" (cpuid_vendor[8]),
+ "=m" (cpuid_max)
+ :
+ : "%eax", "%ebx", "%ecx", "%edx");
+ cpuid_vendor[12] = '\0';
+ }
+
+ printf_filtered ("CPU Type.......................%s", u.machine);
+ if (cpuid_vendor[0])
+ printf_filtered (" (%s)", cpuid_vendor);
+ puts_filtered ("\n");
+
+ /* CPUID with EAX = 1 returns processor signature and features. */
+ if (cpuid_max >= 1)
+ {
+ static char *brand_name[] = {
+ "",
+ " Celeron",
+ " III",
+ " III Xeon",
+ "", "", "", "",
+ " 4"
+ };
+ char cpu_string[80];
+ char cpu_brand[20];
+ unsigned brand_idx;
+ int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
+ int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
+ unsigned cpu_family, cpu_model;
+
+ __asm__ __volatile__ ("movl $1, %%eax;"
+ "cpuid;"
+ : "=a" (cpuid_eax),
+ "=b" (cpuid_ebx),
+ "=d" (cpuid_edx)
+ :
+ : "%ecx");
+ brand_idx = cpuid_ebx & 0xff;
+ cpu_family = (cpuid_eax >> 8) & 0xf;
+ cpu_model = (cpuid_eax >> 4) & 0xf;
+ cpu_brand[0] = '\0';
+ if (intel_p)
+ {
+ if (brand_idx > 0
+ && brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
+ && *brand_name[brand_idx])
+ strcpy (cpu_brand, brand_name[brand_idx]);
+ else if (cpu_family == 5)
+ {
+ if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
+ strcpy (cpu_brand, " MMX");
+ else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
+ strcpy (cpu_brand, " OverDrive");
+ else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
+ strcpy (cpu_brand, " Dual");
+ }
+ else if (cpu_family == 6 && cpu_model < 8)
+ {
+ switch (cpu_model)
+ {
+ case 1:
+ strcpy (cpu_brand, " Pro");
+ break;
+ case 3:
+ strcpy (cpu_brand, " II");
+ break;
+ case 5:
+ strcpy (cpu_brand, " II Xeon");
+ break;
+ case 6:
+ strcpy (cpu_brand, " Celeron");
+ break;
+ case 7:
+ strcpy (cpu_brand, " III");
+ break;
+ }
+ }
+ }
+ else if (amd_p)
+ {
+ switch (cpu_family)
+ {
+ case 4:
+ strcpy (cpu_brand, "486/5x86");
+ break;
+ case 5:
+ switch (cpu_model)
+ {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ strcpy (cpu_brand, "-K5");
+ break;
+ case 6:
+ case 7:
+ strcpy (cpu_brand, "-K6");
+ break;
+ case 8:
+ strcpy (cpu_brand, "-K6-2");
+ break;
+ case 9:
+ strcpy (cpu_brand, "-K6-III");
+ break;
+ }
+ break;
+ case 6:
+ switch (cpu_model)
+ {
+ case 1:
+ case 2:
+ case 4:
+ strcpy (cpu_brand, " Athlon");
+ break;
+ case 3:
+ strcpy (cpu_brand, " Duron");
+ break;
+ }
+ break;
+ }
+ }
+ sprintf (cpu_string, "%s%s Model %d Stepping %d",
+ intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
+ cpu_brand, cpu_model, cpuid_eax & 0xf);
+ printfi_filtered (31, "%s\n", cpu_string);
+ if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
+ || ((cpuid_edx & 1) == 0)
+ || (amd_p && (cpuid_edx & (3 << 30)) != 0))
+ {
+ puts_filtered ("CPU Features...................");
+ /* We only list features which might be useful in the DPMI
+ environment. */
+ if ((cpuid_edx & 1) == 0)
+ puts_filtered ("No FPU "); /* it's unusual to not have an FPU */
+ if ((cpuid_edx & (1 << 1)) != 0)
+ puts_filtered ("VME ");
+ if ((cpuid_edx & (1 << 2)) != 0)
+ puts_filtered ("DE ");
+ if ((cpuid_edx & (1 << 4)) != 0)
+ puts_filtered ("TSC ");
+ if ((cpuid_edx & (1 << 23)) != 0)
+ puts_filtered ("MMX ");
+ if ((cpuid_edx & (1 << 25)) != 0)
+ puts_filtered ("SSE ");
+ if ((cpuid_edx & (1 << 26)) != 0)
+ puts_filtered ("SSE2 ");
+ if (amd_p)
+ {
+ if ((cpuid_edx & (1 << 31)) != 0)
+ puts_filtered ("3DNow! ");
+ if ((cpuid_edx & (1 << 30)) != 0)
+ puts_filtered ("3DNow!Ext");
+ }
+ puts_filtered ("\n");
+ }
+ }
+ puts_filtered ("\n");
+ printf_filtered ("DOS Version....................%s %s.%s",
+ _os_flavor, u.release, u.version);
+ if (true_dos_version != advertized_dos_version)
+ printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
+ puts_filtered ("\n");
+ if (!windows_major)
+ go32_get_windows_version ();
+ if (windows_major != 0xff)
+ {
+ const char *windows_flavor;
+
+ printf_filtered ("Windows Version................%d.%02d (Windows ",
+ windows_major, windows_minor);
+ switch (windows_major)
+ {
+ case 3:
+ windows_flavor = "3.X";
+ break;
+ case 4:
+ switch (windows_minor)
+ {
+ case 0:
+ windows_flavor = "95, 95A, or 95B";
+ break;
+ case 3:
+ windows_flavor = "95B OSR2.1 or 95C OSR2.5";
+ break;
+ case 10:
+ windows_flavor = "98 or 98 SE";
+ break;
+ case 90:
+ windows_flavor = "ME";
+ break;
+ default:
+ windows_flavor = "9X";
+ break;
+ }
+ break;
+ default:
+ windows_flavor = "??";
+ break;
+ }
+ printf_filtered ("%s)\n", windows_flavor);
+ }
+ else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
+ printf_filtered ("Windows Version................Windows NT or Windows 2000\n");
+ puts_filtered ("\n");
+ if (dpmi_vendor_available == 0)
+ {
+ /* The DPMI spec says the vendor string should be ASCIIZ, but
+ I don't trust the vendors to follow that... */
+ if (!memchr (&dpmi_vendor_info[2], 0, 126))
+ dpmi_vendor_info[128] = '\0';
+ printf_filtered ("DPMI Host......................%s v%d.%d (capabilities: %#x)\n",
+ &dpmi_vendor_info[2],
+ (unsigned)dpmi_vendor_info[0],
+ (unsigned)dpmi_vendor_info[1],
+ ((unsigned)dpmi_flags & 0x7f));
+ }
+ __dpmi_get_version (&dpmi_version_data);
+ printf_filtered ("DPMI Version...................%d.%02d\n",
+ dpmi_version_data.major, dpmi_version_data.minor);
+ printf_filtered ("DPMI Info......................%s-bit DPMI, with%s Virtual Memory support\n",
+ (dpmi_version_data.flags & 1) ? "32" : "16",
+ (dpmi_version_data.flags & 4) ? "" : "out");
+ printfi_filtered (31, "Interrupts reflected to %s mode\n",
+ (dpmi_version_data.flags & 2) ? "V86" : "Real");
+ printfi_filtered (31, "Processor type: i%d86\n",
+ dpmi_version_data.cpu);
+ printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
+ dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
+
+ /* a_tss is only initialized when the debuggee is first run. */
+ if (prog_has_started)
+ {
+ __asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
+ printf_filtered ("Protection.....................Ring %d (in %s), with%s I/O protection\n",
+ a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
+ (a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
+ }
+ puts_filtered ("\n");
+ __dpmi_get_free_memory_information (&mem_info);
+ print_mem (mem_info.total_number_of_physical_pages,
+ "DPMI Total Physical Memory.....", 1);
+ print_mem (mem_info.total_number_of_free_pages,
+ "DPMI Free Physical Memory......", 1);
+ print_mem (mem_info.size_of_paging_file_partition_in_pages,
+ "DPMI Swap Space................", 1);
+ print_mem (mem_info.linear_address_space_size_in_pages,
+ "DPMI Total Linear Address Size.", 1);
+ print_mem (mem_info.free_linear_address_space_in_pages,
+ "DPMI Free Linear Address Size..", 1);
+ print_mem (mem_info.largest_available_free_block_in_bytes,
+ "DPMI Largest Free Memory Block.", 0);
+
+ regs.h.ah = 0x48;
+ regs.x.bx = 0xffff;
+ __dpmi_int (0x21, ®s);
+ print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
+ regs.x.ax = 0x5800;
+ __dpmi_int (0x21, ®s);
+ if ((regs.x.flags & 1) == 0)
+ {
+ static const char *dos_hilo[] = {
+ "Low", "", "", "", "High", "", "", "", "High, then Low"
+ };
+ static const char *dos_fit[] = {
+ "First", "Best", "Last"
+ };
+ int hilo_idx = (regs.x.ax >> 4) & 0x0f;
+ int fit_idx = regs.x.ax & 0x0f;
+
+ if (hilo_idx > 8)
+ hilo_idx = 0;
+ if (fit_idx > 2)
+ fit_idx = 0;
+ printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
+ dos_hilo[hilo_idx], dos_fit[fit_idx]);
+ regs.x.ax = 0x5802;
+ __dpmi_int (0x21, ®s);
+ if ((regs.x.flags & 1) != 0)
+ regs.h.al = 0;
+ printfi_filtered (31, "UMBs %sin DOS memory chain\n",
+ regs.h.al == 0 ? "not " : "");
+ }
+}
+
+struct seg_descr {
+ unsigned short limit0;
+ unsigned short base0;
+ unsigned char base1;
+ unsigned stype:5;
+ unsigned dpl:2;
+ unsigned present:1;
+ unsigned limit1:4;
+ unsigned available:1;
+ unsigned dummy:1;
+ unsigned bit32:1;
+ unsigned page_granular:1;
+ unsigned char base2;
+} __attribute__ ((packed));
+
+struct gate_descr {
+ unsigned short offset0;
+ unsigned short selector;
+ unsigned param_count:5;
+ unsigned dummy:3;
+ unsigned stype:5;
+ unsigned dpl:2;
+ unsigned present:1;
+ unsigned short offset1;
+} __attribute__ ((packed));
+
+/* Read LEN bytes starting at logical address ADDR, and put the result
+ into DEST. Return 1 if success, zero if not. */
+static int
+read_memory_region (unsigned long addr, void *dest, size_t len)
+{
+ unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
+ int retval = 1;
+
+ /* For the low memory, we can simply use _dos_ds. */
+ if (addr <= dos_ds_limit - len)
+ dosmemget (addr, len, dest);
+ else
+ {
+ /* For memory above 1MB we need to set up a special segment to
+ be able to access that memory. */
+ int sel = __dpmi_allocate_ldt_descriptors (1);
+
+ if (sel <= 0)
+ retval = 0;
+ else
+ {
+ int access_rights = __dpmi_get_descriptor_access_rights (sel);
+ size_t segment_limit = len - 1;
+
+ /* Make sure the crucial bits in the descriptor access
+ rights are set correctly. Some DPMI providers might barf
+ if we set the segment limit to something that is not an
+ integral multiple of 4KB pages if the granularity bit is
+ not set to byte-granular, even though the DPMI spec says
+ it's the host's responsibility to set that bit correctly. */
+ if (len > 1024 * 1024)
+ {
+ access_rights |= 0x8000;
+ /* Page-granular segments should have the low 12 bits of
+ the limit set. */
+ segment_limit |= 0xfff;
+ }
+ else
+ access_rights &= ~0x8000;
+
+ if (__dpmi_set_segment_base_address (sel, addr) != -1
+ && __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
+ && __dpmi_set_segment_limit (sel, segment_limit) != -1
+ /* W2K silently fails to set the segment limit, leaving
+ it at zero; this test avoids the resulting crash. */
+ && __dpmi_get_segment_limit (sel) >= segment_limit)
+ movedata (sel, 0, _my_ds (), (unsigned)dest, len);
+ else
+ retval = 0;
+
+ __dpmi_free_ldt_descriptor (sel);
+ }
+ }
+ return retval;
+}
+
+/* Get a segment descriptor stored at index IDX in the descriptor
+ table whose base address is TABLE_BASE. Return the descriptor
+ type, or -1 if failure. */
+static int
+get_descriptor (unsigned long table_base, int idx, void *descr)
+{
+ unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
+
+ if (read_memory_region (addr, descr, 8))
+ return (int)((struct seg_descr *)descr)->stype;
+ return -1;
+}
+
+struct dtr_reg {
+ unsigned short limit __attribute__((packed));
+ unsigned long base __attribute__((packed));
+};
+
+/* Display a segment descriptor stored at index IDX in a descriptor
+ table whose type is TYPE and whose base address is BASE_ADDR. If
+ FORCE is non-zero, display even invalid descriptors. */
+static void
+display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
+{
+ struct seg_descr descr;
+ struct gate_descr gate;
+
+ /* Get the descriptor from the table. */
+ if (idx == 0 && type == 0)
+ puts_filtered ("0x000: null descriptor\n");
+ else if (get_descriptor (base_addr, idx, &descr) != -1)
+ {
+ /* For each type of descriptor table, this has a bit set if the
+ corresponding type of selectors is valid in that table. */
+ static unsigned allowed_descriptors[] = {
+ 0xffffdafeL, /* GDT */
+ 0x0000c0e0L, /* IDT */
+ 0xffffdafaL /* LDT */
+ };
+
+ /* If the program hasn't started yet, assume the debuggee will
+ have the same CPL as the debugger. */
+ int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
+ unsigned long limit = (descr.limit1 << 16) | descr.limit0;
+
+ if (descr.present
+ && (allowed_descriptors[type] & (1 << descr.stype)) != 0)
+ {
+ printf_filtered ("0x%03x: ",
+ type == 1
+ ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
+ if (descr.page_granular)
+ limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
+ if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
+ || descr.stype == 9 || descr.stype == 11
+ || (descr.stype >= 16 && descr.stype < 32))
+ printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
+ descr.base2, descr.base1, descr.base0, limit);
+
+ switch (descr.stype)
+ {
+ case 1:
+ case 3:
+ printf_filtered (" 16-bit TSS (task %sactive)",
+ descr.stype == 3 ? "" : "in");
+ break;
+ case 2:
+ puts_filtered (" LDT");
+ break;
+ case 4:
+ memcpy (&gate, &descr, sizeof gate);
+ printf_filtered ("selector=0x%04x offs=0x%04x%04x",
+ gate.selector, gate.offset1, gate.offset0);
+ printf_filtered (" 16-bit Call Gate (params=%d)",
+ gate.param_count);
+ break;
+ case 5:
+ printf_filtered ("TSS selector=0x%04x", descr.base0);
+ printfi_filtered (16, "Task Gate");
+ break;
+ case 6:
+ case 7:
+ memcpy (&gate, &descr, sizeof gate);
+ printf_filtered ("selector=0x%04x offs=0x%04x%04x",
+ gate.selector, gate.offset1, gate.offset0);
+ printf_filtered (" 16-bit %s Gate",
+ descr.stype == 6 ? "Interrupt" : "Trap");
+ break;
+ case 9:
+ case 11:
+ printf_filtered (" 32-bit TSS (task %sactive)",
+ descr.stype == 3 ? "" : "in");
+ break;
+ case 12:
+ memcpy (&gate, &descr, sizeof gate);
+ printf_filtered ("selector=0x%04x offs=0x%04x%04x",
+ gate.selector, gate.offset1, gate.offset0);
+ printf_filtered (" 32-bit Call Gate (params=%d)",
+ gate.param_count);
+ break;
+ case 14:
+ case 15:
+ memcpy (&gate, &descr, sizeof gate);
+ printf_filtered ("selector=0x%04x offs=0x%04x%04x",
+ gate.selector, gate.offset1, gate.offset0);
+ printf_filtered (" 32-bit %s Gate",
+ descr.stype == 14 ? "Interrupt" : "Trap");
+ break;
+ case 16: /* data segments */
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 21:
+ case 22:
+ case 23:
+ printf_filtered (" %s-bit Data (%s Exp-%s%s)",
+ descr.bit32 ? "32" : "16",
+ descr.stype & 2 ? "Read/Write," : "Read-Only, ",
+ descr.stype & 4 ? "down" : "up",
+ descr.stype & 1 ? "" : ", N.Acc");
+ break;
+ case 24: /* code segments */
+ case 25:
+ case 26:
+ case 27:
+ case 28:
+ case 29:
+ case 30:
+ case 31:
+ printf_filtered (" %s-bit Code (%s, %sConf%s)",
+ descr.bit32 ? "32" : "16",
+ descr.stype & 2 ? "Exec/Read" : "Exec-Only",
+ descr.stype & 4 ? "" : "N.",
+ descr.stype & 1 ? "" : ", N.Acc");
+ break;
+ default:
+ printf_filtered ("Unknown type 0x%02x", descr.stype);
+ break;
+ }
+ puts_filtered ("\n");
+ }
+ else if (force)
+ {
+ printf_filtered ("0x%03x: ",
+ type == 1
+ ? idx : (idx * 8) | (type ? (cpl | 4) : 0));
+ if (!descr.present)
+ puts_filtered ("Segment not present\n");
+ else
+ printf_filtered ("Segment type 0x%02x is invalid in this table\n",
+ descr.stype);
+ }
+ }
+ else if (force)
+ printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
+}
+
+static void
+go32_sldt (char *arg, int from_tty)
+{
+ struct dtr_reg gdtr;
+ unsigned short ldtr = 0;
+ int ldt_idx;
+ struct seg_descr ldt_descr;
+ long ldt_entry = -1L;
+ int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
+
+ if (arg && *arg)
+ {
+ while (*arg && isspace(*arg))
+ arg++;
+
+ if (*arg)
+ {
+ ldt_entry = parse_and_eval_long (arg);
+ if (ldt_entry < 0
+ || (ldt_entry & 4) == 0
+ || (ldt_entry & 3) != (cpl & 3))
+ error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
+ }
+ }
+
+ __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
+ __asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ );
+ ldt_idx = ldtr / 8;
+ if (ldt_idx == 0)
+ puts_filtered ("There is no LDT.\n");
+ /* LDT's entry in the GDT must have the type LDT, which is 2. */
+ else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
+ printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
+ ldt_descr.base0
+ | (ldt_descr.base1 << 16)
+ | (ldt_descr.base2 << 24));
+ else
+ {
+ unsigned base =
+ ldt_descr.base0
+ | (ldt_descr.base1 << 16)
+ | (ldt_descr.base2 << 24);
+ unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
+ int max_entry;
+
+ if (ldt_descr.page_granular)
+ /* Page-granular segments must have the low 12 bits of their
+ limit set. */
+ limit = (limit << 12) | 0xfff;
+ /* LDT cannot have more than 8K 8-byte entries, i.e. more than
+ 64KB. */
+ if (limit > 0xffff)
+ limit = 0xffff;
+
+ max_entry = (limit + 1) / 8;
+
+ if (ldt_entry >= 0)
+ {
+ if (ldt_entry > limit)
+ error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
+ (unsigned long)ldt_entry, limit);
+
+ display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
+ }
+ else
+ {
+ int i;
+
+ for (i = 0; i < max_entry; i++)
+ display_descriptor (ldt_descr.stype, base, i, 0);
+ }
+ }
+}
+
+static void
+go32_sgdt (char *arg, int from_tty)
+{
+ struct dtr_reg gdtr;
+ long gdt_entry = -1L;
+ int max_entry;
+
+ if (arg && *arg)
+ {
+ while (*arg && isspace(*arg))
+ arg++;
+
+ if (*arg)
+ {
+ gdt_entry = parse_and_eval_long (arg);
+ if (gdt_entry < 0 || (gdt_entry & 7) != 0)
+ error (_("Invalid GDT entry 0x%03lx: not an integral multiple of 8."),
+ (unsigned long)gdt_entry);
+ }
+ }
+
+ __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
+ max_entry = (gdtr.limit + 1) / 8;
+
+ if (gdt_entry >= 0)
+ {
+ if (gdt_entry > gdtr.limit)
+ error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
+ (unsigned long)gdt_entry, gdtr.limit);
+
+ display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
+ }
+ else
+ {
+ int i;
+
+ for (i = 0; i < max_entry; i++)
+ display_descriptor (0, gdtr.base, i, 0);
+ }
+}
+
+static void
+go32_sidt (char *arg, int from_tty)
+{
+ struct dtr_reg idtr;
+ long idt_entry = -1L;
+ int max_entry;
+
+ if (arg && *arg)
+ {
+ while (*arg && isspace(*arg))
+ arg++;
+
+ if (*arg)
+ {
+ idt_entry = parse_and_eval_long (arg);
+ if (idt_entry < 0)
+ error (_("Invalid (negative) IDT entry %ld."), idt_entry);
+ }
+ }
+
+ __asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ );
+ max_entry = (idtr.limit + 1) / 8;
+ if (max_entry > 0x100) /* no more than 256 entries */
+ max_entry = 0x100;
+
+ if (idt_entry >= 0)
+ {
+ if (idt_entry > idtr.limit)
+ error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
+ (unsigned long)idt_entry, idtr.limit);
+
+ display_descriptor (1, idtr.base, idt_entry, 1);
+ }
+ else
+ {
+ int i;
+
+ for (i = 0; i < max_entry; i++)
+ display_descriptor (1, idtr.base, i, 0);
+ }
+}
+
+/* Cached linear address of the base of the page directory. For
+ now, available only under CWSDPMI. Code based on ideas and
+ suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
+static unsigned long pdbr;
+
+static unsigned long
+get_cr3 (void)
+{
+ unsigned offset;
+ unsigned taskreg;
+ unsigned long taskbase, cr3;
+ struct dtr_reg gdtr;
+
+ if (pdbr > 0 && pdbr <= 0xfffff)
+ return pdbr;
+
+ /* Get the linear address of GDT and the Task Register. */
+ __asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
+ __asm__ __volatile__ ("str %0" : "=m" (taskreg) : /* no inputs */ );
+
+ /* Task Register is a segment selector for the TSS of the current
+ task. Therefore, it can be used as an index into the GDT to get
+ at the segment descriptor for the TSS. To get the index, reset
+ the low 3 bits of the selector (which give the CPL). Add 2 to the
+ offset to point to the 3 low bytes of the base address. */
+ offset = gdtr.base + (taskreg & 0xfff8) + 2;
+
+
+ /* CWSDPMI's task base is always under the 1MB mark. */
+ if (offset > 0xfffff)
+ return 0;
+
+ _farsetsel (_dos_ds);
+ taskbase = _farnspeekl (offset) & 0xffffffU;
+ taskbase += _farnspeekl (offset + 2) & 0xff000000U;
+ if (taskbase > 0xfffff)
+ return 0;
+
+ /* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
+ offset 1Ch in the TSS. */
+ cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
+ if (cr3 > 0xfffff)
+ {
+#if 0 /* not fullly supported yet */
+ /* The Page Directory is in UMBs. In that case, CWSDPMI puts
+ the first Page Table right below the Page Directory. Thus,
+ the first Page Table's entry for its own address and the Page
+ Directory entry for that Page Table will hold the same
+ physical address. The loop below searches the entire UMB
+ range of addresses for such an occurence. */
+ unsigned long addr, pte_idx;
+
+ for (addr = 0xb0000, pte_idx = 0xb0;
+ pte_idx < 0xff;
+ addr += 0x1000, pte_idx++)
+ {
+ if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
+ (_farnspeekl (addr + 0x1000) & 0xfffff027))
+ && ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
+ {
+ cr3 = addr + 0x1000;
+ break;
+ }
+ }
+#endif
+
+ if (cr3 > 0xfffff)
+ cr3 = 0;
+ }
+
+ return cr3;
+}
+
+/* Return the N'th Page Directory entry. */
+static unsigned long
+get_pde (int n)
+{
+ unsigned long pde = 0;
+
+ if (pdbr && n >= 0 && n < 1024)
+ {
+ pde = _farpeekl (_dos_ds, pdbr + 4*n);
+ }
+ return pde;
+}
+
+/* Return the N'th entry of the Page Table whose Page Directory entry
+ is PDE. */
+static unsigned long
+get_pte (unsigned long pde, int n)
+{
+ unsigned long pte = 0;
+
+ /* pde & 0x80 tests the 4MB page bit. We don't support 4MB
+ page tables, for now. */
+ if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
+ {
+ pde &= ~0xfff; /* clear non-address bits */
+ pte = _farpeekl (_dos_ds, pde + 4*n);
+ }
+ return pte;
+}
+
+/* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
+ says this is a Page Directory entry. If FORCE is non-zero, display
+ the entry even if its Present flag is off. OFF is the offset of the
+ address from the page's base address. */
+static void
+display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
+{
+ if ((entry & 1) != 0)
+ {
+ printf_filtered ("Base=0x%05lx000", entry >> 12);
+ if ((entry & 0x100) && !is_dir)
+ puts_filtered (" Global");
+ if ((entry & 0x40) && !is_dir)
+ puts_filtered (" Dirty");
+ printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
+ printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
+ printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
+ printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
+ printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
+ if (off)
+ printf_filtered (" +0x%x", off);
+ puts_filtered ("\n");
+ }
+ else if (force)
+ printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
+ is_dir ? " Table" : "", entry >> 1);
+}
+
+static void
+go32_pde (char *arg, int from_tty)
+{
+ long pde_idx = -1, i;
+
+ if (arg && *arg)
+ {
+ while (*arg && isspace(*arg))
+ arg++;
+
+ if (*arg)
+ {
+ pde_idx = parse_and_eval_long (arg);
+ if (pde_idx < 0 || pde_idx >= 1024)
+ error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
+ }
+ }
+
+ pdbr = get_cr3 ();
+ if (!pdbr)
+ puts_filtered ("Access to Page Directories is not supported on this system.\n");
+ else if (pde_idx >= 0)
+ display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
+ else
+ for (i = 0; i < 1024; i++)
+ display_ptable_entry (get_pde (i), 1, 0, 0);
+}
+
+/* A helper function to display entries in a Page Table pointed to by
+ the N'th entry in the Page Directory. If FORCE is non-zero, say
+ something even if the Page Table is not accessible. */
+static void
+display_page_table (long n, int force)
+{
+ unsigned long pde = get_pde (n);
+
+ if ((pde & 1) != 0)
+ {
+ int i;
+
+ printf_filtered ("Page Table pointed to by Page Directory entry 0x%lx:\n", n);
+ for (i = 0; i < 1024; i++)
+ display_ptable_entry (get_pte (pde, i), 0, 0, 0);
+ puts_filtered ("\n");
+ }
+ else if (force)
+ printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
+}
+
+static void
+go32_pte (char *arg, int from_tty)
+{
+ long pde_idx = -1L, i;
+
+ if (arg && *arg)
+ {
+ while (*arg && isspace(*arg))
+ arg++;
+
+ if (*arg)
+ {
+ pde_idx = parse_and_eval_long (arg);
+ if (pde_idx < 0 || pde_idx >= 1024)
+ error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
+ }
+ }
+
+ pdbr = get_cr3 ();
+ if (!pdbr)
+ puts_filtered ("Access to Page Tables is not supported on this system.\n");
+ else if (pde_idx >= 0)
+ display_page_table (pde_idx, 1);
+ else
+ for (i = 0; i < 1024; i++)
+ display_page_table (i, 0);
+}
+
+static void
+go32_pte_for_address (char *arg, int from_tty)
+{
+ CORE_ADDR addr = 0, i;
+
+ if (arg && *arg)
+ {
+ while (*arg && isspace(*arg))
+ arg++;
+
+ if (*arg)
+ addr = parse_and_eval_address (arg);
+ }
+ if (!addr)
+ error_no_arg (_("linear address"));
+
+ pdbr = get_cr3 ();
+ if (!pdbr)
+ puts_filtered ("Access to Page Tables is not supported on this system.\n");
+ else
+ {
+ int pde_idx = (addr >> 22) & 0x3ff;
+ int pte_idx = (addr >> 12) & 0x3ff;
+ unsigned offs = addr & 0xfff;
+
+ printf_filtered ("Page Table entry for address 0x%llx:\n",
+ (unsigned long long)addr);
+ display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
+ }
+}
+
+static struct cmd_list_element *info_dos_cmdlist = NULL;
+
+static void
+go32_info_dos_command (char *args, int from_tty)
+{
+ help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
}
void
{
init_go32_ops ();
add_target (&go32_ops);
+
+ add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
+Print information specific to DJGPP (aka MS-DOS) debugging."),
+ &info_dos_cmdlist, "info dos ", 0, &infolist);
+
+ add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
+Display information about the target system, including CPU, OS, DPMI, etc."),
+ &info_dos_cmdlist);
+ add_cmd ("ldt", class_info, go32_sldt, _("\
+Display entries in the LDT (Local Descriptor Table).\n\
+Entry number (an expression) as an argument means display only that entry."),
+ &info_dos_cmdlist);
+ add_cmd ("gdt", class_info, go32_sgdt, _("\
+Display entries in the GDT (Global Descriptor Table).\n\
+Entry number (an expression) as an argument means display only that entry."),
+ &info_dos_cmdlist);
+ add_cmd ("idt", class_info, go32_sidt, _("\
+Display entries in the IDT (Interrupt Descriptor Table).\n\
+Entry number (an expression) as an argument means display only that entry."),
+ &info_dos_cmdlist);
+ add_cmd ("pde", class_info, go32_pde, _("\
+Display entries in the Page Directory.\n\
+Entry number (an expression) as an argument means display only that entry."),
+ &info_dos_cmdlist);
+ add_cmd ("pte", class_info, go32_pte, _("\
+Display entries in Page Tables.\n\
+Entry number (an expression) as an argument means display only entries\n\
+from the Page Table pointed to by the specified Page Directory entry."),
+ &info_dos_cmdlist);
+ add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
+Display a Page Table entry for a linear address.\n\
+The address argument must be a linear address, after adding to\n\
+it the base address of the appropriate segment.\n\
+The base address of variables and functions in the debuggee's data\n\
+or code segment is stored in the variable __djgpp_base_address,\n\
+so use `__djgpp_base_address + (char *)&var' as the argument.\n\
+For other segments, look up their base address in the output of\n\
+the `info dos ldt' command."),
+ &info_dos_cmdlist);
}
pid_t
projects / deliverable / binutils-gdb.git / blobdiff