GCC Middle and Back End API Reference
_loop_vec_info Struct Reference

#include <tree-vectorizer.h>

Collaboration diagram for _loop_vec_info:

Data Fields

struct looploop
tree num_iters
tree num_iters_unchanged
int min_profitable_iters
bool vectorizable
int vectorization_factor
LOC loop_line_number
struct data_referenceunaligned_dr
int peeling_for_alignment
int ptr_mask
vec< loop_ploop_nest
vec< data_reference_pdatarefs
vec< ddr_pddrs
vec< ddr_pmay_alias_ddrs
vec< gimplemay_misalign_stmts
vec< gimplegrouped_stores
vec< slp_instanceslp_instances
unsigned slp_unrolling_factor
vec< gimplereductions
vec< gimplereduction_chains
hash_table< peel_info_hasherpeeling_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.  
vec<ddr_p> _loop_vec_info::ddrs
     All data dependences in the loop.  
vec<gimple> _loop_vec_info::grouped_stores
     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.  
vec<loop_p> _loop_vec_info::loop_nest
     The loop nest in which the data dependences are computed.  
vec<ddr_p> _loop_vec_info::may_alias_ddrs
     Data Dependence Relations defining address ranges that are candidates
     for a run-time aliasing check.  
vec<gimple> _loop_vec_info::may_misalign_stmts
     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
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
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.  
vec<gimple> _loop_vec_info::reduction_chains
     All reduction chains in the loop, represented by the first
     stmt in the chain.  
vec<gimple> _loop_vec_info::reductions
     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: