(gcc.info) Scalar Return

 
 How Scalar Function Values Are Returned
 ---------------------------------------
 
    This section discusses the macros that control returning scalars as
 values--values that can fit in registers.
 
 `TRADITIONAL_RETURN_FLOAT'
      Define this macro if `-traditional' should not cause functions
      declared to return `float' to convert the value to `double'.
 
 `FUNCTION_VALUE (VALTYPE, FUNC)'
      A C expression to create an RTX representing the place where a
      function returns a value of data type VALTYPE.  VALTYPE is a tree
      node representing a data type.  Write `TYPE_MODE (VALTYPE)' to get
      the machine mode used to represent that type.  On many machines,
      only the mode is relevant.  (Actually, on most machines, scalar
      values are returned in the same place regardless of mode).
 
      The value of the expression is usually a `reg' RTX for the hard
      register where the return value is stored.  The value can also be a
      `parallel' RTX, if the return value is in multiple places.  See
      `FUNCTION_ARG' for an explanation of the `parallel' form.
 
      If `PROMOTE_FUNCTION_RETURN' is defined, you must apply the same
      promotion rules specified in `PROMOTE_MODE' if VALTYPE is a scalar
      type.
 
      If the precise function being called is known, FUNC is a tree node
      (`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer.  This
      makes it possible to use a different value-returning convention
      for specific functions when all their calls are known.
 
      `FUNCTION_VALUE' is not used for return vales with aggregate data
      types, because these are returned in another way.  See
      `STRUCT_VALUE_REGNUM' and related macros, below.
 
 `FUNCTION_OUTGOING_VALUE (VALTYPE, FUNC)'
      Define this macro if the target machine has "register windows" so
      that the register in which a function returns its value is not the
      same as the one in which the caller sees the value.
 
      For such machines, `FUNCTION_VALUE' computes the register in which
      the caller will see the value.  `FUNCTION_OUTGOING_VALUE' should be
      defined in a similar fashion to tell the function where to put the
      value.
 
      If `FUNCTION_OUTGOING_VALUE' is not defined, `FUNCTION_VALUE'
      serves both purposes.
 
      `FUNCTION_OUTGOING_VALUE' is not used for return vales with
      aggregate data types, because these are returned in another way.
      See `STRUCT_VALUE_REGNUM' and related macros, below.
 
 `LIBCALL_VALUE (MODE)'
      A C expression to create an RTX representing the place where a
      library function returns a value of mode MODE.  If the precise
      function being called is known, FUNC is a tree node
      (`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer.  This
      makes it possible to use a different value-returning convention
      for specific functions when all their calls are known.
 
      Note that "library function" in this context means a compiler
      support routine, used to perform arithmetic, whose name is known
      specially by the compiler and was not mentioned in the C code being
      compiled.
 
      The definition of `LIBRARY_VALUE' need not be concerned aggregate
      data types, because none of the library functions returns such
      types.
 
 `FUNCTION_VALUE_REGNO_P (REGNO)'
      A C expression that is nonzero if REGNO is the number of a hard
      register in which the values of called function may come back.
 
      A register whose use for returning values is limited to serving as
      the second of a pair (for a value of type `double', say) need not
      be recognized by this macro.  So for most machines, this definition
      suffices:
 
           #define FUNCTION_VALUE_REGNO_P(N) ((N) == 0)
 
      If the machine has register windows, so that the caller and the
      called function use different registers for the return value, this
      macro should recognize only the caller's register numbers.
 
 `APPLY_RESULT_SIZE'
      Define this macro if `untyped_call' and `untyped_return' need more
      space than is implied by `FUNCTION_VALUE_REGNO_P' for saving and
      restoring an arbitrary return value.
Info Catalog
(gcc.info) Register Arguments
(gcc.info) Stack and Calling
(gcc.info) Aggregate Return
automatically generated byinfo2html