private HLLocation ProcessTargetExpression(ITargetExpression pExpression) { if (pExpression.Definition is ILocalDefinition) { return(HLLocalLocation.Create(HLDomain.GetLocal(pExpression.Definition as ILocalDefinition))); } else if (pExpression.Definition is IParameterDefinition) { HLParameter parameter = HLDomain.GetParameter(pExpression.Definition as IParameterDefinition); parameter.RequiresAddressing = true; return(HLParameterLocation.Create(parameter)); } else if (pExpression.Definition is IFieldDefinition || pExpression.Definition is IFieldReference) { IFieldDefinition definition = pExpression.Definition is IFieldDefinition ? (IFieldDefinition)pExpression.Definition : ((IFieldReference)pExpression.Definition).ResolvedField; HLType typeFieldContainer = HLDomain.GetOrCreateType(definition.Container); HLField field = HLDomain.GetField(definition); if (field.IsStatic) { return(HLStaticFieldLocation.Create(field)); } HLLocation instance = ProcessExpression(pExpression.Instance); return(HLFieldLocation.Create(instance, field)); } else if (pExpression.Definition is IAddressDereference) { IAddressDereference definition = pExpression.Definition as IAddressDereference; HLLocation locationAddress = ProcessExpression(definition.Address); return(HLIndirectAddressLocation.Create(locationAddress, HLDomain.GetOrCreateType(pExpression.Type))); } throw new NotSupportedException(); }
public override void Visit(IAddressDereference addressDereference) { if (Process(addressDereference)) { visitor.Visit(addressDereference); } base.Visit(addressDereference); }
public override void TraverseChildren(IAddressDereference addressDereference) { base.TraverseChildren(addressDereference); IPointerTypeReference /*?*/ pointerTypeReference = addressDereference.Address.Type as IPointerTypeReference; if (pointerTypeReference != null) { if (!(pointerTypeReference.TargetType is Dummy)) { if (addressDereference.Type is Dummy) { ((AddressDereference)addressDereference).Type = pointerTypeReference.TargetType; } else if (!TypeHelper.TypesAreEquivalent(addressDereference.Type, pointerTypeReference.TargetType)) { var targetPointerType = Immutable.PointerType.GetPointerType(addressDereference.Type, this.host.InternFactory); ((AddressDereference)addressDereference).Address = new Conversion() { ValueToConvert = addressDereference.Address, TypeAfterConversion = targetPointerType, Type = targetPointerType }; } return; } } IManagedPointerTypeReference /*?*/ managedPointerTypeReference = addressDereference.Address.Type as IManagedPointerTypeReference; if (managedPointerTypeReference != null) { if (!(managedPointerTypeReference.TargetType is Dummy)) { if (addressDereference.Type is Dummy) { ((AddressDereference)addressDereference).Type = managedPointerTypeReference.TargetType; } else if (!TypeHelper.TypesAreEquivalent(addressDereference.Type, managedPointerTypeReference.TargetType)) { if (managedPointerTypeReference.TargetType.TypeCode == PrimitiveTypeCode.Boolean && addressDereference.Type.TypeCode == PrimitiveTypeCode.Int8) { ((AddressDereference)addressDereference).Type = managedPointerTypeReference.TargetType; } else { var targetPointerType = Immutable.ManagedPointerType.GetManagedPointerType(addressDereference.Type, this.host.InternFactory); ((AddressDereference)addressDereference).Address = new Conversion() { ValueToConvert = addressDereference.Address, TypeAfterConversion = targetPointerType, Type = targetPointerType }; } } return; } } }
public void Visit(IAddressDereference addressDereference) { throw new NotImplementedException(); }
/// <summary> /// /// </summary> /// <param name="addressDereference"></param> public AddressDereference(IAddressDereference addressDereference) : base(addressDereference) { this.address = addressDereference.Address; if (addressDereference.IsUnaligned) this.alignment = addressDereference.Alignment; else this.alignment = 0; this.isVolatile = addressDereference.IsVolatile; }
public void Visit(IAddressDereference addressDereference) { this.traverser.Traverse(addressDereference); }
/// <summary> /// Performs some computation with the given address dereference expression. /// </summary> /// <param name="addressDereference"></param> public virtual void Visit(IAddressDereference addressDereference) { this.Visit((IExpression)addressDereference); }
public override void TraverseChildren(IAddressDereference addressDereference) { MethodEnter(addressDereference); base.TraverseChildren(addressDereference); MethodExit(); }
/// <summary> /// Traverses the address dereference expression. /// </summary> public void Traverse(IAddressDereference addressDereference) { Contract.Requires(addressDereference != null); if (this.preorderVisitor != null) this.preorderVisitor.Visit(addressDereference); if (this.StopTraversal) return; this.TraverseChildren(addressDereference); if (this.StopTraversal) return; if (this.postorderVisitor != null) this.postorderVisitor.Visit(addressDereference); }
/// <summary> /// Returns a shallow copy of the given address dereference expression. /// </summary> /// <param name="addressDereference"></param> public AddressDereference Copy(IAddressDereference addressDereference) { return new AddressDereference(addressDereference); }
public override void Visit(IAddressDereference addressDereference) { if(Process(addressDereference)){visitor.Visit(addressDereference);} base.Visit(addressDereference); }
private void VisitAssignmentTo(IAddressDereference addressDereference) { if (addressDereference.IsUnaligned) this.generator.Emit(OperationCode.Unaligned_, addressDereference.Alignment); if (addressDereference.IsVolatile) this.generator.Emit(OperationCode.Volatile_); OperationCode opcode; switch (addressDereference.Type.TypeCode) { case PrimitiveTypeCode.Boolean: opcode = OperationCode.Stind_I1; break; case PrimitiveTypeCode.Char: opcode = OperationCode.Stind_I2; break; case PrimitiveTypeCode.Float32: opcode = OperationCode.Stind_R4; break; case PrimitiveTypeCode.Float64: opcode = OperationCode.Stind_R8; break; case PrimitiveTypeCode.Int16: opcode = OperationCode.Stind_I2; break; case PrimitiveTypeCode.Int32: opcode = OperationCode.Stind_I4; break; case PrimitiveTypeCode.Int64: opcode = OperationCode.Stind_I8; break; case PrimitiveTypeCode.Int8: opcode = OperationCode.Stind_I1; break; case PrimitiveTypeCode.IntPtr: opcode = OperationCode.Stind_I; break; case PrimitiveTypeCode.Pointer: opcode = OperationCode.Stind_I; break; case PrimitiveTypeCode.UInt16: opcode = OperationCode.Stind_I2; break; case PrimitiveTypeCode.UInt32: opcode = OperationCode.Stind_I4; break; case PrimitiveTypeCode.UInt64: opcode = OperationCode.Stind_I8; break; case PrimitiveTypeCode.UInt8: opcode = OperationCode.Stind_I1; break; case PrimitiveTypeCode.UIntPtr: opcode = OperationCode.Stind_I; break; default: if (addressDereference.Type.IsValueType || addressDereference.Type is IGenericParameterReference) { this.generator.Emit(OperationCode.Stobj, addressDereference.Type); this.StackSize-=2; return; } opcode = OperationCode.Stind_Ref; break; } this.generator.Emit(opcode); this.StackSize-=2; }
/// <summary> /// Generates IL for the specified address dereference. /// </summary> /// <param name="addressDereference">The address dereference.</param> public override void TraverseChildren(IAddressDereference addressDereference) { this.Traverse(addressDereference.Address); if (addressDereference.IsUnaligned) this.generator.Emit(OperationCode.Unaligned_, addressDereference.Alignment); if (addressDereference.IsVolatile) this.generator.Emit(OperationCode.Volatile_); OperationCode opcode; switch (addressDereference.Type.TypeCode) { case PrimitiveTypeCode.Boolean: opcode = OperationCode.Ldind_U1; break; case PrimitiveTypeCode.Char: opcode = OperationCode.Ldind_U2; break; case PrimitiveTypeCode.Float32: opcode = OperationCode.Ldind_R4; break; case PrimitiveTypeCode.Float64: opcode = OperationCode.Ldind_R8; break; case PrimitiveTypeCode.Int16: opcode = OperationCode.Ldind_I2; break; case PrimitiveTypeCode.Int32: opcode = OperationCode.Ldind_I4; break; case PrimitiveTypeCode.Int64: opcode = OperationCode.Ldind_I8; break; case PrimitiveTypeCode.Int8: opcode = OperationCode.Ldind_I1; break; case PrimitiveTypeCode.IntPtr: opcode = OperationCode.Ldind_I; break; case PrimitiveTypeCode.Pointer: opcode = OperationCode.Ldind_I; break; case PrimitiveTypeCode.UInt16: opcode = OperationCode.Ldind_U2; break; case PrimitiveTypeCode.UInt32: opcode = OperationCode.Ldind_U4; break; case PrimitiveTypeCode.UInt64: opcode = OperationCode.Ldind_I8; break; case PrimitiveTypeCode.UInt8: opcode = OperationCode.Ldind_U1; break; case PrimitiveTypeCode.UIntPtr: opcode = OperationCode.Ldind_I; break; default: var ptr = addressDereference.Type as IPointerTypeReference; if (ptr != null) { opcode = OperationCode.Ldind_I; break; } else { var mgdPtr = addressDereference.Type as IManagedPointerTypeReference; if (mgdPtr != null) { opcode = OperationCode.Ldind_I; break; } } //If addressDereference.Type is a reference type, then Ldobj is equivalent to Lind_Ref, but the instruction is larger, so try to avoid it. if (addressDereference.Type.IsValueType || addressDereference.Type is IGenericParameterReference) { this.generator.Emit(OperationCode.Ldobj, addressDereference.Type); return; } opcode = OperationCode.Ldind_Ref; break; } this.generator.Emit(opcode); }
public override void TraverseChildren(IAddressDereference addressDereference) { if (addressDereference.Address.Type is IPointerTypeReference || addressDereference.Address.Type.TypeCode == PrimitiveTypeCode.IntPtr || addressDereference.Address is IDupValue || addressDereference.Address is IPopValue) this.sourceEmitterOutput.Write("*"); else { var addrOf = addressDereference.Address as IAddressOf; if (addrOf != null) { this.Traverse(addrOf.Expression); return; } } this.Traverse(addressDereference.Address); }
private void VisitAssignmentTo(IAddressDereference addressDereference) { if (addressDereference.IsUnaligned) this.generator.Emit(OperationCode.Unaligned_, addressDereference.Alignment); if (addressDereference.IsVolatile) this.generator.Emit(OperationCode.Volatile_); this.StoreIndirect(addressDereference.Type); }
/// <summary> /// Generates IL for the specified address dereference. /// </summary> /// <param name="addressDereference">The address dereference.</param> public override void TraverseChildren(IAddressDereference addressDereference) { this.Traverse(addressDereference.Address); if (addressDereference.IsUnaligned) this.generator.Emit(OperationCode.Unaligned_, addressDereference.Alignment); if (addressDereference.IsVolatile) this.generator.Emit(OperationCode.Volatile_); this.LoadIndirect(addressDereference.Type); }
public virtual void onASTElement(IAddressDereference addressDereference) { }
public override void TraverseChildren(IAddressDereference addressDereference) { IBoundExpression be = addressDereference.Address as IBoundExpression; if (be != null) { IParameterDefinition pd = be.Definition as IParameterDefinition; if (pd != null) { this.LoadParameter(pd); return; } } this.Traverse(addressDereference.Address); return; }
private HLLocation ProcessAddressDereferenceExpression(IAddressDereference pExpression) { HLLocation locationAddress = ProcessExpression(pExpression.Address); return HLIndirectAddressLocation.Create(locationAddress, HLDomain.GetOrCreateType(pExpression.Type)); }
private HLLocation ProcessAddressDereferenceExpression(IAddressDereference pExpression) { HLLocation locationAddress = ProcessExpression(pExpression.Address); return(HLIndirectAddressLocation.Create(locationAddress, HLDomain.GetOrCreateType(pExpression.Type))); }
public void Visit(IAddressDereference addressDereference) { this.result = this.copier.Copy(addressDereference); }
public override void Visit(IAddressDereference addressDereference) { allElements.Add(new InvokInfo(Traverser, "IAddressDereference", addressDereference)); }
public virtual void onASTElement(IAddressDereference addressDereference) { }
/// <summary> /// Rewrites the given address dereference expression. /// </summary> /// <param name="addressDereference"></param> public virtual IExpression Rewrite(IAddressDereference addressDereference) { return addressDereference; }
/// <summary> /// Performs some computation with the given address dereference expression. /// </summary> /// <param name="addressDereference"></param> public virtual void Visit(IAddressDereference addressDereference) { }
public override void TraverseChildren(IAddressDereference addressDereference) { base.TraverseChildren(addressDereference); IPointerTypeReference/*?*/ pointerTypeReference = addressDereference.Address.Type as IPointerTypeReference; if (pointerTypeReference != null) { if (!(pointerTypeReference.TargetType is Dummy)) { if (addressDereference.Type is Dummy) ((AddressDereference)addressDereference).Type = pointerTypeReference.TargetType; else if (!TypeHelper.TypesAreEquivalent(addressDereference.Type, pointerTypeReference.TargetType)) { var targetPointerType = Immutable.PointerType.GetPointerType(addressDereference.Type, this.host.InternFactory); ((AddressDereference)addressDereference).Address = new Conversion() { ValueToConvert = addressDereference.Address, TypeAfterConversion = targetPointerType, Type = targetPointerType }; } return; } } IManagedPointerTypeReference/*?*/ managedPointerTypeReference = addressDereference.Address.Type as IManagedPointerTypeReference; if (managedPointerTypeReference != null) { if (!(managedPointerTypeReference.TargetType is Dummy)) { if (addressDereference.Type is Dummy) ((AddressDereference)addressDereference).Type = managedPointerTypeReference.TargetType; else if (!TypeHelper.TypesAreEquivalent(addressDereference.Type, managedPointerTypeReference.TargetType)) { if (managedPointerTypeReference.TargetType.TypeCode == PrimitiveTypeCode.Boolean && addressDereference.Type.TypeCode == PrimitiveTypeCode.Int8) ((AddressDereference)addressDereference).Type = managedPointerTypeReference.TargetType; else { var targetPointerType = Immutable.ManagedPointerType.GetManagedPointerType(addressDereference.Type, this.host.InternFactory); ((AddressDereference)addressDereference).Address = new Conversion() { ValueToConvert = addressDereference.Address, TypeAfterConversion = targetPointerType, Type = targetPointerType }; } } return; } } }
/// <summary> /// Traverses the children of the address dereference expression. /// </summary> public virtual void TraverseChildren(IAddressDereference addressDereference) { Contract.Requires(addressDereference != null); this.TraverseChildren((IExpression)addressDereference); if (this.StopTraversal) return; this.Traverse(addressDereference.Address); }
/// <summary> /// Returns a deep copy of the given address dereference expression. /// </summary> /// <param name="addressDereference"></param> public AddressDereference Copy(IAddressDereference addressDereference) { Contract.Requires(addressDereference != null); Contract.Ensures(Contract.Result<AddressDereference>() != null); var mutableCopy = this.shallowCopier.Copy(addressDereference); mutableCopy.Address = this.Copy(mutableCopy.Address); return mutableCopy; }
//^ ensures this.path.Count == old(this.path.Count); /// <summary> /// Traverses the given address dereference expression. /// </summary> /// <param name="addressDereference"></param> public virtual void Visit(IAddressDereference addressDereference) { if (this.stopTraversal) return; //^ int oldCount = this.path.Count; this.path.Push(addressDereference); this.Visit(addressDereference.Address); //^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not to decrease this.path.Count. this.path.Pop(); }
/// <summary> /// Returns a shallow copy of the given address dereference expression. /// </summary> /// <param name="addressDereference"></param> public AddressDereference Copy(IAddressDereference addressDereference) { Contract.Requires(addressDereference != null); Contract.Ensures(Contract.Result<AddressDereference>() != null); return new AddressDereference(addressDereference); }
public void Visit(IAddressDereference addressDereference) { Contract.Requires(addressDereference != null); throw new NotImplementedException(); }
/// <summary> /// Performs some computation with the given address dereference expression. /// </summary> /// <param name="addressDereference"></param> public virtual void Visit(IAddressDereference addressDereference) { }
public override void Visit(IAddressDereference addressDereference) { IBoundExpression be = addressDereference.Address as IBoundExpression; if (be != null) { IParameterDefinition pd = be.Definition as IParameterDefinition; if (pd != null) { var pv = this.sink.FindParameterVariable(pd); TranslatedExpressions.Push(Bpl.Expr.Ident(pv)); return; } } this.Visit(addressDereference.Address); throw new NotImplementedException(); }
/// <summary> /// Visits the specified address dereference. /// </summary> /// <param name="addressDereference">The address dereference.</param> public override void Visit(IAddressDereference addressDereference) { AddressDereference mutableAddressDereference = new AddressDereference(addressDereference); this.resultExpression = this.myCodeCopier.DeepCopy(mutableAddressDereference); }
public override void TraverseChildren(IAddressDereference addressDereference) { if (addressDereference.Address.Type is IPointerTypeReference || addressDereference.Address.Type.TypeCode == PrimitiveTypeCode.IntPtr || addressDereference.Address.Type.TypeCode == PrimitiveTypeCode.UIntPtr || addressDereference.Address is IDupValue || addressDereference.Address is IPopValue) { this.sourceEmitterOutput.Write("*"); var conv = addressDereference.Address as IConversion; if (conv != null && (conv.TypeAfterConversion.TypeCode == PrimitiveTypeCode.IntPtr || conv.TypeAfterConversion.TypeCode == PrimitiveTypeCode.UIntPtr)) { string type = TypeHelper.GetTypeName(addressDereference.Type, NameFormattingOptions.ContractNullable|NameFormattingOptions.UseTypeKeywords); this.sourceEmitterOutput.Write("("+type+"*)"); this.Traverse(conv.ValueToConvert); return; } } else { var addrOf = addressDereference.Address as IAddressOf; if (addrOf != null) { this.Traverse(addrOf.Expression); return; } } this.Traverse(addressDereference.Address); }
/// <summary> /// Returns a deep copy of the given address dereference expression. /// </summary> /// <param name="addressDereference"></param> public AddressDereference Copy(IAddressDereference addressDereference) { var mutableCopy = this.shallowCopier.Copy(addressDereference); mutableCopy.Address = this.Copy(mutableCopy.Address); return mutableCopy; }
public override void TraverseChildren(IAddressDereference addressDereference) { MethodEnter(addressDereference); base.TraverseChildren(addressDereference); MethodExit(); }
public void Visit(IAddressDereference addressDereference) { this.result = this.rewriter.Rewrite(addressDereference); }