gcc/optabs-tree.c

   1 /* Tree-based target query functions relating to optabs
   2    Copyright (C) 1987-2020 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 "rtl.h"
  27 #include "tree.h"
  28 #include "memmodel.h"
  29 #include "optabs.h"
  30 #include "optabs-tree.h"
  31 #include "stor-layout.h"
  32
  33 /* Return the optab used for computing the operation given by the tree code,
  34    CODE and the tree EXP.  This function is not always usable (for example, it
  35    cannot give complete results for multiplication or division) but probably
  36    ought to be relied on more widely throughout the expander.  */
  37 optab
  38 optab_for_tree_code (enum tree_code code, const_tree type,
  39                      enum optab_subtype subtype)
  40 {
  41   bool trapv;
  42   switch (code)
  43     {
  44     case BIT_AND_EXPR:
  45       return and_optab;
  46
  47     case BIT_IOR_EXPR:
  48       return ior_optab;
  49
  50     case BIT_NOT_EXPR:
  51       return one_cmpl_optab;
  52
  53     case BIT_XOR_EXPR:
  54       return xor_optab;
  55
  56     case MULT_HIGHPART_EXPR:
  57       return TYPE_UNSIGNED (type) ? umul_highpart_optab : smul_highpart_optab;
  58
  59     case TRUNC_MOD_EXPR:
  60     case CEIL_MOD_EXPR:
  61     case FLOOR_MOD_EXPR:
  62     case ROUND_MOD_EXPR:
  63       return TYPE_UNSIGNED (type) ? umod_optab : smod_optab;
  64
  65     case RDIV_EXPR:
  66     case TRUNC_DIV_EXPR:
  67     case CEIL_DIV_EXPR:
  68     case FLOOR_DIV_EXPR:
  69     case ROUND_DIV_EXPR:
  70     case EXACT_DIV_EXPR:
  71       if (TYPE_SATURATING (type))
  72         return TYPE_UNSIGNED (type) ? usdiv_optab : ssdiv_optab;
  73       return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;
  74
  75     case LSHIFT_EXPR:
  76       if (TREE_CODE (type) == VECTOR_TYPE)
  77         {
  78           if (subtype == optab_vector)
  79             return TYPE_SATURATING (type) ? unknown_optab : vashl_optab;
  80
  81           gcc_assert (subtype == optab_scalar);
  82         }
  83       if (TYPE_SATURATING (type))
  84         return TYPE_UNSIGNED (type) ? usashl_optab : ssashl_optab;
  85       return ashl_optab;
  86
  87     case RSHIFT_EXPR:
  88       if (TREE_CODE (type) == VECTOR_TYPE)
  89         {
  90           if (subtype == optab_vector)
  91             return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab;
  92
  93           gcc_assert (subtype == optab_scalar);
  94         }
  95       return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;
  96
  97     case LROTATE_EXPR:
  98       if (TREE_CODE (type) == VECTOR_TYPE)
  99         {
 100           if (subtype == optab_vector)
 101             return vrotl_optab;
 102
 103           gcc_assert (subtype == optab_scalar);
 104         }
 105       return rotl_optab;
 106
 107     case RROTATE_EXPR:
 108       if (TREE_CODE (type) == VECTOR_TYPE)
 109         {
 110           if (subtype == optab_vector)
 111             return vrotr_optab;
 112
 113           gcc_assert (subtype == optab_scalar);
 114         }
 115       return rotr_optab;
 116
 117     case MAX_EXPR:
 118       return TYPE_UNSIGNED (type) ? umax_optab : smax_optab;
 119
 120     case MIN_EXPR:
 121       return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;
 122
 123     case REALIGN_LOAD_EXPR:
 124       return vec_realign_load_optab;
 125
 126     case WIDEN_SUM_EXPR:
 127       return TYPE_UNSIGNED (type) ? usum_widen_optab : ssum_widen_optab;
 128
 129     case DOT_PROD_EXPR:
 130       return TYPE_UNSIGNED (type) ? udot_prod_optab : sdot_prod_optab;
 131
 132     case SAD_EXPR:
 133       return TYPE_UNSIGNED (type) ? usad_optab : ssad_optab;
 134
 135     case WIDEN_MULT_PLUS_EXPR:
 136       return (TYPE_UNSIGNED (type)
 137               ? (TYPE_SATURATING (type)
 138                  ? usmadd_widen_optab : umadd_widen_optab)
 139               : (TYPE_SATURATING (type)
 140                  ? ssmadd_widen_optab : smadd_widen_optab));
 141
 142     case WIDEN_MULT_MINUS_EXPR:
 143       return (TYPE_UNSIGNED (type)
 144               ? (TYPE_SATURATING (type)
 145                  ? usmsub_widen_optab : umsub_widen_optab)
 146               : (TYPE_SATURATING (type)
 147                  ? ssmsub_widen_optab : smsub_widen_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_UNPACK_FIX_TRUNC_HI_EXPR:
 192       /* The signedness is determined from output operand.  */
 193       return (TYPE_UNSIGNED (type)
 194               ? vec_unpack_ufix_trunc_hi_optab
 195               : vec_unpack_sfix_trunc_hi_optab);
 196
 197     case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
 198       /* The signedness is determined from output operand.  */
 199       return (TYPE_UNSIGNED (type)
 200               ? vec_unpack_ufix_trunc_lo_optab
 201               : vec_unpack_sfix_trunc_lo_optab);
 202
 203     case VEC_PACK_TRUNC_EXPR:
 204       return vec_pack_trunc_optab;
 205
 206     case VEC_PACK_SAT_EXPR:
 207       return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab;
 208
 209     case VEC_PACK_FIX_TRUNC_EXPR:
 210       /* The signedness is determined from output operand.  */
 211       return (TYPE_UNSIGNED (type)
 212               ? vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab);
 213
 214     case VEC_PACK_FLOAT_EXPR:
 215       /* The signedness is determined from input operand.  */
 216       return (TYPE_UNSIGNED (type)
 217               ? vec_packu_float_optab : vec_packs_float_optab);
 218
 219     case VEC_DUPLICATE_EXPR:
 220       return vec_duplicate_optab;
 221
 222     case VEC_SERIES_EXPR:
 223       return vec_series_optab;
 224
 225     default:
 226       break;
 227     }
 228
 229   trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
 230   switch (code)
 231     {
 232     case POINTER_PLUS_EXPR:
 233     case PLUS_EXPR:
 234       if (TYPE_SATURATING (type))
 235         return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab;
 236       return trapv ? addv_optab : add_optab;
 237
 238     case POINTER_DIFF_EXPR:
 239     case MINUS_EXPR:
 240       if (TYPE_SATURATING (type))
 241         return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab;
 242       return trapv ? subv_optab : sub_optab;
 243
 244     case MULT_EXPR:
 245       if (TYPE_SATURATING (type))
 246         return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab;
 247       return trapv ? smulv_optab : smul_optab;
 248
 249     case NEGATE_EXPR:
 250       if (TYPE_SATURATING (type))
 251         return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab;
 252       return trapv ? negv_optab : neg_optab;
 253
 254     case ABS_EXPR:
 255       return trapv ? absv_optab : abs_optab;
 256
 257     case ABSU_EXPR:
 258       return abs_optab;
 259     default:
 260       return unknown_optab;
 261     }
 262 }
 263
 264 /* Function supportable_convert_operation
 265
 266    Check whether an operation represented by the code CODE is a
 267    convert operation that is supported by the target platform in
 268    vector form (i.e., when operating on arguments of type VECTYPE_IN
 269    producing a result of type VECTYPE_OUT).
 270
 271    Convert operations we currently support directly are FIX_TRUNC and FLOAT.
 272    This function checks if these operations are supported
 273    by the target platform directly (via vector tree-codes).
 274
 275    Output:
 276    - CODE1 is code of vector operation to be used when
 277    vectorizing the operation, if available.  */
 278
 279 bool
 280 supportable_convert_operation (enum tree_code code,
 281                                tree vectype_out, tree vectype_in,
 282                                enum tree_code *code1)
 283 {
 284   machine_mode m1,m2;
 285   bool truncp;
 286
 287   gcc_assert (VECTOR_TYPE_P (vectype_out) && VECTOR_TYPE_P (vectype_in));
 288
 289   m1 = TYPE_MODE (vectype_out);
 290   m2 = TYPE_MODE (vectype_in);
 291
 292   if (!VECTOR_MODE_P (m1) || !VECTOR_MODE_P (m2))
 293     return false;
 294
 295   /* First check if we can done conversion directly.  */
 296   if ((code == FIX_TRUNC_EXPR
 297        && can_fix_p (m1,m2,TYPE_UNSIGNED (vectype_out), &truncp)
 298           != CODE_FOR_nothing)
 299       || (code == FLOAT_EXPR
 300           && can_float_p (m1,m2,TYPE_UNSIGNED (vectype_in))
 301              != CODE_FOR_nothing))
 302     {
 303       *code1 = code;
 304       return true;
 305     }
 306
 307   if (GET_MODE_UNIT_PRECISION (m1) > GET_MODE_UNIT_PRECISION (m2)
 308       && can_extend_p (m1, m2, TYPE_UNSIGNED (vectype_in)))
 309     {
 310       *code1 = code;
 311       return true;
 312     }
 313
 314   if (GET_MODE_UNIT_PRECISION (m1) < GET_MODE_UNIT_PRECISION (m2)
 315       && convert_optab_handler (trunc_optab, m1, m2) != CODE_FOR_nothing)
 316     {
 317       *code1 = code;
 318       return true;
 319     }
 320
 321   return false;
 322 }
 323
 324 /* Return TRUE if appropriate vector insn is available
 325    for vector comparison expr with vector type VALUE_TYPE
 326    and resulting mask with MASK_TYPE.  */
 327
 328 bool
 329 expand_vec_cmp_expr_p (tree value_type, tree mask_type, enum tree_code code)
 330 {
 331   if (get_vec_cmp_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type),
 332                          TYPE_UNSIGNED (value_type)) != CODE_FOR_nothing)
 333     return true;
 334   if ((code == EQ_EXPR || code == NE_EXPR)
 335       && (get_vec_cmp_eq_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type))
 336           != CODE_FOR_nothing))
 337     return true;
 338   return false;
 339 }
 340
 341 /* Return true iff vcond_optab/vcondu_optab can handle a vector
 342    comparison for code CODE, comparing operands of type CMP_OP_TYPE and
 343    producing a result of type VALUE_TYPE.  */
 344
 345 static bool
 346 vcond_icode_p (tree value_type, tree cmp_op_type, enum tree_code code)
 347 {
 348   return can_vcond_compare_p (get_rtx_code (code, TYPE_UNSIGNED (cmp_op_type)),
 349                               TYPE_MODE (value_type), TYPE_MODE (cmp_op_type));
 350 }
 351
 352 /* Return true iff vcondeq_optab can handle a vector comparison for code CODE,
 353    comparing operands of type CMP_OP_TYPE and producing a result of type
 354    VALUE_TYPE.  */
 355
 356 static bool
 357 vcond_eq_icode_p (tree value_type, tree cmp_op_type, enum tree_code code)
 358 {
 359   if (code != EQ_EXPR && code != NE_EXPR)
 360     return false;
 361
 362   return get_vcond_eq_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type))
 363          != CODE_FOR_nothing;
 364 }
 365
 366 /* Return TRUE iff, appropriate vector insns are available
 367    for vector cond expr with vector type VALUE_TYPE and a comparison
 368    with operand vector types in CMP_OP_TYPE.  */
 369
 370 bool
 371 expand_vec_cond_expr_p (tree value_type, tree cmp_op_type, enum tree_code code)
 372 {
 373   machine_mode value_mode = TYPE_MODE (value_type);
 374   machine_mode cmp_op_mode = TYPE_MODE (cmp_op_type);
 375   if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type)
 376       && get_vcond_mask_icode (TYPE_MODE (value_type),
 377                                TYPE_MODE (cmp_op_type)) != CODE_FOR_nothing)
 378     return true;
 379
 380   if (maybe_ne (GET_MODE_SIZE (value_mode), GET_MODE_SIZE (cmp_op_mode))
 381       || maybe_ne (GET_MODE_NUNITS (value_mode), GET_MODE_NUNITS (cmp_op_mode)))
 382     return false;
 383
 384   if (TREE_CODE_CLASS (code) != tcc_comparison)
 385     /* This may happen, for example, if code == SSA_NAME, in which case we
 386        cannot be certain whether a vector insn is available.  */
 387     return false;
 388
 389   return vcond_icode_p (value_type, cmp_op_type, code)
 390          || vcond_eq_icode_p (value_type, cmp_op_type, code);
 391 }
 392
 393 /* Use the current target and options to initialize
 394    TREE_OPTIMIZATION_OPTABS (OPTNODE).  */
 395
 396 void
 397 init_tree_optimization_optabs (tree optnode)
 398 {
 399   /* Quick exit if we have already computed optabs for this target.  */
 400   if (TREE_OPTIMIZATION_BASE_OPTABS (optnode) == this_target_optabs)
 401     return;
 402
 403   /* Forget any previous information and set up for the current target.  */
 404   TREE_OPTIMIZATION_BASE_OPTABS (optnode) = this_target_optabs;
 405   struct target_optabs *tmp_optabs = (struct target_optabs *)
 406     TREE_OPTIMIZATION_OPTABS (optnode);
 407   if (tmp_optabs)
 408     memset (tmp_optabs, 0, sizeof (struct target_optabs));
 409   else
 410     tmp_optabs = ggc_cleared_alloc<target_optabs> ();
 411
 412   /* Generate a new set of optabs into tmp_optabs.  */
 413   init_all_optabs (tmp_optabs);
 414
 415   /* If the optabs changed, record it.  */
 416   if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs)))
 417     TREE_OPTIMIZATION_OPTABS (optnode) = tmp_optabs;
 418   else
 419     {
 420       TREE_OPTIMIZATION_OPTABS (optnode) = NULL;
 421       ggc_free (tmp_optabs);
 422     }
 423 }
 424
 425 /* Return TRUE if the target has support for vector right shift of an
 426    operand of type TYPE.  If OT_TYPE is OPTAB_DEFAULT, check for existence
 427    of a shift by either a scalar or a vector.  Otherwise, check only
 428    for a shift that matches OT_TYPE.  */
 429
 430 bool
 431 target_supports_op_p (tree type, enum tree_code code,
 432                       enum optab_subtype ot_subtype)
 433 {
 434   optab ot = optab_for_tree_code (code, type, ot_subtype);
 435   return (ot != unknown_optab
 436           && optab_handler (ot, TYPE_MODE (type)) != CODE_FOR_nothing);
 437 }
 438