Update TARGET_FUNCTION_INCOMING_ARG documentation

On x86, interrupt handlers are only called by processors which push
interrupt data onto stack at the address where the normal return address
is.  Since interrupt handlers must access interrupt data via pointers so
that they can update interrupt data, the pointer argument is passed as
"argument pointer - word".

TARGET_FUNCTION_INCOMING_ARG defines how callee sees its argument.
Normally it returns REG, NULL, or CONST_INT.  This patch adds arbitrary
address computation based on hard register, which can be forced into a
register, to the list.

When copying an incoming argument onto stack, assign_parm_setup_stack
has:

if (argument in memory)
  copy argument in memory to stack
else
  move argument to stack

Since an arbitrary address computation may be passed as an argument, we
change it to:

if (argument in memory)
  copy argument in memory to stack
else
  {
    if (argument isn't in register)
      force argument into a register
    move argument to stack
  }

	* function.c (assign_parm_setup_stack): Force source into a
	register if needed.
	* target.def (function_incoming_arg): Update documentation to
	allow arbitrary address computation based on hard register.
	* doc/tm.texi: Regenerated.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d4af6afc87e3e1d1b78ad3d2ce2e92b8a6abd56e..770df0732f8256d5555c2717a24622a888e07a7a 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2016-06-02  H.J. Lu  <hongjiu.lu@intel.com>
+           Julia Koval  <julia.koval@intel.com>
+
+       * function.c (assign_parm_setup_stack): Force source into a
+       register if needed.
+       * target.def (function_incoming_arg): Update documentation to
+       allow arbitrary address computation based on hard register.
+       * doc/tm.texi: Regenerated.
+
 2016-06-02  Martin Liska  <mliska@suse.cz>
 
        * predict.c (combine_predictions_for_bb): Fix first match in

diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index 8c7f2a124febe75792f6a2b4eb44a44b1c29c47d..a343e913edaead6a46ce1ba2e81d1702a0ef9dd0 100644 (file)
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -3938,17 +3938,21 @@ documentation.
 @end deftypefn
 
 @deftypefn {Target Hook} rtx TARGET_FUNCTION_INCOMING_ARG (cumulative_args_t @var{ca}, machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
-Define this hook if the target machine has ``register windows'', so
-that the register in which a function sees an arguments is not
-necessarily the same as the one in which the caller passed the
-argument.
+Define this hook if the caller and callee on the target have different
+views of where arguments are passed.  Also define this hook if there are
+functions that are never directly called, but are invoked by the hardware
+and which have nonstandard calling conventions.
 
-For such machines, @code{TARGET_FUNCTION_ARG} computes the register in
+In this case @code{TARGET_FUNCTION_ARG} computes the register in
 which the caller passes the value, and
 @code{TARGET_FUNCTION_INCOMING_ARG} should be defined in a similar
 fashion to tell the function being called where the arguments will
 arrive.
 
+@code{TARGET_FUNCTION_INCOMING_ARG} can also return arbitrary address
+computation using hard register, which can be forced into a register,
+so that it can be used to pass special arguments.
+
 If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined,
 @code{TARGET_FUNCTION_ARG} serves both purposes.
 @end deftypefn

diff --git a/gcc/function.c b/gcc/function.c
index 726c20ca017e0e04c304b22b3cfa84737cabc72e..c15d47d21033a01ae0ebbf69d78ad5c2fb31d494 100644 (file)
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -3466,7 +3466,11 @@ assign_parm_setup_stack (struct assign_parm_data_all *all, tree parm,
                           BLOCK_OP_NORMAL);
        }
       else
-       emit_move_insn (dest, src);
+       {
+         if (!REG_P (src))
+           src = force_reg (GET_MODE (src), src);
+         emit_move_insn (dest, src);
+       }
     }
 
   if (to_conversion)

diff --git a/gcc/target.def b/gcc/target.def
index 6392e73b1977addbf123754443a8bc318a55129a..5285e57345cc7191054dd1e52959425fc23b67d8 100644 (file)
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -4468,21 +4468,23 @@ a register.",
        bool named),
  default_function_arg)
 
-/* Likewise, but for machines with register windows.  Return the
-   location where the argument will appear to the callee.  */
 DEFHOOK
 (function_incoming_arg,
- "Define this hook if the target machine has ``register windows'', so\n\
-that the register in which a function sees an arguments is not\n\
-necessarily the same as the one in which the caller passed the\n\
-argument.\n\
+ "Define this hook if the caller and callee on the target have different\n\
+views of where arguments are passed.  Also define this hook if there are\n\
+functions that are never directly called, but are invoked by the hardware\n\
+and which have nonstandard calling conventions.\n\
 \n\
-For such machines, @code{TARGET_FUNCTION_ARG} computes the register in\n\
+In this case @code{TARGET_FUNCTION_ARG} computes the register in\n\
 which the caller passes the value, and\n\
 @code{TARGET_FUNCTION_INCOMING_ARG} should be defined in a similar\n\
 fashion to tell the function being called where the arguments will\n\
 arrive.\n\
 \n\
+@code{TARGET_FUNCTION_INCOMING_ARG} can also return arbitrary address\n\
+computation using hard register, which can be forced into a register,\n\
+so that it can be used to pass special arguments.\n\
+\n\
 If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined,\n\
 @code{TARGET_FUNCTION_ARG} serves both purposes.",
  rtx, (cumulative_args_t ca, machine_mode mode, const_tree type,