private static void AddCollectionLoop(Collection<Instruction> ins, VariableDefinition leftEnumerator, VariableDefinition leftHasNext,
VariableDefinition rightEnumerator, VariableDefinition rightHasNext)
{
var loopBegin = Instruction.Create(OpCodes.Nop);
ins.Add(loopBegin);
AddMoveNext(ins, leftEnumerator, leftHasNext);
AddMoveNext(ins, rightEnumerator, rightHasNext);
ins.IfAnd(
c => AddCheckHasNext(c, leftHasNext, false),
c => AddCheckHasNext(c, rightHasNext, false),
t => AddReturnTrue(t),
e =>
{
e.IfAnd(
c => AddCheckHasNext(c, leftHasNext, true),
c => AddCheckHasNext(c, rightHasNext, true),
t =>
{
t.If(
c => AddCheckCurrent(c, leftEnumerator, rightEnumerator),
tt => AddRerurnFalse(tt));
},
e2 =>
{
ins.Add(Instruction.Create(OpCodes.Ldc_I4_0));
ins.Add(Instruction.Create(OpCodes.Ret));
});
});
ins.Add(Instruction.Create(OpCodes.Br, loopBegin));
}
/// <summary>
/// Creates a new statement initializing a delegate variable.
/// </summary>
/// <param name="constructor">The constructor for the delegate type.</param>
/// <param name="target">The target the delegate will invoke.</param>
/// <param name="storage">The variable which will store the new delegate.</param>
public InitDelegateStatement(MethodReference constructor, MethodReference target, VariableDefinition storage)
: base(null)
{
this.m_Constructor = constructor;
this.m_Target = target;
this.m_Storage = storage;
}
public GetSurroundingClassImplementation(VariableDefinition invocationInfo,
VariableDefinition surroundingClassImplementation, MethodInfo getSurroundingImplementationMethod)
{
_invocationInfo = invocationInfo;
_surroundingClassImplementation = surroundingClassImplementation;
_getSurroundingImplementationMethod = getSurroundingImplementationMethod;
}
public GetSurroundingImplementationInstance(VariableDefinition aroundInvokeProvider, VariableDefinition invocationInfo, VariableDefinition surroundingImplementation, Instruction skipGetSurroundingImplementation)
{
_aroundInvokeProvider = aroundInvokeProvider;
_invocationInfo = invocationInfo;
_surroundingImplementation = surroundingImplementation;
_skipGetSurroundingImplementation = skipGetSurroundingImplementation;
}
public EmitBeforeInvoke(VariableDefinition invocationInfo, VariableDefinition surroundingClassImplementation, VariableDefinition surroundingImplementation, Type registryType)
{
_invocationInfo = invocationInfo;
_surroundingClassImplementation = surroundingClassImplementation;
_surroundingImplementation = surroundingImplementation;
_registryType = registryType;
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodBodyRewriterParameters"/> class.
/// </summary>
/// <param name="IL">The CilWorker that is responsible for the current method body.</param>
/// <param name="oldInstructions">The value indicating the list of old instructions in the current method body.</param>
/// <param name="interceptionDisabled">The value that determines whether or not interception is disabled.</param>
/// <param name="invocationInfo">The local variable that will store the <see cref="IInvocationInfo"/> instance.</param>
/// <param name="returnValue">The value indicating the local variable that will store the return value.</param>
/// <param name="methodReplacementProvider">The <see cref="IMethodReplacementProvider"/> instance.</param>
/// <param name="aroundInvokeProvider">The <see cref="IAroundInvokeProvider"/> instance.</param>
/// <param name="classMethodReplacementProvider">The class-level<see cref="IMethodReplacementProvider"/> instance.</param>
/// <param name="getMethodReplacementProviderMethod">The functor that resolves the GetMethodReplacementProvider method.</param>
/// <param name="registryType">The interception registry type that will be responsible for handling class-level interception events.</param>
public MethodBodyRewriterParameters(CilWorker IL, IEnumerable<Instruction> oldInstructions,
VariableDefinition interceptionDisabled,
VariableDefinition invocationInfo,
VariableDefinition returnValue,
VariableDefinition methodReplacementProvider,
VariableDefinition aroundInvokeProvider,
VariableDefinition classMethodReplacementProvider,
Func<ModuleDefinition, MethodReference> getMethodReplacementProviderMethod,
Type registryType)
{
if (methodReplacementProvider.VariableType.FullName != typeof(IMethodReplacementProvider).FullName)
throw new ArgumentException("methodReplacementProvider");
if (aroundInvokeProvider.VariableType.FullName != typeof(IAroundInvokeProvider).FullName)
throw new ArgumentException("aroundInvokeProvider");
_cilWorker = IL;
_oldInstructions = oldInstructions;
_interceptionDisabled = interceptionDisabled;
_invocationInfo = invocationInfo;
_returnValue = returnValue;
_methodReplacementProvider = methodReplacementProvider;
_aroundInvokeProvider = aroundInvokeProvider;
_classMethodReplacementProvider = classMethodReplacementProvider;
_getMethodReplacementProviderMethod = getMethodReplacementProviderMethod;
_registryType = registryType;
}
MethodDefinition InjectInterceptedMethod(TypeDefinition targetType, MethodDefinition innerOnPropertyChanging)
{
var delegateHolderInjector = new DelegateHolderInjector
{
TargetTypeDefinition=targetType,
OnPropertyChangingMethodReference = innerOnPropertyChanging,
ModuleWeaver = this
};
delegateHolderInjector.InjectDelegateHolder();
var method = new MethodDefinition(EventInvokerNames.First(), GetMethodAttributes(targetType), ModuleDefinition.TypeSystem.Void);
var propertyName = new ParameterDefinition("propertyName", ParameterAttributes.None, ModuleDefinition.TypeSystem.String);
method.Parameters.Add(propertyName);
if (InterceptorType == InvokerTypes.Before)
{
var before = new ParameterDefinition("before", ParameterAttributes.None, ModuleDefinition.TypeSystem.Object);
method.Parameters.Add(before);
}
var action = new VariableDefinition("firePropertyChanging", ActionTypeReference);
method.Body.Variables.Add(action);
var variableDefinition = new VariableDefinition("delegateHolder", delegateHolderInjector.TypeDefinition);
method.Body.Variables.Add(variableDefinition);
var instructions = method.Body.Instructions;
var last = Instruction.Create(OpCodes.Ret);
instructions.Add(Instruction.Create(OpCodes.Newobj, delegateHolderInjector.ConstructorDefinition));
instructions.Add(Instruction.Create(OpCodes.Stloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldarg_1));
instructions.Add(Instruction.Create(OpCodes.Stfld, delegateHolderInjector.PropertyName));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Stfld, delegateHolderInjector.Target));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldftn, delegateHolderInjector.MethodDefinition));
instructions.Add(Instruction.Create(OpCodes.Newobj, ActionConstructorReference));
instructions.Add(Instruction.Create(OpCodes.Stloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldfld, delegateHolderInjector.PropertyName));
if (InterceptorType == InvokerTypes.Before)
{
instructions.Add(Instruction.Create(OpCodes.Ldarg_2));
instructions.Add(Instruction.Create(OpCodes.Call, InterceptMethod));
}
else
{
instructions.Add(Instruction.Create(OpCodes.Call, InterceptMethod));
}
instructions.Add(last);
method.Body.InitLocals = true;
targetType.Methods.Add(method);
return method;
}
MethodDefinition InjectMethod(TypeDefinition targetType, string eventInvokerName, FieldReference propertyChangingField)
{
var method = new MethodDefinition(eventInvokerName, GetMethodAttributes(targetType), ModuleDefinition.TypeSystem.Void);
method.Parameters.Add(new ParameterDefinition("propertyName", ParameterAttributes.None, ModuleDefinition.TypeSystem.String));
var handlerVariable = new VariableDefinition(PropChangingHandlerReference);
method.Body.Variables.Add(handlerVariable);
var boolVariable = new VariableDefinition(ModuleDefinition.TypeSystem.Boolean);
method.Body.Variables.Add(boolVariable);
var instructions = method.Body.Instructions;
var last = Instruction.Create(OpCodes.Ret);
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Ldfld, propertyChangingField));
instructions.Add(Instruction.Create(OpCodes.Stloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldnull));
instructions.Add(Instruction.Create(OpCodes.Ceq));
instructions.Add(Instruction.Create(OpCodes.Stloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Brtrue_S, last));
instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Ldarg_1));
instructions.Add(Instruction.Create(OpCodes.Newobj, ComponentModelPropertyChangingEventConstructorReference));
instructions.Add(Instruction.Create(OpCodes.Callvirt, ComponentModelPropertyChangingEventHandlerInvokeReference));
instructions.Add(last);
method.Body.InitLocals = true;
targetType.Methods.Add(method);
return method;
}
public static void HandleDups(MethodDefinition coroutine, OrderedDictionary<Instruction, List<Instruction>> coroutineInstructions, Instruction instruction, List<Instruction> current, TypeReference expectedType, ref VariableDefinition dupLoc)
{
// FIXME: This is kindof a kludge... think on it
if (instruction.Previous.OpCode != OpCodes.Dup)
return;
var action = current.ToArray ();
current.Clear ();
if (dupLoc == null) {
dupLoc = new VariableDefinition (coroutine.Module.Import (typeof (object)));
coroutine.Body.Variables.Add (dupLoc);
}
if (expectedType.IsValueType)
current.Add (Instruction.Create (OpCodes.Box, expectedType));
current.Add (Instruction.Create (OpCodes.Stloc, dupLoc));
current.AddRange (action);
current.Add (Instruction.Create (OpCodes.Ldloc, dupLoc));
if (expectedType.IsValueType) {
current.Add (Instruction.Create (OpCodes.Unbox, expectedType));
current.Add (Instruction.Create (OpCodes.Ldobj, expectedType));
}
}
private static AssemblyDefinition CreateTestAssembly(OpCode opCode, bool invert)
{
var name = new AssemblyNameDefinition("TestConditionalsBoundaryTurtle", new Version(1, 0));
var assembly = AssemblyDefinition.CreateAssembly(name, "TestClass", ModuleKind.Dll);
var type = new TypeDefinition("TestConditionalsBoundaryTurtle", "TestClass",
TypeAttributes.Class | TypeAttributes.Public);
var intType = assembly.MainModule.Import(typeof(int));
var boolType = assembly.MainModule.Import(typeof(bool));
var method = new MethodDefinition("TestMethod", MethodAttributes.Public, intType);
var param = new ParameterDefinition("input", ParameterAttributes.In, intType);
method.Parameters.Add(param);
var resultVariable = new VariableDefinition(boolType);
method.Body.Variables.Add(resultVariable);
var processor = method.Body.GetILProcessor();
Instruction loadReturnValueInstruction = processor.Create(OpCodes.Ldloc, resultVariable);
method.Body.Instructions.Add(processor.Create(OpCodes.Ldarg, param));
method.Body.Instructions.Add(processor.Create(OpCodes.Ldc_I4, 0));
method.Body.Instructions.Add(processor.Create(opCode));
if (invert)
{
method.Body.Instructions.Add(processor.Create(OpCodes.Ldc_I4, 0));
method.Body.Instructions.Add(processor.Create(OpCodes.Ceq));
}
method.Body.Instructions.Add(processor.Create(OpCodes.Stloc, resultVariable));
method.Body.Instructions.Add(loadReturnValueInstruction);
method.Body.Instructions.Add(processor.Create(OpCodes.Ret));
type.Methods.Add(method);
assembly.MainModule.Types.Add(type);
return assembly;
}
/// <summary>
/// Initializes a new instance of the <see cref="GetMethodReplacementProvider"/> class.
/// </summary>
/// <param name="methodReplacementProvider">The local variable that contains the <see cref="IMethodReplacementProvider"/> instance.</param>
/// <param name="hostMethod">The target method.</param>
/// <param name="resolveGetProviderMethod">The functor that will resolve the GetProvider method.</param>
public GetMethodReplacementProvider(VariableDefinition methodReplacementProvider, MethodDefinition hostMethod,
Func<ModuleDefinition, MethodReference> resolveGetProviderMethod)
{
_methodReplacementProvider = methodReplacementProvider;
_hostMethod = hostMethod;
_resolveGetProviderMethod = resolveGetProviderMethod;
}
private TypeDefinition GenerateTypeA(AssemblyDefinition assembly)
{
var objType = assembly.MainModule.Import(typeof (object));
// define base class
var aType = new TypeDefinition("A", "", TypeAttributes.Class, objType);
assembly.MainModule.Types.Add(aType);
var typeParameter = new GenericParameter("T", aType);
aType.GenericParameters.Add(typeParameter);
var baseMethod = new MethodDefinition("Get",
MethodAttributes.Assem | MethodAttributes.Virtual |
MethodAttributes.NewSlot, typeParameter);
aType.Methods.Add(baseMethod);
baseMethod.DeclaringType = aType;
var local = new VariableDefinition(typeParameter);
baseMethod.Body.Variables.Add(local);
var cil = baseMethod.Body.CilWorker;
cil.Emit(OpCodes.Ldloca, local);
cil.Emit(OpCodes.Initobj, typeParameter);
cil.Emit(OpCodes.Ldloc, local);
cil.Emit(OpCodes.Ret);
return aType;
}
public void Visit(IBehaviorDefinition method, CustomAttribute attribute)
{
ILProcessor processor = method.Body.GetILProcessor();
string description = attribute.Properties.Where(argument => (argument.Name == "Description")).First().Argument.Value as string;
Instruction exitInstruction = processor.Create(OpCodes.Callvirt, method.Module.Import(broadcastType.GetMethod("Run", new[] {typeof(object), typeof(string)})));
var returnValue = new VariableDefinition("retVal", method.Module.Import(typeof(object)));
var enclosingObject = new VariableDefinition("enclosing", method.Module.Import(typeof(object)));
method.Body.Variables.Add(enclosingObject);
method.Body.Variables.Add(returnValue);
Instruction store = processor.Create(OpCodes.Stloc, returnValue);
Instruction reload = processor.Create(OpCodes.Ldloc, returnValue);
var instructions = new List<Instruction>();
if (!ReturnsVoid(method))
{
instructions.Add(store);
}
instructions.Add(processor.Create(OpCodes.Newobj, method.Module.Import(broadcastType.GetConstructor(new Type[] { }))));
instructions.Add(processor.Create(OpCodes.Ldarg_0));
instructions.Add(processor.Create(OpCodes.Ldstr, description));
instructions.Add(exitInstruction);
if (!ReturnsVoid(method))
{
instructions.Add(reload);
}
new InsertionAtEnd(processor, method).Run(instructions);
}
public ScopeVariable(string name, string type, VariableDefinition variable)
{
Name = name;
Type = type;
Var = variable;
}
private static void AddCollectionCode(PropertyDefinition property, bool isFirst, Collection<Instruction> ins, VariableDefinition resultVariable, MethodDefinition method, TypeDefinition type)
{
if (isFirst)
{
ins.Add(Instruction.Create(OpCodes.Ldc_I4_0));
ins.Add(Instruction.Create(OpCodes.Stloc, resultVariable));
}
ins.If(
c =>
{
LoadVariable(property, c, type);
},
t =>
{
LoadVariable(property, t, type);
var enumeratorVariable = method.Body.Variables.Add(property.Name + "Enumarator", ReferenceFinder.IEnumerator.TypeReference);
var currentVariable = method.Body.Variables.Add(property.Name + "Current", ReferenceFinder.Object.TypeReference);
GetEnumerator(t, enumeratorVariable);
AddCollectionLoop(resultVariable, t, enumeratorVariable, currentVariable);
},
f => { });
}
public GetClassMethodReplacementProvider(VariableDefinition invocationInfo, VariableDefinition classMethodReplacementProvider,
Func<ModuleDefinition, MethodReference> resolveGetProviderMethod)
{
_invocationInfo = invocationInfo;
_classMethodReplacementProvider = classMethodReplacementProvider;
_resolveGetProviderMethod = resolveGetProviderMethod;
}
public void Visit(IBehaviorDefinition method, CustomAttribute attribute)
{
ILProcessor processor = method.Body.GetILProcessor();
string description = attribute.Properties.Where(argument => (argument.Name == "Description")).First().Argument.Value as string;
var listType = typeof(List<object>);
var listVariable = new VariableDefinition("argumentz", method.Module.Import(listType));
method.Body.Variables.Add(listVariable);
var instructions = new List<Instruction>();
instructions.Add(processor.Create(OpCodes.Newobj, method.Module.Import(listType.GetConstructor(new Type[] { }))));
instructions.Add(processor.Create(OpCodes.Stloc, listVariable));
int parameterIndex = 1;
foreach (var parameter in method.Parameters)
{
instructions.Add(processor.Create(OpCodes.Ldloc, listVariable));
instructions.Add(processor.Create(OpCodes.Ldarg, parameterIndex));
if (parameter.ParameterType.IsPrimitive || parameter.ParameterType.IsValueType)
instructions.Add(processor.Create(OpCodes.Box, parameter.ParameterType));
instructions.Add(processor.Create(OpCodes.Callvirt, method.Module.Import(listType.GetMethod("Add", new[] { typeof(object) }))));
++parameterIndex;
}
instructions.Add(processor.Create(OpCodes.Newobj, method.Module.Import(broadcastType.GetConstructor(new Type[] {}))));
instructions.Add(processor.Create(OpCodes.Ldloc, listVariable));
instructions.Add(processor.Create(OpCodes.Ldstr, description));
instructions.Add(processor.Create(OpCodes.Callvirt, method.Module.Import(broadcastType.GetMethod("Run", new[] {listType, typeof(string)}))));
new InsertionAtStart(processor, method).Run(instructions);
}
public GetClassMethodReplacementProvider(IMethodBodyRewriterParameters parameters,
Func<ModuleDefinition, MethodReference> resolveGetProviderMethod)
{
_invocationInfo = parameters.InvocationInfo;
_classMethodReplacementProvider = parameters.ClassMethodReplacementProvider;
_resolveGetProviderMethod = resolveGetProviderMethod;
}
private static AssemblyDefinition CreateTestAssembly()
{
var name = new AssemblyNameDefinition("TestArithmeticOperatorTurtleAdd", new Version(1, 0));
var assembly = AssemblyDefinition.CreateAssembly(name, "TestClass", ModuleKind.Dll);
var type = new TypeDefinition("TestArithmeticOperatorTurtleAdd", "TestClass",
TypeAttributes.Class | TypeAttributes.Public);
var intType = assembly.MainModule.Import(typeof(int));
var method = new MethodDefinition("TestMethod", MethodAttributes.Public, intType);
var leftParam = new ParameterDefinition("left", ParameterAttributes.In, intType);
var rightParam = new ParameterDefinition("right", ParameterAttributes.In, intType);
method.Parameters.Add(leftParam);
method.Parameters.Add(rightParam);
var resultVariable = new VariableDefinition(intType);
method.Body.Variables.Add(resultVariable);
var processor = method.Body.GetILProcessor();
method.Body.Instructions.Add(processor.Create(OpCodes.Ldarg_1));
method.Body.Instructions.Add(processor.Create(OpCodes.Ldarg_2));
method.Body.Instructions.Add(processor.Create(OpCodes.Add));
method.Body.Instructions.Add(processor.Create(OpCodes.Stloc, resultVariable));
method.Body.Instructions.Add(processor.Create(OpCodes.Ldloc, resultVariable));
method.Body.Instructions.Add(processor.Create(OpCodes.Ret));
type.Methods.Add(method);
assembly.MainModule.Types.Add(type);
return assembly;
}
void InjectAsStreamReader(TypeDefinition targetType, FieldDefinition fieldDefinition)
{
AsStreamReaderMethod = new MethodDefinition("AsStreamReader", staticMethodAttributes, StreamReaderTypeReference);
var streamVariable = new VariableDefinition(StreamTypeReference);
AsStreamReaderMethod.Body.Variables.Add(streamVariable);
var pathParam = new ParameterDefinition(ModuleDefinition.TypeSystem.String);
AsStreamReaderMethod.Parameters.Add(pathParam);
AsStreamReaderMethod.Body.InitLocals = true;
var inst = AsStreamReaderMethod.Body.Instructions;
var skipReturn = Instruction.Create(OpCodes.Nop);
inst.Add(Instruction.Create(OpCodes.Ldsfld, fieldDefinition));
inst.Add(Instruction.Create(OpCodes.Ldarg, pathParam));
inst.Add(Instruction.Create(OpCodes.Callvirt, GetManifestResourceStreamMethod));
inst.Add(Instruction.Create(OpCodes.Stloc, streamVariable));
inst.Add(Instruction.Create(OpCodes.Ldloc, streamVariable));
inst.Add(Instruction.Create(OpCodes.Brtrue_S, skipReturn));
inst.Add(Instruction.Create(OpCodes.Ldnull));
inst.Add(Instruction.Create(OpCodes.Ret));
inst.Add(skipReturn);
inst.Add(Instruction.Create(OpCodes.Ldloc, streamVariable));
inst.Add(Instruction.Create(OpCodes.Newobj, StreamReaderConstructorReference));
inst.Add(Instruction.Create(OpCodes.Ret));
targetType.Methods.Add(AsStreamReaderMethod);
}
public void AddLocals(MethodDefinition hostMethod)
{
_constructorArguments = hostMethod.AddLocal<List<object>>();
_currentArgument = hostMethod.AddLocal<object>();
_methodContext = hostMethod.AddLocal<ITypeActivationContext>();
_currentActivator = hostMethod.AddLocal<ITypeActivator>();
}
/// <summary>
/// Emits a call that obtains the hash code for the current service instance.
/// </summary>
/// <param name="il">The <see cref="ILProcessor"/> that points to the method body.</param>
/// <param name="module">The target module.</param>
/// <param name="serviceInstance">The local variable that contains the service instance.</param>
private void GetServiceHash(ILProcessor il, ModuleDefinition module, VariableDefinition serviceInstance)
{
il.Emit(OpCodes.Ldloc, serviceInstance);
var getHashCodeMethod = module.ImportMethod<object>("GetHashCode");
il.Emit(OpCodes.Callvirt, getHashCodeMethod);
}
private static AssemblyDefinition CreateTestAssembly()
{
var name = new AssemblyNameDefinition("TestBranchConditionTurtle", new Version(1, 0));
var assembly = AssemblyDefinition.CreateAssembly(name, "TestClass", ModuleKind.Dll);
var type = new TypeDefinition("TestBranchConditionTurtle", "TestClass",
TypeAttributes.Class | TypeAttributes.Public);
var intType = assembly.MainModule.Import(typeof(int));
var boolType = assembly.MainModule.Import(typeof(bool));
var method = new MethodDefinition("TestMethod", MethodAttributes.Public, intType);
var leftParam = new ParameterDefinition("left", ParameterAttributes.In, intType);
var rightParam = new ParameterDefinition("right", ParameterAttributes.In, intType);
method.Parameters.Add(leftParam);
method.Parameters.Add(rightParam);
var resultVariable = new VariableDefinition(boolType);
method.Body.Variables.Add(resultVariable);
var processor = method.Body.GetILProcessor();
Instruction loadReturnValueInstruction = processor.Create(OpCodes.Ldloc, resultVariable);
Instruction storeTrueInReturnValueInstruction = processor.Create(OpCodes.Ldc_I4, -1);
method.Body.Instructions.Add(processor.Create(OpCodes.Ldarg, leftParam));
method.Body.Instructions.Add(processor.Create(OpCodes.Ldarg, rightParam));
method.Body.Instructions.Add(processor.Create(OpCodes.Ceq));
method.Body.Instructions.Add(processor.Create(OpCodes.Brtrue_S, storeTrueInReturnValueInstruction));
method.Body.Instructions.Add(processor.Create(OpCodes.Ldc_I4, 0));
method.Body.Instructions.Add(processor.Create(OpCodes.Stloc, resultVariable));
method.Body.Instructions.Add(processor.Create(OpCodes.Br_S, loadReturnValueInstruction));
method.Body.Instructions.Add(storeTrueInReturnValueInstruction);
method.Body.Instructions.Add(processor.Create(OpCodes.Stloc, resultVariable));
method.Body.Instructions.Add(loadReturnValueInstruction);
method.Body.Instructions.Add(processor.Create(OpCodes.Ret));
type.Methods.Add(method);
assembly.MainModule.Types.Add(type);
return assembly;
}
public void Visit(IBehaviorDefinition behaviorDefinition, CustomAttribute attribute)
{
ILProcessor processor = behaviorDefinition.Body.GetILProcessor();
var pingerDefinition = new VariableDefinition("pinger",
behaviorDefinition.Module.Import(pingType));
behaviorDefinition.Body.Variables.Add(pingerDefinition);
var start = new List<Instruction>
{
processor.Create(OpCodes.Ldstr, behaviorDefinition.Name),
processor.Create(OpCodes.Newobj,
behaviorDefinition.Module.Import(
pingType.GetConstructor(new[]{typeof(string)}))),
processor.Create(OpCodes.Stloc, pingerDefinition),
processor.Create(OpCodes.Ldloc, pingerDefinition),
processor.Create(OpCodes.Callvirt,
behaviorDefinition.Module.Import(pingType.GetMethod("Start",
new Type[] {}))),
};
var end = new List<Instruction>
{
processor.Create(OpCodes.Ldloc, pingerDefinition),
processor.Create(OpCodes.Callvirt,
behaviorDefinition.Module.Import(pingType.GetMethod("End",
new Type[] {})))
};
new InsertionAtStart(processor, behaviorDefinition).Run(start);
new InsertionAtEnd(processor, behaviorDefinition).Run(end);
foreach (var instruction in behaviorDefinition.Body.Instructions)
{
Console.Out.WriteLine("{0}/[{1}]: {2} {3}", instruction.Offset, Sequence(instruction.SequencePoint), instruction.OpCode, instruction.Operand);
}
}
public InvokeMethodReplacement(Instruction executeOriginalInstructions, VariableDefinition methodReplacementProvider, VariableDefinition classMethodReplacementProvider, VariableDefinition invocationInfo)
{
_executeOriginalInstructions = executeOriginalInstructions;
_methodReplacementProvider = methodReplacementProvider;
_classMethodReplacementProvider = classMethodReplacementProvider;
_invocationInfo = invocationInfo;
}
int AddBeforeAfterInvokerCall(int index, PropertyDefinition property)
{
var beforeVariable = new VariableDefinition(msCoreReferenceFinder.ObjectTypeReference);
setMethodBody.Variables.Add(beforeVariable);
var afterVariable = new VariableDefinition(msCoreReferenceFinder.ObjectTypeReference);
setMethodBody.Variables.Add(afterVariable);
var isVirtual = property.GetMethod.IsVirtual;
var getMethod = property.GetMethod.GetGeneric();
index = instructions.Insert(index,
Instruction.Create(OpCodes.Ldarg_0),
CreateCall(getMethod),
//TODO: look into why this box is required
Instruction.Create(OpCodes.Box, property.GetMethod.ReturnType),
Instruction.Create(OpCodes.Stloc, afterVariable),
Instruction.Create(OpCodes.Ldarg_0),
Instruction.Create(OpCodes.Ldstr, property.Name),
Instruction.Create(OpCodes.Ldloc, beforeVariable),
Instruction.Create(OpCodes.Ldloc, afterVariable),
CallEventInvoker()
);
instructions.Prepend(
Instruction.Create(OpCodes.Ldarg_0),
CreateCall(getMethod),
//TODO: look into why this box is required
Instruction.Create(OpCodes.Box, property.GetMethod.ReturnType),
Instruction.Create(OpCodes.Stloc, beforeVariable));
return index + 4;
}
public void Visit(IBehaviorDefinition behaviorDefinition, CustomAttribute attribute)
{
ILProcessor processor = behaviorDefinition.Body.GetILProcessor();
var pingerDefinition = new VariableDefinition("pinger",
behaviorDefinition.Module.Import(breakpointType));
behaviorDefinition.Body.Variables.Add(pingerDefinition);
var sequencedInstructions =
behaviorDefinition.Body.Instructions.Where(instruction => instruction.SequencePoint != null).ToList();
Console.Out.WriteLine(sequencedInstructions.Count);
// var extractedInstructions = Specific(sequencedInstructions, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21);
var extractedInstructions = Filtered(sequencedInstructions);
foreach (var instruction in extractedInstructions)
{
Type intType = typeof(int);
var breakPointInstructions = new List<Instruction>
{
processor.Create(OpCodes.Newobj, behaviorDefinition.Module.Import(
breakpointType.GetConstructor(new Type[]{}))),
processor.Create(OpCodes.Ldc_I4, instruction.SequencePoint.StartLine),
processor.Create(OpCodes.Ldc_I4, instruction.SequencePoint.StartColumn),
processor.Create(OpCodes.Ldc_I4, instruction.SequencePoint.EndLine),
processor.Create(OpCodes.Ldc_I4, instruction.SequencePoint.EndColumn),
processor.Create(OpCodes.Ldstr, instruction.SequencePoint.Document.Url),
processor.Create(OpCodes.Call,
behaviorDefinition.Module.Import(breakpointType.GetMethod("Activate",
new[] {intType, intType, intType, intType, typeof(string)})))
};
breakPointInstructions.ForEach(bpr => processor.InsertBefore(instruction, bpr));
foreach (var i in behaviorDefinition.Body.Instructions)
{
Console.Out.WriteLine("{0}/[{1}]: {2} {3}", i.Offset, Sequence(i.SequencePoint), i.OpCode, i.Operand);
}
}
}
int AddBeforeAfterInvokerCall(int index, PropertyDefinition property)
{
var beforeVariable = new VariableDefinition(typeSystem.Object);
setMethodBody.Variables.Add(beforeVariable);
var afterVariable = new VariableDefinition(typeSystem.Object);
setMethodBody.Variables.Add(afterVariable);
var getMethod = property.GetMethod.GetGeneric();
index = instructions.Insert(index,
Instruction.Create(OpCodes.Ldarg_0),
CreateCall(getMethod),
Instruction.Create(OpCodes.Box, property.GetMethod.ReturnType),
Instruction.Create(OpCodes.Stloc, afterVariable),
Instruction.Create(OpCodes.Ldarg_0),
Instruction.Create(OpCodes.Ldstr, property.Name),
Instruction.Create(OpCodes.Ldloc, beforeVariable),
Instruction.Create(OpCodes.Ldloc, afterVariable),
CallEventInvoker()
);
instructions.Prepend(
Instruction.Create(OpCodes.Ldarg_0),
CreateCall(getMethod),
Instruction.Create(OpCodes.Box, property.GetMethod.ReturnType),
Instruction.Create(OpCodes.Stloc, beforeVariable));
return index + 4;
}
public static VariableDefinition AddV(this Collection<VariableDefinition> variables,
TypeReference typeReference)
{
VariableDefinition variable = new VariableDefinition(typeReference);
variables.Add(variable);
return variable;
}
/// <summary>
/// Emits the IL instructions that will store information about the method <paramref name="targetMethod">currently being executed</paramref>
/// and stores the results into the <paramref name="invocationInfo">variable.</paramref>
/// </summary>
/// <param name="emitter">The <see cref="IEmitInvocationInfo"/> instance.</param>
/// <param name="method">The method whose implementation will be intercepted.</param>
/// <param name="targetMethod">The actual method that will contain the resulting instructions.</param>
/// <param name="invocationInfo">The <see cref="VariableDefinition">local variable</see> that will store the current <see cref="IInvocationInfo"/> instance.</param>
public static void Emit(this IEmitInvocationInfo emitter, MethodInfo method, MethodDefinition targetMethod,
VariableDefinition invocationInfo)
{
ModuleDefinition module = targetMethod.DeclaringType.Module;
MethodReference interceptedMethod = module.Import(method);
emitter.Emit(targetMethod, interceptedMethod, invocationInfo);
}
public VariableIndex(int index)
{
this.variable = null;
this.index = index;
}
static int GetVariableIndex(VariableDefinition variable)
{
return(variable.Index);
}
