* 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, 67 insertions, 277 deletions

diff --git a/gcc/config/d30v/d30v-protos.h b/gcc/config/d30v/d30v-protos.h
index c395ef7cfff..f681a40fd8b 100644
--- a/gcc/config/d30v/d30v-protos.h
+++ b/gcc/config/d30v/d30v-protos.h
@@ -110,9 +110,7 @@ extern rtx d30v_expand_builtin_va_arg	PARAMS ((tree, tree));
 #endif	/* RTX_CODE */
 #endif	/* TREE_CODE */
 
-extern void d30v_function_prologue	PARAMS ((FILE *, int));
 extern void d30v_expand_prologue	PARAMS ((void));
-extern void d30v_function_epilogue	PARAMS ((FILE *, int));
 extern void d30v_expand_epilogue	PARAMS ((void));
 extern void d30v_function_profiler	PARAMS ((FILE *, int));
 #ifdef RTX_CODE
diff --git a/gcc/config/d30v/d30v.c b/gcc/config/d30v/d30v.c
index c63dd528c1c..e73cad011ff 100644
--- a/gcc/config/d30v/d30v.c
+++ b/gcc/config/d30v/d30v.c
@@ -49,6 +49,8 @@ static void d30v_add_gc_roots PARAMS ((void));
 static void d30v_init_machine_status PARAMS ((struct function *));
 static void d30v_mark_machine_status PARAMS ((struct function *));
 static void d30v_free_machine_status PARAMS ((struct function *));
+static void d30v_output_function_prologue PARAMS ((FILE *, HOST_WIDE_INT));
+static void d30v_output_function_epilogue PARAMS ((FILE *, HOST_WIDE_INT));
 
 /* Define the information needed to generate branch and scc insns.  This is
    stored from the compare operation.  */
@@ -80,6 +82,10 @@ enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER];
 enum reg_class reg_class_from_letter[256];
 
 /* Initialize the GCC target structure.  */
+#undef TARGET_ASM_FUNCTION_PROLOGUE
+#define TARGET_ASM_FUNCTION_PROLOGUE d30v_output_function_prologue
+#undef TARGET_ASM_FUNCTION_EPILOGUE
+#define TARGET_ASM_FUNCTION_EPILOGUE d30v_output_function_epilogue
 
 struct gcc_target target = TARGET_INITIALIZER;
 
@@ -2321,96 +2327,32 @@ d30v_expand_builtin_va_arg(valist, type)
   return ptr_rtx;
 }
 
+/* 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.
 
-/* A C compound statement that outputs the assembler code for entry to a
-   function.  The prologue is responsible for setting up the stack frame,
-   initializing the frame pointer register, saving registers that must be
-   saved, and allocating SIZE additional bytes of storage for the local
-   variables.  SIZE is an integer.  FILE is a stdio stream to which the
-   assembler code should be output.
-
-   The label for the beginning of the function need not be output by this
-   macro.  That has already been done when the macro is run.
-
-   To determine which registers to save, the macro can refer to the array
-   `regs_ever_live': element R is nonzero if hard register R is used anywhere
-   within the function.  This implies the function prologue should save
-   register R, provided it is not one of the call-used registers.
-   (`FUNCTION_EPILOGUE' must likewise use `regs_ever_live'.)
-
-   On machines that have "register windows", the function entry code does not
-   save on the stack the registers that are in the windows, even if they are
-   supposed to be preserved by function calls; instead it takes appropriate
-   steps to "push" the register stack, if any non-call-used registers are used
-   in the function.
-
-   On machines where functions may or may not have frame-pointers, the function
-   entry code must vary accordingly; it must set up the frame pointer if one is
-   wanted, and not otherwise.  To determine whether a frame pointer is in
-   wanted, the macro can refer to the variable `frame_pointer_needed'.  The
-   variable's value will be 1 at run time in a function that needs a frame
-   pointer.  *Note Elimination::.
-
-   The function entry code is responsible for allocating any stack space
-   required for the function.  This stack space consists of the regions listed
-   below.  In most cases, these regions are allocated in the order listed, with
-   the last listed region closest to the top of the stack (the lowest address
-   if `STACK_GROWS_DOWNWARD' is defined, and the highest address if it is not
-   defined).  You can use a different order for a machine if doing so is more
-   convenient or required for compatibility reasons.  Except in cases where
-   required by standard or by a debugger, there is no reason why the stack
-   layout used by GCC need agree with that used by other compilers for a
-   machine.
-
-      * A region of `current_function_pretend_args_size' bytes of
-        uninitialized space just underneath the first argument
-        arriving on the stack.  (This may not be at the very start of
-        the allocated stack region if the calling sequence has pushed
-        anything else since pushing the stack arguments.  But
-        usually, on such machines, nothing else has been pushed yet,
-        because the function prologue itself does all the pushing.)
-        This region is used on machines where an argument may be
-        passed partly in registers and partly in memory, and, in some
-        cases to support the features in `varargs.h' and `stdargs.h'.
-
-      * An area of memory used to save certain registers used by the
-        function.  The size of this area, which may also include
-        space for such things as the return address and pointers to
-        previous stack frames, is machine-specific and usually
-        depends on which registers have been used in the function.
-        Machines with register windows often do not require a save
-        area.
-
-      * A region of at least SIZE bytes, possibly rounded up to an
-        allocation boundary, to contain the local variables of the
-        function.  On some machines, this region and the save area
-        may occur in the opposite order, with the save area closer to
-        the top of the stack.
-
-      * Optionally, when `ACCUMULATE_OUTGOING_ARGS' is defined, a
-        region of `current_function_outgoing_args_size' bytes to be
-        used for outgoing argument lists of the function.  *Note
-        Stack Arguments::.
-
-   Normally, it is necessary for the macros `FUNCTION_PROLOGUE' and
-   `FUNCTION_EPILOGUE' to treat leaf functions specially.  The C variable
-   `leaf_function' is nonzero for such a function.  */
-
-/* For the d30v, move all of the prologue processing into separate insns.  */
-void
-d30v_function_prologue (stream, size)
+   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.  */
+
+static void
+d30v_output_function_prologue (stream, size)
      FILE *stream ATTRIBUTE_UNUSED;
-     int size ATTRIBUTE_UNUSED;
+     HOST_WIDE_INT size ATTRIBUTE_UNUSED;
 {
+  /* For the d30v, move all of the prologue processing into separate
+     insns.  */
 }
 
 
-/* Called after register allocation to add any instructions needed for the
-   prologue.  Using a prologue insn is favored compared to putting all of the
-   instructions in the FUNCTION_PROLOGUE macro, since it allows the scheduler
-   to intermix instructions with the saves of the caller saved registers.  In
-   some cases, it might be necessary to emit a barrier instruction as the last
-   insn to prevent such scheduling.  */
+/* Called after register allocation to add any instructions needed for
+   the prologue.  Using a prologue insn is favored compared to putting
+   all of the instructions in output_function_prologue (), since it
+   allows the scheduler to intermix instructions with the saves of the
+   caller saved registers.  In some cases, it might be necessary to
+   emit a barrier instruction as the last insn to prevent such
+   scheduling.  */
 
 void
 d30v_expand_prologue ()
@@ -2492,60 +2434,33 @@ d30v_expand_prologue ()
 }
 
 
-/* A C compound statement that outputs the assembler code for exit from a
-   function.  The epilogue is responsible for restoring the saved registers and
-   stack pointer to their values when the function was called, and returning
-   control to the caller.  This macro takes the same arguments as the macro
-   `FUNCTION_PROLOGUE', and the registers to restore are determined from
-   `regs_ever_live' and `CALL_USED_REGISTERS' in the same way.
-
-   On some machines, there is a single instruction that does all the work of
-   returning from the function.  On these machines, give that instruction the
-   name `return' and do not define the macro `FUNCTION_EPILOGUE' at all.
-
-   Do not define a pattern named `return' if you want the `FUNCTION_EPILOGUE'
-   to be used.  If you want the target switches to control whether return
-   instructions or epilogues are used, define a `return' pattern with a
-   validity condition that tests the target switches appropriately.  If the
-   `return' pattern's validity condition is false, epilogues will be used.
-
-   On machines where functions may or may not have frame-pointers, the function
-   exit code must vary accordingly.  Sometimes the code for these two cases is
-   completely different.  To determine whether a frame pointer is wanted, the
-   macro can refer to the variable `frame_pointer_needed'.  The variable's
-   value will be 1 when compiling a function that needs a frame pointer.
-
-   Normally, `FUNCTION_PROLOGUE' and `FUNCTION_EPILOGUE' must treat leaf
-   functions specially.  The C variable `leaf_function' is nonzero for such a
-   function.  *Note Leaf Functions::.
-
-   On some machines, some functions pop their arguments on exit while others
-   leave that for the caller to do.  For example, the 68020 when given `-mrtd'
-   pops arguments in functions that take a fixed number of arguments.
-
-   Your definition of the macro `RETURN_POPS_ARGS' decides which functions pop
-   their own arguments.  `FUNCTION_EPILOGUE' needs to know what was decided.
-   The variable that is called `current_function_pops_args' is the number of
-   bytes of its arguments that a function should pop.  *Note Scalar Return::.  */
-
-/* For the d30v, move all processing to be as insns, but do any cleanup
-   here, since it is done after handling all of the insns.  */
-void
-d30v_function_epilogue (stream, size)
+/* This function generates the assembly code for function exit.
+   Args are as for output_function_prologue ().
+
+   The function epilogue should not depend on the current stack
+   pointer!  It should use the frame pointer only.  This is mandatory
+   because of alloca; we also take advantage of it to omit stack
+   adjustments before returning.  */
+
+static void
+d30v_output_function_epilogue (stream, size)
      FILE *stream ATTRIBUTE_UNUSED;
-     int size ATTRIBUTE_UNUSED;
+     HOST_WIDE_INT size ATTRIBUTE_UNUSED;
 {
+  /* For the d30v, move all processing to be as insns, but do any
+     cleanup here, since it is done after handling all of the insns.  */
   d30v_stack_cache = (d30v_stack_t *)0;	/* reset stack cache */
 }
 
 
 
-/* Called after register allocation to add any instructions needed for the
-   epilogue.  Using a epilogue insn is favored compared to putting all of the
-   instructions in the FUNCTION_PROLOGUE macro, since it allows the scheduler
-   to intermix instructions with the saves of the caller saved registers.  In
-   some cases, it might be necessary to emit a barrier instruction as the last
-   insn to prevent such scheduling.  */
+/* Called after register allocation to add any instructions needed for
+   the epilogue.  Using a epilogue insn is favored compared to putting
+   all of the instructions in output_function_prologue(), since it
+   allows the scheduler to intermix instructions with the saves of the
+   caller saved registers.  In some cases, it might be necessary to
+   emit a barrier instruction as the last insn to prevent such
+   scheduling.  */
 
 void
 d30v_expand_epilogue ()
diff --git a/gcc/config/d30v/d30v.h b/gcc/config/d30v/d30v.h
index 2b08b117c89..3565cc71a4c 100644
--- a/gcc/config/d30v/d30v.h
+++ b/gcc/config/d30v/d30v.h
@@ -2656,93 +2656,6 @@ typedef int CUMULATIVE_ARGS;
 /* #define CALLER_SAVE_PROFITABLE(REFS, CALLS) */
 
 
-/* Function Entry and Exit */
-
-/* A C compound statement that outputs the assembler code for entry to a
-   function.  The prologue is responsible for setting up the stack frame,
-   initializing the frame pointer register, saving registers that must be
-   saved, and allocating SIZE additional bytes of storage for the local
-   variables.  SIZE is an integer.  FILE is a stdio stream to which the
-   assembler code should be output.
-
-   The label for the beginning of the function need not be output by this
-   macro.  That has already been done when the macro is run.
-
-   To determine which registers to save, the macro can refer to the array
-   `regs_ever_live': element R is nonzero if hard register R is used anywhere
-   within the function.  This implies the function prologue should save
-   register R, provided it is not one of the call-used registers.
-   (`FUNCTION_EPILOGUE' must likewise use `regs_ever_live'.)
-
-   On machines that have "register windows", the function entry code does not
-   save on the stack the registers that are in the windows, even if they are
-   supposed to be preserved by function calls; instead it takes appropriate
-   steps to "push" the register stack, if any non-call-used registers are used
-   in the function.
-
-   On machines where functions may or may not have frame-pointers, the function
-   entry code must vary accordingly; it must set up the frame pointer if one is
-   wanted, and not otherwise.  To determine whether a frame pointer is in
-   wanted, the macro can refer to the variable `frame_pointer_needed'.  The
-   variable's value will be 1 at run time in a function that needs a frame
-   pointer.  *Note Elimination::.
-
-   The function entry code is responsible for allocating any stack space
-   required for the function.  This stack space consists of the regions listed
-   below.  In most cases, these regions are allocated in the order listed, with
-   the last listed region closest to the top of the stack (the lowest address
-   if `STACK_GROWS_DOWNWARD' is defined, and the highest address if it is not
-   defined).  You can use a different order for a machine if doing so is more
-   convenient or required for compatibility reasons.  Except in cases where
-   required by standard or by a debugger, there is no reason why the stack
-   layout used by GCC need agree with that used by other compilers for a
-   machine.
-
-      * A region of `current_function_pretend_args_size' bytes of
-        uninitialized space just underneath the first argument
-        arriving on the stack.  (This may not be at the very start of
-        the allocated stack region if the calling sequence has pushed
-        anything else since pushing the stack arguments.  But
-        usually, on such machines, nothing else has been pushed yet,
-        because the function prologue itself does all the pushing.)
-        This region is used on machines where an argument may be
-        passed partly in registers and partly in memory, and, in some
-        cases to support the features in `varargs.h' and `stdargs.h'.
-
-      * An area of memory used to save certain registers used by the
-        function.  The size of this area, which may also include
-        space for such things as the return address and pointers to
-        previous stack frames, is machine-specific and usually
-        depends on which registers have been used in the function.
-        Machines with register windows often do not require a save
-        area.
-
-      * A region of at least SIZE bytes, possibly rounded up to an
-        allocation boundary, to contain the local variables of the
-        function.  On some machines, this region and the save area
-        may occur in the opposite order, with the save area closer to
-        the top of the stack.
-
-      * Optionally, when `ACCUMULATE_OUTGOING_ARGS' is defined, a
-        region of `current_function_outgoing_args_size' bytes to be
-        used for outgoing argument lists of the function.  *Note
-        Stack Arguments::.
-
-   Normally, it is necessary for the macros `FUNCTION_PROLOGUE' and
-   `FUNCTION_EPILOGUE' to treat leaf functions specially.  The C variable
-   `leaf_function' is nonzero for such a function.  */
-
-#define FUNCTION_PROLOGUE(FILE, SIZE) d30v_function_prologue (FILE, SIZE)
-
-/* Define this macro as a C expression that is nonzero if the return
-   instruction or the function epilogue ignores the value of the stack pointer;
-   in other words, if it is safe to delete an instruction to adjust the stack
-   pointer before a return from the function.
-
-   Note that this macro's value is relevant only for functions for which frame
-   pointers are maintained.  It is never safe to delete a final stack
-   adjustment in a function that has no frame pointer, and the compiler knows
-   this regardless of `EXIT_IGNORE_STACK'.  */
 /* #define EXIT_IGNORE_STACK */
 
 /* Define this macro as a C expression that is nonzero for registers
@@ -2751,44 +2664,6 @@ typedef int CUMULATIVE_ARGS;
    needed.  */
 #define EPILOGUE_USES(REGNO)  ((REGNO) == GPR_LINK)
 
-/* A C compound statement that outputs the assembler code for exit from a
-   function.  The epilogue is responsible for restoring the saved registers and
-   stack pointer to their values when the function was called, and returning
-   control to the caller.  This macro takes the same arguments as the macro
-   `FUNCTION_PROLOGUE', and the registers to restore are determined from
-   `regs_ever_live' and `CALL_USED_REGISTERS' in the same way.
-
-   On some machines, there is a single instruction that does all the work of
-   returning from the function.  On these machines, give that instruction the
-   name `return' and do not define the macro `FUNCTION_EPILOGUE' at all.
-
-   Do not define a pattern named `return' if you want the `FUNCTION_EPILOGUE'
-   to be used.  If you want the target switches to control whether return
-   instructions or epilogues are used, define a `return' pattern with a
-   validity condition that tests the target switches appropriately.  If the
-   `return' pattern's validity condition is false, epilogues will be used.
-
-   On machines where functions may or may not have frame-pointers, the function
-   exit code must vary accordingly.  Sometimes the code for these two cases is
-   completely different.  To determine whether a frame pointer is wanted, the
-   macro can refer to the variable `frame_pointer_needed'.  The variable's
-   value will be 1 when compiling a function that needs a frame pointer.
-
-   Normally, `FUNCTION_PROLOGUE' and `FUNCTION_EPILOGUE' must treat leaf
-   functions specially.  The C variable `leaf_function' is nonzero for such a
-   function.  *Note Leaf Functions::.
-
-   On some machines, some functions pop their arguments on exit while others
-   leave that for the caller to do.  For example, the 68020 when given `-mrtd'
-   pops arguments in functions that take a fixed number of arguments.
-
-   Your definition of the macro `RETURN_POPS_ARGS' decides which functions pop
-   their own arguments.  `FUNCTION_EPILOGUE' needs to know what was decided.
-   The variable that is called `current_function_pops_args' is the number of
-   bytes of its arguments that a function should pop.  *Note Scalar Return::.  */
-
-#define FUNCTION_EPILOGUE(FILE, SIZE) d30v_function_epilogue (FILE, SIZE)
-
 /* Define this macro if the function epilogue contains delay slots to which
    instructions from the rest of the function can be "moved".  The definition
    should be a C expression whose value is an integer representing the number
@@ -2809,8 +2684,8 @@ typedef int CUMULATIVE_ARGS;
    The insns accepted to fill the epilogue delay slots are put in an
    RTL list made with `insn_list' objects, stored in the variable
    `current_function_epilogue_delay_list'.  The insn for the first
-   delay slot comes first in the list.  Your definition of the macro
-   `FUNCTION_EPILOGUE' should fill the delay slots by outputting the
+   delay slot comes first in the list.  Your definition of the function
+   output_function_epilogue() should fill the delay slots by outputting the
    insns in this list, usually by calling `final_scan_insn'.
 
    You need not define this macro if you did not define
@@ -2833,10 +2708,10 @@ typedef int CUMULATIVE_ARGS;
    the return address.  Hence returning from FUNCTION will return to whoever
    called the current `thunk'.
 
-   The effect must be as if FUNCTION had been called directly with the adjusted
-   first argument.  This macro is responsible for emitting all of the code for
-   a thunk function; `FUNCTION_PROLOGUE' and `FUNCTION_EPILOGUE' are not
-   invoked.
+   The effect must be as if FUNCTION had been called directly with the
+   adjusted first argument.  This macro is responsible for emitting
+   all of the code for a thunk function; output_function_prologue()
+   and output_function_epilogue() are not invoked.
 
    The THUNK_FNDECL is redundant.  (DELTA and FUNCTION have already been
    extracted from it.)  It might possibly be useful on some targets, but
@@ -2975,8 +2850,8 @@ typedef struct machine_function
    code to call function `__bb_trace_ret'.  The assembler code should
    only be output if the global compile flag `profile_block_flag' ==
    2.  This macro has to be used at every place where code for
-   returning from a function is generated (e.g. `FUNCTION_EPILOGUE').
-   Although you have to write the definition of `FUNCTION_EPILOGUE'
+   returning from a function is generated (e.g. output_function_epilogue()).
+   Although you have to write the definition of output_function_epilogue()
    as well, you have to define this macro to tell the compiler, that
    the proper call to `__bb_trace_ret' is produced.  */
 /* #define FUNCTION_BLOCK_PROFILER_EXIT(FILE) */
@@ -2987,17 +2862,18 @@ typedef struct machine_function
    the assembler code can be concatenated with the string ID, to obtain a
    unique lable name.
 
-   Registers or condition codes clobbered by `FUNCTION_PROLOGUE' or
-   `FUNCTION_EPILOGUE' must be saved in the macros `FUNCTION_BLOCK_PROFILER',
-   `FUNCTION_BLOCK_PROFILER_EXIT' and `BLOCK_PROFILER' prior calling
-   `__bb_init_trace_func', `__bb_trace_ret' and `__bb_trace_func' respectively.  */
+   Registers or condition codes clobbered by output_function_prologue()
+   or output_function_epilogue() must be saved in the macros
+   `FUNCTION_BLOCK_PROFILER', FUNCTION_BLOCK_PROFILER_EXIT' and
+   `BLOCK_PROFILER' prior calling `__bb_init_trace_func', `__bb_trace_ret'
+   and `__bb_trace_func' respectively.  */
 /* #define MACHINE_STATE_SAVE(ID) */
 
 /* A C statement or compound statement to restore all registers, including
    condition codes, saved by `MACHINE_STATE_SAVE'.
 
-   Registers or condition codes clobbered by `FUNCTION_PROLOGUE' or
-   `FUNCTION_EPILOGUE' must be restored in the macros
+   Registers or condition codes clobbered by output_function_prologue()
+   or output_function_epilogue() must be restored in the macros
    `FUNCTION_BLOCK_PROFILER', `FUNCTION_BLOCK_PROFILER_EXIT' and
    `BLOCK_PROFILER' after calling `__bb_init_trace_func', `__bb_trace_ret' and
    `__bb_trace_func' respectively.  */
@@ -3131,7 +3007,8 @@ typedef struct machine_function
    stack slot.  This default is right for most machines.  The exceptions are
    machines where it is impossible to execute instructions in the stack area.
    On such machines, you may have to implement a separate stack, using this
-   macro in conjunction with `FUNCTION_PROLOGUE' and `FUNCTION_EPILOGUE'.
+   macro in conjunction with output_function_prologue () and
+   output_function_epilogue ().
 
    FP points to a data structure, a `struct function', which describes the
    compilation status of the immediate containing function of the function
@@ -5399,8 +5276,8 @@ fprintf (STREAM, "\t.word .L%d\n", VALUE)
    To support optional call frame debugging information, you must also define
    `INCOMING_RETURN_ADDR_RTX' and either set `RTX_FRAME_RELATED_P' on the
    prologue insns if you use RTL for the prologue, or call `dwarf2out_def_cfa'
-   and `dwarf2out_reg_save' as appropriate from `FUNCTION_PROLOGUE' if you
-   don't.
+   and `dwarf2out_reg_save' as appropriate from output_function_prologue() if
+   you don't.
 
    Defined in svr4.h.  */
 /* #define DWARF2_DEBUGGING_INFO */
diff --git a/gcc/config/d30v/d30v.md b/gcc/config/d30v/d30v.md
index 5892a1aff8f..4f62f3c64d4 100644
--- a/gcc/config/d30v/d30v.md
+++ b/gcc/config/d30v/d30v.md
@@ -2934,7 +2934,7 @@
 
 ;; Called after register allocation to add any instructions needed for the
 ;; prologue.  Using a prologue insn is favored compared to putting all of the
-;; instructions in the FUNCTION_PROLOGUE macro, since it allows the scheduler
+;; instructions in output_function_prologue (), since it allows the scheduler
 ;; to intermix instructions with the saves of the caller saved registers.  In
 ;; some cases, it might be necessary to emit a barrier instruction as the last
 ;; insn to prevent such scheduling.
@@ -2950,7 +2950,7 @@
 
 ;; Called after register allocation to add any instructions needed for the
 ;; epilogue.  Using a epilogue insn is favored compared to putting all of the
-;; instructions in the FUNCTION_PROLOGUE macro, since it allows the scheduler
+;; instructions in output_function_epilogue (), since it allows the scheduler
 ;; to intermix instructions with the saves of the caller saved registers.  In
 ;; some cases, it might be necessary to emit a barrier instruction as the last
 ;; insn to prevent such scheduling.