1 /* Tree-based target query functions relating to optabs 2 Copyright (C) 1987-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 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "target.h" 25 #include "insn-codes.h" 26 #include "tree.h" 27 #include "optabs-tree.h" 28 #include "stor-layout.h" 29 30 /* Return the optab used for computing the operation given by the tree code, 31 CODE and the tree EXP. This function is not always usable (for example, it 32 cannot give complete results for multiplication or division) but probably 33 ought to be relied on more widely throughout the expander. */ 34 optab 35 optab_for_tree_code (enum tree_code code, const_tree type, 36 enum optab_subtype subtype) 37 { 38 bool trapv; 39 switch (code) 40 { 41 case BIT_AND_EXPR: 42 return and_optab; 43 44 case BIT_IOR_EXPR: 45 return ior_optab; 46 47 case BIT_NOT_EXPR: 48 return one_cmpl_optab; 49 50 case BIT_XOR_EXPR: 51 return xor_optab; 52 53 case MULT_HIGHPART_EXPR: 54 return TYPE_UNSIGNED (type) ? umul_highpart_optab : smul_highpart_optab; 55 56 case TRUNC_MOD_EXPR: 57 case CEIL_MOD_EXPR: 58 case FLOOR_MOD_EXPR: 59 case ROUND_MOD_EXPR: 60 return TYPE_UNSIGNED (type) ? umod_optab : smod_optab; 61 62 case RDIV_EXPR: 63 case TRUNC_DIV_EXPR: 64 case CEIL_DIV_EXPR: 65 case FLOOR_DIV_EXPR: 66 case ROUND_DIV_EXPR: 67 case EXACT_DIV_EXPR: 68 if (TYPE_SATURATING (type)) 69 return TYPE_UNSIGNED (type) ? usdiv_optab : ssdiv_optab; 70 return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab; 71 72 case LSHIFT_EXPR: 73 if (TREE_CODE (type) == VECTOR_TYPE) 74 { 75 if (subtype == optab_vector) 76 return TYPE_SATURATING (type) ? unknown_optab : vashl_optab; 77 78 gcc_assert (subtype == optab_scalar); 79 } 80 if (TYPE_SATURATING (type)) 81 return TYPE_UNSIGNED (type) ? usashl_optab : ssashl_optab; 82 return ashl_optab; 83 84 case RSHIFT_EXPR: 85 if (TREE_CODE (type) == VECTOR_TYPE) 86 { 87 if (subtype == optab_vector) 88 return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab; 89 90 gcc_assert (subtype == optab_scalar); 91 } 92 return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab; 93 94 case LROTATE_EXPR: 95 if (TREE_CODE (type) == VECTOR_TYPE) 96 { 97 if (subtype == optab_vector) 98 return vrotl_optab; 99 100 gcc_assert (subtype == optab_scalar); 101 } 102 return rotl_optab; 103 104 case RROTATE_EXPR: 105 if (TREE_CODE (type) == VECTOR_TYPE) 106 { 107 if (subtype == optab_vector) 108 return vrotr_optab; 109 110 gcc_assert (subtype == optab_scalar); 111 } 112 return rotr_optab; 113 114 case MAX_EXPR: 115 return TYPE_UNSIGNED (type) ? umax_optab : smax_optab; 116 117 case MIN_EXPR: 118 return TYPE_UNSIGNED (type) ? umin_optab : smin_optab; 119 120 case REALIGN_LOAD_EXPR: 121 return vec_realign_load_optab; 122 123 case WIDEN_SUM_EXPR: 124 return TYPE_UNSIGNED (type) ? usum_widen_optab : ssum_widen_optab; 125 126 case DOT_PROD_EXPR: 127 return TYPE_UNSIGNED (type) ? udot_prod_optab : sdot_prod_optab; 128 129 case SAD_EXPR: 130 return TYPE_UNSIGNED (type) ? usad_optab : ssad_optab; 131 132 case WIDEN_MULT_PLUS_EXPR: 133 return (TYPE_UNSIGNED (type) 134 ? (TYPE_SATURATING (type) 135 ? usmadd_widen_optab : umadd_widen_optab) 136 : (TYPE_SATURATING (type) 137 ? ssmadd_widen_optab : smadd_widen_optab)); 138 139 case WIDEN_MULT_MINUS_EXPR: 140 return (TYPE_UNSIGNED (type) 141 ? (TYPE_SATURATING (type) 142 ? usmsub_widen_optab : umsub_widen_optab) 143 : (TYPE_SATURATING (type) 144 ? ssmsub_widen_optab : smsub_widen_optab)); 145 146 case FMA_EXPR: 147 return fma_optab; 148 149 case VEC_WIDEN_MULT_HI_EXPR: 150 return TYPE_UNSIGNED (type) ? 151 vec_widen_umult_hi_optab : vec_widen_smult_hi_optab; 152 153 case VEC_WIDEN_MULT_LO_EXPR: 154 return TYPE_UNSIGNED (type) ? 155 vec_widen_umult_lo_optab : vec_widen_smult_lo_optab; 156 157 case VEC_WIDEN_MULT_EVEN_EXPR: 158 return TYPE_UNSIGNED (type) ? 159 vec_widen_umult_even_optab : vec_widen_smult_even_optab; 160 161 case VEC_WIDEN_MULT_ODD_EXPR: 162 return TYPE_UNSIGNED (type) ? 163 vec_widen_umult_odd_optab : vec_widen_smult_odd_optab; 164 165 case VEC_WIDEN_LSHIFT_HI_EXPR: 166 return TYPE_UNSIGNED (type) ? 167 vec_widen_ushiftl_hi_optab : vec_widen_sshiftl_hi_optab; 168 169 case VEC_WIDEN_LSHIFT_LO_EXPR: 170 return TYPE_UNSIGNED (type) ? 171 vec_widen_ushiftl_lo_optab : vec_widen_sshiftl_lo_optab; 172 173 case VEC_UNPACK_HI_EXPR: 174 return TYPE_UNSIGNED (type) ? 175 vec_unpacku_hi_optab : vec_unpacks_hi_optab; 176 177 case VEC_UNPACK_LO_EXPR: 178 return TYPE_UNSIGNED (type) ? 179 vec_unpacku_lo_optab : vec_unpacks_lo_optab; 180 181 case VEC_UNPACK_FLOAT_HI_EXPR: 182 /* The signedness is determined from input operand. */ 183 return TYPE_UNSIGNED (type) ? 184 vec_unpacku_float_hi_optab : vec_unpacks_float_hi_optab; 185 186 case VEC_UNPACK_FLOAT_LO_EXPR: 187 /* The signedness is determined from input operand. */ 188 return TYPE_UNSIGNED (type) ? 189 vec_unpacku_float_lo_optab : vec_unpacks_float_lo_optab; 190 191 case VEC_PACK_TRUNC_EXPR: 192 return vec_pack_trunc_optab; 193 194 case VEC_PACK_SAT_EXPR: 195 return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab; 196 197 case VEC_PACK_FIX_TRUNC_EXPR: 198 /* The signedness is determined from output operand. */ 199 return TYPE_UNSIGNED (type) ? 200 vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab; 201 202 case VEC_DUPLICATE_EXPR: 203 return vec_duplicate_optab; 204 205 case VEC_SERIES_EXPR: 206 return vec_series_optab; 207 208 default: 209 break; 210 } 211 212 trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type); 213 switch (code) 214 { 215 case POINTER_PLUS_EXPR: 216 case PLUS_EXPR: 217 if (TYPE_SATURATING (type)) 218 return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab; 219 return trapv ? addv_optab : add_optab; 220 221 case POINTER_DIFF_EXPR: 222 case MINUS_EXPR: 223 if (TYPE_SATURATING (type)) 224 return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab; 225 return trapv ? subv_optab : sub_optab; 226 227 case MULT_EXPR: 228 if (TYPE_SATURATING (type)) 229 return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab; 230 return trapv ? smulv_optab : smul_optab; 231 232 case NEGATE_EXPR: 233 if (TYPE_SATURATING (type)) 234 return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab; 235 return trapv ? negv_optab : neg_optab; 236 237 case ABS_EXPR: 238 return trapv ? absv_optab : abs_optab; 239 240 default: 241 return unknown_optab; 242 } 243 } 244 245 /* Function supportable_convert_operation 246 247 Check whether an operation represented by the code CODE is a 248 convert operation that is supported by the target platform in 249 vector form (i.e., when operating on arguments of type VECTYPE_IN 250 producing a result of type VECTYPE_OUT). 251 252 Convert operations we currently support directly are FIX_TRUNC and FLOAT. 253 This function checks if these operations are supported 254 by the target platform either directly (via vector tree-codes), or via 255 target builtins. 256 257 Output: 258 - CODE1 is code of vector operation to be used when 259 vectorizing the operation, if available. 260 - DECL is decl of target builtin functions to be used 261 when vectorizing the operation, if available. In this case, 262 CODE1 is CALL_EXPR. */ 263 264 bool 265 supportable_convert_operation (enum tree_code code, 266 tree vectype_out, tree vectype_in, 267 tree *decl, enum tree_code *code1) 268 { 269 machine_mode m1,m2; 270 bool truncp; 271 272 m1 = TYPE_MODE (vectype_out); 273 m2 = TYPE_MODE (vectype_in); 274 275 /* First check if we can done conversion directly. */ 276 if ((code == FIX_TRUNC_EXPR 277 && can_fix_p (m1,m2,TYPE_UNSIGNED (vectype_out), &truncp) 278 != CODE_FOR_nothing) 279 || (code == FLOAT_EXPR 280 && can_float_p (m1,m2,TYPE_UNSIGNED (vectype_in)) 281 != CODE_FOR_nothing)) 282 { 283 *code1 = code; 284 return true; 285 } 286 287 /* Now check for builtin. */ 288 if (targetm.vectorize.builtin_conversion 289 && targetm.vectorize.builtin_conversion (code, vectype_out, vectype_in)) 290 { 291 *code1 = CALL_EXPR; 292 *decl = targetm.vectorize.builtin_conversion (code, vectype_out, 293 vectype_in); 294 return true; 295 } 296 return false; 297 } 298 299 /* Return TRUE if appropriate vector insn is available 300 for vector comparison expr with vector type VALUE_TYPE 301 and resulting mask with MASK_TYPE. */ 302 303 bool 304 expand_vec_cmp_expr_p (tree value_type, tree mask_type, enum tree_code code) 305 { 306 if (get_vec_cmp_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type), 307 TYPE_UNSIGNED (value_type)) != CODE_FOR_nothing) 308 return true; 309 if ((code == EQ_EXPR || code == NE_EXPR) 310 && (get_vec_cmp_eq_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type)) 311 != CODE_FOR_nothing)) 312 return true; 313 return false; 314 } 315 316 /* Return TRUE iff, appropriate vector insns are available 317 for vector cond expr with vector type VALUE_TYPE and a comparison 318 with operand vector types in CMP_OP_TYPE. */ 319 320 bool 321 expand_vec_cond_expr_p (tree value_type, tree cmp_op_type, enum tree_code code) 322 { 323 machine_mode value_mode = TYPE_MODE (value_type); 324 machine_mode cmp_op_mode = TYPE_MODE (cmp_op_type); 325 if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type) 326 && get_vcond_mask_icode (TYPE_MODE (value_type), 327 TYPE_MODE (cmp_op_type)) != CODE_FOR_nothing) 328 return true; 329 330 if (maybe_ne (GET_MODE_SIZE (value_mode), GET_MODE_SIZE (cmp_op_mode)) 331 || maybe_ne (GET_MODE_NUNITS (value_mode), GET_MODE_NUNITS (cmp_op_mode))) 332 return false; 333 334 if (get_vcond_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type), 335 TYPE_UNSIGNED (cmp_op_type)) == CODE_FOR_nothing 336 && ((code != EQ_EXPR && code != NE_EXPR) 337 || get_vcond_eq_icode (TYPE_MODE (value_type), 338 TYPE_MODE (cmp_op_type)) == CODE_FOR_nothing)) 339 return false; 340 341 return true; 342 } 343 344 /* Use the current target and options to initialize 345 TREE_OPTIMIZATION_OPTABS (OPTNODE). */ 346 347 void 348 init_tree_optimization_optabs (tree optnode) 349 { 350 /* Quick exit if we have already computed optabs for this target. */ 351 if (TREE_OPTIMIZATION_BASE_OPTABS (optnode) == this_target_optabs) 352 return; 353 354 /* Forget any previous information and set up for the current target. */ 355 TREE_OPTIMIZATION_BASE_OPTABS (optnode) = this_target_optabs; 356 struct target_optabs *tmp_optabs = (struct target_optabs *) 357 TREE_OPTIMIZATION_OPTABS (optnode); 358 if (tmp_optabs) 359 memset (tmp_optabs, 0, sizeof (struct target_optabs)); 360 else 361 tmp_optabs = ggc_cleared_alloc<target_optabs> (); 362 363 /* Generate a new set of optabs into tmp_optabs. */ 364 init_all_optabs (tmp_optabs); 365 366 /* If the optabs changed, record it. */ 367 if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs))) 368 TREE_OPTIMIZATION_OPTABS (optnode) = tmp_optabs; 369 else 370 { 371 TREE_OPTIMIZATION_OPTABS (optnode) = NULL; 372 ggc_free (tmp_optabs); 373 } 374 } 375 376 /* Return TRUE if the target has support for vector right shift of an 377 operand of type TYPE. If OT_TYPE is OPTAB_DEFAULT, check for existence 378 of a shift by either a scalar or a vector. Otherwise, check only 379 for a shift that matches OT_TYPE. */ 380 381 bool 382 target_supports_op_p (tree type, enum tree_code code, 383 enum optab_subtype ot_subtype) 384 { 385 optab ot = optab_for_tree_code (code, type, ot_subtype); 386 return (ot != unknown_optab 387 && optab_handler (ot, TYPE_MODE (type)) != CODE_FOR_nothing); 388 } 389 390