Exemplo n.º 1
0
        internal MethodInfo CreateReplacement(out Dictionary <int, CodeInstruction> finalInstructions)
        {
            var originalVariables = DeclareLocalVariables(il, source ?? original);
            var privateVars       = new Dictionary <string, LocalBuilder>();

            LocalBuilder resultVariable = null;

            if (idx > 0)
            {
                resultVariable          = DeclareLocalVariable(returnType, true);
                privateVars[RESULT_VAR] = resultVariable;
            }

            Label?       skipOriginalLabel   = null;
            LocalBuilder runOriginalVariable = null;

            if (prefixes.Any(fix => PrefixAffectsOriginal(fix)))
            {
                runOriginalVariable = DeclareLocalVariable(typeof(bool));
                emitter.Emit(OpCodes.Ldc_I4_1);
                emitter.Emit(OpCodes.Stloc, runOriginalVariable);

                skipOriginalLabel = il.DefineLabel();
            }

            prefixes.Union(postfixes).Union(finalizers).ToList().ForEach(fix =>
            {
                if (fix.DeclaringType is object && privateVars.ContainsKey(fix.DeclaringType.FullName) is false)
                {
                    fix.GetParameters()
                    .Where(patchParam => patchParam.Name == STATE_VAR)
                    .Do(patchParam =>
                    {
                        var privateStateVariable = DeclareLocalVariable(patchParam.ParameterType);
                        privateVars[fix.DeclaringType.FullName] = privateStateVariable;
                    });
                }
            });

            LocalBuilder finalizedVariable = null;

            if (finalizers.Any())
            {
                finalizedVariable = DeclareLocalVariable(typeof(bool));

                privateVars[EXCEPTION_VAR] = DeclareLocalVariable(typeof(Exception));

                // begin try
                emitter.MarkBlockBefore(new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock), out _);
            }

            AddPrefixes(privateVars, runOriginalVariable);
            if (skipOriginalLabel.HasValue)
            {
                emitter.Emit(OpCodes.Ldloc, runOriginalVariable);
                emitter.Emit(OpCodes.Brfalse, skipOriginalLabel.Value);
            }

            var copier = new MethodCopier(source ?? original, il, originalVariables);

            copier.SetArgumentShift(useStructReturnBuffer);
            copier.SetDebugging(debug);

            foreach (var transpiler in transpilers)
            {
                copier.AddTranspiler(transpiler);
            }

            var endLabels = new List <Label>();

            _ = copier.Finalize(emitter, endLabels, out var hasReturnCode);

            foreach (var label in endLabels)
            {
                emitter.MarkLabel(label);
            }
            if (resultVariable is object)
            {
                emitter.Emit(OpCodes.Stloc, resultVariable);
            }
            if (skipOriginalLabel.HasValue)
            {
                emitter.MarkLabel(skipOriginalLabel.Value);
            }

            _ = AddPostfixes(privateVars, false);

            if (resultVariable is object)
            {
                emitter.Emit(OpCodes.Ldloc, resultVariable);
            }

            var needsToStorePassthroughResult = AddPostfixes(privateVars, true);

            var hasFinalizers = finalizers.Any();

            if (hasFinalizers)
            {
                if (needsToStorePassthroughResult)
                {
                    emitter.Emit(OpCodes.Stloc, resultVariable);
                    emitter.Emit(OpCodes.Ldloc, resultVariable);
                }

                _ = AddFinalizers(privateVars, false);
                emitter.Emit(OpCodes.Ldc_I4_1);
                emitter.Emit(OpCodes.Stloc, finalizedVariable);
                var noExceptionLabel1 = il.DefineLabel();
                emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                emitter.Emit(OpCodes.Brfalse, noExceptionLabel1);
                emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                emitter.Emit(OpCodes.Throw);
                emitter.MarkLabel(noExceptionLabel1);

                // end try, begin catch
                emitter.MarkBlockBefore(new ExceptionBlock(ExceptionBlockType.BeginCatchBlock), out var label);
                emitter.Emit(OpCodes.Stloc, privateVars[EXCEPTION_VAR]);

                emitter.Emit(OpCodes.Ldloc, finalizedVariable);
                var endFinalizerLabel = il.DefineLabel();
                emitter.Emit(OpCodes.Brtrue, endFinalizerLabel);

                var rethrowPossible = AddFinalizers(privateVars, true);

                emitter.MarkLabel(endFinalizerLabel);

                var noExceptionLabel2 = il.DefineLabel();
                emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                emitter.Emit(OpCodes.Brfalse, noExceptionLabel2);
                if (rethrowPossible)
                {
                    emitter.Emit(OpCodes.Rethrow);
                }
                else
                {
                    emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                    emitter.Emit(OpCodes.Throw);
                }
                emitter.MarkLabel(noExceptionLabel2);

                // end catch
                emitter.MarkBlockAfter(new ExceptionBlock(ExceptionBlockType.EndExceptionBlock));

                if (resultVariable is object)
                {
                    emitter.Emit(OpCodes.Ldloc, resultVariable);
                }
            }

            if (useStructReturnBuffer)
            {
                var tmpVar = DeclareLocalVariable(returnType);
                emitter.Emit(OpCodes.Stloc, tmpVar);
                emitter.Emit(original.IsStatic ? OpCodes.Ldarg_0 : OpCodes.Ldarg_1);
                emitter.Emit(OpCodes.Ldloc, tmpVar);
                emitter.Emit(OpCodes.Stobj, returnType);                 // store result into ref
            }

            if (hasFinalizers || hasReturnCode)
            {
                emitter.Emit(OpCodes.Ret);
            }

            finalInstructions = emitter.GetInstructions();

            if (debug)
            {
                FileLog.LogBuffered("DONE");
                FileLog.LogBuffered("");
                FileLog.FlushBuffer();
            }

            return(patch.Generate().Pin());
        }
Exemplo n.º 2
0
        public static DynamicMethod CreatePatchedMethod(MethodBase original, MethodBase source, string harmonyInstanceID, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers, List <MethodInfo> finalizers)
        {
            try
            {
                if (original == null)
                {
                    throw new ArgumentNullException(nameof(original));
                }

                Memory.MarkForNoInlining(original);

                if (Harmony.DEBUG)
                {
                    FileLog.LogBuffered("### Patch " + original.FullDescription());
                    FileLog.FlushBuffer();
                }

                var idx = prefixes.Count() + postfixes.Count() + finalizers.Count();
                var firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
                var returnType             = AccessTools.GetReturnedType(original);
                var hasFinalizers          = finalizers.Any();
                var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
                if (patch == null)
                {
                    return(null);
                }

                var il = patch.GetILGenerator();

                var originalVariables = DynamicTools.DeclareLocalVariables(source ?? original, il);
                var privateVars       = new Dictionary <string, LocalBuilder>();

                LocalBuilder resultVariable = null;
                if (idx > 0)
                {
                    resultVariable          = DynamicTools.DeclareLocalVariable(il, returnType);
                    privateVars[RESULT_VAR] = resultVariable;
                }

                prefixes.Union(postfixes).Union(finalizers).ToList().ForEach(fix =>
                {
                    if (privateVars.ContainsKey(fix.DeclaringType?.FullName ?? "") == false)
                    {
                        fix.GetParameters()
                        .Where(patchParam => patchParam.Name == STATE_VAR)
                        .Do(patchParam =>
                        {
                            var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
                            privateVars[fix.DeclaringType?.FullName ?? ""] = privateStateVariable;
                        });
                    }
                });

                LocalBuilder finalizedVariable = null;
                if (hasFinalizers)
                {
                    finalizedVariable = DynamicTools.DeclareLocalVariable(il, typeof(bool));

                    privateVars[EXCEPTION_VAR] = DynamicTools.DeclareLocalVariable(il, typeof(Exception));

                    // begin try
                    Emitter.MarkBlockBefore(il, new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock), out _);
                }

                if (firstArgIsReturnBuffer)
                {
                    Emitter.Emit(il, OpCodes.Ldarg_1);                     // load ref to return value
                }
                var skipOriginalLabel = il.DefineLabel();
                var canHaveJump       = AddPrefixes(il, original, prefixes, privateVars, skipOriginalLabel);

                var copier = new MethodCopier(source ?? original, il, originalVariables);
                foreach (var transpiler in transpilers)
                {
                    copier.AddTranspiler(transpiler);
                }
                if (firstArgIsReturnBuffer)
                {
                    copier.AddTranspiler(NativeThisPointer.m_ArgumentShiftTranspiler);
                }

                var endLabels = new List <Label>();
                copier.Finalize(endLabels);

                foreach (var label in endLabels)
                {
                    Emitter.MarkLabel(il, label);
                }
                if (resultVariable != null)
                {
                    Emitter.Emit(il, OpCodes.Stloc, resultVariable);
                }
                if (canHaveJump)
                {
                    Emitter.MarkLabel(il, skipOriginalLabel);
                }

                AddPostfixes(il, original, postfixes, privateVars, false);

                if (resultVariable != null)
                {
                    Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
                }

                AddPostfixes(il, original, postfixes, privateVars, true);

                if (hasFinalizers)
                {
                    AddFinalizers(il, original, finalizers, privateVars, false);
                    Emitter.Emit(il, OpCodes.Ldc_I4_1);
                    Emitter.Emit(il, OpCodes.Stloc, finalizedVariable);
                    var noExceptionLabel1 = il.DefineLabel();
                    Emitter.Emit(il, OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                    Emitter.Emit(il, OpCodes.Brfalse, noExceptionLabel1);
                    Emitter.Emit(il, OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                    Emitter.Emit(il, OpCodes.Throw);
                    Emitter.MarkLabel(il, noExceptionLabel1);

                    // end try, begin catch
                    Emitter.MarkBlockBefore(il, new ExceptionBlock(ExceptionBlockType.BeginCatchBlock), out var label);
                    Emitter.Emit(il, OpCodes.Stloc, privateVars[EXCEPTION_VAR]);

                    Emitter.Emit(il, OpCodes.Ldloc, finalizedVariable);
                    var endFinalizerLabel = il.DefineLabel();
                    Emitter.Emit(il, OpCodes.Brtrue, endFinalizerLabel);

                    var rethrowPossible = AddFinalizers(il, original, finalizers, privateVars, true);

                    Emitter.MarkLabel(il, endFinalizerLabel);

                    var noExceptionLabel2 = il.DefineLabel();
                    Emitter.Emit(il, OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                    Emitter.Emit(il, OpCodes.Brfalse, noExceptionLabel2);
                    if (rethrowPossible)
                    {
                        Emitter.Emit(il, OpCodes.Rethrow);
                    }
                    else
                    {
                        Emitter.Emit(il, OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                        Emitter.Emit(il, OpCodes.Throw);
                    }
                    Emitter.MarkLabel(il, noExceptionLabel2);

                    // end catch
                    Emitter.MarkBlockAfter(il, new ExceptionBlock(ExceptionBlockType.EndExceptionBlock));

                    if (resultVariable != null)
                    {
                        Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
                    }
                }

                if (firstArgIsReturnBuffer)
                {
                    Emitter.Emit(il, OpCodes.Stobj, returnType);                     // store result into ref
                }
                Emitter.Emit(il, OpCodes.Ret);

                if (Harmony.DEBUG)
                {
                    FileLog.LogBuffered("DONE");
                    FileLog.LogBuffered("");
                    FileLog.FlushBuffer();
                }

                DynamicTools.PrepareDynamicMethod(patch);
                return(patch);
            }
            catch (Exception ex)
            {
                var exceptionString = "Exception from HarmonyInstance \"" + harmonyInstanceID + "\" patching " + original.FullDescription() + ": " + ex;
                if (Harmony.DEBUG)
                {
                    var savedIndentLevel = FileLog.indentLevel;
                    FileLog.indentLevel = 0;
                    FileLog.Log(exceptionString);
                    FileLog.indentLevel = savedIndentLevel;
                }

                throw new Exception(exceptionString, ex);
            }
            finally
            {
                if (Harmony.DEBUG)
                {
                    FileLog.FlushBuffer();
                }
            }
        }
Exemplo n.º 3
0
        internal List <CodeInstruction> FinalizeILCodes(Emitter emitter, List <MethodInfo> transpilers, List <Label> endLabels, out bool hasReturnCode)
        {
            hasReturnCode = false;
            if (generator == null)
            {
                return(null);
            }

            // pass1 - define labels and add them to instructions that are target of a jump
            //
            foreach (var ilInstruction in ilInstructions)
            {
                switch (ilInstruction.opcode.OperandType)
                {
                case OperandType.InlineSwitch:
                {
                    var targets = ilInstruction.operand as ILInstruction[];
                    if (targets != null)
                    {
                        var labels = new List <Label>();
                        foreach (var target in targets)
                        {
                            var label = generator.DefineLabel();
                            target.labels.Add(label);
                            labels.Add(label);
                        }
                        ilInstruction.argument = labels.ToArray();
                    }
                    break;
                }

                case OperandType.ShortInlineBrTarget:
                case OperandType.InlineBrTarget:
                {
                    var target = ilInstruction.operand as ILInstruction;
                    if (target != null)
                    {
                        var label = generator.DefineLabel();
                        target.labels.Add(label);
                        ilInstruction.argument = label;
                    }
                    break;
                }
                }
            }

            // pass2 - filter through all processors
            //
            var codeTranspiler = new CodeTranspiler(ilInstructions, argumentShift);

            transpilers.Do(transpiler => codeTranspiler.Add(transpiler));
            var codeInstructions = codeTranspiler.GetResult(generator, method);

            if (emitter == null)
            {
                return(codeInstructions);
            }

            emitter.LogComment("start original");

            // pass3 - log out all new local variables
            //
            var savedLog = FileLog.GetBuffer(true);

            emitter.LogAllLocalVariables();
            FileLog.LogBuffered(savedLog);

            // pass4 - check for any RET
            //
            hasReturnCode = codeInstructions.Any(code => code.opcode == OpCodes.Ret);

            // pass5 - remove RET if it appears at the end
            //
            while (true)
            {
                var lastInstruction = codeInstructions.LastOrDefault();
                if (lastInstruction == null || lastInstruction.opcode != OpCodes.Ret)
                {
                    break;
                }

                // remember any existing labels
                endLabels.AddRange(lastInstruction.labels);

                codeInstructions.RemoveAt(codeInstructions.Count - 1);
            }

            // pass6 - mark labels and exceptions and emit codes
            //
            codeInstructions.Do(codeInstruction =>
            {
                // mark all labels
                codeInstruction.labels.Do(label => emitter.MarkLabel(label));

                // start all exception blocks
                // TODO: we ignore the resulting label because we have no way to use it
                //
                codeInstruction.blocks.Do(block =>
                {
                    emitter.MarkBlockBefore(block, out var label);
                });

                var code    = codeInstruction.opcode;
                var operand = codeInstruction.operand;

                // replace RET with a jump to the end (outside this code)
                if (code == OpCodes.Ret)
                {
                    var endLabel = generator.DefineLabel();
                    code         = OpCodes.Br;
                    operand      = endLabel;
                    endLabels.Add(endLabel);
                }

                // replace short jumps with long ones (can be optimized but requires byte counting, not instruction counting)
                if (shortJumps.TryGetValue(code, out var longJump))
                {
                    code = longJump;
                }

                switch (code.OperandType)
                {
                case OperandType.InlineNone:
                    emitter.Emit(code);
                    break;

                case OperandType.InlineSig:
                    var cecilGenerator = generator.GetProxiedShim <CecilILGenerator>();
                    if (cecilGenerator == null)
                    {
                        // Right now InlineSignatures can only be emitted using MonoMod.Common and its CecilILGenerator.
                        // That is because DynamicMethod's original ILGenerator is very restrictive about the calli opcode.
                        throw new NotSupportedException();
                    }
                    if (operand == null)
                    {
                        throw new Exception($"Wrong null argument: {codeInstruction}");
                    }
                    if ((operand is ICallSiteGenerator) == false)
                    {
                        throw new Exception($"Wrong Emit argument type {operand.GetType()} in {codeInstruction}");
                    }
                    emitter.AddInstruction(code, operand);
                    emitter.LogIL(code, operand);
                    cecilGenerator.Emit(code, (ICallSiteGenerator)operand);
                    break;

                default:
                    if (operand == null)
                    {
                        throw new Exception($"Wrong null argument: {codeInstruction}");
                    }
                    emitter.AddInstruction(code, operand);
                    emitter.LogIL(code, operand);
                    _ = generator.DynEmit(code, operand);
                    break;
                }

                codeInstruction.blocks.Do(block => emitter.MarkBlockAfter(block));
            });

            emitter.LogComment("end original");
            return(codeInstructions);
        }
Exemplo n.º 4
0
        internal MethodInfo CreateReplacement(out Dictionary <int, CodeInstruction> finalInstructions)
        {
            var originalVariables = DeclareLocalVariables(source ?? original);
            var privateVars       = new Dictionary <string, LocalBuilder>();

            LocalBuilder resultVariable = null;

            if (idx > 0)
            {
                resultVariable          = DeclareLocalVariable(returnType);
                privateVars[RESULT_VAR] = resultVariable;
            }

            prefixes.Union(postfixes).Union(finalizers).ToList().ForEach(fix =>
            {
                if (fix.DeclaringType != null && privateVars.ContainsKey(fix.DeclaringType.FullName) == false)
                {
                    fix.GetParameters()
                    .Where(patchParam => patchParam.Name == STATE_VAR)
                    .Do(patchParam =>
                    {
                        var privateStateVariable = DeclareLocalVariable(patchParam.ParameterType);
                        privateVars[fix.DeclaringType.FullName] = privateStateVariable;
                    });
                }
            });

            LocalBuilder finalizedVariable = null;

            if (finalizers.Any())
            {
                finalizedVariable = DeclareLocalVariable(typeof(bool));

                privateVars[EXCEPTION_VAR] = DeclareLocalVariable(typeof(Exception));

                // begin try
                emitter.MarkBlockBefore(new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock), out _);
            }

            if (firstArgIsReturnBuffer)
            {
                emitter.Emit(original.IsStatic ? OpCodes.Ldarg_0 : OpCodes.Ldarg_1);                 // load ref to return value
            }
            var skipOriginalLabel = il.DefineLabel();
            var canHaveJump       = AddPrefixes(privateVars, skipOriginalLabel);

            var copier = new MethodCopier(source ?? original, il, originalVariables);

            foreach (var transpiler in transpilers)
            {
                copier.AddTranspiler(transpiler);
            }
            if (firstArgIsReturnBuffer)
            {
                if (original.IsStatic)
                {
                    copier.AddTranspiler(NativeThisPointer.m_ArgumentShiftTranspilerStatic);
                }
                else
                {
                    copier.AddTranspiler(NativeThisPointer.m_ArgumentShiftTranspilerInstance);
                }
            }

            var endLabels = new List <Label>();

            copier.Finalize(emitter, endLabels, out var endingReturn);

            foreach (var label in endLabels)
            {
                emitter.MarkLabel(label);
            }
            if (resultVariable != null)
            {
                emitter.Emit(OpCodes.Stloc, resultVariable);
            }
            if (canHaveJump)
            {
                emitter.MarkLabel(skipOriginalLabel);
            }

            AddPostfixes(privateVars, false);

            if (resultVariable != null)
            {
                emitter.Emit(OpCodes.Ldloc, resultVariable);
            }

            AddPostfixes(privateVars, true);

            var hasFinalizers = finalizers.Any();

            if (hasFinalizers)
            {
                _ = AddFinalizers(privateVars, false);
                emitter.Emit(OpCodes.Ldc_I4_1);
                emitter.Emit(OpCodes.Stloc, finalizedVariable);
                var noExceptionLabel1 = il.DefineLabel();
                emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                emitter.Emit(OpCodes.Brfalse, noExceptionLabel1);
                emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                emitter.Emit(OpCodes.Throw);
                emitter.MarkLabel(noExceptionLabel1);

                // end try, begin catch
                emitter.MarkBlockBefore(new ExceptionBlock(ExceptionBlockType.BeginCatchBlock), out var label);
                emitter.Emit(OpCodes.Stloc, privateVars[EXCEPTION_VAR]);

                emitter.Emit(OpCodes.Ldloc, finalizedVariable);
                var endFinalizerLabel = il.DefineLabel();
                emitter.Emit(OpCodes.Brtrue, endFinalizerLabel);

                var rethrowPossible = AddFinalizers(privateVars, true);

                emitter.MarkLabel(endFinalizerLabel);

                var noExceptionLabel2 = il.DefineLabel();
                emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                emitter.Emit(OpCodes.Brfalse, noExceptionLabel2);
                if (rethrowPossible)
                {
                    emitter.Emit(OpCodes.Rethrow);
                }
                else
                {
                    emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
                    emitter.Emit(OpCodes.Throw);
                }
                emitter.MarkLabel(noExceptionLabel2);

                // end catch
                emitter.MarkBlockAfter(new ExceptionBlock(ExceptionBlockType.EndExceptionBlock));

                if (resultVariable != null)
                {
                    emitter.Emit(OpCodes.Ldloc, resultVariable);
                }
            }

            if (firstArgIsReturnBuffer)
            {
                emitter.Emit(OpCodes.Stobj, returnType);                 // store result into ref
            }
            if (hasFinalizers || endingReturn)
            {
                emitter.Emit(OpCodes.Ret);
            }

            finalInstructions = emitter.GetInstructions();

            if (debug)
            {
                FileLog.LogBuffered("DONE");
                FileLog.LogBuffered("");
                FileLog.FlushBuffer();
            }

            return(patch.Generate().Pin());
        }
Exemplo n.º 5
0
        internal void FinalizeILCodes(List <MethodInfo> transpilers, List <Label> endLabels)
        {
            if (generator == null)
            {
                return;
            }

            // pass1 - define labels and add them to instructions that are target of a jump
            //
            foreach (var ilInstruction in ilInstructions)
            {
                switch (ilInstruction.opcode.OperandType)
                {
                case OperandType.InlineSwitch:
                {
                    var targets = ilInstruction.operand as ILInstruction[];
                    if (targets != null)
                    {
                        var labels = new List <Label>();
                        foreach (var target in targets)
                        {
                            var label = generator.DefineLabel();
                            target.labels.Add(label);
                            labels.Add(label);
                        }
                        ilInstruction.argument = labels.ToArray();
                    }
                    break;
                }

                case OperandType.ShortInlineBrTarget:
                case OperandType.InlineBrTarget:
                {
                    var target = ilInstruction.operand as ILInstruction;
                    if (target != null)
                    {
                        var label = generator.DefineLabel();
                        target.labels.Add(label);
                        ilInstruction.argument = label;
                    }
                    break;
                }
                }
            }

            // pass2 - filter through all processors
            //
            var codeTranspiler = new CodeTranspiler(ilInstructions);

            transpilers.Do(transpiler => codeTranspiler.Add(transpiler));
            var codeInstructions = codeTranspiler.GetResult(generator, method);

            if (Harmony.DEBUG)
            {
                Emitter.LogComment(generator, "start original");
            }

            // pass3 - log out all new local variables
            //
            var savedLog = FileLog.GetBuffer(true);

            Emitter.AllLocalVariables(generator).Do(local => Emitter.LogLocalVariable(local));
            FileLog.LogBuffered(savedLog);

            // pass4 - remove RET if it appears at the end
            //
            while (true)
            {
                var lastInstruction = codeInstructions.LastOrDefault();
                if (lastInstruction == null || lastInstruction.opcode != OpCodes.Ret)
                {
                    break;
                }

                // remember any existing labels
                endLabels.AddRange(lastInstruction.labels);

                codeInstructions.RemoveAt(codeInstructions.Count - 1);
            }

            // pass5 - mark labels and exceptions and emit codes
            //
            var idx = 0;

            codeInstructions.Do(codeInstruction =>
            {
                // mark all labels
                codeInstruction.labels.Do(label => Emitter.MarkLabel(generator, label));

                // start all exception blocks
                // TODO: we ignore the resulting label because we have no way to use it
                //
                codeInstruction.blocks.Do(block =>
                {
                    Emitter.MarkBlockBefore(generator, block, out var label);
                });

                var code    = codeInstruction.opcode;
                var operand = codeInstruction.operand;

                // replace RET with a jump to the end (outside this code)
                if (code == OpCodes.Ret)
                {
                    var endLabel = generator.DefineLabel();
                    code         = OpCodes.Br;
                    operand      = endLabel;
                    endLabels.Add(endLabel);
                }

                // replace short jumps with long ones (can be optimized but requires byte counting, not instruction counting)
                if (shortJumps.TryGetValue(code, out var longJump))
                {
                    code = longJump;
                }

                var emitCode = true;

                //if (code == OpCodes.Leave || code == OpCodes.Leave_S)
                //{
                //	// skip LEAVE on EndExceptionBlock
                //	if (codeInstruction.blocks.Any(block => block.blockType == ExceptionBlockType.EndExceptionBlock))
                //		emitCode = false;

                //	// skip LEAVE on next instruction starts a new exception handler and we are already in
                //	if (idx < instructions.Length - 1)
                //		if (instructions[idx + 1].blocks.Any(block => block.blockType != ExceptionBlockType.EndExceptionBlock))
                //			emitCode = false;
                //}

                if (emitCode)
                {
                    switch (code.OperandType)
                    {
                    case OperandType.InlineNone:
                        Emitter.Emit(generator, code);
                        break;

                    case OperandType.InlineSig:

                        // TODO the following will fail because we do not convert the token (operand)
                        // All the decompilers can show the arguments correctly, we just need to find out how
                        //
                        if (operand == null)
                        {
                            throw new Exception("Wrong null argument: " + codeInstruction);
                        }
                        if ((operand is int) == false)
                        {
                            throw new Exception("Wrong Emit argument type " + operand.GetType() + " in " + codeInstruction);
                        }
                        Emitter.Emit(generator, code, (int)operand);

                        /*
                         * // the following will only work if we can convert the original signature token to the required arguments
                         * //
                         * var callingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall;
                         * var returnType = typeof(object);
                         * var parameterTypes = new[] { typeof(object) };
                         * Emitter.EmitCalli(generator, code, callingConvention, returnType, parameterTypes);
                         *
                         * var callingConventions = System.Reflection.CallingConventions.Standard;
                         * var optionalParameterTypes = new[] { typeof(object) };
                         * Emitter.EmitCalli(generator, code, callingConventions, returnType, parameterTypes, optionalParameterTypes);
                         */
                        break;

                    default:
                        if (operand == null)
                        {
                            throw new Exception("Wrong null argument: " + codeInstruction);
                        }
                        var emitMethod = EmitMethodForType(operand.GetType());
                        if (emitMethod == null)
                        {
                            throw new Exception("Unknown Emit argument type " + operand.GetType() + " in " + codeInstruction);
                        }
                        if (Harmony.DEBUG)
                        {
                            FileLog.LogBuffered(Emitter.CodePos(generator) + code + " " + Emitter.FormatArgument(operand));
                        }
                        emitMethod.Invoke(generator, new object[] { code, operand });
                        break;
                    }
                }

                codeInstruction.blocks.Do(block => Emitter.MarkBlockAfter(generator, block));

                idx++;
            });

            if (Harmony.DEBUG)
            {
                Emitter.LogComment(generator, "end original");
            }
        }