* remote-sim.c: first attempt at general simulator interface

	* remote-hms.c: whitespace
	* h8300-tdep.c: (h8300_skip_prologue, examine_prologue):
	understand new stack layout. (print_register_hook): print ccr
	register in a fancy way.

6 files changed, 1159 insertions, 803 deletions

diff --git a/gdb/.Sanitize b/gdb/.Sanitize
index 8cd5d48..df109ec 100644
--- a/gdb/.Sanitize
+++ b/gdb/.Sanitize
@@ -210,6 +210,7 @@ remote-es1800.c
 remote-hms.c
 remote-mm.c
 remote-nindy.c
+remote-sim.c
 remote-st2000.c
 remote-vx.c
 remote.c
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index dabe64b..2ca09d4 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,11 @@
+Sun Jan  3 14:24:56 1993  Steve Chamberlain  (sac@thepub.cygnus.com)
+
+	* remote-sim.c: first attempt at general simulator interface
+	* remote-hms.c: whitespace
+	* h8300-tdep.c: (h8300_skip_prologue, examine_prologue):
+	understand new stack layout. (print_register_hook): print ccr
+	register in a fancy way.
+
 Sun Jan  3 14:16:10 1993  Fred Fish  (fnf@cygnus.com)
 
 	* eval.c (language.h): Include.
diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c
index eb2f03f..c47c266 100644
--- a/gdb/h8300-tdep.c
+++ b/gdb/h8300-tdep.c
@@ -17,9 +17,9 @@ 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
-/* 
+/*
  Contributed by Steve Chamberlain
-                sac@cygnus.com 
+                sac@cygnus.com
  */
 
 #include "defs.h"
@@ -29,61 +29,80 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
 
 /* an easy to debug H8 stack frame looks like:
-0x6df2	push	r2
-0x6df3	push	r3
-0x6df6	push	r6
-0x	mov.w	r7,r6
-	subs	stuff,sp  mov.w #x,r5
-	                  subs  r5,sp
+0x6df6		push	r6
+0x0d76  	mov.w   r7,r6
+0x6dfn          push    reg
+0x7905 nnnn  	mov.w  #n,r5    or   0x1b87  subs #2,sp
+0x1957       	sub.w  r5,sp
 
  */
 
 #define IS_PUSH(x) ((x & 0xff00)==0x6d00)
+#define IS_PUSH_FP(x) (x == 0x6df6)
 #define IS_MOVE_FP(x) (x == 0x0d76)
 #define IS_MOV_SP_FP(x) (x == 0x0d76)
 #define IS_SUB2_SP(x) (x==0x1b87)
 #define IS_MOVK_R5(x) (x==0x7905)
-CORE_ADDR examine_prologue();
+#define IS_SUB_R5SP(x) (x==0x1957)
+CORE_ADDR examine_prologue ();
 
-void   frame_find_saved_regs ();
-CORE_ADDR h8300_skip_prologue(start_pc)
-CORE_ADDR start_pc;
+void frame_find_saved_regs ();
+CORE_ADDR 
+h8300_skip_prologue (start_pc)
+     CORE_ADDR start_pc;
 
 {
+  short int w;
 
+  w = read_memory_short (start_pc);
   /* Skip past all push insns */
-  short int w;
-  
-  w = read_memory_short(start_pc);
-  while (IS_PUSH(w)) 
-  {
-    start_pc+=2;  
-    w = read_memory_short(start_pc);
-  }
+  while (IS_PUSH_FP (w))
+    {
+      start_pc += 2;
+      w = read_memory_short (start_pc);
+    }
 
   /* Skip past a move to FP */
-  if (IS_MOVE_FP(w)) {
-      start_pc +=2 ;
-      w = read_memory_short(start_pc);
+  if (IS_MOVE_FP (w))
+    {
+      start_pc += 2;
+      w = read_memory_short (start_pc);
     }
 
-  return start_pc;  
-  
-}
+  /* Skip the stack adjust */
 
+  if (IS_MOVK_R5 (w))
+    {
+      start_pc += 2;
+      w = read_memory_short (start_pc);
+    }
+  if (IS_SUB_R5SP (w))
+    {
+      start_pc += 2;
+      w = read_memory_short (start_pc);
+    }
+  while (IS_SUB2_SP (w))
+    {
+      start_pc += 2;
+      w = read_memory_short (start_pc);
+    }
+
+  return start_pc;
+
+}
 
 int
-print_insn(memaddr, stream)
-CORE_ADDR memaddr;
-FILE *stream;
+print_insn (memaddr, stream)
+     CORE_ADDR memaddr;
+     FILE *stream;
 {
   /* Nothing is bigger than 8 bytes */
-  char   data[8];
-  read_memory (memaddr, data, sizeof(data));
-  return print_insn_h8300(memaddr,  data, stream);
+  char data[8];
+
+  read_memory (memaddr, data, sizeof (data));
+  return print_insn_h8300 (memaddr, data, stream);
 }
-     
-     
+
 /* Given a GDB frame, determine the address of the calling function's frame.
    This will be used to create a new GDB frame struct, and then
    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
@@ -97,11 +116,9 @@ FRAME_CHAIN (thisframe)
 {
 
   frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0);
-    return thisframe->fsr->regs[SP_REGNUM];
+  return thisframe->fsr->regs[SP_REGNUM];
 }
 
-     
-
 /* Put here the code to store, into a struct frame_saved_regs,
    the addresses of the saved registers of frame described by FRAME_INFO.
    This includes special registers such as pc and fp saved in special
@@ -128,18 +145,19 @@ frame_find_saved_regs (fi, fsr)
   if (!fi->fsr)
     {
       cache_fsr = (struct frame_saved_regs *)
-		  obstack_alloc (&frame_cache_obstack,
-				 sizeof (struct frame_saved_regs));
+	obstack_alloc (&frame_cache_obstack,
+		       sizeof (struct frame_saved_regs));
       bzero (cache_fsr, sizeof (struct frame_saved_regs));
+
       fi->fsr = cache_fsr;
 
       /* Find the start and end of the function prologue.  If the PC
 	 is in the function prologue, we only consider the part that
 	 has executed already.  */
-         
+
       ip = get_pc_function_start (fi->pc);
       sal = find_pc_line (ip, 0);
-      limit = (sal.end && sal.end < fi->pc) ? sal.end: fi->pc;
+      limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc;
 
       /* This will fill in fields in *fi as well as in cache_fsr.  */
       examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
@@ -148,55 +166,37 @@ frame_find_saved_regs (fi, fsr)
   if (fsr)
     *fsr = *fi->fsr;
 }
-     
 
 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
    is not the address of a valid instruction, the address of the next
    instruction beyond ADDR otherwise.  *PWORD1 receives the first word
    of the instruction.*/
 
-
 CORE_ADDR
-NEXT_PROLOGUE_INSN(addr, lim, pword1)
-CORE_ADDR addr;
-CORE_ADDR lim;
-short *pword1;
+NEXT_PROLOGUE_INSN (addr, lim, pword1)
+     CORE_ADDR addr;
+     CORE_ADDR lim;
+     short *pword1;
 {
-  if (addr < lim+8)   
-  {
-    read_memory (addr, pword1, sizeof(*pword1));
-    SWAP_TARGET_AND_HOST (pword1, sizeof (short));
-    return addr + 2;
-  }
+  if (addr < lim + 8)
+    {
+      read_memory (addr, pword1, sizeof (*pword1));
+      SWAP_TARGET_AND_HOST (pword1, sizeof (short));
 
+      return addr + 2;
+    }
   return 0;
-
 }
 
 /* Examine the prologue of a function.  `ip' points to the first instruction.
-   `limit' is the limit of the prologue (e.g. the addr of the first 
+   `limit' is the limit of the prologue (e.g. the addr of the first
    linenumber, or perhaps the program counter if we're stepping through).
-   `frame_sp' is the stack pointer value in use in this frame.  
+   `frame_sp' is the stack pointer value in use in this frame.
    `fsr' is a pointer to a frame_saved_regs structure into which we put
-   info about the registers saved by this frame.  
+   info about the registers saved by this frame.
    `fi' is a struct frame_info pointer; we fill in various fields in it
    to reflect the offsets of the arg pointer and the locals pointer.  */
 
-/* We will find two sorts of prologue, framefull and non framefull:
-   
-   push   r2
-   push   r3
-   push   fp
-   mov    sp,fp
-   stack_ad
- 
-   and
-   push   x
-   push   y
-   stack_ad
-
-*/
-
 static CORE_ADDR
 examine_prologue (ip, limit, after_prolog_fp, fsr, fi)
      register CORE_ADDR ip;
@@ -209,107 +209,102 @@ examine_prologue (ip, limit, after_prolog_fp, fsr, fi)
   int r;
   int i;
   int have_fp = 0;
-  
+
   register int src;
   register struct pic_prologue_code *pcode;
   INSN_WORD insn_word;
   int size, offset;
-  unsigned int reg_save_depth = 2; /* Number of things pushed onto
+  unsigned int reg_save_depth = 2;	/* Number of things pushed onto
 				      stack, starts at 2, 'cause the
 				      PC is already there */
 
   unsigned int auto_depth = 0;	/* Number of bytes of autos */
-  
-  char in_frame[NUM_REGS];      /* One for each reg */
-  
-  memset(in_frame, 1, NUM_REGS);
-  
-  if (after_prolog_fp == 0) {
-      after_prolog_fp = read_register(SP_REGNUM);
-    }  
-  if (ip == 0 || ip & ~0xffff) return 0;
 
-  next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
+  char in_frame[NUM_REGS];	/* One for each reg */
 
-  /* Skip over any push instructions, and remember where they were saved */
+  memset (in_frame, 1, NUM_REGS);
+  for (r = 0; r < NUM_REGS; r++)
+    {
+      fsr->regs[r] = 0;
+    }
+  if (after_prolog_fp == 0)
+    {
+      after_prolog_fp = read_register (SP_REGNUM);
+    }
+  if (ip == 0 || ip & ~0xffff)
+    return 0;
 
+  next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 
-  while (next_ip && IS_PUSH(insn_word))
-  {
-    ip = next_ip;
-    in_frame[insn_word & 0x7] = reg_save_depth;
-    next_ip = NEXT_PROLOGUE_INSN(ip, limit, &insn_word);
-    reg_save_depth +=2;
+  /* Skip over any fp push instructions */
+  fsr->regs[6] = after_prolog_fp;
+  while (next_ip && IS_PUSH_FP (insn_word))
+    {
+      ip = next_ip;
 
-  }
-  
+      in_frame[insn_word & 0x7] = reg_save_depth;
+      next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
+      reg_save_depth += 2;
+    }
 
   /* Is this a move into the fp */
-  if (next_ip && IS_MOV_SP_FP(insn_word)) 
-  {
-    ip = next_ip;
-    next_ip = NEXT_PROLOGUE_INSN(ip, limit, &insn_word);
-    have_fp = 1;
-    
-  }
-  
+  if (next_ip && IS_MOV_SP_FP (insn_word))
+    {
+      ip = next_ip;
+      next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
+      have_fp = 1;
+    }
 
   /* Skip over any stack adjustment, happens either with a number of
      sub#2,sp or a mov #x,r5 sub r5,sp */
 
-  
-  if (next_ip && IS_SUB2_SP(insn_word))
-  {
-    while (next_ip && IS_SUB2_SP(insn_word)) 
+  if (next_ip && IS_SUB2_SP (insn_word))
     {
-      auto_depth +=2 ;
-      ip = next_ip;
-      next_ip = NEXT_PROLOGUE_INSN(ip, limit, &insn_word);
+      while (next_ip && IS_SUB2_SP (insn_word))
+	{
+	  auto_depth += 2;
+	  ip = next_ip;
+	  next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
+	}
     }
-  }
-  else  
-  {
-    if (next_ip && IS_MOVK_R5(insn_word)) 
+  else
+    {
+      if (next_ip && IS_MOVK_R5 (insn_word))
+	{
+	  ip = next_ip;
+	  next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
+	  auto_depth += insn_word;
+
+	  next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn_word);
+	  auto_depth += insn_word;
+
+	}
+    }
+  /* Work out which regs are stored where */
+  while (next_ip && IS_PUSH (insn_word))
     {
       ip = next_ip;
-      next_ip = NEXT_PROLOGUE_INSN(ip, limit, &insn_word);
-      auto_depth += insn_word;
-      ip +=4;
-      
+      next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
+      fsr->regs[r] = after_prolog_fp + auto_depth;
+      auto_depth += 2;
     }
-  }
 
-
-  
   /* The args are always reffed based from the stack pointer */
-  fi->args_pointer =  after_prolog_fp - auto_depth;
+  fi->args_pointer = after_prolog_fp;
   /* Locals are always reffed based from the fp */
-  fi->locals_pointer = after_prolog_fp ;
+  fi->locals_pointer = after_prolog_fp;
   /* The PC is at a known place */
-  fi->from_pc = read_memory_short(after_prolog_fp + reg_save_depth-2 );
-  
+  fi->from_pc = read_memory_short (after_prolog_fp + 2);
 
   /* Rememeber any others too */
-
   in_frame[PC_REGNUM] = 0;
-  
-  for (r = 0; r < NUM_REGS; r++) 
-  {
-    if (in_frame[r] != 1) 
-    {
-      fsr->regs[r] = after_prolog_fp + reg_save_depth - in_frame[r] -2;
-    }
-    else
-    {
-      fsr->regs[r] = 0;
-    }
-  }	
-  if (have_fp) 
-   /* We keep the old FP in the SP spot */
-   fsr->regs[SP_REGNUM] = (read_memory_short(fsr->regs[6])) ;
-  else 
-   fsr->regs[SP_REGNUM] = after_prolog_fp + reg_save_depth;
-  
+
+  if (have_fp)
+    /* We keep the old FP in the SP spot */
+    fsr->regs[SP_REGNUM] = (read_memory_short (fsr->regs[6]));
+  else
+    fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth;
+
   return (ip);
 }
 
@@ -322,8 +317,9 @@ init_extra_frame_info (fromleaf, fi)
   fi->args_pointer = 0;		/* Unknown */
   fi->locals_pointer = 0;	/* Unknown */
   fi->from_pc = 0;
-  
+
 }
+
 /* Return the saved PC from this frame.
 
    If the frame has a memory copy of SRP_REGNUM, use that.  If not,
@@ -331,23 +327,23 @@ init_extra_frame_info (fromleaf, fi)
 
 CORE_ADDR
 frame_saved_pc (frame)
-FRAME frame;
+     FRAME frame;
 
 {
   return frame->from_pc;
 }
 
-
 CORE_ADDR
 frame_locals_address (fi)
      struct frame_info *fi;
 {
-  if (!fi->locals_pointer) 
-  {
-    struct frame_saved_regs ignore;
-    get_frame_saved_regs(fi, &ignore);  
+  if (!fi->locals_pointer)
+    {
+      struct frame_saved_regs ignore;
+
+      get_frame_saved_regs (fi, &ignore);
 
-  }
+    }
   return fi->locals_pointer;
 }
 
@@ -358,38 +354,87 @@ CORE_ADDR
 frame_args_address (fi)
      struct frame_info *fi;
 {
-  if (!fi->args_pointer) 
-  {
-    struct frame_saved_regs ignore;
-  get_frame_saved_regs(fi, &ignore);  
+  if (!fi->args_pointer)
+    {
+      struct frame_saved_regs ignore;
+
+      get_frame_saved_regs (fi, &ignore);
+
+    }
 
-  }
-  
   return fi->args_pointer;
 }
 
-
-void h8300_pop_frame()
+void 
+h8300_pop_frame ()
 {
   unsigned regnum;
   struct frame_saved_regs fsr;
   struct frame_info *fi;
 
-  FRAME frame = get_current_frame();  
-  fi = get_frame_info(frame);  
-  get_frame_saved_regs(fi, &fsr);
+  FRAME frame = get_current_frame ();
 
-  for (regnum = 0; regnum < NUM_REGS; regnum ++) 
-  {
-    if(fsr.regs[regnum]) 
+  fi = get_frame_info (frame);
+  get_frame_saved_regs (fi, &fsr);
+
+  for (regnum = 0; regnum < NUM_REGS; regnum++)
     {
-      write_register(regnum, read_memory_short (fsr.regs[regnum]));
+      if (fsr.regs[regnum])
+	{
+	  write_register (regnum, read_memory_short (fsr.regs[regnum]));
+	}
+
+      flush_cached_frames ();
+      set_current_frame (create_new_frame (read_register (FP_REGNUM),
+					   read_pc ()));
+
     }
-  
-    flush_cached_frames();
-    set_current_frame(create_new_frame(read_register(FP_REGNUM),
-				       read_pc()));
-  
-  }
 
 }
+
+void
+print_register_hook (regno)
+{
+  if (regno == 8)
+    {
+      /* CCR register */
+
+      int C, Z, N, V;
+      unsigned char b[2];
+      unsigned char l;
+
+      read_relative_register_raw_bytes (regno, b);
+      l = b[1];
+      printf ("\t");
+      printf ("I-%d - ", (l & 0x80) != 0);
+      printf ("H-%d - ", (l & 0x20) != 0);
+      N = (l & 0x8) != 0;
+      Z = (l & 0x4) != 0;
+      V = (l & 0x2) != 0;
+      C = (l & 0x1) != 0;
+      printf ("N-%d ", N);
+      printf ("Z-%d ", Z);
+      printf ("V-%d ", V);
+      printf ("C-%d ", C);
+      if ((C | Z) == 0)
+	printf ("u> ");
+      if ((C | Z) == 1)
+	printf ("u<= ");
+      if ((C == 0))
+	printf ("u>= ");
+      if (C == 1)
+	printf ("u< ");
+      if (Z == 0)
+	printf ("!= ");
+      if (Z == 1)
+	printf ("== ");
+      if ((N ^ V) == 0)
+	printf (">= ");
+      if ((N ^ V) == 1)
+	printf ("< ");
+      if ((Z | (N ^ V)) == 0)
+	printf ("> ");
+      if ((Z | (N ^ V)) == 1)
+	printf ("<= ");
+    }
+}
diff --git a/gdb/remote-hms.c b/gdb/remote-hms.c
index 216e5cf..a21d86e 100644
--- a/gdb/remote-hms.c
+++ b/gdb/remote-hms.c
@@ -34,16 +34,16 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "gdbcore.h"
 
 /* External data declarations */
-extern int stop_soon_quietly;           /* for wait_for_inferior */
+extern int stop_soon_quietly;	/* for wait_for_inferior */
 
 /* Forward data declarations */
-extern struct target_ops hms_ops;		/* Forward declaration */
+extern struct target_ops hms_ops;	/* Forward declaration */
 
 /* Forward function declarations */
 static void hms_fetch_registers ();
-static int  hms_store_registers ();
+static int hms_store_registers ();
 static void hms_close ();
-static int  hms_clear_breakpoints();
+static int hms_clear_breakpoints ();
 
 extern struct target_ops hms_ops;
 
@@ -58,21 +58,21 @@ static int quiet = 1;
    Each cache block holds LINE_SIZE bytes of data
    starting at a multiple-of-LINE_SIZE address.  */
 
-
 #define LINE_SIZE_POWER 4
-#define LINE_SIZE (1<<LINE_SIZE_POWER)     /* eg 1<<3 == 8 */
-#define LINE_SIZE_MASK ((LINE_SIZE-1))      /* eg 7*2+1= 111*/
+#define LINE_SIZE (1<<LINE_SIZE_POWER)	/* eg 1<<3 == 8 */
+#define LINE_SIZE_MASK ((LINE_SIZE-1))	/* eg 7*2+1= 111*/
 #define DCACHE_SIZE 64		/* Number of cache blocks */
 #define XFORM(x)  ((x&LINE_SIZE_MASK)>>2)
-struct dcache_block {
-	struct dcache_block *next, *last;
-	unsigned int addr;	/* Address for which data is recorded.  */
-	int data[LINE_SIZE/sizeof(int)];
-};
+struct dcache_block
+  {
+    struct dcache_block *next, *last;
+    unsigned int addr;		/* Address for which data is recorded.  */
+    int data[LINE_SIZE / sizeof (int)];
+  };
 
 struct dcache_block dcache_free, dcache_valid;
 
-/* Free all the data cache blocks, thus discarding all cached data.  */ 
+/* Free all the data cache blocks, thus discarding all cached data.  */
 static
 void
 dcache_flush ()
@@ -104,7 +104,7 @@ dcache_hit (addr)
   db = dcache_valid.next;
   while (db != &dcache_valid)
     {
-      if ((addr & ~LINE_SIZE_MASK)== db->addr)
+      if ((addr & ~LINE_SIZE_MASK) == db->addr)
 	return db;
       db = db->next;
     }
@@ -120,7 +120,7 @@ dcache_value (db, addr)
 {
   if (addr & 3)
     abort ();
-  return (db->data[XFORM(addr)]);
+  return (db->data[XFORM (addr)]);
 }
 
 /* Get a free cache block, put or keep it on the valid list,
@@ -163,10 +163,10 @@ dcache_fetch (addr)
     {
       db = dcache_alloc ();
       immediate_quit++;
-      hms_read_inferior_memory(addr & ~LINE_SIZE_MASK, (unsigned char *)db->data, LINE_SIZE);
+      hms_read_inferior_memory (addr & ~LINE_SIZE_MASK, (unsigned char *) db->data, LINE_SIZE);
       immediate_quit--;
       db->addr = addr & ~LINE_SIZE_MASK;
-      remque (db);			/* Off the free list */
+      remque (db);		/* Off the free list */
       insque (db, &dcache_valid);	/* On the valid list */
     }
   return (dcache_value (db, addr));
@@ -183,22 +183,22 @@ dcache_poke (addr, data)
   /* First make sure the word is IN the cache.  DB is its cache block.  */
   db = dcache_hit (addr);
   if (db == 0)
-  {
-    db = dcache_alloc ();
-    immediate_quit++;
-    hms_write_inferior_memory(addr & ~LINE_SIZE_MASK, (unsigned char *)db->data, LINE_SIZE);
-    immediate_quit--;
-    db->addr = addr & ~LINE_SIZE_MASK;
-    remque (db);		/* Off the free list */
-    insque (db, &dcache_valid);	/* On the valid list */
-  }
+    {
+      db = dcache_alloc ();
+      immediate_quit++;
+      hms_write_inferior_memory (addr & ~LINE_SIZE_MASK, (unsigned char *) db->data, LINE_SIZE);
+      immediate_quit--;
+      db->addr = addr & ~LINE_SIZE_MASK;
+      remque (db);		/* Off the free list */
+      insque (db, &dcache_valid);	/* On the valid list */
+    }
 
   /* Modify the word in the cache.  */
-  db->data[XFORM(addr)] = data;
+  db->data[XFORM (addr)] = data;
 
   /* Send the changed word.  */
   immediate_quit++;
-  hms_write_inferior_memory(addr, (unsigned char *)&data, 4);
+  hms_write_inferior_memory (addr, (unsigned char *) &data, 4);
   immediate_quit--;
 }
 
@@ -215,11 +215,10 @@ dcache_init ()
   db = the_cache;
   dcache_free.next = dcache_free.last = &dcache_free;
   dcache_valid.next = dcache_valid.last = &dcache_valid;
-  for (i=0;i<DCACHE_SIZE;i++,db++)
+  for (i = 0; i < DCACHE_SIZE; i++, db++)
     insque (db, &dcache_free);
 }
 
-
 /***********************************************************************
  * I/O stuff stolen from remote-eb.c
  ***********************************************************************/
@@ -228,19 +227,18 @@ static int timeout = 2;
 
 static const char *dev_name;
 
-
 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
    hms_open knows that we don't have a file open when the program
    starts.  */
 
-
 int is_open = 0;
-int check_open()
+int 
+check_open ()
 {
   if (!is_open)
-  {
-    error("remote device not open");
-  }
+    {
+      error ("remote device not open");
+    }
 }
 
 #define ON	1
@@ -252,14 +250,15 @@ static int
 readchar ()
 {
   int buf;
-  buf = serial_readchar(timeout);
+
+  buf = serial_readchar (timeout);
 
   if (buf < 0)
-   error ("Timeout reading from remote system.");
+    error ("Timeout reading from remote system.");
 
   if (!quiet)
-   printf("%c",buf);
-  
+    printf ("%c", buf);
+
   return buf & 0x7f;
 }
 
@@ -267,16 +266,18 @@ static int
 readchar_nofail ()
 {
   int buf;
-  buf = serial_readchar(timeout);
-  if (buf < 0) buf = 0;
+
+  buf = serial_readchar (timeout);
+  if (buf < 0)
+    buf = 0;
   if (!quiet)
-   printf("%c",buf);
-  
+    printf ("%c", buf);
+
   return buf & 0x7f;
 
 }
 
-/* Keep discarding input from the remote system, until STRING is found. 
+/* Keep discarding input from the remote system, until STRING is found.
    Let the user break out immediately.  */
 static void
 expect (string)
@@ -284,11 +285,10 @@ expect (string)
 {
   char *p = string;
 
-
   immediate_quit = 1;
   while (1)
     {
-      if (readchar() == *p)
+      if (readchar () == *p)
 	{
 	  p++;
 	  if (*p == '\0')
@@ -329,6 +329,7 @@ get_hex_digit (ignore_space)
      int ignore_space;
 {
   int ch;
+
   while (1)
     {
       ch = readchar ();
@@ -362,20 +363,19 @@ get_hex_byte (byt)
 }
 
 /* Read a 32-bit hex word from the hms, preceded by a space  */
-static long 
-get_hex_word()
+static long
+get_hex_word ()
 {
   long val;
   int j;
-      
+
   val = 0;
   for (j = 0; j < 8; j++)
-	val = (val << 4) + get_hex_digit (j == 0);
+    val = (val << 4) + get_hex_digit (j == 0);
   return val;
 }
-/* Called when SIGALRM signal sent due to alarm() timeout.  */
-
 
+/* Called when SIGALRM signal sent due to alarm() timeout.  */
 
 /* Number of SIGTRAPs we need to simulate.  That is, the next
    NEED_ARTIFICIAL_TRAP calls to hms_wait should just return
@@ -384,75 +384,74 @@ get_hex_word()
 static int need_artificial_trap = 0;
 
 void
-hms_kill(arg,from_tty)
-char	*arg;
-int	from_tty;
+hms_kill (arg, from_tty)
+     char *arg;
+     int from_tty;
 {
 
 }
 
-
-
 /*
- * Download a file specified in 'args', to the hms. 
+ * Download a file specified in 'args', to the hms.
  */
 static void
-hms_load(args,fromtty)
-char	*args;
-int	fromtty;
+hms_load (args, fromtty)
+     char *args;
+     int fromtty;
 {
-  bfd	*abfd;
+  bfd *abfd;
   asection *s;
-  int	n;
-  char	buffer[1024];
+  int n;
+  char buffer[1024];
 
-  check_open();
+  check_open ();
 
-  dcache_flush();
-  inferior_pid = 0;  
-  abfd = bfd_openr(args,"coff-h8300");
-  if (!abfd) 
-  {
-    printf_filtered("Unable to open file %s\n", args);
-    return;
-  }
+  dcache_flush ();
+  inferior_pid = 0;
+  abfd = bfd_openr (args, 0);
+  if (!abfd)
+    {
+      printf_filtered ("Unable to open file %s\n", args);
+      return;
+    }
 
-  if (bfd_check_format(abfd, bfd_object) ==0) 
-  {
-    printf_filtered("File is not an object file\n");
-    return ;
-  }
+  if (bfd_check_format (abfd, bfd_object) == 0)
+    {
+      printf_filtered ("File is not an object file\n");
+      return;
+    }
 
   s = abfd->sections;
-  while (s != (asection *)NULL) 
-  {
-    if (s->flags & SEC_LOAD) 
+  while (s != (asection *) NULL)
     {
-      int i;
+      if (s->flags & SEC_LOAD)
+	{
+	  int i;
 
-      
 #define DELTA 1024
-      char *buffer = xmalloc(DELTA);
-      printf_filtered("%s\t: 0x%4x .. 0x%4x  ",s->name, s->vma, s->vma + s->_raw_size);
-      for (i = 0; i < s->_raw_size; i+= DELTA) 
-      {
-	int delta = DELTA;
-	if (delta > s->_raw_size - i)
-	 delta = s->_raw_size - i ;
-
-	bfd_get_section_contents(abfd, s, buffer, i, delta);
-	hms_write_inferior_memory(s->vma + i, buffer, delta);
-	printf_filtered("*");
-	fflush(stdout);
-      }
-      printf_filtered(  "\n");      
-      free(buffer);
+	  char *buffer = xmalloc (DELTA);
+
+	  printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, s->vma, s->vma + s->_raw_size);
+	  for (i = 0; i < s->_raw_size; i += DELTA)
+	    {
+	      int delta = DELTA;
+
+	      if (delta > s->_raw_size - i)
+		delta = s->_raw_size - i;
+
+	      bfd_get_section_contents (abfd, s, buffer, i, delta);
+	      hms_write_inferior_memory (s->vma + i, buffer, delta);
+	      printf_filtered ("*");
+	      fflush (stdout);
+	    }
+	  printf_filtered ("\n");
+	  free (buffer);
+	}
+      s = s->next;
     }
-    s = s->next;
-  }
-  sprintf(buffer, "r PC=%x", abfd->start_address);
-  hms_write_cr(buffer);
-  expect_prompt();
+  sprintf (buffer, "r PC=%x", abfd->start_address);
+  hms_write_cr (buffer);
+  expect_prompt ();
 }
 
 /* This is called not only when we first attach, but also when the
@@ -464,66 +463,65 @@ hms_create_inferior (execfile, args, env)
      char **env;
 {
   int entry_pt;
-  char buffer[100];    
+  char buffer[100];
 
   if (args && *args)
-   error ("Can't pass arguments to remote hms process.");
+    error ("Can't pass arguments to remote hms process.");
 
   if (execfile == 0 || exec_bfd == 0)
-   error ("No exec file specified");
+    error ("No exec file specified");
 
   entry_pt = (int) bfd_get_start_address (exec_bfd);
-  check_open();
+  check_open ();
 
-
-  hms_kill(NULL,NULL);	 
-  hms_clear_breakpoints();
+  hms_kill (NULL, NULL);
+  hms_clear_breakpoints ();
   init_wait_for_inferior ();
-  hms_write_cr("");
-  expect_prompt();
+  hms_write_cr ("");
+  expect_prompt ();
 
   insert_breakpoints ();	/* Needed to get correct instruction in cache */
-  proceed(entry_pt, -1, 0);
+  proceed (entry_pt, -1, 0);
 }
 
-
 /* Open a connection to a remote debugger.
    NAME is the filename used for communication, then a space,
    then the baud rate.
  */
 
 static char *
-find_end_of_word(s)
-char *s;
+find_end_of_word (s)
+     char *s;
 {
-  while (*s && !isspace(*s))
-   s++;
+  while (*s && !isspace (*s))
+    s++;
   return s;
 }
 
-static char *get_word(p)
-char **p;
+static char *
+get_word (p)
+     char **p;
 {
   char *s = *p;
-  char *word ;
+  char *word;
   char *copy;
   size_t len;
 
-  while (isspace(*s))
-   s++;
+  while (isspace (*s))
+    s++;
 
   word = s;
 
   len = 0;
 
-  while (*s && !isspace(*s)) 
-  {
-    s++;
-    len++;
-  
-  }
-  copy = xmalloc(len+1);
-  memcpy(copy, word, len);
+  while (*s && !isspace (*s))
+    {
+      s++;
+      len++;
+
+    }
+  copy = xmalloc (len + 1);
+  memcpy (copy, word, len);
   copy[len] = 0;
   *p = s;
   return copy;
@@ -532,50 +530,53 @@ char **p;
 static int baudrate = 9600;
 
 static int
-is_baudrate_right()
+is_baudrate_right ()
 {
   int ok;
+
   /* Put this port into NORMAL mode, send the 'normal' character */
 
-  hms_write("\001", 1);		/* Control A */
-  hms_write("\r", 1);		/* Cr */
-  
-  while (1) 
-  {
-    ok = serial_readchar(timeout);
-    if (ok < 0) break;
-  }
+  hms_write ("\001", 1);	/* Control A */
+  hms_write ("\r", 1);		/* Cr */
 
-  hms_write("r",1);
+  while (1)
+    {
+      ok = serial_readchar (timeout);
+      if (ok < 0)
+	break;
+    }
 
-  if (readchar_nofail() == 'r')  
-   return 1;
+  hms_write ("r", 1);
+
+  if (readchar_nofail () == 'r')
+    return 1;
 
   /* Not the right baudrate, or the board's not on */
   return 0;
 }
 static void
-set_rate()
+set_rate ()
 {
-  if (!serial_setbaudrate(baudrate))
-   error("Can't set baudrate");
+  if (!serial_setbaudrate (baudrate))
+    error ("Can't set baudrate");
 }
 
 static void
-get_baudrate_right()
+get_baudrate_right ()
 {
 #if 0
-  while (!is_baudrate_right()) 
-  {
-    baudrate = serial_nextbaudrate(baudrate);
-    if (baudrate == 0) {
-      printf_filtered("Board not yet in sync\n");
-      break;
+  while (!is_baudrate_right ())
+    {
+      baudrate = serial_nextbaudrate (baudrate);
+      if (baudrate == 0)
+	{
+	  printf_filtered ("Board not yet in sync\n");
+	  break;
+	}
+      printf_filtered ("Board not responding, trying %d baud\n", baudrate);
+      QUIT;
+      serial_setbaudrate (baudrate);
     }
-    printf_filtered("Board not responding, trying %d baud\n",baudrate);
-    QUIT;
-    serial_setbaudrate(baudrate);
-  }
 #endif
 }
 
@@ -587,32 +588,32 @@ hms_open (name, from_tty)
 
   unsigned int prl;
   char *p;
-  
-  if(name == 0) 
-  {
-    name = "";
-  }
-  if (is_open)  
+
+  if (name == 0)
+    {
+      name = "";
+    }
+  if (is_open)
     hms_close (0);
-  if (name && strlen(name))
-    dev_name = strdup(name);
-  if (!serial_open(dev_name))
-    perror_with_name ((char *)dev_name);
-  serial_raw();
+  if (name && strlen (name))
+    dev_name = strdup (name);
+  if (!serial_open (dev_name))
+    perror_with_name ((char *) dev_name);
+  serial_raw ();
   is_open = 1;
 
-  dcache_init();
+  dcache_init ();
+
+  get_baudrate_right ();
 
-  get_baudrate_right();
-  
   /* Hello?  Are you there?  */
-  serial_write("\r",1);
+  serial_write ("\r", 1);
   expect_prompt ();
 
   /* Clear any break points */
-  hms_clear_breakpoints();
+  hms_clear_breakpoints ();
 
-  printf_filtered("Connected to remote H8/300 HMS system.\n");
+  printf_filtered ("Connected to remote H8/300 HMS system.\n");
 }
 
 /* Close out all files and local state before this target loses control. */
@@ -622,14 +623,13 @@ hms_close (quitting)
      int quitting;
 {
 
-
   /* Clear any break points */
-  hms_clear_breakpoints();
+  hms_clear_breakpoints ();
 
-  /* Put this port back into REMOTE mode */ 
-  sleep(1);			/* Let any output make it all the way back */
-  serial_write("R\r", 2);
-  serial_close();
+  /* Put this port back into REMOTE mode */
+  sleep (1);			/* Let any output make it all the way back */
+  serial_write ("R\r", 2);
+  serial_close ();
   is_open = 0;
 }
 
@@ -637,43 +637,43 @@ hms_close (quitting)
    Use this when you want to detach and do something else
    with your gdb.  */
 void
-hms_detach (args,from_tty)
+hms_detach (args, from_tty)
      char *args;
      int from_tty;
 {
   if (is_open)
-  { 
-	hms_clear_breakpoints();
-  }
- 
-  pop_target();		/* calls hms_close to do the real work */
+    {
+      hms_clear_breakpoints ();
+    }
+
+  pop_target ();		/* calls hms_close to do the real work */
   if (from_tty)
     printf_filtered ("Ending remote %s debugging\n", target_shortname);
 }
- 
+
 /* Tell the remote machine to resume.  */
 
 void
 hms_resume (step, sig)
      int step, sig;
 {
-  dcache_flush();
-  
-  if (step)	
-  {
-    hms_write_cr("s");
-    expect("Step>");
-    
-    /* Force the next hms_wait to return a trap.  Not doing anything
+  dcache_flush ();
+
+  if (step)
+    {
+      hms_write_cr ("s");
+      expect ("Step>");
+
+      /* Force the next hms_wait to return a trap.  Not doing anything
        about I/O from the target means that the user has to type
        "continue" to see any.  FIXME, this should be fixed.  */
-    need_artificial_trap = 1;
-  }
+      need_artificial_trap = 1;
+    }
   else
-  {
-    hms_write_cr("g");
-    expect("g");
-  }
+    {
+      hms_write_cr ("g");
+      expect ("g");
+    }
 }
 
 /* Wait until the remote machine stops, then return,
@@ -683,12 +683,13 @@ int
 hms_wait (status)
      WAITTYPE *status;
 {
-  /* Strings to look for.  '?' means match any single character.  
+  /* Strings to look for.  '?' means match any single character.
      Note that with the algorithm we use, the initial character
      of the string cannot recur in the string, or we will not
      find some cases of the string in the input.  */
-  
+
   static char bpt[] = "At breakpoint:";
+
   /* It would be tempting to look for "\n[__exit + 0x8]\n"
      but that requires loading symbols with "yc i" and even if
      we did do that we don't know that the file has symbols.  */
@@ -698,6 +699,7 @@ hms_wait (status)
 
   /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars.  */
   char swallowed[50];
+
   /* Current position in swallowed.  */
   char *swallowed_p = swallowed;
 
@@ -706,78 +708,79 @@ hms_wait (status)
   int old_timeout = timeout;
   int old_immediate_quit = immediate_quit;
   int swallowed_cr = 0;
-  
+
   WSETEXIT ((*status), 0);
 
   if (need_artificial_trap != 0)
-  {
-    WSETSTOP ((*status), SIGTRAP);
-    need_artificial_trap--;
-    return 0;
-  }
+    {
+      WSETSTOP ((*status), SIGTRAP);
+      need_artificial_trap--;
+      return 0;
+    }
 
-  timeout = 99999; 	/* Don't time out -- user program is running. */
+  timeout = 99999;		/* Don't time out -- user program is running. */
   immediate_quit = 1;		/* Helps ability to QUIT */
-  while (1) 
-  {
-    QUIT;			/* Let user quit and leave process running */
-    ch_handled = 0;
-    ch = readchar ();
-    if (ch == *bp) 
-    {
-	bp++;
-	if (*bp == '\0')
-	 break;
-	ch_handled = 1;
-
-	*swallowed_p++ = ch;
-      } 
-    else 
+  while (1)
     {
-      bp = bpt;
+      QUIT;			/* Let user quit and leave process running */
+      ch_handled = 0;
+      ch = readchar ();
+      if (ch == *bp)
+	{
+	  bp++;
+	  if (*bp == '\0')
+	    break;
+	  ch_handled = 1;
+
+	  *swallowed_p++ = ch;
+	}
+      else
+	{
+	  bp = bpt;
+	}
+      if (ch == *ep || *ep == '?')
+	{
+	  ep++;
+	  if (*ep == '\0')
+	    break;
+
+	  if (!ch_handled)
+	    *swallowed_p++ = ch;
+	  ch_handled = 1;
+	}
+      else
+	{
+	  ep = exitmsg;
+	}
+
+      if (!ch_handled)
+	{
+	  char *p;
+
+	  /* Print out any characters which have been swallowed.  */
+	  for (p = swallowed; p < swallowed_p; ++p)
+	    putc (*p, stdout);
+	  swallowed_p = swallowed;
+
+	  if ((ch != '\r' && ch != '\n') || swallowed_cr > 10)
+	    {
+	      putc (ch, stdout);
+	      swallowed_cr = 10;
+	    }
+	  swallowed_cr++;
+
+	}
     }
-    if (ch == *ep || *ep == '?') 
+  if (*bp == '\0')
     {
-	ep++;
-	if (*ep == '\0')
-	 break;
-
-	if (!ch_handled)
-	 *swallowed_p++ = ch;
-	ch_handled = 1;
-      } 
-    else 
+      WSETSTOP ((*status), SIGTRAP);
+      expect_prompt ();
+    }
+  else
     {
-      ep = exitmsg;
+      WSETEXIT ((*status), 0);
     }
-      
-    if (!ch_handled) {
-	char *p;
-	/* Print out any characters which have been swallowed.  */
-	for (p = swallowed; p < swallowed_p; ++p)
-	 putc (*p, stdout);
-	swallowed_p = swallowed;
-
-	  
-	if ((ch != '\r' && ch != '\n') || swallowed_cr>10) 
-	{
-	  putc (ch, stdout);
-	  swallowed_cr = 10;
-	}
-	swallowed_cr ++;
-	  
-      }
-  }
-  if (*bp== '\0') 
-  {
-    WSETSTOP ((*status), SIGTRAP);
-    expect_prompt();
-  }
-  else 
-  {
-    WSETEXIT ((*status), 0);
-  }
-  
+
   timeout = old_timeout;
   immediate_quit = old_immediate_quit;
   return 0;
@@ -791,135 +794,143 @@ static char *
 get_reg_name (regno)
      int regno;
 {
-  static  char *rn[NUM_REGS]= REGISTER_NAMES;
+  static char *rn[NUM_REGS] = REGISTER_NAMES;
+
   return rn[regno];
 }
 
 /* Read the remote registers.  */
-static int gethex(length, start, ok)
-unsigned int length;
-char *start;
-int *ok;
+static int 
+gethex (length, start, ok)
+     unsigned int length;
+     char *start;
+     int *ok;
 {
   int result = 0;
-  while (length--)   
-  {
-    result <<= 4 ;
-    if (*start >='a' && *start <= 'f') 
-    {
-      result += *start - 'a' + 10;
-    }
-    else if (*start >='A' && *start <= 'F') 
-    {
-      result += *start - 'A' + 10;
-    }
-    else  if (*start >='0' && *start <= '9') 
+
+  while (length--)
     {
-      result += *start - '0' ;
+      result <<= 4;
+      if (*start >= 'a' && *start <= 'f')
+	{
+	  result += *start - 'a' + 10;
+	}
+      else if (*start >= 'A' && *start <= 'F')
+	{
+	  result += *start - 'A' + 10;
+	}
+      else if (*start >= '0' && *start <= '9')
+	{
+	  result += *start - '0';
+	}
+      else
+	*ok = 0;
+      start++;
+
     }
-    else *ok = 0;
-    start++;
-    
-  }
   return result;
 }
-static int 
-timed_read(buf, n, timeout)
-char *buf;
+static int
+timed_read (buf, n, timeout)
+     char *buf;
 
 {
   int i;
   char c;
+
   i = 0;
-  while (i < n) 
-  {
-    c = readchar();
-    
-    if (c == 0) return i;
-    buf[i] = c;
-    i++;
-    
-  }
-  return i;  
+  while (i < n)
+    {
+      c = readchar ();
+
+      if (c == 0)
+	return i;
+      buf[i] = c;
+      i++;
+
+    }
+  return i;
 
 }
-hms_write(a,l)
-char *a;
+
+hms_write (a, l)
+     char *a;
 {
   int i;
-  serial_write(a, l);
+
+  serial_write (a, l);
 
   if (!quiet)
-   for (i = 0; i < l ; i++)
-   {
-     printf("%c", a[i]);
-   }
+    for (i = 0; i < l; i++)
+      {
+	printf ("%c", a[i]);
+      }
 }
 
-hms_write_cr(s)
-char *s;
+hms_write_cr (s)
+     char *s;
 {
-  hms_write( s, strlen(s));
-  hms_write("\r",1);  
+  hms_write (s, strlen (s));
+  hms_write ("\r", 1);
 }
 
 static void
 hms_fetch_register (dummy)
-int dummy;
+     int dummy;
 {
 #define REGREPLY_SIZE 79
-  char linebuf[REGREPLY_SIZE+1];
+  char linebuf[REGREPLY_SIZE + 1];
   int i;
-  int s ;
+  int s;
   int gottok;
-  
+
   REGISTER_TYPE reg[NUM_REGS];
   int foo[8];
-  check_open();
-  
-  do 
-  {
-    
-    hms_write_cr("r");
-    s = timed_read(linebuf, REGREPLY_SIZE, 1);
-
-  
-    linebuf[REGREPLY_SIZE] = 0;
-    gottok = 0;    
-    if (linebuf[0] == 'r' &&
-	linebuf[3] == 'P' &&
-	linebuf[4] == 'C' &&
-	linebuf[5] == '=' && 
-	linebuf[75] == 'H' &&
-	linebuf[76] == 'M' &&
-	linebuf[77] == 'S') 
+
+  check_open ();
+
+  do
     {
-      /*
+
+      hms_write_cr ("r");
+      s = timed_read (linebuf, REGREPLY_SIZE, 1);
+
+      linebuf[REGREPLY_SIZE] = 0;
+      gottok = 0;
+      if (linebuf[0] == 'r' &&
+	  linebuf[3] == 'P' &&
+	  linebuf[4] == 'C' &&
+	  linebuf[5] == '=' &&
+	  linebuf[75] == 'H' &&
+	  linebuf[76] == 'M' &&
+	  linebuf[77] == 'S')
+	{
+	  /*
 	PC=XXXX CCR=XX:XXXXXXXX R0-R7= XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX
 	5436789012345678901234567890123456789012345678901234567890123456789012
-	0      1         2         3         4         5         6         
+	0      1         2         3         4         5         6
 	*/
-      gottok = 1;
-      
-      reg[PC_REGNUM] =  gethex(4,linebuf+6, &gottok);
-      reg[CCR_REGNUM] = gethex(2,linebuf+15, &gottok);
-      for (i = 0; i < 8; i++) 
-      {
-	reg[i] = gethex(4, linebuf+34+5*i, &gottok);
-      }
+	  gottok = 1;
+
+	  reg[PC_REGNUM] = gethex (4, linebuf + 6, &gottok);
+	  reg[CCR_REGNUM] = gethex (2, linebuf + 15, &gottok);
+	  for (i = 0; i < 8; i++)
+	    {
+	      reg[i] = gethex (4, linebuf + 34 + 5 * i, &gottok);
+	    }
+	}
     }
-  }
   while (!gottok);
-  for (i = 0; i < NUM_REGS; i++) 
-  {
-    char swapped[2];
-    swapped[1] = reg[i];
-    swapped[0] = (reg[i])>> 8;
+  for (i = 0; i < NUM_REGS; i++)
+    {
+      char swapped[2];
 
-    supply_register (i, swapped);
-  }  
-}
+      swapped[1] = reg[i];
+      swapped[0] = (reg[i]) >> 8;
 
+      supply_register (i, swapped);
+    }
+}
 
 /* Store register REGNO, or all if REGNO == -1.
    Return errno value.  */
@@ -929,24 +940,23 @@ hms_store_register (regno)
 {
 
   /* printf("hms_store_register() called.\n"); fflush(stdout); /* */
-  if (regno == -1) 
-  {
-    for (regno = 0; regno < NUM_REGS; regno ++) 
+  if (regno == -1)
     {
-      hms_store_register(regno);
+      for (regno = 0; regno < NUM_REGS; regno++)
+	{
+	  hms_store_register (regno);
+	}
     }
-  }
   else
-  {
-    char *name = get_reg_name (regno);
-    char buffer[100];
-    sprintf(buffer,"r %s=%x", name, read_register(regno));
-    hms_write_cr(buffer);
-    expect_prompt();
-  }
-}
-
+    {
+      char *name = get_reg_name (regno);
+      char buffer[100];
 
+      sprintf (buffer, "r %s=%x", name, read_register (regno));
+      hms_write_cr (buffer);
+      expect_prompt ();
+    }
+}
 
 /* Get ready to modify the registers array.  On machines which store
    individual registers, this doesn't need to do anything.  On machines
@@ -960,12 +970,12 @@ hms_prepare_to_store ()
   /* Do nothing, since we can store individual regs */
 }
 
-static CORE_ADDR 
-translate_addr(addr)
-CORE_ADDR addr;
+static CORE_ADDR
+translate_addr (addr)
+     CORE_ADDR addr;
 {
 
-	return(addr);
+  return (addr);
 
 }
 
@@ -976,7 +986,7 @@ int
 hms_fetch_word (addr)
      CORE_ADDR addr;
 {
-	return dcache_fetch (addr);
+  return dcache_fetch (addr);
 }
 
 /* Write a word WORD into remote address ADDR.
@@ -987,83 +997,86 @@ hms_store_word (addr, word)
      CORE_ADDR addr;
      int word;
 {
-	dcache_poke (addr, word);
+  dcache_poke (addr, word);
 }
 
 int
-hms_xfer_inferior_memory(memaddr, myaddr, len, write, target)
+hms_xfer_inferior_memory (memaddr, myaddr, len, write, target)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
      int write;
-     struct target_ops *target;			/* ignored */
+     struct target_ops *target;	/* ignored */
 {
   register int i;
+
   /* Round starting address down to longword boundary.  */
-  register CORE_ADDR addr; 
+  register CORE_ADDR addr;
+
   /* Round ending address up; get number of longwords that makes.  */
   register int count;
+
   /* Allocate buffer of that many longwords.  */
-  register int *buffer ;
+  register int *buffer;
 
   memaddr &= 0xffff;
-  addr = memaddr & - sizeof (int);
-  count   = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+  addr = memaddr & -sizeof (int);
+  count = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 
+  buffer = (int *) alloca (count * sizeof (int));
 
-  buffer = (int *)alloca (count * sizeof (int));
   if (write)
-  {
-    /* Fill start and end extra bytes of buffer with existing memory data.  */
+    {
+      /* Fill start and end extra bytes of buffer with existing memory data.  */
 
-    if (addr != memaddr || len < (int)sizeof (int)) {
-	/* Need part of initial word -- fetch it.  */
-        buffer[0] = hms_fetch_word (addr);
-      }
+      if (addr != memaddr || len < (int) sizeof (int))
+	{
+	  /* Need part of initial word -- fetch it.  */
+	  buffer[0] = hms_fetch_word (addr);
+	}
 
-    if (count > 1)		/* FIXME, avoid if even boundary */
-    {
-      buffer[count - 1]
-       = hms_fetch_word (addr + (count - 1) * sizeof (int));
-    }
+      if (count > 1)		/* FIXME, avoid if even boundary */
+	{
+	  buffer[count - 1]
+	    = hms_fetch_word (addr + (count - 1) * sizeof (int));
+	}
 
-    /* Copy data to be written over corresponding part of buffer */
+      /* Copy data to be written over corresponding part of buffer */
 
-    bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+      bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 
-    /* Write the entire buffer.  */
+      /* Write the entire buffer.  */
 
-    for (i = 0; i < count; i++, addr += sizeof (int))
-    {
-      errno = 0;
-      hms_store_word (addr, buffer[i]);
-      if (errno) 
-      {
-	
-	return 0;
-      }
-      
+      for (i = 0; i < count; i++, addr += sizeof (int))
+	{
+	  errno = 0;
+	  hms_store_word (addr, buffer[i]);
+	  if (errno)
+	    {
+
+	      return 0;
+	    }
+
+	}
     }
-  }
   else
-  {
-    /* Read all the longwords */
-    for (i = 0; i < count; i++, addr += sizeof (int))
     {
-      errno = 0;
-      buffer[i] = hms_fetch_word (addr);
-      if (errno) 
-      {
-	return 0;
-      }
-      QUIT;
-    }
+      /* Read all the longwords */
+      for (i = 0; i < count; i++, addr += sizeof (int))
+	{
+	  errno = 0;
+	  buffer[i] = hms_fetch_word (addr);
+	  if (errno)
+	    {
+	      return 0;
+	    }
+	  QUIT;
+	}
 
-    /* Copy appropriate bytes out of the buffer.  */
-    bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
-  }
+      /* Copy appropriate bytes out of the buffer.  */
+      bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+    }
 
-  
   return len;
 }
 
@@ -1075,133 +1088,138 @@ hms_write_inferior_memory (memaddr, myaddr, len)
 {
   bfd_vma addr;
   int done;
-  int todo ;
+  int todo;
+
   done = 0;
-  while(done < len) 
-  {
-    char buffer[20];
-    int thisgo;
-    int idx;
-    thisgo = len - done;
-    if (thisgo > 20) thisgo = 20;
-
-    sprintf(buffer,"M.B %4x =", memaddr+done);
-    hms_write(buffer,10);
-    for (idx = 0; idx < thisgo; idx++) 
+  while (done < len)
     {
-      char buf[20];
-      sprintf(buf, "%2x ", myaddr[idx+done]); 
-      hms_write(buf, 3);
-    }
-    hms_write_cr("");
-    expect_prompt();
-    done += thisgo;
-  }
+      char buffer[20];
+      int thisgo;
+      int idx;
+
+      thisgo = len - done;
+      if (thisgo > 20)
+	thisgo = 20;
 
+      sprintf (buffer, "M.B %4x =", memaddr + done);
+      hms_write (buffer, 10);
+      for (idx = 0; idx < thisgo; idx++)
+	{
+	  char buf[20];
+
+	  sprintf (buf, "%2x ", myaddr[idx + done]);
+	  hms_write (buf, 3);
+	}
+      hms_write_cr ("");
+      expect_prompt ();
+      done += thisgo;
+    }
 
 }
 
 void
 hms_files_info ()
 {
-char *file = "nothing";
-if (exec_bfd)
- file = bfd_get_filename(exec_bfd);
+  char *file = "nothing";
+
+  if (exec_bfd)
+    file = bfd_get_filename (exec_bfd);
 
-if (exec_bfd)
+  if (exec_bfd)
 #ifdef __GO32__
-   printf_filtered("\tAttached to DOS asynctsr and running program %s\n",file);
+    printf_filtered ("\tAttached to DOS asynctsr and running program %s\n", file);
 #else
-  printf_filtered("\tAttached to %s at %d baud and running program %s\n",file);
+    printf_filtered ("\tAttached to %s at %d baud and running program %s\n", file);
 #endif
-  printf_filtered("\ton an H8/300 processor.\n");
+  printf_filtered ("\ton an H8/300 processor.\n");
 }
 
 /* Copy LEN bytes of data from debugger memory at MYADDR
-   to inferior's memory at MEMADDR.  Returns errno value.  
- * sb/sh instructions don't work on unaligned addresses, when TU=1. 
+   to inferior's memory at MEMADDR.  Returns errno value.
+ * sb/sh instructions don't work on unaligned addresses, when TU=1.
  */
 
-
 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
    at debugger address MYADDR.  Returns errno value.  */
 int
-hms_read_inferior_memory(memaddr, myaddr, len)
+hms_read_inferior_memory (memaddr, myaddr, len)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
 {
   /* Align to nearest low 16 bits */
   int i;
-				    
+
 #if 0
   CORE_ADDR start = memaddr & ~0xf;
-  CORE_ADDR end = ((memaddr + len +16) & ~0xf) -1;
+  CORE_ADDR end = ((memaddr + len + 16) & ~0xf) - 1;
+
 #endif
   CORE_ADDR start = memaddr;
-  CORE_ADDR end = memaddr + len -1;
-  
-  int ok =1;
-  
+  CORE_ADDR end = memaddr + len - 1;
+
+  int ok = 1;
+
   /*
     AAAA: XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX '................'
     012345678901234567890123456789012345678901234567890123456789012345
     0         1         2         3         4         5         6
     */
   char buffer[66];
-  if (memaddr & 0xf) abort();
-  if (len != 16) abort();
-  
-  sprintf(buffer, "m %4x %4x", start & 0xffff, end & 0xffff);
-  hms_write_cr(buffer);
+
+  if (memaddr & 0xf)
+    abort ();
+  if (len != 16)
+    abort ();
+
+  sprintf (buffer, "m %4x %4x", start & 0xffff, end & 0xffff);
+  hms_write_cr (buffer);
   /* drop the echo and newline*/
   for (i = 0; i < 13; i++)
-   readchar();
-  
+    readchar ();
 
-  
   /* Grab the lines as they come out and fill the area */
   /* Skip over cr */
-  while(1)
-  {
-    int p;
-    int i;
-    int addr;
-    size_t idx;
-    
-    char byte[16];    
-    buffer[0] = readchar();
-    if (buffer[0] == 'M') 
-     break;
-    for (i = 1; i < 66; i++)
-     buffer[i] = readchar();
-    
-    /* Now parse the line */
-
-    addr = gethex(4, buffer, &ok);
-    idx = 6;
-    for (p = 0; p < 16; p+=2) 
+  while (1)
     {
-      byte[p] = gethex(2, buffer + idx, &ok);
-      byte[p+1] = gethex(2, buffer+ idx + 2, &ok);
-      idx+=5;
-      
-    }
+      int p;
+      int i;
+      int addr;
+      size_t idx;
 
-    
-    for (p = 0; p<16;p++)
-    {
-      if (addr + p >= memaddr &&
-	  addr + p  < memaddr + len) 
-      {
-	myaddr[ (addr + p)-memaddr] = byte[p];
-	
-      }
-       
+      char byte[16];
+
+      buffer[0] = readchar ();
+      if (buffer[0] == 'M')
+	break;
+      for (i = 1; i < 66; i++)
+	buffer[i] = readchar ();
+
+      /* Now parse the line */
+
+      addr = gethex (4, buffer, &ok);
+      idx = 6;
+      for (p = 0; p < 16; p += 2)
+	{
+	  byte[p] = gethex (2, buffer + idx, &ok);
+	  byte[p + 1] = gethex (2, buffer + idx + 2, &ok);
+	  idx += 5;
+
+	}
+
+      for (p = 0; p < 16; p++)
+	{
+	  if (addr + p >= memaddr &&
+	      addr + p < memaddr + len)
+	    {
+	      myaddr[(addr + p) - memaddr] = byte[p];
+
+	    }
+
+	}
     }
-  } 
-  hms_write_cr(" ");
-  expect_prompt();
+  hms_write_cr (" ");
+  expect_prompt ();
   return len;
 }
 
@@ -1220,72 +1238,70 @@ hms_before_main_loop ()
   push_target (&hms_ops);
 }
 
-
 #define MAX_BREAKS	16
-static int num_brkpts=0;
+static int num_brkpts = 0;
 static int
-hms_insert_breakpoint(addr, save)
-CORE_ADDR	addr;
-char		*save;	/* Throw away, let hms save instructions */
+hms_insert_breakpoint (addr, save)
+     CORE_ADDR addr;
+     char *save;		/* Throw away, let hms save instructions */
 {
-  check_open();
-  
-  if (num_brkpts < MAX_BREAKS) 
-  {
-    char buffer[100];
-    num_brkpts++;
-    sprintf(buffer,"b %x", addr & 0xffff);
-    hms_write_cr(buffer);
-    expect_prompt ();
-    return(0);
-  }
-  else 
-  {
-    fprintf_filtered(stderr,
-		     "Too many break points, break point not installed\n");
-    return(1);
-  }
+  check_open ();
+
+  if (num_brkpts < MAX_BREAKS)
+    {
+      char buffer[100];
 
+      num_brkpts++;
+      sprintf (buffer, "b %x", addr & 0xffff);
+      hms_write_cr (buffer);
+      expect_prompt ();
+      return (0);
+    }
+  else
+    {
+      fprintf_filtered (stderr,
+		      "Too many break points, break point not installed\n");
+      return (1);
+    }
 
 }
 static int
-hms_remove_breakpoint(addr, save)
-CORE_ADDR	addr;
-char		*save;	/* Throw away, let hms save instructions */
+hms_remove_breakpoint (addr, save)
+     CORE_ADDR addr;
+     char *save;		/* Throw away, let hms save instructions */
 {
-  if (num_brkpts > 0) 
-  {
-    char buffer[100];
-      
-    num_brkpts--;
-    sprintf(buffer,"b - %x", addr & 0xffff);
-    hms_write_cr(buffer);
-    expect_prompt();
-      
-  }
-  return(0);
+  if (num_brkpts > 0)
+    {
+      char buffer[100];
+
+      num_brkpts--;
+      sprintf (buffer, "b - %x", addr & 0xffff);
+      hms_write_cr (buffer);
+      expect_prompt ();
+
+    }
+  return (0);
 }
 
 /* Clear the hmss notion of what the break points are */
 static int
-hms_clear_breakpoints() 
-{ 
+hms_clear_breakpoints ()
+{
 
-  if (is_open) {
-    hms_write_cr("b -");
-    expect_prompt ();
-  }
+  if (is_open)
+    {
+      hms_write_cr ("b -");
+      expect_prompt ();
+    }
   num_brkpts = 0;
 }
 static void
-hms_mourn() 
-{ 
-  hms_clear_breakpoints();
+hms_mourn ()
+{
+  hms_clear_breakpoints ();
   generic_mourn_inferior ();
 }
 
-
-
 /* Put a command string, in args, out to the hms.  The hms is assumed to
    be in raw mode, all writing/reading done through desc.
    Ouput from the hms is placed on the users terminal until the
@@ -1294,93 +1310,94 @@ hms_mourn()
 
 void
 hms_com (args, fromtty)
-     char	*args;
-     int	fromtty;
+     char *args;
+     int fromtty;
 {
-  check_open();
-  
-  if (!args) return;
-	
+  check_open ();
+
+  if (!args)
+    return;
+
   /* Clear all input so only command relative output is displayed */
 
-  hms_write_cr(args);
-  hms_write("\030",1);
-  expect_prompt();
+  hms_write_cr (args);
+  hms_write ("\030", 1);
+  expect_prompt ();
 }
 
 /* Define the target subroutine names */
 
-struct target_ops hms_ops = {
-	"hms", "Remote HMS monitor",
-"Use the H8 evaluation board running the HMS monitor connected\n\
+struct target_ops hms_ops =
+{
+  "hms", "Remote HMS monitor",
+  "Use the H8 evaluation board running the HMS monitor connected\n\
 by a serial line.",
 
-	hms_open, hms_close, 
-	0, hms_detach, hms_resume, hms_wait,	/* attach */
-	hms_fetch_register, hms_store_register,
-	hms_prepare_to_store,
-	hms_xfer_inferior_memory, 
-	hms_files_info,
-	hms_insert_breakpoint, hms_remove_breakpoint, /* Breakpoints */
-	0, 0, 0, 0, 0,		/* Terminal handling */
-	hms_kill, 		/* FIXME, kill */
-	hms_load, 
-	0, 			/* lookup_symbol */
-	hms_create_inferior, 	/* create_inferior */ 
-	hms_mourn, 		/* mourn_inferior FIXME */
-  	0,			/* can_run */
-  	0,			/* notice_signals */
-	process_stratum, 0, /* next */
-	1, 1, 1, 1, 1,	/* all mem, mem, stack, regs, exec */
-	0,0,		/* Section pointers */
-	OPS_MAGIC,		/* Always the last thing */
+  hms_open, hms_close,
+  0, hms_detach, hms_resume, hms_wait,	/* attach */
+  hms_fetch_register, hms_store_register,
+  hms_prepare_to_store,
+  hms_xfer_inferior_memory,
+  hms_files_info,
+  hms_insert_breakpoint, hms_remove_breakpoint,	/* Breakpoints */
+  0, 0, 0, 0, 0,		/* Terminal handling */
+  hms_kill,			/* FIXME, kill */
+  hms_load,
+  0,				/* lookup_symbol */
+  hms_create_inferior,		/* create_inferior */
+  hms_mourn,			/* mourn_inferior FIXME */
+  0,				/* can_run */
+  0,				/* notice_signals */
+  process_stratum, 0,		/* next */
+  1, 1, 1, 1, 1,		/* all mem, mem, stack, regs, exec */
+  0, 0,				/* Section pointers */
+  OPS_MAGIC,			/* Always the last thing */
 };
 
-
-hms_quiet()
+hms_quiet ()
 {
- quiet = ! quiet;  
-   if (quiet)
-     printf_filtered("Snoop disabled\n");
-   else
-     printf_filtered("Snoop enabled\n");
+  quiet = !quiet;
+  if (quiet)
+    printf_filtered ("Snoop disabled\n");
+  else
+    printf_filtered ("Snoop enabled\n");
 
 }
 
-hms_device(s)
-char *s;
+hms_device (s)
+     char *s;
 {
-  if (s) 
-  {
-    dev_name = get_word(&s);
-  }  
+  if (s)
+    {
+      dev_name = get_word (&s);
+    }
 }
 
-
-static 
-hms_speed(s)
-char *s;
+static
+hms_speed (s)
+     char *s;
 {
-  check_open();
-  
-  if (s) 
-  {
-    char buffer[100];
-    int newrate = atoi(s);
-    int which = 0;
-    if (!serial_setbaudrate(newrate))
-	error("Can't use %d baud\n", newrate);
-    
-    printf_filtered("Checking target is in sync\n");
-    
-    get_baudrate_right();
-    baudrate = newrate;
-    printf_filtered("Sending commands to set target to %d\n",
-		    baudrate);    
-    
-    sprintf(buffer, "tm %d. N 8 1", baudrate);
-    hms_write_cr(buffer);
-  }    
+  check_open ();
+
+  if (s)
+    {
+      char buffer[100];
+      int newrate = atoi (s);
+      int which = 0;
+
+      if (!serial_setbaudrate (newrate))
+	error ("Can't use %d baud\n", newrate);
+
+      printf_filtered ("Checking target is in sync\n");
+
+      get_baudrate_right ();
+      baudrate = newrate;
+      printf_filtered ("Sending commands to set target to %d\n",
+		       baudrate);
+
+      sprintf (buffer, "tm %d. N 8 1", baudrate);
+      hms_write_cr (buffer);
+    }
 }
 
 /***********************************************************************/
@@ -1389,8 +1406,9 @@ void
 _initialize_remote_hms ()
 {
   add_target (&hms_ops);
+
   add_com ("hms <command>", class_obscure, hms_com,
- 	"Send a command to the HMS monitor.");
+	   "Send a command to the HMS monitor.");
   add_com ("snoop", class_obscure, hms_quiet,
 	   "Show what commands are going to the monitor");
 
@@ -1399,9 +1417,6 @@ _initialize_remote_hms ()
 
   add_com ("speed", class_obscure, hms_speed,
 	   "Set the terminal line speed for HMS communications");
-  
-#if 0
-  dev_name = serial_default_name();
-#endif
+
   dev_name = NULL;
 }
diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
new file mode 100644
index 0000000..92be34a
--- /dev/null
+++ b/gdb/remote-sim.c
@@ -0,0 +1,293 @@
+/* Remote debugging interface for generalized simulator
+   Copyright 1992 Free Software Foundation, Inc.
+   Contributed by Cygnus Support.  Written by Steve Chamberlain
+   (sac@cygnus.com).
+
+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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include "defs.h"
+#include "inferior.h"
+#include "wait.h"
+#include "value.h"
+#include <string.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <errno.h>
+#include "terminal.h"
+#include "target.h"
+#include "gdbcore.h"
+
+/* Forward data declarations */
+extern struct target_ops sim_ops;		/* Forward declaration */
+
+int
+sim_write_inferior_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     unsigned char *myaddr;
+     int len;
+{
+  return  sim_write(memaddr, myaddr, len);
+}
+
+static int
+store_register(regno)
+int regno;
+{
+  if (regno  == -1) 
+  {
+    for (regno = 0; regno < NUM_REGS; regno++)
+     store_register(regno);
+  }
+  else 
+  {
+    sim_store_register(regno, read_register(regno));
+  }
+  return 0;
+}
+
+
+/*
+ * Download a file specified in 'args', to the sim. 
+ */
+static void
+sim_load(args,fromtty)
+char	*args;
+int	fromtty;
+{
+  bfd	*abfd;
+  asection *s;
+
+  inferior_pid = 0;  
+  abfd = bfd_openr(args, (char*)0);
+
+  if (!abfd) 
+  {
+    printf_filtered("Unable to open file %s\n", args);
+    return;
+  }
+
+  if (bfd_check_format(abfd, bfd_object) ==0) 
+  {
+    printf_filtered("File is not an object file\n");
+    return ;
+  }
+
+  s = abfd->sections;
+  while (s != (asection *)NULL) 
+  {
+    if (s->flags & SEC_LOAD) 
+    {
+      int i;
+      int delta = 4096;
+      char *buffer = xmalloc(delta);
+      printf_filtered("%s\t: 0x%4x .. 0x%4x  ",
+		      s->name, s->vma, s->vma + s->_raw_size);
+      for (i = 0; i < s->_raw_size; i+= delta) 
+      {
+	int sub_delta = delta;
+	if (sub_delta > s->_raw_size - i)
+	 sub_delta = s->_raw_size - i ;
+
+	bfd_get_section_contents(abfd, s, buffer, i, sub_delta);
+	sim_write_inferior_memory(s->vma + i, buffer, sub_delta);
+	printf_filtered("*");
+	fflush(stdout);
+      }
+      printf_filtered(  "\n");      
+      free(buffer);
+    }
+    s = s->next;
+  }
+
+  sim_store_register(PC_REGNUM, abfd->start_address);
+}
+
+/* This is called not only when we first attach, but also when the
+   user types "run" after having attached.  */
+void
+sim_create_inferior (execfile, args, env)
+     char *execfile;
+     char *args;
+     char **env;
+{
+  int entry_pt;
+
+  if (args && *args)
+   error ("Can't pass arguments to remote sim process.");
+
+  if (execfile == 0 || exec_bfd == 0)
+   error ("No exec file specified");
+
+  entry_pt = (int) bfd_get_start_address (exec_bfd);
+  init_wait_for_inferior ();
+  insert_breakpoints ();
+  proceed(entry_pt, -1, 0);
+}
+
+
+
+static int
+sim_open (name, from_tty)
+     char *name;
+     int from_tty;
+{
+  if(name == 0) 
+  {
+    name = "";
+  }
+
+  push_target (&sim_ops);
+  target_fetch_registers(-1);
+  printf_filtered("Connected to the simulator.\n");
+}
+
+/* Close out all files and local state before this target loses control. */
+
+static int
+sim_close (quitting)
+     int quitting;
+{
+}
+
+/* Terminate the open connection to the remote debugger.
+   Use this when you want to detach and do something else
+   with your gdb.  */
+int
+sim_detach (args,from_tty)
+     char *args;
+     int from_tty;
+{
+  pop_target();			/* calls sim_close to do the real work */
+  if (from_tty)
+   printf_filtered ("Ending remote %s debugging\n", target_shortname);
+  return 0;
+}
+ 
+/* Tell the remote machine to resume.  */
+
+
+/* Wait until the remote machine stops, then return,
+   storing status in STATUS just as `wait' would.  */
+
+int
+sim_wait (status)
+     WAITTYPE *status;
+{
+  WSETSTOP(*status, sim_stop_signal());  
+  return 0;
+}
+
+
+
+static void
+fetch_register(regno)
+int regno;
+{
+  if (regno  == -1) 
+  {
+    for (regno = 0; regno < NUM_REGS; regno++)
+     fetch_register(regno);
+  }
+  else 
+  {
+    char buf[MAX_REGISTER_RAW_SIZE];
+    sim_fetch_register(regno, buf);
+    supply_register(regno, buf);
+  }
+}
+
+
+int
+sim_xfer_inferior_memory(memaddr, myaddr, len, write, target)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+     int write;
+     struct target_ops *target;			/* ignored */
+{
+  if (write)
+  {
+    sim_write(memaddr, myaddr, len);
+  }
+  else 
+  {
+    sim_read(memaddr, myaddr, len);
+  } 
+  return len;
+}
+
+
+/* This routine is run as a hook, just before the main command loop is
+   entered.  If gdb is configured for the H8, but has not had its
+   target specified yet, this will loop prompting the user to do so.
+*/
+
+void
+sim_before_main_loop ()
+{
+  push_target (&sim_ops);
+}
+
+
+static int rem_resume(a,b)
+{
+  sim_resume(a,b);
+  return 0;
+}
+
+pstore()
+{
+  return 1;
+}
+/* Define the target subroutine names */
+
+struct target_ops sim_ops = 
+{
+  "sim", "simulator",
+  "Use the simulator",
+  sim_open, sim_close, 
+  0, sim_detach, rem_resume, sim_wait, /* attach */
+  fetch_register, store_register,
+  pstore,
+  sim_xfer_inferior_memory, 
+  0,
+  0, 0, /* Breakpoints */
+  0, 0, 0, 0, 0,		/* Terminal handling */
+  pstore,
+  sim_load, 
+  0,				/* lookup_symbol */
+  sim_create_inferior,		/* create_inferior */ 
+  pstore,			/* mourn_inferior FIXME */
+  0,				/* can_run */
+  0,				/* notice_signals */
+  process_stratum, 0,		/* next */
+  1, 1, 1, 1, 1,		/* all mem, mem, stack, regs, exec */
+  0,0,				/* Section pointers */
+  OPS_MAGIC,			/* Always the last thing */
+};
+
+/***********************************************************************/
+
+void
+_initialize_remote_sim ()
+{
+  add_target (&sim_ops);
+}
+
+
diff --git a/gdb/tm-h8300.h b/gdb/tm-h8300.h
index f46f29a..5678c4a 100644
--- a/gdb/tm-h8300.h
+++ b/gdb/tm-h8300.h
@@ -77,17 +77,8 @@ UNSIGNED_SHORT(read_memory_integer (read_register (SP_REGNUM), 2))
 
 #define INNER_THAN <
 
-/* Sequence of bytes for breakpoint instruction.
-   This is a TRAP instruction.  The last 4 bits (0xf below) is the
-   vector.  Systems which don't use 0xf should define BPT_VECTOR
-   themselves before including this file.  */
 
-
-#define BPT_VECTOR 0xf
-
-
-
-#define BREAKPOINT {0x4e, (0x40 | BPT_VECTOR)}
+#define BREAKPOINT {0x53, 0x00}
 
 
 /* If your kernel resets the pc after the trap happens you may need to
@@ -305,3 +296,6 @@ typedef unsigned short INSN_WORD;
 #define read_memory_short(x)  (read_memory_integer(x,2) & 0xffff)
 #define DONT_USE_REMOTE
 
+
+#define	PRINT_REGISTER_HOOK(regno) print_register_hook(regno)
+