GNU Info

(gcc-295.info)Scalar Return

---

Next: Aggregate Return Prev: Register Arguments Up: Stack and Calling

---

Enter node , (file) or (file)node

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.