gcc/tree-vectorizer.h

   1 /* Loop Vectorization
   2    Copyright (C) 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Dorit Naishlos <dorit@il.ibm.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #ifndef GCC_TREE_VECTORIZER_H
  23 #define GCC_TREE_VECTORIZER_H
  24
  25 /* Used for naming of new temporaries.  */
  26 enum vect_var_kind {
  27   vect_simple_var,
  28   vect_pointer_var
  29 };
  30
  31 /* Defines type of operation: unary or binary.  */
  32 enum operation_type {
  33   unary_op = 1,
  34   binary_op
  35 };
  36
  37 /*-----------------------------------------------------------------*/
  38 /* Info on vectorized defs.                                        */
  39 /*-----------------------------------------------------------------*/
  40 enum stmt_vec_info_type {
  41   undef_vec_info_type = 0,
  42   load_vec_info_type,
  43   store_vec_info_type,
  44   op_vec_info_type,
  45   assignment_vec_info_type
  46 };
  47
  48 typedef struct _stmt_vec_info {
  49
  50   enum stmt_vec_info_type type;
  51
  52   /* The stmt to which this info struct refers to.  */
  53   tree stmt;
  54
  55   /* The loop with respect to which STMT is vectorized.  */
  56   struct loop *loop;
  57
  58   /* Not all stmts in the loop need to be vectorized. e.g, the incrementation
  59      of the loop induction variable and computation of array indexes. relevant
  60      indicates whether the stmt needs to be vectorized.  */
  61   bool relevant;
  62
  63   /* The vector type to be used.  */
  64   tree vectype;
  65
  66   /* The vectorized version of the stmt.  */
  67   tree vectorized_stmt;
  68
  69
  70   /** The following is relevant only for stmts that contain a non-scalar
  71      data-ref (array/pointer/struct access). A GIMPLE stmt is expected to have
  72      at most one such data-ref.  **/
  73
  74   /* Information about the data-ref (access function, etc).  */
  75   struct data_reference *data_ref_info;
  76
  77   /* Aliasing information.  */
  78   tree memtag;
  79
  80   /* Data reference base. This field holds the entire invariant part of the
  81      data-reference (with respect to the relevant loop), as opposed to the
  82      field DR_BASE of the STMT_VINFO_DATA_REF struct, which holds only the
  83      initial base; e.g:
  84      REF        BR_BASE     VECT_DR_BASE
  85      a[i]       a               a
  86      a[i][j]    a               a[i]  */
  87   tree vect_dr_base;
  88 } *stmt_vec_info;
  89
  90 /* Access Functions.  */
  91 #define STMT_VINFO_TYPE(S)          (S)->type
  92 #define STMT_VINFO_STMT(S)          (S)->stmt
  93 #define STMT_VINFO_LOOP(S)          (S)->loop
  94 #define STMT_VINFO_RELEVANT_P(S)    (S)->relevant
  95 #define STMT_VINFO_VECTYPE(S)       (S)->vectype
  96 #define STMT_VINFO_VEC_STMT(S)      (S)->vectorized_stmt
  97 #define STMT_VINFO_DATA_REF(S)      (S)->data_ref_info
  98 #define STMT_VINFO_MEMTAG(S)        (S)->memtag
  99 #define STMT_VINFO_VECT_DR_BASE(S)  (S)->vect_dr_base
 100
 101 static inline void set_stmt_info (stmt_ann_t ann, stmt_vec_info stmt_info);
 102 static inline stmt_vec_info vinfo_for_stmt (tree stmt);
 103
 104 static inline void
 105 set_stmt_info (stmt_ann_t ann, stmt_vec_info stmt_info)
 106 {
 107   if (ann)
 108     ann->common.aux = (char *) stmt_info;
 109 }
 110
 111 static inline stmt_vec_info
 112 vinfo_for_stmt (tree stmt)
 113 {
 114   stmt_ann_t ann = stmt_ann (stmt);
 115   return ann ? (stmt_vec_info) ann->common.aux : NULL;
 116 }
 117
 118 /*-----------------------------------------------------------------*/
 119 /* Info on data references alignment.                              */
 120 /*-----------------------------------------------------------------*/
 121
 122 #define DR_MISALIGNMENT(DR)   (DR)->aux
 123
 124 static inline bool
 125 aligned_access_p (struct data_reference *data_ref_info)
 126 {
 127   return (DR_MISALIGNMENT (data_ref_info) == 0);
 128 }
 129
 130 static inline bool
 131 unknown_alignment_for_access_p (struct data_reference *data_ref_info)
 132 {
 133   return (DR_MISALIGNMENT (data_ref_info) == -1);
 134 }
 135
 136 /* Perform signed modulo, always returning a non-negative value.  */
 137 #define VECT_SMODULO(x,y) ((x) % (y) < 0 ? ((x) % (y) + (y)) : (x) % (y))
 138
 139
 140 /*-----------------------------------------------------------------*/
 141 /* Info on vectorized loops.                                       */
 142 /*-----------------------------------------------------------------*/
 143 typedef struct _loop_vec_info {
 144
 145   /* The loop to which this info struct refers to.  */
 146   struct loop *loop;
 147
 148   /* The loop basic blocks.  */
 149   basic_block *bbs;
 150
 151   /* The loop exit_condition.  */
 152   tree exit_cond;
 153
 154   /* Number of iterations. -1 if unknown.  */
 155   HOST_WIDE_INT num_iters;
 156
 157   /* Is the loop vectorizable? */
 158   bool vectorizable;
 159
 160   /* Unrolling factor  */
 161   int vectorization_factor;
 162
 163   /* All data references in the loop that are being written to.  */
 164   varray_type data_ref_writes;
 165
 166   /* All data references in the loop that are being read from.  */
 167   varray_type data_ref_reads;
 168 } *loop_vec_info;
 169
 170 /* Access Functions.  */
 171 #define LOOP_VINFO_LOOP(L)           (L)->loop
 172 #define LOOP_VINFO_BBS(L)            (L)->bbs
 173 #define LOOP_VINFO_EXIT_COND(L)      (L)->exit_cond
 174 #define LOOP_VINFO_NITERS(L)         (L)->num_iters
 175 #define LOOP_VINFO_VECTORIZABLE_P(L) (L)->vectorizable
 176 #define LOOP_VINFO_VECT_FACTOR(L)    (L)->vectorization_factor
 177 #define LOOP_VINFO_DATAREF_WRITES(L) (L)->data_ref_writes
 178 #define LOOP_VINFO_DATAREF_READS(L)  (L)->data_ref_reads
 179
 180 #define LOOP_VINFO_NITERS_KNOWN_P(L) ((L)->num_iters > 0)
 181
 182 /*-----------------------------------------------------------------*/
 183 /* Function prototypes.                                            */
 184 /*-----------------------------------------------------------------*/
 185
 186 /* Main driver.  */
 187 extern void vectorize_loops (struct loops *);
 188
 189 /* creation and deletion of loop and stmt info structs.  */
 190 extern loop_vec_info new_loop_vec_info (struct loop *loop);
 191 extern void destroy_loop_vec_info (loop_vec_info);
 192 extern stmt_vec_info new_stmt_vec_info (tree stmt, struct loop *loop);
 193
 194 #endif  /* GCC_TREE_VECTORIZER_H  */