diff --git a/gdb/remote-z8k.c b/gdb/remote-z8k.c
index d1e3623006..744bc46b79 100644
--- a/gdb/remote-z8k.c
+++ b/gdb/remote-z8k.c
@@ -35,14 +35,13 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "../sim/z8k/sim.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 sim_ops;		/* Forward declaration */
-
-void sim_store_register();
-void sim_set_oc();
+extern struct target_ops sim_ops;	/* Forward declaration */
 
+void sim_store_register ();
+void sim_set_oc ();
 
 int
 sim_write_inferior_memory (memaddr, myaddr, len)
@@ -50,93 +49,91 @@ sim_write_inferior_memory (memaddr, myaddr, len)
      unsigned char *myaddr;
      int len;
 {
-  sim_write(memaddr, myaddr, len);
+  sim_write (memaddr, myaddr, len);
   return 1;
 }
 
 static void
-store_register(regno)
-int regno;
+store_register (regno)
+     int regno;
 {
-  if (regno  == -1) 
-  {
-    for (regno = 0; regno < 16; regno++)
+  if (regno == -1)
     {
-      store_register(regno);
+      for (regno = 0; regno < 16; regno++)
+	{
+	  store_register (regno);
+	}
+    }
+  else
+    {
+      sim_store_register (regno, read_register (regno));
     }
-  }
-  else 
-  {
-    sim_store_register(regno,read_register(regno));
-  }
 }
 
-
-
 void
-sim_kill(arg,from_tty)
-char	*arg;
-int	from_tty;
+sim_kill (arg, from_tty)
+     char *arg;
+     int from_tty;
 {
 
 }
 
-
-
 /*
- * Download a file specified in 'args', to the sim. 
+ * Download a file specified in 'args', to the sim.
  */
 static void
-sim_load(args,fromtty)
-char	*args;
-int	fromtty;
+sim_load (args, fromtty)
+     char *args;
+     int fromtty;
 {
-  bfd	*abfd;
+  bfd *abfd;
   asection *s;
 
-  inferior_pid = 0;  
-  abfd = bfd_openr(args,"coff-z8k");
+  inferior_pid = 0;
+  abfd = bfd_openr (args, "coff-z8k");
 
-  if (!abfd) 
-  {
-    printf_filtered("Unable to open file %s\n", args);
-    return;
-  }
+  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;
-      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 ;
+      if (s->flags & SEC_LOAD)
+	{
+	  int i;
+	  int delta = 4096;
+	  char *buffer = xmalloc (delta);
 
-	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);
+	  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;
     }
-    s = s->next;
-  }
 
-  sim_set_pc(abfd->start_address);
+  sim_set_pc (abfd->start_address);
 }
 
 /* This is called not only when we first attach, but also when the
@@ -150,39 +147,37 @@ sim_create_inferior (execfile, args, env)
   int entry_pt;
 
   if (args && *args)
-   error ("Can't pass arguments to remote sim process.");
+    error ("Can't pass arguments to remote sim 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);
 
-  sim_kill(NULL,NULL);	 
-  sim_clear_breakpoints();
+  sim_kill (NULL, NULL);
+  sim_clear_breakpoints ();
   init_wait_for_inferior ();
   insert_breakpoints ();
-  proceed(entry_pt, -1, 0);
+  proceed (entry_pt, -1, 0);
 }
 
-
-
 static void
 sim_open (name, from_tty)
      char *name;
      int from_tty;
 {
-  if(name == 0) 
-  {
-    name = "";
-  }
+  if (name == 0)
+    {
+      name = "";
+    }
 
   /* Clear any break points */
-  sim_clear_breakpoints();
+  sim_clear_breakpoints ();
 
   push_target (&sim_ops);
-  target_fetch_registers(-1);
+  target_fetch_registers (-1);
 
-  printf_filtered("Connected to the Z8000 Simulator.\n");
+  printf_filtered ("Connected to the Z8000 Simulator.\n");
 }
 
 /* Close out all files and local state before this target loses control. */
@@ -191,26 +186,25 @@ static void
 sim_close (quitting)
      int quitting;
 {
-  sim_clear_breakpoints();
+  sim_clear_breakpoints ();
 }
 
 /* Terminate the open connection to the remote debugger.
    Use this when you want to detach and do something else
    with your gdb.  */
 static void
-sim_detach (args,from_tty)
+sim_detach (args, from_tty)
      char *args;
      int from_tty;
 {
-  sim_clear_breakpoints();
- 
-  pop_target();			/* calls sim_close to do the real work */
-  if (from_tty)
-   printf_filtered ("Ending remote %s debugging\n", target_shortname);
-}
- 
-/* Tell the remote machine to resume.  */
+  sim_clear_breakpoints ();
 
+  pop_target ();		/* calls sim_close to do the real work */
+  if (from_tty)
+    printf_filtered ("Ending remote %s debugging\n", target_shortname);
+}
+
+/* Tell the remote machine to resume.  */
 
 /* Wait until the remote machine stops, then return,
    storing status in STATUS just as `wait' would.  */
@@ -219,11 +213,10 @@ int
 sim_wait (status)
      WAITTYPE *status;
 {
-  *status = sim_stop_signal();
+  *status = sim_stop_signal ();
   return 0;
 }
 
-
 /* Get ready to modify the registers array.  On machines which store
    individual registers, this doesn't need to do anything.  On machines
    which store all the registers in one fell swoop, this makes sure
@@ -236,21 +229,22 @@ sim_prepare_to_store ()
   /* Do nothing, since we can store individual regs */
 }
 
-
 static void
-fetch_register(regno)
-int regno;
+fetch_register (regno)
+     int regno;
 {
-  if (regno  == -1) 
-  {
-    for (regno = 0; regno < 16; regno++)
-     fetch_register(regno);
-  }
-  else {
-    char buf[MAX_REGISTER_RAW_SIZE];
-    sim_fetch_register(regno, buf);
-    supply_register(regno, buf);
-  }
+  if (regno == -1)
+    {
+      for (regno = 0; regno < 16; regno++)
+	fetch_register (regno);
+    }
+  else
+    {
+      char buf[MAX_REGISTER_RAW_SIZE];
+
+      sim_fetch_register (regno, buf);
+      supply_register (regno, buf);
+    }
 }
 
 /* Write a word WORD into remote address ADDR.
@@ -265,33 +259,34 @@ sim_store_word (addr, word)
 }
 
 int
-sim_xfer_inferior_memory(memaddr, myaddr, len, write, target)
+sim_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 */
 {
   if (write)
-  {
-    sim_write(memaddr, myaddr, len);
+    {
+      sim_write (memaddr, myaddr, len);
 
-  }
-  else 
-  {
-    sim_read(memaddr, myaddr, len);
-  } 
-    return len;
+    }
+  else
+    {
+      sim_read (memaddr, myaddr, len);
+    }
+  return len;
 }
 
 void
 sim_files_info ()
 {
   char *file = "nothing";
-  if (exec_bfd)
-   file = bfd_get_filename(exec_bfd);
 
-  printf_filtered("\tAttached to %s running on the z8k simulator\n",file);
+  if (exec_bfd)
+    file = bfd_get_filename (exec_bfd);
+
+  printf_filtered ("\tAttached to %s running on the z8k simulator\n", file);
 }
 
 /* This routine is run as a hook, just before the main command loop is
@@ -305,62 +300,57 @@ sim_before_main_loop ()
   push_target (&sim_ops);
 }
 
-
 /* Clear the sims notion of what the break points are */
 static void
-sim_mourn() 
-{ 
-  sim_clear_breakpoints();
+sim_mourn ()
+{
+  sim_clear_breakpoints ();
   generic_mourn_inferior ();
 }
 
-static void rem_resume(a,b)
-int a;
-int b;
+static void 
+rem_resume (a, b)
+     int a;
+     int b;
 {
-  sim_resume(a,b);
+  sim_resume (a, b);
 }
 
 /* Define the target subroutine names */
 
-struct target_ops sim_ops = 
+struct target_ops sim_ops =
 {
   "sim", "Remote SIM monitor",
   "Use the Z8000 simulator",
-  sim_open, sim_close, 
-  0, sim_detach, rem_resume, sim_wait, /* attach */
+  sim_open, sim_close,
+  0, sim_detach, rem_resume, sim_wait,	/* attach */
   fetch_register, store_register,
   sim_prepare_to_store,
-  sim_xfer_inferior_memory, 
+  sim_xfer_inferior_memory,
   sim_files_info,
-  0, 0, /* Breakpoints */
+  0, 0,				/* Breakpoints */
   0, 0, 0, 0, 0,		/* Terminal handling */
   sim_kill,			/* FIXME, kill */
-  sim_load, 
+  sim_load,
   0,				/* lookup_symbol */
-  sim_create_inferior,		/* create_inferior */ 
+  sim_create_inferior,		/* create_inferior */
   sim_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 */
+  0, 0,				/* Section pointers */
   OPS_MAGIC,			/* Always the last thing */
 };
 
-
-
-
-
-
 /***********************************************************************/
 
 void
 _initialize_remote_sim ()
 {
   extern int sim_z8001_mode;
+
   sim_z8001_mode = z8001_mode;
   add_target (&sim_ops);
+
 }
-
-
diff --git a/gdb/tm-z8k.h b/gdb/tm-z8k.h
index 7284e4f133..945c176dec 100644
--- a/gdb/tm-z8k.h
+++ b/gdb/tm-z8k.h
@@ -1,5 +1,5 @@
 /* Parameters for execution on a z8000 series machine.
-   Copyright 1992 Free Software Foundation, Inc.
+   Copyright 1992,1993 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -148,26 +148,23 @@ extern CORE_ADDR mz8k_skip_prologue PARAMS ((CORE_ADDR ip));
    to be actual register numbers as far as the user is concerned
    but do serve to get the desired values when passed to read_register.  */
 
-#define CCR_REGNUM 16		/* Contains processor status */
-#define PC_REGNUM 17		/* Contains program counter */
-#define CYCLES_REGNUM 18
-#define INSTS_REGNUM 19
-#define TIME_REGNUM 20
-#define FP_REGNUM 21		/* Contains fp, whatever memory model */
-#define SP_REGNUM 22		/* Conatins sp, whatever memory model */
-
-
-
-
+#define CCR_REGNUM 	16	/* Contains processor status */
+#define PC_REGNUM 	17	/* Contains program counter */
+#define CYCLES_REGNUM 	18
+#define INSTS_REGNUM 	19
+#define TIME_REGNUM 	20
+#define FP_REGNUM 	21	/* Contains fp, whatever memory model */
+#define SP_REGNUM 	22	/* Conatins sp, whatever memory model */
 
 
 
 #define PTR_SIZE (BIG ? 4: 2)
 #define PTR_MASK (BIG ? 0xff00ffff : 0x0000ffff)
+
 /* Store the address of the place in which to copy the structure the
    subroutine will return.  This is called from call_function. */
 
-#define STORE_STRUCT_RETURN(ADDR, SP) store_struct_return(ADDR,SP)
+#define STORE_STRUCT_RETURN(ADDR, SP) abort();
 
 /* Extract from an array REGBUF containing the (raw) register state
    a function return value of type TYPE, and copy that, in virtual format,
@@ -176,13 +173,12 @@ extern CORE_ADDR mz8k_skip_prologue PARAMS ((CORE_ADDR ip));
 
 
 #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- extract_return_value(TYPE,REGBUF,VALBUF)
+  bcopy(REGBUF + REGISTER_BYTE(2), VALBUF, TYPE_LENGTH(TYPE));
 
 /* Write into appropriate registers a function return value
-   of type TYPE, given in virtual format.  Assumes floats are passed
-   in d0/d1.  */
+   of type TYPE, given in virtual format. */
 
-#define STORE_RETURN_VALUE(TYPE,VALBUF) store_return_value(TYPE,VALBUF);
+#define STORE_RETURN_VALUE(TYPE,VALBUF) abort();
 
 /* Extract from an array REGBUF containing the (raw) register state
    the address in which a function should return its structure value,
@@ -195,10 +191,13 @@ extern CORE_ADDR mz8k_skip_prologue PARAMS ((CORE_ADDR ip));
 
 /* FRAME_CHAIN takes a frame's nominal address and produces the frame's
    chain-pointer.
-   In the case of the 68000, the frame's nominal address
-   is the address of a 4-byte word containing the calling frame's address.  */
+   In the case of the Z8000, the frame's nominal address
+   is the address of a ptr sized byte word containing the calling
+   frame's address.  */
+
+#define FRAME_CHAIN(thisframe) frame_chain(thisframe);
+
 
-#define FRAME_CHAIN(thisframe)  frame_chain(thisframe)
 
 /* Define other aspects of the stack frame.  */
 
@@ -302,8 +301,6 @@ int z8001_mode;
 
 #define NO_STD_REGS
 
-
-
 #define	PRINT_REGISTER_HOOK(regno) print_register_hook(regno)
 
 
@@ -312,4 +309,6 @@ int z8001_mode;
 
 #define NAMES_HAVE_UNDERSCORE
 
-#define ADDITIONAL_OPTIONS {"z8001",no_argument,&z8001_mode, 1},
+
+#define INIT_EXTRA_SYMTAB_INFO \
+  z8k_set_pointer_size(objfile->obfd->arch_info->bits_per_address);
diff --git a/gdb/z8k-tdep.c b/gdb/z8k-tdep.c
index 852c0f0da4..bd39d00c2a 100644
--- a/gdb/z8k-tdep.c
+++ b/gdb/z8k-tdep.c
@@ -1,5 +1,5 @@
 /* Target-machine dependent code for Zilog Z8000, for GDB.
-   Copyright (C) 1992 Free Software Foundation, Inc.
+   Copyright (C) 1992,1993 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -17,19 +17,18 @@ 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"
 #include "frame.h"
 #include "obstack.h"
 #include "symtab.h"
+#include "gdbcmd.h"
 #include "gdbtypes.h"
 
-
 /* Return the saved PC from this frame.
 
    If the frame has a memory copy of SRP_REGNUM, use that.  If not,
@@ -37,9 +36,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 CORE_ADDR
 frame_saved_pc (frame)
-FRAME frame;
+     FRAME frame;
 {
-  return ( read_memory_pointer(frame->frame+(BIG ? 4 : 2)));
+  return (read_memory_pointer (frame->frame + (BIG ? 4 : 2)));
 }
 
 #define IS_PUSHL(x) (BIG ? ((x & 0xfff0) == 0x91e0):((x & 0xfff0) == 0x91F0))
@@ -51,128 +50,129 @@ FRAME frame;
 #define IS_SUB_SP(x) ((x & 0xffff) == 0x020f)
 #define IS_PUSH_FP(x) (BIG ? (x == 0x93ea) : (x == 0x93fa))
 
-
-/* work out how much local space is on the stack and 
+/* work out how much local space is on the stack and
    return the pc pointing to the first push */
 
-static
-CORE_ADDR 
-skip_adjust(pc, size)
-CORE_ADDR pc;
-int *size;
+static CORE_ADDR
+skip_adjust (pc, size)
+     CORE_ADDR pc;
+     int *size;
 {
   *size = 0;
 
-  if (IS_PUSH_FP(read_memory_short(pc))
-      && IS_MOV_SP_FP(read_memory_short(pc+2)))
-  {
-    /* This is a function with an explict frame pointer */
-    pc += 4;
-    *size += 2;			/* remember the frame pointer */
-  }
+  if (IS_PUSH_FP (read_memory_short (pc))
+      && IS_MOV_SP_FP (read_memory_short (pc + 2)))
+    {
+      /* This is a function with an explict frame pointer */
+      pc += 4;
+      *size += 2;		/* remember the frame pointer */
+    }
 
   /* remember any stack adjustment */
-  if (IS_SUB_SP(read_memory_short(pc)))
-  {
-    *size += read_memory_short(pc+2);
-    pc += 4;
-  }
+  if (IS_SUB_SP (read_memory_short (pc)))
+    {
+      *size += read_memory_short (pc + 2);
+      pc += 4;
+    }
   return pc;
 }
 
-
 int
-examine_frame(pc, regs, sp)
-CORE_ADDR pc;
-struct frame_saved_regs *regs;
-CORE_ADDR sp;
+examine_frame (pc, regs, sp)
+     CORE_ADDR pc;
+     struct frame_saved_regs *regs;
+     CORE_ADDR sp;
 {
- int w = read_memory_short(pc);
- int offset = 0;
- int regno;
+  int w = read_memory_short (pc);
+  int offset = 0;
+  int regno;
 
+  for (regno = 0; regno < NUM_REGS; regno++)
+   regs->regs[regno] = 0;
 
-
- for (regno = 0; regno < NUM_REGS; regno++)
-  regs->regs[regno] = 0;
-
-  while  (IS_PUSHW(w) || IS_PUSHL(w)) 
+  while (IS_PUSHW (w) || IS_PUSHL (w))
   {
     /* work out which register is being pushed to where */
-    if (IS_PUSHL(w)) 
+    if (IS_PUSHL (w))
     {
       regs->regs[w & 0xf] = offset;
-      regs->regs[(w & 0xf) + 1] = offset +2;
+      regs->regs[(w & 0xf) + 1] = offset + 2;
       offset += 4;
     }
-    else {
+    else
+    {
       regs->regs[w & 0xf] = offset;
       offset += 2;
     }
     pc += 2;
-    w = read_memory_short(pc);
+    w = read_memory_short (pc);
   }
 
- if (IS_MOVE_FP(w)) 
- {
-   /* We know the fp */
+  if (IS_MOVE_FP (w))
+  {
+    /* We know the fp */
 
- }
- else if (IS_SUB_SP(w))
- {
-   /* Subtracting a value from the sp, so were in a function
-      which needs stack space for locals, but has no fp.  We fake up
-      the values as if we had an fp */
-   regs->regs[FP_REGNUM] = sp;
- }
- else
- {
-   /* This one didn't have an fp, we'll fake it up */
-   regs->regs[SP_REGNUM] = sp;
- }
- /* stack pointer contains address of next frame */
-/*  regs->regs[fp_regnum()] = fp;*/
+  }
+  else if (IS_SUB_SP (w))
+  {
+    /* Subtracting a value from the sp, so were in a function
+       which needs stack space for locals, but has no fp.  We fake up
+       the values as if we had an fp */
+    regs->regs[FP_REGNUM] = sp;
+  }
+  else
+  {
+    /* This one didn't have an fp, we'll fake it up */
+    regs->regs[SP_REGNUM] = sp;
+  }
+  /* stack pointer contains address of next frame */
+  /*  regs->regs[fp_regnum()] = fp;*/
   regs->regs[SP_REGNUM] = sp;
   return pc;
 }
 
-CORE_ADDR z8k_skip_prologue(start_pc)
-CORE_ADDR start_pc;
+CORE_ADDR 
+z8k_skip_prologue (start_pc)
+     CORE_ADDR start_pc;
 {
   struct frame_saved_regs dummy;
-  return examine_frame(start_pc, &dummy, 0);
+
+  return examine_frame (start_pc, &dummy, 0);
 }
 
-CORE_ADDR addr_bits_remove(x)
-CORE_ADDR x;
+CORE_ADDR 
+addr_bits_remove (x)
+     CORE_ADDR x;
 {
   return x & PTR_MASK;
 }
 
-read_memory_pointer(x)
-CORE_ADDR x;
+read_memory_pointer (x)
+     CORE_ADDR x;
 {
 
-return read_memory_integer(ADDR_BITS_REMOVE(x), BIG ? 4 : 2);
+  return read_memory_integer (ADDR_BITS_REMOVE (x), BIG ? 4 : 2);
 }
 
 FRAME_ADDR
 frame_chain (thisframe)
      FRAME thisframe;
 {
-  if (thisframe->prev == 0) 
-  {
-    /* This is the top of the stack, let's get the sp for real */
-  }
+  if (thisframe->prev == 0)
+    {
+      /* This is the top of the stack, let's get the sp for real */
+    }
   if (!inside_entry_file ((thisframe)->pc))
-  {
-return     read_memory_pointer ((thisframe)->frame);
-  }
-
+    {
+      return read_memory_pointer ((thisframe)->frame);
+    }
   return 0;
 }
 
-init_frame_pc() { abort(); }
+init_frame_pc ()
+{
+  abort ();
+}
 
 /* Put here the code to store, into a struct frame_saved_regs,
    the addresses of the saved registers of frame described by FRAME_INFO.
@@ -180,79 +180,70 @@ init_frame_pc() { abort(); }
    ways in the stack frame.  sp is even more special:
    the address we return for it IS the sp for the next frame.  */
 
-void get_frame_saved_regs(frame_info, frame_saved_regs) 
+void 
+get_frame_saved_regs (frame_info, frame_saved_regs)
      struct frame_info *frame_info;
      struct frame_saved_regs *frame_saved_regs;
 
 {
-CORE_ADDR pc;
-int w;
-bzero(frame_saved_regs, sizeof(*frame_saved_regs));
-pc = get_pc_function_start(frame_info->pc);
+  CORE_ADDR pc;
+  int w;
+
+  bzero (frame_saved_regs, sizeof (*frame_saved_regs));
+  pc = get_pc_function_start (frame_info->pc);
 
 /* wander down the instruction stream */
-examine_frame(pc, frame_saved_regs, frame_info->frame);
+  examine_frame (pc, frame_saved_regs, frame_info->frame);
 
 }
 
-
-extract_return_value(valtype, regbuf, valbuf)
-struct type *valtype;
-char regbuf[REGISTER_BYTES];
-char *valbuf;
-{ 
-  bcopy(regbuf + REGISTER_BYTE(2), valbuf, TYPE_LENGTH(valtype));
+void 
+z8k_push_dummy_frame ()
+{
+  abort ();
 }
-void z8k_push_dummy_frame() { abort(); }
 
-int print_insn(memaddr, stream)
-CORE_ADDR memaddr;
-FILE *stream;
+int 
+print_insn (memaddr, stream)
+     CORE_ADDR memaddr;
+     FILE *stream;
 {
   char temp[20];
+
   read_memory (memaddr, temp, 20);
-  if (BIG) {
-    return print_insn_z8001(memaddr, temp, stream);
-  }
-  else {
-    return print_insn_z8002(memaddr, temp, stream);
-  }
+  if (BIG)
+    {
+      return print_insn_z8001 (memaddr, temp, stream);
+    }
+  else
+    {
+      return print_insn_z8002 (memaddr, temp, stream);
+    }
 }
 
-void
-store_return_value()
-{
-abort();
-}
-void
-store_struct_return() { abort(); }
-
-
-
 /* 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;
 
 }
 
-
 /* 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
@@ -271,108 +262,180 @@ frame_find_saved_regs (fip, fsrp)
   CORE_ADDR pc;
   CORE_ADDR adr;
   int i;
-  
+
   memset (fsrp, 0, sizeof *fsrp);
 
-  pc = skip_adjust(get_pc_function_start (fip->pc), &locals);
+  pc = skip_adjust (get_pc_function_start (fip->pc), &locals);
 
- {
-   adr = fip->frame - locals;
-   for (i = 0; i < 8; i++) 
-   {
-     int word = read_memory_short(pc);
-     pc += 2 ;
-     if (IS_PUSHL(word)) {
-       fsrp->regs[word & 0xf] = adr;
-       fsrp->regs[(word & 0xf) + 1] = adr - 2;
-       adr -= 4;
-     }
-     else if (IS_PUSHW(word)) {
-       fsrp->regs[word & 0xf] = adr;
-       adr -= 2;
-     }
-     else
-      break;
-   }
+  {
+    adr = fip->frame - locals;
+    for (i = 0; i < 8; i++)
+      {
+	int word = read_memory_short (pc);
+
+	pc += 2;
+	if (IS_PUSHL (word))
+	  {
+	    fsrp->regs[word & 0xf] = adr;
+	    fsrp->regs[(word & 0xf) + 1] = adr - 2;
+	    adr -= 4;
+	  }
+	else if (IS_PUSHW (word))
+	  {
+	    fsrp->regs[word & 0xf] = adr;
+	    adr -= 2;
+	  }
+	else
+	  break;
+      }
+
+  }
 
- }
-  
   fsrp->regs[PC_REGNUM] = fip->frame + 4;
   fsrp->regs[FP_REGNUM] = fip->frame;
 
 }
 
 void
-addr_bits_set() { abort(); }
+addr_bits_set ()
+{
+  abort ();
+}
 
 int
-saved_pc_after_call() 
-{ 
-  return addr_bits_remove(read_memory_integer(read_register(SP_REGNUM), PTR_SIZE));
+saved_pc_after_call ()
+{
+  return addr_bits_remove (read_memory_integer (read_register (SP_REGNUM), PTR_SIZE));
 }
 
 void
-print_register_hook(regno)
-int regno;
+print_register_hook (regno)
+     int regno;
 {
 
-  if ((regno & 1)==0 && regno < 16) 
-  {
-    unsigned    short l[2];
-    read_relative_register_raw_bytes(regno, (char *)(l+0));
-    read_relative_register_raw_bytes(regno+1, (char *)(l+1));
-    printf("\t");
-    printf("%04x%04x", l[0],l[1]);
-  }
+  if ((regno & 1) == 0 && regno < 16)
+    {
+      unsigned short l[2];
 
-  if ((regno & 3)== 0 && regno < 16)
-  {
-    unsigned    short l[4];
-    read_relative_register_raw_bytes(regno, l+0);
-    read_relative_register_raw_bytes(regno+1, l+1);
-    read_relative_register_raw_bytes(regno+2, l+2);
-    read_relative_register_raw_bytes(regno+3, l+3);
-
-    printf("\t");
-    printf("%04x%04x%04x%04x", l[0],l[1],l[2],l[3]);
-  }
-  if (regno == 15) 
-  {
-    unsigned    short  rval;
-    int i;
-    read_relative_register_raw_bytes(regno, (char *)(&rval));
-
-    printf("\n");
-    for (i = 0; i < 10; i+=2)   {
-      printf("(sp+%d=%04x)",i, read_memory_short(rval+i));
+      read_relative_register_raw_bytes (regno, (char *) (l + 0));
+      read_relative_register_raw_bytes (regno + 1, (char *) (l + 1));
+      printf ("\t");
+      printf ("%04x%04x", l[0], l[1]);
     }
-  }
-  
-}
 
+  if ((regno & 3) == 0 && regno < 16)
+    {
+      unsigned short l[4];
+
+      read_relative_register_raw_bytes (regno, l + 0);
+      read_relative_register_raw_bytes (regno + 1, l + 1);
+      read_relative_register_raw_bytes (regno + 2, l + 2);
+      read_relative_register_raw_bytes (regno + 3, l + 3);
+
+      printf ("\t");
+      printf ("%04x%04x%04x%04x", l[0], l[1], l[2], l[3]);
+    }
+  if (regno == 15)
+    {
+      unsigned short rval;
+      int i;
+
+      read_relative_register_raw_bytes (regno, (char *) (&rval));
+
+      printf ("\n");
+      for (i = 0; i < 10; i += 2)
+	{
+	  printf ("(sp+%d=%04x)", i, read_memory_short (rval + i));
+	}
+    }
 
-void
-register_convert_to_virtual(regnum, from, to) 
-unsigned char *from;
-unsigned char *to;
-{
-    to[0] = from[0];
-    to[1] = from[1];
-    to[2] = from[2];
-    to[3] = from[3];
 }
 
 void
-register_convert_to_raw(regnum, to, from) 
-char *to;
-char *from;
+register_convert_to_virtual (regnum, from, to)
+     unsigned char *from;
+     unsigned char *to;
 {
-    to[0] = from[0];
-    to[1] = from[1];
-    to[2] = from[2];
-    to[3] = from[3];
+  to[0] = from[0];
+  to[1] = from[1];
+  to[2] = from[2];
+  to[3] = from[3];
 }
 
+void
+register_convert_to_raw (regnum, to, from)
+     char *to;
+     char *from;
+{
+  to[0] = from[0];
+  to[1] = from[1];
+  to[2] = from[2];
+  to[3] = from[3];
+}
 
+void 
+z8k_pop_frame ()
+{
+}
 
-void z8k_pop_frame() {  }
+struct cmd_list_element *setmemorylist;
+
+void 
+z8k_set_pointer_size (newsize)
+     int newsize;
+{
+  static int oldsize = 0;
+
+  if (oldsize != newsize)
+    {
+      printf ("pointer size set to %d bits\n", newsize);
+      oldsize = newsize;
+      if (newsize == 32)
+	{
+	  BIG = 1;
+	}
+      else
+	{
+	  BIG = 0;
+	}
+      _initialize_gdbtypes ();
+    }
+}
+
+static void
+segmented_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  z8k_set_pointer_size (16);
+}
+
+static void
+unsegmented_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  z8k_set_pointer_size (16);
+
+}
+
+static void
+set_memory (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  printf ("\"set memory\" must be followed by the name of a memory subcommand.\n");
+  help_list (setmemorylist, "set memory ", -1, stdout);
+}
+
+_initialize_z8ktdep ()
+{
+  add_prefix_cmd ("memory", no_class, set_memory,
+		  "set the memory model", &setmemorylist, "set memory ", 0,
+		  &setlist);
+  add_cmd ("segmented", class_support, segmented_command,
+	   "Set segmented memory model.", &setmemorylist);
+  add_cmd ("unsegmented", class_support, unsegmented_command,
+	   "Set unsegmented memory model.", &setmemorylist);
+
+}