+2014-04-15 Eric Botcazou <ebotcazou@adacore.com>
+
+ * cfgloop.h (struct loop): Move force_vectorize down.
+ * gimplify.c (gimple_boolify) <ANNOTATE_EXPR>: Handle new kinds.
+ (gimplify_expr) <ANNOTATE_EXPR>: Minor tweak.
+ * lto-streamer-in.c (input_cfg): Read dont_vectorize field.
+ * lto-streamer-out.c (output_cfg): Write dont_vectorize field.
+ * tree-cfg.c (replace_loop_annotate): Revamp and handle new kinds.
+ * tree-core.h (enum annot_expr_kind): Add new kind values.
+ * tree-inline.c (copy_loops): Copy dont_vectorize field and reorder.
+ * tree-pretty-print.c (dump_generic_node) <ANNOTATE_EXPR>: Handle new
+ kinds.
+ * tree.def (ANNOTATE_EXPR): Tweak comment.
+
2014-04-14 Jan Hubicka <hubicka@ucw.cz>
* ipa-devirt.c (maybe_record_node): Ignore all non-methods (including
+2014-04-15 Eric Botcazou <ebotcazou@adacore.com>
+
+ * gcc-interface/trans.c (gnat_gimplify_stmt): Propagate loop hints.
+
2014-04-14 Paolo Carlini <paolo.carlini@oracle.com>
* gcc-interface/decl.c (gnat_to_gnu_entity, components_to_record):
build_int_cst (integer_type_node,
annot_expr_ivdep_kind));
+ if (LOOP_STMT_NO_VECTOR (stmt))
+ gnu_cond = build2 (ANNOTATE_EXPR, TREE_TYPE (gnu_cond), gnu_cond,
+ build_int_cst (integer_type_node,
+ annot_expr_no_vector_kind));
+ if (LOOP_STMT_VECTOR (stmt))
+ gnu_cond = build2 (ANNOTATE_EXPR, TREE_TYPE (gnu_cond), gnu_cond,
+ build_int_cst (integer_type_node,
+ annot_expr_vector_kind));
+
gnu_cond
= build3 (COND_EXPR, void_type_node, gnu_cond, NULL_TREE,
build1 (GOTO_EXPR, void_type_node, gnu_end_label));
of the loop can be safely evaluated concurrently. */
int safelen;
- /* True if we should try harder to vectorize this loop. */
- bool force_vectorize;
-
/* True if this loop should never be vectorized. */
bool dont_vectorize;
+ /* True if we should try harder to vectorize this loop. */
+ bool force_vectorize;
+
/* For SIMD loops, this is a unique identifier of the loop, referenced
by IFN_GOMP_SIMD_VF, IFN_GOMP_SIMD_LANE and IFN_GOMP_SIMD_LAST_LANE
builtins. */
return expr;
case ANNOTATE_EXPR:
- if ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (expr, 1))
- == annot_expr_ivdep_kind)
+ switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)))
{
+ case annot_expr_ivdep_kind:
+ case annot_expr_no_vector_kind:
+ case annot_expr_vector_kind:
TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
if (TREE_CODE (type) != BOOLEAN_TYPE)
TREE_TYPE (expr) = boolean_type_node;
return expr;
+ default:
+ gcc_unreachable ();
}
- /* FALLTHRU */
default:
if (COMPARISON_CLASS_P (expr))
case ANNOTATE_EXPR:
{
tree cond = TREE_OPERAND (*expr_p, 0);
- tree id = TREE_OPERAND (*expr_p, 1);
+ tree kind = TREE_OPERAND (*expr_p, 1);
tree type = TREE_TYPE (cond);
if (!INTEGRAL_TYPE_P (type))
{
}
tree tmp = create_tmp_var (type, NULL);
gimplify_arg (&cond, pre_p, EXPR_LOCATION (*expr_p));
- gimple call = gimple_build_call_internal (IFN_ANNOTATE, 2,
- cond, id);
+ gimple call
+ = gimple_build_call_internal (IFN_ANNOTATE, 2, cond, kind);
gimple_call_set_lhs (call, tmp);
gimplify_seq_add_stmt (pre_p, call);
*expr_p = tmp;
/* Read OMP SIMD related info. */
loop->safelen = streamer_read_hwi (ib);
+ loop->dont_vectorize = streamer_read_hwi (ib);
loop->force_vectorize = streamer_read_hwi (ib);
loop->simduid = stream_read_tree (ib, data_in);
/* Write OMP SIMD related info. */
streamer_write_hwi (ob, loop->safelen);
+ streamer_write_hwi (ob, loop->dont_vectorize);
streamer_write_hwi (ob, loop->force_vectorize);
stream_write_tree (ob, loop->simduid, true);
}
+2014-04-15 Eric Botcazou <ebotcazou@adacore.com>
+
+ * gnat.dg/vect12.ad[sb]: New test.
+ * gnat.dg/vect13.ad[sb]: Likewise.
+
2014-04-15 Max Ostapenko <m.ostapenko@partner.samsung.com>
* c-c++-common/asan/null-deref-1.c: Change regexp to pass test
--- /dev/null
+-- { dg-do compile { target i?86-*-* x86_64-*-* } }
+-- { dg-options "-O3 -msse2 -fdump-tree-vect-details" }
+
+package body Vect12 is
+
+ function "+" (X, Y : Sarray) return Sarray is
+ R : Sarray;
+ begin
+ for I in Sarray'Range loop
+ pragma Loop_Optimize (No_Vector);
+ R(I) := X(I) + Y(I);
+ end loop;
+ return R;
+ end;
+
+ procedure Add (X, Y : Sarray; R : out Sarray) is
+ begin
+ for I in Sarray'Range loop
+ pragma Loop_Optimize (No_Vector);
+ R(I) := X(I) + Y(I);
+ end loop;
+ end;
+
+end Vect12;
+
+-- { dg-final { scan-tree-dump-not "vectorized 1 loops" "vect" } }
+-- { dg-final { cleanup-tree-dump "vect" } }
--- /dev/null
+package Vect12 is
+
+ -- Constrained array types are vectorizable
+ type Sarray is array (1 .. 4) of Float;
+ for Sarray'Alignment use 16;
+
+ function "+" (X, Y : Sarray) return Sarray;
+ procedure Add (X, Y : Sarray; R : out Sarray);
+
+end Vect12;
--- /dev/null
+-- { dg-do compile { target i?86-*-* x86_64-*-* } }
+-- { dg-options "-O3 -msse2 -fdump-tree-vect-details" }
+
+package body Vect13 is
+
+ function "+" (X, Y : Sarray) return Sarray is
+ R : Sarray;
+ begin
+ for I in Sarray'Range loop
+ pragma Loop_Optimize (Vector);
+ R(I) := X(I) + Y(I);
+ end loop;
+ return R;
+ end;
+
+ procedure Add (X, Y : Sarray; R : out Sarray) is
+ begin
+ for I in Sarray'Range loop
+ pragma Loop_Optimize (Vector);
+ R(I) := X(I) + Y(I);
+ end loop;
+ end;
+
+end Vect13;
+
+-- { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" } }
+-- { dg-final { cleanup-tree-dump "vect" } }
--- /dev/null
+package Vect13 is
+
+ -- Constrained array types are vectorizable
+ type Sarray is array (1 .. 4) of Float;
+ for Sarray'Alignment use 16;
+
+ function "+" (X, Y : Sarray) return Sarray;
+ procedure Add (X, Y : Sarray; R : out Sarray);
+
+end Vect13;
}
-/* Search for ANNOTATE call with annot_expr_ivdep_kind; if found, remove
- it and set loop->safelen to INT_MAX. We assume that the annotation
- comes immediately before the condition. */
+/* Look for ANNOTATE calls with loop annotation kind; if found, remove
+ them and propagate the information to the loop. We assume that the
+ annotations come immediately before the condition of the loop. */
static void
replace_loop_annotate ()
{
gsi = gsi_last_bb (loop->header);
stmt = gsi_stmt (gsi);
- if (stmt && gimple_code (stmt) == GIMPLE_COND)
+ if (!(stmt && gimple_code (stmt) == GIMPLE_COND))
+ continue;
+ for (gsi_prev_nondebug (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
{
- gsi_prev_nondebug (&gsi);
- if (gsi_end_p (gsi))
- continue;
stmt = gsi_stmt (gsi);
if (gimple_code (stmt) != GIMPLE_CALL)
- continue;
+ break;
if (!gimple_call_internal_p (stmt)
- || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
- continue;
- if ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1))
- != annot_expr_ivdep_kind)
- continue;
+ || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
+ break;
+ switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
+ {
+ case annot_expr_ivdep_kind:
+ loop->safelen = INT_MAX;
+ break;
+ case annot_expr_no_vector_kind:
+ loop->dont_vectorize = true;
+ break;
+ case annot_expr_vector_kind:
+ loop->force_vectorize = true;
+ cfun->has_force_vectorize_loops = true;
+ break;
+ default:
+ gcc_unreachable ();
+ }
stmt = gimple_build_assign (gimple_call_lhs (stmt),
gimple_call_arg (stmt, 0));
gsi_replace (&gsi, stmt, true);
- loop->safelen = INT_MAX;
}
}
- /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
+ /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
FOR_EACH_BB_FN (bb, cfun)
{
- gsi = gsi_last_bb (bb);
- stmt = gsi_stmt (gsi);
- if (stmt && gimple_code (stmt) == GIMPLE_COND)
- gsi_prev_nondebug (&gsi);
- if (gsi_end_p (gsi))
- continue;
- stmt = gsi_stmt (gsi);
- if (gimple_code (stmt) != GIMPLE_CALL)
- continue;
- if (!gimple_call_internal_p (stmt)
- || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
- continue;
- if ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1))
- != annot_expr_ivdep_kind)
- continue;
- warning_at (gimple_location (stmt), 0, "ignoring %<GCC ivdep%> "
- "annotation");
- stmt = gimple_build_assign (gimple_call_lhs (stmt),
- gimple_call_arg (stmt, 0));
- gsi_replace (&gsi, stmt, true);
+ for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
+ {
+ stmt = gsi_stmt (gsi);
+ if (gimple_code (stmt) != GIMPLE_CALL)
+ break;
+ if (!gimple_call_internal_p (stmt)
+ || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
+ break;
+ switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
+ {
+ case annot_expr_ivdep_kind:
+ case annot_expr_no_vector_kind:
+ case annot_expr_vector_kind:
+ break;
+ default:
+ gcc_unreachable ();
+ }
+ warning_at (gimple_location (stmt), 0, "ignoring loop annotation");
+ stmt = gimple_build_assign (gimple_call_lhs (stmt),
+ gimple_call_arg (stmt, 0));
+ gsi_replace (&gsi, stmt, true);
+ }
}
}
};
enum annot_expr_kind {
- annot_expr_ivdep_kind
+ annot_expr_ivdep_kind,
+ annot_expr_no_vector_kind,
+ annot_expr_vector_kind,
+ annot_expr_kind_last
};
place_new_loop (cfun, dest_loop);
flow_loop_tree_node_add (dest_parent, dest_loop);
- if (src_loop->simduid)
- {
- dest_loop->simduid = remap_decl (src_loop->simduid, id);
- cfun->has_simduid_loops = true;
- }
+ dest_loop->safelen = src_loop->safelen;
+ dest_loop->dont_vectorize = src_loop->dont_vectorize;
if (src_loop->force_vectorize)
{
dest_loop->force_vectorize = true;
cfun->has_force_vectorize_loops = true;
}
- dest_loop->safelen = src_loop->safelen;
+ if (src_loop->simduid)
+ {
+ dest_loop->simduid = remap_decl (src_loop->simduid, id);
+ cfun->has_simduid_loops = true;
+ }
/* Recurse. */
copy_loops (id, dest_loop, src_loop);
case ANNOTATE_EXPR:
pp_string (buffer, "ANNOTATE_EXPR <");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
{
case annot_expr_ivdep_kind:
- pp_string (buffer, "ivdep, ");
+ pp_string (buffer, ", ivdep");
+ break;
+ case annot_expr_no_vector_kind:
+ pp_string (buffer, ", no-vector");
+ break;
+ case annot_expr_vector_kind:
+ pp_string (buffer, ", vector");
break;
+ default:
+ gcc_unreachable ();
}
- dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_greater (buffer);
break;
/* ANNOTATE_EXPR.
Operand 0 is the expression to be annotated.
- Operand 1 is the annotation id. */
+ Operand 1 is the annotation kind. */
DEFTREECODE (ANNOTATE_EXPR, "annotate_expr", tcc_expression, 2)
/* Cilk spawn statement
projects / platform / upstream / gcc.git / commitdiff