Mono.Cecil.Rocks.MethodBodyRocks.MakeMacro C# (CSharp) Method

        static void MakeMacro(Instruction instruction, OpCode opcode)
        {
            instruction.OpCode = opcode;
            instruction.Operand = null;
        }

        public static void OptimizeMacros(this MethodBody self)
        {
            int index;

            if (self == null)
            {
                throw new ArgumentNullException("self");
            }
            MethodDefinition method = self.Method;

            foreach (Instruction instruction in self.Instructions)
            {
                Code code = instruction.OpCode.Code;
                if (code == Code.Ldc_I4)
                {
                    int operand = (int)instruction.Operand;
                    switch (operand)
                    {
                    case -1:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_M1);
                        continue;
                    }

                    case 0:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_0);
                        continue;
                    }

                    case 1:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_1);
                        continue;
                    }

                    case 2:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_2);
                        continue;
                    }

                    case 3:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_3);
                        continue;
                    }

                    case 4:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_4);
                        continue;
                    }

                    case 5:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_5);
                        continue;
                    }

                    case 6:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_6);
                        continue;
                    }

                    case 7:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_7);
                        continue;
                    }

                    case 8:
                    {
                        MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldc_I4_8);
                        continue;
                    }
                    }
                    if (operand < -128 || operand >= 128)
                    {
                        continue;
                    }
                    MethodBodyRocks.ExpandMacro(instruction, OpCodes.Ldc_I4_S, (sbyte)operand);
                }
                else
                {
                    switch (code)
                    {
                    case Code.Ldarg:
                    {
                        index = ((ParameterDefinition)instruction.Operand).Index;
                        if (index == -1 && instruction.Operand == self.ThisParameter)
                        {
                            index = 0;
                        }
                        else if (method.HasThis)
                        {
                            index++;
                        }
                        switch (index)
                        {
                        case 0:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldarg_0);
                            continue;
                        }

                        case 1:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldarg_1);
                            continue;
                        }

                        case 2:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldarg_2);
                            continue;
                        }

                        case 3:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldarg_3);
                            continue;
                        }
                        }
                        if (index >= 256)
                        {
                            continue;
                        }
                        MethodBodyRocks.ExpandMacro(instruction, OpCodes.Ldarg_S, instruction.Operand);
                        continue;
                    }

                    case Code.Ldarga:
                    {
                        index = ((ParameterDefinition)instruction.Operand).Index;
                        if (index == -1 && instruction.Operand == self.ThisParameter)
                        {
                            index = 0;
                        }
                        else if (method.HasThis)
                        {
                            index++;
                        }
                        if (index >= 256)
                        {
                            continue;
                        }
                        MethodBodyRocks.ExpandMacro(instruction, OpCodes.Ldarga_S, instruction.Operand);
                        continue;
                    }

                    case Code.Ldloc:
                    {
                        index = ((VariableDefinition)instruction.Operand).Index;
                        switch (index)
                        {
                        case 0:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldloc_0);
                            continue;
                        }

                        case 1:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldloc_1);
                            continue;
                        }

                        case 2:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldloc_2);
                            continue;
                        }

                        case 3:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Ldloc_3);
                            continue;
                        }
                        }
                        if (index >= 256)
                        {
                            continue;
                        }
                        MethodBodyRocks.ExpandMacro(instruction, OpCodes.Ldloc_S, instruction.Operand);
                        continue;
                    }

                    case Code.Ldloca:
                    {
                        if (((VariableDefinition)instruction.Operand).Index >= 256)
                        {
                            continue;
                        }
                        MethodBodyRocks.ExpandMacro(instruction, OpCodes.Ldloca_S, instruction.Operand);
                        continue;
                    }

                    case Code.Stloc:
                    {
                        index = ((VariableDefinition)instruction.Operand).Index;
                        switch (index)
                        {
                        case 0:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Stloc_0);
                            continue;
                        }

                        case 1:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Stloc_1);
                            continue;
                        }

                        case 2:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Stloc_2);
                            continue;
                        }

                        case 3:
                        {
                            MethodBodyRocks.MakeMacro(instruction, OpCodes.Stloc_3);
                            continue;
                        }
                        }
                        if (index >= 256)
                        {
                            continue;
                        }
                        MethodBodyRocks.ExpandMacro(instruction, OpCodes.Stloc_S, instruction.Operand);
                        continue;
                    }

                    default:
                    {
                        continue;
                    }
                    }
                }
            }
            MethodBodyRocks.OptimizeBranches(self);
        }