protected IOperation GetOperationInstance(IOperation operation)
{
if (operation != null)
{
switch (operation.Kind.ConvertToLocalType())
{
case ConvertedOperationKind.FieldAccess:
IFieldAccess fieldAccess = operation as IFieldAccess;
if (fieldAccess != null)
{
return(fieldAccess.Instance);
}
break;
case ConvertedOperationKind.InvocationExpression:
IInvocationExpression invocationExpression = operation as IInvocationExpression;
if (invocationExpression != null)
{
return(invocationExpression.Instance);
}
break;
}
}
return(null);
}
private void UpdateStateCopy(ConstantPropagationDomain state, IFieldAccess dest, IVariable src)
{
/*
* When we set a field of an object O to a constant, we also need to set the same field
* to objects that are must aliased to O. We know that all field accesses corresponding
* to closure fields must alias each other since they are compiler generated. That is,
* a user cannot instantiate such class nor does the compiler instantiate it inside the class itself.
*/
var faccess = GetAccessRef(dest);
IFieldDefinition fdef = faccess.Item2.Resolve(parent.Host);
// We know that closure field accesses must alias each other.
if (IsClosureField(fdef))
{
foreach (var pair in parent.Fields)
{
var fresolved = pair.Item2.Resolve(parent.Host);
if (fresolved == fdef || fresolved.Equals(fdef))
{
state.Set(GetAccess(pair.Item1), state.Constants(src).Clone());
}
}
}
else
{
// TODO: refine this by type of the field.
state.SetFieldNonConstant();
}
}
private Tuple <IFieldAccess, IFieldReference> GetAccessRef(IFieldAccess f)
{
foreach (var pair in parent.Fields)
{
if (f.ToExpression().ToString() == pair.Item1.ToExpression().ToString())
{
return(pair);
}
}
return(null);
}
/// <summary>
/// Same field accesses can have different objects associated.
/// This function gets that object that is used in "state."
/// </summary>
/// <param name="f"></param>
/// <returns></returns>
private IFieldAccess GetAccess(IFieldAccess f)
{
foreach (var pair in parent.Fields)
{
if (f.ToExpression().ToString() == pair.Item1.ToExpression().ToString())
{
return(pair.Item1);
}
}
return(null);
}
public bool Escaped(Instruction instruction, IFieldAccess field)
{
if (!analysis.PossiblyRow(field.Type))
{
return(true);
}
var domain = info[instruction];
if (domain.IsTop)
{
return(true);
}
return(domain.Escaped(field));
}
/// <summary>
/// Check whether a field access corresponds to a field we track.
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
private bool IsFieldTracked(IFieldAccess field)
{
if (parent.TrackedFields.Contains(field))
{
return(true);
}
// for sanity
foreach (var f in parent.TrackedFields)
{
if (f.ToExpression().ToString() == field.ToExpression().ToString())
{
return(true);
}
}
return(false);
}
public IEnumerable <Constant> GetConstants(Instruction instruction, IFieldAccess field)
{
if (!ConstantPropagationSetAnalysis.IsConstantType(field.Type, host))
{
return(null);
}
var domain = info[instruction];
var fieldDomain = domain.Constants(field);
if (fieldDomain.IsTop)
{
return(null);
}
if (fieldDomain.IsBottom)
{
return(new HashSet <Constant>());
}
return(new HashSet <Constant>(fieldDomain.Elements));
}
public ConstantSetDomain Constants(IFieldAccess f)
{
return(fieldMapping[f]);
}
public bool Contains(IFieldAccess f, ConstantSetDomain cpd)
{
return(fieldMapping[f].Contains(cpd));
}
public bool Contains(IFieldAccess f, Constant c)
{
return(fieldMapping[f].Contains(c));
}
public bool Contains(IFieldAccess f)
{
return(fieldMapping.ContainsKey(f));
}
public void Return(IFieldAccess f)
{
fset.Return(f);
}
private void UpdateStateNotConstant(ConstantPropagationDomain state, IFieldAccess f)
{
state.SetNonConstant(GetAccess(f));
}
public bool Escaped(IFieldAccess f)
{
return(fset.Escaped(f));
}
public void Set(IFieldAccess f, ConstantSetDomain cons)
{
fieldMapping[f] = cons;
}
private void UpdateStateCopy(ConstantPropagationDomain state, IVariable dest, IFieldAccess src)
{
var cl = state.Constants(GetAccess(src)).Clone();
state.Set(dest, cl);
}
public void SetNonConstant(IFieldAccess f)
{
Constants(f).SetNotConstant();
}
public void Escape(IFieldAccess f)
{
fset.Escape(f);
}
