Exemplo n.º 1
0
 public override void Visit(Model.Bytecode.ConstrainedInstruction instruction)
 {
     Mono.Cecil.Cil.Instruction ins = processor.Create(Mono.Cecil.Cil.OpCodes.Constrained, referenceGenerator.TypeReference(instruction.ThisType));
     Result = new List <Mono.Cecil.Cil.Instruction>()
     {
         ins
     };
 }
Exemplo n.º 2
0
        public override void Visit(Model.Bytecode.StoreArrayElementInstruction instruction)
        {
            Mono.Cecil.Cil.Instruction res = null;

            if (!instruction.Array.IsVector)
            {
                Cecil.MethodReference arraySet = ArrayHelper.ArraySet(referenceGenerator.TypeReference(instruction.Array) as Cecil.ArrayType);
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Call, arraySet);
            }
            else if (instruction.Array.ElementsType == Model.Types.PlatformType.IntPtr)
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_I);
            }
            else if (instruction.Array.ElementsType == Model.Types.PlatformType.Int8)
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_I1);
            }
            else if (instruction.Array.ElementsType == Model.Types.PlatformType.Int16)
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_I2);
            }
            else if (instruction.Array.ElementsType == Model.Types.PlatformType.Int32)
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_I4);
            }
            else if (instruction.Array.ElementsType == Model.Types.PlatformType.Int64)
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_I8);
            }
            else if (instruction.Array.ElementsType == Model.Types.PlatformType.Float32)
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_R4);
            }
            else if (instruction.Array.ElementsType == Model.Types.PlatformType.Float64)
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_R8);
            }
            else if (instruction.Array.ElementsType == Model.Types.PlatformType.Float64)
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_R8);
            }
            else if (instruction.Array.ElementsType.TypeKind == Model.Types.TypeKind.ReferenceType)
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_Ref);
            }
            else
            {
                res = processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_Any, referenceGenerator.TypeReference(instruction.Array.ElementsType));
            }

            Result = new List <Mono.Cecil.Cil.Instruction>()
            {
                res
            };
        }
Exemplo n.º 3
0
        public override void Visit(Model.Bytecode.CreateArrayInstruction instruction)
        {
            Cecil.ArrayType cilArrayType = referenceGenerator.TypeReference(instruction.Type) as Cecil.ArrayType;

            Mono.Cecil.Cil.Instruction cilIns = null;
            if (!instruction.Type.IsVector)
            {
                Cecil.MethodReference arrayCtor = ArrayHelper.ArrayCtor(cilArrayType as Cecil.ArrayType);
                cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Newobj, arrayCtor);
            }
            else
            {
                cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Newarr, cilArrayType.ElementType);
            }

            Result = new List <Mono.Cecil.Cil.Instruction>()
            {
                cilIns
            };
        }
Exemplo n.º 4
0
        public override void Visit(Model.Bytecode.LoadArrayElementInstruction instruction)
        {
            Mono.Cecil.Cil.Instruction res = null;

            if (instruction.Operation == AnalysisNet.Bytecode.LoadArrayElementOperation.Address)
            {
                if (!instruction.Array.IsVector)
                {
                    Cecil.MethodReference arrayAddress = ArrayHelper.ArrayAddress(referenceGenerator.TypeReference(instruction.Array) as Cecil.ArrayType);
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Call, arrayAddress);
                }
                else
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelema, referenceGenerator.TypeReference(instruction.Array.ElementsType));
                }
            }
            else if (instruction.Operation == AnalysisNet.Bytecode.LoadArrayElementOperation.Content)
            {
                if (!instruction.Array.IsVector)
                {
                    Cecil.MethodReference arrayGet = ArrayHelper.ArrayGet(referenceGenerator.TypeReference(instruction.Array) as Cecil.ArrayType);

                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Call, arrayGet);
                }
                else if (instruction.Array.ElementsType.Equals(Model.Types.PlatformType.IntPtr))
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_I);
                }
                else if (instruction.Array.ElementsType.Equals(Model.Types.PlatformType.Int8))
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_I1);
                }
                else if (instruction.Array.ElementsType.Equals(Model.Types.PlatformType.Int16))
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_I2);
                }
                else if (instruction.Array.ElementsType.Equals(Model.Types.PlatformType.Int32))
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_I4);
                }
                else if (instruction.Array.ElementsType.Equals(Model.Types.PlatformType.Int64))
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_I8);
                }
                else if (instruction.Array.ElementsType.Equals(Model.Types.PlatformType.Float32))
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_R4);
                }
                else if (instruction.Array.ElementsType.Equals(Model.Types.PlatformType.Float64))
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_R8);
                }
                else if (instruction.Array.ElementsType.Equals(Model.Types.PlatformType.Float64))
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_R8);
                }
                else if (instruction.Array.ElementsType.TypeKind == Model.Types.TypeKind.ReferenceType)
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_Ref);
                }
                else
                {
                    res = processor.Create(Mono.Cecil.Cil.OpCodes.Ldelem_Any, referenceGenerator.TypeReference(instruction.Array.ElementsType));
                }
            }
            else
            {
                throw new NotImplementedException();
            }

            Result = new List <Mono.Cecil.Cil.Instruction>()
            {
                res
            };
        }