#include <tree-vectorizer.h>
Data Fields | |
| struct loop * | loop |
| basic_block * | bbs |
| tree | num_iters |
| tree | num_iters_unchanged |
| int | min_profitable_iters |
| bool | vectorizable |
| int | vectorization_factor |
| LOC | loop_line_number |
| struct data_reference * | unaligned_dr |
| int | peeling_for_alignment |
| int | ptr_mask |
| vec< loop_p > | loop_nest |
| vec< data_reference_p > | datarefs |
| vec< ddr_p > | ddrs |
| vec< ddr_p > | may_alias_ddrs |
| vec< gimple > | may_misalign_stmts |
| vec< gimple > | grouped_stores |
| vec< slp_instance > | slp_instances |
| unsigned | slp_unrolling_factor |
| vec< gimple > | reductions |
| vec< gimple > | reduction_chains |
| hash_table< peel_info_hasher > | peeling_htab |
| void * | target_cost_data |
| bool | peeling_for_gaps |
| bool | operands_swapped |
Detailed Description
Info on vectorized loops.
Field Documentation
| basic_block* _loop_vec_info::bbs |
The loop basic blocks.
| vec<data_reference_p> _loop_vec_info::datarefs |
All data references in the loop.
All interleaving chains of stores in the loop, represented by the first stmt in the chain.
| struct loop* _loop_vec_info::loop |
The loop to which this info struct refers to.
| LOC _loop_vec_info::loop_line_number |
The loop location in the source.
Data Dependence Relations defining address ranges that are candidates for a run-time aliasing check.
Statements in the loop that have data references that are candidates for a runtime (loop versioning) misalignment check.
| int _loop_vec_info::min_profitable_iters |
Minimum number of iterations below which vectorization is expected to not be profitable (as estimated by the cost model). -1 indicates that vectorization will not be profitable. FORNOW: This field is an int. Will be a tree in the future, to represent values unknown at compile time.
| tree _loop_vec_info::num_iters |
Number of iterations.
| tree _loop_vec_info::num_iters_unchanged |
| bool _loop_vec_info::operands_swapped |
Reductions are canonicalized so that the last operand is the reduction operand. If this places a constant into RHS1, this decanonicalizes GIMPLE for other phases, so we must track when this has occurred and fix it up.
| int _loop_vec_info::peeling_for_alignment |
peeling_for_alignment indicates whether peeling for alignment will take place, and what the peeling factor should be: peeling_for_alignment = X means: If X=0: Peeling for alignment will not be applied. If X>0: Peel first X iterations. If X=-1: Generate a runtime test to calculate the number of iterations to be peeled, using the dataref recorded in the field unaligned_dr.
| bool _loop_vec_info::peeling_for_gaps |
When we have grouped data accesses with gaps, we may introduce invalid memory accesses. We peel the last iteration of the loop to prevent this.
| hash_table<peel_info_hasher> _loop_vec_info::peeling_htab |
Hash table used to choose the best peeling option.
| int _loop_vec_info::ptr_mask |
The mask used to check the alignment of pointers or arrays.
All reduction chains in the loop, represented by the first stmt in the chain.
Reduction cycles detected in the loop. Used in loop-aware SLP.
| vec<slp_instance> _loop_vec_info::slp_instances |
All SLP instances in the loop. This is a subset of the set of GROUP_STORES of the loop.
| unsigned _loop_vec_info::slp_unrolling_factor |
The unrolling factor needed to SLP the loop. In case of that pure SLP is applied to the loop, i.e., no unrolling is needed, this is 1.
| void* _loop_vec_info::target_cost_data |
Cost data used by the target cost model.
| struct data_reference* _loop_vec_info::unaligned_dr |
Unknown DRs according to which loop was peeled.
| bool _loop_vec_info::vectorizable |
Is the loop vectorizable?
| int _loop_vec_info::vectorization_factor |
Unrolling factor
The documentation for this struct was generated from the following file:
