public ReplacementStaticFieldAssignmentBuilder(ReplacementMethodConstructionContext context, ReplaceableFieldInfo fieldInfo)
: base(context)
{
var reflector = new UnitReflector(context.Host);
var containingType = reflector.Get(fieldInfo.DeclaringType.FullName);
field = reflector.From(containingType).GetField(fieldInfo.Name);
}
internal string Mangle(IFieldReference field) {
Contract.Requires(field != null);
field.ResolvedField.Dispatch(this); //compute the hash
var sb = new StringBuilder();
sb.Append('_');
sb.Append((uint)this.hash);
sb.Append('_');
this.AppendSanitizedName(sb, field.Name.Value);
return sb.ToString();
}
public ReplacementMethodConstructionContext(IMetadataHost host, IFieldReference originalField, IMethodDefinition fakeMethod, BlockStatement block, bool isAssignment, ILogger log, IReplaceableReference originalReference)
{
this.host = host;
this.block = block;
this.originalField = originalField;
this.isAssignment = isAssignment;
this.log = log;
this.originalReference = originalReference;
fakeMethodParameters = fakeMethod.Parameters;
returnType = fakeMethod.Type;
}
public override void Visit(IFieldReference fieldReference)
{
if (!alreadySeen.Add(fieldReference))
{
return;
}
IUnitReference definingUnit = MetadataWriter.GetDefiningUnitReference(fieldReference.GetContainingType(Context), Context);
if (definingUnit != null && ReferenceEquals(definingUnit, this.module))
{
return;
}
this.Visit((ITypeMemberReference)fieldReference);
this.Visit(fieldReference.GetType(Context));
ReserveFieldToken(fieldReference);
}
/// <summary>
/// Tries to get the first field reference in the method body
/// </summary>
/// <param name="body"></param>
/// <param name="field"></param>
/// <returns></returns>
public static bool TryGetFirstFieldReference(IMethodBody body, out IFieldReference field)
{
Contract.Requires(body != null);
Contract.Ensures(!Contract.Result<bool>() || Contract.ValueAtReturn(out field) != null);
foreach (var operation in body.Operations)
{
if (operation.OperationCode == OperationCode.Stfld ||
operation.OperationCode == OperationCode.Ldfld)
{
field = (IFieldReference)operation.Value;
return field != null;
}
}
field = null;
return false;
}
public override void Visit(IFieldReference fieldReference)
{
if (!_alreadySeen.Add(fieldReference))
{
return;
}
IUnitReference definingUnit = MetadataWriter.GetDefiningUnitReference(fieldReference.GetContainingType(Context), Context);
if (definingUnit != null && ReferenceEquals(definingUnit, Context.Module))
{
return;
}
this.Visit((ITypeMemberReference)fieldReference);
this.Visit(fieldReference.GetType(Context));
ReserveFieldToken(fieldReference);
}
public void PointsTo(SimplePTGNode source, IFieldReference field, SimplePTGNode target)
{
if (source.Equals(SimplePointsToGraph.NullNode))
{
return;
}
this.nodes.Add(target);
this.nodes.Add(source);
var currentTargets = GetTargets(source, field);
if (currentTargets.Count == 1 && currentTargets.Single() == SimplePointsToGraph.NullNode)
{
this.RemoveTargets(source, field);
}
this.AddEdge(source, field, target);
}
private static void VisitFieldReference(IFieldReference fieldReference, EmitContext context)
{
Debug.Assert(fieldReference != null);
// Visit containing type
VisitTypeReference(fieldReference.GetContainingType(context), context);
// Translate substituted field to original definition
ISpecializedFieldReference specializedField = fieldReference.AsSpecializedFieldReference;
if (specializedField != null)
{
fieldReference = specializedField.UnspecializedVersion;
}
// Visit field type
VisitTypeReference(fieldReference.GetType(context), context);
}
public override void TraverseChildren(IFieldReference fieldReference)
{
log.WriteTrace("Visiting field: {0}.", fieldReference.Name.Value);
var replaceableField = fieldReference.AsReplaceable(ReplaceableReferenceTypes.FieldAccessor);
if (registry.IsRegistered(replaceableField))
{
var replacementMethodToCall = registry.GetReplacement(replaceableField);
var replacementExpression = new MethodCall();
replacementExpression.Type = replacementMethodToCall.Type;
replacementExpression.Arguments = new List<IExpression>();
replacementExpression.MethodToCall = replacementMethodToCall;
replacementExpression.IsStaticCall = true;
var expressionStatement = parent as ExpressionStatement;
if (expressionStatement != null)
{
var assignment = expressionStatement.Expression as Assignment;
if (assignment != null)
{
var source = assignment.Source as BoundExpression;
if (source != null)
{
var assignmentSource = source.Definition as FieldReference;
if (assignmentSource != null)
{
if (fieldReference.ResolvedField.Equals(assignmentSource.ResolvedField))
{
assignment.Source = replacementExpression;
}
}
}
}
}
var returnStatement = parent as ReturnStatement;
if (returnStatement != null)
{
returnStatement.Expression = replacementExpression;
}
}
}
public override void TraverseChildren(IBoundExpression boundExpression)
{
base.TraverseChildren(boundExpression);
ITypeReference type = Dummy.TypeReference;
ILocalDefinition /*?*/ local = boundExpression.Definition as ILocalDefinition;
if (local != null)
{
type = local.Type;
if (local.IsReference)
{
if (local.IsPinned)
{
type = Immutable.PointerType.GetPointerType(type, this.host.InternFactory);
}
else
{
type = Immutable.ManagedPointerType.GetManagedPointerType(type, this.host.InternFactory);
}
}
}
else
{
IParameterDefinition /*?*/ parameter = boundExpression.Definition as IParameterDefinition;
if (parameter != null)
{
type = parameter.Type;
if (parameter.IsByReference)
{
type = Immutable.ManagedPointerType.GetManagedPointerType(type, this.host.InternFactory);
}
}
else
{
IFieldReference /*?*/ field = boundExpression.Definition as IFieldReference;
if (field != null)
{
type = field.Type;
}
}
}
((BoundExpression)boundExpression).Type = type;
}
/// <summary>
/// Creates a fresh BPL variable to represent <paramref name="field"/>, deciding
/// on its type based on the heap representation.
/// </summary>
public override Bpl.Variable CreateFieldVariable(IFieldReference field) {
Bpl.Variable v;
string fieldname = MemberHelper.GetMemberSignature(field, NameFormattingOptions.DocumentationId);
fieldname = TranslationHelper.TurnStringIntoValidIdentifier(fieldname);
Bpl.IToken tok = field.Token();
Bpl.Type t = this.sink.CciTypeToBoogie(field.Type.ResolvedType);
if (field.ResolvedField.IsStatic) {
Bpl.TypedIdent tident = new Bpl.TypedIdent(tok, fieldname, t);
v = new Bpl.GlobalVariable(tok, tident);
}
else {
Bpl.Type mt = new Bpl.MapType(tok, new List<Bpl.TypeVariable>(), new List<Bpl.Type>(new Bpl.Type[] {this.RefType}), t);
Bpl.TypedIdent tident = new Bpl.TypedIdent(tok, fieldname, mt);
v = new Bpl.GlobalVariable(tok, tident);
}
return v;
}
/// <summary>
/// Returns a "live" System.Reflection.FieldInfo object that provides reflective access to the referenced field.
/// If the field cannot be found or cannot be loaded, the result is null.
/// </summary>
public FieldInfo /*?*/ GetField(IFieldReference /*?*/ fieldReference)
{
if (fieldReference == null)
{
return(null);
}
var result = this.fieldMap.Find(fieldReference.ContainingType.InternedKey, (uint)fieldReference.Name.UniqueKey);
if (result == null)
{
var containingType = this.GetType(fieldReference.ContainingType);
if (containingType == null)
{
return(null);
}
var fieldType = this.GetType(fieldReference.Type);
if (fieldType == null)
{
return(null);
}
foreach (var member in containingType.GetMember(fieldReference.Name.Value, BindingFlags.NonPublic | BindingFlags.DeclaredOnly))
{
var field = (FieldInfo)member as FieldInfo;
if (field == null)
{
continue;
}
if (field.FieldType != fieldType)
{
continue;
}
if (fieldReference.IsModified)
{
if (!this.ModifiersMatch(field.GetOptionalCustomModifiers(), field.GetRequiredCustomModifiers(), fieldReference.CustomModifiers))
{
continue;
}
}
}
this.fieldMap.Add(fieldReference.ContainingType.InternedKey, (uint)fieldReference.Name.UniqueKey, result);
}
return(result);
}
private void AddDependency(IFieldReference field)
{
field = field.UnWrapMember <IFieldReference>();
AddGeneralDependency(field);
if (this.ComputeFullClosure)
{
IFieldDefinition fieldDef = field.ResolvedField;
if (fieldDef is Dummy)
{
_unresolvedDependencies.Add(field);
}
else
{
base.Traverse(fieldDef);
}
}
}
public static string GetName(IFieldReference value)
{
IType fieldType = value.FieldType;
IType declaringType = value.DeclaringType;
if (fieldType.Equals(declaringType))
{
ITypeReference typeReference = fieldType as ITypeReference;
if (typeReference != null)
{
if (Helper.IsEnumeration(typeReference))
{
return(value.Name);
}
}
}
return(value.Name + " : " + value.FieldType.ToString());
}
private void UpdateDeclaringBlock(IFieldReference /*?*/ fieldReference)
{
if (fieldReference == null)
{
return;
}
var boundExpr = this.closureFieldToLocalOrParameterMap[fieldReference.InternedKey] as BoundExpression;
if (boundExpr == null || !(boundExpr.Definition is ILocalDefinition))
{
return;
}
var declaringBlock = this.declaringBlockMap[fieldReference.InternedKey];
if (declaringBlock == null)
{
this.declaringBlockMap[fieldReference.InternedKey] = this.currentBlock;
return;
}
var dblock = declaringBlock;
while (dblock != null)
{
if (dblock == this.currentBlock)
{
return;
}
Contract.Assume(this.currentBlock != null);
var cblock = this.containingBlockMap[this.currentBlock];
while (cblock != null)
{
if (cblock == dblock)
{
this.declaringBlockMap[fieldReference.InternedKey] = dblock;
return;
}
cblock = this.containingBlockMap[cblock];
}
dblock = this.containingBlockMap[dblock];
}
Contract.Assume(false);
}
public int CompareTo(object obj)
{
IFieldReference reference = obj as IFieldReference;
if (reference == null)
{
throw new NotSupportedException();
}
int ret = this.DeclaringType.CompareTo(reference.DeclaringType);
if (0 == ret)
{
ret = String.Compare(this.Name, reference.Name, StringComparison.InvariantCulture);
}
if (0 == ret)
{
ret = this.FieldType.CompareTo(reference.FieldType);
}
return(ret);
}
public static IEnumerable <IFieldReference> FieldsReferences(this ControlFlowGraph cfg)
{
var fields = new HashSet <IFieldReference>();
foreach (var node in cfg.Nodes)
{
foreach (var ins in node.Instructions)
{
if (ins is LoadInstruction || ins is StoreInstruction)
{
IValue operand;
if (ins is LoadInstruction)
{
operand = (ins as LoadInstruction).Operand;
}
else
{
operand = (ins as StoreInstruction).Result;
}
IFieldReference field = null;
if (operand is InstanceFieldAccess)
{
field = (operand as InstanceFieldAccess).Field;
}
else if (operand is StaticFieldAccess)
{
field = (operand as StaticFieldAccess).Field;
}
if (field == null)
{
continue;
}
fields.Add(field);
}
}
}
return(fields);
}
public override void TraverseChildren(IFieldReference fieldReference)
{
log.WriteTrace("Visiting field: {0}.", fieldReference.Name.Value);
var replaceableField = fieldReference.AsReplaceable(ReplaceableReferenceTypes.FieldAssignment);
if (registry.IsRegistered(replaceableField))
{
var replacementMethodToCall = registry.GetReplacement(replaceableField);
var replacementExpression = new MethodCall();
replacementExpression.Type = replacementMethodToCall.Type;
replacementExpression.Arguments = new List<IExpression>();
replacementExpression.MethodToCall = replacementMethodToCall;
replacementExpression.IsStaticCall = true;
var expressionStatement = parent as ExpressionStatement;
if (expressionStatement != null)
{
var assignment = expressionStatement.Expression as Assignment;
if (assignment != null)
{
var target = assignment.Target.Definition as FieldReference;
if (target != null)
{
// If the target is what we're visiting ...
if (target.ResolvedField.Equals(fieldReference.ResolvedField))
{
if (!fieldReference.ResolvedField.IsStatic)
{
replacementExpression.Arguments.Add(assignment.Target.Instance);
}
replacementExpression.Arguments.Add(assignment.Source);
expressionStatement.Expression = replacementExpression;
}
}
}
}
}
}
public int GetHashCode(ITypeMemberReference memberRef)
{
int hash = Hash.Combine(memberRef.Name, (int)_metadataWriter.GetMemberRefParentCodedIndex(memberRef) << 4);
IFieldReference /*?*/ fieldRef = memberRef as IFieldReference;
if (fieldRef != null)
{
hash = Hash.Combine(hash, (int)_metadataWriter.GetFieldSignatureIndex(fieldRef));
}
else
{
IMethodReference /*?*/ methodRef = memberRef as IMethodReference;
if (methodRef != null)
{
hash = Hash.Combine(hash, (int)_metadataWriter.GetMethodSignatureIndex(methodRef));
}
}
return(hash);
}
public bool AssignHeapTraceables(IVariable destination, IFieldReference field, IEnumerable <Traceable> traceables)
{
var nodes = PTG.GetTargets(destination);
if (nodes.Any())
{
// This should be only for scalars
foreach (var SimplePTGNode in nodes)
{
if (SimplePTGNode != SimplePointsToGraph.NullNode)
{
AssignHeapTraceables(SimplePTGNode, field, traceables);
}
}
}
else
{
return(false);
}
return(true);
}
public int GetHashCode(ITypeMemberReference memberRef)
{
int hash = Hash.Combine(memberRef.Name, _metadataWriter.GetMemberReferenceParent(memberRef).GetHashCode());
IFieldReference fieldRef = memberRef as IFieldReference;
if (fieldRef != null)
{
hash = Hash.Combine(hash, _metadataWriter.GetFieldSignatureIndex(fieldRef).GetHashCode());
}
else
{
IMethodReference methodRef = memberRef as IMethodReference;
if (methodRef != null)
{
hash = Hash.Combine(hash, _metadataWriter.GetMethodSignatureHandle(methodRef).GetHashCode());
}
}
return(hash);
}
public void VisitMethodBodyTypes(IModule module)
{
// Emulates ReferenceIndexerBase.Visit(IOperation operation)
this.module = module;
int count;
foreach (IReference o in module.ReferencesInIL(out count))
{
ITypeReference /*?*/ typeReference = o as ITypeReference;
if (typeReference != null)
{
this.typeReferenceNeedsToken = true;
this.Visit(typeReference);
Debug.Assert(!this.typeReferenceNeedsToken);
}
else
{
IFieldReference /*?*/ fieldReference = o as IFieldReference;
if (fieldReference != null)
{
if (fieldReference.IsContextualNamedEntity)
{
((IContextualNamedEntity)fieldReference).AssociateWithPeWriter(this.peWriter);
}
this.Visit(fieldReference);
}
else
{
IMethodReference /*?*/ methodReference = o as IMethodReference;
if (methodReference != null)
{
this.Visit(methodReference);
}
}
}
}
}
public override void TraverseChildren(IAddressableExpression addressableExpression)
{
base.TraverseChildren(addressableExpression);
ITypeReference type = Dummy.TypeReference;
ILocalDefinition /*?*/ local = addressableExpression.Definition as ILocalDefinition;
if (local != null)
{
type = local.Type;
}
else
{
IParameterDefinition /*?*/ parameter = addressableExpression.Definition as IParameterDefinition;
if (parameter != null)
{
type = parameter.Type;
if (parameter.IsByReference)
{
type = Immutable.ManagedPointerType.GetManagedPointerType(type, this.host.InternFactory);
}
}
else
{
IFieldReference /*?*/ field = addressableExpression.Definition as IFieldReference;
if (field != null)
{
type = field.Type;
}
else
{
IExpression /*?*/ expression = addressableExpression.Definition as IExpression;
if (expression != null)
{
type = expression.Type;
}
}
}
}
((AddressableExpression)addressableExpression).Type = type;
}
public static bool IsVisible(IFieldReference value, IVisibilityConfiguration visibility)
{
if (Helper.IsVisible(value.DeclaringType, visibility))
{
IFieldDeclaration fieldDeclaration = value.Resolve();
if (fieldDeclaration == null)
{
return(true);
}
switch (fieldDeclaration.Visibility)
{
case FieldVisibility.Public:
return(visibility.Public);
case FieldVisibility.Assembly:
return(visibility.Assembly);
case FieldVisibility.FamilyOrAssembly:
return(visibility.FamilyOrAssembly);
case FieldVisibility.Family:
return(visibility.Family);
case FieldVisibility.Private:
return(visibility.Private);
case FieldVisibility.FamilyAndAssembly:
return(visibility.FamilyAndAssembly);
case FieldVisibility.PrivateScope:
return(visibility.Private);
}
throw new NotSupportedException();
}
return(false);
}
/// <summary>
/// Creates a fresh BPL variable to represent <paramref name="field"/>, deciding
/// on its type based on the heap representation.
/// </summary>
public override Bpl.Variable CreateFieldVariable(IFieldReference field)
{
Bpl.Variable v;
string fieldname = MemberHelper.GetMemberSignature(field, NameFormattingOptions.DocumentationId);
fieldname = TranslationHelper.TurnStringIntoValidIdentifier(fieldname);
Bpl.IToken tok = field.Token();
Bpl.Type t = this.sink.CciTypeToBoogie(field.Type.ResolvedType);
if (field.ResolvedField.IsStatic)
{
Bpl.TypedIdent tident = new Bpl.TypedIdent(tok, fieldname, t);
v = new Bpl.GlobalVariable(tok, tident);
}
else
{
Bpl.Type mt = new Bpl.MapType(tok, new List <Bpl.TypeVariable>(), new List <Bpl.Type>(new Bpl.Type[] { this.RefType }), t);
Bpl.TypedIdent tident = new Bpl.TypedIdent(tok, fieldname, mt);
v = new Bpl.GlobalVariable(tok, tident);
}
return(v);
}
public bool Equals(ITypeMemberReference x, ITypeMemberReference y)
{
if (x == y)
{
return(true);
}
if (x.GetContainingType(_metadataWriter.Context) != y.GetContainingType(_metadataWriter.Context))
{
if (_metadataWriter.GetMemberRefParentCodedIndex(x) != _metadataWriter.GetMemberRefParentCodedIndex(y))
{
return(false);
}
}
if (x.Name != y.Name)
{
return(false);
}
IFieldReference /*?*/ xf = x as IFieldReference;
IFieldReference /*?*/ yf = y as IFieldReference;
if (xf != null && yf != null)
{
return(_metadataWriter.GetFieldSignatureIndex(xf) == _metadataWriter.GetFieldSignatureIndex(yf));
}
IMethodReference /*?*/ xm = x as IMethodReference;
IMethodReference /*?*/ ym = y as IMethodReference;
if (xm != null && ym != null)
{
return(_metadataWriter.GetMethodSignatureIndex(xm) == _metadataWriter.GetMethodSignatureIndex(ym));
}
return(false);
}
public string GetMemberSignature(ITypeMemberReference member, bool TypeMemberPrefix)
{
string sig;
IFieldReference typeRef = member as IFieldReference;
if (typeRef != null) // CCI change where now fields Signature contains return type.
{
sig = GetMemberSignature(member, FieldFormatOpts);
}
else
{
sig = GetMemberSignature(member, FormatOpts);
}
IMethodReference method = member as IMethodReference;
if (method != null && sig.Contains("()")) // CCI change where parameterless methods now return empty parenthesis.
{
sig = sig.Replace("()", "");
}
IPropertyDefinition property = member as IPropertyDefinition;
if (property != null)
{
sig = sig.Replace("[", "(").Replace("]", ")");
}
if (TypeMemberPrefix)
{
string prefix = Enum.GetName(typeof(MemberTypes), TypeMemberType(member));
return(prefix + " : " + sig);
}
else
{
return(sig);
}
}
private ICollection <int> InternalGetLastDefs(PTGNode ptgNode, IFieldReference f)
{
IDictionary <IFieldReference, ICollection <int> > lastDefsDict = new Dictionary <IFieldReference, ICollection <int> >();
ICollection <int> lastDefs = new HashSet <int>();
if (LastDefsPtg.ContainsKey(ptgNode))
{
lastDefsDict = LastDefsPtg[ptgNode];
}
else
{
LastDefsPtg[ptgNode] = lastDefsDict;
}
if (lastDefsDict.ContainsKey(f))
{
lastDefs = lastDefsDict[f];
}
else
{
lastDefsDict[f] = lastDefs;
}
return(lastDefs);
}
/// <summary>
/// Given a field definition in the closure class, get its reference as will be used by the methods in the closure class.
/// </summary>
internal IFieldReference GetReferenceOfFieldUsedByPeers(IFieldDefinition fieldDef)
{
IFieldReference fieldReference = null;
ITypeReference typeReference = this.ClosureDefinitionReference;
ISpecializedNestedTypeReference nestedTypeRef = typeReference as ISpecializedNestedTypeReference;
IGenericTypeInstanceReference genericTypeInstanceRef = typeReference as IGenericTypeInstanceReference;
if (nestedTypeRef != null || genericTypeInstanceRef != null)
{
fieldReference = new SpecializedFieldReference()
{
ContainingType = typeReference,
InternFactory = this.host.InternFactory,
Name = fieldDef.Name,
UnspecializedVersion = fieldDef,
Type = fieldDef.Type
};
}
else
{
fieldReference = fieldDef;
}
return(fieldReference);
}
public override void Visit(IOperation operation)
{
ITypeReference /*?*/ typeReference = operation.Value as ITypeReference;
if (typeReference != null)
{
this.typeReferenceNeedsToken = true;
if (operation.OperationCode == Microsoft.CodeAnalysis.ILOpCode.Newarr)
{
// ^ assume operation.Value is IArrayTypeReference;
this.Visit(((IArrayTypeReference)operation.Value).GetElementType(Context));
}
else
{
this.Visit(typeReference);
}
Debug.Assert(!this.typeReferenceNeedsToken);
}
else
{
IFieldReference /*?*/ fieldReference = operation.Value as IFieldReference;
if (fieldReference != null)
{
this.Visit(fieldReference);
}
else
{
IMethodReference /*?*/ methodReference = operation.Value as IMethodReference;
if (methodReference != null)
{
this.Visit(methodReference);
}
}
}
}
public void Visit(IFieldReference fieldReference)
{
throw new NotImplementedException();
}
uint GetFieldReferenceInternedId(IFieldReference fieldReference) {
Contract.Requires(fieldReference != null);
uint containingTypeReferenceInternedId = this.GetTypeReferenceInternId(fieldReference.ContainingType);
uint fieldTypeInternedId;
if (fieldReference.IsModified)
fieldTypeInternedId = this.GetModifiedTypeReferenceInternId(fieldReference.Type, fieldReference.CustomModifiers);
else
fieldTypeInternedId = this.GetTypeReferenceInternId(fieldReference.Type);
uint fieldNameId = (uint)fieldReference.Name.UniqueKey;
var fieldsForType = this.FieldReferenceHashtable.Find(containingTypeReferenceInternedId);
if (fieldsForType == null) {
fieldsForType = new DoubleHashtable();
this.FieldReferenceHashtable.Add(containingTypeReferenceInternedId, fieldsForType);
}
uint result = fieldsForType.Find(fieldNameId, fieldTypeInternedId);
if (result == 0) {
result = this.CurrentFieldReferenceInternValue++;
fieldsForType.Add(fieldNameId, fieldTypeInternedId, result);
}
return result;
}
protected override IExpression ConvertAssign(IAssignExpression iae)
{
assignmentIndex--;
//Trace.WriteLine($"{analysis.methods[currentMethodIndex].Declaration.Name} {assignmentIndex} {iae}");
bool assignmentIsDead = false;
// do not convert the target, only its indices
IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target);
if (ivd != null)
{
if (!liveVariables.Contains(ivd) && !analysis.loopVariables.Contains(ivd))
{
assignmentIsDead = true;
}
}
IFieldReference ifr = Recognizer.GetFieldReference(iae.Target);
IFieldDeclaration ifd = ifr?.Resolve();
if (ifd != null)
{
if (!liveFields.Contains(ifd))
{
assignmentIsDead = true;
}
}
if (iae.Target is IVariableReferenceExpression || iae.Target is IVariableDeclarationExpression)
{
liveVariables.Remove(ivd);
}
else if (iae.Target is IFieldReferenceExpression && ((IFieldReferenceExpression)iae.Target).Field.Equals(ifr))
{
liveFields.Remove(ifd);
}
if (!assignmentIsDead)
{
if (ivd != null)
{
usedVariables.Add(ivd);
}
else if (ifd != null)
{
usedFields.Add(ifd);
}
// analyze the indices of target
foreach (var bracket in Recognizer.GetIndices(iae.Target))
{
ConvertCollection(bracket);
}
// must convert the expression afterward, since it may use target.
base.ConvertExpression(iae.Expression);
}
else if (LivenessThisMethod != null)
{
bool variableIsUsed = (ivd != null && usedVariables.Contains(ivd)) ||
(ifd != null && usedFields.Contains(ifd));
LivenessThisMethod[assignmentIndex] = variableIsUsed ? Liveness.Dead : Liveness.Unused;
if (debug && false)
{
Trace.WriteLine($"dead statement: {iae}");
if (!variableIsUsed)
{
Trace.WriteLine($"unused variable: {iae.Target}");
}
}
}
return(iae);
}
public override void TraverseChildren(IFieldReference fieldReference)
{
AddDependency(fieldReference);
base.TraverseChildren(fieldReference);
}
private IMethodDefinition CreateInitMethod(IMethodDefinition incomingMethodDefinition, IFieldReference loadLibraryModule, IFieldReference methodField, IMethodReference isLibraryInitMethod, IPlatformInvokeInformation platformInvokeInformation)
{
var methodDefinition = new MethodDefinition
{
IsStatic = true,
Type = this.platformType.SystemVoid,
ContainingTypeDefinition = incomingMethodDefinition.ContainingTypeDefinition,
Name = this.nameTable.GetNameFor("init_" + incomingMethodDefinition.Name.Value),
IsNeverInlined = true,
Visibility = TypeMemberVisibility.Private
};
var ilGenerator = new ILGenerator(this.host, methodDefinition);
ilGenerator.Emit(OperationCode.Ldsfld, loadLibraryModule);
ilGenerator.Emit(OperationCode.Dup);
ilGenerator.Emit(OperationCode.Ldstr, platformInvokeInformation.ImportModule.Name.Value);
ilGenerator.Emit(OperationCode.Call, isLibraryInitMethod);
ilGenerator.Emit(OperationCode.Ldstr, platformInvokeInformation.ImportName.Value);
ilGenerator.Emit(OperationCode.Call, this.getProcAddress);
ilGenerator.Emit(OperationCode.Stsfld, methodField);
ilGenerator.Emit(OperationCode.Ret);
var ilMethodBody = new ILGeneratorMethodBody(ilGenerator, false, 2, methodDefinition, Enumerable.Empty <ILocalDefinition>(), Enumerable.Empty <ITypeDefinition>());
methodDefinition.Body = ilMethodBody;
return(methodDefinition);
}
/// <summary>
/// Performs some computation with the given field reference.
/// </summary>
public void Visit(IFieldReference fieldReference)
{
this.Visit((ITypeMemberReference)fieldReference);
if (fieldReference.InternedKey == 0)
this.ReportError(MetadataError.IncompleteNode, fieldReference, "InternedKey");
if (fieldReference.Type is Dummy)
this.ReportError(MetadataError.IncompleteNode, fieldReference, "Type");
var resolvedField = fieldReference.ResolvedField;
if (!(resolvedField is Dummy) && fieldReference.InternedKey != resolvedField.InternedKey)
this.ReportError(MetadataError.FieldReferenceResolvesToDifferentField, fieldReference);
}
public RegisteredResolver(
Type sourceType,
IFieldReference field)
: this(sourceType, sourceType, field)
{
}
/// <summary>
/// Performs some computation with the given field reference.
/// </summary>
public virtual void Visit(IFieldReference fieldReference)
{
}
/// <summary>
/// Traverses the field reference.
/// </summary>
public void Traverse(IFieldReference fieldReference)
{
Contract.Requires(fieldReference != null);
fieldReference.DispatchAsReference(this.dispatchingVisitor);
}
public override void TraverseChildren(IFieldReference fieldReference)
{ MethodEnter(fieldReference);
base.TraverseChildren(fieldReference);
MethodExit(); }
protected abstract void ReserveFieldToken(IFieldReference fieldReference);
protected override void ReserveFieldToken(IFieldReference fieldReference)
{
}
public FieldAccessorReplacementBuilder(IFieldReference field, ReplacementRegistry registry)
{
this.field = field;
this.registry = registry;
}
public uint GetFieldInternedKey(IFieldReference fieldReference) {
return 0;
}
public static bool IsVisible(IFieldReference value, IVisibilityConfiguration visibility)
{
if (IsVisible(value.DeclaringType, visibility))
{
IFieldDeclaration fieldDeclaration = value.Resolve();
if (fieldDeclaration == null)
{
return true;
}
switch (fieldDeclaration.Visibility)
{
case FieldVisibility.Public:
return visibility.Public;
case FieldVisibility.Assembly:
return visibility.Assembly;
case FieldVisibility.FamilyOrAssembly:
return visibility.FamilyOrAssembly;
case FieldVisibility.Family:
return visibility.Family;
case FieldVisibility.Private:
return visibility.Private;
case FieldVisibility.FamilyAndAssembly:
return visibility.FamilyAndAssembly;
case FieldVisibility.PrivateScope:
return visibility.Private;
}
throw new NotSupportedException();
}
return false;
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Performs some computation with the given field reference.
/// </summary>
/// <param name="fieldReference"></param>
public virtual void Visit(IFieldReference fieldReference)
{
if (this.stopTraversal) return;
this.Visit((ITypeMemberReference)fieldReference);
//^ int oldCount = this.path.Count;
this.path.Push(fieldReference);
if (fieldReference.IsModified)
this.Visit(fieldReference.CustomModifiers);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count.
this.path.Pop();
}
/// <summary>
/// Returns an expression that results in a closure object instance that contains the given field.
/// If the expression will be evaluated in the body of this.method, the result is a bound expression
/// that references the local that contains the object. Otherwise it is the "this" argument of the
/// anonymous delegate method, possibly with a number of field accesses to chase down the outer closure chain.
/// </summary>
/// <param name="closureField">A reference to a field from the "self instance" of a closure class.</param>
private IExpression GetClosureObjectInstanceContaining(IFieldReference closureField) {
if (this.isInsideAnonymousMethod) {
IExpression result = new ThisReference() { Type = this.currentClosureSelfInstance };
while (result.Type != closureField.ContainingType) {
var outerClosureField = this.fieldReferencesForUseInsideAnonymousMethods[result.Type];
result = new BoundExpression() { Instance = result, Definition = outerClosureField, Type = outerClosureField.Type };
}
return result;
} else {
foreach (var instance in this.closureLocalInstances) {
if (instance.Type == closureField.ContainingType) return instance;
}
return this.currentClosureObject;
}
}
/// <summary>
/// Traverses the children of the field reference.
/// </summary>
public virtual void TraverseChildren(IFieldReference fieldReference)
{
Contract.Requires(fieldReference != null);
//field reference attributes are distinct from field definition attributes. When a definition serves as a reference, the reference is assumed to be unattributed.
if (!(fieldReference is IFieldDefinition))
this.Traverse(fieldReference.Attributes);
this.Traverse(fieldReference.ContainingType);
if (this.stopTraversal) return;
if (fieldReference.IsModified) {
this.Traverse(fieldReference.CustomModifiers);
if (this.stopTraversal) return;
}
this.Traverse(fieldReference.Type);
}
public virtual void Visit(IFieldReference fieldReference)
{
this.Visit((ITypeMemberReference)fieldReference);
}
/// <summary>
/// Traverses the unspecialized field reference.
/// </summary>
private void TraverseUnspecialized(IFieldReference fieldReference)
{
Contract.Requires(fieldReference != null);
Contract.Requires(!(fieldReference is ISpecializedFieldReference));
if (!this.objectsThatHaveAlreadyBeenTraversed.Add(fieldReference)) return;
if (this.preorderVisitor != null) this.preorderVisitor.Visit(fieldReference);
if (this.stopTraversal) return;
this.TraverseChildren(fieldReference);
if (this.stopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(fieldReference);
}
public static string GetNameWithDeclaringType(IFieldReference value)
{
return GetNameWithResolutionScope(value.DeclaringType as ITypeReference) + "." + GetName(value);
}
public void Visit(IFieldReference fieldReference)
{
this.traverser.TraverseUnspecialized(fieldReference);
}
private IMethodDefinition CreateLoadLibraryMethod(ITypeDefinition typeDefinition, IModuleReference moduleRef, IFieldReference fieldRef)
{
var methodDefinition = new MethodDefinition
{
IsStatic = true,
Type = this.platformType.SystemVoid,
ContainingTypeDefinition = typeDefinition,
Name = this.nameTable.GetNameFor("LoadLibrary" + moduleRef.Name.Value),
IsNeverInlined = true,
Visibility = TypeMemberVisibility.Public,
Parameters = new List <IParameterDefinition> {
new ParameterDefinition {
Index = 0, Type = this.platformType.SystemString, Name = this.host.NameTable.GetNameFor("nativeLibraryFilePath")
}
}
};
var ilGenerator = new ILGenerator(this.host, methodDefinition);
ilGenerator.Emit(OperationCode.Ldarg_0);
ilGenerator.Emit(OperationCode.Call, this.loadLibrary);
ilGenerator.Emit(OperationCode.Stsfld, fieldRef);
ilGenerator.Emit(OperationCode.Ret);
var ilMethodBody = new ILGeneratorMethodBody(ilGenerator, false, 2, methodDefinition, Enumerable.Empty <ILocalDefinition>(), Enumerable.Empty <ITypeDefinition>());
methodDefinition.Body = ilMethodBody;
return(methodDefinition);
}
/// <summary>
/// Performs some computation with the given field reference.
/// </summary>
public virtual void Visit(IFieldReference fieldReference)
{
this.Visit((ITypeMemberReference)fieldReference);
}
public virtual void onMetadataElement(IFieldReference fieldReference) { }
protected override void ReserveFieldToken(IFieldReference fieldReference)
{
this.metadataWriter.GetFieldToken(fieldReference);
}
uint IInternFactory.GetFieldInternedKey(IFieldReference methodReference) {
lock (GlobalLock.LockingObject) {
return this.GetFieldReferenceInternedId(methodReference);
}
}
public bool AssignHeapTraceables(IVariable destination, IFieldReference field, IVariable source)
{
return(AssignHeapTraceables(destination, field, GetTraceables(source)));
}
public override void TraverseChildren(IFieldReference fieldReference)
{
MethodEnter(fieldReference);
base.TraverseChildren(fieldReference);
MethodExit();
}
private void ProcessFieldVariable(IFieldReference field, IExpression instance, bool buildSelectExpr) {
//TranslatedExpressions.Push(Bpl.Expr.Ident(this.StmtTraverser.MethodTraverser.ClassTraverser.FindOrCreateFieldVariable(field.ResolvedField))
TranslatedExpressions.Push( Bpl.Expr.Ident(
this.sink.FindOrCreateFieldVariable(field.ResolvedField) ) );
this.Visit(instance);
// if the field access is not a targetexpression we build a select expression
// otherwise the assignment visitor will build a mapassignment later on
if (buildSelectExpr) {
List<Bpl.Expr> elist = new List<Bpl.Expr>();
while (TranslatedExpressions.Count > 0) {
elist.Add(TranslatedExpressions.Pop());
}
TranslatedExpressions.Push(Bpl.Expr.Select(new Bpl.IdentifierExpr(field.Token(), HeapVariable), elist));
}
}
