/// <inheritdoc />
public void StoreElement(int index, TypeMemoryLayout typeLayout, ICliValue value, ICliMarshaller marshaller)
{
AssertIndexValidity(index);
var elementValue = marshaller.ToCtsValue(value, typeLayout.Type.ToTypeSignature());
this.WriteStruct(index * (int)typeLayout.Size, _memoryAllocator, typeLayout, elementValue);
}
private void Verify(IFieldDescriptor field, ICliValue expectedValue)
{
var result = Dispatcher.Execute(ExecutionContext, new CilInstruction(CilOpCodes.Ldsfld, field));
Assert.True(result.IsSuccess);
Assert.Equal(expectedValue, ExecutionContext.ProgramState.Stack.Top);
}
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);
}
/// <inheritdoc />
public override DispatchResult Execute(CilExecutionContext context, CilInstruction instruction)
{
var environment = context.GetService <ICilRuntimeEnvironment>();
var stack = context.ProgramState.Stack;
var value = (ICliValue)stack.Pop();
bool overflowed = false;
ICliValue newValue = instruction.OpCode.Code switch
{
CilCode.Conv_I1 => value.ConvertToI1(false, out _),
CilCode.Conv_Ovf_I1 => value.ConvertToI1(false, out overflowed),
CilCode.Conv_Ovf_I1_Un => value.ConvertToI1(true, out overflowed),
CilCode.Conv_U1 => value.ConvertToU1(false, out _),
CilCode.Conv_Ovf_U1 => value.ConvertToU1(false, out overflowed),
CilCode.Conv_Ovf_U1_Un => value.ConvertToU1(true, out overflowed),
CilCode.Conv_I2 => value.ConvertToI2(false, out _),
CilCode.Conv_Ovf_I2 => value.ConvertToI2(false, out overflowed),
CilCode.Conv_Ovf_I2_Un => value.ConvertToI2(true, out overflowed),
CilCode.Conv_U2 => value.ConvertToU2(false, out _),
CilCode.Conv_Ovf_U2 => value.ConvertToU2(false, out overflowed),
CilCode.Conv_Ovf_U2_Un => value.ConvertToU2(true, out overflowed),
CilCode.Conv_I4 => value.ConvertToI4(false, out _),
CilCode.Conv_Ovf_I4 => value.ConvertToI4(false, out overflowed),
CilCode.Conv_Ovf_I4_Un => value.ConvertToI4(true, out overflowed),
CilCode.Conv_U4 => value.ConvertToU4(false, out _),
CilCode.Conv_Ovf_U4 => value.ConvertToU4(false, out overflowed),
CilCode.Conv_Ovf_U4_Un => value.ConvertToU4(true, out overflowed),
CilCode.Conv_I8 => value.ConvertToI8(false, out _),
CilCode.Conv_Ovf_I8 => value.ConvertToI8(false, out overflowed),
CilCode.Conv_Ovf_I8_Un => value.ConvertToI8(true, out overflowed),
CilCode.Conv_U8 => value.ConvertToU8(false, out _),
CilCode.Conv_Ovf_U8 => value.ConvertToU8(false, out overflowed),
CilCode.Conv_Ovf_U8_Un => value.ConvertToU8(true, out overflowed),
CilCode.Conv_I => value.ConvertToI(environment.Is32Bit, false, out _),
CilCode.Conv_Ovf_I => value.ConvertToI(environment.Is32Bit, false, out overflowed),
CilCode.Conv_Ovf_I_Un => value.ConvertToI(environment.Is32Bit, true, out overflowed),
CilCode.Conv_U => value.ConvertToU(environment.Is32Bit, false, out _),
CilCode.Conv_Ovf_U => value.ConvertToU(environment.Is32Bit, false, out overflowed),
CilCode.Conv_Ovf_U_Un => value.ConvertToU(environment.Is32Bit, true, out overflowed),
CilCode.Conv_R4 => value.ConvertToR4(),
CilCode.Conv_R8 => value.ConvertToR8(),
CilCode.Conv_R_Un => value.ConvertToR(),
_ => throw new ArgumentOutOfRangeException()
};
if (overflowed)
{
return(new DispatchResult(new OverflowException()));
}
context.ProgramState.Stack.Push(newValue);
return(base.Execute(context, instruction));
}
}
/// <inheritdoc />
protected override void StoreElement(
ExecutionContext context,
CilInstruction instruction,
IDotNetArrayValue array,
int index,
ICliValue value)
{
var environment = context.GetService <ICilRuntimeEnvironment>();
var type = (ITypeDescriptor)instruction.Operand;
var typeLayout = environment.ValueFactory.GetTypeMemoryLayout(type);
array.StoreElement(index, typeLayout, value, environment.CliMarshaller);
}
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));
}
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);
}
/// <inheritdoc />
protected override void StoreElement(ExecutionContext context, CilInstruction instruction,
IDotNetArrayValue dotNetArray, int index, ICliValue value)
{
var marshaller = context.GetService <ICilRuntimeEnvironment>().CliMarshaller;
switch (instruction.OpCode.Code)
{
case CilCode.Stelem_I:
dotNetArray.StoreElementI(index, value.InterpretAsI(marshaller.Is32Bit), marshaller);
break;
case CilCode.Stelem_I1:
dotNetArray.StoreElementI1(index, value.InterpretAsI1(), marshaller);
break;
case CilCode.Stelem_I2:
dotNetArray.StoreElementI2(index, value.InterpretAsI2(), marshaller);
break;
case CilCode.Stelem_I4:
dotNetArray.StoreElementI4(index, value.InterpretAsI4(), marshaller);
break;
case CilCode.Stelem_I8:
dotNetArray.StoreElementI8(index, value.InterpretAsI8(), marshaller);
break;
case CilCode.Stelem_R4:
dotNetArray.StoreElementR4(index, value.InterpretAsR4(), marshaller);
break;
case CilCode.Stelem_R8:
dotNetArray.StoreElementR8(index, value.InterpretAsR8(), marshaller);
break;
case CilCode.Stelem_Ref:
dotNetArray.StoreElementRef(index, value.InterpretAsRef(marshaller.Is32Bit), marshaller);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <inheritdoc />
public void StoreElement(int index, TypeMemoryLayout typeLayout, ICliValue value, ICliMarshaller marshaller) =>
_values[index] = marshaller.ToCtsValue(value, typeLayout.Type.ToTypeSignature());
/// <inheritdoc />
public ICliValue InvokeIndirect(ICliValue address, MethodSignature methodSig, IEnumerable <ICliValue> arguments)
{
return(CreateReturnValue(methodSig));
}
public ICliValue InvokeIndirect(ICliValue address, MethodSignature methodSig, IEnumerable <ICliValue> arguments)
{
return(_original.InvokeIndirect(address, methodSig, arguments));
}
