]>
Commit | Line | Data |
---|---|---|
79fe1b3b DN |
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 | ||
8c27b7d4 | 31 | /* Defines type of operation: unary or binary. */ |
79fe1b3b DN |
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 | ||
6cb38cd4 | 55 | /* The loop with respect to which STMT is vectorized. */ |
79fe1b3b DN |
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; | |
6775f1f3 IR |
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; | |
79fe1b3b DN |
88 | } *stmt_vec_info; |
89 | ||
90 | /* Access Functions. */ | |
6775f1f3 IR |
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 | |
79fe1b3b DN |
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 | ||
7ccf35ed | 122 | /* The misalignment of the memory access in bytes. */ |
79fe1b3b DN |
123 | #define DR_MISALIGNMENT(DR) (DR)->aux |
124 | ||
125 | static inline bool | |
126 | aligned_access_p (struct data_reference *data_ref_info) | |
127 | { | |
128 | return (DR_MISALIGNMENT (data_ref_info) == 0); | |
129 | } | |
130 | ||
131 | static inline bool | |
132 | unknown_alignment_for_access_p (struct data_reference *data_ref_info) | |
133 | { | |
134 | return (DR_MISALIGNMENT (data_ref_info) == -1); | |
135 | } | |
136 | ||
6775f1f3 IR |
137 | /* Perform signed modulo, always returning a non-negative value. */ |
138 | #define VECT_SMODULO(x,y) ((x) % (y) < 0 ? ((x) % (y) + (y)) : (x) % (y)) | |
139 | ||
79fe1b3b DN |
140 | |
141 | /*-----------------------------------------------------------------*/ | |
142 | /* Info on vectorized loops. */ | |
143 | /*-----------------------------------------------------------------*/ | |
144 | typedef struct _loop_vec_info { | |
145 | ||
146 | /* The loop to which this info struct refers to. */ | |
147 | struct loop *loop; | |
148 | ||
149 | /* The loop basic blocks. */ | |
150 | basic_block *bbs; | |
151 | ||
152 | /* The loop exit_condition. */ | |
153 | tree exit_cond; | |
154 | ||
155 | /* Number of iterations. -1 if unknown. */ | |
156 | HOST_WIDE_INT num_iters; | |
157 | ||
158 | /* Is the loop vectorizable? */ | |
159 | bool vectorizable; | |
160 | ||
161 | /* Unrolling factor */ | |
162 | int vectorization_factor; | |
163 | ||
164 | /* All data references in the loop that are being written to. */ | |
165 | varray_type data_ref_writes; | |
166 | ||
167 | /* All data references in the loop that are being read from. */ | |
168 | varray_type data_ref_reads; | |
169 | } *loop_vec_info; | |
170 | ||
171 | /* Access Functions. */ | |
172 | #define LOOP_VINFO_LOOP(L) (L)->loop | |
173 | #define LOOP_VINFO_BBS(L) (L)->bbs | |
174 | #define LOOP_VINFO_EXIT_COND(L) (L)->exit_cond | |
175 | #define LOOP_VINFO_NITERS(L) (L)->num_iters | |
176 | #define LOOP_VINFO_VECTORIZABLE_P(L) (L)->vectorizable | |
177 | #define LOOP_VINFO_VECT_FACTOR(L) (L)->vectorization_factor | |
178 | #define LOOP_VINFO_DATAREF_WRITES(L) (L)->data_ref_writes | |
179 | #define LOOP_VINFO_DATAREF_READS(L) (L)->data_ref_reads | |
180 | ||
181 | #define LOOP_VINFO_NITERS_KNOWN_P(L) ((L)->num_iters > 0) | |
182 | ||
183 | /*-----------------------------------------------------------------*/ | |
184 | /* Function prototypes. */ | |
185 | /*-----------------------------------------------------------------*/ | |
186 | ||
187 | /* Main driver. */ | |
188 | extern void vectorize_loops (struct loops *); | |
189 | ||
190 | /* creation and deletion of loop and stmt info structs. */ | |
191 | extern loop_vec_info new_loop_vec_info (struct loop *loop); | |
192 | extern void destroy_loop_vec_info (loop_vec_info); | |
193 | extern stmt_vec_info new_stmt_vec_info (tree stmt, struct loop *loop); | |
194 | ||
195 | #endif /* GCC_TREE_VECTORIZER_H */ |