gcc/optabs-query.h

   1 /* IR-agnostic target query functions relating to optabs
   2    Copyright (C) 2001-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
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 GCC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License 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_OPTABS_QUERY_H
  21 #define GCC_OPTABS_QUERY_H
  22
  23 #include "insn-opinit.h"
  24 #include "target.h"
  25
  26 /* Return the insn used to implement mode MODE of OP, or CODE_FOR_nothing
  27    if the target does not have such an insn.  */
  28
  29 inline enum insn_code
  30 optab_handler (optab op, machine_mode mode)
  31 {
  32   unsigned scode = (op << 16) | mode;
  33   gcc_assert (op > LAST_CONV_OPTAB);
  34   return raw_optab_handler (scode);
  35 }
  36
  37 /* Return the insn used to perform conversion OP from mode FROM_MODE
  38    to mode TO_MODE; return CODE_FOR_nothing if the target does not have
  39    such an insn.  */
  40
  41 inline enum insn_code
  42 convert_optab_handler (convert_optab op, machine_mode to_mode,
  43                        machine_mode from_mode)
  44 {
  45   unsigned scode = (op << 16) | (from_mode << 8) | to_mode;
  46   gcc_assert (op > unknown_optab && op <= LAST_CONV_OPTAB);
  47   return raw_optab_handler (scode);
  48 }
  49
  50 enum insn_code convert_optab_handler (convert_optab, machine_mode,
  51                                       machine_mode, optimization_type);
  52
  53 /* Return the insn used to implement mode MODE of OP, or CODE_FOR_nothing
  54    if the target does not have such an insn.  */
  55
  56 inline enum insn_code
  57 direct_optab_handler (direct_optab op, machine_mode mode)
  58 {
  59   return optab_handler (op, mode);
  60 }
  61
  62 enum insn_code direct_optab_handler (convert_optab, machine_mode,
  63                                      optimization_type);
  64
  65 /* Return true if UNOPTAB is for a trapping-on-overflow operation.  */
  66
  67 inline bool
  68 trapv_unoptab_p (optab unoptab)
  69 {
  70   return (unoptab == negv_optab
  71           || unoptab == absv_optab);
  72 }
  73
  74 /* Return true if BINOPTAB is for a trapping-on-overflow operation.  */
  75
  76 inline bool
  77 trapv_binoptab_p (optab binoptab)
  78 {
  79   return (binoptab == addv_optab
  80           || binoptab == subv_optab
  81           || binoptab == smulv_optab);
  82 }
  83
  84 /* Return insn code for a comparison operator with VMODE
  85    resultin MASK_MODE, unsigned if UNS is true.  */
  86
  87 static inline enum insn_code
  88 get_vec_cmp_icode (machine_mode vmode, machine_mode mask_mode, bool uns)
  89 {
  90   optab tab = uns ? vec_cmpu_optab : vec_cmp_optab;
  91   return convert_optab_handler (tab, vmode, mask_mode);
  92 }
  93
  94 /* Return insn code for a comparison operator with VMODE
  95    resultin MASK_MODE (only for EQ/NE).  */
  96
  97 static inline enum insn_code
  98 get_vec_cmp_eq_icode (machine_mode vmode, machine_mode mask_mode)
  99 {
 100   return convert_optab_handler (vec_cmpeq_optab, vmode, mask_mode);
 101 }
 102
 103 /* Return insn code for a conditional operator with a comparison in
 104    mode CMODE, unsigned if UNS is true, resulting in a value of mode VMODE.  */
 105
 106 inline enum insn_code
 107 get_vcond_icode (machine_mode vmode, machine_mode cmode, bool uns)
 108 {
 109   enum insn_code icode = CODE_FOR_nothing;
 110   if (uns)
 111     icode = convert_optab_handler (vcondu_optab, vmode, cmode);
 112   else
 113     icode = convert_optab_handler (vcond_optab, vmode, cmode);
 114   return icode;
 115 }
 116
 117 /* Return insn code for a conditional operator with a mask mode
 118    MMODE resulting in a value of mode VMODE.  */
 119
 120 static inline enum insn_code
 121 get_vcond_mask_icode (machine_mode vmode, machine_mode mmode)
 122 {
 123   return convert_optab_handler (vcond_mask_optab, vmode, mmode);
 124 }
 125
 126 /* Return insn code for a conditional operator with a comparison in
 127    mode CMODE (only EQ/NE), resulting in a value of mode VMODE.  */
 128
 129 static inline enum insn_code
 130 get_vcond_eq_icode (machine_mode vmode, machine_mode cmode)
 131 {
 132   return convert_optab_handler (vcondeq_optab, vmode, cmode);
 133 }
 134
 135 /* Enumerates the possible extraction_insn operations.  */
 136 enum extraction_pattern { EP_insv, EP_extv, EP_extzv };
 137
 138 /* Describes an instruction that inserts or extracts a bitfield.  */
 139 struct extraction_insn
 140 {
 141   /* The code of the instruction.  */
 142   enum insn_code icode;
 143
 144   /* The mode that the structure operand should have.  This is byte_mode
 145      when using the legacy insv, extv and extzv patterns to access memory.
 146      If no mode is given, the structure is a BLKmode memory.  */
 147   opt_scalar_int_mode struct_mode;
 148
 149   /* The mode of the field to be inserted or extracted, and by extension
 150      the mode of the insertion or extraction itself.  */
 151   scalar_int_mode field_mode;
 152
 153   /* The mode of the field's bit position.  This is only important
 154      when the position is variable rather than constant.  */
 155   scalar_int_mode pos_mode;
 156 };
 157
 158 bool get_best_reg_extraction_insn (extraction_insn *,
 159                                    enum extraction_pattern,
 160                                    unsigned HOST_WIDE_INT, machine_mode);
 161 bool get_best_mem_extraction_insn (extraction_insn *,
 162                                    enum extraction_pattern,
 163                                    HOST_WIDE_INT, HOST_WIDE_INT, machine_mode);
 164
 165 enum insn_code can_extend_p (machine_mode, machine_mode, int);
 166 enum insn_code can_float_p (machine_mode, machine_mode, int);
 167 enum insn_code can_fix_p (machine_mode, machine_mode, int, bool *);
 168 bool can_conditionally_move_p (machine_mode mode);
 169 bool can_vec_perm_p (machine_mode, bool, vec_perm_indices *);
 170 enum insn_code widening_optab_handler (optab, machine_mode, machine_mode);
 171 /* Find a widening optab even if it doesn't widen as much as we want.  */
 172 #define find_widening_optab_handler(A,B,C,D) \
 173   find_widening_optab_handler_and_mode (A, B, C, D, NULL)
 174 enum insn_code find_widening_optab_handler_and_mode (optab, machine_mode,
 175                                                      machine_mode, int,
 176                                                      machine_mode *);
 177 int can_mult_highpart_p (machine_mode, bool);
 178 bool can_vec_mask_load_store_p (machine_mode, machine_mode, bool);
 179 bool can_compare_and_swap_p (machine_mode, bool);
 180 bool can_atomic_exchange_p (machine_mode, bool);
 181 bool can_atomic_load_p (machine_mode);
 182 bool lshift_cheap_p (bool);
 183
 184 #endif