This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[sel-sched] Substitute inside insn groups, COND_EXEC fixes
- From: Andrey Belevantsev <abel at ispras dot ru>
- To: gcc-patches at gcc dot gnu dot org
- Cc: Alexander Monakov <amonakov at ispras dot ru>
- Date: Wed, 13 Jun 2007 19:45:52 +0400
- Subject: [sel-sched] Substitute inside insn groups, COND_EXEC fixes
Hello,
These two patches were sitting in our tree for a while. The first patch
allows substitution to work inside an insn group, i.e. a group of
independent insns that will be scheduled on the same cycle. Previously,
the substitution mechanism worked only when an insn was being moved up
to the boundary of the current group, but we haven't moved it through
already scheduled insns in the group. This can help when a reg-reg copy
was scheduled earlier on this cycle, and we have a true dependence from
this copy. The dependence will be eliminated by substitution. For this
purpose, a new function that performs propagation just inside an insn
group was introduced, and some of the older stuff was resurrected.
The second patch handles COND_EXEC insns in haifa_classify_insn by
looking through them to understand whether they are trapping or not,
instead of blindly returning TRAP_RISKY for them. While testing this
fix, it turned out that we were too aggressive in propagating possibly
trapping insns outside of their home basic blocks, so this was also
fixed. Unfortunately, currently we can't decide on the fly whether a
code motion will require bookkeeping copies or not, thus we restrict
some of the (otherwise legal) code motions. This is supposed to be
fixed via tracking expressions that are available on all paths. This
patch was written by Alexander Monakov.
Tested on ia64-linux, committed on sel-sched branch.
Andrey
Index: gcc/haifa-sched.c
===================================================================
--- gcc/haifa-sched.c (revision 125677)
+++ gcc/haifa-sched.c (working copy)
@@ -391,10 +391,9 @@ may_trap_exp (rtx x, int is_store)
PFREE_CANDIDATE, PRISKY_CANDIDATE: load that need to be checked for
being either PFREE or PRISKY. */
-int
-haifa_classify_insn (rtx insn)
+static int
+haifa_classify_insn_1 (rtx pat)
{
- rtx pat = PATTERN (insn);
int tmp_class = TRAP_FREE;
int insn_class = TRAP_FREE;
enum rtx_code code;
@@ -405,31 +404,7 @@ haifa_classify_insn (rtx insn)
for (i = len - 1; i >= 0; i--)
{
- code = GET_CODE (XVECEXP (pat, 0, i));
- switch (code)
- {
- case CLOBBER:
- /* Test if it is a 'store'. */
- tmp_class = may_trap_exp (XEXP (XVECEXP (pat, 0, i), 0), 1);
- break;
- case SET:
- /* Test if it is a store. */
- tmp_class = may_trap_exp (SET_DEST (XVECEXP (pat, 0, i)), 1);
- if (tmp_class == TRAP_RISKY)
- break;
- /* Test if it is a load. */
- tmp_class
- = WORST_CLASS (tmp_class,
- may_trap_exp (SET_SRC (XVECEXP (pat, 0, i)),
- 0));
- break;
- case COND_EXEC:
- case TRAP_IF:
- tmp_class = TRAP_RISKY;
- break;
- default:
- ;
- }
+ tmp_class = haifa_classify_insn_1 (XVECEXP (pat, 0, i));
insn_class = WORST_CLASS (insn_class, tmp_class);
if (insn_class == TRAP_RISKY || insn_class == IRISKY)
break;
@@ -455,6 +430,12 @@ haifa_classify_insn (rtx insn)
may_trap_exp (SET_SRC (pat), 0));
break;
case COND_EXEC:
+ tmp_class = haifa_classify_insn_1 (COND_EXEC_CODE (pat));
+ if (tmp_class == TRAP_RISKY)
+ break;
+ tmp_class = WORST_CLASS (tmp_class,
+ may_trap_exp (COND_EXEC_TEST (pat), 0));
+ break;
case TRAP_IF:
tmp_class = TRAP_RISKY;
break;
@@ -466,6 +447,12 @@ haifa_classify_insn (rtx insn)
return insn_class;
}
+int
+haifa_classify_insn (rtx insn)
+{
+ return haifa_classify_insn_1 (PATTERN (insn));
+}
+
/* Forward declarations. */
HAIFA_INLINE static int insn_cost1 (rtx, enum reg_note, rtx, rtx);
Index: gcc/sel-sched.c
===================================================================
--- gcc/sel-sched.c (revision 125678)
+++ gcc/sel-sched.c (working copy)
@@ -1583,6 +1583,10 @@ moveup_rhs_inside_insn_group (rhs_t insn
return MOVEUP_RHS_NULL;
}
+#define CANT_MOVE_TRAPPING(insn_to_move_up, through_insn) \
+ (VINSN_MAY_TRAP_P (EXPR_VINSN (insn_to_move_up)) \
+ && !sel_insn_has_single_succ_p ((through_insn), SUCCS_ALL))
+
/* Modifies INSN_TO_MOVE_UP so it can be moved through the THROUGH_INSN,
performing necessary transformations. When INSIDE_INSN_GROUP,
permit all dependencies except true ones, and try to remove those
@@ -1637,7 +1641,10 @@ moveup_rhs (rhs_t insn_to_move_up, insn_
full_ds = has_dependence_p (insn_to_move_up, through_insn, &has_dep_p);
if (full_ds == 0)
- return MOVEUP_RHS_SAME;
+ {
+ if (!CANT_MOVE_TRAPPING (insn_to_move_up, through_insn))
+ return MOVEUP_RHS_SAME;
+ }
else
{
if (VINSN_UNIQUE_P (vi))
@@ -1721,8 +1728,7 @@ moveup_rhs (rhs_t insn_to_move_up, insn_
/* Don't move trapping insns through jumps.
This check should be at the end to give a chance to control speculation
to perform its duties. */
- if (VINSN_MAY_TRAP_P (EXPR_VINSN (insn_to_move_up))
- && !sel_insn_has_single_succ_p (through_insn, SUCCS_ALL))
+ if (CANT_MOVE_TRAPPING (insn_to_move_up, through_insn))
return MOVEUP_RHS_NULL;
return MOVEUP_RHS_CHANGED;
2007-06-13 Alexander Monakov <amonakov@ispras.ru>
* haifa-sched.c (haifa_classify_insn_1): Rename from
haifa_classify_insn, add COND_EXEC handling, use recursion to analyze
PARALLEL and COND_EXEC.
(haifa_classify_insn): New implementation.
* sel-sched.c (CANT_MOVE_TRAPPING): New macro.
(moveup_rhs): Use it.
2007-06-13 Andrey Belevantsev <abel@ispras.ru>
* common.opt (fsel-sched-substitute-inside-insn-group): New flag.
* sel-sched.c (moveup_rhs_inside_insn_group): New.
(moveup_rhs): Add inside_insn_group parameter. When it is true,
use the above function. Kill unneeded comment.
(moveup_set_rhs): Add inside_insn_group parameter. Pass it to
moveup_rhs.
(equal_after_moveup_path_p_1): Call moveup_rhs with inside_insn_group
set to true.
(compute_av_set): Call moveup_set_rhs with inside_insn_group == false.
(find_used_regs_1): Tidy.
(generate_bookkeeping_insn): Kill #if 0'd code.
(fill_insns): Add to rhs_seq expressions from boundaries' av sets
instead of rhs_vliw. Put correct register in them. Fix comment.
Take pattern for the final insn to schedule from rhs_vliw.
Move comment before 'if'. Kill unneeded scope.
(sel_region_init): Enable moveup_set_path when the user requested
substitution inside insn groups.
(sel_global_init): Do not pipeline outer loops when the user doesn't
permit any kind of pipelining.
* sel-sched-ir.c: Include sel-sched-dump.h. Use again sel_print_insn
as a debug hook.
(RHS_DEST): New macro.
* sel-sched-dump.c (sel_print_insn): Resurrect. Fix it to not
segfault, use new macros.
* sched-vis.c (dump_insn_slim_1): Pass 1 instead of 0 to print_insn.
* config/ia64/ia64.opt (msched-spec-verbose, msched-prefer-non-data-spec-insns,
msched-prefer-non-control-spec-insns, msched-count-spec-in-critical-path,
msel-sched-renaming, msel-sched-substitution, msel-sched-data-spec,
msel-sched-control-spec, msel-sched-dont-check-control-spec): Use Target
Report Var instead of Common Report Var.
Index: gcc/sel-sched.c
===================================================================
--- gcc/sel-sched.c (revision 125677)
+++ gcc/sel-sched.c (working copy)
@@ -1533,16 +1533,74 @@ un_speculate (av_set_t *avp, insn_t insn
/* Moveup_* helpers for code motion and computing av sets. */
+/* Propagates INSN_TO_MOVE_UP inside an insn group through THROUGH_INSN.
+ The difference from the below function is that only substitution is
+ performed. */
+static enum MOVEUP_RHS_CODE
+moveup_rhs_inside_insn_group (rhs_t insn_to_move_up, insn_t through_insn)
+{
+ vinsn_t vi = RHS_VINSN (insn_to_move_up);
+ insn_t insn = VINSN_INSN (vi);
+ ds_t *has_dep_p;
+ ds_t full_ds;
+
+ full_ds = has_dependence_p (insn_to_move_up, through_insn, &has_dep_p);
+
+ if (full_ds == 0)
+ return MOVEUP_RHS_SAME;
+
+ /* Substitution is the only cure in this case. */
+ if (has_dep_p[DEPS_IN_RHS])
+ {
+ /* Can't substitute UNIQUE VINSNs. */
+ gcc_assert (!VINSN_UNIQUE_P (vi));
+
+ if (flag_sel_sched_substitution
+ && insn_eligible_for_subst_p (through_insn))
+ {
+ /* Substitute in vinsn. */
+ line_start ();
+ print ("Substituting in moveup_rhs inside insn group:\nBefore: ");
+ sel_print_rtl (insn);
+ print (" Moving through: ");
+ sel_print_rtl (through_insn);
+ print (" After: ");
+
+ if (substitute_reg_in_rhs (insn_to_move_up, through_insn))
+ {
+ sel_print_rtl (insn);
+ line_finish ();
+
+ return MOVEUP_RHS_CHANGED;
+ }
+ else
+ print (" Can't move up due to architecture constraints.\n");
+
+ line_finish ();
+ }
+ }
+
+ return MOVEUP_RHS_NULL;
+}
+
/* Modifies INSN_TO_MOVE_UP so it can be moved through the THROUGH_INSN,
- performing necessary transformations. */
+ performing necessary transformations. When INSIDE_INSN_GROUP,
+ permit all dependencies except true ones, and try to remove those
+ too via forward substitution. All cases when a non-eliminable
+ non-zero cost dependency exists inside an insn group will be fixed
+ in tick_check_p instead. */
static enum MOVEUP_RHS_CODE
-moveup_rhs (rhs_t insn_to_move_up, insn_t through_insn)
+moveup_rhs (rhs_t insn_to_move_up, insn_t through_insn, bool inside_insn_group)
{
vinsn_t vi = RHS_VINSN (insn_to_move_up);
insn_t insn = VINSN_INSN (vi);
ds_t *has_dep_p;
ds_t full_ds;
+ /* When inside_insn_group, delegate to the helper. */
+ if (inside_insn_group)
+ return moveup_rhs_inside_insn_group (insn_to_move_up, through_insn);
+
if (VINSN_UNIQUE_P (vi))
{
if (/* Don't move branches for now. */
@@ -1605,17 +1663,6 @@ moveup_rhs (rhs_t insn_to_move_up, insn_
if (has_dep_p[DEPS_IN_LHS] && !EXPR_SEPARABLE_P (insn_to_move_up))
return MOVEUP_RHS_NULL;
- /* If dependency is in lhs, it affects only those insns that are
- not RHS_SCHEDULE_AS_RHS, so they couldn't be moved.
- Rhses can be moved up through the anti or output dependence
- without any change:
-
- Ex. 1: Ex. 2:
- y = x; y = x;
- x = z*2; y = z*2;
-
- z*2 can be easily lifted above the y=x assignment. */
-
/* At this point we have either separable insns, that will be lifted
up only as RHSes, or non-separable insns with no dependency in lhs.
If dependency is in RHS, then try perform substitution and move up
@@ -1681,10 +1728,11 @@ moveup_rhs (rhs_t insn_to_move_up, insn_
return MOVEUP_RHS_CHANGED;
}
+
/* Moves an av set AVP up through INSN, performing necessary
transformations. */
static void
-moveup_set_rhs (av_set_t *avp, insn_t insn)
+moveup_set_rhs (av_set_t *avp, insn_t insn, bool inside_insn_group)
{
av_set_iterator i;
rhs_t rhs;
@@ -1697,7 +1745,7 @@ moveup_set_rhs (av_set_t *avp, insn_t in
line_start ();
dump_rhs (rhs);
- switch (moveup_rhs (rhs, insn))
+ switch (moveup_rhs (rhs, insn, inside_insn_group))
{
case MOVEUP_RHS_NULL:
av_set_iter_remove (&i);
@@ -1746,7 +1794,7 @@ moveup_set_path_1 (av_set_t *avp, ilist_
if (ILIST_NEXT (path))
moveup_set_path_1 (avp, ILIST_NEXT (path));
- moveup_set_rhs (avp, ILIST_INSN (path));
+ moveup_set_rhs (avp, ILIST_INSN (path), true);
}
/* Moves AVP set along PATH. */
@@ -1780,7 +1828,7 @@ equal_after_moveup_path_p_1 (rhs_t rhs,
res = true;
if (res)
- res = (moveup_rhs (rhs, ILIST_INSN (path)) != MOVEUP_RHS_NULL);
+ res = (moveup_rhs (rhs, ILIST_INSN (path), true) != MOVEUP_RHS_NULL);
return res;
}
@@ -1961,7 +2009,6 @@ compute_av_set (insn_t insn, ilist_t p,
free (succs);
ilist_remove (&p);
- /* Debug output. */
line_start ();
print ("av_succs (%d): ", INSN_UID (insn));
dump_av_set (av1);
@@ -1973,8 +2020,8 @@ compute_av_set (insn_t insn, ilist_t p,
expr_t expr;
vinsn_t vi = INSN_VI (insn);
- moveup_set_rhs (&av1, insn);
-
+ moveup_set_rhs (&av1, insn, false);
+
expr = av_set_lookup (av1, vi);
if (expr != NULL)
@@ -2253,6 +2300,7 @@ find_used_regs_1 (insn_t insn, av_set_t
}
orig_ops = av_set_copy (orig_ops);
+
/* If we've found valid av set, then filter the orig_ops set. */
if (INSN_AV_VALID_P (insn))
{
@@ -3252,10 +3300,7 @@ generate_bookkeeping_insn (rhs_t c_rhs,
/* We do not split header. */
gcc_assert (bb != current_loop_nest->header);
-#if 0
- /* We do not redirect a latch edge. */
- gcc_assert (e1 != loop_latch_edge (current_loop_nest));
-#endif
+
/* We do not redirect the only edge to the latch block. */
gcc_assert (e1->dest != latch
|| !single_pred_p (latch)
@@ -3498,18 +3543,24 @@ fill_insns (fence_t fence, int seqno, il
{
gcc_assert (first_p);
first_p = false;
- /*av_set_add (&rhs_seq, rhs);*/
+
+ /* The sequential expression has the right form to pass
+ to move_op except when renaming happened. Put the
+ correct register in RHS then. */
+ if (EXPR_SEPARABLE_P (rhs) && REG_P (EXPR_LHS (rhs))
+ && rhs_dest_regno (rhs) != rhs_dest_regno (rhs_vliw))
+ replace_dest_with_reg_in_rhs (rhs, EXPR_LHS (rhs_vliw));
+
+ av_set_add (&rhs_seq, rhs);
}
}
- av_set_add (&rhs_seq, rhs_vliw);
-
line_start ();
print ("rhs_seq: ");
dump_av_set (rhs_seq);
line_finish ();
- /* Move choosen insn. */
+ /* Move chosen insn. */
{
insn_t place_to_insert;
insn_t new_bb_head = NULL_RTX;
@@ -3546,6 +3597,12 @@ fill_insns (fence_t fence, int seqno, il
scheduling. */
gcc_assert (b);
+ /* We want to use a pattern from rhs_vliw, because it could've
+ been substituted, and the rest of data from rhs_seq. */
+ if (! rtx_equal_p (EXPR_PATTERN (rhs_vliw),
+ EXPR_PATTERN (c_rhs)))
+ change_vinsn_in_expr (c_rhs, EXPR_VINSN (rhs_vliw));
+
/* Find a place for C_RHS to schedule.
We want to have an invariant that only insns that are
sel_bb_header_p () have a valid LV_SET. But, in the same time,
@@ -3634,8 +3691,8 @@ fill_insns (fence_t fence, int seqno, il
new_bb_head = insn;
}
+ /* Initialize LV_SET of the bb header. */
if (new_bb_head != NULL_RTX)
- /* Initialize LV_SET of the bb header. */
{
/* !!! TODO: We should replace all occurencies of
LV_SET_VALID_P () with LV_SET () != NULL. Overwise it is
@@ -4079,12 +4136,10 @@ move_op (insn_t insn, av_set_t orig_ops,
if (b)
{
- {
- enum MOVEUP_RHS_CODE res;
-
- res = moveup_rhs (x, insn);
- gcc_assert (res != MOVEUP_RHS_NULL);
- }
+ enum MOVEUP_RHS_CODE res;
+
+ res = moveup_rhs (x, insn, false);
+ gcc_assert (res != MOVEUP_RHS_NULL);
if (!c_rhs_inited_p)
{
@@ -4428,7 +4483,8 @@ sel_region_init (int rgn)
/* We don't need the semantics of moveup_set_path, because filtering of
dependencies inside a sched group is handled by tick_check_p and
the target. */
- enable_moveup_set_path_p = 0;
+ enable_moveup_set_path_p
+ = flag_sel_sched_substitute_inside_insn_group != 0;
/* We need to treat insns as RHSes only when renaming is enabled. */
enable_schedule_as_rhs_p = (flag_sel_sched_renaming != 0);
@@ -5170,6 +5226,12 @@ sel_sched_region (int rgn)
static void
sel_global_init (void)
{
+ /* Pipelining outer loops is only possible when general pipelining
+ capabilities are requested.
+ FIXME: move this in opts.c. */
+ if (!flag_sel_sched_pipelining)
+ flag_sel_sched_pipelining_outer_loops = 0;
+
if (flag_sel_sched_pipelining_outer_loops)
pipeline_outer_loops_init ();
Index: gcc/sel-sched-ir.c
===================================================================
--- gcc/sel-sched-ir.c (revision 125677)
+++ gcc/sel-sched-ir.c (working copy)
@@ -53,6 +53,8 @@
#ifdef INSN_SCHEDULING
#include "sel-sched-ir.h"
+/* We don't have to use it except for sel_print_insn. */
+#include "sel-sched-dump.h"
/* A structure used to hold various parameters of insn initialization. */
struct _insn_init insn_init;
@@ -3792,7 +3794,7 @@ static struct haifa_sched_info sched_sel
NULL, /* schedule_more_p */
NULL, /* new_ready */
NULL, /* rgn_rank */
- NULL, /* rgn_print_insn */
+ sel_print_insn, /* rgn_print_insn */
contributes_to_priority,
NULL, NULL,
Index: gcc/sel-sched-ir.h
===================================================================
--- gcc/sel-sched-ir.h (revision 125677)
+++ gcc/sel-sched-ir.h (working copy)
@@ -36,6 +36,7 @@ Software Foundation, 51 Franklin Street,
/* For reg_note. */
#include "rtl.h"
#include "ggc.h"
+#include "bitmap.h"
#include "sched-int.h"
#include "sched-rgn.h"
#include "cfgloop.h"
@@ -133,6 +134,7 @@ typedef expr_t rhs_t;
#define RHS_PATTERN(RHS) (VINSN_PATTERN (RHS_VINSN (RHS)))
#define RHS_SPEC(RHS) ((RHS)->spec)
#define RHS_PRIORITY(RHS) ((RHS)->priority)
+#define RHS_DEST(RHS) (VINSN_LHS (RHS_VINSN (RHS)))
#define RHS_SCHED_TIMES(RHS) ((RHS)->sched_times)
/* Insn definition for list of original insns in find_used_regs. */
Index: gcc/sel-sched-dump.c
===================================================================
--- gcc/sel-sched-dump.c (revision 125677)
+++ gcc/sel-sched-dump.c (working copy)
@@ -673,7 +673,6 @@ dump_hard_reg_set (const char *prefix, H
}
}
-#if 0
/* Pretty print INSN. This is used as a hook. */
const char *
sel_print_insn (rtx insn, int aligned ATTRIBUTE_UNUSED)
@@ -682,14 +681,14 @@ sel_print_insn (rtx insn, int aligned AT
/* '+' before insn means it is a new cycle start and it's not been
scheduled yet. '>' - has been scheduled. */
- if (s_i_d && INSN_UID (insn) < sel_max_uid && INSN_VI (insn))
+ if (s_i_d && INSN_LUID (insn) > 0)
if (GET_MODE (insn) == TImode)
sprintf (buf, "%s %4d",
- (VINSN_SCHED_TIMES (INSN_VI (insn)) > 0) ? "> " : "< ",
+ INSN_SCHED_TIMES (insn) > 0 ? "> " : "< ",
INSN_UID (insn));
else
sprintf (buf, "%s %4d",
- VINSN_SCHED_TIMES (INSN_VI (insn)) > 0 ? "! " : " ",
+ INSN_SCHED_TIMES (insn) > 0 ? "! " : " ",
INSN_UID (insn));
else
if (GET_MODE (insn) == TImode)
@@ -699,7 +698,6 @@ sel_print_insn (rtx insn, int aligned AT
return buf;
}
-#endif
/* Functions for pretty printing of CFG. */
Index: gcc/common.opt
===================================================================
--- gcc/common.opt (revision 125677)
+++ gcc/common.opt (working copy)
@@ -850,6 +850,10 @@ fsel-sched-substitution
Common Report Var(flag_sel_sched_substitution) Init(0)
Perform substitution in selective scheduling
+fsel-sched-substitute-inside-insn-group
+Common Report Var(flag_sel_sched_substitute_inside_insn_group) Init(1)
+Perform substitution inside an instruction group
+
fsel-sched-verbose
Common Report Var(flag_sel_sched_verbose) Init(0)
Be verbose when running selective scheduling
Index: gcc/sched-vis.c
===================================================================
--- gcc/sched-vis.c (revision 125677)
+++ gcc/sched-vis.c (working copy)
@@ -694,7 +694,7 @@ dump_insn_slim_1 (FILE *f, rtx x)
{
char t[BUF_LEN + 32];
- print_insn (t, x, 0);
+ print_insn (t, x, 1);
fputs (t, f);
}
Index: gcc/config/ia64/ia64.opt
===================================================================
--- gcc/config/ia64/ia64.opt (revision 125677)
+++ gcc/config/ia64/ia64.opt (working copy)
@@ -129,19 +129,19 @@ Target Report Var(mflag_sched_spec_contr
Use simple data speculation check for control speculation
msched-spec-verbose
-Common Report Var(mflag_sched_spec_verbose) Init(0)
-Print information about speculative motions.
+Target Report Var(mflag_sched_spec_verbose) Init(0)
+Print information about speculative motions
msched-prefer-non-data-spec-insns
-Common Report Var(mflag_sched_prefer_non_data_spec_insns) Init(0)
+Target Report Var(mflag_sched_prefer_non_data_spec_insns) Init(0)
If set, data speculative instructions will be chosen for schedule only if there are no other choices at the moment
msched-prefer-non-control-spec-insns
-Common Report Var(mflag_sched_prefer_non_control_spec_insns) Init(0)
+Target Report Var(mflag_sched_prefer_non_control_spec_insns) Init(0)
If set, control speculative instructions will be chosen for schedule only if there are no other choices at the moment
msched-count-spec-in-critical-path
-Common Report Var(mflag_sched_count_spec_in_critical_path) Init(0)
+Target Report Var(mflag_sched_count_spec_in_critical_path) Init(0)
Count speculative dependencies while calculating priority of instructions
msched-stop-bits-after-every-cycle
@@ -153,23 +153,23 @@ Target Report Var(mflag_sched_fp_mem_dep
Assume that floating-point stores and loads are not likely to cause conflict when placed into one instruction group
msel-sched-renaming
-Common Report Var(mflag_sel_sched_renaming) Init(1)
+Target Report Var(mflag_sel_sched_renaming) Init(1)
Do register renaming in selective scheduling
msel-sched-substitution
-Common Report Var(mflag_sel_sched_substitution) Init(1)
+Target Report Var(mflag_sel_sched_substitution) Init(1)
Perform substitution in selective scheduling
msel-sched-data-spec
-Common Report Var(mflag_sel_sched_data_spec) Init(0)
+Target Report Var(mflag_sel_sched_data_spec) Init(0)
Perform data speculation in selective scheduling
msel-sched-control-spec
-Common Report Var(mflag_sel_sched_control_spec) Init(1)
+Target Report Var(mflag_sel_sched_control_spec) Init(1)
Perform control speculation in selective scheduling
msel-sched-dont-check-control-spec
-Common Report Var(mflag_sel_sched_dont_check_control_spec) Init(0)
+Target Report Var(mflag_sel_sched_dont_check_control_spec) Init(0)
Don't generate checks for control speculation in selective scheduling
; This comment is to ensure we retain the blank line above.