Finally
}
- public sealed class Reachability
- {
- bool barrier;
-
- public bool Barrier {
- get { return barrier; }
- }
-
- Reachability (bool barrier)
- {
- this.barrier = barrier;
- }
-
- public Reachability Clone ()
- {
- return new Reachability (barrier);
- }
-
- public void Meet (Reachability b)
- {
- barrier &= b.barrier;
- }
-
- public void Or (Reachability b)
- {
- barrier |= b.barrier;
- }
-
- public static Reachability Always ()
- {
- return new Reachability (false);
- }
-
- public bool IsUnreachable {
- get { return barrier; }
- }
-
- public void SetBarrier ()
- {
- barrier = true;
- }
-
- public override string ToString ()
- {
- return String.Format ("[{0}]", barrier);
- }
- }
-
public static FlowBranching CreateBranching (FlowBranching parent, BranchingType type, Block block, Location loc)
{
switch (type) {
// Private.
//
MyBitVector locals, parameters;
- Reachability reachability;
+ bool is_unreachable;
static int next_id = 0;
int id;
? MyBitVector.Empty
: new MyBitVector (parent == null ? MyBitVector.Empty : parent.parameters, num_params);
- reachability = parent == null ? Reachability.Always () : parent.Reachability.Clone ();
+ if (parent != null)
+ is_unreachable = parent.is_unreachable;
id = ++next_id;
+
}
public UsageVector (SiblingType type, UsageVector parent, Block block, Location loc)
: this (type, parent, block, loc, parent.CountParameters, parent.CountLocals)
{ }
- public UsageVector (MyBitVector parameters, MyBitVector locals, Reachability reachability, Block block, Location loc)
+ private UsageVector (MyBitVector parameters, MyBitVector locals, bool is_unreachable, Block block, Location loc)
{
this.Type = SiblingType.Block;
this.Location = loc;
this.Block = block;
- this.reachability = reachability;
+ this.is_unreachable = is_unreachable;
+
this.parameters = parameters;
this.locals = locals;
id = ++next_id;
+
}
// <summary>
retval.locals = locals.Clone ();
retval.parameters = parameters.Clone ();
- retval.reachability = reachability.Clone ();
+ retval.is_unreachable = is_unreachable;
return retval;
}
public bool IsAssigned (VariableInfo var, bool ignoreReachability)
{
- if (!ignoreReachability && !var.IsParameter && Reachability.IsUnreachable)
+ if (!ignoreReachability && !var.IsParameter && IsUnreachable)
return true;
return var.IsAssigned (var.IsParameter ? parameters : locals);
public void SetAssigned (VariableInfo var)
{
- if (!var.IsParameter && Reachability.IsUnreachable)
+ if (!var.IsParameter && IsUnreachable)
return;
var.SetAssigned (var.IsParameter ? parameters : locals);
public bool IsFieldAssigned (VariableInfo var, string name)
{
- if (!var.IsParameter && Reachability.IsUnreachable)
+ if (!var.IsParameter && IsUnreachable)
return true;
return var.IsFieldAssigned (var.IsParameter ? parameters : locals, name);
public void SetFieldAssigned (VariableInfo var, string name)
{
- if (!var.IsParameter && Reachability.IsUnreachable)
+ if (!var.IsParameter && IsUnreachable)
return;
var.SetFieldAssigned (var.IsParameter ? parameters : locals, name);
}
- public Reachability Reachability {
- get { return reachability; }
+ public bool IsUnreachable {
+ get { return is_unreachable; }
+ }
+
+ public void ResetBarrier ()
+ {
+ is_unreachable = false;
}
public void Goto ()
{
- if (!reachability.IsUnreachable)
- reachability.SetBarrier ();
+ is_unreachable = true;
}
public static UsageVector MergeSiblings (UsageVector sibling_list, Location loc)
MyBitVector locals = null;
MyBitVector parameters = null;
- Reachability reachability = sibling_list.Reachability.Clone ();
+ bool is_unreachable = sibling_list.is_unreachable;
- if (!sibling_list.Reachability.IsUnreachable) {
+ if (!sibling_list.IsUnreachable) {
locals &= sibling_list.locals;
parameters &= sibling_list.parameters;
}
for (UsageVector child = sibling_list.Next; child != null; child = child.Next) {
- reachability.Meet (child.Reachability);
+ is_unreachable &= child.is_unreachable;
- if (!child.Reachability.IsUnreachable) {
+ if (!child.IsUnreachable) {
locals &= child.locals;
parameters &= child.parameters;
}
}
- return new UsageVector (parameters, locals, reachability, null, loc);
+ return new UsageVector (parameters, locals, is_unreachable, null, loc);
}
// <summary>
// </summary>
public UsageVector MergeChild (UsageVector child, bool overwrite)
{
- Report.Debug (2, " MERGING CHILD EFFECTS", this, child, reachability, Type);
+ Report.Debug (2, " MERGING CHILD EFFECTS", this, child, Type);
- Reachability new_r = child.Reachability;
+ bool new_isunr = child.is_unreachable;
//
// We've now either reached the point after the branching or we will
// we need to look at (see above).
//
- if ((Type == SiblingType.SwitchSection) && !new_r.IsUnreachable) {
+ if ((Type == SiblingType.SwitchSection) && !new_isunr) {
Report.Error (163, Location,
"Control cannot fall through from one " +
"case label to another");
parameters |= child.parameters;
if (overwrite)
- reachability = new_r.Clone ();
+ is_unreachable = new_isunr;
else
- reachability.Or (new_r);
+ is_unreachable |= new_isunr;
return child;
}
if (o_vectors == null)
return;
- if (reachability.IsUnreachable) {
+ if (IsUnreachable) {
if (locals != null)
locals.SetAll (true);
if (parameters != null)
for (UsageVector vector = o_vectors; vector != null; vector = vector.Next) {
Report.Debug (1, " MERGING BREAK ORIGIN", vector);
- if (vector.Reachability.IsUnreachable)
+ if (vector.IsUnreachable)
continue;
locals &= vector.locals;
parameters &= vector.parameters;
- reachability.Meet (vector.Reachability);
+ is_unreachable &= vector.is_unreachable;
}
Report.Debug (1, " MERGING BREAK ORIGINS DONE", this);
public override string ToString ()
{
- return String.Format ("Vector ({0},{1},{2}-{3}-{4})", Type, id, reachability, parameters, locals);
+ return String.Format ("Vector ({0},{1},{2}-{3}-{4})", Type, id, is_unreachable, parameters, locals);
}
}
actual = CurrentUsageVector.Clone ();
// stand-in for backward jumps
- CurrentUsageVector.Reachability.Meet (Reachability.Always ());
+ CurrentUsageVector.ResetBarrier ();
}
public override bool AddGotoOrigin (UsageVector vector, Goto goto_stmt)
{
UsageVector vector = base.Merge ();
- if (actual.Reachability.IsUnreachable)
+ if (actual.IsUnreachable)
Report.Warning (162, 2, stmt.loc, "Unreachable code detected");
actual.MergeChild (vector, false);
// </summary>
void CheckOutParameters (UsageVector vector, Location loc)
{
- if (vector.Reachability.IsUnreachable)
+ if (vector.IsUnreachable)
return;
for (int i = 0; i < param_map.Count; i++) {
VariableInfo var = param_map [i];
return vector;
}
- public Reachability End ()
+ public bool End ()
{
- return Merge ().Reachability;
+ return Merge ().IsUnreachable;
}
}
projects / mono.git / blobdiff