/* Vectorizer
- Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 2003-2014 Free Software Foundation, Inc.
Contributed by Dorit Naishlos <dorit@il.ibm.com>
This file is part of GCC.
#define GCC_TREE_VECTORIZER_H
#include "tree-data-ref.h"
-
-typedef source_location LOC;
-#define UNKNOWN_LOC UNKNOWN_LOCATION
-#define EXPR_LOC(e) EXPR_LOCATION(e)
-#define LOC_FILE(l) LOCATION_FILE (l)
-#define LOC_LINE(l) LOCATION_LINE (l)
+#include "target.h"
+#include "hash-table.h"
/* Used for naming of new temporaries. */
enum vect_var_kind {
|| ((D) == vect_double_reduction_def) \
|| ((D) == vect_nested_cycle))
+/* Structure to encapsulate information about a group of like
+ instructions to be presented to the target cost model. */
+typedef struct _stmt_info_for_cost {
+ int count;
+ enum vect_cost_for_stmt kind;
+ gimple stmt;
+ int misalign;
+} stmt_info_for_cost;
+
+
+typedef vec<stmt_info_for_cost> stmt_vector_for_cost;
+
+static inline void
+add_stmt_info_to_vec (stmt_vector_for_cost *stmt_cost_vec, int count,
+ enum vect_cost_for_stmt kind, gimple stmt, int misalign)
+{
+ stmt_info_for_cost si;
+ si.count = count;
+ si.kind = kind;
+ si.stmt = stmt;
+ si.misalign = misalign;
+ stmt_cost_vec->safe_push (si);
+}
+
/************************************************************************
SLP
************************************************************************/
-typedef void *slp_void_p;
-DEF_VEC_P (slp_void_p);
-DEF_VEC_ALLOC_P (slp_void_p, heap);
+typedef struct _slp_tree *slp_tree;
/* A computation tree of an SLP instance. Each node corresponds to a group of
stmts to be packed in a SIMD stmt. */
-typedef struct _slp_tree {
+struct _slp_tree {
/* Nodes that contain def-stmts of this node statements operands. */
- VEC (slp_void_p, heap) *children;
+ vec<slp_tree> children;
/* A group of scalar stmts to be vectorized together. */
- VEC (gimple, heap) *stmts;
+ vec<gimple> stmts;
+ /* Load permutation relative to the stores, NULL if there is no
+ permutation. */
+ vec<unsigned> load_permutation;
/* Vectorized stmt/s. */
- VEC (gimple, heap) *vec_stmts;
+ vec<gimple> vec_stmts;
/* Number of vector stmts that are created to replace the group of scalar
stmts. It is calculated during the transformation phase as the number of
scalar elements in one scalar iteration (GROUP_SIZE) multiplied by VF
divided by vector size. */
unsigned int vec_stmts_size;
- /* Vectorization costs associated with SLP node. */
- struct
- {
- int outside_of_loop; /* Statements generated outside loop. */
- int inside_of_loop; /* Statements generated inside loop. */
- } cost;
-} *slp_tree;
+};
-DEF_VEC_P(slp_tree);
-DEF_VEC_ALLOC_P(slp_tree, heap);
/* SLP instance is a sequence of stmts in a loop that can be packed into
SIMD stmts. */
unsigned int unrolling_factor;
/* Vectorization costs associated with SLP instance. */
- struct
- {
- int outside_of_loop; /* Statements generated outside loop. */
- int inside_of_loop; /* Statements generated inside loop. */
- } cost;
-
- /* Loads permutation relatively to the stores, NULL if there is no
- permutation. */
- VEC (int, heap) *load_permutation;
+ stmt_vector_for_cost body_cost_vec;
/* The group of nodes that contain loads of this SLP instance. */
- VEC (slp_tree, heap) *loads;
+ vec<slp_tree> loads;
/* The first scalar load of the instance. The created vector loads will be
inserted before this statement. */
gimple first_load;
} *slp_instance;
-DEF_VEC_P(slp_instance);
-DEF_VEC_ALLOC_P(slp_instance, heap);
/* Access Functions. */
#define SLP_INSTANCE_TREE(S) (S)->root
#define SLP_INSTANCE_GROUP_SIZE(S) (S)->group_size
#define SLP_INSTANCE_UNROLLING_FACTOR(S) (S)->unrolling_factor
-#define SLP_INSTANCE_OUTSIDE_OF_LOOP_COST(S) (S)->cost.outside_of_loop
-#define SLP_INSTANCE_INSIDE_OF_LOOP_COST(S) (S)->cost.inside_of_loop
-#define SLP_INSTANCE_LOAD_PERMUTATION(S) (S)->load_permutation
+#define SLP_INSTANCE_BODY_COST_VEC(S) (S)->body_cost_vec
#define SLP_INSTANCE_LOADS(S) (S)->loads
#define SLP_INSTANCE_FIRST_LOAD_STMT(S) (S)->first_load
#define SLP_TREE_SCALAR_STMTS(S) (S)->stmts
#define SLP_TREE_VEC_STMTS(S) (S)->vec_stmts
#define SLP_TREE_NUMBER_OF_VEC_STMTS(S) (S)->vec_stmts_size
-#define SLP_TREE_OUTSIDE_OF_LOOP_COST(S) (S)->cost.outside_of_loop
-#define SLP_TREE_INSIDE_OF_LOOP_COST(S) (S)->cost.inside_of_loop
+#define SLP_TREE_LOAD_PERMUTATION(S) (S)->load_permutation
/* This structure is used in creation of an SLP tree. Each instance
corresponds to the same operand in a group of scalar stmts in an SLP
typedef struct _slp_oprnd_info
{
/* Def-stmts for the operands. */
- VEC (gimple, heap) *def_stmts;
+ vec<gimple> def_stmts;
/* Information about the first statement, its vector def-type, type, the
operand itself in case it's constant, and an indication if it's a pattern
stmt. */
enum vect_def_type first_dt;
- tree first_def_type;
- tree first_const_oprnd;
+ tree first_op_type;
bool first_pattern;
} *slp_oprnd_info;
-DEF_VEC_P(slp_oprnd_info);
-DEF_VEC_ALLOC_P(slp_oprnd_info, heap);
+
+
+/* This struct is used to store the information of a data reference,
+ including the data ref itself, the access offset (calculated by summing its
+ offset and init) and the segment length for aliasing checks.
+ This is used to merge alias checks. */
+
+struct dr_with_seg_len
+{
+ dr_with_seg_len (data_reference_p d, tree len)
+ : dr (d),
+ offset (size_binop (PLUS_EXPR, DR_OFFSET (d), DR_INIT (d))),
+ seg_len (len) {}
+
+ data_reference_p dr;
+ tree offset;
+ tree seg_len;
+};
+
+/* This struct contains two dr_with_seg_len objects with aliasing data
+ refs. Two comparisons are generated from them. */
+
+struct dr_with_seg_len_pair_t
+{
+ dr_with_seg_len_pair_t (const dr_with_seg_len& d1,
+ const dr_with_seg_len& d2)
+ : first (d1), second (d2) {}
+
+ dr_with_seg_len first;
+ dr_with_seg_len second;
+};
typedef struct _vect_peel_info
struct _vect_peel_info peel_info;
unsigned int inside_cost;
unsigned int outside_cost;
+ stmt_vector_for_cost body_cost_vec;
} *vect_peel_extended_info;
+
+/* Peeling hashtable helpers. */
+
+struct peel_info_hasher : typed_free_remove <_vect_peel_info>
+{
+ typedef _vect_peel_info value_type;
+ typedef _vect_peel_info compare_type;
+ static inline hashval_t hash (const value_type *);
+ static inline bool equal (const value_type *, const compare_type *);
+};
+
+inline hashval_t
+peel_info_hasher::hash (const value_type *peel_info)
+{
+ return (hashval_t) peel_info->npeel;
+}
+
+inline bool
+peel_info_hasher::equal (const value_type *a, const compare_type *b)
+{
+ return (a->npeel == b->npeel);
+}
+
+
/*-----------------------------------------------------------------*/
/* Info on vectorized loops. */
/*-----------------------------------------------------------------*/
/* The loop basic blocks. */
basic_block *bbs;
+ /* Number of latch executions. */
+ tree num_itersm1;
/* Number of iterations. */
tree num_iters;
+ /* Number of iterations of the original loop. */
tree num_iters_unchanged;
/* Minimum number of iterations below which vectorization is expected to
values unknown at compile time. */
int min_profitable_iters;
+ /* Threshold of number of iterations below which vectorzation will not be
+ performed. It is calculated from MIN_PROFITABLE_ITERS and
+ PARAM_MIN_VECT_LOOP_BOUND. */
+ unsigned int th;
+
/* Is the loop vectorizable? */
bool vectorizable;
/* Unrolling factor */
int vectorization_factor;
- /* The loop location in the source. */
- LOC loop_line_number;
-
/* Unknown DRs according to which loop was peeled. */
struct data_reference *unaligned_dr;
int ptr_mask;
/* The loop nest in which the data dependences are computed. */
- VEC (loop_p, heap) *loop_nest;
+ vec<loop_p> loop_nest;
/* All data references in the loop. */
- VEC (data_reference_p, heap) *datarefs;
+ vec<data_reference_p> datarefs;
/* All data dependences in the loop. */
- VEC (ddr_p, heap) *ddrs;
+ vec<ddr_p> ddrs;
/* Data Dependence Relations defining address ranges that are candidates
for a run-time aliasing check. */
- VEC (ddr_p, heap) *may_alias_ddrs;
+ vec<ddr_p> may_alias_ddrs;
+
+ /* Data Dependence Relations defining address ranges together with segment
+ lengths from which the run-time aliasing check is built. */
+ vec<dr_with_seg_len_pair_t> comp_alias_ddrs;
/* Statements in the loop that have data references that are candidates for a
runtime (loop versioning) misalignment check. */
- VEC(gimple,heap) *may_misalign_stmts;
+ vec<gimple> may_misalign_stmts;
/* All interleaving chains of stores in the loop, represented by the first
stmt in the chain. */
- VEC(gimple, heap) *strided_stores;
+ vec<gimple> grouped_stores;
- /* All SLP instances in the loop. This is a subset of the set of STRIDED_STORES
+ /* All SLP instances in the loop. This is a subset of the set of GROUP_STORES
of the loop. */
- VEC(slp_instance, heap) *slp_instances;
+ vec<slp_instance> slp_instances;
/* 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. */
unsigned slp_unrolling_factor;
/* Reduction cycles detected in the loop. Used in loop-aware SLP. */
- VEC (gimple, heap) *reductions;
+ vec<gimple> reductions;
/* All reduction chains in the loop, represented by the first
stmt in the chain. */
- VEC (gimple, heap) *reduction_chains;
+ vec<gimple> reduction_chains;
/* Hash table used to choose the best peeling option. */
- htab_t peeling_htab;
+ hash_table<peel_info_hasher> *peeling_htab;
+
+ /* Cost data used by the target cost model. */
+ void *target_cost_data;
- /* When we have strided data accesses with gaps, we may introduce invalid
+ /* 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. */
bool peeling_for_gaps;
+ /* When the number of iterations is not a multiple of the vector size
+ we need to peel off iterations at the end to form an epilogue loop. */
+ bool peeling_for_niter;
+
+ /* 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. */
+ bool operands_swapped;
+
+ /* True if there are no loop carried data dependencies in the loop.
+ If loop->safelen <= 1, then this is always true, either the loop
+ didn't have any loop carried data dependencies, or the loop is being
+ vectorized guarded with some runtime alias checks, or couldn't
+ be vectorized at all, but then this field shouldn't be used.
+ For loop->safelen >= 2, the user has asserted that there are no
+ backward dependencies, but there still could be loop carried forward
+ dependencies in such loops. This flag will be false if normal
+ vectorizer data dependency analysis would fail or require versioning
+ for alias, but because of loop->safelen >= 2 it has been vectorized
+ even without versioning for alias. E.g. in:
+ #pragma omp simd
+ for (int i = 0; i < m; i++)
+ a[i] = a[i + k] * c;
+ (or #pragma simd or #pragma ivdep) we can vectorize this and it will
+ DTRT even for k > 0 && k < m, but without safelen we would not
+ vectorize this, so this field would be false. */
+ bool no_data_dependencies;
+
+ /* If if-conversion versioned this loop before conversion, this is the
+ loop version without if-conversion. */
+ struct loop *scalar_loop;
+
} *loop_vec_info;
/* Access Functions. */
#define LOOP_VINFO_LOOP(L) (L)->loop
#define LOOP_VINFO_BBS(L) (L)->bbs
+#define LOOP_VINFO_NITERSM1(L) (L)->num_itersm1
#define LOOP_VINFO_NITERS(L) (L)->num_iters
-/* Since LOOP_VINFO_NITERS can change after prologue peeling
- retain total unchanged scalar loop iterations for cost model. */
+/* Since LOOP_VINFO_NITERS and LOOP_VINFO_NITERSM1 can change after
+ prologue peeling retain total unchanged scalar loop iterations for
+ cost model. */
#define LOOP_VINFO_NITERS_UNCHANGED(L) (L)->num_iters_unchanged
#define LOOP_VINFO_COST_MODEL_MIN_ITERS(L) (L)->min_profitable_iters
+#define LOOP_VINFO_COST_MODEL_THRESHOLD(L) (L)->th
#define LOOP_VINFO_VECTORIZABLE_P(L) (L)->vectorizable
#define LOOP_VINFO_VECT_FACTOR(L) (L)->vectorization_factor
#define LOOP_VINFO_PTR_MASK(L) (L)->ptr_mask
#define LOOP_VINFO_DATAREFS(L) (L)->datarefs
#define LOOP_VINFO_DDRS(L) (L)->ddrs
#define LOOP_VINFO_INT_NITERS(L) (TREE_INT_CST_LOW ((L)->num_iters))
-#define LOOP_PEELING_FOR_ALIGNMENT(L) (L)->peeling_for_alignment
+#define LOOP_VINFO_PEELING_FOR_ALIGNMENT(L) (L)->peeling_for_alignment
#define LOOP_VINFO_UNALIGNED_DR(L) (L)->unaligned_dr
#define LOOP_VINFO_MAY_MISALIGN_STMTS(L) (L)->may_misalign_stmts
-#define LOOP_VINFO_LOC(L) (L)->loop_line_number
#define LOOP_VINFO_MAY_ALIAS_DDRS(L) (L)->may_alias_ddrs
-#define LOOP_VINFO_STRIDED_STORES(L) (L)->strided_stores
+#define LOOP_VINFO_COMP_ALIAS_DDRS(L) (L)->comp_alias_ddrs
+#define LOOP_VINFO_GROUPED_STORES(L) (L)->grouped_stores
#define LOOP_VINFO_SLP_INSTANCES(L) (L)->slp_instances
#define LOOP_VINFO_SLP_UNROLLING_FACTOR(L) (L)->slp_unrolling_factor
#define LOOP_VINFO_REDUCTIONS(L) (L)->reductions
#define LOOP_VINFO_REDUCTION_CHAINS(L) (L)->reduction_chains
#define LOOP_VINFO_PEELING_HTAB(L) (L)->peeling_htab
+#define LOOP_VINFO_TARGET_COST_DATA(L) (L)->target_cost_data
#define LOOP_VINFO_PEELING_FOR_GAPS(L) (L)->peeling_for_gaps
+#define LOOP_VINFO_OPERANDS_SWAPPED(L) (L)->operands_swapped
+#define LOOP_VINFO_PEELING_FOR_NITER(L) (L)->peeling_for_niter
+#define LOOP_VINFO_NO_DATA_DEPENDENCIES(L) (L)->no_data_dependencies
+#define LOOP_VINFO_SCALAR_LOOP(L) (L)->scalar_loop
#define LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT(L) \
-VEC_length (gimple, (L)->may_misalign_stmts) > 0
+ ((L)->may_misalign_stmts.length () > 0)
#define LOOP_REQUIRES_VERSIONING_FOR_ALIAS(L) \
-VEC_length (ddr_p, (L)->may_alias_ddrs) > 0
-
-#define NITERS_KNOWN_P(n) \
-(host_integerp ((n),0) \
-&& TREE_INT_CST_LOW ((n)) > 0)
+ ((L)->may_alias_ddrs.length () > 0)
#define LOOP_VINFO_NITERS_KNOWN_P(L) \
-NITERS_KNOWN_P((L)->num_iters)
+ (tree_fits_shwi_p ((L)->num_iters) && tree_to_shwi ((L)->num_iters) > 0)
static inline loop_vec_info
loop_vec_info_for_loop (struct loop *loop)
basic_block bb;
/* All interleaving chains of stores in the basic block, represented by the
first stmt in the chain. */
- VEC(gimple, heap) *strided_stores;
+ vec<gimple> grouped_stores;
/* All SLP instances in the basic block. This is a subset of the set of
- STRIDED_STORES of the basic block. */
- VEC(slp_instance, heap) *slp_instances;
+ GROUP_STORES of the basic block. */
+ vec<slp_instance> slp_instances;
/* All data references in the basic block. */
- VEC (data_reference_p, heap) *datarefs;
+ vec<data_reference_p> datarefs;
/* All data dependences in the basic block. */
- VEC (ddr_p, heap) *ddrs;
+ vec<ddr_p> ddrs;
+
+ /* Cost data used by the target cost model. */
+ void *target_cost_data;
+
} *bb_vec_info;
-#define BB_VINFO_BB(B) (B)->bb
-#define BB_VINFO_STRIDED_STORES(B) (B)->strided_stores
-#define BB_VINFO_SLP_INSTANCES(B) (B)->slp_instances
-#define BB_VINFO_DATAREFS(B) (B)->datarefs
-#define BB_VINFO_DDRS(B) (B)->ddrs
+#define BB_VINFO_BB(B) (B)->bb
+#define BB_VINFO_GROUPED_STORES(B) (B)->grouped_stores
+#define BB_VINFO_SLP_INSTANCES(B) (B)->slp_instances
+#define BB_VINFO_DATAREFS(B) (B)->datarefs
+#define BB_VINFO_DDRS(B) (B)->ddrs
+#define BB_VINFO_TARGET_COST_DATA(B) (B)->target_cost_data
static inline bb_vec_info
vec_info_for_bb (basic_block bb)
shift_vec_info_type,
op_vec_info_type,
call_vec_info_type,
+ call_simd_clone_vec_info_type,
assignment_vec_info_type,
condition_vec_info_type,
reduc_vec_info_type,
typedef struct data_reference *dr_p;
-DEF_VEC_P(dr_p);
-DEF_VEC_ALLOC_P(dr_p,heap);
typedef struct _stmt_vec_info {
/* Stmt is part of some pattern (computation idiom) */
bool in_pattern_p;
- /* For loads only, if there is a store with the same location, this field is
- TRUE. */
- bool read_write_dep;
-
/* The stmt to which this info struct refers to. */
gimple stmt;
tree dr_step;
tree dr_aligned_to;
+ /* For loop PHI nodes, the evolution part of it. This makes sure
+ this information is still available in vect_update_ivs_after_vectorizer
+ where we may not be able to re-analyze the PHI nodes evolution as
+ peeling for the prologue loop can make it unanalyzable. The evolution
+ part is still correct though. */
+ tree loop_phi_evolution_part;
+
/* Used for various bookkeeping purposes, generally holding a pointer to
some other stmt S that is in some way "related" to this stmt.
Current use of this field is:
/* List of datarefs that are known to have the same alignment as the dataref
of this stmt. */
- VEC(dr_p,heap) *same_align_refs;
+ vec<dr_p> same_align_refs;
+
+ /* Selected SIMD clone's function decl. */
+ tree simd_clone_fndecl;
/* Classify the def of this stmt. */
enum vect_def_type def_type;
is 1. */
unsigned int gap;
+ /* The minimum negative dependence distance this stmt participates in
+ or zero if none. */
+ unsigned int min_neg_dist;
+
/* Not all stmts in the loop need to be vectorized. e.g, the increment
of the loop induction variable and computation of array indexes. relevant
indicates whether the stmt needs to be vectorized. */
enum vect_relevant relevant;
- /* Vectorization costs associated with statement. */
- struct
- {
- int outside_of_loop; /* Statements generated outside loop. */
- int inside_of_loop; /* Statements generated inside loop. */
- } cost;
-
/* The bb_vec_info with respect to which STMT is vectorized. */
bb_vec_info bb_vinfo;
/* For loads only, true if this is a gather load. */
bool gather_p;
+ bool stride_load_p;
+
+ /* For both loads and stores. */
+ bool simd_lane_access_p;
} *stmt_vec_info;
/* Access Functions. */
#define STMT_VINFO_VECTORIZABLE(S) (S)->vectorizable
#define STMT_VINFO_DATA_REF(S) (S)->data_ref_info
#define STMT_VINFO_GATHER_P(S) (S)->gather_p
+#define STMT_VINFO_STRIDE_LOAD_P(S) (S)->stride_load_p
+#define STMT_VINFO_SIMD_LANE_ACCESS_P(S) (S)->simd_lane_access_p
#define STMT_VINFO_DR_BASE_ADDRESS(S) (S)->dr_base_address
#define STMT_VINFO_DR_INIT(S) (S)->dr_init
#define STMT_VINFO_RELATED_STMT(S) (S)->related_stmt
#define STMT_VINFO_PATTERN_DEF_SEQ(S) (S)->pattern_def_seq
#define STMT_VINFO_SAME_ALIGN_REFS(S) (S)->same_align_refs
+#define STMT_VINFO_SIMD_CLONE_FNDECL(S) (S)->simd_clone_fndecl
#define STMT_VINFO_DEF_TYPE(S) (S)->def_type
#define STMT_VINFO_GROUP_FIRST_ELEMENT(S) (S)->first_element
#define STMT_VINFO_GROUP_NEXT_ELEMENT(S) (S)->next_element
#define STMT_VINFO_GROUP_STORE_COUNT(S) (S)->store_count
#define STMT_VINFO_GROUP_GAP(S) (S)->gap
#define STMT_VINFO_GROUP_SAME_DR_STMT(S) (S)->same_dr_stmt
-#define STMT_VINFO_GROUP_READ_WRITE_DEPENDENCE(S) (S)->read_write_dep
-#define STMT_VINFO_STRIDED_ACCESS(S) ((S)->first_element != NULL && (S)->data_ref_info)
+#define STMT_VINFO_GROUPED_ACCESS(S) ((S)->first_element != NULL && (S)->data_ref_info)
+#define STMT_VINFO_LOOP_PHI_EVOLUTION_PART(S) (S)->loop_phi_evolution_part
+#define STMT_VINFO_MIN_NEG_DIST(S) (S)->min_neg_dist
#define GROUP_FIRST_ELEMENT(S) (S)->first_element
#define GROUP_NEXT_ELEMENT(S) (S)->next_element
#define GROUP_STORE_COUNT(S) (S)->store_count
#define GROUP_GAP(S) (S)->gap
#define GROUP_SAME_DR_STMT(S) (S)->same_dr_stmt
-#define GROUP_READ_WRITE_DEPENDENCE(S) (S)->read_write_dep
#define STMT_VINFO_RELEVANT_P(S) ((S)->relevant != vect_unused_in_scope)
-#define STMT_VINFO_OUTSIDE_OF_LOOP_COST(S) (S)->cost.outside_of_loop
-#define STMT_VINFO_INSIDE_OF_LOOP_COST(S) (S)->cost.inside_of_loop
#define HYBRID_SLP_STMT(S) ((S)->slp_type == hybrid)
#define PURE_SLP_STMT(S) ((S)->slp_type == pure_slp)
#define STMT_SLP_TYPE(S) (S)->slp_type
+struct dataref_aux {
+ tree base_decl;
+ bool base_misaligned;
+ int misalignment;
+};
+
#define VECT_MAX_COST 1000
/* The maximum number of intermediate steps required in multi-step type
conversion. */
#define MAX_INTERM_CVT_STEPS 3
-/* The maximum vectorization factor supported by any target (V32QI). */
-#define MAX_VECTORIZATION_FACTOR 32
+/* The maximum vectorization factor supported by any target (V64QI). */
+#define MAX_VECTORIZATION_FACTOR 64
/* Avoid GTY(()) on stmt_vec_info. */
typedef void *vec_void_p;
-DEF_VEC_P (vec_void_p);
-DEF_VEC_ALLOC_P (vec_void_p, heap);
-extern VEC(vec_void_p,heap) *stmt_vec_info_vec;
+extern vec<vec_void_p> stmt_vec_info_vec;
void init_stmt_vec_info_vec (void);
void free_stmt_vec_info_vec (void);
if (uid == 0)
return NULL;
- return (stmt_vec_info) VEC_index (vec_void_p, stmt_vec_info_vec, uid - 1);
+ return (stmt_vec_info) stmt_vec_info_vec[uid - 1];
}
/* Set vectorizer information INFO for STMT. */
if (uid == 0)
{
gcc_checking_assert (info);
- uid = VEC_length (vec_void_p, stmt_vec_info_vec) + 1;
+ uid = stmt_vec_info_vec.length () + 1;
gimple_set_uid (stmt, uid);
- VEC_safe_push (vec_void_p, heap, stmt_vec_info_vec, (vec_void_p) info);
+ stmt_vec_info_vec.safe_push ((vec_void_p) info);
}
else
- VEC_replace (vec_void_p, stmt_vec_info_vec, uid - 1, (vec_void_p) info);
+ stmt_vec_info_vec[uid - 1] = (vec_void_p) info;
}
/* Return the earlier statement between STMT1 and STMT2. */
if (uid1 == 0 || uid2 == 0)
return NULL;
- gcc_checking_assert (uid1 <= VEC_length (vec_void_p, stmt_vec_info_vec)
- && uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec));
+ gcc_checking_assert (uid1 <= stmt_vec_info_vec.length ()
+ && uid2 <= stmt_vec_info_vec.length ());
if (uid1 < uid2)
return stmt1;
if (uid1 == 0 || uid2 == 0)
return NULL;
- gcc_assert (uid1 <= VEC_length (vec_void_p, stmt_vec_info_vec));
- gcc_assert (uid2 <= VEC_length (vec_void_p, stmt_vec_info_vec));
+ gcc_assert (uid1 <= stmt_vec_info_vec.length ());
+ gcc_assert (uid2 <= stmt_vec_info_vec.length ());
if (uid1 > uid2)
return stmt1;
return false;
}
-/* Set inside loop vectorization cost. */
+/* Return pow2 (X). */
+
+static inline int
+vect_pow2 (int x)
+{
+ int i, res = 1;
+
+ for (i = 0; i < x; i++)
+ res *= 2;
+
+ return res;
+}
+
+/* Alias targetm.vectorize.builtin_vectorization_cost. */
-static inline void
-stmt_vinfo_set_inside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node,
- int cost)
+static inline int
+builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
+ tree vectype, int misalign)
{
- if (slp_node)
- SLP_TREE_INSIDE_OF_LOOP_COST (slp_node) = cost;
- else
- STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info) = cost;
+ return targetm.vectorize.builtin_vectorization_cost (type_of_cost,
+ vectype, misalign);
}
-/* Set inside loop vectorization cost. */
+/* Get cost by calling cost target builtin. */
-static inline void
-stmt_vinfo_set_outside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node,
- int cost)
+static inline
+int vect_get_stmt_cost (enum vect_cost_for_stmt type_of_cost)
{
- if (slp_node)
- SLP_TREE_OUTSIDE_OF_LOOP_COST (slp_node) = cost;
- else
- STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info) = cost;
+ return builtin_vectorization_cost (type_of_cost, NULL, 0);
}
-/* Return pow2 (X). */
+/* Alias targetm.vectorize.init_cost. */
-static inline int
-vect_pow2 (int x)
+static inline void *
+init_cost (struct loop *loop_info)
{
- int i, res = 1;
+ return targetm.vectorize.init_cost (loop_info);
+}
- for (i = 0; i < x; i++)
- res *= 2;
+/* Alias targetm.vectorize.add_stmt_cost. */
- return res;
+static inline unsigned
+add_stmt_cost (void *data, int count, enum vect_cost_for_stmt kind,
+ stmt_vec_info stmt_info, int misalign,
+ enum vect_cost_model_location where)
+{
+ return targetm.vectorize.add_stmt_cost (data, count, kind,
+ stmt_info, misalign, where);
}
+/* Alias targetm.vectorize.finish_cost. */
+
+static inline void
+finish_cost (void *data, unsigned *prologue_cost,
+ unsigned *body_cost, unsigned *epilogue_cost)
+{
+ targetm.vectorize.finish_cost (data, prologue_cost, body_cost, epilogue_cost);
+}
+
+/* Alias targetm.vectorize.destroy_cost_data. */
+
+static inline void
+destroy_cost_data (void *data)
+{
+ targetm.vectorize.destroy_cost_data (data);
+}
+
+
/*-----------------------------------------------------------------*/
/* Info on data references alignment. */
/*-----------------------------------------------------------------*/
+inline void
+set_dr_misalignment (struct data_reference *dr, int val)
+{
+ dataref_aux *data_aux = (dataref_aux *) dr->aux;
+
+ if (!data_aux)
+ {
+ data_aux = XCNEW (dataref_aux);
+ dr->aux = data_aux;
+ }
+
+ data_aux->misalignment = val;
+}
+
+inline int
+dr_misalignment (struct data_reference *dr)
+{
+ gcc_assert (dr->aux);
+ return ((dataref_aux *) dr->aux)->misalignment;
+}
/* Reflects actual alignment of first access in the vectorized loop,
taking into account peeling/versioning if applied. */
-#define DR_MISALIGNMENT(DR) ((int) (size_t) (DR)->aux)
-#define SET_DR_MISALIGNMENT(DR, VAL) ((DR)->aux = (void *) (size_t) (VAL))
+#define DR_MISALIGNMENT(DR) dr_misalignment (DR)
+#define SET_DR_MISALIGNMENT(DR, VAL) set_dr_misalignment (DR, VAL)
/* Return TRUE if the data access is aligned, and FALSE otherwise. */
return (DR_MISALIGNMENT (data_ref_info) != -1);
}
-/* vect_dump will be set to stderr or dump_file if exist. */
-extern FILE *vect_dump;
-extern LOC vect_loop_location;
+
+/* Return true if the vect cost model is unlimited. */
+static inline bool
+unlimited_cost_model (loop_p loop)
+{
+ if (loop != NULL && loop->force_vectorize
+ && flag_simd_cost_model != VECT_COST_MODEL_DEFAULT)
+ return flag_simd_cost_model == VECT_COST_MODEL_UNLIMITED;
+ return (flag_vect_cost_model == VECT_COST_MODEL_UNLIMITED);
+}
+
+/* Source location */
+extern source_location vect_location;
/*-----------------------------------------------------------------*/
/* Function prototypes. */
in tree-vect-loop-manip.c. */
extern void slpeel_make_loop_iterate_ntimes (struct loop *, tree);
extern bool slpeel_can_duplicate_loop_p (const struct loop *, const_edge);
-extern void vect_loop_versioning (loop_vec_info, bool, tree *, gimple_seq *);
-extern void vect_do_peeling_for_loop_bound (loop_vec_info, tree *,
- tree, gimple_seq);
-extern void vect_do_peeling_for_alignment (loop_vec_info);
-extern LOC find_loop_location (struct loop *);
+struct loop *slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *,
+ struct loop *, edge);
+extern void vect_loop_versioning (loop_vec_info, unsigned int, bool);
+extern void vect_do_peeling_for_loop_bound (loop_vec_info, tree, tree,
+ unsigned int, bool);
+extern void vect_do_peeling_for_alignment (loop_vec_info, tree,
+ unsigned int, bool);
+extern source_location find_loop_location (struct loop *);
extern bool vect_can_advance_ivs_p (loop_vec_info);
/* In tree-vect-stmts.c. */
extern unsigned int current_vector_size;
extern tree get_vectype_for_scalar_type (tree);
extern tree get_same_sized_vectype (tree, tree);
-extern bool vect_is_simple_use (tree, loop_vec_info, bb_vec_info, gimple *,
+extern bool vect_is_simple_use (tree, gimple, loop_vec_info,
+ bb_vec_info, gimple *,
tree *, enum vect_def_type *);
-extern bool vect_is_simple_use_1 (tree, loop_vec_info, bb_vec_info, gimple *,
+extern bool vect_is_simple_use_1 (tree, gimple, loop_vec_info,
+ bb_vec_info, gimple *,
tree *, enum vect_def_type *, tree *);
extern bool supportable_widening_operation (enum tree_code, gimple, tree, tree,
- tree *, tree *, enum tree_code *,
- enum tree_code *, int *,
- VEC (tree, heap) **);
+ enum tree_code *, enum tree_code *,
+ int *, vec<tree> *);
extern bool supportable_narrowing_operation (enum tree_code, tree, tree,
enum tree_code *,
- int *, VEC (tree, heap) **);
+ int *, vec<tree> *);
extern stmt_vec_info new_stmt_vec_info (gimple stmt, loop_vec_info,
bb_vec_info);
extern void free_stmt_vec_info (gimple stmt);
extern tree vectorizable_function (gimple, tree, tree);
extern void vect_model_simple_cost (stmt_vec_info, int, enum vect_def_type *,
- slp_tree);
+ stmt_vector_for_cost *,
+ stmt_vector_for_cost *);
extern void vect_model_store_cost (stmt_vec_info, int, bool,
- enum vect_def_type, slp_tree);
-extern void vect_model_load_cost (stmt_vec_info, int, bool, slp_tree);
+ enum vect_def_type, slp_tree,
+ stmt_vector_for_cost *,
+ stmt_vector_for_cost *);
+extern void vect_model_load_cost (stmt_vec_info, int, bool, slp_tree,
+ stmt_vector_for_cost *,
+ stmt_vector_for_cost *);
+extern unsigned record_stmt_cost (stmt_vector_for_cost *, int,
+ enum vect_cost_for_stmt, stmt_vec_info,
+ int, enum vect_cost_model_location);
extern void vect_finish_stmt_generation (gimple, gimple,
gimple_stmt_iterator *);
extern bool vect_mark_stmts_to_be_vectorized (loop_vec_info);
-extern int cost_for_stmt (gimple);
extern tree vect_get_vec_def_for_operand (tree, gimple, tree *);
extern tree vect_init_vector (gimple, tree, tree,
gimple_stmt_iterator *);
extern bool vectorizable_condition (gimple, gimple_stmt_iterator *, gimple *,
tree, int, slp_tree);
extern void vect_get_load_cost (struct data_reference *, int, bool,
- unsigned int *, unsigned int *);
-extern void vect_get_store_cost (struct data_reference *, int, unsigned int *);
+ unsigned int *, unsigned int *,
+ stmt_vector_for_cost *,
+ stmt_vector_for_cost *, bool);
+extern void vect_get_store_cost (struct data_reference *, int,
+ unsigned int *, stmt_vector_for_cost *);
extern bool vect_supportable_shift (enum tree_code, tree);
-extern void vect_get_vec_defs (tree, tree, gimple, VEC (tree, heap) **,
- VEC (tree, heap) **, slp_tree, int);
-extern tree vect_gen_perm_mask (tree, unsigned char *);
+extern void vect_get_vec_defs (tree, tree, gimple, vec<tree> *,
+ vec<tree> *, slp_tree, int);
+extern tree vect_gen_perm_mask_any (tree, const unsigned char *);
+extern tree vect_gen_perm_mask_checked (tree, const unsigned char *);
/* In tree-vect-data-refs.c. */
extern bool vect_can_force_dr_alignment_p (const_tree, unsigned int);
(struct data_reference *, bool);
extern tree vect_get_smallest_scalar_type (gimple, HOST_WIDE_INT *,
HOST_WIDE_INT *);
-extern bool vect_analyze_data_ref_dependences (loop_vec_info, bb_vec_info,
- int *);
+extern bool vect_analyze_data_ref_dependences (loop_vec_info, int *);
+extern bool vect_slp_analyze_data_ref_dependences (bb_vec_info);
extern bool vect_enhance_data_refs_alignment (loop_vec_info);
extern bool vect_analyze_data_refs_alignment (loop_vec_info, bb_vec_info);
extern bool vect_verify_datarefs_alignment (loop_vec_info, bb_vec_info);
extern bool vect_prune_runtime_alias_test_list (loop_vec_info);
extern tree vect_check_gather (gimple, loop_vec_info, tree *, tree *,
int *);
-extern bool vect_analyze_data_refs (loop_vec_info, bb_vec_info, int *);
+extern bool vect_analyze_data_refs (loop_vec_info, bb_vec_info, int *,
+ unsigned *);
extern tree vect_create_data_ref_ptr (gimple, tree, struct loop *, tree,
tree *, gimple_stmt_iterator *,
- gimple *, bool, bool *);
+ gimple *, bool, bool *,
+ tree = NULL_TREE);
extern tree bump_vector_ptr (tree, gimple, gimple_stmt_iterator *, gimple, tree);
extern tree vect_create_destination_var (tree, tree);
-extern bool vect_strided_store_supported (tree, unsigned HOST_WIDE_INT);
+extern bool vect_grouped_store_supported (tree, unsigned HOST_WIDE_INT);
extern bool vect_store_lanes_supported (tree, unsigned HOST_WIDE_INT);
-extern bool vect_strided_load_supported (tree, unsigned HOST_WIDE_INT);
+extern bool vect_grouped_load_supported (tree, unsigned HOST_WIDE_INT);
extern bool vect_load_lanes_supported (tree, unsigned HOST_WIDE_INT);
-extern void vect_permute_store_chain (VEC(tree,heap) *,unsigned int, gimple,
- gimple_stmt_iterator *, VEC(tree,heap) **);
+extern void vect_permute_store_chain (vec<tree> ,unsigned int, gimple,
+ gimple_stmt_iterator *, vec<tree> *);
extern tree vect_setup_realignment (gimple, gimple_stmt_iterator *, tree *,
enum dr_alignment_support, tree,
struct loop **);
-extern void vect_transform_strided_load (gimple, VEC(tree,heap) *, int,
+extern void vect_transform_grouped_load (gimple, vec<tree> , int,
gimple_stmt_iterator *);
-extern void vect_record_strided_load_vectors (gimple, VEC(tree,heap) *);
-extern int vect_get_place_in_interleaving_chain (gimple, gimple);
+extern void vect_record_grouped_load_vectors (gimple, vec<tree> );
extern tree vect_get_new_vect_var (tree, enum vect_var_kind, const char *);
extern tree vect_create_addr_base_for_vector_ref (gimple, gimple_seq *,
- tree, struct loop *);
+ tree, struct loop *,
+ tree = NULL_TREE);
/* In tree-vect-loop.c. */
/* FORNOW: Used in tree-parloops.c. */
extern bool vectorizable_reduction (gimple, gimple_stmt_iterator *, gimple *,
slp_tree);
extern bool vectorizable_induction (gimple, gimple_stmt_iterator *, gimple *);
-extern int vect_estimate_min_profitable_iters (loop_vec_info);
extern tree get_initial_def_for_reduction (gimple, tree, tree *);
extern int vect_min_worthwhile_factor (enum tree_code);
-extern int vect_get_known_peeling_cost (loop_vec_info, int, int *, int);
-extern int vect_get_single_scalar_iteraion_cost (loop_vec_info);
+extern int vect_get_known_peeling_cost (loop_vec_info, int, int *, int,
+ stmt_vector_for_cost *,
+ stmt_vector_for_cost *);
+extern int vect_get_single_scalar_iteration_cost (loop_vec_info);
/* In tree-vect-slp.c. */
extern void vect_free_slp_instance (slp_instance);
-extern bool vect_transform_slp_perm_load (gimple, VEC (tree, heap) *,
+extern bool vect_transform_slp_perm_load (slp_tree, vec<tree> ,
gimple_stmt_iterator *, int,
slp_instance, bool);
extern bool vect_schedule_slp (loop_vec_info, bb_vec_info);
extern void vect_update_slp_costs_according_to_vf (loop_vec_info);
-extern bool vect_analyze_slp (loop_vec_info, bb_vec_info);
+extern bool vect_analyze_slp (loop_vec_info, bb_vec_info, unsigned);
extern bool vect_make_slp_decision (loop_vec_info);
extern void vect_detect_hybrid_slp (loop_vec_info);
-extern void vect_get_slp_defs (VEC (tree, heap) *, slp_tree,
- VEC (slp_void_p, heap) **, int);
+extern void vect_get_slp_defs (vec<tree> , slp_tree,
+ vec<vec<tree> > *, int);
-extern LOC find_bb_location (basic_block);
+extern source_location find_bb_location (basic_block);
extern bb_vec_info vect_slp_analyze_bb (basic_block);
extern void vect_slp_transform_bb (basic_block);
/* Pattern recognition functions.
Additional pattern recognition functions can (and will) be added
in the future. */
-typedef gimple (* vect_recog_func_ptr) (VEC (gimple, heap) **, tree *, tree *);
-#define NUM_PATTERNS 10
-void vect_pattern_recog (loop_vec_info);
+typedef gimple (* vect_recog_func_ptr) (vec<gimple> *, tree *, tree *);
+#define NUM_PATTERNS 12
+void vect_pattern_recog (loop_vec_info, bb_vec_info);
/* In tree-vectorizer.c. */
unsigned vectorize_loops (void);
-/* Vectorization debug information */
-extern bool vect_print_dump_info (enum vect_verbosity_levels);
+void vect_destroy_datarefs (loop_vec_info, bb_vec_info);
#endif /* GCC_TREE_VECTORIZER_H */
projects / gcc.git / blobdiff