* Makefile.in (final.o): Depend on target.h.

	* final.c: Include target.h.
	(default_function_pro_epilogue): New.
	(final_start_function): Use target structure for function prologues.
	(final_end_function): Use target structure for function epilogues.
	* fold-const.c (real_hex_to_f): Constify s and p.
	* output.h (default_function_pro_epilogue): New.
	* real.h (real_hex_to_f): Update prototype.
	* target-def.h (TARGET_ASM_FUNCTION_PROLOGUE,
	TARGET_ASM_FUNCTION_EPILOGUE, TARGET_ASM_OUT): New.
	(TARGET_INITIALIZER): Update.
	* target.h (gcc_target): Add struct asm_out.
	* doc/tm.texi: Update.

config:
	Update each arch to use TARGET_ASM_FUNCTION_PROLOGUE and
	TARGET_ASM_FUNCTION_EPILOGUE.  Move macro code to functions
	in cpu/cpu.c, or rename old functions consistently.  Take
	a HOST_WIDE INT not an int as the SIZE parameter.  Remove now
	redundant macros and prototypes.  Make new functions static.

	* 1750a/1750a.c: Similarly.
	* 1750a/1750a.h: Similarly.
	* a29k/a29k-protos.h: Similarly.
	* a29k/a29k.c: Similarly.
	* a29k/a29k.h: Similarly.
	* arc/arc-protos.h: Similarly.
	* arc/arc.c: Similarly.
	* arc/arc.h: Similarly.
	* arm/arm-protos.h: Similarly.
	* arm/arm.c: Similarly.
	* arm/arm.h: Similarly.
	* avr/avr-protos.h: Similarly.
	* avr/avr.c: Similarly.
	* avr/avr.h: Similarly.
	* clipper/clipper-protos.h: Similarly.
	* clipper/clipper.c: Similarly.
	* clipper/clipper.h: Similarly.
	* convex/convex.c: Similarly.
	* convex/convex.h: Similarly.
	* d30v/d30v-protos.h: Similarly.
	* d30v/d30v.c: Similarly.
	* d30v/d30v.h: Similarly.
	* d30v/d30v.md: Similarly.
	* dsp16xx/dsp16xx-protos.h: Similarly.
	* dsp16xx/dsp16xx.c: Similarly.
	* dsp16xx/dsp16xx.h: Similarly.
	* elxsi/elxsi.c: Similarly.
	* elxsi/elxsi.h: Similarly.
	* fr30/fr30.c: Similarly.
	* fr30/fr30.md: Similarly.
	* h8300/h8300-protos.h: Similarly.
	* h8300/h8300.c: Similarly.
	* h8300/h8300.h: Similarly.
	* i370/i370-protos.h: Similarly.
	* i370/i370.c: Similarly.
	* i370/i370.h: Similarly.
	* i386/i386.c: Similarly.
	* i386/osf1elf.h: Similarly.
	* i386/osfrose.h: Similarly.
	* i860/i860-protos.h: Similarly.
	* i860/i860.c: Similarly.
	* i860/i860.h: Similarly.
	* i960/i960-protos.h: Similarly.
	* i960/i960.c: Similarly.
	* i960/i960.h: Similarly.
	* ia64/ia64-protos.h: Similarly.
	* ia64/ia64.c: Similarly.
	* ia64/ia64.h: Similarly.
	* m32r/m32r-protos.h: Similarly.
	* m32r/m32r.c: Similarly.
	* m32r/m32r.h: Similarly.
	* m68hc11/m68hc11-protos.h: Similarly.
	* m68hc11/m68hc11.c: Similarly.
	* m68hc11/m68hc11.h: Similarly.
	* m68k/crds.h: Similarly.
	* m68k/dpx2.h: Similarly.
	* m68k/m68k-protos.h: Similarly.
	* m68k/m68k.c: Similarly.
	* m68k/m68k.h: Similarly.
	* m68k/news.h: Similarly.
	* m88k/m88k-protos.h: Similarly.
	* m88k/m88k.c: Similarly.
	* m88k/m88k.h: Similarly.
	* mips/mips-protos.h: Similarly.
	* mips/mips.c: Similarly.
	* mips/mips.h: Similarly.
	* ns32k/merlin.h: Similarly.
	* ns32k/ns32k.c: Similarly.
	* ns32k/ns32k.h: Similarly.
	* ns32k/tek6000.h: Similarly.
	* pa/pa-protos.h: Similarly.
	* pa/pa.c: Similarly.
	* pa/pa.h: Similarly.
	* pdp11/2bsd.h: Similarly.
	* pdp11/pdp11-protos.h: Similarly.
	* pdp11/pdp11.c: Similarly.
	* pdp11/pdp11.h: Similarly.
	* romp/romp-protos.h: Similarly.
	* romp/romp.c: Similarly.
	* romp/romp.h: Similarly.
	* rs6000/rs6000-protos.h: Similarly.
	* rs6000/rs6000.c: Similarly.
	* rs6000/rs6000.h: Similarly.
	* rs6000/sysv4.h: Similarly.
	* sh/sh-protos.h: Similarly.
	* sh/sh.c: Similarly.
	* sh/sh.h: Similarly.
	* sparc/sparc-protos.h: Similarly.
	* sparc/sparc.c: Similarly.
	* sparc/sparc.h: Similarly.
	* vax/vax.c: Similarly.
	* vax/vax.h: Similarly.
	* vax/vms.h: Similarly.
	* we32k/we32k.c: Similarly.
	* we32k/we32k.h: Similarly.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@43817 138bc75d-0d04-0410-961f-82ee72b054a4

4 files changed, 383 insertions, 407 deletions

diff --git a/gcc/config/ns32k/merlin.h b/gcc/config/ns32k/merlin.h
index 411c25107d8..a3b41baf260 100644
--- a/gcc/config/ns32k/merlin.h
+++ b/gcc/config/ns32k/merlin.h
@@ -26,6 +26,8 @@ Boston, MA 02111-1307, USA.  */
 
 #include "ns32k/ns32k.h"
 
+#define MERLIN_TARGET
+
 /* This is BSD, so it wants DBX format.  */
 #define DBX_DEBUGGING_INFO
 
@@ -123,108 +125,6 @@ Boston, MA 02111-1307, USA.  */
 	   fprintf (FILE, "$0f%.20e", u.d); }				\
   else output_addr_const (FILE, X); }
 
-#undef  FUNCTION_PROLOGUE
-
-/* This differs from the one in ns32k.h in printing a bitmask
-   rather than a register list in the enter or save instruction.  */
-
-#define FUNCTION_PROLOGUE(FILE, SIZE)     \
-{ register int regno, g_regs_used = 0;				\
-  int used_regs_buf[8], *bufp = used_regs_buf;			\
-  int used_fregs_buf[8], *fbufp = used_fregs_buf;		\
-  extern char call_used_regs[];					\
-  MAIN_FUNCTION_PROLOGUE;					\
-  for (regno = 0; regno < 8; regno++)				\
-    if (regs_ever_live[regno]					\
-	&& ! call_used_regs[regno])				\
-    {								\
-      *bufp++ = regno; g_regs_used++;				\
-    }								\
-  *bufp = -1;							\
-  for (; regno < 16; regno++)					\
-    if (regs_ever_live[regno] && !call_used_regs[regno]) {	\
-      *fbufp++ = regno;						\
-    }								\
-  *fbufp = -1;							\
-  bufp = used_regs_buf;						\
-  if (frame_pointer_needed)					\
-    fprintf (FILE, "\tenter ");					\
-  else if (g_regs_used)						\
-    fprintf (FILE, "\tsave ");					\
-  if (frame_pointer_needed || g_regs_used)			\
-    {								\
-      char mask = 0;						\
-      while (*bufp >= 0)					\
-	mask |= 1 << *bufp++;					\
-      fprintf (FILE, "$0x%x", (int) mask & 0xff);		\
-    }								\
-  if (frame_pointer_needed)					\
-    fprintf (FILE, ",%d\n", SIZE);				\
-  else if (g_regs_used)						\
-    fprintf (FILE, "\n");					\
-  fbufp = used_fregs_buf;					\
-  while (*fbufp >= 0)						\
-    {								\
-      if ((*fbufp & 1) || (fbufp[0] != fbufp[1] - 1))		\
-	fprintf (FILE, "\tmovf f%d,tos\n", *fbufp++ - 8);	\
-      else							\
-	{							\
-	  fprintf (FILE, "\tmovl f%d,tos\n", fbufp[0] - 8);	\
-	  fbufp += 2;						\
-	}							\
-    }								\
-}
-
-#undef  FUNCTION_EPILOGUE
-
-/* This differs from the one in ns32k.h in printing a bitmask
-   rather than a register list in the exit or restore instruction.  */
-
-#define FUNCTION_EPILOGUE(FILE, SIZE) \
-{ register int regno, g_regs_used = 0, f_regs_used = 0;		\
-  int used_regs_buf[8], *bufp = used_regs_buf;			\
-  int used_fregs_buf[8], *fbufp = used_fregs_buf;		\
-  extern char call_used_regs[];					\
-  *fbufp++ = -2;						\
-  for (regno = 8; regno < 16; regno++)				\
-    if (regs_ever_live[regno] && !call_used_regs[regno]) {	\
-       *fbufp++ = regno; f_regs_used++;				\
-    }								\
-  fbufp--;							\
-  for (regno = 0; regno < 8; regno++)				\
-    if (regs_ever_live[regno]					\
-	&& ! call_used_regs[regno])				\
-    {                                                         	\
-      *bufp++ = regno; g_regs_used++;				\
-    }                                                         	\
-  while (fbufp > used_fregs_buf)				\
-    {								\
-      if ((*fbufp & 1) && fbufp[0] == fbufp[-1] + 1)		\
-	{							\
-	  fprintf (FILE, "\tmovl tos,f%d\n", fbufp[-1] - 8);	\
-	  fbufp -= 2;						\
-	}							\
-      else fprintf (FILE, "\tmovf tos,f%d\n", *fbufp-- - 8);	\
-    }								\
-  if (frame_pointer_needed)					\
-    fprintf (FILE, "\texit ");					\
-  else if (g_regs_used)						\
-    fprintf (FILE, "\trestore ");				\
-  if (g_regs_used || frame_pointer_needed)			\
-    {								\
-      char mask = 0;						\
-								\
-      while (bufp > used_regs_buf)				\
-	{							\
-	  /* Utek assembler takes care of reversing this */	\
-	  mask |= 1 << *--bufp;					\
-	}							\
-      fprintf (FILE, "$0x%x\n", (int) mask & 0xff);		\
-    }								\
-  if (current_function_pops_args)				\
-    fprintf (FILE, "\tret %d\n", current_function_pops_args);	\
-  else fprintf (FILE, "\tret 0\n"); }
-
 #endif /* UTEK_ASM */
 
 #undef PRINT_OPERAND_ADDRESS
diff --git a/gcc/config/ns32k/ns32k.c b/gcc/config/ns32k/ns32k.c
index 6dc89b16878..ca84f6e3feb 100644
--- a/gcc/config/ns32k/ns32k.c
+++ b/gcc/config/ns32k/ns32k.c
@@ -65,13 +65,393 @@ static rtx gen_indexed_expr PARAMS ((rtx, rtx, rtx));
 static const char *singlemove_string PARAMS ((rtx *));
 static void move_tail PARAMS ((rtx[], int, int));
 static int ns32k_valid_type_attribute_p PARAMS ((tree, tree, tree, tree));
+static void ns32k_output_function_prologue PARAMS ((FILE *, HOST_WIDE_INT));
+static void ns32k_output_function_epilogue PARAMS ((FILE *, HOST_WIDE_INT));
 
 /* Initialize the GCC target structure.  */
 #undef TARGET_VALID_TYPE_ATTRIBUTE
 #define TARGET_VALID_TYPE_ATTRIBUTE ns32k_valid_type_attribute_p
 
+#undef TARGET_ASM_FUNCTION_PROLOGUE
+#define TARGET_ASM_FUNCTION_PROLOGUE ns32k_output_function_prologue
+#undef TARGET_ASM_FUNCTION_EPILOGUE
+#define TARGET_ASM_FUNCTION_EPILOGUE ns32k_output_function_epilogue
+
 struct gcc_target target = TARGET_INITIALIZER;
 
+/* Generate the assembly code for function entry.  FILE is a stdio
+   stream to output the code to.  SIZE is an int: how many units of
+   temporary storage to allocate.
+
+   Refer to the array `regs_ever_live' to determine which registers to
+   save; `regs_ever_live[I]' is nonzero if register number I is ever
+   used in the function.  This function is responsible for knowing
+   which registers should not be saved even if used.  */
+
+/*
+ * The function prologue for the ns32k is fairly simple.
+ * If a frame pointer is needed (decided in reload.c ?) then
+ * we need assembler of the form
+ *
+ *  # Save the oldframe pointer, set the new frame pointer, make space
+ *  # on the stack and save any general purpose registers necessary
+ *
+ *  enter [<general purpose regs to save>], <local stack space>
+ *
+ *  movf  fn, tos    # Save any floating point registers necessary
+ *  .
+ *  .
+ *
+ * If a frame pointer is not needed we need assembler of the form
+ *
+ *  # Make space on the stack
+ *
+ *  adjspd <local stack space + 4>
+ *
+ *  # Save any general purpose registers necessary
+ *
+ *  save [<general purpose regs to save>]
+ *
+ *  movf  fn, tos    # Save any floating point registers necessary
+ *  .
+ *  .
+ */
+
+#if !defined (MERLIN_TARGET) && !defined (UTEK_ASM)
+
+#if defined(IMMEDIATE_PREFIX) && IMMEDIATE_PREFIX
+#define ADJSP(FILE, N) \
+        fprintf (FILE, "\tadjspd %c%d\n", IMMEDIATE_PREFIX, (N))
+#else
+#define ADJSP(FILE, N) \
+        fprintf (FILE, "\tadjspd %d\n", (N))
+#endif
+
+static void
+ns32k_output_function_prologue (file, size)
+     FILE *file;
+     HOST_WIDE_INT size;
+{
+  register int regno, g_regs_used = 0;
+  int used_regs_buf[8], *bufp = used_regs_buf;
+  int used_fregs_buf[17], *fbufp = used_fregs_buf;
+  extern char call_used_regs[];
+
+  for (regno = R0_REGNUM; regno < F0_REGNUM; regno++)
+    if (regs_ever_live[regno]
+	&& ! call_used_regs[regno])
+      {
+        *bufp++ = regno; g_regs_used++;
+      }
+  *bufp = -1;
+
+  for (; regno < FRAME_POINTER_REGNUM; regno++)
+    if (regs_ever_live[regno] && !call_used_regs[regno])
+      {
+        *fbufp++ = regno;
+      }
+  *fbufp = -1;
+
+  bufp = used_regs_buf;
+  if (frame_pointer_needed)
+    fprintf (file, "\tenter [");
+  else
+    {
+      if (size)
+        ADJSP (file, size + 4);
+      if (g_regs_used && g_regs_used > 4)
+        fprintf (file, "\tsave [");
+      else
+	{
+	  while (*bufp >= 0)
+            fprintf (file, "\tmovd r%d,tos\n", *bufp++);
+	  g_regs_used = 0;
+	}
+    }
+
+  while (*bufp >= 0)
+    {
+      fprintf (file, "r%d", *bufp++);
+      if (*bufp >= 0)
+	fputc (',', file);
+    }
+
+  if (frame_pointer_needed)
+    fprintf (file, "],%d\n", size);
+  else if (g_regs_used)
+    fprintf (file, "]\n");
+
+  fbufp = used_fregs_buf;
+  while (*fbufp >= 0)
+    {
+      if ((*fbufp & 1) || (fbufp[0] != fbufp[1] - 1))
+	fprintf (file, "\tmovf %s,tos\n", ns32k_out_reg_names[*fbufp++]);
+      else
+	{
+	  fprintf (file, "\tmovl %s,tos\n",
+		   ns32k_out_reg_names[fbufp[0]]);
+	  fbufp += 2;
+	}
+    }
+
+  if (flag_pic && current_function_uses_pic_offset_table)
+    {
+      fprintf (file, "\tsprd sb,tos\n");
+      if (TARGET_REGPARM)
+	{
+	  fprintf (file, "\taddr __GLOBAL_OFFSET_TABLE_(pc),tos\n");
+	  fprintf (file, "\tlprd sb,tos\n");
+	}
+      else
+	{
+	  fprintf (file, "\taddr __GLOBAL_OFFSET_TABLE_(pc),r0\n");
+	  fprintf (file, "\tlprd sb,r0\n");
+	}
+    }
+}
+
+#else /* MERLIN_TARGET || UTEK_ASM  */
+
+/* This differs from the standard one above in printing a bitmask
+   rather than a register list in the enter or save instruction.  */
+
+static void
+ns32k_output_function_prologue (file, size)
+     FILE *file;
+     HOST_WIDE_INT size;
+{
+  register int regno, g_regs_used = 0;
+  int used_regs_buf[8], *bufp = used_regs_buf;
+  int used_fregs_buf[8], *fbufp = used_fregs_buf;
+  extern char call_used_regs[];
+
+  for (regno = 0; regno < 8; regno++)
+    if (regs_ever_live[regno]
+	&& ! call_used_regs[regno])
+      {
+	*bufp++ = regno; g_regs_used++;
+      }
+  *bufp = -1;
+
+  for (; regno < 16; regno++)
+    if (regs_ever_live[regno] && !call_used_regs[regno]) {
+      *fbufp++ = regno;
+    }
+  *fbufp = -1;
+
+  bufp = used_regs_buf;
+  if (frame_pointer_needed)
+    fprintf (file, "\tenter ");
+  else if (g_regs_used)
+    fprintf (file, "\tsave ");
+
+  if (frame_pointer_needed || g_regs_used)
+    {
+      char mask = 0;
+      while (*bufp >= 0)
+	mask |= 1 << *bufp++;
+      fprintf (file, "$0x%x", (int) mask & 0xff);
+    }
+
+  if (frame_pointer_needed)
+#ifdef UTEK_ASM
+    fprintf (file, ",$%d\n", size);
+#else
+    fprintf (file, ",%d\n", size);
+#endif
+  else if (g_regs_used)
+    fprintf (file, "\n");
+
+  fbufp = used_fregs_buf;
+  while (*fbufp >= 0)
+    {
+      if ((*fbufp & 1) || (fbufp[0] != fbufp[1] - 1))
+	fprintf (file, "\tmovf f%d,tos\n", *fbufp++ - 8);
+      else
+	{
+	  fprintf (file, "\tmovl f%d,tos\n", fbufp[0] - 8);
+	  fbufp += 2;
+	}
+    }
+}
+
+#endif /* MERLIN_TARGET || UTEK_ASM  */
+
+/* This function generates the assembly code for function exit,
+   on machines that need it.
+
+   The function epilogue should not depend on the current stack pointer,
+   if EXIT_IGNORE_STACK is nonzero.  That doesn't apply here.
+
+   If a frame pointer is needed (decided in reload.c ?) then
+   we need assembler of the form
+
+    movf  tos, fn	# Restore any saved floating point registers
+    .
+    .
+
+    # Restore any saved general purpose registers, restore the stack
+    # pointer from the frame pointer, restore the old frame pointer.
+    exit [<general purpose regs to save>]
+
+   If a frame pointer is not needed we need assembler of the form
+    # Restore any general purpose registers saved
+
+    movf  tos, fn	# Restore any saved floating point registers
+    .
+    .
+    .
+    restore [<general purpose regs to save>]
+
+    # reclaim space allocated on stack
+
+    adjspd <-(local stack space + 4)> */
+
+#if !defined (MERLIN_TARGET) && !defined (UTEK_ASM)
+
+static void
+ns32k_output_function_epilogue (file, size)
+     FILE *file;
+     HOST_WIDE_INT size;
+{
+  register int regno, g_regs_used = 0, f_regs_used = 0;
+  int used_regs_buf[8], *bufp = used_regs_buf;
+  int used_fregs_buf[17], *fbufp = used_fregs_buf;
+  extern char call_used_regs[];
+
+  if (flag_pic && current_function_uses_pic_offset_table)
+    fprintf (file, "\tlprd sb,tos\n");
+
+  *fbufp++ = -2;
+  for (regno = F0_REGNUM; regno < FRAME_POINTER_REGNUM; regno++)
+    if (regs_ever_live[regno] && !call_used_regs[regno])
+      {
+	*fbufp++ = regno; f_regs_used++;
+      }
+  fbufp--;
+
+  for (regno = 0; regno < F0_REGNUM; regno++)
+    if (regs_ever_live[regno]
+	&& ! call_used_regs[regno])
+      {
+        *bufp++ = regno; g_regs_used++;
+      }
+
+  while (fbufp > used_fregs_buf)
+    {
+      if ((*fbufp & 1) && fbufp[0] == fbufp[-1] + 1)
+	{
+	  fprintf (file, "\tmovl tos,%s\n",
+		   ns32k_out_reg_names[fbufp[-1]]);
+	  fbufp -= 2;
+	}
+      else fprintf (file, "\tmovf tos,%s\n", ns32k_out_reg_names[*fbufp--]);
+    }
+
+  if (frame_pointer_needed)
+    fprintf (file, "\texit [");
+  else
+    {
+      if (g_regs_used && g_regs_used > 4)
+        fprintf (file, "\trestore [");
+      else
+        {
+	  while (bufp > used_regs_buf)
+            fprintf (file, "\tmovd tos,r%d\n", *--bufp);
+	  g_regs_used = 0;
+        }
+    }
+
+  while (bufp > used_regs_buf)
+    {
+      fprintf (file, "r%d", *--bufp);
+      if (bufp > used_regs_buf)
+	fputc (',', file);
+    }
+
+  if (g_regs_used || frame_pointer_needed)
+    fprintf (file, "]\n");
+
+  if (size && !frame_pointer_needed)
+    ADJSP (file, -(size + 4));
+
+  if (current_function_pops_args)
+    fprintf (file, "\tret %d\n", current_function_pops_args);
+  else
+    fprintf (file, "\tret 0\n");
+}
+
+#else /* MERLIN_TARGET || UTEK_ASM  */
+
+/* This differs from the standard one above in printing a bitmask
+   rather than a register list in the exit or restore instruction.  */
+
+static void
+ns32k_output_function_epilogue (file, size)
+     FILE *file;
+     HOST_WIDE_INT size ATTRIBUTE_UNUSED;
+{
+  register int regno, g_regs_used = 0, f_regs_used = 0;
+  int used_regs_buf[8], *bufp = used_regs_buf;
+  int used_fregs_buf[8], *fbufp = used_fregs_buf;
+  extern char call_used_regs[];
+
+  *fbufp++ = -2;
+  for (regno = 8; regno < 16; regno++)
+    if (regs_ever_live[regno] && !call_used_regs[regno]) {
+      *fbufp++ = regno; f_regs_used++;
+    }
+  fbufp--;
+
+  for (regno = 0; regno < 8; regno++)
+    if (regs_ever_live[regno]
+	&& ! call_used_regs[regno])
+      {
+	*bufp++ = regno; g_regs_used++;
+      }
+
+  while (fbufp > used_fregs_buf)
+    {
+      if ((*fbufp & 1) && fbufp[0] == fbufp[-1] + 1)
+	{
+	  fprintf (file, "\tmovl tos,f%d\n", fbufp[-1] - 8);
+	  fbufp -= 2;
+	}
+      else fprintf (file, "\tmovf tos,f%d\n", *fbufp-- - 8);
+    }
+
+  if (frame_pointer_needed)
+    fprintf (file, "\texit ");
+  else if (g_regs_used)
+    fprintf (file, "\trestore ");
+
+  if (g_regs_used || frame_pointer_needed)
+    {
+      char mask = 0;
+
+      while (bufp > used_regs_buf)
+	{
+	  /* Utek assembler takes care of reversing this */
+	  mask |= 1 << *--bufp;
+	}
+      fprintf (file, "$0x%x\n", (int) mask & 0xff);
+    }
+
+#ifdef UTEK_ASM
+  if (current_function_pops_args)
+    fprintf (file, "\tret $%d\n", current_function_pops_args);
+  else
+    fprintf (file, "\tret $0\n");
+#else
+  if (current_function_pops_args)
+    fprintf (file, "\tret %d\n", current_function_pops_args);
+  else
+    fprintf (file, "\tret 0\n");
+#endif
+}
+
+#endif /* MERLIN_TARGET || UTEK_ASM  */
+
 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE. */ 
 int
 hard_regno_mode_ok (regno, mode)
diff --git a/gcc/config/ns32k/ns32k.h b/gcc/config/ns32k/ns32k.h
index 3adc9bbd1b7..778644c5a41 100644
--- a/gcc/config/ns32k/ns32k.h
+++ b/gcc/config/ns32k/ns32k.h
@@ -678,119 +678,6 @@ enum reg_class
 		      : GET_MODE_SIZE (MODE))))  		\
  ? 2 - (CUM) / 4 : 0)
 
-#ifndef MAIN_FUNCTION_PROLOGUE
-#define MAIN_FUNCTION_PROLOGUE
-#endif
-
-/*
- * The function prologue for the ns32k is fairly simple.
- * If a frame pointer is needed (decided in reload.c ?) then
- * we need assembler of the form
- *
- *  # Save the oldframe pointer, set the new frame pointer, make space
- *  # on the stack and save any general purpose registers necessary
- *
- *  enter [<general purpose regs to save>], <local stack space>
- *
- *  movf  fn, tos    # Save any floating point registers necessary
- *  .
- *  .
- *
- * If a frame pointer is not needed we need assembler of the form
- *
- *  # Make space on the stack
- *
- *  adjspd <local stack space + 4>
- *
- *  # Save any general purpose registers necessary
- *
- *  save [<general purpose regs to save>]
- *
- *  movf  fn, tos    # Save any floating point registers necessary
- *  .
- *  .
- */
-#if defined(IMMEDIATE_PREFIX) && IMMEDIATE_PREFIX
-#define ADJSP(FILE, N) \
-        fprintf (FILE, "\tadjspd %c%d\n", IMMEDIATE_PREFIX, (N))
-#else
-#define ADJSP(FILE, N) \
-        fprintf (FILE, "\tadjspd %d\n", (N))
-#endif
-
-#define FUNCTION_PROLOGUE(FILE, SIZE)     \
-{ register int regno, g_regs_used = 0;				\
-  int used_regs_buf[8], *bufp = used_regs_buf;			\
-  int used_fregs_buf[17], *fbufp = used_fregs_buf;		\
-  extern char call_used_regs[];					\
-  MAIN_FUNCTION_PROLOGUE;					\
-  for (regno = R0_REGNUM; regno < F0_REGNUM; regno++)		\
-    if (regs_ever_live[regno]					\
-	&& ! call_used_regs[regno])				\
-      {								\
-        *bufp++ = regno; g_regs_used++;				\
-      }								\
-  *bufp = -1;							\
-  for (; regno < FRAME_POINTER_REGNUM; regno++)			\
-    if (regs_ever_live[regno] && !call_used_regs[regno])	\
-      {								\
-        *fbufp++ = regno;					\
-      }								\
-  *fbufp = -1;							\
-  bufp = used_regs_buf;						\
-  if (frame_pointer_needed)					\
-    fprintf (FILE, "\tenter [");				\
-  else								\
-    {								\
-      if (SIZE)							\
-        ADJSP (FILE, SIZE + 4);					\
-      if (g_regs_used && g_regs_used > 4)			\
-        fprintf (FILE, "\tsave [");				\
-      else							\
-	{							\
-	  while (*bufp >= 0)					\
-            fprintf (FILE, "\tmovd r%d,tos\n", *bufp++);	\
-	  g_regs_used = 0;					\
-	}							\
-    }								\
-  while (*bufp >= 0)						\
-    {								\
-      fprintf (FILE, "r%d", *bufp++);				\
-      if (*bufp >= 0)						\
-	fputc (',', FILE);					\
-    }								\
-  if (frame_pointer_needed)					\
-    fprintf (FILE, "],%d\n", SIZE);				\
-  else if (g_regs_used)						\
-    fprintf (FILE, "]\n");					\
-  fbufp = used_fregs_buf;					\
-  while (*fbufp >= 0)						\
-    {								\
-      if ((*fbufp & 1) || (fbufp[0] != fbufp[1] - 1))	\
-	fprintf (FILE, "\tmovf %s,tos\n", ns32k_out_reg_names[*fbufp++]); \
-      else							\
-	{							\
-	  fprintf (FILE, "\tmovl %s,tos\n",                     \
-		   ns32k_out_reg_names[fbufp[0]]);                    \
-	  fbufp += 2;						\
-	}							\
-    }								\
-  if (flag_pic && current_function_uses_pic_offset_table)	\
-    {								\
-      fprintf (FILE, "\tsprd sb,tos\n");			\
-      if (TARGET_REGPARM)					\
-	{							\
-	  fprintf (FILE, "\taddr __GLOBAL_OFFSET_TABLE_(pc),tos\n"); \
-	  fprintf (FILE, "\tlprd sb,tos\n");			\
-	}							\
-      else							\
-	{							\
-	  fprintf (FILE, "\taddr __GLOBAL_OFFSET_TABLE_(pc),r0\n"); \
-	  fprintf (FILE, "\tlprd sb,r0\n");			\
-	}							\
-    }								\
-}
-
 /* Output assembler code to FILE to increment profiler label # LABELNO
    for profiling a function entry.
 
@@ -804,101 +691,11 @@ enum reg_class
    functions that have frame pointers.
    No definition is equivalent to always zero.
 
-   We use 0, because using 1 requires hair in FUNCTION_EPILOGUE
+   We use 0, because using 1 requires hair in output_function_epilogue()
    that is worse than the stack adjust we could save.  */
 
 /* #define EXIT_IGNORE_STACK 1 */
 
-/* This macro generates the assembly code for function exit,
-   on machines that need it.  If FUNCTION_EPILOGUE is not defined
-   then individual return instructions are generated for each
-   return statement.  Args are same as for FUNCTION_PROLOGUE.
-
-   The function epilogue should not depend on the current stack pointer,
-   if EXIT_IGNORE_STACK is nonzero.  That doesn't apply here.
-
-   If a frame pointer is needed (decided in reload.c ?) then
-   we need assembler of the form
-
-    movf  tos, fn	# Restore any saved floating point registers
-    .
-    .
-
-    # Restore any saved general purpose registers, restore the stack
-    # pointer from the frame pointer, restore the old frame pointer.
-    exit [<general purpose regs to save>]
-
-   If a frame pointer is not needed we need assembler of the form
-    # Restore any general purpose registers saved
-
-    movf  tos, fn	# Restore any saved floating point registers
-    .
-    .
-    .
-    restore [<general purpose regs to save>]
-
-    # reclaim space allocated on stack
-
-    adjspd <-(local stack space + 4)> */
-
-
-#define FUNCTION_EPILOGUE(FILE, SIZE) \
-{ register int regno, g_regs_used = 0, f_regs_used = 0;		\
-  int used_regs_buf[8], *bufp = used_regs_buf;			\
-  int used_fregs_buf[17], *fbufp = used_fregs_buf;		\
-  extern char call_used_regs[];					\
-  if (flag_pic && current_function_uses_pic_offset_table)	\
-    fprintf (FILE, "\tlprd sb,tos\n");				\
-  *fbufp++ = -2;						\
-  for (regno = F0_REGNUM; regno < FRAME_POINTER_REGNUM; regno++) \
-    if (regs_ever_live[regno] && !call_used_regs[regno])	\
-      {								\
-       *fbufp++ = regno; f_regs_used++;				\
-      }								\
-  fbufp--;							\
-  for (regno = 0; regno < F0_REGNUM; regno++)			\
-    if (regs_ever_live[regno]					\
-	&& ! call_used_regs[regno])				\
-      {                                                        	\
-        *bufp++ = regno; g_regs_used++;				\
-      }                                                        	\
-  while (fbufp > used_fregs_buf)				\
-    {								\
-      if ((*fbufp & 1) && fbufp[0] == fbufp[-1] + 1)	        \
-	{							\
-	  fprintf (FILE, "\tmovl tos,%s\n",                     \
-		   ns32k_out_reg_names[fbufp[-1]]);                   \
-	  fbufp -= 2;						\
-	}							\
-      else fprintf (FILE, "\tmovf tos,%s\n", ns32k_out_reg_names[*fbufp--]); \
-    }								\
-  if (frame_pointer_needed)					\
-    fprintf (FILE, "\texit [");					\
-  else								\
-    {								\
-      if (g_regs_used && g_regs_used > 4)			\
-        fprintf (FILE, "\trestore [");				\
-      else							\
-        {							\
-	  while (bufp > used_regs_buf)				\
-            fprintf (FILE, "\tmovd tos,r%d\n", *--bufp);	\
-	  g_regs_used = 0;					\
-        }							\
-    }								\
-  while (bufp > used_regs_buf)					\
-    {								\
-      fprintf (FILE, "r%d", *--bufp);				\
-      if (bufp > used_regs_buf)					\
-	fputc (',', FILE);					\
-    }								\
-  if (g_regs_used || frame_pointer_needed)			\
-    fprintf (FILE, "]\n");					\
-  if (SIZE && !frame_pointer_needed)				\
-    ADJSP (FILE, -(SIZE + 4));					\
-  if (current_function_pops_args)				\
-    fprintf (FILE, "\tret %d\n", current_function_pops_args);	\
-  else fprintf (FILE, "\tret 0\n"); }
-
 /* Store in the variable DEPTH the initial difference between the
    frame pointer reg contents and the stack pointer reg contents,
    as of the start of the function body.  This depends on the layout
diff --git a/gcc/config/ns32k/tek6000.h b/gcc/config/ns32k/tek6000.h
index 1565ae863be..219d9198903 100644
--- a/gcc/config/ns32k/tek6000.h
+++ b/gcc/config/ns32k/tek6000.h
@@ -112,107 +112,6 @@ Boston, MA 02111-1307, USA.  */
 #define SHARED_SECTION_ASM_OP "\t.shdata"
 
 #ifdef UTEK_ASM
-#undef  FUNCTION_PROLOGUE
-
-/* This differs from the one in ns32k.h in printing a bitmask
-   rather than a register list in the enter or save instruction.  */
-
-#define FUNCTION_PROLOGUE(FILE, SIZE)     \
-{ register int regno, g_regs_used = 0;				\
-  int used_regs_buf[8], *bufp = used_regs_buf;			\
-  int used_fregs_buf[8], *fbufp = used_fregs_buf;		\
-  extern char call_used_regs[];					\
-  MAIN_FUNCTION_PROLOGUE;					\
-  for (regno = 0; regno < 8; regno++)				\
-    if (regs_ever_live[regno]					\
-	&& ! call_used_regs[regno])				\
-    {								\
-      *bufp++ = regno; g_regs_used++;				\
-    }								\
-  *bufp = -1;							\
-  for (; regno < 16; regno++)					\
-    if (regs_ever_live[regno] && !call_used_regs[regno]) {	\
-      *fbufp++ = regno;						\
-    }								\
-  *fbufp = -1;							\
-  bufp = used_regs_buf;						\
-  if (frame_pointer_needed)					\
-    fprintf (FILE, "\tenter ");					\
-  else if (g_regs_used)						\
-    fprintf (FILE, "\tsave ");					\
-  if (frame_pointer_needed || g_regs_used)			\
-    {								\
-      char mask = 0;						\
-      while (*bufp >= 0)					\
-	mask |= 1 << *bufp++;					\
-      fprintf (FILE, "$0x%x", (int) mask & 0xff);		\
-    }								\
-  if (frame_pointer_needed)					\
-    fprintf (FILE, ",$%d\n", SIZE);				\
-  else if (g_regs_used)						\
-    fprintf (FILE, "\n");					\
-  fbufp = used_fregs_buf;					\
-  while (*fbufp >= 0)						\
-    {								\
-      if ((*fbufp & 1) || (fbufp[0] != fbufp[1] - 1))		\
-	fprintf (FILE, "\tmovf f%d,tos\n", *fbufp++ - 8);	\
-      else							\
-	{							\
-	  fprintf (FILE, "\tmovl f%d,tos\n", fbufp[0] - 8);	\
-	  fbufp += 2;						\
-	}							\
-    }								\
-}
-
-#undef  FUNCTION_EPILOGUE
-
-/* This differs from the one in ns32k.h in printing a bitmask
-   rather than a register list in the exit or restore instruction.  */
-
-#define FUNCTION_EPILOGUE(FILE, SIZE) \
-{ register int regno, g_regs_used = 0, f_regs_used = 0;		\
-  int used_regs_buf[8], *bufp = used_regs_buf;			\
-  int used_fregs_buf[8], *fbufp = used_fregs_buf;		\
-  extern char call_used_regs[];					\
-  *fbufp++ = -2;						\
-  for (regno = 8; regno < 16; regno++)				\
-    if (regs_ever_live[regno] && !call_used_regs[regno]) {	\
-       *fbufp++ = regno; f_regs_used++;				\
-    }								\
-  fbufp--;							\
-  for (regno = 0; regno < 8; regno++)				\
-    if (regs_ever_live[regno]					\
-	&& ! call_used_regs[regno])				\
-    {                                                         	\
-      *bufp++ = regno; g_regs_used++;				\
-    }                                                         	\
-  while (fbufp > used_fregs_buf)				\
-    {								\
-      if ((*fbufp & 1) && fbufp[0] == fbufp[-1] + 1)		\
-	{							\
-	  fprintf (FILE, "\tmovl tos,f%d\n", fbufp[-1] - 8);	\
-	  fbufp -= 2;						\
-	}							\
-      else fprintf (FILE, "\tmovf tos,f%d\n", *fbufp-- - 8);	\
-    }								\
-  if (frame_pointer_needed)					\
-    fprintf (FILE, "\texit ");					\
-  else if (g_regs_used)						\
-    fprintf (FILE, "\trestore ");				\
-  if (g_regs_used || frame_pointer_needed)			\
-    {								\
-      char mask = 0;						\
-								\
-      while (bufp > used_regs_buf)				\
-	{							\
-	  /* Utek assembler takes care of reversing this */	\
-	  mask |= 1 << *--bufp;					\
-	}							\
-      fprintf (FILE, "$0x%x\n", (int) mask & 0xff);		\
-    }								\
-  if (current_function_pops_args)				\
-    fprintf (FILE, "\tret $%d\n", current_function_pops_args);	\
-  else fprintf (FILE, "\tret $0\n"); }
 
 /* UTek assembler needs "ret $0", not "ret 0". */
 #undef  TRANSFER_FROM_TRAMPOLINE