gcc/internal-fn.h

   1 /* Internal functions.
   2    Copyright (C) 2011-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 #ifndef GCC_INTERNAL_FN_H
  21 #define GCC_INTERNAL_FN_H
  22
  23 /* INTEGER_CST values for IFN_UNIQUE function arg-0.
  24
  25    UNSPEC: Undifferentiated UNIQUE.
  26
  27    FORK and JOIN mark the points at which OpenACC partitioned
  28    execution is entered or exited.
  29       DEP_VAR = UNIQUE ({FORK,JOIN}, DEP_VAR, AXIS)
  30
  31    HEAD_MARK and TAIL_MARK are used to demark the sequence entering
  32    or leaving partitioned execution.
  33       DEP_VAR = UNIQUE ({HEAD,TAIL}_MARK, REMAINING_MARKS, ...PRIMARY_FLAGS)
  34
  35    The PRIMARY_FLAGS only occur on the first HEAD_MARK of a sequence.  */
  36 #define IFN_UNIQUE_CODES                                  \
  37   DEF(UNSPEC),  \
  38     DEF(OACC_FORK), DEF(OACC_JOIN),             \
  39     DEF(OACC_HEAD_MARK), DEF(OACC_TAIL_MARK)
  40
  41 enum ifn_unique_kind {
  42 #define DEF(X) IFN_UNIQUE_##X
  43   IFN_UNIQUE_CODES
  44 #undef DEF
  45 };
  46
  47 /* INTEGER_CST values for IFN_GOACC_LOOP arg-0.  Allows the precise
  48    stepping of the compute geometry over the loop iterations to be
  49    deferred until it is known which compiler is generating the code.
  50    The action is encoded in a constant first argument.
  51
  52      CHUNK_MAX = LOOP (CODE_CHUNKS, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
  53      STEP = LOOP (CODE_STEP, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
  54      OFFSET = LOOP (CODE_OFFSET, DIR, RANGE, STEP, CHUNK_SIZE, MASK, CHUNK_NO)
  55      BOUND = LOOP (CODE_BOUND, DIR, RANGE, STEP, CHUNK_SIZE, MASK, OFFSET)
  56
  57      DIR - +1 for up loop, -1 for down loop
  58      RANGE - Range of loop (END - BASE)
  59      STEP - iteration step size
  60      CHUNKING - size of chunking, (constant zero for no chunking)
  61      CHUNK_NO - chunk number
  62      MASK - partitioning mask.  */
  63
  64 #define IFN_GOACC_LOOP_CODES \
  65   DEF(CHUNKS), DEF(STEP), DEF(OFFSET), DEF(BOUND)
  66 enum ifn_goacc_loop_kind {
  67 #define DEF(X) IFN_GOACC_LOOP_##X
  68   IFN_GOACC_LOOP_CODES
  69 #undef DEF
  70 };
  71
  72 /* The GOACC_REDUCTION function defines a generic interface to support
  73    gang, worker and vector reductions.  All calls are of the following
  74    form:
  75
  76      V = REDUCTION (CODE, REF_TO_RES, LOCAL_VAR, LEVEL, OP, OFFSET)
  77
  78    REF_TO_RES - is a reference to the original reduction varl, may be NULL
  79    LOCAL_VAR is the intermediate reduction variable
  80    LEVEL corresponds to the GOMP_DIM of the reduction
  81    OP is the tree code of the reduction operation
  82    OFFSET may be used as an offset into a reduction array for the
  83           reductions occuring at this level.
  84    In general the return value is LOCAL_VAR, which creates a data
  85    dependency between calls operating on the same reduction.  */
  86
  87 #define IFN_GOACC_REDUCTION_CODES \
  88   DEF(SETUP), DEF(INIT), DEF(FINI), DEF(TEARDOWN)
  89 enum ifn_goacc_reduction_kind {
  90 #define DEF(X) IFN_GOACC_REDUCTION_##X
  91   IFN_GOACC_REDUCTION_CODES
  92 #undef DEF
  93 };
  94
  95 /* Initialize internal function tables.  */
  96
  97 extern void init_internal_fns ();
  98
  99 /* Return the name of internal function FN.  The name is only meaningful
 100    for dumps; it has no linkage.  */
 101
 102 extern const char *const internal_fn_name_array[];
 103
 104 static inline const char *
 105 internal_fn_name (enum internal_fn fn)
 106 {
 107   return internal_fn_name_array[(int) fn];
 108 }
 109
 110 extern internal_fn lookup_internal_fn (const char *);
 111
 112 /* Return the ECF_* flags for function FN.  */
 113
 114 extern const int internal_fn_flags_array[];
 115
 116 static inline int
 117 internal_fn_flags (enum internal_fn fn)
 118 {
 119   return internal_fn_flags_array[(int) fn];
 120 }
 121
 122 /* Return fnspec for function FN.  */
 123
 124 extern GTY(()) const_tree internal_fn_fnspec_array[IFN_LAST + 1];
 125
 126 static inline const_tree
 127 internal_fn_fnspec (enum internal_fn fn)
 128 {
 129   return internal_fn_fnspec_array[(int) fn];
 130 }
 131
 132 /* Describes an internal function that maps directly to an optab.  */
 133 struct direct_internal_fn_info
 134 {
 135   /* optabs can be parameterized by one or two modes.  These fields describe
 136      how to select those modes from the types of the return value and
 137      arguments.  A value of -1 says that the mode is determined by the
 138      return type while a value N >= 0 says that the mode is determined by
 139      the type of argument N.  A value of -2 says that this internal
 140      function isn't directly mapped to an optab.  */
 141   signed int type0 : 8;
 142   signed int type1 : 8;
 143   /* True if the function is pointwise, so that it can be vectorized by
 144      converting the return type and all argument types to vectors of the
 145      same number of elements.  E.g. we can vectorize an IFN_SQRT on
 146      floats as an IFN_SQRT on vectors of N floats.
 147
 148      This only needs 1 bit, but occupies the full 16 to ensure a nice
 149      layout.  */
 150   unsigned int vectorizable : 16;
 151 };
 152
 153 extern const direct_internal_fn_info direct_internal_fn_array[IFN_LAST + 1];
 154
 155 /* Return true if FN is mapped directly to an optab.  */
 156
 157 inline bool
 158 direct_internal_fn_p (internal_fn fn)
 159 {
 160   return direct_internal_fn_array[fn].type0 >= -1;
 161 }
 162
 163 /* Return optab information about internal function FN.  Only meaningful
 164    if direct_internal_fn_p (FN).  */
 165
 166 inline const direct_internal_fn_info &
 167 direct_internal_fn (internal_fn fn)
 168 {
 169   gcc_checking_assert (direct_internal_fn_p (fn));
 170   return direct_internal_fn_array[fn];
 171 }
 172
 173 extern tree_pair direct_internal_fn_types (internal_fn, tree, tree *);
 174 extern tree_pair direct_internal_fn_types (internal_fn, gcall *);
 175 extern bool direct_internal_fn_supported_p (internal_fn, tree_pair,
 176                                             optimization_type);
 177 extern bool direct_internal_fn_supported_p (internal_fn, tree,
 178                                             optimization_type);
 179
 180 /* Return true if FN is supported for types TYPE0 and TYPE1 when the
 181    optimization type is OPT_TYPE.  The types are those associated with
 182    the "type0" and "type1" fields of FN's direct_internal_fn_info
 183    structure.  */
 184
 185 inline bool
 186 direct_internal_fn_supported_p (internal_fn fn, tree type0, tree type1,
 187                                 optimization_type opt_type)
 188 {
 189   return direct_internal_fn_supported_p (fn, tree_pair (type0, type1),
 190                                          opt_type);
 191 }
 192
 193 extern bool set_edom_supported_p (void);
 194
 195 extern internal_fn get_conditional_internal_fn (tree_code);
 196 extern tree_code conditional_internal_fn_code (internal_fn);
 197
 198 extern bool internal_load_fn_p (internal_fn);
 199 extern bool internal_store_fn_p (internal_fn);
 200 extern bool internal_gather_scatter_fn_p (internal_fn);
 201 extern int internal_fn_mask_index (internal_fn);
 202 extern int internal_fn_stored_value_index (internal_fn);
 203 extern bool internal_gather_scatter_fn_supported_p (internal_fn, tree,
 204                                                     tree, signop, int);
 205
 206 extern void expand_internal_call (gcall *);
 207 extern void expand_internal_call (internal_fn, gcall *);
 208 extern void expand_PHI (internal_fn, gcall *);
 209
 210 #endif