public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Add --param vect-single-lane-slp
@ 2023-10-19 13:28 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-10-19 13:28 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:ae99d208e6e9d8dd5b9741e40e5e2f35242e5d4f
commit ae99d208e6e9d8dd5b9741e40e5e2f35242e5d4f
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 12:54:17 2023 +0200
Add --param vect-single-lane-slp
The following adds --param vect-single-lane-slp to guard single-lane
loop SLP discovery. As first client we look at non-grouped stores
with an assert that SLP discovery works to discover gaps in it.
* params.opt (-param=vect-single-lane-slp=): New.
* tree-vect-slp.cc (vect_analyze_slp): Perform single-lane
loop SLP discovery for non-grouped stores if requested.
Diff:
---
gcc/params.opt | 4 ++++
gcc/tree-vect-slp.cc | 26 ++++++++++++++++++++++++++
2 files changed, 30 insertions(+)
diff --git a/gcc/params.opt b/gcc/params.opt
index ae2fa54fc589..8cfc9bcc60a4 100644
--- a/gcc/params.opt
+++ b/gcc/params.opt
@@ -1183,6 +1183,10 @@ The maximum factor which the loop vectorizer applies to the cost of statements i
Common Joined UInteger Var(param_vect_induction_float) Init(1) IntegerRange(0, 1) Param Optimization
Enable loop vectorization of floating point inductions.
+-param=vect-single-lane-slp=
+Common Joined UInteger Var(param_vect_single_lane_slp) Init(0) IntegerRange(0, 1) Param Optimization
+Enable single lane SLP discovery.
+
-param=vect-force-slp=
Common Joined UInteger Var(param_vect_force_slp) Init(0) IntegerRange(0, 1) Param Optimization
Fail vectorization when falling back to non-SLP.
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 8efff2e912d7..76d023fd38b4 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -3575,6 +3575,7 @@ vect_analyze_slp_instance (vec_info *vinfo,
opt_result
vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
{
+ loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
unsigned int i;
stmt_vec_info first_element;
slp_instance instance;
@@ -3590,6 +3591,31 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
FOR_EACH_VEC_ELT (vinfo->grouped_stores, i, first_element)
vect_analyze_slp_instance (vinfo, bst_map, first_element,
slp_inst_kind_store, max_tree_size, &limit);
+ if (loop_vinfo && param_vect_single_lane_slp != 0)
+ {
+ data_reference_p dr;
+ FOR_EACH_VEC_ELT (vinfo->shared->datarefs, i, dr)
+ if (DR_IS_WRITE (dr))
+ {
+ stmt_vec_info stmt_info = vinfo->lookup_dr (dr)->stmt;
+ /* It works a bit to dissolve the group but that's
+ not really what we want to do. Instead group analysis
+ above starts discovery for each lane and pieces them together
+ to a single store to the whole group. */
+ if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
+ continue;
+ vec<stmt_vec_info> stmts;
+ vec<stmt_vec_info> roots = vNULL;
+ vec<tree> remain = vNULL;
+ stmts.create (1);
+ stmts.quick_push (stmt_info);
+ bool res = vect_build_slp_instance (vinfo, slp_inst_kind_store,
+ stmts, roots, remain,
+ max_tree_size, &limit,
+ bst_map, NULL);
+ gcc_assert (res);
+ }
+ }
if (bb_vec_info bb_vinfo = dyn_cast <bb_vec_info> (vinfo))
{
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Add --param vect-single-lane-slp
@ 2024-02-23 7:31 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2024-02-23 7:31 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:f9c2a5d3b3a0438aec38a31d01d32927f8134a5d
commit f9c2a5d3b3a0438aec38a31d01d32927f8134a5d
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 12:54:17 2023 +0200
Add --param vect-single-lane-slp
The following adds --param vect-single-lane-slp to guard single-lane
loop SLP discovery. As first client we look at non-grouped stores
with an assert that SLP discovery works to discover gaps in it.
* params.opt (-param=vect-single-lane-slp=): New.
* tree-vect-slp.cc (vect_analyze_slp): Perform single-lane
loop SLP discovery for non-grouped stores if requested.
Diff:
---
gcc/params.opt | 4 ++++
gcc/tree-vect-slp.cc | 26 ++++++++++++++++++++++++++
2 files changed, 30 insertions(+)
diff --git a/gcc/params.opt b/gcc/params.opt
index e1848e6cc2af..ae5d0ed24e85 100644
--- a/gcc/params.opt
+++ b/gcc/params.opt
@@ -1198,6 +1198,10 @@ The maximum factor which the loop vectorizer applies to the cost of statements i
Common Joined UInteger Var(param_vect_induction_float) Init(1) IntegerRange(0, 1) Param Optimization
Enable loop vectorization of floating point inductions.
+-param=vect-single-lane-slp=
+Common Joined UInteger Var(param_vect_single_lane_slp) Init(0) IntegerRange(0, 1) Param Optimization
+Enable single lane SLP discovery.
+
-param=vect-force-slp=
Common Joined UInteger Var(param_vect_force_slp) Init(0) IntegerRange(0, 1) Param Optimization
Fail vectorization when falling back to non-SLP.
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 7cf9504398c9..a89836f0df35 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -3628,6 +3628,7 @@ vect_analyze_slp_instance (vec_info *vinfo,
opt_result
vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
{
+ loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
unsigned int i;
stmt_vec_info first_element;
slp_instance instance;
@@ -3643,6 +3644,31 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
FOR_EACH_VEC_ELT (vinfo->grouped_stores, i, first_element)
vect_analyze_slp_instance (vinfo, bst_map, first_element,
slp_inst_kind_store, max_tree_size, &limit);
+ if (loop_vinfo && param_vect_single_lane_slp != 0)
+ {
+ data_reference_p dr;
+ FOR_EACH_VEC_ELT (vinfo->shared->datarefs, i, dr)
+ if (DR_IS_WRITE (dr))
+ {
+ stmt_vec_info stmt_info = vinfo->lookup_dr (dr)->stmt;
+ /* It works a bit to dissolve the group but that's
+ not really what we want to do. Instead group analysis
+ above starts discovery for each lane and pieces them together
+ to a single store to the whole group. */
+ if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
+ continue;
+ vec<stmt_vec_info> stmts;
+ vec<stmt_vec_info> roots = vNULL;
+ vec<tree> remain = vNULL;
+ stmts.create (1);
+ stmts.quick_push (stmt_info);
+ bool res = vect_build_slp_instance (vinfo, slp_inst_kind_store,
+ stmts, roots, remain,
+ max_tree_size, &limit,
+ bst_map, NULL);
+ gcc_assert (res);
+ }
+ }
if (bb_vec_info bb_vinfo = dyn_cast <bb_vec_info> (vinfo))
{
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Add --param vect-single-lane-slp
@ 2023-11-09 13:03 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-11-09 13:03 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:ca77a297110c208082ce3705e06f1bbe2786a28f
commit ca77a297110c208082ce3705e06f1bbe2786a28f
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 12:54:17 2023 +0200
Add --param vect-single-lane-slp
The following adds --param vect-single-lane-slp to guard single-lane
loop SLP discovery. As first client we look at non-grouped stores
with an assert that SLP discovery works to discover gaps in it.
* params.opt (-param=vect-single-lane-slp=): New.
* tree-vect-slp.cc (vect_analyze_slp): Perform single-lane
loop SLP discovery for non-grouped stores if requested.
Diff:
---
gcc/params.opt | 4 ++++
gcc/tree-vect-slp.cc | 26 ++++++++++++++++++++++++++
2 files changed, 30 insertions(+)
diff --git a/gcc/params.opt b/gcc/params.opt
index d0b7a6d770b..3132c695fed 100644
--- a/gcc/params.opt
+++ b/gcc/params.opt
@@ -1191,6 +1191,10 @@ The maximum factor which the loop vectorizer applies to the cost of statements i
Common Joined UInteger Var(param_vect_induction_float) Init(1) IntegerRange(0, 1) Param Optimization
Enable loop vectorization of floating point inductions.
+-param=vect-single-lane-slp=
+Common Joined UInteger Var(param_vect_single_lane_slp) Init(0) IntegerRange(0, 1) Param Optimization
+Enable single lane SLP discovery.
+
-param=vect-force-slp=
Common Joined UInteger Var(param_vect_force_slp) Init(0) IntegerRange(0, 1) Param Optimization
Fail vectorization when falling back to non-SLP.
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 3e5814c3a31..30ed123d100 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -3612,6 +3612,7 @@ vect_analyze_slp_instance (vec_info *vinfo,
opt_result
vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
{
+ loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
unsigned int i;
stmt_vec_info first_element;
slp_instance instance;
@@ -3627,6 +3628,31 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
FOR_EACH_VEC_ELT (vinfo->grouped_stores, i, first_element)
vect_analyze_slp_instance (vinfo, bst_map, first_element,
slp_inst_kind_store, max_tree_size, &limit);
+ if (loop_vinfo && param_vect_single_lane_slp != 0)
+ {
+ data_reference_p dr;
+ FOR_EACH_VEC_ELT (vinfo->shared->datarefs, i, dr)
+ if (DR_IS_WRITE (dr))
+ {
+ stmt_vec_info stmt_info = vinfo->lookup_dr (dr)->stmt;
+ /* It works a bit to dissolve the group but that's
+ not really what we want to do. Instead group analysis
+ above starts discovery for each lane and pieces them together
+ to a single store to the whole group. */
+ if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
+ continue;
+ vec<stmt_vec_info> stmts;
+ vec<stmt_vec_info> roots = vNULL;
+ vec<tree> remain = vNULL;
+ stmts.create (1);
+ stmts.quick_push (stmt_info);
+ bool res = vect_build_slp_instance (vinfo, slp_inst_kind_store,
+ stmts, roots, remain,
+ max_tree_size, &limit,
+ bst_map, NULL);
+ gcc_assert (res);
+ }
+ }
if (bb_vec_info bb_vinfo = dyn_cast <bb_vec_info> (vinfo))
{
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Add --param vect-single-lane-slp
@ 2023-11-02 13:59 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-11-02 13:59 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:836c86e13fea1252963426cbc2b7578338ab4ddd
commit 836c86e13fea1252963426cbc2b7578338ab4ddd
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 12:54:17 2023 +0200
Add --param vect-single-lane-slp
The following adds --param vect-single-lane-slp to guard single-lane
loop SLP discovery. As first client we look at non-grouped stores
with an assert that SLP discovery works to discover gaps in it.
* params.opt (-param=vect-single-lane-slp=): New.
* tree-vect-slp.cc (vect_analyze_slp): Perform single-lane
loop SLP discovery for non-grouped stores if requested.
Diff:
---
gcc/params.opt | 4 ++++
gcc/tree-vect-slp.cc | 26 ++++++++++++++++++++++++++
2 files changed, 30 insertions(+)
diff --git a/gcc/params.opt b/gcc/params.opt
index d0b7a6d770b0..3132c695fed2 100644
--- a/gcc/params.opt
+++ b/gcc/params.opt
@@ -1191,6 +1191,10 @@ The maximum factor which the loop vectorizer applies to the cost of statements i
Common Joined UInteger Var(param_vect_induction_float) Init(1) IntegerRange(0, 1) Param Optimization
Enable loop vectorization of floating point inductions.
+-param=vect-single-lane-slp=
+Common Joined UInteger Var(param_vect_single_lane_slp) Init(0) IntegerRange(0, 1) Param Optimization
+Enable single lane SLP discovery.
+
-param=vect-force-slp=
Common Joined UInteger Var(param_vect_force_slp) Init(0) IntegerRange(0, 1) Param Optimization
Fail vectorization when falling back to non-SLP.
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 43d742e3c92e..c11b58107a3d 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -3612,6 +3612,7 @@ vect_analyze_slp_instance (vec_info *vinfo,
opt_result
vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
{
+ loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
unsigned int i;
stmt_vec_info first_element;
slp_instance instance;
@@ -3627,6 +3628,31 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
FOR_EACH_VEC_ELT (vinfo->grouped_stores, i, first_element)
vect_analyze_slp_instance (vinfo, bst_map, first_element,
slp_inst_kind_store, max_tree_size, &limit);
+ if (loop_vinfo && param_vect_single_lane_slp != 0)
+ {
+ data_reference_p dr;
+ FOR_EACH_VEC_ELT (vinfo->shared->datarefs, i, dr)
+ if (DR_IS_WRITE (dr))
+ {
+ stmt_vec_info stmt_info = vinfo->lookup_dr (dr)->stmt;
+ /* It works a bit to dissolve the group but that's
+ not really what we want to do. Instead group analysis
+ above starts discovery for each lane and pieces them together
+ to a single store to the whole group. */
+ if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
+ continue;
+ vec<stmt_vec_info> stmts;
+ vec<stmt_vec_info> roots = vNULL;
+ vec<tree> remain = vNULL;
+ stmts.create (1);
+ stmts.quick_push (stmt_info);
+ bool res = vect_build_slp_instance (vinfo, slp_inst_kind_store,
+ stmts, roots, remain,
+ max_tree_size, &limit,
+ bst_map, NULL);
+ gcc_assert (res);
+ }
+ }
if (bb_vec_info bb_vinfo = dyn_cast <bb_vec_info> (vinfo))
{
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Add --param vect-single-lane-slp
@ 2023-10-16 12:49 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-10-16 12:49 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:3193fdcfed995df0579224eabfe703213656ed66
commit 3193fdcfed995df0579224eabfe703213656ed66
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 12:54:17 2023 +0200
Add --param vect-single-lane-slp
The following adds --param vect-single-lane-slp to guard single-lane
loop SLP discovery. As first client we look at non-grouped stores
with an assert that SLP discovery works to discover gaps in it.
* params.opt (-param=vect-single-lane-slp=): New.
* tree-vect-slp.cc (vect_analyze_slp): Perform single-lane
loop SLP discovery for non-grouped stores if requested.
Diff:
---
gcc/params.opt | 4 ++++
gcc/tree-vect-slp.cc | 26 ++++++++++++++++++++++++++
2 files changed, 30 insertions(+)
diff --git a/gcc/params.opt b/gcc/params.opt
index ae2fa54fc589..8cfc9bcc60a4 100644
--- a/gcc/params.opt
+++ b/gcc/params.opt
@@ -1183,6 +1183,10 @@ The maximum factor which the loop vectorizer applies to the cost of statements i
Common Joined UInteger Var(param_vect_induction_float) Init(1) IntegerRange(0, 1) Param Optimization
Enable loop vectorization of floating point inductions.
+-param=vect-single-lane-slp=
+Common Joined UInteger Var(param_vect_single_lane_slp) Init(0) IntegerRange(0, 1) Param Optimization
+Enable single lane SLP discovery.
+
-param=vect-force-slp=
Common Joined UInteger Var(param_vect_force_slp) Init(0) IntegerRange(0, 1) Param Optimization
Fail vectorization when falling back to non-SLP.
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index af8f5031bd27..4e0b0436aa31 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -3534,6 +3534,7 @@ vect_analyze_slp_instance (vec_info *vinfo,
opt_result
vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
{
+ loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
unsigned int i;
stmt_vec_info first_element;
slp_instance instance;
@@ -3549,6 +3550,31 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
FOR_EACH_VEC_ELT (vinfo->grouped_stores, i, first_element)
vect_analyze_slp_instance (vinfo, bst_map, first_element,
slp_inst_kind_store, max_tree_size, &limit);
+ if (loop_vinfo && param_vect_single_lane_slp != 0)
+ {
+ data_reference_p dr;
+ FOR_EACH_VEC_ELT (vinfo->shared->datarefs, i, dr)
+ if (DR_IS_WRITE (dr))
+ {
+ stmt_vec_info stmt_info = vinfo->lookup_dr (dr)->stmt;
+ /* It works a bit to dissolve the group but that's
+ not really what we want to do. Instead group analysis
+ above starts discovery for each lane and pieces them together
+ to a single store to the whole group. */
+ if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
+ continue;
+ vec<stmt_vec_info> stmts;
+ vec<stmt_vec_info> roots = vNULL;
+ vec<tree> remain = vNULL;
+ stmts.create (1);
+ stmts.quick_push (stmt_info);
+ bool res = vect_build_slp_instance (vinfo, slp_inst_kind_store,
+ stmts, roots, remain,
+ max_tree_size, &limit,
+ bst_map, NULL);
+ gcc_assert (res);
+ }
+ }
if (bb_vec_info bb_vinfo = dyn_cast <bb_vec_info> (vinfo))
{
^ permalink raw reply [flat|nested] 6+ messages in thread
* [gcc(refs/users/rguenth/heads/vect-force-slp)] Add --param vect-single-lane-slp
@ 2023-10-06 7:06 Richard Biener
0 siblings, 0 replies; 6+ messages in thread
From: Richard Biener @ 2023-10-06 7:06 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:8799d8329d24429faf5c515f8ba5873be13adbd8
commit 8799d8329d24429faf5c515f8ba5873be13adbd8
Author: Richard Biener <rguenther@suse.de>
Date: Fri Sep 29 12:54:17 2023 +0200
Add --param vect-single-lane-slp
The following adds --param vect-single-lane-slp to guard single-lane
loop SLP discovery. As first client we look at non-grouped stores
with an assert that SLP discovery works to discover gaps in it.
* params.opt (-param=vect-single-lane-slp=): New.
* tree-vect-slp.cc (vect_analyze_slp): Perform single-lane
loop SLP discovery for non-grouped stores if requested.
Diff:
---
gcc/params.opt | 4 ++++
gcc/tree-vect-slp.cc | 26 ++++++++++++++++++++++++++
2 files changed, 30 insertions(+)
diff --git a/gcc/params.opt b/gcc/params.opt
index ae2fa54fc58..8cfc9bcc60a 100644
--- a/gcc/params.opt
+++ b/gcc/params.opt
@@ -1183,6 +1183,10 @@ The maximum factor which the loop vectorizer applies to the cost of statements i
Common Joined UInteger Var(param_vect_induction_float) Init(1) IntegerRange(0, 1) Param Optimization
Enable loop vectorization of floating point inductions.
+-param=vect-single-lane-slp=
+Common Joined UInteger Var(param_vect_single_lane_slp) Init(0) IntegerRange(0, 1) Param Optimization
+Enable single lane SLP discovery.
+
-param=vect-force-slp=
Common Joined UInteger Var(param_vect_force_slp) Init(0) IntegerRange(0, 1) Param Optimization
Fail vectorization when falling back to non-SLP.
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index fa098f9ff4e..0a533251fd9 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -3516,6 +3516,7 @@ vect_analyze_slp_instance (vec_info *vinfo,
opt_result
vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
{
+ loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
unsigned int i;
stmt_vec_info first_element;
slp_instance instance;
@@ -3531,6 +3532,31 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size)
FOR_EACH_VEC_ELT (vinfo->grouped_stores, i, first_element)
vect_analyze_slp_instance (vinfo, bst_map, first_element,
slp_inst_kind_store, max_tree_size, &limit);
+ if (loop_vinfo && param_vect_single_lane_slp != 0)
+ {
+ data_reference_p dr;
+ FOR_EACH_VEC_ELT (vinfo->shared->datarefs, i, dr)
+ if (DR_IS_WRITE (dr))
+ {
+ stmt_vec_info stmt_info = vinfo->lookup_dr (dr)->stmt;
+ /* It works a bit to dissolve the group but that's
+ not really what we want to do. Instead group analysis
+ above starts discovery for each lane and pieces them together
+ to a single store to the whole group. */
+ if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
+ continue;
+ vec<stmt_vec_info> stmts;
+ vec<stmt_vec_info> roots = vNULL;
+ vec<tree> remain = vNULL;
+ stmts.create (1);
+ stmts.quick_push (stmt_info);
+ bool res = vect_build_slp_instance (vinfo, slp_inst_kind_store,
+ stmts, roots, remain,
+ max_tree_size, &limit,
+ bst_map, NULL);
+ gcc_assert (res);
+ }
+ }
if (bb_vec_info bb_vinfo = dyn_cast <bb_vec_info> (vinfo))
{
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2024-02-23 7:31 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-10-19 13:28 [gcc(refs/users/rguenth/heads/vect-force-slp)] Add --param vect-single-lane-slp Richard Biener
-- strict thread matches above, loose matches on Subject: below --
2024-02-23 7:31 Richard Biener
2023-11-09 13:03 Richard Biener
2023-11-02 13:59 Richard Biener
2023-10-16 12:49 Richard Biener
2023-10-06 7:06 Richard Biener
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).