gccint: Addressing Modes
1
1 18.13 Addressing Modes
1 ======================
1
1 This is about addressing modes.
1
1 -- Macro: HAVE_PRE_INCREMENT
1 -- Macro: HAVE_PRE_DECREMENT
1 -- Macro: HAVE_POST_INCREMENT
1 -- Macro: HAVE_POST_DECREMENT
1 A C expression that is nonzero if the machine supports
1 pre-increment, pre-decrement, post-increment, or post-decrement
1 addressing respectively.
1
1 -- Macro: HAVE_PRE_MODIFY_DISP
1 -- Macro: HAVE_POST_MODIFY_DISP
1 A C expression that is nonzero if the machine supports pre- or
1 post-address side-effect generation involving constants other than
1 the size of the memory operand.
1
1 -- Macro: HAVE_PRE_MODIFY_REG
1 -- Macro: HAVE_POST_MODIFY_REG
1 A C expression that is nonzero if the machine supports pre- or
1 post-address side-effect generation involving a register
1 displacement.
1
1 -- Macro: CONSTANT_ADDRESS_P (X)
1 A C expression that is 1 if the RTX X is a constant which is a
1 valid address. On most machines the default definition of
1 '(CONSTANT_P (X) && GET_CODE (X) != CONST_DOUBLE)' is acceptable,
1 but a few machines are more restrictive as to which constant
1 addresses are supported.
1
1 -- Macro: CONSTANT_P (X)
1 'CONSTANT_P', which is defined by target-independent code, accepts
1 integer-values expressions whose values are not explicitly known,
1 such as 'symbol_ref', 'label_ref', and 'high' expressions and
1 'const' arithmetic expressions, in addition to 'const_int' and
1 'const_double' expressions.
1
1 -- Macro: MAX_REGS_PER_ADDRESS
1 A number, the maximum number of registers that can appear in a
1 valid memory address. Note that it is up to you to specify a value
1 equal to the maximum number that 'TARGET_LEGITIMATE_ADDRESS_P'
1 would ever accept.
1
1 -- Target Hook: bool TARGET_LEGITIMATE_ADDRESS_P (machine_mode MODE,
1 rtx X, bool STRICT)
1 A function that returns whether X (an RTX) is a legitimate memory
1 address on the target machine for a memory operand of mode MODE.
1
1 Legitimate addresses are defined in two variants: a strict variant
1 and a non-strict one. The STRICT parameter chooses which variant
1 is desired by the caller.
1
1 The strict variant is used in the reload pass. It must be defined
1 so that any pseudo-register that has not been allocated a hard
1 register is considered a memory reference. This is because in
1 contexts where some kind of register is required, a pseudo-register
1 with no hard register must be rejected. For non-hard registers,
1 the strict variant should look up the 'reg_renumber' array; it
1 should then proceed using the hard register number in the array, or
1 treat the pseudo as a memory reference if the array holds '-1'.
1
1 The non-strict variant is used in other passes. It must be defined
1 to accept all pseudo-registers in every context where some kind of
1 register is required.
1
1 Normally, constant addresses which are the sum of a 'symbol_ref'
1 and an integer are stored inside a 'const' RTX to mark them as
1 constant. Therefore, there is no need to recognize such sums
1 specifically as legitimate addresses. Normally you would simply
1 recognize any 'const' as legitimate.
1
1 Usually 'PRINT_OPERAND_ADDRESS' is not prepared to handle constant
1 sums that are not marked with 'const'. It assumes that a naked
1 'plus' indicates indexing. If so, then you _must_ reject such
1 naked constant sums as illegitimate addresses, so that none of them
1 will be given to 'PRINT_OPERAND_ADDRESS'.
1
1 On some machines, whether a symbolic address is legitimate depends
1 on the section that the address refers to. On these machines,
1 define the target hook 'TARGET_ENCODE_SECTION_INFO' to store the
1 information into the 'symbol_ref', and then check for it here.
1 When you see a 'const', you will have to look inside it to find the
11 'symbol_ref' in order to determine the section. ⇒Assembler
Format.
1
1 Some ports are still using a deprecated legacy substitute for this
1 hook, the 'GO_IF_LEGITIMATE_ADDRESS' macro. This macro has this
1 syntax:
1
1 #define GO_IF_LEGITIMATE_ADDRESS (MODE, X, LABEL)
1
1 and should 'goto LABEL' if the address X is a valid address on the
1 target machine for a memory operand of mode MODE.
1
1 Compiler source files that want to use the strict variant of this
1 macro define the macro 'REG_OK_STRICT'. You should use an '#ifdef
1 REG_OK_STRICT' conditional to define the strict variant in that
1 case and the non-strict variant otherwise.
1
1 Using the hook is usually simpler because it limits the number of
1 files that are recompiled when changes are made.
1
1 -- Macro: TARGET_MEM_CONSTRAINT
1 A single character to be used instead of the default ''m''
1 character for general memory addresses. This defines the
1 constraint letter which matches the memory addresses accepted by
1 'TARGET_LEGITIMATE_ADDRESS_P'. Define this macro if you want to
1 support new address formats in your back end without changing the
1 semantics of the ''m'' constraint. This is necessary in order to
1 preserve functionality of inline assembly constructs using the
1 ''m'' constraint.
1
1 -- Macro: FIND_BASE_TERM (X)
1 A C expression to determine the base term of address X, or to
1 provide a simplified version of X from which 'alias.c' can easily
1 find the base term. This macro is used in only two places:
1 'find_base_value' and 'find_base_term' in 'alias.c'.
1
1 It is always safe for this macro to not be defined. It exists so
1 that alias analysis can understand machine-dependent addresses.
1
1 The typical use of this macro is to handle addresses containing a
1 label_ref or symbol_ref within an UNSPEC.
1
1 -- Target Hook: rtx TARGET_LEGITIMIZE_ADDRESS (rtx X, rtx OLDX,
1 machine_mode MODE)
1 This hook is given an invalid memory address X for an operand of
1 mode MODE and should try to return a valid memory address.
1
1 X will always be the result of a call to 'break_out_memory_refs',
1 and OLDX will be the operand that was given to that function to
1 produce X.
1
1 The code of the hook should not alter the substructure of X. If it
1 transforms X into a more legitimate form, it should return the new
1 X.
1
1 It is not necessary for this hook to come up with a legitimate
11 address, with the exception of native TLS addresses (⇒Emulated
TLS). The compiler has standard ways of doing so in all cases.
1 In fact, if the target supports only emulated TLS, it is safe to
1 omit this hook or make it return X if it cannot find a valid way to
1 legitimize the address. But often a machine-dependent strategy can
1 generate better code.
1
1 -- Macro: LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS,
1 WIN)
1 A C compound statement that attempts to replace X, which is an
1 address that needs reloading, with a valid memory address for an
1 operand of mode MODE. WIN will be a C statement label elsewhere in
1 the code. It is not necessary to define this macro, but it might
1 be useful for performance reasons.
1
1 For example, on the i386, it is sometimes possible to use a single
1 reload register instead of two by reloading a sum of two pseudo
1 registers into a register. On the other hand, for number of RISC
1 processors offsets are limited so that often an intermediate
1 address needs to be generated in order to address a stack slot. By
1 defining 'LEGITIMIZE_RELOAD_ADDRESS' appropriately, the
1 intermediate addresses generated for adjacent some stack slots can
1 be made identical, and thus be shared.
1
1 _Note_: This macro should be used with caution. It is necessary to
1 know something of how reload works in order to effectively use
1 this, and it is quite easy to produce macros that build in too much
1 knowledge of reload internals.
1
1 _Note_: This macro must be able to reload an address created by a
1 previous invocation of this macro. If it fails to handle such
1 addresses then the compiler may generate incorrect code or abort.
1
1 The macro definition should use 'push_reload' to indicate parts
1 that need reloading; OPNUM, TYPE and IND_LEVELS are usually
1 suitable to be passed unaltered to 'push_reload'.
1
1 The code generated by this macro must not alter the substructure of
1 X. If it transforms X into a more legitimate form, it should
1 assign X (which will always be a C variable) a new value. This
1 also applies to parts that you change indirectly by calling
1 'push_reload'.
1
1 The macro definition may use 'strict_memory_address_p' to test if
1 the address has become legitimate.
1
1 If you want to change only a part of X, one standard way of doing
1 this is to use 'copy_rtx'. Note, however, that it unshares only a
1 single level of rtl. Thus, if the part to be changed is not at the
1 top level, you'll need to replace first the top level. It is not
1 necessary for this macro to come up with a legitimate address; but
1 often a machine-dependent strategy can generate better code.
1
1 -- Target Hook: bool TARGET_MODE_DEPENDENT_ADDRESS_P (const_rtx ADDR,
1 addr_space_t ADDRSPACE)
1 This hook returns 'true' if memory address ADDR in address space
1 ADDRSPACE can have different meanings depending on the machine mode
1 of the memory reference it is used for or if the address is valid
1 for some modes but not others.
1
1 Autoincrement and autodecrement addresses typically have
1 mode-dependent effects because the amount of the increment or
1 decrement is the size of the operand being addressed. Some
1 machines have other mode-dependent addresses. Many RISC machines
1 have no mode-dependent addresses.
1
1 You may assume that ADDR is a valid address for the machine.
1
1 The default version of this hook returns 'false'.
1
1 -- Target Hook: bool TARGET_LEGITIMATE_CONSTANT_P (machine_mode MODE,
1 rtx X)
1 This hook returns true if X is a legitimate constant for a
1 MODE-mode immediate operand on the target machine. You can assume
1 that X satisfies 'CONSTANT_P', so you need not check this.
1
1 The default definition returns true.
1
1 -- Target Hook: rtx TARGET_DELEGITIMIZE_ADDRESS (rtx X)
1 This hook is used to undo the possibly obfuscating effects of the
1 'LEGITIMIZE_ADDRESS' and 'LEGITIMIZE_RELOAD_ADDRESS' target macros.
1 Some backend implementations of these macros wrap symbol references
1 inside an 'UNSPEC' rtx to represent PIC or similar addressing
1 modes. This target hook allows GCC's optimizers to understand the
1 semantics of these opaque 'UNSPEC's by converting them back into
1 their original form.
1
1 -- Target Hook: bool TARGET_CONST_NOT_OK_FOR_DEBUG_P (rtx X)
1 This hook should return true if X should not be emitted into debug
1 sections.
1
1 -- Target Hook: bool TARGET_CANNOT_FORCE_CONST_MEM (machine_mode MODE,
1 rtx X)
1 This hook should return true if X is of a form that cannot (or
1 should not) be spilled to the constant pool. MODE is the mode of
1 X.
1
1 The default version of this hook returns false.
1
1 The primary reason to define this hook is to prevent reload from
1 deciding that a non-legitimate constant would be better reloaded
1 from the constant pool instead of spilling and reloading a register
1 holding the constant. This restriction is often true of addresses
1 of TLS symbols for various targets.
1
1 -- Target Hook: bool TARGET_USE_BLOCKS_FOR_CONSTANT_P (machine_mode
1 MODE, const_rtx X)
1 This hook should return true if pool entries for constant X can be
1 placed in an 'object_block' structure. MODE is the mode of X.
1
1 The default version returns false for all constants.
1
1 -- Target Hook: bool TARGET_USE_BLOCKS_FOR_DECL_P (const_tree DECL)
1 This hook should return true if pool entries for DECL should be
1 placed in an 'object_block' structure.
1
1 The default version returns true for all decls.
1
1 -- Target Hook: tree TARGET_BUILTIN_RECIPROCAL (tree FNDECL)
1 This hook should return the DECL of a function that implements the
1 reciprocal of the machine-specific builtin function FNDECL, or
1 'NULL_TREE' if such a function is not available.
1
1 -- Target Hook: tree TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD (void)
1 This hook should return the DECL of a function F that given an
1 address ADDR as an argument returns a mask M that can be used to
1 extract from two vectors the relevant data that resides in ADDR in
1 case ADDR is not properly aligned.
1
1 The autovectorizer, when vectorizing a load operation from an
1 address ADDR that may be unaligned, will generate two vector loads
1 from the two aligned addresses around ADDR. It then generates a
1 'REALIGN_LOAD' operation to extract the relevant data from the two
1 loaded vectors. The first two arguments to 'REALIGN_LOAD', V1 and
1 V2, are the two vectors, each of size VS, and the third argument,
1 OFF, defines how the data will be extracted from these two vectors:
1 if OFF is 0, then the returned vector is V2; otherwise, the
1 returned vector is composed from the last VS-OFF elements of V1
1 concatenated to the first OFF elements of V2.
1
1 If this hook is defined, the autovectorizer will generate a call to
1 F (using the DECL tree that this hook returns) and will use the
1 return value of F as the argument OFF to 'REALIGN_LOAD'.
1 Therefore, the mask M returned by F should comply with the
1 semantics expected by 'REALIGN_LOAD' described above. If this hook
1 is not defined, then ADDR will be used as the argument OFF to
1 'REALIGN_LOAD', in which case the low log2(VS) - 1 bits of ADDR
1 will be considered.
1
1 -- Target Hook: int TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST (enum
1 vect_cost_for_stmt TYPE_OF_COST, tree VECTYPE, int MISALIGN)
1 Returns cost of different scalar or vector statements for
1 vectorization cost model. For vector memory operations the cost
1 may depend on type (VECTYPE) and misalignment value (MISALIGN).
1
1 -- Target Hook: HOST_WIDE_INT
1 TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT (const_tree TYPE)
1 This hook returns the preferred alignment in bits for accesses to
1 vectors of type TYPE in vectorized code. This might be less than
1 or greater than the ABI-defined value returned by
1 'TARGET_VECTOR_ALIGNMENT'. It can be equal to the alignment of a
1 single element, in which case the vectorizer will not try to
1 optimize for alignment.
1
1 The default hook returns 'TYPE_ALIGN (TYPE)', which is correct for
1 most targets.
1
1 -- Target Hook: bool TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
1 (const_tree TYPE, bool IS_PACKED)
1 Return true if vector alignment is reachable (by peeling N
1 iterations) for the given scalar type TYPE. IS_PACKED is false if
1 the scalar access using TYPE is known to be naturally aligned.
1
1 -- Target Hook: bool TARGET_VECTORIZE_VEC_PERM_CONST (machine_mode
1 MODE, rtx OUTPUT, rtx IN0, rtx IN1, const vec_perm_indices
1 &SEL)
1 This hook is used to test whether the target can permute up to two
1 vectors of mode MODE using the permutation vector 'sel', and also
1 to emit such a permutation. In the former case IN0, IN1 and OUT
1 are all null. In the latter case IN0 and IN1 are the source
1 vectors and OUT is the destination vector; all three are registers
1 of mode MODE. IN1 is the same as IN0 if SEL describes a
1 permutation on one vector instead of two.
1
1 Return true if the operation is possible, emitting instructions for
1 it if rtxes are provided.
1
1 If the hook returns false for a mode with multibyte elements, GCC
1 will try the equivalent byte operation. If that also fails, it
1 will try forcing the selector into a register and using the
1 VEC_PERMMODE instruction pattern. There is no need for the hook to
1 handle these two implementation approaches itself.
1
1 -- Target Hook: tree TARGET_VECTORIZE_BUILTIN_CONVERSION (unsigned
1 CODE, tree DEST_TYPE, tree SRC_TYPE)
1 This hook should return the DECL of a function that implements
1 conversion of the input vector of type SRC_TYPE to type DEST_TYPE.
1 The value of CODE is one of the enumerators in 'enum tree_code' and
1 specifies how the conversion is to be applied (truncation,
1 rounding, etc.).
1
1 If this hook is defined, the autovectorizer will use the
1 'TARGET_VECTORIZE_BUILTIN_CONVERSION' target hook when vectorizing
1 conversion. Otherwise, it will return 'NULL_TREE'.
1
1 -- Target Hook: tree TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
1 (unsigned CODE, tree VEC_TYPE_OUT, tree VEC_TYPE_IN)
1 This hook should return the decl of a function that implements the
1 vectorized variant of the function with the 'combined_fn' code CODE
1 or 'NULL_TREE' if such a function is not available. The return
1 type of the vectorized function shall be of vector type
1 VEC_TYPE_OUT and the argument types should be VEC_TYPE_IN.
1
1 -- Target Hook: tree TARGET_VECTORIZE_BUILTIN_MD_VECTORIZED_FUNCTION
1 (tree FNDECL, tree VEC_TYPE_OUT, tree VEC_TYPE_IN)
1 This hook should return the decl of a function that implements the
1 vectorized variant of target built-in function 'fndecl'. The
1 return type of the vectorized function shall be of vector type
1 VEC_TYPE_OUT and the argument types should be VEC_TYPE_IN.
1
1 -- Target Hook: bool TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT
1 (machine_mode MODE, const_tree TYPE, int MISALIGNMENT, bool
1 IS_PACKED)
1 This hook should return true if the target supports misaligned
1 vector store/load of a specific factor denoted in the MISALIGNMENT
1 parameter. The vector store/load should be of machine mode MODE
1 and the elements in the vectors should be of type TYPE. IS_PACKED
1 parameter is true if the memory access is defined in a packed
1 struct.
1
1 -- Target Hook: machine_mode TARGET_VECTORIZE_PREFERRED_SIMD_MODE
1 (scalar_mode MODE)
1 This hook should return the preferred mode for vectorizing scalar
1 mode MODE. The default is equal to 'word_mode', because the
1 vectorizer can do some transformations even in absence of
1 specialized SIMD hardware.
1
1 -- Target Hook: machine_mode TARGET_VECTORIZE_SPLIT_REDUCTION
1 (machine_mode)
1 This hook should return the preferred mode to split the final
1 reduction step on MODE to. The reduction is then carried out
1 reducing upper against lower halves of vectors recursively until
1 the specified mode is reached. The default is MODE which means no
1 splitting.
1
1 -- Target Hook: void TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
1 (vector_sizes *SIZES)
1 If the mode returned by 'TARGET_VECTORIZE_PREFERRED_SIMD_MODE' is
1 not the only one that is worth considering, this hook should add
1 all suitable vector sizes to SIZES, in order of decreasing
1 preference. The first one should be the size of
1 'TARGET_VECTORIZE_PREFERRED_SIMD_MODE'.
1
1 The hook does not need to do anything if the vector returned by
1 'TARGET_VECTORIZE_PREFERRED_SIMD_MODE' is the only one relevant for
1 autovectorization. The default implementation does nothing.
1
1 -- Target Hook: opt_machine_mode TARGET_VECTORIZE_GET_MASK_MODE
1 (poly_uint64 NUNITS, poly_uint64 LENGTH)
1 A vector mask is a value that holds one boolean result for every
1 element in a vector. This hook returns the machine mode that
1 should be used to represent such a mask when the vector in question
1 is LENGTH bytes long and contains NUNITS elements. The hook
1 returns an empty 'opt_machine_mode' if no such mode exists.
1
1 The default implementation returns the mode of an integer vector
1 that is LENGTH bytes long and that contains NUNITS elements, if
1 such a mode exists.
1
1 -- Target Hook: bool TARGET_VECTORIZE_EMPTY_MASK_IS_EXPENSIVE (unsigned
1 IFN)
1 This hook returns true if masked internal function IFN (really of
1 type 'internal_fn') should be considered expensive when the mask is
1 all zeros. GCC can then try to branch around the instruction
1 instead.
1
1 -- Target Hook: void * TARGET_VECTORIZE_INIT_COST (struct loop
1 *LOOP_INFO)
1 This hook should initialize target-specific data structures in
1 preparation for modeling the costs of vectorizing a loop or basic
1 block. The default allocates three unsigned integers for
1 accumulating costs for the prologue, body, and epilogue of the loop
1 or basic block. If LOOP_INFO is non-NULL, it identifies the loop
1 being vectorized; otherwise a single block is being vectorized.
1
1 -- Target Hook: unsigned TARGET_VECTORIZE_ADD_STMT_COST (void *DATA,
1 int COUNT, enum vect_cost_for_stmt KIND, struct _stmt_vec_info
1 *STMT_INFO, int MISALIGN, enum vect_cost_model_location WHERE)
1 This hook should update the target-specific DATA in response to
1 adding COUNT copies of the given KIND of statement to a loop or
1 basic block. The default adds the builtin vectorizer cost for the
1 copies of the statement to the accumulator specified by WHERE, (the
1 prologue, body, or epilogue) and returns the amount added. The
1 return value should be viewed as a tentative cost that may later be
1 revised.
1
1 -- Target Hook: void TARGET_VECTORIZE_FINISH_COST (void *DATA, unsigned
1 *PROLOGUE_COST, unsigned *BODY_COST, unsigned *EPILOGUE_COST)
1 This hook should complete calculations of the cost of vectorizing a
1 loop or basic block based on DATA, and return the prologue, body,
1 and epilogue costs as unsigned integers. The default returns the
1 value of the three accumulators.
1
1 -- Target Hook: void TARGET_VECTORIZE_DESTROY_COST_DATA (void *DATA)
1 This hook should release DATA and any related data structures
1 allocated by TARGET_VECTORIZE_INIT_COST. The default releases the
1 accumulator.
1
1 -- Target Hook: tree TARGET_VECTORIZE_BUILTIN_GATHER (const_tree
1 MEM_VECTYPE, const_tree INDEX_TYPE, int SCALE)
1 Target builtin that implements vector gather operation.
1 MEM_VECTYPE is the vector type of the load and INDEX_TYPE is scalar
1 type of the index, scaled by SCALE. The default is 'NULL_TREE'
1 which means to not vectorize gather loads.
1
1 -- Target Hook: tree TARGET_VECTORIZE_BUILTIN_SCATTER (const_tree
1 VECTYPE, const_tree INDEX_TYPE, int SCALE)
1 Target builtin that implements vector scatter operation. VECTYPE
1 is the vector type of the store and INDEX_TYPE is scalar type of
1 the index, scaled by SCALE. The default is 'NULL_TREE' which means
1 to not vectorize scatter stores.
1
1 -- Target Hook: int TARGET_SIMD_CLONE_COMPUTE_VECSIZE_AND_SIMDLEN
1 (struct cgraph_node *, struct cgraph_simd_clone *, TREE, INT)
1 This hook should set VECSIZE_MANGLE, VECSIZE_INT, VECSIZE_FLOAT
1 fields in SIMD_CLONE structure pointed by CLONE_INFO argument and
1 also SIMDLEN field if it was previously 0. The hook should return
1 0 if SIMD clones shouldn't be emitted, or number of VECSIZE_MANGLE
1 variants that should be emitted.
1
1 -- Target Hook: void TARGET_SIMD_CLONE_ADJUST (struct cgraph_node *)
1 This hook should add implicit 'attribute(target("..."))' attribute
1 to SIMD clone NODE if needed.
1
1 -- Target Hook: int TARGET_SIMD_CLONE_USABLE (struct cgraph_node *)
1 This hook should return -1 if SIMD clone NODE shouldn't be used in
1 vectorized loops in current function, or non-negative number if it
1 is usable. In that case, the smaller the number is, the more
1 desirable it is to use it.
1
1 -- Target Hook: int TARGET_SIMT_VF (void)
1 Return number of threads in SIMT thread group on the target.
1
1 -- Target Hook: bool TARGET_GOACC_VALIDATE_DIMS (tree DECL, int *DIMS,
1 int FN_LEVEL)
1 This hook should check the launch dimensions provided for an
1 OpenACC compute region, or routine. Defaulted values are
1 represented as -1 and non-constant values as 0. The FN_LEVEL is
1 negative for the function corresponding to the compute region. For
1 a routine is is the outermost level at which partitioned execution
1 may be spawned. The hook should verify non-default values. If
1 DECL is NULL, global defaults are being validated and unspecified
1 defaults should be filled in. Diagnostics should be issued as
1 appropriate. Return true, if changes have been made. You must
1 override this hook to provide dimensions larger than 1.
1
1 -- Target Hook: int TARGET_GOACC_DIM_LIMIT (int AXIS)
1 This hook should return the maximum size of a particular dimension,
1 or zero if unbounded.
1
1 -- Target Hook: bool TARGET_GOACC_FORK_JOIN (gcall *CALL, const int
1 *DIMS, bool IS_FORK)
1 This hook can be used to convert IFN_GOACC_FORK and IFN_GOACC_JOIN
1 function calls to target-specific gimple, or indicate whether they
1 should be retained. It is executed during the oacc_device_lower
1 pass. It should return true, if the call should be retained. It
1 should return false, if it is to be deleted (either because
1 target-specific gimple has been inserted before it, or there is no
1 need for it). The default hook returns false, if there are no RTL
1 expanders for them.
1
1 -- Target Hook: void TARGET_GOACC_REDUCTION (gcall *CALL)
1 This hook is used by the oacc_transform pass to expand calls to the
1 GOACC_REDUCTION internal function, into a sequence of gimple
1 instructions. CALL is gimple statement containing the call to the
1 function. This hook removes statement CALL after the expanded
1 sequence has been inserted. This hook is also responsible for
1 allocating any storage for reductions when necessary.
1