gcc/optabs-tree.c

   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