/// <inheritdoc />
public void SetFieldValue(IFieldDescriptor field, IConcreteValue value)
{
var typeMemoryLayout = _memoryAllocator.GetTypeMemoryLayout(field.DeclaringType);
var fieldMemoryLayout = typeMemoryLayout[field.Resolve()];
this.WriteStruct((int)fieldMemoryLayout.Offset, _memoryAllocator, fieldMemoryLayout.ContentsLayout, value);
}
private void SetAndVerify(IFieldDescriptor field, IConcreteValue fieldValue, ICliValue expectedValue)
{
var environment = ExecutionContext.GetService <ICilRuntimeEnvironment>();
environment.StaticFieldFactory.Get(field).Value = fieldValue;
Verify(field, expectedValue);
}
private void SetAndVerify(string fieldName, IConcreteValue fieldValue, ICliValue expectedValue)
{
var module = ModuleDefinition.FromFile(typeof(SimpleClass).Assembly.Location);
var type = (TypeDefinition)module.LookupMember(typeof(SimpleClass).MetadataToken);
var field = type.Fields.First(f => f.Name == fieldName);
SetAndVerify(field, fieldValue, expectedValue);
}
public void CreateNewArrayFromExistingArray()
{
var elements = new IConcreteValue[]
{
new Integer32Value(0), new Integer32Value(1), new Integer32Value(2),
};
var array = new ArrayValue(elements);
Assert.Equal(elements, array);
}
private void Verify(string fieldName, ICliValue newValue, IConcreteValue expectedValue)
{
var module = ModuleDefinition.FromFile(typeof(SimpleClass).Assembly.Location);
var type = (TypeDefinition)module.LookupMember(typeof(SimpleClass).MetadataToken);
var field = type.Fields.First(f => f.Name == fieldName);
var environment = ExecutionContext.GetService <ICilRuntimeEnvironment>();
var staticField = environment.StaticFieldFactory.Get(field);
ExecutionContext.ProgramState.Stack.Push(newValue);
var result = Dispatcher.Execute(ExecutionContext, new CilInstruction(CilOpCodes.Stsfld, field));
Assert.True(result.IsSuccess);
Assert.Equal(expectedValue, staticField.Value);
}
private void VerifyUndocumentedWriteStatic(IConcreteValue instanceObject, ICliValue stackValue, IConcreteValue expectedValue)
{
var environment = ExecutionContext.GetService <ICilRuntimeEnvironment>();
var stack = ExecutionContext.ProgramState.Stack;
// Set initial field value.
var simpleClassType = LookupTestType(typeof(SimpleClass));
var field = simpleClassType.Fields.First(f => f.Name == nameof(SimpleClass.StaticIntField));
// Push random object.
stack.Push(instanceObject);
stack.Push(stackValue);
// Test.
var result = Dispatcher.Execute(ExecutionContext, new CilInstruction(CilOpCodes.Stfld, field));
Assert.True(result.IsSuccess);
Assert.Equal(expectedValue, environment.StaticFieldFactory.Get(field).Value);
}
private void Verify(string fieldName, ICliValue stackValue, IConcreteValue expectedValue)
{
var environment = ExecutionContext.GetService <ICilRuntimeEnvironment>();
var stack = ExecutionContext.ProgramState.Stack;
// Look up relevant metadata.
var simpleClassType = LookupTestType(typeof(SimpleClass));
var field = simpleClassType.Fields.First(f => f.Name == fieldName);
// Create new virtual instance and push on stack.
var value = new HleObjectValue(simpleClassType.ToTypeSignature(), environment.Is32Bit);
stack.Push(environment.CliMarshaller.ToCliValue(value, simpleClassType.ToTypeSignature()));
stack.Push(stackValue);
// Test stfld.
var result = Dispatcher.Execute(ExecutionContext, new CilInstruction(CilOpCodes.Stfld, field));
Assert.True(result.IsSuccess);
Assert.Equal(expectedValue, value.GetFieldValue(field));
}
/// <inheritdoc />
public ICliValue ToCliValue(IConcreteValue value, TypeSignature originalType)
{
return(originalType.ElementType switch
{
ElementType.I1 => Int8ToI4(value as IntegerValue, true),
ElementType.U1 => Int8ToI4(value as IntegerValue, false),
ElementType.I2 => Int16ToI4(value as IntegerValue, true),
ElementType.Char => Int16ToI4(value as IntegerValue, false),
ElementType.U2 => Int16ToI4(value as IntegerValue, false),
ElementType.Boolean => BoolToI4(value as IntegerValue),
ElementType.I4 => Int32ToI4(value as IntegerValue),
ElementType.U4 => Int32ToI4(value as IntegerValue),
ElementType.I8 => Int64ToI8(value as IntegerValue),
ElementType.U8 => Int64ToI8(value as IntegerValue),
ElementType.R4 => Float32ToR4((Float32Value)value),
ElementType.R8 => Float64ToR8((Float64Value)value),
ElementType.I => IntToI(value as IntegerValue),
ElementType.U => IntToI(value as IntegerValue),
ElementType.Ptr => PtrToPointerValue(value as IPointerValue),
ElementType.ValueType => ObjectToStruct(value, originalType),
_ => ObjectToO(value)
});
private void Verify(string fieldName, IConcreteValue fieldValue, ICliValue expectedValue)
{
var environment = ExecutionContext.GetService <ICilRuntimeEnvironment>();
var stack = ExecutionContext.ProgramState.Stack;
// Look up relevant metadata.
var simpleClassType = LookupTestType(typeof(SimpleClass));
var field = simpleClassType.Fields.First(f => f.Name == fieldName);
// Create new virtual instance and push on stack.
var objectRef = environment.ValueFactory.CreateObject(simpleClassType.ToTypeSignature(), true);
var contents = (IDotNetStructValue)objectRef.ReferencedObject;
contents.SetFieldValue(field, fieldValue);
stack.Push(environment.CliMarshaller.ToCliValue(objectRef, simpleClassType.ToTypeSignature()));
// Test ldfld.
var result = Dispatcher.Execute(ExecutionContext, new CilInstruction(CilOpCodes.Ldfld, field));
Assert.True(result.IsSuccess);
Assert.Equal(expectedValue, stack.Top);
}
public IConcreteValue InvokeIndirect(IConcreteValue address, MethodSignature methodSig,
IEnumerable <IConcreteValue> arguments)
{
return(_original.InvokeIndirect(address, methodSig, arguments));
}
/// <summary>
/// Creates a new reference to an object.
/// </summary>
/// <param name="referencedObject">The referenced object.</param>
/// <param name="isKnown">Indicates the referenced object is known.</param>
/// <param name="is32Bit">Indicates the pointer to the referenced object is 32 or 64 bits wide.</param>
public ObjectReference(IConcreteValue referencedObject, bool isKnown, bool is32Bit)
{
Is32Bit = is32Bit;
ReferencedObject = referencedObject;
IsKnown = isKnown;
}
/// <summary>
/// Creates a new fully known reference to an object.
/// </summary>
/// <param name="referencedObject">The referenced object.</param>
/// <param name="is32Bit">Indicates the pointer to the referenced object is 32 or 64 bits wide.</param>
public ObjectReference(IConcreteValue referencedObject, bool is32Bit)
: this(referencedObject, true, is32Bit)
{
}
/// <summary>
/// Creates a new object reference value.
/// </summary>
/// <param name="referencedObject">The referenced value.</param>
/// <param name="isKnown">Indicates whether the value is known.</param>
/// <param name="is32Bit">Indicates whether the reference to the object is 32 or 64 bits wide.</param>
public OValue(IConcreteValue referencedObject, bool isKnown, bool is32Bit)
: base(referencedObject, isKnown, is32Bit)
{
}
/// <inheritdoc />
public IConcreteValue InvokeIndirect(IConcreteValue address, MethodSignature methodSig,
IEnumerable <IConcreteValue> arguments)
{
return(CreateReturnValue(methodSig));
}
public ConcreteValueEqualityComparer(IConcreteValue a1)
{
this.a1 = a1;
}
public LhsConcreteValueUnifier(IConcreteValue lhsConcreteValue, BoundVariableSet boundVariables)
{
this.lhsConcreteValue = lhsConcreteValue;
this.boundVariables = boundVariables;
}
public bool Visit(IConcreteValue lhsConcreteValue)
{
return(rhsValue.Accept(new LhsConcreteValueUnifier(lhsConcreteValue, boundVariables)));
}
public Unifier(IConcreteValue lhs, BoundVariableSet boundVariables)
{
this.lhs = lhs;
this.boundVariables = boundVariables;
}
