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))); }
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)); } }