1 /* Internal functions. 2 Copyright (C) 2011-2018 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef GCC_INTERNAL_FN_H 21 #define GCC_INTERNAL_FN_H 22 23 /* INTEGER_CST values for IFN_UNIQUE function arg-0. 24 25 UNSPEC: Undifferentiated UNIQUE. 26 27 FORK and JOIN mark the points at which OpenACC partitioned 28 execution is entered or exited. 29 DEP_VAR = UNIQUE ({FORK,JOIN}, DEP_VAR, AXIS) 30 31 HEAD_MARK and TAIL_MARK are used to demark the sequence entering 32 or leaving partitioned execution. 33 DEP_VAR = UNIQUE ({HEAD,TAIL}_MARK, REMAINING_MARKS, ...PRIMARY_FLAGS) 34 35 The PRIMARY_FLAGS only occur on the first HEAD_MARK of a sequence. */ 36 #define IFN_UNIQUE_CODES \ 37 DEF(UNSPEC), \ 38 DEF(OACC_FORK), DEF(OACC_JOIN), \ 39 DEF(OACC_HEAD_MARK), DEF(OACC_TAIL_MARK) 40 41 enum ifn_unique_kind { 42 #define DEF(X) IFN_UNIQUE_##X 43 IFN_UNIQUE_CODES 44 #undef DEF 45 }; 46 47 /* INTEGER_CST values for IFN_GOACC_LOOP arg-0. Allows the precise 48 stepping of the compute geometry over the loop iterations to be 49 deferred until it is known which compiler is generating the code. 50 The action is encoded in a constant first argument. 51 52 CHUNK_MAX = LOOP (CODE_CHUNKS, DIR, RANGE, STEP, CHUNK_SIZE, MASK) 53 STEP = LOOP (CODE_STEP, DIR, RANGE, STEP, CHUNK_SIZE, MASK) 54 OFFSET = LOOP (CODE_OFFSET, DIR, RANGE, STEP, CHUNK_SIZE, MASK, CHUNK_NO) 55 BOUND = LOOP (CODE_BOUND, DIR, RANGE, STEP, CHUNK_SIZE, MASK, OFFSET) 56 57 DIR - +1 for up loop, -1 for down loop 58 RANGE - Range of loop (END - BASE) 59 STEP - iteration step size 60 CHUNKING - size of chunking, (constant zero for no chunking) 61 CHUNK_NO - chunk number 62 MASK - partitioning mask. */ 63 64 #define IFN_GOACC_LOOP_CODES \ 65 DEF(CHUNKS), DEF(STEP), DEF(OFFSET), DEF(BOUND) 66 enum ifn_goacc_loop_kind { 67 #define DEF(X) IFN_GOACC_LOOP_##X 68 IFN_GOACC_LOOP_CODES 69 #undef DEF 70 }; 71 72 /* The GOACC_REDUCTION function defines a generic interface to support 73 gang, worker and vector reductions. All calls are of the following 74 form: 75 76 V = REDUCTION (CODE, REF_TO_RES, LOCAL_VAR, LEVEL, OP, OFFSET) 77 78 REF_TO_RES - is a reference to the original reduction varl, may be NULL 79 LOCAL_VAR is the intermediate reduction variable 80 LEVEL corresponds to the GOMP_DIM of the reduction 81 OP is the tree code of the reduction operation 82 OFFSET may be used as an offset into a reduction array for the 83 reductions occuring at this level. 84 In general the return value is LOCAL_VAR, which creates a data 85 dependency between calls operating on the same reduction. */ 86 87 #define IFN_GOACC_REDUCTION_CODES \ 88 DEF(SETUP), DEF(INIT), DEF(FINI), DEF(TEARDOWN) 89 enum ifn_goacc_reduction_kind { 90 #define DEF(X) IFN_GOACC_REDUCTION_##X 91 IFN_GOACC_REDUCTION_CODES 92 #undef DEF 93 }; 94 95 /* Initialize internal function tables. */ 96 97 extern void init_internal_fns (); 98 99 /* Return the name of internal function FN. The name is only meaningful 100 for dumps; it has no linkage. */ 101 102 extern const char *const internal_fn_name_array[]; 103 104 static inline const char * 105 internal_fn_name (enum internal_fn fn) 106 { 107 return internal_fn_name_array[(int) fn]; 108 } 109 110 /* Return the ECF_* flags for function FN. */ 111 112 extern const int internal_fn_flags_array[]; 113 114 static inline int 115 internal_fn_flags (enum internal_fn fn) 116 { 117 return internal_fn_flags_array[(int) fn]; 118 } 119 120 /* Return fnspec for function FN. */ 121 122 extern GTY(()) const_tree internal_fn_fnspec_array[IFN_LAST + 1]; 123 124 static inline const_tree 125 internal_fn_fnspec (enum internal_fn fn) 126 { 127 return internal_fn_fnspec_array[(int) fn]; 128 } 129 130 /* Describes an internal function that maps directly to an optab. */ 131 struct direct_internal_fn_info 132 { 133 /* optabs can be parameterized by one or two modes. These fields describe 134 how to select those modes from the types of the return value and 135 arguments. A value of -1 says that the mode is determined by the 136 return type while a value N >= 0 says that the mode is determined by 137 the type of argument N. A value of -2 says that this internal 138 function isn't directly mapped to an optab. */ 139 signed int type0 : 8; 140 signed int type1 : 8; 141 /* True if the function is pointwise, so that it can be vectorized by 142 converting the return type and all argument types to vectors of the 143 same number of elements. E.g. we can vectorize an IFN_SQRT on 144 floats as an IFN_SQRT on vectors of N floats. 145 146 This only needs 1 bit, but occupies the full 16 to ensure a nice 147 layout. */ 148 unsigned int vectorizable : 16; 149 }; 150 151 extern const direct_internal_fn_info direct_internal_fn_array[IFN_LAST + 1]; 152 153 /* Return true if FN is mapped directly to an optab. */ 154 155 inline bool 156 direct_internal_fn_p (internal_fn fn) 157 { 158 return direct_internal_fn_array[fn].type0 >= -1; 159 } 160 161 /* Return optab information about internal function FN. Only meaningful 162 if direct_internal_fn_p (FN). */ 163 164 inline const direct_internal_fn_info & 165 direct_internal_fn (internal_fn fn) 166 { 167 gcc_checking_assert (direct_internal_fn_p (fn)); 168 return direct_internal_fn_array[fn]; 169 } 170 171 extern tree_pair direct_internal_fn_types (internal_fn, tree, tree *); 172 extern tree_pair direct_internal_fn_types (internal_fn, gcall *); 173 extern bool direct_internal_fn_supported_p (internal_fn, tree_pair, 174 optimization_type); 175 extern bool direct_internal_fn_supported_p (internal_fn, tree, 176 optimization_type); 177 178 /* Return true if FN is supported for types TYPE0 and TYPE1 when the 179 optimization type is OPT_TYPE. The types are those associated with 180 the "type0" and "type1" fields of FN's direct_internal_fn_info 181 structure. */ 182 183 inline bool 184 direct_internal_fn_supported_p (internal_fn fn, tree type0, tree type1, 185 optimization_type opt_type) 186 { 187 return direct_internal_fn_supported_p (fn, tree_pair (type0, type1), 188 opt_type); 189 } 190 191 extern bool set_edom_supported_p (void); 192 193 extern internal_fn get_conditional_internal_fn (tree_code); 194 195 extern bool internal_load_fn_p (internal_fn); 196 extern bool internal_store_fn_p (internal_fn); 197 extern bool internal_gather_scatter_fn_p (internal_fn); 198 extern int internal_fn_mask_index (internal_fn); 199 extern int internal_fn_stored_value_index (internal_fn); 200 extern bool internal_gather_scatter_fn_supported_p (internal_fn, tree, 201 tree, signop, int); 202 203 extern void expand_internal_call (gcall *); 204 extern void expand_internal_call (internal_fn, gcall *); 205 extern void expand_PHI (internal_fn, gcall *); 206 207 #endif 208