public FieldAssignmentReplacementBuilder(FieldReference field, IMetadataHost host, ExpressionStatement assignment, ReplacementRegistry registry) { this.field = field; this.host = host; this.assignment = assignment; this.registry = registry; }
public override void HandleEvent(object sender, EventArgs e) { TerminologyLogger.GetLogger().Info("Handling add instance event!"); var result = new FieldReference<string>(string.Empty); var confim = this.Engine.UiControl.MainWindow.PopupSingleLineInputDialog(TranslationManager.GetManager.Localize("Title", "Add a Instance"), TranslationManager.GetManager.Localize("InstanceUrl", "Instance URL:"), result); if (confim == null || confim.Value == false) { TerminologyLogger.GetLogger().Info("Empty input or user canceled. Ignore!"); return; } try { var message = this.Engine.InstanceManager.AddInstance(result.Value); this.Engine.UiControl.MainWindow.InstanceList = new ObservableCollection<InstanceEntity>(this.Engine.InstanceManager.InstancesWithLocalImageSource); this.Engine.UiControl.MainWindow.PopupNotifyDialog("Successful", message); } catch (WebException ex) { TerminologyLogger.GetLogger() .ErrorFormat($"Network is not accessable! Detail: {ex.Message}"); this.Engine.UiControl.MainWindow.PopupNotifyDialog(TranslationManager.GetManager.Localize("Error", "Error"), string.Format(TranslationManager.GetManager.Localize("NetworkNotAccessable", "Network is not accessable! Detail: {0}", 1), ex.Message)); } catch (JsonReaderException ex) { TerminologyLogger.GetLogger() .ErrorFormat($"Wrong instance json format! {ex.Message}"); this.Engine.UiControl.MainWindow.PopupNotifyDialog(TranslationManager.GetManager.Localize("Error", "Error"), string.Format(TranslationManager.GetManager.Localize("WrongJsonFormat", "Wrong instance json format! {0}", 1), ex.Message)); } catch (MissingFieldException ex) { TerminologyLogger.GetLogger() .ErrorFormat($"Critical field is missing! {ex.Message}"); this.Engine.UiControl.MainWindow.PopupNotifyDialog(TranslationManager.GetManager.Localize("Error", "Error"), string.Format(TranslationManager.GetManager.Localize("MissCriticalField", "Some critical field is missing. Unable to add this instance! Detail:{0}", 1), ex.Message)); } catch (Exception ex) { TerminologyLogger.GetLogger() .ErrorFormat($"Cannot add this instance because {ex}"); this.Engine.UiControl.MainWindow.PopupNotifyDialog(TranslationManager.GetManager.Localize("Error", "Error"), string.Format(TranslationManager.GetManager.Localize("UnknownError", "Caused by an error, we cannot add this instance right now. Detail: {0}", 1), ex.Message)); } }
internal SingleSelectWindow(Window owner, string title, string fieldName, IEnumerable<string> options, FieldReference<string> selection) { this.SelectItemValue = selection; this.SelectItems = new ObservableCollection<string>(); this.InitializeComponent(); if (owner != null) { this.Owner = owner; this.WindowStartupLocation = WindowStartupLocation.CenterOwner; } else { this.WindowStartupLocation = WindowStartupLocation.CenterScreen; } this.Title = title; this.FieldName = fieldName; this.SelectItems = new ObservableCollection<string>(options); this.OnPropertyChanged(); }
public bool? PopupSingleLineInputDialog(string title, string fieldName, FieldReference<string> content) { throw new NotImplementedException(); }
/// <summary> /// 为类型注入InitHotFix函数 /// </summary> /// <param name="typeDefinition"></param> private static void InjectInitHotFixFunc(TypeDefinition typeDefinition, FieldReference hotfixState, List <FieldDefinition> bridgeLuaFuncs) { string funcName = "InitHotFix"; foreach (var method in typeDefinition.Methods) { if (method.Name == funcName) { typeDefinition.Methods.Remove(method); break; } } MethodDefinition initHotFixMethod = new MethodDefinition(funcName, MethodAttributes.Static | MethodAttributes.Private, typeRef_bool); initHotFixMethod.Body = new Mono.Cecil.Cil.MethodBody(initHotFixMethod); initHotFixMethod.Parameters.Add(new ParameterDefinition("luaModule", ParameterAttributes.None, typeRef_LuaTable)); initHotFixMethod.Body = new Mono.Cecil.Cil.MethodBody(initHotFixMethod); initHotFixMethod.Body.MaxStackSize = 4; initHotFixMethod.Body.Variables.Add(new VariableDefinition(typeRef_bool)); initHotFixMethod.Body.Variables.Add(new VariableDefinition(typeRef_bool)); // 开始注入IL代码 var ilProcessor = initHotFixMethod.Body.GetILProcessor(); initHotFixMethod.Body.Instructions.Add(ilProcessor.Create(OpCodes.Ret)); var insertPoint = initHotFixMethod.Body.Instructions[0]; // 设置一些标签用于语句跳转 var label1 = ilProcessor.Create(OpCodes.Nop); var label2 = ilProcessor.Create(OpCodes.Ldloc_0); var label3 = ilProcessor.Create(OpCodes.Ldloc_1); // if (luaModule == null) ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldarg_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldnull)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Call, methodRef_LuaVar_op_Equality)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Brfalse, label1)); //result = false; 将0压入局部变量索引零处 ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label2)); //luaModule != null ilProcessor.InsertBefore(insertPoint, label1); //OpCodes.Nop //初始化方法对应的luaFunction变量 Type type = FindType(typeDefinition.FullName); bool isUnityComponent = type.IsAssignableFrom(typeof(UnityEngine.Component)); foreach (var methodDef in typeDefinition.Methods) { //for example: //m_Add_ThisInt32Int32_fix = (luaModule.get("Add_ThisInt32Int32", rawget: true) as LuaFunction); if (!LuaInjectUtil.IsMethodNeedHotFix(methodDef, isUnityComponent)) { continue; } var bridgeLuaFunc = bridgeLuaFuncs.Find((field) => { return(field.Name == LuaInjectUtil.GetHotFixFunctionNameInCS(methodDef)); }); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldarg_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldstr, LuaInjectUtil.GetHotFixFunctionNameInLua(methodDef))); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_1)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Callvirt, methodRef_LuaTable_get)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Isinst, typeRef_LuaFunction)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stsfld, bridgeLuaFunc)); } ////result = true; 将1压入局部变量索引零处 ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_1)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop)); ilProcessor.InsertBefore(insertPoint, label2);//OpCodes.Ldloc_0 ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_1)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label3)); ilProcessor.InsertBefore(insertPoint, label3);//OpCodes.Ldloc_1 typeDefinition.Methods.Add(initHotFixMethod); }
public FieldReference Import(FieldReference field) { return m_helper == null ? field : m_helper.ImportFieldReference (field, this); }
internal FieldSignatureConverter GetFieldRefSignature( FieldReference moduleFieldReference ) { uint signatureBlobOffset = this.PEFileReader.MemberRefTable.GetSignature(moduleFieldReference.MemberRefRowId); // TODO: error checking offset in range MemoryBlock signatureMemoryBlock = this.PEFileReader.BlobStream.GetMemoryBlockAt(signatureBlobOffset); // TODO: Error checking enough space in signature memoryBlock. MemoryReader memoryReader = new MemoryReader(signatureMemoryBlock); // TODO: Check if this is really field signature there. FieldSignatureConverter fieldSigConv = new FieldSignatureConverter(this, moduleFieldReference, memoryReader); return fieldSigConv; }
private void CompileFieldReference(Parser parser, ByteBuffer buffer, FieldReference fieldRef, bool outputUsed) { EnsureUsed(fieldRef.FirstToken, outputUsed); if (fieldRef.Field.IsStaticField) { buffer.Add( fieldRef.FirstToken, OpCode.DEREF_STATIC_FIELD, ((ClassDefinition)fieldRef.Field.FunctionOrClassOwner).ClassID, fieldRef.Field.StaticMemberID); } else { buffer.Add( fieldRef.FirstToken, OpCode.DEREF_INSTANCE_FIELD, fieldRef.Field.MemberID); } }
private void ReadFieldReferences(BinaryReader reader) { reader.PreserveCurrentPosition(header.FieldReferencesOffset, () => { for (int i = 0; i < header.FieldReferencesSize; i++) { int classIndex = reader.ReadUInt16(); int typeIndex = reader.ReadUInt16(); int nameIndex = reader.ReadInt32(); var fref = new FieldReference(); fref.Owner = (ClassReference) typeReferences[classIndex]; fref.Type = typeReferences[typeIndex]; fref.Name = strings[nameIndex]; fieldReferences.Add(fref); } }); }
static bool NonGenericFieldComparer(FieldReference fieldReference, FieldDefinition fieldDefinition) { return(fieldDefinition == fieldReference); }
public FluentEmitter Emit(OpCode opcode, FieldReference arg) { return Emit(Instruction.Create(opcode, Module.SafeImport(arg))); }
private static void GenerateStaticProxy(AssemblyRewriteContext assemblyContext, TypeRewriteContext typeContext) { var oldType = typeContext.OriginalType; var newType = typeContext.NewType; var staticCtorMethod = new MethodDefinition(".cctor", MethodAttributes.Static | MethodAttributes.Private | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.RTSpecialName, assemblyContext.Imports.Void); newType.Methods.Add(staticCtorMethod); var ctorBuilder = staticCtorMethod.Body.GetILProcessor(); if (newType.IsNested) { ctorBuilder.Emit(OpCodes.Ldsfld, assemblyContext.GlobalContext.GetNewTypeForOriginal(oldType.DeclaringType).ClassPointerFieldRef); ctorBuilder.Emit(OpCodes.Ldstr, oldType.Name); ctorBuilder.Emit(OpCodes.Call, assemblyContext.Imports.GetIl2CppNestedClass); } else { ctorBuilder.Emit(OpCodes.Ldstr, oldType.Module.Name); ctorBuilder.Emit(OpCodes.Ldstr, oldType.Namespace); ctorBuilder.Emit(OpCodes.Ldstr, oldType.Name); ctorBuilder.Emit(OpCodes.Call, assemblyContext.Imports.GetIl2CppGlobalClass); } if (oldType.HasGenericParameters) { var il2CppTypeTypeRewriteContext = assemblyContext.GlobalContext.GetAssemblyByName("mscorlib").GetTypeByName("System.Type"); var il2CppSystemTypeRef = newType.Module.ImportReference(il2CppTypeTypeRewriteContext.NewType); var il2CppTypeHandleTypeRewriteContext = assemblyContext.GlobalContext.GetAssemblyByName("mscorlib").GetTypeByName("System.RuntimeTypeHandle"); var il2CppSystemTypeHandleRef = newType.Module.ImportReference(il2CppTypeHandleTypeRewriteContext.NewType); ctorBuilder.Emit(OpCodes.Call, assemblyContext.Imports.GetIl2CppTypeFromClass); ctorBuilder.Emit(OpCodes.Call, new MethodReference("internal_from_handle", il2CppSystemTypeRef, il2CppSystemTypeRef) { Parameters = { new ParameterDefinition(assemblyContext.Imports.IntPtr) } }); ctorBuilder.EmitLdcI4(oldType.GenericParameters.Count); ctorBuilder.Emit(OpCodes.Newarr, il2CppSystemTypeRef); for (var i = 0; i < oldType.GenericParameters.Count; i++) { ctorBuilder.Emit(OpCodes.Dup); ctorBuilder.EmitLdcI4(i); var param = oldType.GenericParameters[i]; var storeRef = new GenericInstanceType(assemblyContext.Imports.Il2CppClassPointerStore) { GenericArguments = { param } }; var fieldRef = new FieldReference(nameof(Il2CppClassPointerStore <object> .NativeClassPtr), assemblyContext.Imports.IntPtr, storeRef); ctorBuilder.Emit(OpCodes.Ldsfld, fieldRef); ctorBuilder.Emit(OpCodes.Call, assemblyContext.Imports.GetIl2CppTypeFromClass); ctorBuilder.Emit(OpCodes.Call, new MethodReference("internal_from_handle", il2CppSystemTypeRef, il2CppSystemTypeRef) { Parameters = { new ParameterDefinition(assemblyContext.Imports.IntPtr) } }); ctorBuilder.Emit(OpCodes.Stelem_Ref); } var il2CppTypeArray = new GenericInstanceType(assemblyContext.Imports.Il2CppReferenceArray) { GenericArguments = { il2CppSystemTypeRef } }; ctorBuilder.Emit(OpCodes.Newobj, new MethodReference(".ctor", assemblyContext.Imports.Void, il2CppTypeArray) { HasThis = true, Parameters = { new ParameterDefinition(new ArrayType(assemblyContext.Imports.Il2CppReferenceArray.GenericParameters[0])) } }); ctorBuilder.Emit(OpCodes.Call, new MethodReference(nameof(Type.MakeGenericType), il2CppSystemTypeRef, il2CppSystemTypeRef) { HasThis = true, Parameters = { new ParameterDefinition(il2CppTypeArray) } }); ctorBuilder.Emit(OpCodes.Call, new MethodReference(typeof(Type).GetProperty(nameof(Type.TypeHandle)) !.GetMethod !.Name, il2CppSystemTypeHandleRef, il2CppSystemTypeRef) { HasThis = true });
static bool GenericFieldComparer(FieldReference fieldReference, FieldDefinition fieldDefinition) { return(fieldDefinition == fieldReference.Resolve()); }
/// <summary>Try rewriting the field into a matching property.</summary> /// <param name="module">The assembly module containing the instruction.</param> /// <param name="instruction">The CIL instruction to rewrite.</param> /// <param name="fieldRef">The field reference.</param> /// <param name="declaringType">The type on which the field was defined.</param> /// <param name="isRead">Whether the field is being read; else it's being written to.</param> private bool TryRewriteToProperty(ModuleDefinition module, Instruction instruction, FieldReference fieldRef, TypeDefinition declaringType, bool isRead) { // get equivalent property PropertyDefinition property = declaringType.Properties.FirstOrDefault(p => p.Name == fieldRef.Name); MethodDefinition method = isRead ? property?.GetMethod : property?.SetMethod; if (method == null) { return(false); } // rewrite field to property instruction.OpCode = OpCodes.Call; instruction.Operand = module.ImportReference(method); this.Phrases.Add($"{fieldRef.DeclaringType.Name}.{fieldRef.Name} (field => property)"); return(this.MarkRewritten()); }
public bool? PopupSingleSelectDialog(string title, string fieldName, IEnumerable<string> options, FieldReference<string> selection) { throw new NotImplementedException(); }
public static void Weave(ModuleDefinition module, Dictionary <ushort, MethodDefinition> methods, TypeDefinition protocol) { if (module == null || methods.Count == 0 || protocol == null) { return; } FieldReference connectionField = module.ImportReference(ResolveHelper.ResolveField(protocol.BaseType, "m_Connection")); { //public void Register(); MethodDefinition registerMethod = ResolveHelper.ResolveMethod(protocol, "Register"); registerMethod.Body.Variables.Clear(); registerMethod.Body.Instructions.Clear(); ILProcessor registerProcessor = registerMethod.Body.GetILProcessor(); registerProcessor.Append(registerProcessor.Create(OpCodes.Nop)); foreach (ushort key in methods.Keys) { MethodDefinition method = methods[key]; if (!CheckHelper.CheckMethodFirstParams(WeaverProgram.Server, method)) { continue; } MethodDefinition protoMethodImpl = MethodFactory.CreateMethod(module, protocol, "OnProtocol_" + key, MethodAttributes.Private | MethodAttributes.HideBySig, true); protoMethodImpl.Parameters.Add(new ParameterDefinition("msg", ParameterAttributes.None, module.ImportReference(WeaverProgram.ChannelMessageType))); protoMethodImpl.Body.Variables.Add(new VariableDefinition(module.ImportReference(WeaverProgram.ByteBufferType))); { ILProcessor processor = protoMethodImpl.Body.GetILProcessor(); processor.Append(processor.Create(OpCodes.Nop)); processor.Append(processor.Create(OpCodes.Ldarg_1)); processor.Append(processor.Create(OpCodes.Ldfld, module.ImportReference(WeaverProgram.ChannelMessageBufferField))); processor.Append(processor.Create(OpCodes.Stloc_0)); List <int> indexs = new List <int>(); Collection <ParameterDefinition> parms = method.Parameters; for (int i = 0; i < parms.Count; ++i) { if (i > 0) { ParameterDefinition parm = parms[i]; TypeDefinition parmType = parm.ParameterType.Resolve(); protoMethodImpl.Body.Variables.Add(new VariableDefinition(module.ImportReference(parm.ParameterType))); int index = protoMethodImpl.Body.Variables.Count - 1; indexs.Add(index); if (parm.ParameterType.FullName == typeof(byte[]).FullName) { processor.Append(processor.Create(OpCodes.Ldloc_0)); processor.Append(processor.Create(OpCodes.Call, module.ImportReference(WeaverProgram.ByteUtilsReadMethod))); processor.Append(processor.Create(OpCodes.Stloc, index)); continue; } if (parm.ParameterType.FullName == typeof(ByteBuffer).FullName) { processor.Append(processor.Create(OpCodes.Ldloc_0)); processor.Append(processor.Create(OpCodes.Call, module.ImportReference(WeaverProgram.ByteBufferUtilsReadMethod))); processor.Append(processor.Create(OpCodes.Stloc, index)); continue; } if (parm.ParameterType.IsArray) { ArrayReadFactory.CreateMethodVariableReadInstruction(module, protoMethodImpl, processor, parmType); continue; } if (BaseTypeFactory.IsBaseType(parmType)) { processor.Append(processor.Create(OpCodes.Ldloc_0)); processor.Append(BaseTypeFactory.CreateReadInstruction(module, processor, parmType)); processor.Append(processor.Create(OpCodes.Stloc, index)); continue; } if (parmType.IsValueType) { MethodDefinition deserialize = StructMethodFactory.CreateDeserialize(module, parmType); processor.Append(processor.Create(OpCodes.Ldloca, index)); processor.Append(processor.Create(OpCodes.Initobj, module.ImportReference(parmType))); processor.Append(processor.Create(OpCodes.Ldloca, index)); processor.Append(processor.Create(OpCodes.Ldloc_0)); processor.Append(processor.Create(OpCodes.Call, module.ImportReference(deserialize))); } } } processor.Append(processor.Create(OpCodes.Ldarg_0)); processor.Append(processor.Create(OpCodes.Ldfld, connectionField)); for (int i = 0; i < indexs.Count; ++i) { processor.Append(processor.Create(OpCodes.Ldloc, indexs[i])); } processor.Append(processor.Create(OpCodes.Call, method)); processor.Append(processor.Create(OpCodes.Nop)); processor.Append(processor.Create(OpCodes.Ret)); } registerProcessor.Append(registerProcessor.Create(OpCodes.Ldarg_0)); registerProcessor.Append(registerProcessor.Create(OpCodes.Ldfld, connectionField)); registerProcessor.Append(registerProcessor.Create(OpCodes.Ldc_I4, key)); registerProcessor.Append(registerProcessor.Create(OpCodes.Ldarg_0)); registerProcessor.Append(registerProcessor.Create(OpCodes.Ldftn, protoMethodImpl)); registerProcessor.Append(registerProcessor.Create(OpCodes.Newobj, module.ImportReference(typeof(ChannelMessageDelegate).GetConstructor(new Type[] { typeof(object), typeof(IntPtr) })))); registerProcessor.Append(registerProcessor.Create(OpCodes.Callvirt, module.ImportReference(WeaverProgram.IConnectionRegisterHandlerMethod))); } registerProcessor.Append(registerProcessor.Create(OpCodes.Ret)); } { //public void Unregister(); MethodDefinition unregisterMethod = ResolveHelper.ResolveMethod(protocol, "UnRegister"); unregisterMethod.Body.Variables.Clear(); unregisterMethod.Body.Instructions.Clear(); ILProcessor unregisterProcessor = unregisterMethod.Body.GetILProcessor(); unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Nop)); foreach (short key in methods.Keys) { unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Ldarg_0)); unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Ldfld, connectionField)); unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Ldc_I4, key)); unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Callvirt, module.ImportReference(WeaverProgram.IConnectionUnregisterHandlerMethod))); } unregisterProcessor.Append(unregisterProcessor.Create(OpCodes.Ret)); } }
public Instruction Create(OpCode opcode, FieldReference field) { return(Instruction.Create(opcode, field)); }
public FieldDefinition Resolve(FieldReference field) { TypeDefinition type = Resolve(field.DeclaringType); return(GetField(type.Fields, field)); }
/// <summary> /// Creates a new <see cref="IsNullClause"/> instance. /// </summary> /// <param name="field">A reference to the field that should be null.</param> public IsNullClause(FieldReference field) { _field = field; }
/// <summary> /// Creates a property getter method implementation with the /// <paramref name="propertyType" /> as the return type. /// </summary> /// <param name="propertyType">Represents the <see cref="TypeReference">return type</see> for the getter method.</param> /// <param name="getterName">The getter method name.</param> /// <param name="attributes">The method attributes associated with the getter method.</param> /// <param name="backingField">The field that will store the instance that the getter method will retrieve.</param> /// <returns>A <see cref="MethodDefinition" /> representing the getter method itself.</returns> private static MethodDefinition AddPropertyGetter(TypeReference propertyType, string getterName, MethodAttributes attributes, FieldReference backingField) { var getter = new MethodDefinition(getterName, attributes, propertyType) { IsPublic = true, ImplAttributes = MethodImplAttributes.Managed | MethodImplAttributes.IL }; var IL = getter.Body.GetILProcessor(); IL.Emit(OpCodes.Ldarg_0); IL.Emit(OpCodes.Ldfld, backingField); IL.Emit(OpCodes.Ret); return(getter); }
public FieldAccessorReplacementFactory(FieldReference field, ReturnStatement firstStatement, ReplacementRegistry registry) { this.field = field; this.firstStatement = firstStatement; this.registry = registry; }
public static bool RequiresReflectionMethodBodyScannerForAccess(LinkContext context, FieldReference field) { FieldDefinition?fieldDefinition = context.TryResolve(field); if (fieldDefinition == null) { return(false); } return(context.Annotations.FlowAnnotations.RequiresDataFlowAnalysis(fieldDefinition)); }
protected override void RewriteLoadField(IOperation op) { var fieldReference = op.Value as IFieldReference; Contract.Assert(fieldReference != null); if (fieldReference.ContainingType.IsEnum == false) { var loadFieldCounterReference = new FieldReference() { Name = base.host.NameTable.GetNameFor(MemberHelper.GetMemberSignature(fieldReference, NameFormattingOptions.None) + "$$loadCount"), Type = base.host.PlatformType.SystemInt64, InternFactory = base.host.InternFactory, ContainingType = fieldReference.ContainingType, IsStatic = false }; base.generator.Emit(OperationCode.Dup); // load "this" onto stack base.generator.Emit(OperationCode.Dup); // load "this" onto stack base.generator.Emit(OperationCode.Ldfld, loadFieldCounterReference); // load field$$loadCount onto stack base.generator.Emit(OperationCode.Ldc_I4_1); // load 1 onto stack base.generator.Emit(OperationCode.Conv_I8); // convert to int64 base.generator.Emit(OperationCode.Add); // add field$loadCount + 1 base.generator.Emit(OperationCode.Stfld, loadFieldCounterReference); // store result of add to field$$loadCount } // now do the actual ldfld base.RewriteLoadField(op); }
public FieldReference GetBindablePropertyFieldReference(string value, ModuleDefinition module, BaseNode node) { FieldReference bpRef = null; string typeName = null, propertyName = null; var parts = value.Split('.'); if (parts.Length == 1) { var parent = node.Parent?.Parent as IElementNode; if ((node.Parent as ElementNode)?.XmlType.NamespaceUri == XamlParser.XFUri && ((node.Parent as ElementNode)?.XmlType.Name == "Setter" || (node.Parent as ElementNode)?.XmlType.Name == "PropertyCondition")) { if (parent.XmlType.NamespaceUri == XamlParser.XFUri && (parent.XmlType.Name == "Trigger" || parent.XmlType.Name == "DataTrigger" || parent.XmlType.Name == "MultiTrigger" || parent.XmlType.Name == "Style")) { var ttnode = (parent as ElementNode).Properties [new XmlName("", "TargetType")]; if (ttnode is ValueNode) { typeName = (ttnode as ValueNode).Value as string; } else if (ttnode is IElementNode) { typeName = ((ttnode as IElementNode).CollectionItems.FirstOrDefault() as ValueNode)?.Value as string ?? ((ttnode as IElementNode).Properties [new XmlName("", "TypeName")] as ValueNode)?.Value as string; } } } else if ((node.Parent as ElementNode)?.XmlType.NamespaceUri == XamlParser.XFUri && (node.Parent as ElementNode)?.XmlType.Name == "Trigger") { typeName = ((node.Parent as ElementNode).Properties [new XmlName("", "TargetType")] as ValueNode).Value as string; } propertyName = parts [0]; } else if (parts.Length == 2) { typeName = parts [0]; propertyName = parts [1]; } else { throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(BindableProperty)}", node); } if (typeName == null || propertyName == null) { throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(BindableProperty)}", node); } var typeRef = XmlTypeExtensions.GetTypeReference(typeName, module, node); if (typeRef == null) { throw new XamlParseException($"Can't resolve {typeName}", node); } bpRef = GetBindablePropertyFieldReference(typeRef, propertyName, module); if (bpRef == null) { throw new XamlParseException($"Can't resolve {propertyName} on {typeRef.Name}", node); } return(bpRef); }
public IFieldReference Map(Microsoft.CodeAnalysis.CSharp.Symbols.FieldSymbol fieldSymbol) { IFieldReference fr = null; if (!fieldSymbolCache.TryGetValue(fieldSymbol, out fr)) { fr = new FieldReference() { ContainingType = Map(fieldSymbol.ContainingType), InternFactory = this.host.InternFactory, Name = this.nameTable.GetNameFor(fieldSymbol.Name), Type = Map(fieldSymbol.Type), }; this.fieldSymbolCache[fieldSymbol] = fr; } return fr; }
static LambdaJobDescriptionConstruction AnalyzeLambdaJobStatement(MethodDefinition method, Instruction getEntitiesOrJobInstruction, int lambdaNumber) { List <InvokedConstructionMethod> modifiers = new List <InvokedConstructionMethod>(); Instruction cursor = getEntitiesOrJobInstruction; var expectedPreviousMethodPushingDescription = getEntitiesOrJobInstruction; while (true) { cursor = FindNextConstructionMethod(method, cursor); var mr = cursor?.Operand as MethodReference; if (mr.Name == nameof(LambdaJobDescriptionExecutionMethods.Schedule) || mr.Name == nameof(LambdaJobDescriptionExecutionMethods.ScheduleParallel) || mr.Name == nameof(LambdaJobDescriptionExecutionMethods.Run)) { var withNameModifier = modifiers.FirstOrDefault(m => m.MethodName == nameof(LambdaJobDescriptionConstructionMethods.WithName)); var givenName = withNameModifier?.Arguments.OfType <string>().Single(); var lambdaJobName = givenName ?? $"{method.Name}_LambdaJob{lambdaNumber}"; if (givenName != null && !VerifyLambdaName(givenName)) { UserError.DC0043(method, givenName, getEntitiesOrJobInstruction).Throw(); } var hasWithStructuralChangesModifier = modifiers.Any(m => m.MethodName == nameof(LambdaJobDescriptionConstructionMethods.WithStructuralChanges)); if (hasWithStructuralChangesModifier && mr.Name != nameof(LambdaJobDescriptionExecutionMethods.Run)) { UserError.DC0028(method, getEntitiesOrJobInstruction).Throw(); } FieldReference storeQueryInField = null; foreach (var modifier in modifiers) { if (modifier.MethodName == nameof(LambdaJobQueryConstructionMethods.WithStoreEntityQueryInField)) { var instructionThatPushedField = CecilHelpers.FindInstructionThatPushedArg(method, 1, modifier.InstructionInvokingMethod); storeQueryInField = instructionThatPushedField.Operand as FieldReference; if (instructionThatPushedField.OpCode != OpCodes.Ldflda || storeQueryInField == null || instructionThatPushedField.Previous.OpCode != OpCodes.Ldarg_0) { UserError.DC0031(method, getEntitiesOrJobInstruction).Throw(); } } } LambdaJobDescriptionKind FindLambdaDescriptionKind() { switch (((MethodReference)getEntitiesOrJobInstruction.Operand).Name) { case EntitiesGetterName: return(LambdaJobDescriptionKind.Entities); case JobGetterName: return(LambdaJobDescriptionKind.Job); #if ENABLE_DOTS_COMPILER_CHUNKS case "get_" + nameof(JobComponentSystem.Chunks): return(LambdaJobDescriptionKind.Chunk); #endif default: throw new ArgumentOutOfRangeException(); } } if (modifiers.All(m => m.MethodName != nameof(LambdaForEachDescriptionConstructionMethods.ForEach) && m.MethodName != nameof(LambdaSingleJobDescriptionConstructionMethods.WithCode))) { DiagnosticMessage MakeDiagnosticMessage() { switch (FindLambdaDescriptionKind()) { case LambdaJobDescriptionKind.Entities: return(UserError.DC0006(method, getEntitiesOrJobInstruction)); case LambdaJobDescriptionKind.Job: return(UserError.DC0017(method, getEntitiesOrJobInstruction)); case LambdaJobDescriptionKind.Chunk: return(UserError.DC0018(method, getEntitiesOrJobInstruction)); default: throw new ArgumentOutOfRangeException(); } } MakeDiagnosticMessage().Throw(); } if (method.DeclaringType.HasGenericParameters) { UserError.DC0025($"Entities.ForEach cannot be used in system {method.DeclaringType.Name} as Entities.ForEach in generic system types are not supported.", method, getEntitiesOrJobInstruction).Throw(); } var withCodeInvocationInstruction = modifiers .Single(m => m.MethodName == nameof(LambdaForEachDescriptionConstructionMethods.ForEach) || m.MethodName == nameof(LambdaSingleJobDescriptionConstructionMethods.WithCode)) .InstructionInvokingMethod; return(new LambdaJobDescriptionConstruction() { Kind = FindLambdaDescriptionKind(), InvokedConstructionMethods = modifiers, WithCodeInvocationInstruction = withCodeInvocationInstruction, ScheduleOrRunInvocationInstruction = cursor, LambdaJobName = lambdaJobName, ChainInitiatingInstruction = getEntitiesOrJobInstruction, ContainingMethod = method, DelegateProducingSequence = AnalyzeForEachInvocationInstruction(method, withCodeInvocationInstruction), WithStructuralChanges = hasWithStructuralChangesModifier, StoreQueryInField = (storeQueryInField != null) ? storeQueryInField.Resolve() : null }); } var instructions = mr.Parameters.Skip(1) .Select(p => OperandObjectFor(CecilHelpers.FindInstructionThatPushedArg(method, p.Index, cursor))).ToArray(); var invokedConstructionMethod = new InvokedConstructionMethod(mr.Name, (mr as GenericInstanceMethod)?.GenericArguments.ToArray() ?? Array.Empty <TypeReference>(), instructions, cursor); var allowDynamicValue = method.Module.ImportReference(typeof(AllowDynamicValueAttribute)); for (int i = 0; i != invokedConstructionMethod.Arguments.Length; i++) { if (invokedConstructionMethod.Arguments[i] != null) { continue; } var inbovokedForEachMethod = mr.Resolve(); var methodDefinitionParameter = inbovokedForEachMethod.Parameters[i + 1]; if (!methodDefinitionParameter.CustomAttributes.Any(c => c.AttributeType.TypeReferenceEquals(allowDynamicValue))) { UserError.DC0008(method, cursor, mr).Throw(); } } if (modifiers.Any(m => m.MethodName == mr.Name) && !HasAllowMultipleAttribute(mr.Resolve())) { UserError.DC0009(method, cursor, mr).Throw(); } var findInstructionThatPushedArg = CecilHelpers.FindInstructionThatPushedArg(method, 0, cursor); if (cursor == null || findInstructionThatPushedArg != expectedPreviousMethodPushingDescription) { UserError.DC0007(method, cursor).Throw(); } expectedPreviousMethodPushingDescription = cursor; modifiers.Add(invokedConstructionMethod); } }
/// <summary> /// Creates a new <see cref="SortExpression"/> instance. /// </summary> /// <param name="field"> /// Value for the <see cref="SortExpression.Field"/> property. /// </param> public SortExpression(FieldReference field) { _field = field; }
public static void WriteOperand(ITextOutput writer, object operand) { if (operand == null) { throw new ArgumentNullException("operand"); } Instruction targetInstruction = operand as Instruction; if (targetInstruction != null) { WriteOffsetReference(writer, targetInstruction); return; } Instruction[] targetInstructions = operand as Instruction[]; if (targetInstructions != null) { WriteLabelList(writer, targetInstructions); return; } VariableReference variableRef = operand as VariableReference; if (variableRef != null) { if (string.IsNullOrEmpty(variableRef.Name)) { writer.WriteReference(variableRef.Index.ToString(), variableRef); } else { writer.WriteReference(Escape(variableRef.Name), variableRef); } return; } ParameterReference paramRef = operand as ParameterReference; if (paramRef != null) { if (string.IsNullOrEmpty(paramRef.Name)) { writer.WriteReference(paramRef.Index.ToString(), paramRef); } else { writer.WriteReference(Escape(paramRef.Name), paramRef); } return; } MethodReference methodRef = operand as MethodReference; if (methodRef != null) { methodRef.WriteTo(writer); return; } TypeReference typeRef = operand as TypeReference; if (typeRef != null) { typeRef.WriteTo(writer, ILNameSyntax.TypeName); return; } FieldReference fieldRef = operand as FieldReference; if (fieldRef != null) { fieldRef.WriteTo(writer); return; } string s = operand as string; if (s != null) { writer.Write("\"" + NRefactory.CSharp.OutputVisitor.ConvertString(s) + "\""); } else if (operand is char) { writer.Write(((int)(char)operand).ToString()); } else if (operand is float) { float val = (float)operand; if (val == 0) { writer.Write("0.0"); } else if (float.IsInfinity(val) || float.IsNaN(val)) { byte[] data = BitConverter.GetBytes(val); writer.Write('('); for (int i = 0; i < data.Length; i++) { if (i > 0) { writer.Write(' '); } writer.Write(data[i].ToString("X2")); } writer.Write(')'); } else { writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture)); } } else if (operand is double) { double val = (double)operand; if (val == 0) { writer.Write("0.0"); } else if (double.IsInfinity(val) || double.IsNaN(val)) { byte[] data = BitConverter.GetBytes(val); writer.Write('('); for (int i = 0; i < data.Length; i++) { if (i > 0) { writer.Write(' '); } writer.Write(data[i].ToString("X2")); } writer.Write(')'); } else { writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture)); } } else if (operand is bool) { writer.Write((bool)operand ? "true" : "false"); } else { s = ToInvariantCultureString(operand); writer.Write(s); } }
public Instruction Create(OpCode opcode, FieldReference field) { return Instruction.Create (opcode, field); }
static string FormatInstruction(Instruction instr) { switch (instr.OpCode.FlowControl) { case FlowControl.Branch: case FlowControl.Cond_Branch: if (instr.Operand is Instruction target) { return($"{instr.OpCode.ToString ()} il_{target.Offset.ToString ("x")}"); } break; } switch (instr.OpCode.Code) { case Code.Ldc_I4: if (instr.Operand is int ivalue) { return($"{instr.OpCode.ToString ()} 0x{ivalue.ToString ("x")}"); } throw new NotImplementedException(instr.Operand.GetType().ToString()); case Code.Ldc_I4_S: if (instr.Operand is sbyte bvalue) { return($"{instr.OpCode.ToString ()} 0x{bvalue.ToString ("x")}"); } throw new NotImplementedException(instr.Operand.GetType().ToString()); case Code.Ldc_I8: if (instr.Operand is long lvalue) { return($"{instr.OpCode.ToString ()} 0x{lvalue.ToString ("x")}"); } throw new NotImplementedException(instr.Operand.GetType().ToString()); case Code.Ldc_R4: if (instr.Operand is float fvalue) { return($"{instr.OpCode.ToString ()} {fvalue.ToString ()}"); } throw new NotImplementedException(instr.Operand.GetType().ToString()); case Code.Ldc_R8: if (instr.Operand is double dvalue) { return($"{instr.OpCode.ToString ()} {dvalue.ToString ()}"); } throw new NotImplementedException(instr.Operand.GetType().ToString()); case Code.Ldstr: if (instr.Operand is string svalue) { return($"{instr.OpCode.ToString ()} '{svalue}'"); } throw new NotImplementedException(instr.Operand.GetType().ToString()); default: { string operandString = null; switch (instr.OpCode.OperandType) { case OperandType.InlineField: case OperandType.InlineMethod: case OperandType.InlineType: case OperandType.InlineTok: operandString = instr.Operand switch { FieldReference fieldRef => fieldRef.FullName, MethodReference methodRef => methodRef.FullName, TypeReference typeRef => typeRef.FullName, _ => null }; break; } if (operandString != null) { return($"{instr.OpCode.ToString ()} {operandString}"); } else { return(instr.OpCode.ToString()); } } } }
/// <summary> /// 为类型注入TryInitHotFix函数 /// </summary> /// <param name="typeDefinition"></param> private static MethodDefinition InjectTryInitHotFixFunc(TypeDefinition typeDefinition, FieldReference hotfixStateField) { string funcName = "TryInitHotFix"; foreach (var method in typeDefinition.Methods) { if (method.Name == funcName) { typeDefinition.Methods.Remove(method); break; } } MethodDefinition tryInitHotFixMethod = new MethodDefinition(funcName, MethodAttributes.Static | MethodAttributes.Private, typeRef_bool); tryInitHotFixMethod.Parameters.Add(new ParameterDefinition("luaModuleName", ParameterAttributes.None, typeRef_string)); tryInitHotFixMethod.Body = new Mono.Cecil.Cil.MethodBody(tryInitHotFixMethod); tryInitHotFixMethod.Body.MaxStackSize = 2; tryInitHotFixMethod.Body.Variables.Add(new VariableDefinition(typeRef_bool)); tryInitHotFixMethod.Body.Variables.Add(new VariableDefinition(typeRef_bool)); // 开始注入IL代码 var ilProcessor = tryInitHotFixMethod.Body.GetILProcessor(); tryInitHotFixMethod.Body.Instructions.Add(ilProcessor.Create(OpCodes.Ret)); var insertPoint = tryInitHotFixMethod.Body.Instructions[0]; // 设置一些标签用于语句跳转 var label1 = ilProcessor.Create(OpCodes.Nop); var label2 = ilProcessor.Create(OpCodes.Ldloc_0); var label3 = ilProcessor.Create(OpCodes.Ldc_I4_1); var label4 = ilProcessor.Create(OpCodes.Stsfld, hotfixStateField); var label5 = ilProcessor.Create(OpCodes.Ldloc_1); //if (m_hotFixState == 0) ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldsfld, hotfixStateField)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Brfalse, label1)); //flag = (HotFixTestScript.m_hotfixState == ObjectLuaHotFixState.InitAvialable); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldsfld, hotfixStateField)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_2)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ceq)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label2)); //flag = LuaManager.TryInitHotfixForObj(typeof(HotFixTestScript), luaModuleName); ilProcessor.InsertBefore(insertPoint, label1);//OpCodes.Nop ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldtoken, typeDefinition)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Call, methodRef_Type_GetTypeFromHandle)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldarg_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Call, methodRef_LuaManager_TryInitHotFix)); //HotFixTestScript.m_hotfixState = ((!flag) ? ObjectLuaHotFixState.InitUnavialable : ObjectLuaHotFixState.InitAvialable); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldloc_0)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Brfalse, label3)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Ldc_I4_2)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label4)); ilProcessor.InsertBefore(insertPoint, label3); //OpCodes.Ldc_I4_1 ilProcessor.InsertBefore(insertPoint, label4); //OpCodes.Stsfld, hotfixState //return flag ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Nop)); ilProcessor.InsertBefore(insertPoint, label2); //OpCodes.Ldloc_0 ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Stloc_1)); ilProcessor.InsertBefore(insertPoint, ilProcessor.Create(OpCodes.Br, label5)); ilProcessor.InsertBefore(insertPoint, label5);//OpCodes.Ldloc_1 typeDefinition.Methods.Add(tryInitHotFixMethod); return(tryInitHotFixMethod); }
public MethodReference GetOrCreateGetPropertyChangedMethod(AssemblyDefinition assembly, TypeDefinition typeDefinition, FieldReference propertyChangedField) { var methodReference = GetGetPropertyChangedMethod(assembly, typeDefinition); if (methodReference != null) { return(methodReference); } var method = new MethodDefinition("GetPropertyChanged", MethodAttributes.Family, propertyChangedField.FieldType); var bodyInstructions = method.Body.Instructions; // return PropertyChanged bodyInstructions.Add(Instruction.Create(OpCodes.Ldarg_0)); bodyInstructions.Add(Instruction.Create(OpCodes.Ldfld, propertyChangedField)); bodyInstructions.Add(Instruction.Create(OpCodes.Ret)); typeDefinition.Methods.Add(method); return(method); }
public void Emit(OpCode opcode, FieldReference field) { Append(Create(opcode, field)); }
public MethodEmitter(InstrumentationContext context, FieldReference field) { _context = context; _activatorField = FieldReferenceFor(field); }
public static void Compile(ByteCodeCompiler bcc, ParserContext parser, ByteBuffer buffer, Increment increment, bool outputUsed) { if (!outputUsed) { throw new Exception("This should have been optimized into a += or -="); } if (increment.Root is Variable) { // OpCode re-use be damned. This should be not one, but two top-level op codes. // INCREMENT_INLINE and INCREMENT_POP (depending on whether outputUsed is true) // In fact, the code here in its current form is actually WRONG because someString++ will have // a '1' appended to it when it really should be an error if the variable is not an integer. // Same for the others below. Ideally the DUPLICATE_STACK_TOP op should be removed. Variable variable = (Variable)increment.Root; VariableId varId = variable.VarId; bool isClosureVar = varId.UsedByClosure; int scopeId = isClosureVar ? varId.ClosureID : varId.ID; bcc.CompileExpression(parser, buffer, increment.Root, true); if (increment.IsPrefix) { buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1)); buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION); buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1); buffer.Add(variable.FirstToken, isClosureVar ? OpCode.ASSIGN_CLOSURE : OpCode.ASSIGN_LOCAL, scopeId); } else { buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1); buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1)); buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION); buffer.Add(variable.FirstToken, isClosureVar ? OpCode.ASSIGN_CLOSURE : OpCode.ASSIGN_LOCAL, scopeId); } } else if (increment.Root is BracketIndex) { BracketIndex bracketIndex = (BracketIndex)increment.Root; bcc.CompileExpression(parser, buffer, bracketIndex.Root, true); bcc.CompileExpression(parser, buffer, bracketIndex.Index, true); buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 2); buffer.Add(bracketIndex.BracketToken, OpCode.INDEX); if (increment.IsPrefix) { buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1)); buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION); buffer.Add(increment.IncrementToken, OpCode.ASSIGN_INDEX, 1); } else { buffer.Add(increment.IncrementToken, OpCode.STACK_INSERTION_FOR_INCREMENT); buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1)); buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION); buffer.Add(increment.IncrementToken, OpCode.ASSIGN_INDEX, 0); } } else if (increment.Root is DotField) { DotField dotStep = (DotField)increment.Root; bcc.CompileExpression(parser, buffer, dotStep.Root, true); buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1); int nameId = parser.GetId(dotStep.FieldToken.Value); int localeScopedNameId = nameId * parser.GetLocaleCount() + parser.GetLocaleId(dotStep.Owner.FileScope.CompilationScope.Locale); int originClassId = increment.ClassOwner == null ? -1 : increment.ClassOwner.ClassID; int originAssemblyId = increment.CompilationScope.ScopeNumId; buffer.Add( dotStep.DotToken, OpCode.DEREF_DOT, nameId, localeScopedNameId, originClassId, increment.CompilationScope.ScopeNumId, -1, 0); if (increment.IsPrefix) { buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1)); buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION); buffer.Add(increment.IncrementToken, OpCode.ASSIGN_FIELD, nameId, 1, localeScopedNameId, originClassId, originAssemblyId, -1, 0); } else { buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 2); buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1)); buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION); buffer.Add(increment.IncrementToken, OpCode.ASSIGN_FIELD, nameId, 0, localeScopedNameId, originClassId, originAssemblyId, -1, 0); buffer.Add(increment.IncrementToken, OpCode.STACK_SWAP_POP); } } else if (increment.Root is FieldReference) { FieldReference fr = (FieldReference)increment.Root; bool isStatic = fr.Field.Modifiers.HasStatic; ClassDefinition cd = (ClassDefinition)fr.Field.Owner; int memberId = isStatic ? fr.Field.StaticMemberID : fr.Field.MemberID; bcc.CompileExpression(parser, buffer, fr, true); if (increment.IsPrefix) { buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1)); buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION); buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1); } else { buffer.Add(increment.IncrementToken, OpCode.DUPLICATE_STACK_TOP, 1); buffer.Add(increment.IncrementToken, OpCode.LITERAL, parser.GetIntConstant(1)); buffer.Add(increment.IncrementToken, OpCode.BINARY_OP, increment.IsIncrement ? (int)Ops.ADDITION : (int)Ops.SUBTRACTION); } Token token = increment.IsPrefix ? increment.FirstToken : fr.FirstToken; if (isStatic) { buffer.Add(token, OpCode.ASSIGN_STATIC_FIELD, ((ClassDefinition)fr.Field.Owner).ClassID, memberId); } else { buffer.Add(token, OpCode.ASSIGN_THIS_FIELD, memberId); } } else { throw new ParserException(increment.IncrementToken, "Cannot apply " + (increment.IsIncrement ? "++" : "--") + " to this sort of expression."); } }
MethodDefinition CreateEventMethod(string methodName, MethodReference delegateMethodReference, FieldReference propertyChangedField) { const MethodAttributes Attributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Final | MethodAttributes.SpecialName | MethodAttributes.NewSlot | MethodAttributes.Virtual; var method = new MethodDefinition(methodName, Attributes, ModuleDefinition.TypeSystem.Void); method.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, PropChangedHandlerReference)); var handlerVariable0 = new VariableDefinition(PropChangedHandlerReference); method.Body.Variables.Add(handlerVariable0); var handlerVariable1 = new VariableDefinition(PropChangedHandlerReference); method.Body.Variables.Add(handlerVariable1); var handlerVariable2 = new VariableDefinition(PropChangedHandlerReference); method.Body.Variables.Add(handlerVariable2); var loopBegin = Instruction.Create(OpCodes.Ldloc, handlerVariable0); method.Body.Instructions.Append( Instruction.Create(OpCodes.Ldarg_0), Instruction.Create(OpCodes.Ldfld, propertyChangedField), Instruction.Create(OpCodes.Stloc, handlerVariable0), loopBegin, Instruction.Create(OpCodes.Stloc, handlerVariable1), Instruction.Create(OpCodes.Ldloc, handlerVariable1), Instruction.Create(OpCodes.Ldarg_1), Instruction.Create(OpCodes.Call, delegateMethodReference), Instruction.Create(OpCodes.Castclass, PropChangedHandlerReference), Instruction.Create(OpCodes.Stloc, handlerVariable2), Instruction.Create(OpCodes.Ldarg_0), Instruction.Create(OpCodes.Ldflda, propertyChangedField), Instruction.Create(OpCodes.Ldloc, handlerVariable2), Instruction.Create(OpCodes.Ldloc, handlerVariable1), Instruction.Create(OpCodes.Call, InterlockedCompareExchangeForPropChangedHandler), Instruction.Create(OpCodes.Stloc, handlerVariable0), Instruction.Create(OpCodes.Ldloc, handlerVariable0), Instruction.Create(OpCodes.Ldloc, handlerVariable1), Instruction.Create(OpCodes.Bne_Un_S, loopBegin), // go to begin of loop Instruction.Create(OpCodes.Ret)); method.Body.InitLocals = true; method.Body.OptimizeMacros(); return(method); }
private bool CheckJavaPath() { //Check config if (this.Engine.JreManager.JavaRuntime != null) { return true; } var javaRuntimeEntitiesKP = new Dictionary<string, JavaRuntimeEntity>(); foreach (var availableJre in this.Engine.JreManager.AvailableJavaRuntimes) { javaRuntimeEntitiesKP.Add(availableJre.Key, availableJre.Value); } if (javaRuntimeEntitiesKP.Keys.Count != 0) { var field = new FieldReference<string>(javaRuntimeEntitiesKP.Keys.First()); var result = this.Engine.UiControl.PopupSingleSelectDialog(TranslationManager.GetManager.Localize("JavaSelectWindowTitle", "Select a Java"), TranslationManager.GetManager.Localize("JavaSelectField", "Available Java exe:"), javaRuntimeEntitiesKP.Keys, field); if (result == null || result.Value == false) { return false; } else { this.Engine.JreManager.JavaRuntime = javaRuntimeEntitiesKP[field.Value]; return true; } } while (this.Engine.JreManager.JavaRuntime == null) { TerminologyLogger.GetLogger().Warn("Java path is empty. Try to receive from user.."); var field = new FieldReference<string>(string.Empty); var result = this.Engine.UiControl.PopupSingleLineInputDialog(TranslationManager.GetManager.Localize("JavaInputWindowTitle", "Input a Java exe"), TranslationManager.GetManager.Localize("JavaInputField", "Java(not javaw) exe path:"), field); if (result == null || result.Value == false) { { try { var javaBinFolder = new DirectoryInfo(field.Value); var jre = new JavaRuntimeEntity { JavaDetails = JavaUtils.GetJavaDetails(Path.Combine(javaBinFolder.FullName, "java.exe")), JavaPath = Path.Combine(javaBinFolder.FullName, "java.exe"), JavaWPath = Path.Combine(javaBinFolder.FullName, "javaw.exe") }; if (JavaUtils.IsJavaRuntimeValid(jre)) { this.Engine.JreManager.JavaRuntime = jre; } else { continue; } } catch (Exception ex) { TerminologyLogger.GetLogger() .ErrorFormat($"cannot resolve java exe path through user input. Caused by:{ex.Message}"); continue; } break; } } else { return false; } } return true; }
public FieldAssignmentReplacementRegistrar(FieldReference field, ReplacementRegistry registry) { this.field = field; this.registry = registry; }
public FieldReference Import(FieldReference field) { return m_importer.ImportFieldReference (field, this); }
public bool? PopupSingleLineInputDialog(string title, string fieldName, FieldReference<string> content) { bool? result = null; this.Dispatcher.Invoke(() => { var inputWindow = new SingleLineInputWindow(null, title, fieldName, content); result = inputWindow.ShowDialog(); }); return result; }
private void Emit(OpCode opCode, FieldReference fieldReference) { Labelize(body.Create(opCode, fieldReference)); }
public Instruction Create(OpCode opcode, FieldReference field) { if (opcode.OperandType != OperandType.InlineField && opcode.OperandType != OperandType.InlineTok) throw new ArgumentException ("opcode"); return FinalCreate (opcode, field); }
public FieldReference ImportFieldReference(FieldReference field, ImportContext context) { return field; }
public FieldDefinition TryResolve(FieldReference fieldReference) { throw null; }
public bool? PopupSingleSelectDialog(string title, string fieldName, IEnumerable<string> options, FieldReference<string> selection) { bool? result = false; this.Dispatcher.Invoke(() => { var selectWindow = new SingleSelectWindow(null, title, fieldName, options, selection); result = selectWindow.ShowDialog(); }); return result; }
private void InitializeInStaticConstructor(ICommonAssembly assembly, ICommonType frameworkElementType, ICommonProperty property, FieldReference field) { var staticConstructor = frameworkElementType.MonoCecil.GetStaticConstructor(); if (staticConstructor == null) { staticConstructor = new MethodDefinition(".cctor", MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.Static, assembly.MonoCecil.MainModule.TypeSystem.Void); staticConstructor.Body.Instructions.Add(Instruction.Create(OpCodes.Ret)); frameworkElementType.MonoCecil.Methods.Add(staticConstructor); } staticConstructor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldstr, property.Name)); staticConstructor.Body.Instructions.Insert(1, Instruction.Create(OpCodes.Ldtoken, property.MonoCecil.PropertyType)); staticConstructor.Body.Instructions.Insert(2, Instruction.Create(OpCodes.Call, getTypeFromHandleMethod.GetValue(assembly))); staticConstructor.Body.Instructions.Insert(3, Instruction.Create(OpCodes.Ldtoken, frameworkElementType.MonoCecil)); staticConstructor.Body.Instructions.Insert(4, Instruction.Create(OpCodes.Call, getTypeFromHandleMethod.GetValue(assembly))); staticConstructor.Body.Instructions.Insert(5, Instruction.Create(OpCodes.Call, registerMethod.GetValue(assembly))); staticConstructor.Body.Instructions.Insert(6, Instruction.Create(OpCodes.Stsfld, field)); }
protected override void RewriteStoreField(IOperation op) { var fieldReference = op.Value as IFieldReference; Contract.Assert(fieldReference != null); if (fieldReference.ContainingType.IsEnum == false) { var storeFieldCounter = new FieldReference() { Name = base.host.NameTable.GetNameFor(MemberHelper.GetMemberSignature(fieldReference, NameFormattingOptions.None) + "$$storeCount"), Type = base.host.PlatformType.SystemInt64, InternFactory = base.host.InternFactory, ContainingType = fieldReference.ContainingType, IsStatic = false }; // save the variable that is on the top of stack var name = "XXX_" + fieldReference.Name.ToString(); var def = new LocalDefinition { Name = base.host.NameTable.GetNameFor(name), Type = fieldReference.Type }; if (base.methodBody.LocalVariables == null) base.methodBody.LocalVariables = new List<ILocalDefinition>(1); base.methodBody.LocalVariables.Add(def); // store top-of-stack into a local. This is the value the stfld uses generator.Emit(OperationCode.Stloc, def); base.generator.Emit(OperationCode.Dup); // load "this" onto stack base.generator.Emit(OperationCode.Dup); // load "this" onto stack base.generator.Emit(OperationCode.Ldfld, storeFieldCounter); // load field$$storeCount onto stack base.generator.Emit(OperationCode.Ldc_I4_1); // load 1 onto stack base.generator.Emit(OperationCode.Conv_I8); // convert to int64 base.generator.Emit(OperationCode.Add); // add field$storeCount + 1 base.generator.Emit(OperationCode.Stfld, storeFieldCounter); // store result of add to field$$storeCount // restore the var we saved from the local generator.Emit(OperationCode.Ldloc, def); } // now do the original stfld base.RewriteStoreField(op); }
private void GenerateGetMethodBody(ICommonAssembly assembly, ICommonType frameworkElementType, PropertyDefinition property, FieldReference field) { log.Info("Generate get method body..."); if (property.GetMethod == null) { log.Debug($"Create get accessor method for property '{property.Name}'"); var getMethod = new MethodDefinition($"get_{property.Name}", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, property.PropertyType); property.GetMethod = getMethod; frameworkElementType.MonoCecil.Methods.Add(getMethod); } property.GetMethod.Body.Variables.Clear(); property.GetMethod.Body.Instructions.Clear(); property.GetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0)); property.GetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldsfld, field)); property.GetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Call, getValueMethod.GetValue(assembly))); property.GetMethod.Body.Instructions.Add(Instruction.Create(property.PropertyType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, property.PropertyType)); property.GetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ret)); property.GetMethod.RemoveAttributes <CompilerGeneratedAttribute>(); log.Info("Get method body was generated"); }
public Instruction Emit (OpCode opcode, FieldReference field) { Instruction instr = Create (opcode, field); Append (instr); return instr; }
private void GenerateSetMethodBody(ICommonAssembly assembly, ICommonType frameworkElementType, PropertyDefinition property, FieldReference field) { log.Info("Generate set method body..."); if (property.SetMethod == null) { log.Debug($"Create set accessor method for property '{property.Name}'"); var setMethod = new MethodDefinition($"set_{property.Name}", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, assembly.MonoCecil.MainModule.TypeSystem.Void); setMethod.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, property.PropertyType)); property.SetMethod = setMethod; frameworkElementType.MonoCecil.Methods.Add(setMethod); } property.GetMethod.Body.Variables.Clear(); property.SetMethod.Body.Instructions.Clear(); property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0)); property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldsfld, field)); property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_1)); if (property.PropertyType.IsValueType) { property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Box, property.PropertyType)); } property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Call, setValueMethod.GetValue(assembly))); property.SetMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ret)); property.SetMethod.RemoveAttributes <CompilerGeneratedAttribute>(); log.Info("Set method body was generated"); }
public static FieldReference ChangeDeclaringType( this FieldReference fieldDef, TypeReference typeRef) { return(new FieldReference( fieldDef.Name, fieldDef.FieldType, typeRef)); }
public static void EmitPointerToObject(this ILProcessor body, TypeReference originalReturnType, TypeReference convertedReturnType, TypeRewriteContext enclosingType, Instruction loadPointer, bool extraDerefForNonValueTypes, bool unboxValueType) { // input stack: not used // output stack: converted result if (originalReturnType is GenericParameter) { EmitPointerToObjectGeneric(body, originalReturnType, convertedReturnType, enclosingType, loadPointer, extraDerefForNonValueTypes, unboxValueType); return; } var imports = enclosingType.AssemblyContext.Imports; if (originalReturnType.FullName == "System.Void") { // do nothing } else if (originalReturnType.IsValueType) { if (convertedReturnType.IsValueType) { body.Append(loadPointer); if (unboxValueType) { body.Emit(OpCodes.Call, imports.ObjectUnbox); } body.Emit(OpCodes.Ldobj, convertedReturnType); } else { if (!unboxValueType) { var classPointerTypeRef = new GenericInstanceType(imports.Il2CppClassPointerStore) { GenericArguments = { convertedReturnType } }; var classPointerFieldRef = new FieldReference(nameof(Il2CppClassPointerStore <int> .NativeClassPtr), imports.IntPtr, classPointerTypeRef); body.Emit(OpCodes.Ldsfld, enclosingType.NewType.Module.ImportReference(classPointerFieldRef)); body.Append(loadPointer); body.Emit(OpCodes.Call, imports.ObjectBox); } else // already boxed { body.Append(loadPointer); } body.Emit(OpCodes.Newobj, new MethodReference(".ctor", imports.Void, convertedReturnType) { Parameters = { new ParameterDefinition(imports.IntPtr) }, HasThis = true }); } } else if (originalReturnType.FullName == "System.String") { body.Append(loadPointer); if (extraDerefForNonValueTypes) { body.Emit(OpCodes.Ldind_I); } body.Emit(OpCodes.Call, imports.StringFromNative); } else if (originalReturnType.IsArray && originalReturnType.GetElementType().IsGenericParameter) { body.Append(loadPointer); var actualReturnType = imports.Il2CppArrayBaseSelfSubst; var methodRef = new MethodReference(nameof(Il2CppArrayBase <int> .WrapNativeGenericArrayPointer), actualReturnType, convertedReturnType) { HasThis = false, Parameters = { new ParameterDefinition(imports.IntPtr) } }; body.Emit(OpCodes.Call, methodRef); } else { var createRealObject = body.Create(OpCodes.Newobj, new MethodReference(".ctor", imports.Void, convertedReturnType) { Parameters = { new ParameterDefinition(imports.IntPtr) }, HasThis = true }); var endNop = body.Create(OpCodes.Nop); body.Append(loadPointer); if (extraDerefForNonValueTypes) { body.Emit(OpCodes.Ldind_I); } body.Emit(OpCodes.Dup); body.Emit(OpCodes.Brtrue_S, createRealObject); body.Emit(OpCodes.Pop); body.Emit(OpCodes.Ldnull); body.Emit(OpCodes.Br, endNop); body.Append(createRealObject); body.Append(endNop); } }
//^ invariant this.PEFileReader.MethodSpecTable.NumberOfRows >= 1 ==> this.MethodSpecHashtable != null; internal MemberReference/*?*/ GetModuleMemberReferenceAtRowWorker( MetadataObject owningObject, uint memberRefRowId ) { if (memberRefRowId == 0 || memberRefRowId > this.PEFileReader.MemberRefTable.NumberOfRows) { return null; } if (this.ModuleMemberReferenceArray[memberRefRowId] == null) { MemberRefRow memberRefRow = this.PEFileReader.MemberRefTable[memberRefRowId]; uint classTokenType = memberRefRow.Class & TokenTypeIds.TokenTypeMask; uint classRowId = memberRefRow.Class & TokenTypeIds.RIDMask; IModuleTypeReference/*?*/ parentTypeReference = null; switch (classTokenType) { case TokenTypeIds.TypeDef: parentTypeReference = this.GetTypeDefinitionAtRowWorker(classRowId); break; case TokenTypeIds.TypeRef: parentTypeReference = this.GetTypeRefReferenceAtRowWorker(classRowId); break; case TokenTypeIds.TypeSpec: parentTypeReference = this.GetTypeSpecReferenceAtRow(owningObject, classRowId).UnderlyingModuleTypeReference; break; case TokenTypeIds.MethodDef: { MethodDefinition/*?*/ methodDef = this.GetMethodDefAtRow(classRowId); if (methodDef == null) { // Error... return null; } parentTypeReference = methodDef.OwningModuleType; break; } case TokenTypeIds.ModuleRef: { ModuleReference/*?*/ modRef = this.GetModuleReferenceAt(classRowId); if (modRef == null) { // MDError return null; } Module/*?*/ module = this.ResolveModuleRefReference(modRef); if (module == null) { //TODO: MDError... return null; } PEFileToObjectModel modulePEFileToObjectModel = module.PEFileToObjectModel; parentTypeReference = modulePEFileToObjectModel._Module_; break; } default: { // MDError... return null; } } if (parentTypeReference == null) { // Error... return null; } MemberReference retModuleMemberReference; IName name = this.GetNameFromOffset(memberRefRow.Name); byte firstByte = this.PEFileReader.BlobStream.GetByteAt(memberRefRow.Signature, 0); IModuleGenericTypeInstance/*?*/ genericTypeInstance = parentTypeReference as IModuleGenericTypeInstance; IModuleSpecializedNestedTypeReference/*?*/ specializedNestedTypeReference = parentTypeReference as IModuleSpecializedNestedTypeReference; if (SignatureHeader.IsFieldSignature(firstByte)) { if (genericTypeInstance != null) { //The same memberRef token can be shared by distinct instance references, therefore recompute every time. return new GenericInstanceFieldReference(this, memberRefRowId, genericTypeInstance, name); } else if (specializedNestedTypeReference != null) { //The same memberRef token can be shared by distinct instance references, therefore recompute every time. return new SpecializedNestedTypeFieldReference(this, memberRefRowId, parentTypeReference, specializedNestedTypeReference, name); } else { retModuleMemberReference = new FieldReference(this, memberRefRowId, parentTypeReference, name); } } else if (SignatureHeader.IsMethodSignature(firstByte)) { if (genericTypeInstance != null) { //The same memberRef token can be shared by distinct instance references, therefore recompute every time. return new GenericInstanceMethodReference(this, memberRefRowId, genericTypeInstance, name, firstByte); } else if (specializedNestedTypeReference != null) { //The same memberRef token can be shared by distinct instance references, therefore recompute every time. return new SpecializedNestedTypeMethodReference(this, memberRefRowId, parentTypeReference, specializedNestedTypeReference, name, firstByte); } else { retModuleMemberReference = new MethodReference(this, memberRefRowId, parentTypeReference, name, firstByte); } } else { // MD Error return null; } this.ModuleMemberReferenceArray[memberRefRowId] = retModuleMemberReference; } MemberReference/*?*/ ret = this.ModuleMemberReferenceArray[memberRefRowId]; return ret; }
void ProcessInvocationExpression(InvocationExpression invocationExpression) { var method = invocationExpression.GetSymbol() as IMethod; if (method == null) { return; } var arguments = invocationExpression.Arguments.ToArray(); // Reduce "String.Concat(a, b)" to "a + b" if (method.Name == "Concat" && method.DeclaringType.FullName == "System.String" && CheckArgumentsForStringConcat(arguments)) { invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression Expression expr = arguments[0]; for (int i = 1; i < arguments.Length; i++) { expr = new BinaryOperatorExpression(expr, BinaryOperatorType.Add, arguments[i]); } invocationExpression.ReplaceWith(expr); return; } switch (method.FullName) { case "System.Type.GetTypeFromHandle": if (arguments.Length == 1) { if (typeHandleOnTypeOfPattern.IsMatch(arguments[0])) { invocationExpression.ReplaceWith(((MemberReferenceExpression)arguments[0]).Target); return; } } break; case "System.Reflection.FieldInfo.GetFieldFromHandle": if (arguments.Length == 1) { MemberReferenceExpression mre = arguments[0] as MemberReferenceExpression; if (mre != null && mre.MemberName == "FieldHandle" && mre.Target.Annotation <LdTokenAnnotation>() != null) { invocationExpression.ReplaceWith(mre.Target); return; } } else if (arguments.Length == 2) { MemberReferenceExpression mre1 = arguments[0] as MemberReferenceExpression; MemberReferenceExpression mre2 = arguments[1] as MemberReferenceExpression; if (mre1 != null && mre1.MemberName == "FieldHandle" && mre1.Target.Annotation <LdTokenAnnotation>() != null) { if (mre2 != null && mre2.MemberName == "TypeHandle" && mre2.Target is TypeOfExpression) { Expression oldArg = ((InvocationExpression)mre1.Target).Arguments.Single(); FieldReference field = oldArg.Annotation <FieldReference>(); if (field != null) { AstType declaringType = ((TypeOfExpression)mre2.Target).Type.Detach(); oldArg.ReplaceWith(new MemberReferenceExpression(new TypeReferenceExpression(declaringType), field.Name).CopyAnnotationsFrom(oldArg)); invocationExpression.ReplaceWith(mre1.Target); return; } } } } break; case "System.Activator.CreateInstance": if (method.TypeArguments.Count == 1 && arguments.Length == 0 && method.TypeArguments[0].Kind == TypeKind.TypeParameter) { invocationExpression.ReplaceWith(new ObjectCreateExpression(context.TypeSystemAstBuilder.ConvertType(method.TypeArguments.First()))); } break; } BinaryOperatorType?bop = GetBinaryOperatorTypeFromMetadataName(method.Name); if (bop != null && arguments.Length == 2) { invocationExpression.Arguments.Clear(); // detach arguments from invocationExpression invocationExpression.ReplaceWith( new BinaryOperatorExpression(arguments[0], bop.Value, arguments[1]).CopyAnnotationsFrom(invocationExpression) ); return; } UnaryOperatorType?uop = GetUnaryOperatorTypeFromMetadataName(method.Name); if (uop != null && arguments.Length == 1) { arguments[0].Remove(); // detach argument invocationExpression.ReplaceWith( new UnaryOperatorExpression(uop.Value, arguments[0]).CopyAnnotationsFrom(invocationExpression) ); return; } if (method.Name == "op_Explicit" && arguments.Length == 1) { arguments[0].Remove(); // detach argument invocationExpression.ReplaceWith( new CastExpression(context.TypeSystemAstBuilder.ConvertType(method.ReturnType), arguments[0]) .CopyAnnotationsFrom(invocationExpression) ); return; } if (method.Name == "op_Implicit" && arguments.Length == 1) { invocationExpression.ReplaceWith(arguments[0]); return; } if (method.Name == "op_True" && arguments.Length == 1 && invocationExpression.Role == Roles.Condition) { invocationExpression.ReplaceWith(arguments[0]); return; } return; }
//^ invariant this.PEFileReader.MethodSpecTable.NumberOfRows >= 1 ==> this.MethodSpecHashtable != null; internal ITypeMemberReference/*?*/ GetModuleMemberReferenceAtRowWorker( MetadataObject owningObject, uint memberRefRowId ) { if (memberRefRowId == 0 || memberRefRowId > this.PEFileReader.MemberRefTable.NumberOfRows) { return null; } if (this.ModuleMemberReferenceArray[memberRefRowId] == null) { MemberRefRow memberRefRow = this.PEFileReader.MemberRefTable[memberRefRowId]; uint classTokenType = memberRefRow.Class & TokenTypeIds.TokenTypeMask; uint classRowId = memberRefRow.Class & TokenTypeIds.RIDMask; ITypeReference/*?*/ parentTypeReference = null; switch (classTokenType) { case TokenTypeIds.TypeDef: parentTypeReference = this.GetTypeDefinitionAtRow(classRowId); break; case TokenTypeIds.TypeRef: parentTypeReference = this.GetTypeRefReferenceAtRow(classRowId); break; case TokenTypeIds.TypeSpec: parentTypeReference = this.GetTypeSpecReferenceAtRow(owningObject, classRowId).UnderlyingModuleTypeReference; break; case TokenTypeIds.MethodDef: { var/*?*/ methodDef = this.GetMethodDefAtRow(classRowId); if (methodDef == null) { // Error... return null; } parentTypeReference = methodDef.ContainingType; break; } case TokenTypeIds.ModuleRef: { ModuleReference/*?*/ modRef = this.GetModuleReferenceAt(classRowId); if (modRef == null) { // MDError return null; } var module = this.ResolveModuleRefReference(modRef) as Module; if (module == null) { //TODO: MDError... return null; } PEFileToObjectModel modulePEFileToObjectModel = module.PEFileToObjectModel; parentTypeReference = modulePEFileToObjectModel._Module_; break; } default: { // MDError... return null; } } if (parentTypeReference == null) { // Error... return null; } MemberReference retModuleMemberReference; IName name = this.GetNameFromOffset(memberRefRow.Name); byte firstByte = this.PEFileReader.BlobStream.GetByteAt(memberRefRow.Signature, 0); var genericTypeInstance = parentTypeReference as IGenericTypeInstanceReference; var specializedNestedTypeReference = parentTypeReference as ISpecializedNestedTypeReference; if (SignatureHeader.IsFieldSignature(firstByte)) { if (genericTypeInstance != null || specializedNestedTypeReference != null) { //The same memberRef token can be shared by distinct instance references, therefore special caching is required FieldReference unspecializedFieldReference = this.UnspecializedMemberReferenceArray[memberRefRowId] as FieldReference; if (unspecializedFieldReference == null) { unspecializedFieldReference = new FieldReference(this, memberRefRowId, TypeCache.Unspecialize(parentTypeReference), name); this.UnspecializedMemberReferenceArray[memberRefRowId] = unspecializedFieldReference; } uint key1 = parentTypeReference.InternedKey; uint key2 = unspecializedFieldReference.InternedKey; var specializedField = this.SpecializedFieldHashtable.Find(key1, key2); if (specializedField == null) { specializedField = new SpecializedFieldReference(parentTypeReference, unspecializedFieldReference, this.InternFactory); this.SpecializedFieldHashtable.Add(key1, key2, specializedField); } return specializedField; } else { retModuleMemberReference = new FieldReference(this, memberRefRowId, parentTypeReference, name); } } else if (SignatureHeader.IsMethodSignature(firstByte)) { if (genericTypeInstance != null || specializedNestedTypeReference != null) { //The same memberRef token can be shared by distinct instance references, therefore special caching is required MethodReference unspecializedMethodReference = this.UnspecializedMemberReferenceArray[memberRefRowId] as MethodReference; if (unspecializedMethodReference == null) { unspecializedMethodReference = new MethodReference(this, memberRefRowId, TypeCache.Unspecialize(parentTypeReference), name, firstByte); this.UnspecializedMemberReferenceArray[memberRefRowId] = unspecializedMethodReference; } uint key1 = parentTypeReference.InternedKey; uint key2 = unspecializedMethodReference.InternedKey; var specializedMethod = this.SpecializedMethodHashtable.Find(key1, key2); if (specializedMethod == null) { specializedMethod = new SpecializedMethodReference(parentTypeReference, unspecializedMethodReference, this.InternFactory); this.SpecializedMethodHashtable.Add(key1, key2, specializedMethod); } return specializedMethod; } else { retModuleMemberReference = new MethodReference(this, memberRefRowId, parentTypeReference, name, firstByte); } } else { // MD Error return null; } this.ModuleMemberReferenceArray[memberRefRowId] = retModuleMemberReference; } MemberReference/*?*/ ret = this.ModuleMemberReferenceArray[memberRefRowId]; return ret; }
static void AddICollectionTProxy(ModuleDefinition moduleDefinition, TypeDefinition type, GenericInstanceType collectionT, ReferenceFinder referenceFinder) { var itemType = collectionT.GenericArguments[0]; var itemArray = itemType.MakeArrayType(); var proxyType = CreateProxy(moduleDefinition, type, referenceFinder); TypeReference proxyTypeRef = proxyType; if (type.HasGenericParameters) { proxyTypeRef = proxyType.MakeGenericInstanceType(type.GenericParameters.Select(CloneGenericParameter).ToArray()); } var field = proxyType.Fields[0]; var fieldRef = new FieldReference(field.Name, field.FieldType, proxyTypeRef); var countProperty = type.Properties.First(p => p.Name == "Count" || p.Name == "System.Collections.ICollection.Count"); MethodReference countMethod = countProperty.GetMethod; MethodReference copyToMethod = type.Methods.First(p => p.Name == "CopyTo" || p.Name == "System.Collections.ICollection.CopyTo"); if (type.HasGenericParameters) { countMethod = countMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(CloneGenericParameter).ToArray()); copyToMethod = copyToMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(CloneGenericParameter).ToArray()); } var getMethod = new MethodDefinition("get_Items", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, itemArray); var getMethodBody = getMethod.Body; var localItems = new VariableDefinition(itemArray); getMethodBody.Variables.Add(localItems); getMethodBody.SimplifyMacros(); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, countMethod)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Newarr, itemType)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Stloc, localItems)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldlen)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Conv_I4)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, copyToMethod)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems)); getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ret)); getMethodBody.InitLocals = true; getMethodBody.OptimizeMacros(); proxyType.Methods.Add(getMethod); var property = new PropertyDefinition("Items", PropertyAttributes.None, itemArray) { GetMethod = getMethod }; var debuggerBrowsableAttribute = new CustomAttribute(referenceFinder.DebuggerBrowsableAttributeCtor); debuggerBrowsableAttribute.ConstructorArguments.Add(new CustomAttributeArgument(referenceFinder.DebuggerBrowsableStateType, (int)DebuggerBrowsableState.RootHidden)); property.CustomAttributes.Add(debuggerBrowsableAttribute); proxyType.Properties.Add(property); AddDebuggerTypeProxyAttribute(type, proxyType, referenceFinder); }
public void Emit(OpCode opcode, FieldReference field) { Append (Create (opcode, field)); }
public static void DoObfuscate(string[] assemblyPath, string uselessCodeLibAssemblyPath, int randomSeed, bool enableNameObfuscate, bool enableCodeInject, ObfuscateType nameObfuscateType, ObfuscateType codeInjectObfuscateType, ObfuscateNameType obfuscateNameType, int garbageMethodMultiplePerClass, int insertMethodCountPerMethod) { if (Application.isPlaying || EditorApplication.isCompiling) { Debug.Log("You need stop play mode or wait compiling finished"); return; } if (assemblyPath.Length <= 0) { Debug.LogError("Obfuscate dll paths length: 0"); } Debug.Log("Code Obfuscate Start"); var resolver = new DefaultAssemblyResolver(); foreach (var item in Const.ResolverSearchDirs) { resolver.AddSearchDirectory(item); } var readerParameters = new ReaderParameters { AssemblyResolver = resolver, ReadSymbols = true }; AssemblyDefinition[] assemblies = new AssemblyDefinition[assemblyPath.Length]; for (int i = 0; i < assemblyPath.Length; i++) { var assembly = AssemblyDefinition.ReadAssembly(assemblyPath[i], readerParameters); if (assembly == null) { Debug.LogError(string.Format("Code Obfuscate Load assembly failed: {0}", assemblyPath[i])); return; } assemblies[i] = assembly; } AssemblyDefinition garbageCodeAssmbly = null; if (enableCodeInject) { garbageCodeAssmbly = AssemblyDefinition.ReadAssembly(uselessCodeLibAssemblyPath, readerParameters); if (garbageCodeAssmbly == null) { Debug.LogError(string.Format("Code Obfuscate Load assembly failed: {0}", uselessCodeLibAssemblyPath)); return; } } try { //初始化组件 ObfuscatorHelper.Init(randomSeed); NameObfuscate.Instance.Init(nameObfuscateType); CodeInject.Instance.Init(codeInjectObfuscateType, garbageMethodMultiplePerClass, insertMethodCountPerMethod); NameFactory.Instance.Load(obfuscateNameType); //混淆并注入垃圾代码 for (int i = 0; i < assemblies.Length; i++) { var module = assemblies[i].MainModule; if (enableCodeInject) { CodeInject.Instance.DoObfuscate(assemblies[i], garbageCodeAssmbly); } if (enableNameObfuscate) { NameObfuscate.Instance.DoObfuscate(assemblies[i]); } } //把每个dll对其他被混淆的dll的引用名字修改为混淆后的名字 if (enableNameObfuscate) { foreach (var assembly in assemblies) { foreach (var item in assembly.MainModule.GetMemberReferences()) { try { if (item is FieldReference) { FieldReference fieldReference = item as FieldReference; Dictionary <BaseObfuscateItem, string> dic = NameFactory.Instance.GetOld_New_NameDic(NameType.Filed); FieldObfuscateItem fieldObfuscateItem = new FieldObfuscateItem(fieldReference.DeclaringType.Namespace, fieldReference.DeclaringType.Name, fieldReference.Name); if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Filed, fieldObfuscateItem)) { item.Name = NameFactory.Instance.GetRandomName(NameType.Filed, fieldObfuscateItem); } } else if (item is PropertyReference) { PropertyReference propertyReference = item as PropertyReference; PropertyObfuscateItem propertyObfuscateItem = new PropertyObfuscateItem(propertyReference.DeclaringType.Namespace, propertyReference.DeclaringType.Name, propertyReference.Name); if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Property, propertyObfuscateItem)) { item.Name = NameFactory.Instance.GetRandomName(NameType.Property, propertyObfuscateItem); } } else if (item is MethodReference) { MethodReference methodReference = item as MethodReference; MethodObfuscateItem methodObfuscateItem = new MethodObfuscateItem(methodReference.DeclaringType.Namespace, methodReference.DeclaringType.Name, methodReference.Name); if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Method, methodObfuscateItem)) { item.Name = NameFactory.Instance.GetRandomName(NameType.Method, methodObfuscateItem); } } } catch { continue; } } foreach (var item in assembly.MainModule.GetTypeReferences()) { try { TypeDefinition typeDefinition = item.Resolve(); TypeObfuscateItem typeObfuscateItem = ObfuscateItemFactory.Create(typeDefinition); NamespaceObfuscateItem namespaceObfuscateItem = ObfuscateItemFactory.Create(typeDefinition.Namespace, typeDefinition.Module); if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Class, typeObfuscateItem)) { item.Name = NameFactory.Instance.GetRandomName(NameType.Class, typeObfuscateItem); } if (NameFactory.Instance.AlreadyHaveRandomName(NameType.Namespace, namespaceObfuscateItem)) { item.Namespace = NameFactory.Instance.GetRandomName(NameType.Namespace, namespaceObfuscateItem); } } catch { continue; } } } } for (int i = 0; i < assemblies.Length; i++) { assemblies[i].Write(assemblyPath[i], new WriterParameters { WriteSymbols = true }); } Debug.Log("Code Obfuscate Completed!"); } catch (Exception ex) { Debug.LogError(string.Format("Code Obfuscate failed: {0}", ex)); } finally { for (int i = 0; i < assemblies.Length; i++) { assemblies[i].MainModule.SymbolReader.Dispose(); } if (garbageCodeAssmbly != null && garbageCodeAssmbly.MainModule.SymbolReader != null) { garbageCodeAssmbly.MainModule.SymbolReader.Dispose(); } //输出 名字-混淆后名字 的map NameFactory.Instance.OutputNameMap(Const.NameMapPath); } }
public static Instruction Create (OpCode opcode, FieldReference field) { if (field == null) throw new ArgumentNullException ("field"); if (opcode.OperandType != OperandType.InlineField && opcode.OperandType != OperandType.InlineTok) throw new ArgumentException ("opcode"); return new Instruction (opcode, field); }
public static string IdentifyRegex = "^[A-z,0-9]+$", SplitRegex = null; //example : "FeatureName" public override IEvalResult[] Eval(IEvalResult[] parameters) { //Get parameters List<BLL.BusinessObjects.Feature> featureReferences = new List<BusinessObjects.Feature>(); foreach (IEvalResult parameter in parameters) { try { ObjectReference objRef = (ObjectReference)parameter; featureReferences.Add((BusinessObjects.Feature)objRef.GetReference()); } catch (Exception ex) { throw new SyntaxIncorrectException(); } } //Get the Attributes and AttributeValues List<BLL.BusinessObjects.AttributeValue> attributeValues = new List<BusinessObjects.AttributeValue>(); foreach (BLL.BusinessObjects.Feature featureRef in featureReferences) { //Get the Attribute string attributeIdentifier = _syntaxString; BusinessObjects.Attribute attribute = _configSession.Model.GetAttributeByIdentifier(featureRef, attributeIdentifier); if (attribute != null) //if the feature doesn't have the Attribute, it is ignored { //Get the AttributeValue BusinessObjects.AttributeValue attributeValue = _configSession.Configuration.GetAttributeValueByAttributeID(attribute.ID); attributeValues.Add(attributeValue); } } //Return a list of references pointing to the each of the childFeatures List<IEvalResult> returnRef = new List<IEvalResult>(); foreach (BLL.BusinessObjects.AttributeValue attrValue in attributeValues) { object target = (object)attrValue; FieldReference objRef = new FieldReference(target, "Value"); returnRef.Add(objRef); } return returnRef.ToArray(); }