public void PropertyDefinitions(AnalysisNet.Types.TypeDefinition analysisNetType, Cecil.TypeDefinition cecilTypeDef) { foreach (AnalysisNet.Types.PropertyDefinition analysisNetProp in analysisNetType.PropertyDefinitions) { Cecil.PropertyDefinition cecilProp = new Cecil.PropertyDefinition(analysisNetProp.Name, Cecil.PropertyAttributes.None, ReferenceGenerator.TypeReference(analysisNetProp.PropertyType)); if (analysisNetProp.Getter != null) { Cecil.MethodDefinition getterDef = ReferenceGenerator.MethodReference(analysisNetProp.Getter).Resolve(); cecilProp.GetMethod = getterDef; } if (analysisNetProp.Setter != null) { Cecil.MethodDefinition setterDef = ReferenceGenerator.MethodReference(analysisNetProp.Setter).Resolve(); cecilProp.SetMethod = setterDef; } SetCustomAttributes(analysisNetProp.Attributes, cecilProp.CustomAttributes); // Properties.Add sets this field //cecilProp.DeclaringType = ReferenceGenerator.TypeReference(analysisNetType).Resolve(); cecilTypeDef.Properties.Add(cecilProp); } }
private Cecil.FieldDefinition CreateFieldDefinition(AnalysisNet.Types.FieldDefinition fieldDefinition) { Cecil.FieldAttributes fieldAttribute = Cecil.FieldAttributes.Public; if (fieldDefinition.IsStatic) { fieldAttribute |= Cecil.FieldAttributes.Static; } Cecil.TypeReference fieldType = ReferenceGenerator.TypeReference(fieldDefinition.Type); Cecil.FieldDefinition cecilField = new Cecil.FieldDefinition(fieldDefinition.Name, fieldAttribute, fieldType); if (fieldDefinition.Value != null) { cecilField.Constant = fieldDefinition.Value.Value; cecilField.HasConstant = true; } byte[] newArray = new byte[fieldDefinition.InitialValue.Length]; Array.Copy(fieldDefinition.InitialValue, newArray, newArray.Length); cecilField.InitialValue = newArray; if (newArray.Length > 0) { cecilField.Attributes |= Cecil.FieldAttributes.HasFieldRVA; } return(cecilField); }
private void SetOverrides(AnalysisNet.Types.MethodDefinition methodDefinition, Cecil.MethodDefinition methodDef) { ISet <AnalysisNet.Types.MethodImplementation> impls = methodDefinition.ContainingType.ExplicitOverrides; IEnumerable <AnalysisNet.Types.MethodImplementation> matchedImpls = impls.Where(impl => methodDefinition.MatchReference(impl.ImplementingMethod)); methodDef.Overrides.AddRange(matchedImpls.Select(impl => ReferenceGenerator.MethodReference(impl.ImplementedMethod))); }
public Cecil.MethodDefinition MethodDefinition(AnalysisNet.Types.MethodDefinition methodDefinition) { Cecil.MethodDefinition cecilMethodDefinition = new Cecil.MethodDefinition(methodDefinition.Name, 0, Context.CurrentModule.TypeSystem.Void); GenerateMethodAttributes(methodDefinition, cecilMethodDefinition); cecilMethodDefinition.CreateGenericParameters(methodDefinition.GenericParameters.Count); Cecil.TypeReference returnType = ReferenceGenerator.TypeReference(methodDefinition.ReturnType); cecilMethodDefinition.ReturnType = returnType; AddConstraintsToGenericParameters(methodDefinition, cecilMethodDefinition); Cecil.TypeReference typeRef = ReferenceGenerator.TypeReference(methodDefinition.ContainingType); Cecil.TypeDefinition containingType = typeRef.Resolve(); cecilMethodDefinition.DeclaringType = containingType as Cecil.TypeDefinition; SetOverrides(methodDefinition, cecilMethodDefinition); SetCustomAttributes(methodDefinition.Attributes, cecilMethodDefinition.CustomAttributes); IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.ParameterDefinition> parameterDefinitions = CreateParameters(methodDefinition, cecilMethodDefinition); if (methodDefinition.HasBody) { cecilMethodDefinition.Body.MaxStackSize = methodDefinition.Body.MaxStack; cecilMethodDefinition.Body.InitLocals = methodDefinition.Body.LocalVariables.Count > 0; IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.Cil.VariableDefinition> variableDefinitions = CreateLocalVariables(methodDefinition, cecilMethodDefinition); InstructionGenerator instructionGenerator = new InstructionGenerator(ReferenceGenerator); // analysis-net instruction -> [cecil instruction] IDictionary <AnalysisNet.Bytecode.Instruction, IList <Cecil.Cil.Instruction> > mapInstructions = instructionGenerator.CreateInstructions(methodDefinition, cecilMethodDefinition, variableDefinitions, parameterDefinitions); CreateExceptionHandlers(mapInstructions, methodDefinition.Body, cecilMethodDefinition.Body); } return(cecilMethodDefinition); }
private void AddInterfaceImplementations(AnalysisNet.Types.TypeDefinition typeDefinition, Cecil.TypeDefinition t) { foreach (AnalysisNet.Types.IBasicType inter in typeDefinition.Interfaces) { t.Interfaces.Add(new Cecil.InterfaceImplementation(ReferenceGenerator.TypeReference(inter))); } }
public BytecodeTranslator(AnalysisNet.Types.MethodDefinition methodDefinition, IDictionary <AnalysisNetTac.Values.IVariable, Cecil.Cil.VariableDefinition> variableDefinitions, IDictionary <AnalysisNetTac.Values.IVariable, Cecil.ParameterDefinition> parameterDefinitions, ReferenceGenerator referenceGenerator, Cecil.Cil.ILProcessor processor) { this.methodDefinition = methodDefinition; this.processor = processor; this.variableDefinitions = variableDefinitions; this.parameterDefinitions = parameterDefinitions; this.referenceGenerator = referenceGenerator; }
private Cecil.TypeDefinition CreateEnumDefinition(AnalysisNet.Types.TypeDefinition typeDefinition) { Cecil.TypeDefinition def = CreateClassDefinition(typeDefinition); def.IsSealed = true; foreach (Cecil.FieldDefinition field in def.Fields) { field.IsStatic = true; field.IsLiteral = true; field.HasDefault = true; field.FieldType.IsValueType = true; } Cecil.TypeReference underlyingType = ReferenceGenerator.TypeReference(typeDefinition.UnderlayingType); Cecil.FieldDefinition value__ = new Cecil.FieldDefinition("value__", Cecil.FieldAttributes.RTSpecialName | Cecil.FieldAttributes.SpecialName, underlyingType); def.Fields.Insert(0, value__); return(def); }
private void CreateExceptionHandlers(IDictionary <Model.Bytecode.Instruction, IList <Mono.Cecil.Cil.Instruction> > map, AnalysisNet.Types.MethodBody analysisNetBody, Cecil.Cil.MethodBody cecilBody) { foreach (AnalysisNet.ProtectedBlock protectedBlock in analysisNetBody.ExceptionInformation) { Cecil.Cil.ExceptionHandler handler = new Cecil.Cil.ExceptionHandler(GetExceptionHandlerType(protectedBlock.Handler.Kind)) { TryStart = GetTarget(protectedBlock.Start, map), TryEnd = GetTarget(protectedBlock.End, map) }; if (protectedBlock.Handler is AnalysisNet.FilterExceptionHandler filterHandler) { handler.CatchType = ReferenceGenerator.TypeReference(filterHandler.ExceptionType); handler.FilterStart = GetTarget(filterHandler.FilterStart, map); handler.HandlerStart = GetTarget(filterHandler.Start, map); handler.HandlerEnd = GetTarget(filterHandler.End, map); } else if (protectedBlock.Handler is AnalysisNet.CatchExceptionHandler catchHandler) { handler.CatchType = ReferenceGenerator.TypeReference(catchHandler.ExceptionType); handler.HandlerStart = GetTarget(catchHandler.Start, map); handler.HandlerEnd = GetTarget(catchHandler.End, map); } else if (protectedBlock.Handler is AnalysisNet.FaultExceptionHandler faultHandler) { handler.HandlerStart = GetTarget(faultHandler.Start, map); handler.HandlerEnd = GetTarget(faultHandler.End, map); } else if (protectedBlock.Handler is AnalysisNet.FinallyExceptionHandler finallyHandler) { handler.HandlerStart = GetTarget(finallyHandler.Start, map); handler.HandlerEnd = GetTarget(finallyHandler.End, map); } else { throw new NotImplementedException(); } cecilBody.ExceptionHandlers.Add(handler); } }
private IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.ParameterDefinition> CreateParameters(AnalysisNet.Types.MethodDefinition methodDefinition, Mono.Cecil.MethodDefinition methodDef) { IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.ParameterDefinition> parameterDefinitions = new Dictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.ParameterDefinition>(); for (int idx = 0; idx < methodDefinition.Parameters.Count; idx++) { AnalysisNet.Types.MethodParameter methodParameter = methodDefinition.Parameters.ElementAt(idx); //if (methodParameter.Name.Equals("this")) // continue; Cecil.ParameterDefinition paramDef = new Cecil.ParameterDefinition(ReferenceGenerator.TypeReference(methodParameter.Type)); if (methodParameter.DefaultValue != null) { paramDef.Constant = methodParameter.DefaultValue.Value; paramDef.HasDefault = true; } if (methodParameter.Kind == AnalysisNet.Types.MethodParameterKind.In) { paramDef.IsIn = true; } else if (methodParameter.Kind == AnalysisNet.Types.MethodParameterKind.Out) { paramDef.IsOut = true; } methodDef.Parameters.Add(paramDef); // map body parameters to cecil parameters if (methodDefinition.HasBody && methodDefinition.Body.Parameters.Count > 0) { // body parameters contain 'this' while analysis-net's parameters do not int localIdx = (methodDefinition.IsStatic ? 0 : 1) + idx; AnalysisNet.ThreeAddressCode.Values.IVariable localVariable = methodDefinition.Body.Parameters.ElementAt(localIdx); parameterDefinitions[localVariable] = paramDef; } } return(parameterDefinitions); }
private void CreateDefinitions(ModelMapping modelMapping) { IDictionary <Model.Assembly, AssemblyDefinition> assembliesMap = modelMapping.AssembliesMap; foreach (KeyValuePair <Model.Assembly, AssemblyDefinition> keyval in assembliesMap) { AssemblyDefinition cecilAssembly = keyval.Value; Model.Assembly analysisNetAssembly = keyval.Key; ReferenceGenerator referenceGen = new ReferenceGenerator(new Context(cecilAssembly.MainModule, modelMapping, Host)); // TraverseTypes returns every nested type in A before returning A // this is assumed by the TypeGenerator and MethodGenerator foreach (Model.Types.TypeDefinition analysisNetType in analysisNetAssembly.TraverseTypes()) { TypeGenerator typeGenerator = new TypeGenerator(referenceGen); Mono.Cecil.TypeDefinition cecilTypeDef = typeGenerator.TypeDefinition(analysisNetType); // nested types are not added directly to the main module // instead they are added to their enclosing type (that's the way cecil works) if (cecilTypeDef.DeclaringType == null) { cecilAssembly.MainModule.Types.Add(cecilTypeDef); } foreach (Model.Types.MethodDefinition analysisNetMethod in analysisNetType.Methods) { MethodGenerator methodGenerator = new MethodGenerator(referenceGen); cecilTypeDef.Methods.Add(methodGenerator.MethodDefinition(analysisNetMethod)); } // we need to have every method definition created typeGenerator.PropertyDefinitions(analysisNetType, cecilTypeDef); } } }
public MethodGenerator(ReferenceGenerator referenceGenerator) : base(referenceGenerator) { }
private void SetDeclaringType(AnalysisNet.Types.TypeDefinition typeDefinition, Cecil.TypeDefinition cecilDef) { Cecil.TypeReference declaringTypeRef = typeDefinition.ContainingType == null ? null : ReferenceGenerator.TypeReference(typeDefinition.ContainingType); if (declaringTypeRef != null) { Cecil.TypeDefinition declaringType = declaringTypeRef.Resolve(); declaringType.NestedTypes.Add(cecilDef); cecilDef.DeclaringType = declaringType; } }
public InstructionGenerator(ReferenceGenerator referenceGenerator) { Context = referenceGenerator.Context; ReferenceGenerator = referenceGenerator; }
private IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.Cil.VariableDefinition> CreateLocalVariables(Model.Types.MethodDefinition methodDefinition, Mono.Cecil.MethodDefinition methodDef) { IDictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.Cil.VariableDefinition> variableDefinitions = new Dictionary <AnalysisNet.ThreeAddressCode.Values.IVariable, Cecil.Cil.VariableDefinition>(); foreach (AnalysisNet.ThreeAddressCode.Values.IVariable localVariable in methodDefinition.Body.LocalVariables) { Cecil.Cil.VariableDefinition varDef = new Cecil.Cil.VariableDefinition(ReferenceGenerator.TypeReference(localVariable.Type)); methodDef.Body.Variables.Add(varDef); variableDefinitions[localVariable] = varDef; } return(variableDefinitions); }
public TypeGenerator(ReferenceGenerator referenceGenerator) : base(referenceGenerator) { }
private void SetBaseType(AnalysisNet.Types.TypeDefinition typeDefinition, Cecil.TypeDefinition cecilDef) { Cecil.TypeReference baseType = typeDefinition.Base == null ? null : ReferenceGenerator.TypeReference(typeDefinition.Base); cecilDef.BaseType = baseType; }
public DefinitionGenerator(ReferenceGenerator referenceGenerator) { Context = referenceGenerator.Context; ReferenceGenerator = referenceGenerator; }