C# ILProcessor.InsertAfter方法代码示例

    void HandleOfParameter(Instruction instruction, ILProcessor ilProcessor)
    {
        //Info.OfMethod("AssemblyToProcess","MethodClass","InstanceMethod");

        var methodNameInstruction = instruction.Previous;
        var methodName = GetLdString(methodNameInstruction);

        var typeNameInstruction = methodNameInstruction.Previous;
        var typeName = GetLdString(typeNameInstruction);

        var assemblyNameInstruction = typeNameInstruction.Previous;
        var assemblyName = GetLdString(assemblyNameInstruction);

        var typeDefinition = GetTypeDefinition(assemblyName, typeName);

        var methodDefinition = typeDefinition.Methods.FirstOrDefault(x => x.Name == methodName);
        if (methodDefinition == null)
        {
            throw new WeavingException($"Could not find method named '{methodName}'.");
        }

        var methodReference = ModuleDefinition.ImportReference(methodDefinition);

        ilProcessor.Remove(typeNameInstruction);

        assemblyNameInstruction.OpCode = OpCodes.Ldtoken;
        assemblyNameInstruction.Operand = methodReference;

        instruction.Operand = getMethodFromHandle;

        ilProcessor.InsertAfter(instruction,Instruction.Create(OpCodes.Castclass,methodInfoType));
    }

        public Instruction InsertAfter(Instruction instruction, ILProcessor processor)
        {
            var currentInstruction = instruction;
            foreach (var newInstruction in Instructions)
            {
                processor.InsertAfter(currentInstruction, newInstruction);
                currentInstruction = newInstruction;
            }

            return currentInstruction;
        }

        public static void GetMethod(Instruction i, ILProcessor proc, ModuleDefinition baseModule)
        {
            if (i.Operand is FieldReference
                && ((FieldReference)i.Operand).FullName.Contains("Monocle.Sprite`1<System.Int32> TowerFall.AwardInfo/<>c__DisplayClass")
                && ((FieldReference)i.Operand).FullName.Contains("::sprite"))
            {
                Stored = Instruction.Create(OpCodes.Ldfld, i.Operand as FieldReference);
            }

            if (i.OpCode == OpCodes.Callvirt && i.Next.OpCode != OpCodes.Br_S
                && ((MethodReference)i.Operand).FullName == "System.Void Monocle.Sprite`1<System.Int32>::Add(T,System.Int32)")
            {
                TypeDefinition graphicsComponent = baseModule.GetType("Monocle.GraphicsComponent");
                 var fieldReference = graphicsComponent.Fields.Single(f => f.Name == "Zoom");
                var instr = Instruction.Create(OpCodes.Stfld, fieldReference);
                var ldinstr = Instruction.Create(i.Next.OpCode);
                proc.InsertAfter(i, instr);
                proc.InsertAfter(i, proc.Create(OpCodes.Ldc_R4, (float)0.7));
                proc.InsertAfter(i, Stored);
                proc.InsertAfter(i, ldinstr);
            }
        }

    void HandleOfProperty(Instruction instruction, ILProcessor ilProcessor, Func<PropertyDefinition, MethodDefinition> func)
    {
        var propertyNameInstruction = instruction.Previous;
        var propertyName = GetLdString(propertyNameInstruction);

        var typeNameInstruction = propertyNameInstruction.Previous;
        var typeName = GetLdString(typeNameInstruction);

        var assemblyNameInstruction = typeNameInstruction.Previous;
        var assemblyName = GetLdString(assemblyNameInstruction);

        var typeDefinition = GetTypeDefinition(assemblyName, typeName);

        var property = typeDefinition.Properties.FirstOrDefault(x => x.Name == propertyName);

        if (property == null)
        {
            throw new WeavingException($"Could not find property named '{propertyName}'.")
            {
                SequencePoint = instruction.SequencePoint
            };
        }
        var methodDefinition = func(property);
        if (methodDefinition == null)
        {
            throw new WeavingException($"Could not find property named '{propertyName}'.")
            {
                SequencePoint = instruction.SequencePoint
            };
        }
        ilProcessor.Remove(typeNameInstruction);
        ilProcessor.Remove(propertyNameInstruction);

        assemblyNameInstruction.OpCode = OpCodes.Ldtoken;
        assemblyNameInstruction.Operand = methodDefinition;

        if (typeDefinition.HasGenericParameters)
        {
            var typeReference = ModuleDefinition.ImportReference(typeDefinition);
            ilProcessor.InsertBefore(instruction, Instruction.Create(OpCodes.Ldtoken, typeReference));
            instruction.Operand = getMethodFromHandleGeneric;
        }
        else
        {
            instruction.Operand = getMethodFromHandle;
        }

        ilProcessor.InsertAfter(instruction, Instruction.Create(OpCodes.Castclass, methodInfoType));
    }

        private Instruction AddConditionGoto(ILProcessor ilp, Instruction last, Instruction stateMachineStarting)
        {
            var shouldRunSynchronouslyMethod = _engine.GetMethod<Func<ActorCore, bool>> (a => a.ShouldRunSynchronously ());

            var loadThis = ilp.Create (OpCodes.Ldarg_0);
            var loadField = ilp.Create (OpCodes.Ldfld, _actorMixin);
            var callMethod = ilp.Create (OpCodes.Call, shouldRunSynchronouslyMethod);
            var gotoNext = ilp.Create (OpCodes.Brtrue_S, stateMachineStarting);

            ilp.InsertAfter (last, loadThis);
            ilp.InsertAfter (loadThis, loadField);
            ilp.InsertAfter (loadField, callMethod);
            ilp.InsertAfter (callMethod, gotoNext);

            return gotoNext;
        }

        public static int ToNop(ILProcessor ilp, Instruction ins, bool sameSize)
        {
            if (ins == null) return 0;

            int size = ins.GetSize();
            ins.OpCode = OpCodes.Nop;
            ins.Operand = null;
            if (sameSize)
            {
                for (int i = 1; i < size; i++)
                {
                    Instruction newIns = ilp.Create(OpCodes.Nop);
                    ilp.InsertAfter(ins, newIns);
                }
            }
            else
            {
                size = 1;
            }
            return size;
        }

        private void ReplaceIncrementPinnedStructGeneric(MethodDefinition method, ILProcessor ilProcessor, Instruction incrementPinnedToPatch)
        {
            var paramT = ((GenericInstanceMethod)incrementPinnedToPatch.Operand).GenericArguments[0];

            var sizeOfInst = ilProcessor.Create(OpCodes.Sizeof, paramT);

            ilProcessor.Replace(incrementPinnedToPatch, sizeOfInst);
            ilProcessor.InsertAfter(sizeOfInst, ilProcessor.Create(OpCodes.Add));
        }

        private static void Inject(ILProcessor ilGen, IEnumerable<Instruction> instructions, Instruction instructionToReplace)
        {
            Instruction prevInstruction = instructionToReplace;

            foreach(Instruction currInstruction in instructions)
            {
                ilGen.InsertAfter(prevInstruction, currInstruction);
                prevInstruction = currInstruction;
            }

            ilGen.Remove(instructionToReplace);
        }

		void SendWriterPacket(MethodDefinition sendData, ILProcessor processor, VariableDefinition mswriter, OpCode binaryWriter)
		{

			// inject the packet contents array after the method updates the packet id.
			// our signature we look for is the last call to update the Position
			var offset = sendData.Body.Instructions.Last(
				x => x.OpCode == OpCodes.Callvirt
				&& (x.Operand as MethodReference).Name == "set_Position"
			);

			VariableDefinition packetContents;
			sendData.Body.Variables.Add(packetContents = new VariableDefinition("packetContents",
				this.SourceDefinition.MainModule.Import(typeof(byte[]))
			));

			processor.InsertAfter(offset,
				new { OpCodes.Ldloc, mswriter },
				new
				{
					OpCodes.Callvirt,
					Operand = this.SourceDefinition.MainModule.Import(typeof(MemoryStream)
						.GetMethods()
						.Single(x => x.Name == "ToArray" && x.GetParameters().Count() == 0)
					)
				},
				new { OpCodes.Stloc, packetContents }
			);

			// replace all instances of NetMessage.buffer[index].writeBuffer with out new packetContents
			foreach (var writeBuffer in sendData.Body.Instructions.Where(
				x => x.OpCode == OpCodes.Ldfld
				&& (x.Operand as FieldReference).Name == "writeBuffer"
			).ToArray())
			{
				// now remove all calls back to the when the buffer is loaded
				// remove the writeBuffer
				// replace the messagebuffer instruction with our packet contents
				// note: always ensure the writeBuffer is below packetContents

				VariableDefinition vrbBuffer = packetContents;
				if (writeBuffer.Offset < offset.Offset)
				{
					//Needs a local buffer that gets written into our writer

					//find the first argument (ldarg.s number)
					var firstInstruction = writeBuffer.Previous(
						x => x.OpCode == OpCodes.Ldarg_S
						&& (x.Operand as ParameterReference).Name == "number"
					);

					VariableDefinition localBuffer;
					sendData.Body.Variables.Add(localBuffer = new VariableDefinition(
						this.SourceDefinition.MainModule.Import(typeof(byte[]))
					));

					processor.InsertAfter(firstInstruction,
					   //new { OpCodes.Ldc_I4, Operand = 65536 },
					   new { OpCodes.Newarr, Operand = this.SourceDefinition.MainModule.TypeSystem.Byte },
					   new { OpCodes.Stloc, Operand = localBuffer },
					   new { firstInstruction.OpCode, Operand = (ParameterDefinition)firstInstruction.Operand }
				   );

					firstInstruction.OpCode = OpCodes.Ldc_I4;
					firstInstruction.Operand = 65535;

					//find the position set, as we are starting from 0 with out new array
					var argPosition = firstInstruction.Next(x => x.OpCode == OpCodes.Ldloc_1);
					while (argPosition.Next.OpCode != OpCodes.Call)
					{
						processor.Remove(argPosition.Next);
					}
					argPosition.OpCode = OpCodes.Ldc_I4_0;

					vrbBuffer = localBuffer;

					// the local buffer is now in place
					// we now need to send it off to the writer, instead of simply incrementing

					// get the method call and skip the result variable and remove all instructions until the branch out
					var call = writeBuffer.Next(
						x => x.OpCode == OpCodes.Call
						&& (x.Operand as MethodReference).Name == "CompressTileBlock"
					).Next;

					while (call.Next.OpCode != OpCodes.Br)
					{
						processor.Remove(call.Next);
					}

					processor.InsertAfter(call,
						new { OpCode = binaryWriter },
						new { OpCodes.Ldloc, localBuffer },
						new { OpCodes.Ldc_I4_0 },
						new { OpCodes.Ldloc_S, Operand = (VariableDefinition)call.Operand },
						new
						{
							OpCodes.Callvirt,
							Operand = this.SourceDefinition.MainModule.Import(typeof(BinaryWriter)
								.GetMethods()
								.Single(x => x.Name == "Write"
//.........这里部分代码省略.........

		void InjectNewWriter(MethodDefinition sendData, ILProcessor processor, out VariableDefinition mswriter, out OpCode binaryWriter)
		{
			var buffer = sendData.Body.Instructions.First(
				x => x.OpCode == OpCodes.Ldsfld
				&& (x.Operand as FieldReference).Name == "buffer"
			);

			while (!(buffer.Next.OpCode == OpCodes.Callvirt
				&& (buffer.Next.Operand as MethodReference).Name == "set_Position"))
			{
				processor.Remove(buffer.Next);
			}
			processor.Remove(buffer.Next);
			//processor.Remove(buffer);

			//VariableDefinition mswriter;
			sendData.Body.Variables.Add(mswriter = new VariableDefinition("mswriter",
				this.SourceDefinition.MainModule.Import(typeof(MemoryStream))
			));

			var res = processor.InsertBefore(buffer.Previous.Previous,
				new
				{
					OpCodes.Newobj,
					Operand = this.SourceDefinition.MainModule.Import(typeof(MemoryStream)
						.GetConstructors()
						.Single(x => x.GetParameters().Count() == 0)
					)
				},
				new { OpCodes.Stloc, Operand = mswriter },
				new { OpCodes.Ldloc, Operand = mswriter }
			);

			buffer.Previous.Previous.ReplaceTransfer(res[0], sendData);
			processor.Remove(buffer.Previous);
			processor.Remove(buffer.Previous);

			buffer.OpCode = OpCodes.Newobj;
			buffer.Operand = this.SourceDefinition.MainModule.Import(typeof(BinaryWriter)
				.GetConstructors()
				.Single(x => x.GetParameters().Count() == 1)
			);
			if (buffer.Next.OpCode != OpCodes.Ldloc_1)
			{
				throw new NotSupportedException("Expected Ldloc_1");
			}

			/*var*/
			binaryWriter = buffer.Next.OpCode;
			processor.InsertAfter(buffer,
				new { OpCodes.Stloc_1 }
			);
		}

 private void UnwrapLazyVariable(ILProcessor ilProcessor, Instruction targetInstructin)
 {
     ilProcessor.InsertAfter(targetInstructin,Instruction.Create(OpCodes.Blt));
 }

//.........这里部分代码省略.........
			//				var typeDefinition = typeModuleDefinition.Types.Where(td => td.FullName == genericParameter).FirstOrDefault();
			//				if(typeDefinition != null && Verbosity >= 5) 
			//				{
			//					Console.WriteLine("Resolved typeDefinition: " + typeDefinition);
			//				}
			//				else
			//				{
			//					Console.WriteLine("Failed to resolve typeDefinition: " + type.FullName);
			////					foreach(var td in ModuleDefinition.ReadModule(type.Module.Assembly.Location).Types)
			////					{
			////						Console.WriteLine(" ... " + td.FullName);
			////					}
			//					continue;
			//				}
					
			//				method.Module.Import(type); // try removing this
					
			//				IMetadataScope scope = method.Module;
			//				var typeRef = new TypeReference(type.Namespace, type.Name, typeModuleDefinition, scope, type.IsValueType);
			//				Console.WriteLine("TypeRef: "+ typeRef);
					
			//				method.Module.Import(type);
			var replacementMethodImported = method.Module.Import (replacementMethod);
					
			// IL_0000:  ldtoken Rewriter.TestClass
					
			if (genericTypeParameter != null) {
				processor.InsertBefore (i, processor.Create (OpCodes.Ldtoken, method.Module.Import (genericTypeParameter)));
			} else {
				processor.InsertBefore (i, processor.Create (OpCodes.Ldtoken, method.Module.Import (genericTypeParameterDefinition)));
			}
					
			// IL_0005:  call class [mscorlib]System.Type class
			//              [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
					
			var gtfh = typeof(Type).GetMethod ("GetTypeFromHandle");
			MethodReference gtfhRef = method.Module.Import (gtfh, mr);
					
			processor.InsertBefore (i, processor.Create (OpCodes.Call, gtfhRef));
					
			// IL_000a:  call void class Rewriter.TestClass::TestMethod(class [mscorlib]System.Type)
			var callMethod = processor.Create (i.OpCode, replacementMethodImported);
			processor.InsertAfter (i, callMethod);
					
			#region Cast the result, if it exists
					
			if (mr.ReturnType.FullName != "System.Void" && !noCast) {
				string castAssembly;
				string castType;
						
				if (genericTypeParameter != null) {
					castAssembly = genericTypeParameter.Assembly.GetName (false).Name;
					castType = "[" + castAssembly + "]" + genericTypeParameter.FullName;
				} else if (genericTypeParameterDefinition != null) {
					castAssembly = "";
					castType = genericTypeParameterDefinition.ToString ();
					//						var resolvedGTPD = genericTypeParameterDefinition.Resolve();
					//						resolvedGTPD.FullName
				} else {
					castType = "???";
					Console.WriteLine ("INTERNAL ERROR - genericTypeParameter not set for " + mr.FullName + ". genericTypeParameterDefinition:" + genericTypeParameterDefinition.Resolve ());
					return InvocationResult.Failed;
				}
						
				//					castAssembly = castAssembly.Substring(castAssembly.IndexOf(","));
				if (Verbosity > 8)
					Console.WriteLine ("CAST to " + castType + " | " + genericTypeParameterDefinition);
				var importedGenericType = mr.Module.Import (genericTypeParameterDefinition);
				processor.InsertAfter (callMethod,
						                      processor.Create (OpCodes.Castclass, importedGenericType));
			}
					
			#endregion
					
			processor.Remove (i);
			replaced++;
					
			//				if(Verbosity >= Verbosities.Success)
			//					Console.WriteLine(" - " + ((MethodReference)i.Operand).Name + " replaced with " + replacementMethod.FullName);
					
					
			//				mr.GetGenericParameters(null);
			//
			//			if(method.GenericParameters.Count == 0) return;
			//
			//			if(method.GenericParameters.Count > 1)
			//			{
			//				Console.WriteLine("Warning: cannot handle more than one generic parameter yet: " + 
			//				                  method.DeclaringType.FullName + "." + method.Name);
			//				return;
			//			}
			//
			//			var body = method.Body;
			//			body.Instructions
			//			if(method.GenericParameters.Count == 1)
			//			{
			//			}

			return InvocationResult.Succeeded;
		}

        private Instruction AddEnqueueOps(ILProcessor ilp, Instruction last)
        {
            var enqueueMethod = GetEnqueueMethodReference();
            var endInstruction = ilp.Body.Instructions.Last ();

            var loadThis = ilp.Create (OpCodes.Ldarg_0);
            var loadMixinField = ilp.Create (OpCodes.Ldfld, _actorMixin);
            var loadStateMachineVar_1 = ilp.Create (OpCodes.Ldloca_S, ilp.Body.Variables[0]);
            var loadBuilderField = ilp.Create (OpCodes.Ldfld, GetBuilderField ());
            var loadStateMachineVar_2 = ilp.Create (OpCodes.Ldloca_S, ilp.Body.Variables[0]);
            var callMethod = ilp.Create (OpCodes.Call, enqueueMethod);
            var gotoEnd = ilp.Create (OpCodes.Br, endInstruction);

            ilp.InsertAfter (last, loadThis);
            ilp.InsertAfter (loadThis, loadMixinField);
            ilp.InsertAfter (loadMixinField, loadStateMachineVar_1);
            ilp.InsertAfter (loadStateMachineVar_1, loadBuilderField);
            ilp.InsertAfter (loadBuilderField, loadStateMachineVar_2);
            ilp.InsertAfter (loadStateMachineVar_2, callMethod);
            ilp.InsertAfter (callMethod, gotoEnd);

            return gotoEnd;
        }

        /// <summary>
        /// stateMachine.mixin = this.mixin;
        /// </summary>
        /// <returns>The last instruction added</returns>
        /// <param name="ilp">Il processor</param>
        /// <param name="after">Add instructions after this one</param>
        private Instruction AddSetActorMixin(ILProcessor ilp, Instruction after)
        {
            var loadStateMachineVar = ilp.Create (OpCodes.Ldloca_S, ilp.Body.Variables[0]);
            var loadThis = ilp.Create (OpCodes.Ldarg_0);
            var loadField = ilp.Create (OpCodes.Ldfld, _actorMixin);
            var storeField = ilp.Create (OpCodes.Stfld, _stateMachineMixin);

            ilp.InsertAfter (after, loadStateMachineVar);
            ilp.InsertAfter (loadStateMachineVar, loadThis);
            ilp.InsertAfter (loadThis, loadField);
            ilp.InsertAfter (loadField, storeField);

            return storeField;
        }

        private static void Instrument (
                                      AssemblyDefinition assembly,
                                      TypeDefinition type,
                                       Instruction instruction,
                                       MethodReference countReference,
                                       MethodDefinition method,
                                       ILProcessor worker,
                                       string lastLine,
                                       InstrumentConfig config,
                                       TextWriter writer,
                                       ref int instrumentIndex)
        {
            //if the previous instruction is a Prefix instruction then this instruction MUST go with it.
            //we cannot put an instruction between the two.
            if (instruction.Previous != null && instruction.Previous.OpCode.OpCodeType == OpCodeType.Prefix)
                return;

            if (config.HasOffset (method.FullName, instruction.Offset))
                return;

            if (lastLine != null && config.HasLine (method.FullName, lastLine)) {
                return;
            }

            var lineNumStart = -1;
            var lineNumEnd = -1;
            if (instruction.SequencePoint != null) {
                lineNumStart = instruction.SequencePoint.StartLine;
                lineNumEnd = instruction.SequencePoint.EndLine;
            }

            var parentTypeRef = type;
            while (parentTypeRef.DeclaringType != null)
                parentTypeRef = parentTypeRef.DeclaringType;

            var line = string.Join ("\t",
                                   assembly.Name,  //0
                                   parentTypeRef.FullName,//1
                                   method.FullName, //2 
                                   lineNumStart, //3
                                   lineNumEnd, //4 
                                   instruction.Offset, //5
                                   instruction.ToString ().Replace ("\n", " "), //6
                                   instruction.SequencePoint?.Document.Url); //7

   
            writer.WriteLine (line);

            var pathParamLoadInstruction = worker.Create (OpCodes.Ldstr, config.HitsPathPrefix);
            var lineParamLoadInstruction = worker.Create (OpCodes.Ldc_I4, instrumentIndex);
            var registerInstruction = worker.Create (OpCodes.Call, countReference);

            //inserting method before instruction  because after will not happen after a method Ret instruction
            worker.InsertBefore (instruction, pathParamLoadInstruction);
            worker.InsertAfter (pathParamLoadInstruction, lineParamLoadInstruction);
            worker.InsertAfter (lineParamLoadInstruction, registerInstruction);

            ++instrumentIndex;

            //change try/finally etc to point to our first instruction if they referenced the one we inserted before
            foreach (var handler in method.Body.ExceptionHandlers) {
                if (handler.FilterStart == instruction)
                    handler.FilterStart = pathParamLoadInstruction;

                if (handler.TryStart == instruction)
                    handler.TryStart = pathParamLoadInstruction;
                if (handler.TryEnd == instruction)
                    handler.TryEnd = pathParamLoadInstruction;

                if (handler.HandlerStart == instruction)
                    handler.HandlerStart = pathParamLoadInstruction;
                if (handler.HandlerEnd == instruction)
                    handler.HandlerEnd = pathParamLoadInstruction;
            }

            //change instructions with a target instruction if they referenced the one we inserted before to be our first instruction
            foreach (var iteratedInstruction in method.Body.Instructions) {
                var operand = iteratedInstruction.Operand;
                if (operand == instruction) {
                    iteratedInstruction.Operand = pathParamLoadInstruction;
                    continue;
                }

                if (!(operand is Instruction []))
                    continue;

                var operands = (Instruction [])operand;
                for (var i = 0; i < operands.Length; ++i) {
                    if (operands [i] == instruction)
                        operands [i] = pathParamLoadInstruction;
                }
            }
        }