public void HeuristicAdd(Mono.Cecil.ModuleDefinition module) { // Search module for PFEs and add enclosing method. // Find all pfe's in graph. foreach (Mono.Cecil.MethodDefinition method in Campy.Types.Utils.ReflectionCecilInterop.GetMethods(module)) { if (method.Body == null) { return; } foreach (Mono.Cecil.Cil.Instruction i in method.Body.Instructions) { Mono.Cecil.Cil.OpCode op = i.OpCode; Mono.Cecil.Cil.FlowControl fc = op.FlowControl; object operand = i.Operand; Mono.Cecil.MethodReference call_to = operand as Mono.Cecil.MethodReference; if (fc == Mono.Cecil.Cil.FlowControl.Call) { if (call_to != null && call_to.Name.Equals("For") && call_to.DeclaringType != null && call_to.DeclaringType.FullName.Equals("Campy.Parallel")) { Add(method); } } } } }
public void FindGetLoggerMethod() { var loggerFactoryAttribute = ModuleDefinition .Assembly .CustomAttributes .FirstOrDefault(x => x.AttributeType.Name == "LoggerFactoryAttribute"); if (loggerFactoryAttribute == null) { LogInfo("Could not find a 'LoggerFactoryAttribute' on the current assembly. Going to search current assembly for 'LoggerFactory'."); var typeDefinition = ModuleDefinition .GetTypes() .FirstOrDefault(x => !x.IsGenericInstance && x.Name == "LoggerFactory"); if (typeDefinition == null) { throw new WeavingException("Could not find a type named LoggerFactory"); } FindGetLogger(typeDefinition); } else { var typeReference = (TypeReference) loggerFactoryAttribute.ConstructorArguments.First().Value; FindGetLogger(typeReference.Resolve()); GetLoggerMethod = ModuleDefinition.ImportReference(GetLoggerMethod); ModuleDefinition.Assembly.CustomAttributes.Remove(loggerFactoryAttribute); } }
private AnalysisNet.Types.IMethodReference ExtractNonGenericInstanceMethod(Cecil.MethodReference methodref) { AnalysisNet.Types.IType extractedType = ExtractType(methodref.DeclaringType); AnalysisNet.Types.IBasicType containingType; if (extractedType is AnalysisNet.Types.ArrayType arrayType) { containingType = new FakeArrayType(arrayType); } else { containingType = (AnalysisNet.Types.IBasicType)extractedType; } AnalysisNet.Types.MethodReference method = new AnalysisNet.Types.MethodReference(methodref.Name, AnalysisNet.Types.PlatformType.Void); genericParameterExtractor.MapGenericParameters(methodref, method); method.ReturnType = ExtractType(methodref.ReturnType); ExtractParameters(method.Parameters, methodref.Parameters); method.GenericParameterCount = methodref.GenericParameters.Count(); method.ContainingType = containingType; method.IsStatic = !(methodref.HasThis || methodref.ExplicitThis); method.Resolve(host); return(method); }
private AnalysisNet.IInstruction ProcessMethodCall(Cecil.Cil.Instruction op) { AnalysisNetBytecode.MethodCallOperation operation = OperationHelper.ToMethodCallOperation(op.OpCode.Code); Cecil.MethodReference cciMethod = op.Operand as Cecil.MethodReference; AnalysisNet.Types.IMethodReference ourMethod = typeExtractor.ExtractMethod(cciMethod); AnalysisNet.IInstruction instruction; if (ourMethod.ContainingType is FakeArrayType fakeArrayType) { AnalysisNet.Types.ArrayType arrayType = fakeArrayType.Type; if (ourMethod.Name == "Set") { instruction = ProcessStoreArrayElement(op, arrayType); return(instruction); } else { AnalysisNetBytecode.LoadArrayElementOperation arrayOp = OperationHelper.ToLoadArrayElementOperation(ourMethod.Name); instruction = ProcessLoadArrayElement(op, arrayOp, arrayType); return(instruction); } } instruction = new AnalysisNetBytecode.MethodCallInstruction((uint)op.Offset, operation, ourMethod); return(instruction); }
public static GenericBindingContext Create(MethodReference methodReference) { var genericMethod = methodReference as GenericInstanceMethod; return genericMethod != null ? new GenericBindingContext(genericMethod) : new GenericBindingContext(); }
public MethodReference GetLogEnabledForLog(MethodReference methodReference) { var name = methodReference.Name; if (name == "Debug" || name == "DebugException") { return IsDebugEnabledMethod; } if (name == "Info" || name == "InfoException") { return IsInfoEnabledMethod; } if (name == "Warn" || name == "WarnException") { return IsWarnEnabledMethod; } if (name == "Error" || name == "ErrorException") { return IsErrorEnabledMethod; } if (name == "Fatal" || name == "FatalException") { return IsFatalEnabledMethod; } throw new Exception("Invalid method name"); }
internal static string BuildMethodParameterList(MethodReference interopMethod, MethodReference interfaceMethod, Unity.IL2CPP.ILPreProcessor.TypeResolver typeResolver, MarshalType marshalType, bool includeTypeNames) { List<string> elements = new List<string>(); int num = 0; foreach (ParameterDefinition definition in interopMethod.Parameters) { MarshalInfo marshalInfo = interfaceMethod.Parameters[num].MarshalInfo; DefaultMarshalInfoWriter writer = MarshalDataCollector.MarshalInfoWriterFor(typeResolver.Resolve(definition.ParameterType), marshalType, marshalInfo, true, false, false, null); foreach (MarshaledType type in writer.MarshaledTypes) { elements.Add(string.Format(!includeTypeNames ? "{1}" : "{0} {1}", type.DecoratedName, Naming.ForParameterName(definition) + type.VariableName)); } num++; } TypeReference reference2 = typeResolver.Resolve(interopMethod.ReturnType); if (reference2.MetadataType != MetadataType.Void) { MarshalInfo info2 = interfaceMethod.MethodReturnType.MarshalInfo; MarshaledType[] marshaledTypes = MarshalDataCollector.MarshalInfoWriterFor(reference2, marshalType, info2, true, false, false, null).MarshaledTypes; for (int i = 0; i < (marshaledTypes.Length - 1); i++) { elements.Add(string.Format(!includeTypeNames ? "{1}" : "{0}* {1}", marshaledTypes[i].DecoratedName, Naming.ForComInterfaceReturnParameterName() + marshaledTypes[i].VariableName)); } elements.Add(string.Format(!includeTypeNames ? "{1}" : "{0}* {1}", marshaledTypes[marshaledTypes.Length - 1].DecoratedName, Naming.ForComInterfaceReturnParameterName())); } return EnumerableExtensions.AggregateWithComma(elements); }
void FindGetLogger(TypeDefinition typeDefinition) { if (!typeDefinition.IsPublic) { var message = $"The logger factory type '{typeDefinition.FullName}' needs to be public."; throw new WeavingException(message); } GetLoggerMethod = typeDefinition .Methods .FirstOrDefault(x => x.Name == "GetLogger" && x.IsStatic && x.HasGenericParameters && x.GenericParameters.Count == 1 && x.Parameters.Count == 0); if (GetLoggerMethod == null) { throw new WeavingException("Found 'LoggerFactory' but it did not have a static 'GetLogger' method that takes 'string' as a parameter"); } if (!GetLoggerMethod.Resolve().IsPublic) { var message = $"The logger factory method '{GetLoggerMethod.FullName}' needs to be public."; throw new WeavingException(message); } }
public void Init() { var methods = MsCoreReferenceFinder.StringDefinition.Methods; reference_String = ModuleDefinition.ImportReference(methods.First(x => x.Name == "IndexOf" && x.Parameters.Matches("String", "StringComparison"))); reference_StringInt = ModuleDefinition.ImportReference(methods.First(x => x.Name == "IndexOf" && x.Parameters.Matches("String", "Int32", "StringComparison"))); reference_StringIntInt = ModuleDefinition.ImportReference(methods.First(x => x.Name == "IndexOf" && x.Parameters.Matches("String", "Int32", "Int32", "StringComparison"))); }
public MethodReference GetExceptionOperand(MethodReference methodReference) { var name = methodReference.Name; if (name == "DebugException") { return DebugExceptionMethod; } if (name == "InfoException") { return InfoExceptionMethod; } if (name == "WarnException") { return WarnExceptionMethod; } if (name == "ErrorException") { return ErrorExceptionMethod; } if (name == "FatalException") { return FatalExceptionMethod; } throw new Exception("Invalid method name"); }
public ILBlockTranslator(AssemblyTranslator translator, DecompilerContext context, MethodReference methodReference, MethodDefinition methodDefinition, ILBlock ilb, IEnumerable<ILVariable> parameters, IEnumerable<ILVariable> allVariables) { Translator = translator; Context = context; ThisMethodReference = methodReference; ThisMethod = methodDefinition; Block = ilb; SpecialIdentifiers = new JSIL.SpecialIdentifiers(TypeSystem); if (methodReference.HasThis) Variables.Add("this", JSThisParameter.New(methodReference.DeclaringType, methodReference)); foreach (var parameter in parameters) { if ((parameter.Name == "this") && (parameter.OriginalParameter.Index == -1)) continue; ParameterNames.Add(parameter.Name); Variables.Add(parameter.Name, new JSParameter(parameter.Name, parameter.Type, methodReference)); } foreach (var variable in allVariables) { var v = JSVariable.New(variable, methodReference); if (Variables.ContainsKey(v.Identifier)) { v = new JSVariable(variable.OriginalVariable.Name, variable.Type, methodReference); RenamedVariables[variable] = v; Variables.Add(v.Identifier, v); } else { Variables.Add(v.Identifier, v); } } }
public OpCode GetLevelForLog(MethodReference methodReference) { var name = methodReference.Name; if (name == "Debug" || name == "DebugException") { return OpCodes.Ldc_I4_2; } if (name == "Info" || name == "InfoException") { return OpCodes.Ldc_I4_3; } if (name == "Warn" || name == "WarnException") { return OpCodes.Ldc_I4_4; } if (name == "Error" || name == "ErrorException") { return OpCodes.Ldc_I4_5; } if (name == "Fatal" || name == "FatalException") { return OpCodes.Ldc_I4_6; } throw new Exception("Invalid method name"); }
public MethodDefinition GetExternalMethod (MethodReference mr) { string library = GetSymbolLibrary (mr.Name); if (library != null) { List<MethodDefinition> methods = null; if (externalMethods.ContainsKey (mr.Name)) { methods = externalMethods [mr.Name]; foreach (MethodDefinition method in methods) { if (CompareMethodSignatures (mr, method)) { return method; } } } else { methods = new List<MethodDefinition> (); externalMethods [mr.Name] = methods; } if (! referredLibraries.ContainsKey (library)) { referredLibraries [library] = new ModuleReference (library); } MethodDefinition md = CreateExternalMethod (mr, library, referredLibraries [library]); methods.Add (md); return md; } else { return null; } }
public static MethodDefinition GetMethod(IList<MethodDefinition> methods, MethodReference reference) { for (int i = 0; i < methods.Count; i++) { var method = methods [i]; if (method.Name != reference.Name) continue; if (!AreSame (method.ReturnType, reference.ReturnType)) continue; if (method.HasParameters != reference.HasParameters) continue; if (!method.HasParameters && !reference.HasParameters) return method; if (!AreSame (method.Parameters, reference.Parameters)) continue; return method; } return null; }
void EmitInstruction(ILGenerator il, OpCode opcode, Cecil.MethodReference operandMethod) { var ourType = FindType(operandMethod.DeclaringType); Type[] opParamTypes = operandMethod.Parameters.Select((prm) => { if (prm.ParameterType is Cecil.GenericParameter) { throw new Exception("Unsupported generic parameter"); //return ourType.GenericTypeArguments[((Cecil.GenericParameter)prm.ParameterType).Position]; } return(FindType(prm.ParameterType)); }).ToArray(); if (operandMethod.Name == ".ctor") { il.Emit(opcode, ourType.GetConstructor( Reflection.BindingFlags.Instance | Reflection.BindingFlags.Static /*| Reflection.BindingFlags.NonPublic */ | Reflection.BindingFlags.Public, binder: null, types: opParamTypes, modifiers: null)); } else { il.Emit(opcode, ourType.GetMethod(operandMethod.Name, bindingAttr: bflags_all, binder: null, types: opParamTypes, modifiers: null)); } }
public static MethodReference MakeHostInstanceGeneric(this MethodReference @this, params TypeReference[] genericArguments) { var genericDeclaringType = new GenericInstanceType(@this.DeclaringType); foreach (var genericArgument in genericArguments) { genericDeclaringType.GenericArguments.Add(genericArgument); } var reference = new MethodReference(@this.Name, @this.ReturnType, genericDeclaringType) { HasThis = @this.HasThis, ExplicitThis = @this.ExplicitThis, CallingConvention = @this.CallingConvention }; foreach (var parameter in @this.Parameters) { reference.Parameters.Add(new ParameterDefinition(parameter.ParameterType)); } foreach (var genericParam in @this.GenericParameters) { reference.GenericParameters.Add(new GenericParameter(genericParam.Name, reference)); } return reference; }
public void FindCoreReferences() { var coreTypes = new List<TypeDefinition>(); AppendTypes("mscorlib", coreTypes); AppendTypes("System.IO", coreTypes); AppendTypes("System.Runtime", coreTypes); AppendTypes("System.Reflection", coreTypes); var textReaderTypeDefinition = coreTypes.First(x => x.Name == "TextReader"); ReadToEndMethod = ModuleDefinition.ImportReference(textReaderTypeDefinition.Find("ReadToEnd")); var exceptionTypeDefinition = coreTypes.First(x => x.Name == "Exception"); ExceptionConstructorReference = ModuleDefinition.ImportReference(exceptionTypeDefinition.Find(".ctor", "String")); var stringTypeDefinition = coreTypes.First(x => x.Name == "String"); ConcatReference = ModuleDefinition.ImportReference(stringTypeDefinition.Find("Concat", "String", "String", "String")); DisposeTextReaderMethod = ModuleDefinition.ImportReference(textReaderTypeDefinition.Find("Dispose")); var streamTypeDefinition = coreTypes.First(x => x.Name == "Stream"); DisposeStreamMethod = ModuleDefinition.ImportReference(streamTypeDefinition.Find("Dispose")); StreamTypeReference = ModuleDefinition.ImportReference(streamTypeDefinition); var streamReaderTypeDefinition = coreTypes.First(x => x.Name == "StreamReader"); StreamReaderTypeReference = ModuleDefinition.ImportReference(streamReaderTypeDefinition); StreamReaderConstructorReference = ModuleDefinition.ImportReference(streamReaderTypeDefinition.Find(".ctor", "Stream")); var assemblyTypeDefinition = coreTypes.First(x => x.Name == "Assembly"); AssemblyTypeReference = ModuleDefinition.ImportReference(assemblyTypeDefinition); GetExecutingAssemblyMethod = ModuleDefinition.ImportReference(assemblyTypeDefinition.Find("GetExecutingAssembly")); GetManifestResourceStreamMethod = ModuleDefinition.ImportReference(assemblyTypeDefinition.Find("GetManifestResourceStream", "String")); }
public OpCode GetLevel(MethodReference methodReference) { var name = methodReference.Name; if (name == "get_IsDebugEnabled") { return OpCodes.Ldc_I4_2; } if (name == "get_IsInfoEnabled") { return OpCodes.Ldc_I4_3; } if (name == "get_IsWarnEnabled") { return OpCodes.Ldc_I4_4; } if (name == "get_IsErrorEnabled") { return OpCodes.Ldc_I4_5; } if (name == "get_IsFatalEnabled") { return OpCodes.Ldc_I4_6; } throw new Exception("Invalid method name"); }
private void FixArguments(MethodReference method, ExpressionCollection arguments) { TypeDefinition declaringTypeDefinition = method.DeclaringType.Resolve(); if (declaringTypeDefinition == null) { return; } List<MethodDefinition> sameNameMethods = GetSameNameMethods(declaringTypeDefinition, method, arguments); if (sameNameMethods.Count > 0) { for (int i = 0; i < arguments.Count; i++) { TypeReference paramType = method.Parameters[i].ResolveParameterType(method); if (!arguments[i].HasType) { continue; } if (arguments[i].ExpressionType.FullName == paramType.FullName) { continue; } if (ShouldAddCast(arguments[i], sameNameMethods, i, paramType)) { arguments[i] = new CastExpression(arguments[i], paramType, null); } } } }
private static MethodReference CloneMethodWithDeclaringType(MethodDefinition methodDef, TypeReference declaringTypeRef) { if (!declaringTypeRef.IsGenericInstance || methodDef == null) { return methodDef; } var methodRef = new MethodReference(methodDef.Name, methodDef.ReturnType, declaringTypeRef) { CallingConvention = methodDef.CallingConvention, HasThis = methodDef.HasThis, ExplicitThis = methodDef.ExplicitThis }; foreach (var paramDef in methodDef.Parameters) { methodRef.Parameters.Add(new ParameterDefinition(paramDef.Name, paramDef.Attributes, paramDef.ParameterType)); } foreach (var genParamDef in methodDef.GenericParameters) { methodRef.GenericParameters.Add(new GenericParameter(genParamDef.Name, methodRef)); } return methodRef; }
private void CastMethodArguments(MethodReference method, ExpressionCollection arguments) { for (int i = 0; i < arguments.Count; i++) { Expression argument = arguments[i]; TypeReference parameterType = method.Parameters[i].ResolveParameterType(method); if (argument.HasType && parameterType != null && !(argument is LiteralExpression)) { TypeReference argumentType = argument.ExpressionType; if ((IsUnsignedIntegerType(argumentType) && IsSignedIntegerType(parameterType)) || (IsSignedIntegerType(argumentType) && IsUnsignedIntegerType(parameterType))) { Expression toCast = argument; if (argument is CastExpression) { CastExpression argumentCast = argument as CastExpression; if (IsIntegerType(argumentCast.TargetType)) { toCast = argumentCast.Expression; } } arguments[i] = new CastExpression(toCast, parameterType, null); } } } }
public MethodReference GetNormalOperand(MethodReference methodReference) { var name = methodReference.Name; if (name == "Trace") { return TraceMethod; } if (name == "Debug") { return DebugMethod; } if (name == "Info") { return InfoMethod; } if (name == "Warn") { return WarnMethod; } if (name == "Error") { return ErrorMethod; } if (name == "Fatal") { return FatalMethod; } throw new Exception("Invalid method name"); }
public FunctionPointerType() : base(null) { this.function = new MethodReference (); this.function.Name = "method"; this.etype = MD.ElementType.FnPtr; }
public IEnumerable<Instruction> Convert(MethodReference method) { if (method.Name != "IndexOf") { yield break; } if (method.Parameters.Matches("String")) { yield return Instruction.Create(OpCodes.Ldc_I4, StringComparisonConstant); yield return Instruction.Create(OpCodes.Callvirt, reference_String); yield break; } if (method.Parameters.Matches("String","Int32")) { yield return Instruction.Create(OpCodes.Ldc_I4, StringComparisonConstant); yield return Instruction.Create(OpCodes.Callvirt, reference_StringInt); yield break; } if (method.Parameters.Matches("String", "Int32", "Int32")) { yield return Instruction.Create(OpCodes.Ldc_I4, StringComparisonConstant); yield return Instruction.Create(OpCodes.Callvirt, reference_StringIntInt); } }
public static MethodDefinition InjectEqualsObject(TypeDefinition type, TypeReference typeRef, MethodReference newEquals, int typeCheck) { var methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual; var method = new MethodDefinition("Equals", methodAttributes, ReferenceFinder.Boolean.TypeReference); method.CustomAttributes.MarkAsGeneratedCode(); var obj = method.Parameters.Add("obj", ReferenceFinder.Object.TypeReference); var body = method.Body; var result = body.Variables.Add("result", ReferenceFinder.Boolean.TypeReference); var ins = body.Instructions; var labelRet = Instruction.Create(OpCodes.Nop); AddCheckEqualsReference(type, ins); ins.If( c => AddTypeChecking(type, typeRef, typeCheck, c), t => AddInternalEqualsCall(type, typeRef, newEquals, t, result), e => AddReturnFalse(e)); AddReturn(ins, labelRet, result); body.OptimizeMacros(); type.Methods.Add(method); return method; }
protected override CallResult createCallResult(MethodReference method, Block block, int callInstrIndex) { int methodId; if (!methodTokenToId.TryGetValue(method.MetadataToken.ToInt32(), out methodId)) return null; return new MyCallResult(block, callInstrIndex, methodId); }
public MethodReference GetFormatOperand(MethodReference methodReference) { var name = methodReference.Name; if (name == "Debug") { return DebugFormatMethod; } if (name == "Info") { return InfoFormatMethod; } if (name == "Warn") { return WarnFormatMethod; } if (name == "Error") { return ErrorFormatMethod; } if (name == "Fatal") { return FatalFormatMethod; } throw new Exception("Invalid method name"); }
internal static bool MethodSignaturesMatchIgnoreStaticness(MethodReference candidate, MethodReference method) { if (candidate.Parameters.Count != method.Parameters.Count) { return false; } if (candidate.GenericParameters.Count != method.GenericParameters.Count) { return false; } Unity.IL2CPP.ILPreProcessor.TypeResolver resolver = new Unity.IL2CPP.ILPreProcessor.TypeResolver(candidate.DeclaringType as GenericInstanceType, candidate as GenericInstanceMethod); Unity.IL2CPP.ILPreProcessor.TypeResolver resolver2 = new Unity.IL2CPP.ILPreProcessor.TypeResolver(method.DeclaringType as GenericInstanceType, method as GenericInstanceMethod); if (!Unity.IL2CPP.Common.TypeReferenceEqualityComparer.AreEqual(resolver.ResolveReturnType(candidate), resolver2.ResolveReturnType(method), TypeComparisonMode.SignatureOnly)) { return false; } for (int i = 0; i < candidate.Parameters.Count; i++) { if (!Unity.IL2CPP.Common.TypeReferenceEqualityComparer.AreEqual(resolver.ResolveParameterType(candidate, candidate.Parameters[i]), resolver2.ResolveParameterType(method, method.Parameters[i]), TypeComparisonMode.SignatureOnly)) { return false; } } return true; }
public AnalysisNet.Types.IMethodReference ExtractMethod(Cecil.MethodReference methodReference) { return(performanceCache.GetOrCreate(methodReference, (cacheEntry) => { if (methodReference is Cecil.GenericInstanceMethod instanceMethod) { List <AnalysisNet.Types.IType> genericArguments = new List <AnalysisNet.Types.IType>(); foreach (Cecil.TypeReference typeParameterref in instanceMethod.GenericArguments) { AnalysisNet.Types.IType typeArgumentref = ExtractType(typeParameterref); genericArguments.Add(typeArgumentref); } AnalysisNet.Types.IMethodReference method = ExtractMethod(instanceMethod.GetElementMethod()); AnalysisNet.Types.MethodReference instantiatedMethod = AnalysisNet.Extensions.Instantiate(method, genericArguments); instantiatedMethod.Resolve(host); return instantiatedMethod; } else { return ExtractNonGenericInstanceMethod(methodReference); } })); }
public void Execute() { var assemblyContainsAttribute = ModuleDefinition.Assembly.CustomAttributes.ContainsAttribute("LogMinimalMessageAttribute"); var moduleContainsAttribute = ModuleDefinition.CustomAttributes.ContainsAttribute("LogMinimalMessageAttribute"); if (assemblyContainsAttribute || moduleContainsAttribute) { LogMinimalMessage = true; } FindReference(); Init(); var stringType = ModuleDefinition.TypeSystem.String.Resolve(); ConcatMethod = ModuleDefinition.Import(stringType.FindMethod("Concat", "String", "String")); FormatMethod = ModuleDefinition.Import(stringType.FindMethod("Format", "String", "Object[]")); ObjectArray = new ArrayType(ModuleDefinition.TypeSystem.Object); FindExceptionType(); foreach (var type in ModuleDefinition .GetTypes() .Where(x => (x.BaseType != null) && !x.IsEnum && !x.IsInterface)) { ProcessType(type); } //TODO: ensure attributes dont exist on interfaces RemoveReference(); }
public void Execute() { var validationTemplateAttribute = ModuleDefinition .Assembly .CustomAttributes .FirstOrDefault(x=>x.AttributeType.Name == "ValidationTemplateAttribute"); if (validationTemplateAttribute == null) { LogInfo("Could not find a 'ValidationTemplateAttribute' on the current assembly. Going to search current assembly for 'ValidationTemplate'."); TypeDefinition = ModuleDefinition .GetTypes() .FirstOrDefault(x => x.Name == "ValidationTemplate" || x.Name == "ValidationTemplate`1"); if (TypeDefinition == null) { throw new WeavingException("Could not find a type named 'ValidationTemplate'"); } TypeReference = TypeDefinition; FindConstructor(); } else { var typeReference = (TypeReference) validationTemplateAttribute.ConstructorArguments.First().Value; TypeReference = typeReference; TypeDefinition = typeReference.Resolve(); FindConstructor(); TemplateConstructor = ModuleDefinition.Import(TemplateConstructor); } }
public static bool AreSame(this MethodReference method, MethodReference other) { var possiblyEqual = method.DeclaringType.FullName.Equals(other.DeclaringType.FullName, StringComparison.Ordinal) && method.FullName.Equals(other.FullName, StringComparison.Ordinal) && method.Parameters.Count == other.Parameters.Count && method.GenericParameters.Count == other.GenericParameters.Count && method.IsGenericInstance == other.IsGenericInstance; if (!possiblyEqual) { return false; } for (var i = 0; i < method.Parameters.Count; ++i) { var pThis = method.Parameters[i]; var pThat = other.Parameters[i]; if (!pThis.ParameterType.FullName.Equals(pThat.ParameterType.FullName, StringComparison.Ordinal)) { return false; } } return true; }
public void add(MethodReference calledMethod) { int count; var key = new MethodReferenceAndDeclaringTypeKey(calledMethod); calls.TryGetValue(key, out count); calls[key] = count + 1; }
public MethodReference GetLogEnabled(MethodReference methodReference) { var name = methodReference.Name; if (name == "get_IsDebugEnabled") { return IsDebugEnabledMethod; } if (name == "get_IsInfoEnabled") { return IsInfoEnabledMethod; } if (name == "get_IsWarnEnabled") { return IsWarnEnabledMethod; } if (name == "get_IsErrorEnabled") { return IsErrorEnabledMethod; } if (name == "get_IsFatalEnabled") { return IsFatalEnabledMethod; } throw new Exception("Invalid method name"); }
public Cecil.MethodReference MethodReference(AnalysisNet.Types.IMethodReference methodReference) { if (methodsCache.TryGetValue(methodReference, out Cecil.MethodReference cecilMethodReference)) { return(cecilMethodReference); } Cecil.TypeReference dummyReturnType = Context.CurrentModule.TypeSystem.Void; Cecil.TypeReference declaringType = TypeReference(methodReference.ContainingType); string name = methodReference.Name; cecilMethodReference = new Cecil.MethodReference(name, dummyReturnType, declaringType) { HasThis = !methodReference.IsStatic }; if (methodReference.GenericParameterCount > 0) { cecilMethodReference.CreateGenericParameters(methodReference.GenericParameterCount); MapGenericParameters(cecilMethodReference, methodReference); // should we add constraints? if (methodReference.GenericArguments.Count == 0) { Cecil.GenericInstanceMethod instantiated = new Cecil.GenericInstanceMethod(cecilMethodReference); instantiated.GenericArguments.AddRange(cecilMethodReference.GenericParameters); cecilMethodReference = instantiated; } else { IEnumerable <Cecil.TypeReference> arguments = methodReference.GenericArguments.Select(ga => TypeReference(ga)); Cecil.GenericInstanceMethod instantiated = new Cecil.GenericInstanceMethod(cecilMethodReference); instantiated.GenericArguments.AddRange(arguments); cecilMethodReference = instantiated; } } cecilMethodReference.ReturnType = TypeReference(methodReference.ReturnType); foreach (AnalysisNet.Types.IMethodParameterReference parameter in methodReference.Parameters) { Cecil.ParameterDefinition cecilParam = new Cecil.ParameterDefinition(TypeReference(parameter.Type)); if (parameter.Kind == AnalysisNet.Types.MethodParameterKind.In) { cecilParam.IsIn = true; } else if (parameter.Kind == AnalysisNet.Types.MethodParameterKind.Out) { cecilParam.IsOut = true; } cecilMethodReference.Parameters.Add(cecilParam); } cecilMethodReference = Context.CurrentModule.ImportReference(cecilMethodReference); methodsCache[methodReference] = cecilMethodReference; return(cecilMethodReference); }
public override void Visit(Model.Bytecode.CreateObjectInstruction instruction) { Cecil.MethodReference methodReference = referenceGenerator.MethodReference(instruction.Constructor); Cecil.Cil.Instruction cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Newobj, methodReference); Result = new List <Mono.Cecil.Cil.Instruction>() { cilIns }; }
private AnalysisNet.IInstruction ProcessLoadMethodAddress(Cecil.Cil.Instruction op) { AnalysisNetBytecode.LoadMethodAddressOperation operation = OperationHelper.ToLoadMethodAddressOperation(op.OpCode.Code); Cecil.MethodReference cciMethod = op.Operand as Cecil.MethodReference; AnalysisNet.Types.IMethodReference ourMethod = typeExtractor.ExtractMethod(cciMethod); AnalysisNetBytecode.LoadMethodAddressInstruction instruction = new AnalysisNetBytecode.LoadMethodAddressInstruction((uint)op.Offset, operation, ourMethod); return(instruction); }
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 }; }
public CFGVertex FindEntry(Mono.Cecil.MethodReference mr) { foreach (CFG.CFGVertex node in this.VertexNodes) { if (node.Method == mr) { return(node); } } return(null); }
public Vertex FindEntry(Mono.Cecil.MethodReference mr) { foreach (CFG.Vertex node in this.Vertices) { if (node._original_method_reference == mr) { return(node); } } return(null); }
public void FindNewBlocks(Assembly assembly) { // Do not analyze Campy modules generally... if (Options.Singleton.Get(Options.OptionType.DoNotAnalyzeCampyAssemblies)) { return; } // Starting from all blocks in this assembly, // find all PFE's, then compute control-flow/ // data-flow analysis in order to compute call // structure and new blocks to analyze. List <Inst> pfe_list = new List <Inst>(); List <CFG.CFGVertex> pfe_entries = new List <CFGVertex>(); // Find all pfe's all nodes in assembly. foreach (CFG.CFGVertex node in this.VertexNodes) { foreach (Inst inst in node._instructions) { Mono.Cecil.Cil.OpCode op = inst.OpCode; Mono.Cecil.Cil.FlowControl fc = op.FlowControl; object operand = inst.Operand; Mono.Cecil.MethodReference call_to = operand as Mono.Cecil.MethodReference; if (fc == Mono.Cecil.Cil.FlowControl.Call) { if (call_to != null && call_to.Name.Equals("For") && call_to.DeclaringType != null && call_to.DeclaringType.FullName.Equals("Campy.Parallel")) { System.Console.WriteLine("Found PFE in block " + node.Name); pfe_list.Add(inst); } } } } // Convert PFE instructions into a list of entries. foreach (Inst inst in pfe_list) { CFG.CFGVertex entry = FindEntry(inst); if (!pfe_entries.Contains(entry)) { pfe_entries.Add(entry); } } // Perform sparse data flow propagation in order to // get all indirect calls. Add those blocks to the graph. this._cfa.SparseDataFlowPropagation(pfe_entries); }
private static bool AnalyzeMethodCreateNewObjects(MethodDefinition methodDefinition, XElement entity, XElement newMethodNode) { XElement createNode = null; bool result = false; Mono.Cecil.Cil.MethodBody body = methodDefinition.Body; if (null != body) { // method calls foreach (Instruction itemInstruction in body.Instructions) { if (itemInstruction.OpCode.Name.StartsWith("newobj")) { Mono.Cecil.MethodReference methodReference = itemInstruction.Operand as Mono.Cecil.MethodReference; string typeName = GetNameFromNewObjMethodReference(methodReference); string componentName = NetOfficeSupportTable.GetLibrary(typeName); string[] supportByLibrary = _netOfficeSupportTable.GetTypeSupport(typeName); if (typeName.StartsWith(_apiName) && !typeName.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase) && CountOf(typeName, ".") > 1 && (null != supportByLibrary)) { result = true; if (null == createNode) { createNode = new XElement("NewObjects"); newMethodNode.Add(createNode); } XElement newObject = new XElement("Entity", new XAttribute("Type", typeName), new XAttribute("Api", componentName)); createNode.Add(newObject); XElement supportByNode = new XElement("SupportByLibrary"); newObject.Add(supportByNode); if (null != supportByLibrary) { supportByNode.Add(new XAttribute("Name", typeName), new XAttribute("Api", componentName)); foreach (string item in supportByLibrary) { supportByNode.Add(new XElement("Version", item)); } } } } } } return(result); }
private AnalysisNet.IInstruction ProcessCreateObject(Cecil.Cil.Instruction op) { Cecil.MethodReference cciMethod = op.Operand as Cecil.MethodReference; AnalysisNet.Types.IMethodReference ourMethod = typeExtractor.ExtractMethod(cciMethod); if (ourMethod.ContainingType is FakeArrayType fakeArrayType) { bool withLowerBounds = ourMethod.Parameters.Count > fakeArrayType.Type.Rank; return(CreateArray((uint)op.Offset, fakeArrayType.Type, withLowerBounds)); } AnalysisNetBytecode.CreateObjectInstruction instruction = new AnalysisNetBytecode.CreateObjectInstruction((uint)op.Offset, ourMethod); return(instruction); }
void EmitInstruction(ILGenerator il, OpCode opcode, Cecil.MethodReference operandMethod) { var ourType = FindType(operandMethod.DeclaringType); Type[] opParamTypes = operandMethod.Parameters.Select((prm) => { if (prm.ParameterType is Cecil.GenericParameter) { return(ourType.GenericTypeArguments[((Cecil.GenericParameter)prm.ParameterType).Position]); } return(FindType(prm.ParameterType)); }).ToArray(); if (operandMethod.Name == ".ctor") { var target = ourType.GetConstructor( Reflection.BindingFlags.Instance | Reflection.BindingFlags.Static /*| Reflection.BindingFlags.NonPublic */ | Reflection.BindingFlags.Public, binder: null, types: opParamTypes, modifiers: null); if (target == null) { throw new Exception($"Cannot find call target constructor: {operandMethod.Name} {opParamTypes}"); } il.Emit(opcode, target); } else { var target = ourType.GetMethod(operandMethod.Name, bindingAttr: bflags_all, binder: null, types: opParamTypes, modifiers: null); if (target == null) { throw new Exception($"Cannot find call target method: {operandMethod.Name} {opParamTypes}"); } il.Emit(opcode, target); } }
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 }; }
public Reflection.MethodBase FindMethod(Type type, Cecil.MethodReference methodRef) { Type[] opParamTypes = methodRef.Parameters.Select((prm) => { if (prm.ParameterType is Cecil.GenericParameter) { throw new Exception("Unsupported generic parameter"); //return ourType.GenericTypeArguments[((Cecil.GenericParameter)prm.ParameterType).Position]; } if (prm.ParameterType is Cecil.ArrayType) { var arr = (Cecil.ArrayType)prm.ParameterType; if (arr.ElementType.IsGenericParameter) { throw new Exception("Unsupported generic array parameter"); } } return(FindType(prm.ParameterType)); }).ToArray(); if (methodRef.Name == ".ctor") { return(type.GetConstructor( Reflection.BindingFlags.Instance | Reflection.BindingFlags.Static /*| Reflection.BindingFlags.NonPublic */ | Reflection.BindingFlags.Public, binder: null, types: opParamTypes, modifiers: null)); } else { return(type.GetMethod(methodRef.Name, bindingAttr: bflags_all, binder: null, types: opParamTypes, modifiers: null)); } }
/// <summary> /// Create a method reference for the given method using this this as declaring type. /// Usually the method will be returned, unless this type is a generic instance type. /// </summary> internal static ILMethodReference CreateReference(this ILTypeReference declaringType, ILMethodDefinition method) { var git = declaringType as GenericInstanceType; if (git == null) { return(method); } var methodRef = new ILMethodReference(method.Name, method.ReturnType, git); methodRef.HasThis = method.HasThis; methodRef.ExplicitThis = method.ExplicitThis; foreach (var p in method.Parameters) { methodRef.Parameters.Add(new ParameterDefinition(p.Name, p.Attributes, p.ParameterType)); } foreach (var gp in method.GenericParameters) { methodRef.GenericParameters.Add(new GenericParameter(gp.Name, methodRef)); } return(methodRef); }
public override void Visit(Model.Bytecode.MethodCallInstruction instruction) { Mono.Cecil.Cil.Instruction cilIns; Cecil.MethodReference methodReference = referenceGenerator.MethodReference(instruction.Method); if (instruction.Operation == Model.Bytecode.MethodCallOperation.Static) { cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Call, methodReference); } else if (instruction.Operation == Model.Bytecode.MethodCallOperation.Virtual) { cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Callvirt, methodReference); } else { throw new NotImplementedException(); } Result = new List <Mono.Cecil.Cil.Instruction>() { cilIns }; }
protected void SetCustomAttributes(ICollection <AnalysisNet.Types.CustomAttribute> ourAttributes, ICollection <Cecil.CustomAttribute> cecilAttributes) { foreach (AnalysisNet.Types.CustomAttribute analysisNetAttr in ourAttributes) { Cecil.MethodReference ctor = ReferenceGenerator.MethodReference(analysisNetAttr.Constructor); Cecil.TypeReference type = ReferenceGenerator.TypeReference(analysisNetAttr.Type); Cecil.CustomAttribute cecilAttr = new Cecil.CustomAttribute(ctor); foreach (AnalysisNet.ThreeAddressCode.Values.Constant constant in analysisNetAttr.Arguments) { // todo: cci is not working correctly if (constant == null) { continue; } Cecil.CustomAttributeArgument cecilArg = new Cecil.CustomAttributeArgument(ReferenceGenerator.TypeReference(constant.Type), constant.Value); cecilAttr.ConstructorArguments.Add(cecilArg); } cecilAttributes.Add(cecilAttr); } }
public static bool EqualsReference(this Mono.Cecil.MethodDefinition definition, Mono.Cecil.MethodReference reference) { bool parameterMatch = (reference.Parameters.Count == definition.Parameters.Count); if (parameterMatch) { for (int i = 0; i < reference.Parameters.Count; i++) { Mono.Cecil.ParameterDefinition refParam = reference.Parameters [i]; Mono.Cecil.ParameterDefinition defParam = definition.Parameters [i]; if (!refParam.ParameterType.FullName.Equals(defParam.ParameterType.FullName)) { parameterMatch = false; } } } return((reference.CallingConvention.Equals(definition.CallingConvention) && (reference.DeclaringType.FullName.Equals(definition.DeclaringType.FullName)) && (reference.Name.Equals(definition.Name)) && (reference.ReturnType.ReturnType.FullName.Equals(definition.ReturnType.ReturnType.FullName)) && (reference.GenericParameters.Count == definition.GenericParameters.Count) && parameterMatch)); }
private static Mono.Cecil.Cil.Instruction GetParameterInstruction(Instruction itemInstruction, int index) { Mono.Cecil.Cil.Instruction methodInstruction = itemInstruction as Mono.Cecil.Cil.Instruction; Mono.Cecil.MethodReference methodReference = methodInstruction.Operand as Mono.Cecil.MethodReference; int i = 0; Instruction startItem = itemInstruction.Previous; while (startItem != null) { if (startItem.OpCode.Name.StartsWith("ld")) { i++; if (i == methodReference.Parameters.Count) { break; } } startItem = startItem.Previous; } i = 0; while (startItem != null) { if (startItem.OpCode.Name.StartsWith("ld")) { i++; if (i == index) { return(startItem); } } startItem = startItem.Next; } return(null); }
public static string Disassemble(DomCecilMethod method, bool markup) { if (method.MethodDefinition.IsPInvokeImpl) { return(GettextCatalog.GetString("Method is P/Invoke")); } if (method.MethodDefinition.Body == null) { IType type = method.DeclaringType; return(type == null || type.ClassType == ClassType.Interface ? GettextCatalog.GetString("Interface method") : GettextCatalog.GetString("Abstract method")); } StringBuilder result = new StringBuilder(); foreach (Instruction instruction in method.MethodDefinition.Body.Instructions) { if (markup) { result.Append("<b>"); } result.Append(GetInstructionOffset(instruction)); result.Append(markup ? ":</b> " : ": "); result.Append(instruction.OpCode); if (markup) { result.Append("<i>"); } if (instruction.Operand != null) { result.Append(' '); if (instruction.Operand is string) { result.Append('"'); result.Append(AssemblyBrowserWidget.FormatText(instruction.Operand.ToString())); result.Append('"'); } else if (instruction.Operand is Mono.Cecil.Cil.Instruction) { result.Append(GetInstructionOffset((Mono.Cecil.Cil.Instruction)instruction.Operand)); } else if (instruction.Operand is Mono.Cecil.TypeDefinition) { AppendLink(result, new DomCecilType((Mono.Cecil.TypeDefinition)instruction.Operand).HelpUrl, instruction.Operand.ToString()); } else if (instruction.Operand is Mono.Cecil.MethodDefinition) { Mono.Cecil.MethodDefinition md = instruction.Operand as Mono.Cecil.MethodDefinition; AppendLink(result, new DomCecilMethod(md) { DeclaringType = new DomCecilType(md.DeclaringType) }.HelpUrl, instruction.Operand.ToString()); } else if (instruction.Operand is Mono.Cecil.FieldDefinition) { Mono.Cecil.FieldDefinition fd = instruction.Operand as Mono.Cecil.FieldDefinition; AppendLink(result, new DomCecilField(fd) { DeclaringType = new DomCecilType(fd.DeclaringType) }.HelpUrl, instruction.Operand.ToString()); } else if (instruction.Operand is Mono.Cecil.PropertyDefinition) { Mono.Cecil.PropertyDefinition pd = instruction.Operand as Mono.Cecil.PropertyDefinition; AppendLink(result, new DomCecilProperty(pd) { DeclaringType = new DomCecilType(pd.DeclaringType) }.HelpUrl, instruction.Operand.ToString()); } else if (instruction.Operand is Mono.Cecil.TypeReference) { AppendLink(result, "T:" + ((TypeReference)instruction.Operand).FullName, instruction.Operand.ToString()); } else if (instruction.Operand is Mono.Cecil.MethodReference) { Mono.Cecil.MethodReference mr = instruction.Operand as Mono.Cecil.MethodReference; StringBuilder id = new StringBuilder(mr.DeclaringType.ToString()); bool isConstructor = mr.Name == ".ctor"; if (!isConstructor) { id.Append("." + mr.Name); } id.Append("("); for (int i = 0; i < mr.Parameters.Count; i++) { if (i > 0) { id.Append(','); } id.Append(mr.Parameters[i].ParameterType.FullName); } id.Append(")"); AppendLink(result, (isConstructor ? "C:" : "M:") + id, id.ToString()); } else if (instruction.Operand is Mono.Cecil.FieldReference) { Mono.Cecil.FieldReference fr = instruction.Operand as Mono.Cecil.FieldReference; string id = fr.DeclaringType + "." + fr.Name; AppendLink(result, "F:" + id, id); } else if (instruction.Operand is Mono.Cecil.PropertyReference) { Mono.Cecil.PropertyReference pr = instruction.Operand as Mono.Cecil.PropertyReference; string id = pr.DeclaringType + "." + pr.Name; AppendLink(result, "P:" + id, id); } else { result.Append(AssemblyBrowserWidget.FormatText(instruction.Operand.ToString())); } } if (markup) { result.Append("</i>"); } result.AppendLine(); } result.AppendLine(); return(result.ToString()); }
internal IMethod GetMethod(object token, ILType contextType, ILMethod contextMethod, out bool invalidToken) { string methodname = null; string typename = null; List <IType> paramList = null; int hashCode = token.GetHashCode(); IMethod method; IType[] genericArguments = null; IType returnType; invalidToken = false; bool isConstructor = false; if (mapMethod.TryGetValue(hashCode, out method)) { return(method); } IType type = null; if (token is Mono.Cecil.MethodReference) { Mono.Cecil.MethodReference _ref = (token as Mono.Cecil.MethodReference); if (_ref.FullName == "System.Void System.Object::.ctor()") { mapMethod[hashCode] = null; return(null); } if (_ref.FullName == "System.Void System.Attribute::.ctor()") { mapMethod[hashCode] = null; return(null); } methodname = _ref.Name; var typeDef = _ref.DeclaringType; type = GetType(typeDef, contextType, contextMethod); if (type == null) { throw new KeyNotFoundException("Cannot find type:" + typename); } if (token is Mono.Cecil.MethodDefinition) { var def = _ref as MethodDefinition; isConstructor = def.IsConstructor; } else { isConstructor = methodname == ".ctor"; } if (_ref.IsGenericInstance) { GenericInstanceMethod gim = (GenericInstanceMethod)_ref; genericArguments = new IType[gim.GenericArguments.Count]; for (int i = 0; i < genericArguments.Length; i++) { if (gim.GenericArguments[i].IsGenericParameter) { invalidToken = true; } var gt = GetType(gim.GenericArguments[i], contextType, contextMethod); if (gt == null) { gt = contextMethod.FindGenericArgument(gim.GenericArguments[i].Name); if (gt == null)//This means it contains unresolved generic arguments, which means it's not searching the generic instance { genericArguments = null; break; } else { genericArguments[i] = gt; } } else { genericArguments[i] = gt; } } } paramList = _ref.GetParamList(this, contextType, contextMethod, genericArguments); returnType = GetType(_ref.ReturnType, contextType, null); } else { throw new NotImplementedException(); //Mono.Cecil.GenericInstanceMethod gmethod = _def as Mono.Cecil.GenericInstanceMethod; //genlist = new MethodParamList(environment, gmethod); } if (isConstructor) { method = type.GetConstructor(paramList); } else { method = type.GetMethod(methodname, paramList, genericArguments, returnType); if (method != null && method.IsGenericInstance) { mapMethod[method.GetHashCode()] = method; } } if (method == null) { if (isConstructor && contextType.FirstCLRBaseType != null && contextType.FirstCLRBaseType is CrossBindingAdaptor && type.TypeForCLR == ((CrossBindingAdaptor)contextType.FirstCLRBaseType).BaseCLRType) { method = contextType.BaseType.GetConstructor(paramList); if (method == null) { throw new KeyNotFoundException("Cannot find method:" + methodname); } invalidToken = true; mapMethod[method.GetHashCode()] = method; } else { throw new KeyNotFoundException("Cannot find method:" + methodname); } } if (!invalidToken) { mapMethod[hashCode] = method; } return(method); }
public MethodReference Import(MethodReference method, IGenericParameterProvider context) { return(ImportReference(method, context)); }
public MethodReference ImportReference(MethodReference method) { return(ImportReference(method, null)); }
private static bool AnalyzeMethodCallParameters(Instruction itemInstruction, XElement newMethodCallNode) { bool result = false; Mono.Cecil.Cil.Instruction methodInstruction = itemInstruction as Mono.Cecil.Cil.Instruction; Mono.Cecil.MethodReference methodReference = methodInstruction.Operand as Mono.Cecil.MethodReference; int i = 1; foreach (ParameterDefinition itemParameter in methodReference.Parameters) { string paramType = itemParameter.ParameterType.FullName; if (paramType.StartsWith(_apiName) && CountOf(paramType, ".") > 1 && !paramType.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase)) { result = true; Mono.Cecil.Cil.Instruction parameterInstruction = GetParameterInstruction(itemInstruction, i); if (itemParameter.ParameterType.IsValueType) { string[] supportByLibrary = _netOfficeSupportTable.GetEnumMemberSupport(itemParameter.ParameterType.FullName, GetOperatorValue(parameterInstruction)); if (null != supportByLibrary) { XElement newParameter = new XElement("Parameter"); string componentName = NetOfficeSupportTable.GetLibrary(itemParameter.ParameterType.FullName); XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName)); string enumMemberName = _netOfficeSupportTable.GetEnumMemberNameFromValue(itemParameter.ParameterType.FullName, GetOperatorValue(parameterInstruction)); if (null != enumMemberName) { supportByNode.Add(new XAttribute("Name", paramType + "." + enumMemberName)); } else { supportByNode.Add(new XAttribute("Name", paramType + "." + GetOperatorValue(parameterInstruction).ToString())); } foreach (string item in supportByLibrary) { supportByNode.Add(new XElement("Version", item)); } newParameter.Add(supportByNode); newMethodCallNode.Element("Parameters").Add(newParameter); } } else { string[] supportByLibrary = _netOfficeSupportTable.GetTypeSupport(itemParameter.ParameterType.FullName); if (null != supportByLibrary) { XElement newParameter = new XElement("Parameter"); string componentName = NetOfficeSupportTable.GetLibrary(itemParameter.ParameterType.FullName); XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName)); supportByNode.Add(new XAttribute("Name", paramType)); foreach (string item in supportByLibrary) { supportByNode.Add(new XElement("Version", item)); } newParameter.Add(supportByNode); newMethodCallNode.Element("Parameters").Add(newParameter); } } } else { Instruction prevInstruction = methodInstruction.Previous; while (prevInstruction.OpCode.Name.StartsWith("ld") || prevInstruction.OpCode.Name.StartsWith("box")) { if (null != prevInstruction.Operand) { string targetName = prevInstruction.Operand.ToString(); string[] dumyByLibrary = _netOfficeSupportTable.GetTypeSupport(targetName); if (null != dumyByLibrary) { if (null != prevInstruction.Previous.Operand) { int temp = 0; if (Int32.TryParse(prevInstruction.Previous.Operand.ToString(), out temp)) { int opValue = Convert.ToInt32(temp); string enumMemberName = _netOfficeSupportTable.GetEnumMemberNameFromValue(targetName, opValue); if (null != enumMemberName) { string[] supportByLibrary = _netOfficeSupportTable.GetEnumMemberSupport(targetName, opValue); if (null != supportByLibrary) { XElement newParameter = new XElement("Parameter"); string componentName = NetOfficeSupportTable.GetLibrary(targetName); XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName)); supportByNode.Add(new XAttribute("Name", targetName + "." + enumMemberName)); foreach (string item in supportByLibrary) { supportByNode.Add(new XElement("Version", item)); } newParameter.Add(supportByNode); newMethodCallNode.Element("Parameters").Add(newParameter); } } } } } } prevInstruction = prevInstruction.Previous; } } i++; } return(result); }
private static bool AnalyzeMethodCalls(MethodDefinition methodDefinition, XElement entity, XElement newMethodNode) { XElement callsNode = null; bool result = false; Mono.Cecil.Cil.MethodBody body = methodDefinition.Body; if (null != body) { // method calls foreach (Instruction itemInstruction in body.Instructions) { if (itemInstruction.OpCode.Name.StartsWith("callvirt")) { Mono.Cecil.Cil.Instruction methodInstruction = itemInstruction as Mono.Cecil.Cil.Instruction; Mono.Cecil.MethodReference methodReference = methodInstruction.Operand as Mono.Cecil.MethodReference; string callName = GetCallNameFromAnalyzeMethodCalls(methodReference); string typeName = GetNameFromNewObjMethodReference(methodReference); string componentName = NetOfficeSupportTable.GetLibrary(typeName); string[] testArray = typeName.Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries); if (testArray.Length >= 3 && testArray[2] == "Tools") { continue; } if ((typeName.StartsWith(_apiName)) && !typeName.Equals(_apiName + ".dll", StringComparison.InvariantCultureIgnoreCase) && CountOf(typeName, ".") > 1 && (!typeName.StartsWith("NetOffice.DeveloperToolbox"))) { string[] supportByLibrary = _netOfficeSupportTable.GetTypeCallSupport(callName); result = true; if (null == callsNode) { callsNode = new XElement("Calls"); newMethodNode.Add(callsNode); } XElement newObject = new XElement("Entity", new XElement("Parameters"), new XAttribute("Type", typeName), new XAttribute("Name", callName), new XAttribute("Api", componentName)); callsNode.Add(newObject); XElement supportByNode = new XElement("SupportByLibrary", new XAttribute("Api", componentName)); newObject.Add(supportByNode); if (null != supportByLibrary) { supportByNode.Add(new XAttribute("Name", callName)); foreach (string item in supportByLibrary) { supportByNode.Add(new XElement("Version", item)); } } bool resultParameter = AnalyzeMethodCallParameters(itemInstruction, newObject); } } } } return(result); }
private static string GetNameFromNewObjMethodReference(Mono.Cecil.MethodReference methodReference) { string[] array = methodReference.ToString().Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries); string[] array2 = array[1].Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries); return(array2[0].Trim()); }
private static string GetCallNameFromAnalyzeMethodCalls(Mono.Cecil.MethodReference methodReference) { string[] array = methodReference.ToString().Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries); return(array[1].Trim()); }
public MMethod getMethod(MethodReference methodReference) { initMethods(); MMethod method; methodReferenceToMethod.TryGetValue(new MethodReferenceKey(methodReference), out method); return method; }