[deliverable/binutils-gdb.git] / gdb / go32-nat.c

/* Native debugging support for Intel x86 running DJGPP.
   Copyright 1997, 1999 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
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
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.  */

#include <fcntl.h>

#include "defs.h"
#include "frame.h"		/* required by inferior.h */
#include "inferior.h"
#include "target.h"
#include "wait.h"
#include "gdbcore.h"
#include "command.h"
#include "floatformat.h"

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <debug/v2load.h>
#include <debug/dbgcom.h>

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];
};

extern char **environ;

#define SOME_PID 42

/* FIXME add decls of all static functions here */

static int prog_has_started = 0;

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);
  printf_unfiltered ("last exception: ");
  printf_unfiltered ("opcode %s; ", local_hex_string (ep->opcode));
  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 = 0; fpreg < 8; fpreg++)
    {
      long double val;

      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:
	  printf_unfiltered ("trap  ");
	  break;
	case 3:
	  printf_unfiltered ("empty ");
	  break;
	}
      for (i = 0; i < 8; i++)
	printf_unfiltered ("%02x", ep->regs[fpreg][i]);

      REGISTER_CONVERT_TO_VIRTUAL (FP0_REGNUM + fpreg, builtin_type_long_double,
				   &ep->regs[fpreg], &val);

      printf_unfiltered ("  %LG\n", val);
    }
}

void
i386_go32_float_info (void)
{
  print_387_status (0, (struct env387 *) &npx);
}

#define r_ofs(x) ((int)(&(((TSS *)0)->x)))

static struct
{
  int tss_ofs;
  int size;
}
regno_mapping[] =
{
  r_ofs (tss_eax), 4,
  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,
  1, 10,
  2, 10,
  3, 10,
  4, 10,
  5, 10,
  6, 10,
  7, 10,
  0, 2,
  4, 2,
  8, 2,
  12, 4,
  16, 2,
  20, 4,
  24, 2
};

static struct
  {
    int go32_sig;
    int gdb_sig;
  }
sig_map[] =
{
  0, TARGET_SIGNAL_FPE,
  1, TARGET_SIGNAL_TRAP,
  2, TARGET_SIGNAL_UNKNOWN,
  3, TARGET_SIGNAL_TRAP,
  4, TARGET_SIGNAL_FPE,
  5, TARGET_SIGNAL_SEGV,
  6, TARGET_SIGNAL_ILL,
  7, TARGET_SIGNAL_FPE,
  8, TARGET_SIGNAL_SEGV,
  9, TARGET_SIGNAL_SEGV,
  10, TARGET_SIGNAL_BUS,
  11, TARGET_SIGNAL_SEGV,
  12, TARGET_SIGNAL_SEGV,
  13, TARGET_SIGNAL_ABRT,
  14, TARGET_SIGNAL_SEGV,
  16, TARGET_SIGNAL_FPE,
  31, TARGET_SIGNAL_ILL,
  0x75, TARGET_SIGNAL_FPE,
  0x79, TARGET_SIGNAL_INT,
  0x1b, TARGET_SIGNAL_INT,
  -1, -1
};

static void
go32_open (char *name, int from_tty)
{
  printf_unfiltered ("Use the `run' command to run go32 programs\n");
}

static void
go32_close (int quitting)
{
}

static void
go32_attach (char *args, int from_tty)
{
  printf_unfiltered ("Use the `run' command to run go32 programs\n");
}

static void
go32_detach (char *args, int from_tty)
{
}

static int resume_is_step;

static void
go32_resume (int pid, int step, enum target_signal siggnal)
  {
    resume_is_step = step;
  }

static int
go32_wait (int pid, struct target_waitstatus *status)
{
  int i;

  if (resume_is_step)
    a_tss.tss_eflags |= 0x0100;
  else
    a_tss.tss_eflags &= 0xfeff;

  run_child ();

  if (a_tss.tss_irqn == 0x21)
    {
      status->kind = TARGET_WAITKIND_EXITED;
      status->value.integer = a_tss.tss_eax & 0xff;
    }
  else
    {
      status->value.sig = TARGET_SIGNAL_UNKNOWN;
      status->kind = TARGET_WAITKIND_STOPPED;
      for (i = 0; sig_map[i].go32_sig != -1; i++)
	{
	  if (a_tss.tss_irqn == sig_map[i].go32_sig)
	    {
	      if ((status->value.sig = sig_map[i].gdb_sig) !=
		  TARGET_SIGNAL_TRAP)
		status->kind = TARGET_WAITKIND_SIGNALLED;
	      break;
	    }
	}
    }
  return SOME_PID;
}

static void
go32_fetch_registers (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]);
    }

  for (; regno < end_reg; regno++)
    {
      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.reg + regno_mapping[regno].tss_ofs);
      else
	{
	  printf_unfiltered ("Invalid register in go32_fetch_register(%d)",
			     regno);
	  exit (1);
	}
    }
}

static void
store_register (int regno)
{
  void *rp;
  void *v = (void *) &registers[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;
  else
    {
      printf_unfiltered ("Invalid register in store_register(%d)", regno);
      exit (1);
    }
  memcpy (rp, v, regno_mapping[regno].size);
}

static void
go32_store_registers (int regno)
{
  int r;

  if (regno >= 0)
    store_register (regno);
  else
    {
      for (r = 0; r < sizeof (regno_mapping) / sizeof (regno_mapping[0]); r++)
	store_register (r);
    }
}

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)
{
  if (write)
    {
      if (write_child (memaddr, myaddr, len))
	{
	  return 0;
	}
      else
	{
	  return len;
	}
    }
  else
    {
      if (read_child (memaddr, myaddr, len))
	{
	  return 0;
	}
      else
	{
	  return len;
	}
    }
}

static void
go32_files_info (struct target_ops *target)
{
  printf_unfiltered ("You are running a DJGPP V2 program\n");
}

static void
go32_stop (void)
{
  normal_stop ();
  cleanup_client ();
  inferior_pid = 0;
  prog_has_started = 0;
}

static void
go32_kill_inferior (void)
{
  go32_stop ();
  unpush_target (&go32_ops);
}

static void
go32_create_inferior (char *exec_file, char *args, char **env)
{
  jmp_buf start_state;
  char *cmdline;
  char **env_save = environ;

  if (prog_has_started)
    {
      go32_kill_inferior ();
    }

  cmdline = (char *) alloca (strlen (args) + 4);
  cmdline[0] = strlen (args);
  strcpy (cmdline + 1, args);
  cmdline[strlen (args) + 1] = 13;

  environ = env;

  if (v2loadimage (exec_file, cmdline, start_state))
    {
      environ = env_save;
      printf_unfiltered ("Load failed for image %s\n", exec_file);
      exit (1);
    }
  environ = env_save;

  edi_init (start_state);

  inferior_pid = SOME_PID;
  push_target (&go32_ops);
  clear_proceed_status ();
  insert_breakpoints ();
  proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
}

static void
go32_mourn_inferior (void)
{
  go32_kill_inferior ();
  generic_mourn_inferior ();
}

static int
go32_can_run (void)
{
  return 1;
}

static void
ignore (void)
{
}

static void
ignore2 (char *a, int b)
{
}

/* 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_READ 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 SET_BREAK(index,address) \
  do {\
    CONTROL &= ~(DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * index));\
    D_REGS[index] = address;\
  } 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 WATCH_HIT(index) \
  (\
   (STATUS & (1 << index)) && \
   (CONTROL & (DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * index)))\
  )

#if 0 /* use debugging macro */
#define SHOW_DR(text) \
do { \
  fprintf(stderr,"%08x %08x ",edi.dr[7],edi.dr[6]); \
  fprintf(stderr,"%08x %08x ",edi.dr[0],edi.dr[1]); \
  fprintf(stderr,"%08x %08x ",edi.dr[2],edi.dr[3]); \
  fprintf(stderr,"(%s)\n",#text); \
} while (0)
#else
#define SHOW_DR(text) do {} while (0)
#endif

static int go32_insert_aligned_watchpoint (int pid, CORE_ADDR waddr,
					   CORE_ADDR addr, int len, int rw);

static int go32_insert_nonaligned_watchpoint (int pid, CORE_ADDR waddr,
					      CORE_ADDR addr, int len, int rw);

/* Insert a watchpoint.  */

int
go32_insert_watchpoint (int pid, CORE_ADDR addr, int len, int rw)
{
  int ret = go32_insert_aligned_watchpoint (pid, addr, addr, len, rw);

  SHOW_DR (insert_watch);
  return ret;
}

static int
go32_insert_aligned_watchpoint (int pid, CORE_ADDR waddr, CORE_ADDR addr,
				int len, int rw)
{
  int i;
  int read_write_bits, len_bits;

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

  read_write_bits = ((rw & 1) ? DR_RW_READ : 0) | ((rw & 2) ? DR_RW_WRITE : 0);

  if (len == 1)
    len_bits = DR_LEN_1;
  else if (len == 2)
    {
      if (addr % 2)
	return go32_insert_nonaligned_watchpoint (pid, waddr, addr, len, rw);
      len_bits = DR_LEN_2;
    }
  else if (len == 4)
    {
      if (addr % 4)
	return go32_insert_nonaligned_watchpoint (pid, waddr, addr, len, rw);
      len_bits = DR_LEN_4;
    }
  else
    return go32_insert_nonaligned_watchpoint (pid, waddr, addr, len, rw);

  SET_WATCH (i, addr, read_write_bits, len_bits);
  LOCAL_ENABLE_REG (i);
  SET_LOCAL_EXACT ();
}

static int
go32_insert_nonaligned_watchpoint (int pid, CORE_ADDR waddr, CORE_ADDR addr,
				   int len, int rw)
{
  int align;
  int size;
  int rv = 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];
      rv = go32_insert_aligned_watchpoint (pid, waddr, addr, size, rw);
      if (rv)
	{
	  go32_remove_watchpoint (pid, waddr, size);
	  return rv;
	}
      addr += size;
      len -= size;
    }
  return rv;
}

/* Remove a watchpoint.  */

int
go32_remove_watchpoint (int pid, CORE_ADDR addr, int len)
{
  int i;

  for (i = 0; i <= 3; i++)
    {
      if (D_REGS[i] == addr)
	{
	  DISABLE_REG (i);
	}
    }
  SHOW_DR (remove_watch);

  return 0;
}

/* Check if stopped by a watchpoint.  */

CORE_ADDR
go32_stopped_by_watchpoint (int pid)
{
  int i, ret = 0;
  int status;

  status = edi.dr[DR_STATUS];
  SHOW_DR (stopped_by);
  for (i = 0; i <= 3; i++)
    {
      if (WATCH_HIT (i))
	{
	  SHOW_DR (HIT);
	  ret = D_REGS[i];
	}
    }
  /* this is a hack to GDB. If we stopped at a hardware breakpoint,
     the stop_pc must incremented by DECR_PC_AFTER_BREAK. I tried everything
     with the DECR_PC_AFTER_HW_BREAK, but nothing works. */
  /* This is probably fixed by jtc's recent patch -sts 2/19/99 */
  if (STATUS && !ret)
    stop_pc += DECR_PC_AFTER_BREAK;
  STATUS = 0;

  return ret;
}

/* Remove a breakpoint.  */

int
go32_remove_hw_breakpoint (CORE_ADDR addr, CORE_ADDR shadow)
{
  int i;
  for (i = 0; i <= 3; i++)
    {
      if (D_REGS[i] == addr)
	{
	  DISABLE_REG (i);
	}
    }
  SHOW_DR (remove_hw);
  return 0;
}

int
go32_insert_hw_breakpoint (CORE_ADDR addr, CORE_ADDR shadow)
{
  int i;
  int read_write_bits, len_bits;
  int free_debug_register;
  int register_number;

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

  SET_BREAK (i, addr);
  LOCAL_ENABLE_REG (i);
  SHOW_DR (insert_hw);

  return 0;
}

static struct target_ops go32_ops;

static void
init_go32_ops (void)
{
  go32_ops.to_shortname = "djgpp";
  go32_ops.to_longname = "djgpp target process";
  go32_ops.to_doc =
    "Program loaded by djgpp, when gdb is used as an external debugger";
  go32_ops.to_open = go32_open;
  go32_ops.to_close = go32_close;
  go32_ops.to_detach = go32_detach;
  go32_ops.to_resume = go32_resume;
  go32_ops.to_wait = go32_wait;
  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.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_terminal_init = ignore;
  go32_ops.to_terminal_inferior = ignore;
  go32_ops.to_terminal_ours_for_output = ignore;
  go32_ops.to_terminal_ours = ignore;
  go32_ops.to_terminal_info = ignore2;
  go32_ops.to_kill = go32_kill_inferior;
  go32_ops.to_create_inferior = go32_create_inferior;
  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_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;
  go32_ops.to_magic = OPS_MAGIC;
}

void
_initialize_go32_nat (void)
{
  init_go32_ops ();
  add_target (&go32_ops);
}
Commit	Line	Data
e49d4fa6 SS	1	/* Native debugging support for Intel x86 running DJGPP.
	2	Copyright 1997, 1999 Free Software Foundation, Inc.
	3	Written by Robert Hoehne.
	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	20
	21	#include <fcntl.h>
	22
	23	#include "defs.h"
	24	#include "frame.h" /* required by inferior.h */
	25	#include "inferior.h"
	26	#include "target.h"
	27	#include "wait.h"
	28	#include "gdbcore.h"
	29	#include "command.h"
	30	#include "floatformat.h"
	31
	32	#include <stdlib.h>
	33	#include <string.h>
	34	#include <unistd.h>
	35	#include <debug/v2load.h>
	36	#include <debug/dbgcom.h>
	37
	38	extern void _initialize_go32_nat (void);
	39
	40	struct env387
	41	{
	42	unsigned short control;
	43	unsigned short r0;
	44	unsigned short status;
	45	unsigned short r1;
	46	unsigned short tag;
	47	unsigned short r2;
	48	unsigned long eip;
	49	unsigned short code_seg;
	50	unsigned short opcode;
	51	unsigned long operand;
	52	unsigned short operand_seg;
	53	unsigned short r3;
	54	unsigned char regs[8][10];
	55	};
	56
	57	extern char **environ;
	58
	59	#define SOME_PID 42
	60
	61	/* FIXME add decls of all static functions here */
	62
	63	static int prog_has_started = 0;
	64
65	static void
66	print_387_status (unsigned short status, struct env387 *ep)
67	{
68	int i;
69	int bothstatus;
70	int top;
71	int fpreg;
72
73	bothstatus = ((status != 0) && (ep->status != 0));
74	if (status != 0)
75	{
76	if (bothstatus)
77	printf_unfiltered ("u: ");
78	print_387_status_word (status);
79	}
80
81	if (ep->status != 0)
82	{
83	if (bothstatus)
84	printf_unfiltered ("e: ");
85	print_387_status_word (ep->status);
86	}
87
88	print_387_control_word (ep->control & 0xffff);
89	printf_unfiltered ("last exception: ");
90	printf_unfiltered ("opcode %s; ", local_hex_string (ep->opcode));
91	printf_unfiltered ("pc %s:", local_hex_string (ep->code_seg));
92	printf_unfiltered ("%s; ", local_hex_string (ep->eip));
93	printf_unfiltered ("operand %s", local_hex_string (ep->operand_seg));
94	printf_unfiltered (":%s\n", local_hex_string (ep->operand));
95
96	top = (ep->status >> 11) & 7;
97
98	printf_unfiltered ("regno tag msb lsb value\n");
99	for (fpreg = 0; fpreg < 8; fpreg++)
100	{
101	long double val;
102
103	printf_unfiltered ("%s %d: ", fpreg == top ? "=>" : " ", fpreg);
104
105	switch ((ep->tag >> (fpreg * 2)) & 3)
106	{
107	case 0:
108	printf_unfiltered ("valid ");
109	break;
110	case 1:
111	printf_unfiltered ("zero ");
112	break;
113	case 2:
114	printf_unfiltered ("trap ");
115	break;
116	case 3:
117	printf_unfiltered ("empty ");
118	break;
119	}
120	for (i = 0; i < 8; i++)
121	printf_unfiltered ("%02x", ep->regs[fpreg][i]);
122
123	REGISTER_CONVERT_TO_VIRTUAL (FP0_REGNUM + fpreg, builtin_type_long_double,
124	&ep->regs[fpreg], &val);
125
126	printf_unfiltered (" %LG\n", val);
127	}
128	}
129
130	void
131	i386_go32_float_info (void)
132	{
133	print_387_status (0, (struct env387 *) &npx);
134	}
135
136	#define r_ofs(x) ((int)(&(((TSS *)0)->x)))
137
138	static struct
139	{
140	int tss_ofs;
141	int size;
142	}
143	regno_mapping[] =
144	{
145	r_ofs (tss_eax), 4,
146	r_ofs (tss_ecx), 4,
147	r_ofs (tss_edx), 4,
148	r_ofs (tss_ebx), 4,
149	r_ofs (tss_esp), 4,
150	r_ofs (tss_ebp), 4,
151	r_ofs (tss_esi), 4,
152	r_ofs (tss_edi), 4,
153	r_ofs (tss_eip), 4,
154	r_ofs (tss_eflags), 4,
155	r_ofs (tss_cs), 2,
156	r_ofs (tss_ss), 2,
157	r_ofs (tss_ds), 2,
158	r_ofs (tss_es), 2,
159	r_ofs (tss_fs), 2,
160	r_ofs (tss_gs), 2,
161	0, 10,
162	1, 10,
163	2, 10,
164	3, 10,
165	4, 10,
166	5, 10,
167	6, 10,
168	7, 10,
169	0, 2,
170	4, 2,
171	8, 2,
172	12, 4,
173	16, 2,
174	20, 4,
175	24, 2
176	};
177
178	static struct
179	{
180	int go32_sig;
181	int gdb_sig;
182	}
183	sig_map[] =
184	{
185	0, TARGET_SIGNAL_FPE,
186	1, TARGET_SIGNAL_TRAP,
187	2, TARGET_SIGNAL_UNKNOWN,
188	3, TARGET_SIGNAL_TRAP,
189	4, TARGET_SIGNAL_FPE,
190	5, TARGET_SIGNAL_SEGV,
191	6, TARGET_SIGNAL_ILL,
192	7, TARGET_SIGNAL_FPE,
193	8, TARGET_SIGNAL_SEGV,
194	9, TARGET_SIGNAL_SEGV,
195	10, TARGET_SIGNAL_BUS,
196	11, TARGET_SIGNAL_SEGV,
197	12, TARGET_SIGNAL_SEGV,
198	13, TARGET_SIGNAL_ABRT,
199	14, TARGET_SIGNAL_SEGV,
200	16, TARGET_SIGNAL_FPE,
201	31, TARGET_SIGNAL_ILL,
202	0x75, TARGET_SIGNAL_FPE,
203	0x79, TARGET_SIGNAL_INT,
204	0x1b, TARGET_SIGNAL_INT,
205	-1, -1
206	};
207
208	static void
209	go32_open (char *name, int from_tty)
210	{
211	printf_unfiltered ("Use the `run' command to run go32 programs\n");
212	}
213
214	static void
215	go32_close (int quitting)
216	{
217	}
218
219	static void
220	go32_attach (char *args, int from_tty)
221	{
222	printf_unfiltered ("Use the `run' command to run go32 programs\n");
223	}
224
225	static void
226	go32_detach (char *args, int from_tty)
227	{
228	}
229
230	static int resume_is_step;
231
232	static void
233	go32_resume (int pid, int step, enum target_signal siggnal)
234	{
235	resume_is_step = step;
236	}
237
238	static int
239	go32_wait (int pid, struct target_waitstatus *status)
240	{
241	int i;
242
243	if (resume_is_step)
244	a_tss.tss_eflags \|= 0x0100;
245	else
246	a_tss.tss_eflags &= 0xfeff;
247
248	run_child ();
249
250	if (a_tss.tss_irqn == 0x21)
251	{
252	status->kind = TARGET_WAITKIND_EXITED;
253	status->value.integer = a_tss.tss_eax & 0xff;
254	}
255	else
256	{
257	status->value.sig = TARGET_SIGNAL_UNKNOWN;
258	status->kind = TARGET_WAITKIND_STOPPED;
259	for (i = 0; sig_map[i].go32_sig != -1; i++)
260	{
261	if (a_tss.tss_irqn == sig_map[i].go32_sig)
262	{
263	if ((status->value.sig = sig_map[i].gdb_sig) !=
264	TARGET_SIGNAL_TRAP)
265	status->kind = TARGET_WAITKIND_SIGNALLED;
266	break;
267	}
268	}
269	}
270	return SOME_PID;
271	}
272
273	static void
274	go32_fetch_registers (int regno)
275	{
276	/JHW/
277	int end_reg = regno + 1; /* just one reg initially */
278
279	if (regno < 0) /* do the all registers */
280	{
281	regno = 0; /* start at first register */
282	/* # regs in table */
283	end_reg = sizeof (regno_mapping) / sizeof (regno_mapping[0]);
284	}
285
286	for (; regno < end_reg; regno++)
287	{
288	if (regno < 16)
289	supply_register (regno,
290	(char *) &a_tss + regno_mapping[regno].tss_ofs);
291	else if (regno < 24)
292	supply_register (regno,
293	(char *) &npx.reg[regno_mapping[regno].tss_ofs]);
294	else if (regno < 31)
295	supply_register (regno,
296	(char *) &npx.reg + regno_mapping[regno].tss_ofs);
297	else
298	{
299	printf_unfiltered ("Invalid register in go32_fetch_register(%d)",
300	regno);
301	exit (1);
302	}
303	}
304	}
305
306	static void
307	store_register (int regno)
308	{
309	void *rp;
310	void v = (void ) &registers[REGISTER_BYTE (regno)];
311
312	if (regno < 16)
313	rp = (char *) &a_tss + regno_mapping[regno].tss_ofs;
314	else if (regno < 24)
315	rp = (char *) &npx.reg[regno_mapping[regno].tss_ofs];
316	else if (regno > 31)
317	rp = (char *) &npx + regno_mapping[regno].tss_ofs;
318	else
319	{
320	printf_unfiltered ("Invalid register in store_register(%d)", regno);
321	exit (1);
322	}
323	memcpy (rp, v, regno_mapping[regno].size);
324	}
325
326	static void
327	go32_store_registers (int regno)
328	{
329	int r;
330
331	if (regno >= 0)
332	store_register (regno);
333	else
334	{
335	for (r = 0; r < sizeof (regno_mapping) / sizeof (regno_mapping[0]); r++)
336	store_register (r);
337	}
338	}
339
340	static void
341	go32_prepare_to_store (void)
342	{
343	}
344
345	static int
346	go32_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
347	struct target_ops *target)
348	{
349	if (write)
350	{
351	if (write_child (memaddr, myaddr, len))
352	{
353	return 0;
354	}
355	else
356	{
357	return len;
358	}
359	}
360	else
361	{
362	if (read_child (memaddr, myaddr, len))
363	{
364	return 0;
365	}
366	else
367	{
368	return len;
369	}
370	}
371	}
372
373	static void
374	go32_files_info (struct target_ops *target)
375	{
376	printf_unfiltered ("You are running a DJGPP V2 program\n");
377	}
378
379	static void
380	go32_stop (void)
381	{
382	normal_stop ();
383	cleanup_client ();
384	inferior_pid = 0;
385	prog_has_started = 0;
386	}
387
388	static void
389	go32_kill_inferior (void)
390	{
391	go32_stop ();
392	unpush_target (&go32_ops);
393	}
394
395	static void
396	go32_create_inferior (char exec_file, char args, char **env)
397	{
398	jmp_buf start_state;
399	char *cmdline;
400	char **env_save = environ;
401
402	if (prog_has_started)
403	{
404	go32_kill_inferior ();
405	}
406
407	cmdline = (char *) alloca (strlen (args) + 4);
408	cmdline[0] = strlen (args);
409	strcpy (cmdline + 1, args);
410	cmdline[strlen (args) + 1] = 13;
411
412	environ = env;
413
414	if (v2loadimage (exec_file, cmdline, start_state))
415	{
416	environ = env_save;
417	printf_unfiltered ("Load failed for image %s\n", exec_file);
418	exit (1);
419	}
420	environ = env_save;
421
422	edi_init (start_state);
423
424	inferior_pid = SOME_PID;
425	push_target (&go32_ops);
426	clear_proceed_status ();
427	insert_breakpoints ();
428	proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
429	}
430
431	static void
432	go32_mourn_inferior (void)
433	{
434	go32_kill_inferior ();
435	generic_mourn_inferior ();
436	}
437
438	static int
439	go32_can_run (void)
440	{
441	return 1;
442	}
443
444	static void
445	ignore (void)
446	{
447	}
448
449	static void
450	ignore2 (char *a, int b)
451	{
452	}
453
454	/* Hardware watchpoint support. */
455
456	#define DR_STATUS 6
457	#define DR_CONTROL 7
458	#define DR_ENABLE_SIZE 2
459	#define DR_LOCAL_ENABLE_SHIFT 0
460	#define DR_GLOBAL_ENABLE_SHIFT 1
461	#define DR_LOCAL_SLOWDOWN 0x100
462	#define DR_GLOBAL_SLOWDOWN 0x200
463	#define DR_CONTROL_SHIFT 16
464	#define DR_CONTROL_SIZE 4
465	#define DR_RW_READ 0x3
466	#define DR_RW_WRITE 0x1
467	#define DR_CONTROL_MASK 0xf
468	#define DR_ENABLE_MASK 0x3
469	#define DR_LEN_1 0x0
470	#define DR_LEN_2 0x4
471	#define DR_LEN_4 0xc
472
473	#define D_REGS edi.dr
474	#define CONTROL D_REGS[DR_CONTROL]
475	#define STATUS D_REGS[DR_STATUS]
476
477	#define IS_REG_FREE(index) \
478	(!(CONTROL & (3 << (DR_ENABLE_SIZE * index))))
479
480	#define LOCAL_ENABLE_REG(index) \
481	(CONTROL \|= (1 << (DR_LOCAL_ENABLE_SHIFT + DR_ENABLE_SIZE * index)))
482
483	#define GLOBAL_ENABLE_REG(index) \
484	(CONTROL \|= (1 << (DR_GLOBAL_ENABLE_SHIFT + DR_ENABLE_SIZE * index)))
485
486	#define DISABLE_REG(index) \
487	(CONTROL &= ~(3 << (DR_ENABLE_SIZE * index)))
488
489	#define SET_LOCAL_EXACT() \
490	(CONTROL \|= DR_LOCAL_SLOWDOWN)
491
492	#define SET_GLOBAL_EXACT() \
493	(CONTROL \|= DR_GLOBAL_SLOWDOWN)
494
495	#define SET_BREAK(index,address) \
496	do {\
497	CONTROL &= ~(DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * index));\
498	D_REGS[index] = address;\
499	} while(0)
500
501	#define SET_WATCH(index,address,rw,len) \
502	do {\
503	SET_BREAK(index,address);\
504	CONTROL \|= (len \| rw) << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * index);\
505	} while (0)
506
507	#define WATCH_HIT(index) \
508	(\
509	(STATUS & (1 << index)) && \
510	(CONTROL & (DR_CONTROL_MASK << (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * index)))\
511	)
512
513	#if 0 /* use debugging macro */
514	#define SHOW_DR(text) \
515	do { \
516	fprintf(stderr,"%08x %08x ",edi.dr[7],edi.dr[6]); \
517	fprintf(stderr,"%08x %08x ",edi.dr[0],edi.dr[1]); \
518	fprintf(stderr,"%08x %08x ",edi.dr[2],edi.dr[3]); \
519	fprintf(stderr,"(%s)\n",#text); \
520	} while (0)
521	#else
522	#define SHOW_DR(text) do {} while (0)
523	#endif
524
525	static int go32_insert_aligned_watchpoint (int pid, CORE_ADDR waddr,
526	CORE_ADDR addr, int len, int rw);
527
528	static int go32_insert_nonaligned_watchpoint (int pid, CORE_ADDR waddr,
529	CORE_ADDR addr, int len, int rw);
530
531	/* Insert a watchpoint. */
532
533	int
534	go32_insert_watchpoint (int pid, CORE_ADDR addr, int len, int rw)
535	{
536	int ret = go32_insert_aligned_watchpoint (pid, addr, addr, len, rw);
537
538	SHOW_DR (insert_watch);
539	return ret;
540	}
541
542	static int
543	go32_insert_aligned_watchpoint (int pid, CORE_ADDR waddr, CORE_ADDR addr,
544	int len, int rw)
545	{
546	int i;
547	int read_write_bits, len_bits;
548
549	/* Look for a free debug register. */
550	for (i = 0; i <= 3; i++)
551	{
552	if (IS_REG_FREE (i))
553	break;
554	}
555
556	/* No more debug registers! */
557	if (i > 3)
558	return -1;
559
560	read_write_bits = ((rw & 1) ? DR_RW_READ : 0) \| ((rw & 2) ? DR_RW_WRITE : 0);
561
562	if (len == 1)
563	len_bits = DR_LEN_1;
564	else if (len == 2)
565	{
566	if (addr % 2)
567	return go32_insert_nonaligned_watchpoint (pid, waddr, addr, len, rw);
568	len_bits = DR_LEN_2;
569	}
570	else if (len == 4)
571	{
572	if (addr % 4)
573	return go32_insert_nonaligned_watchpoint (pid, waddr, addr, len, rw);
574	len_bits = DR_LEN_4;
575	}
576	else
577	return go32_insert_nonaligned_watchpoint (pid, waddr, addr, len, rw);
578
579	SET_WATCH (i, addr, read_write_bits, len_bits);
580	LOCAL_ENABLE_REG (i);
581	SET_LOCAL_EXACT ();
582	}
583
584	static int
585	go32_insert_nonaligned_watchpoint (int pid, CORE_ADDR waddr, CORE_ADDR addr,
586	int len, int rw)
587	{
588	int align;
589	int size;
590	int rv = 0;
591
592	static int size_try_array[16] =
593	{
594	1, 1, 1, 1, /* trying size one */
595	2, 1, 2, 1, /* trying size two */
596	2, 1, 2, 1, /* trying size three */
597	4, 1, 2, 1 /* trying size four */
598	};
599
600	while (len > 0)
601	{
602	align = addr % 4;
603	/* Four is the maximum length for 386. */
604	size = (len > 4) ? 3 : len - 1;
605	size = size_try_array[size * 4 + align];
606	rv = go32_insert_aligned_watchpoint (pid, waddr, addr, size, rw);
607	if (rv)
608	{
609	go32_remove_watchpoint (pid, waddr, size);
610	return rv;
611	}
612	addr += size;
613	len -= size;
614	}
615	return rv;
616	}
617
618	/* Remove a watchpoint. */
619
620	int
621	go32_remove_watchpoint (int pid, CORE_ADDR addr, int len)
622	{
623	int i;
624
625	for (i = 0; i <= 3; i++)
626	{
627	if (D_REGS[i] == addr)
628	{
629	DISABLE_REG (i);
630	}
631	}
632	SHOW_DR (remove_watch);
633
634	return 0;
635	}
636
637	/* Check if stopped by a watchpoint. */
638
639	CORE_ADDR
640	go32_stopped_by_watchpoint (int pid)
641	{
642	int i, ret = 0;
643	int status;
644
645	status = edi.dr[DR_STATUS];
646	SHOW_DR (stopped_by);
647	for (i = 0; i <= 3; i++)
648	{
649	if (WATCH_HIT (i))
650	{
651	SHOW_DR (HIT);
652	ret = D_REGS[i];
653	}
654	}
655	/* this is a hack to GDB. If we stopped at a hardware breakpoint,
656	the stop_pc must incremented by DECR_PC_AFTER_BREAK. I tried everything
657	with the DECR_PC_AFTER_HW_BREAK, but nothing works. */
658	/* This is probably fixed by jtc's recent patch -sts 2/19/99 */
659	if (STATUS && !ret)
660	stop_pc += DECR_PC_AFTER_BREAK;
661	STATUS = 0;
662
663	return ret;
664	}
665
666	/* Remove a breakpoint. */
667
668	int
669	go32_remove_hw_breakpoint (CORE_ADDR addr, CORE_ADDR shadow)
670	{
671	int i;
672	for (i = 0; i <= 3; i++)
673	{
674	if (D_REGS[i] == addr)
675	{
676	DISABLE_REG (i);
677	}
678	}
679	SHOW_DR (remove_hw);
680	return 0;
681	}
682
683	int
684	go32_insert_hw_breakpoint (CORE_ADDR addr, CORE_ADDR shadow)
685	{
686	int i;
687	int read_write_bits, len_bits;
688	int free_debug_register;
689	int register_number;
690
691	/* Look for a free debug register. */
692	for (i = 0; i <= 3; i++)
693	{
694	if (IS_REG_FREE (i))
695	break;
696	}
697
698	/* No more debug registers! */
699	if (i > 3)
700	return -1;
701
702	SET_BREAK (i, addr);
703	LOCAL_ENABLE_REG (i);
704	SHOW_DR (insert_hw);
705
706	return 0;
707	}
708
709	static struct target_ops go32_ops;
710
711	static void
712	init_go32_ops (void)
713	{
714	go32_ops.to_shortname = "djgpp";
715	go32_ops.to_longname = "djgpp target process";
716	go32_ops.to_doc =
717	"Program loaded by djgpp, when gdb is used as an external debugger";
718	go32_ops.to_open = go32_open;
719	go32_ops.to_close = go32_close;
720	go32_ops.to_detach = go32_detach;
721	go32_ops.to_resume = go32_resume;
722	go32_ops.to_wait = go32_wait;
723	go32_ops.to_fetch_registers = go32_fetch_registers;
724	go32_ops.to_store_registers = go32_store_registers;
725	go32_ops.to_prepare_to_store = go32_prepare_to_store;
726	go32_ops.to_xfer_memory = go32_xfer_memory;
727	go32_ops.to_files_info = go32_files_info;
728	go32_ops.to_insert_breakpoint = memory_insert_breakpoint;
729	go32_ops.to_remove_breakpoint = memory_remove_breakpoint;
730	go32_ops.to_terminal_init = ignore;
731	go32_ops.to_terminal_inferior = ignore;
732	go32_ops.to_terminal_ours_for_output = ignore;
733	go32_ops.to_terminal_ours = ignore;
734	go32_ops.to_terminal_info = ignore2;
735	go32_ops.to_kill = go32_kill_inferior;
736	go32_ops.to_create_inferior = go32_create_inferior;
737	go32_ops.to_mourn_inferior = go32_mourn_inferior;
738	go32_ops.to_can_run = go32_can_run;
739	go32_ops.to_stop = go32_stop;
740	go32_ops.to_stratum = process_stratum;
741	go32_ops.to_has_all_memory = 1;
742	go32_ops.to_has_memory = 1;
743	go32_ops.to_has_stack = 1;
744	go32_ops.to_has_registers = 1;
745	go32_ops.to_has_execution = 1;
746	go32_ops.to_magic = OPS_MAGIC;
747	}
748
749	void
750	_initialize_go32_nat (void)
751	{
752	init_go32_ops ();
753	add_target (&go32_ops);
754	}