gcc/optabs-tree.c

   1 /* Tree-based target query functions relating to optabs
   2    Copyright (C) 1987-2017 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     default:
 203       break;
 204     }
 205
 206   trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
 207   switch (code)
 208     {
 209     case POINTER_PLUS_EXPR:
 210     case PLUS_EXPR:
 211       if (TYPE_SATURATING (type))
 212         return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab;
 213       return trapv ? addv_optab : add_optab;
 214
 215     case POINTER_DIFF_EXPR:
 216     case MINUS_EXPR:
 217       if (TYPE_SATURATING (type))
 218         return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab;
 219       return trapv ? subv_optab : sub_optab;
 220
 221     case MULT_EXPR:
 222       if (TYPE_SATURATING (type))
 223         return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab;
 224       return trapv ? smulv_optab : smul_optab;
 225
 226     case NEGATE_EXPR:
 227       if (TYPE_SATURATING (type))
 228         return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab;
 229       return trapv ? negv_optab : neg_optab;
 230
 231     case ABS_EXPR:
 232       return trapv ? absv_optab : abs_optab;
 233
 234     default:
 235       return unknown_optab;
 236     }
 237 }
 238
 239 /* Function supportable_convert_operation
 240
 241    Check whether an operation represented by the code CODE is a
 242    convert operation that is supported by the target platform in
 243    vector form (i.e., when operating on arguments of type VECTYPE_IN
 244    producing a result of type VECTYPE_OUT).
 245
 246    Convert operations we currently support directly are FIX_TRUNC and FLOAT.
 247    This function checks if these operations are supported
 248    by the target platform either directly (via vector tree-codes), or via
 249    target builtins.
 250
 251    Output:
 252    - CODE1 is code of vector operation to be used when
 253    vectorizing the operation, if available.
 254    - DECL is decl of target builtin functions to be used
 255    when vectorizing the operation, if available.  In this case,
 256    CODE1 is CALL_EXPR.  */
 257
 258 bool
 259 supportable_convert_operation (enum tree_code code,
 260                                tree vectype_out, tree vectype_in,
 261                                tree *decl, enum tree_code *code1)
 262 {
 263   machine_mode m1,m2;
 264   bool truncp;
 265
 266   m1 = TYPE_MODE (vectype_out);
 267   m2 = TYPE_MODE (vectype_in);
 268
 269   /* First check if we can done conversion directly.  */
 270   if ((code == FIX_TRUNC_EXPR
 271        && can_fix_p (m1,m2,TYPE_UNSIGNED (vectype_out), &truncp)
 272           != CODE_FOR_nothing)
 273       || (code == FLOAT_EXPR
 274           && can_float_p (m1,m2,TYPE_UNSIGNED (vectype_in))
 275              != CODE_FOR_nothing))
 276     {
 277       *code1 = code;
 278       return true;
 279     }
 280
 281   /* Now check for builtin.  */
 282   if (targetm.vectorize.builtin_conversion
 283       && targetm.vectorize.builtin_conversion (code, vectype_out, vectype_in))
 284     {
 285       *code1 = CALL_EXPR;
 286       *decl = targetm.vectorize.builtin_conversion (code, vectype_out,
 287                                                     vectype_in);
 288       return true;
 289     }
 290   return false;
 291 }
 292
 293 /* Return TRUE if appropriate vector insn is available
 294    for vector comparison expr with vector type VALUE_TYPE
 295    and resulting mask with MASK_TYPE.  */
 296
 297 bool
 298 expand_vec_cmp_expr_p (tree value_type, tree mask_type, enum tree_code code)
 299 {
 300   if (get_vec_cmp_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type),
 301                          TYPE_UNSIGNED (value_type)) != CODE_FOR_nothing)
 302     return true;
 303   if ((code == EQ_EXPR || code == NE_EXPR)
 304       && (get_vec_cmp_eq_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type))
 305           != CODE_FOR_nothing))
 306     return true;
 307   return false;
 308 }
 309
 310 /* Return TRUE iff, appropriate vector insns are available
 311    for vector cond expr with vector type VALUE_TYPE and a comparison
 312    with operand vector types in CMP_OP_TYPE.  */
 313
 314 bool
 315 expand_vec_cond_expr_p (tree value_type, tree cmp_op_type, enum tree_code code)
 316 {
 317   machine_mode value_mode = TYPE_MODE (value_type);
 318   machine_mode cmp_op_mode = TYPE_MODE (cmp_op_type);
 319   if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type)
 320       && get_vcond_mask_icode (TYPE_MODE (value_type),
 321                                TYPE_MODE (cmp_op_type)) != CODE_FOR_nothing)
 322     return true;
 323
 324   if (GET_MODE_SIZE (value_mode) != GET_MODE_SIZE (cmp_op_mode)
 325       || GET_MODE_NUNITS (value_mode) != GET_MODE_NUNITS (cmp_op_mode))
 326     return false;
 327
 328   if (get_vcond_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type),
 329                        TYPE_UNSIGNED (cmp_op_type)) == CODE_FOR_nothing
 330       && ((code != EQ_EXPR && code != NE_EXPR)
 331           || get_vcond_eq_icode (TYPE_MODE (value_type),
 332                                  TYPE_MODE (cmp_op_type)) == CODE_FOR_nothing))
 333     return false;
 334
 335   return true;
 336 }
 337
 338 /* Use the current target and options to initialize
 339    TREE_OPTIMIZATION_OPTABS (OPTNODE).  */
 340
 341 void
 342 init_tree_optimization_optabs (tree optnode)
 343 {
 344   /* Quick exit if we have already computed optabs for this target.  */
 345   if (TREE_OPTIMIZATION_BASE_OPTABS (optnode) == this_target_optabs)
 346     return;
 347
 348   /* Forget any previous information and set up for the current target.  */
 349   TREE_OPTIMIZATION_BASE_OPTABS (optnode) = this_target_optabs;
 350   struct target_optabs *tmp_optabs = (struct target_optabs *)
 351     TREE_OPTIMIZATION_OPTABS (optnode);
 352   if (tmp_optabs)
 353     memset (tmp_optabs, 0, sizeof (struct target_optabs));
 354   else
 355     tmp_optabs = ggc_alloc<target_optabs> ();
 356
 357   /* Generate a new set of optabs into tmp_optabs.  */
 358   init_all_optabs (tmp_optabs);
 359
 360   /* If the optabs changed, record it.  */
 361   if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs)))
 362     TREE_OPTIMIZATION_OPTABS (optnode) = tmp_optabs;
 363   else
 364     {
 365       TREE_OPTIMIZATION_OPTABS (optnode) = NULL;
 366       ggc_free (tmp_optabs);
 367     }
 368 }
 369
 370 /* Return TRUE if the target has support for vector right shift of an
 371    operand of type TYPE.  If OT_TYPE is OPTAB_DEFAULT, check for existence
 372    of a shift by either a scalar or a vector.  Otherwise, check only
 373    for a shift that matches OT_TYPE.  */
 374
 375 bool
 376 target_supports_op_p (tree type, enum tree_code code,
 377                       enum optab_subtype ot_subtype)
 378 {
 379   optab ot = optab_for_tree_code (code, type, ot_subtype);
 380   return (ot != unknown_optab
 381           && optab_handler (ot, TYPE_MODE (type)) != CODE_FOR_nothing);
 382 }
 383