public override void Process(ScannedMethod m, MethodSpec o) { foreach (var t in o.GenericInstMethodSig.GenericArguments) { m.RegisterGeneric(t); } }
public void AddAssociatedType(IMemberRef type, TypeSig associatedType) { if (associatedType.IsGenericInstanceType || associatedType.IsGenericTypeParameter) { return; } var si = GetScannedItem(type); if (si == null) { switch (type) { case MethodDef m: si = new ScannedMethod(m); break; case TypeDef t: // si = new ScannedType(t); //types are currently Broken break; default: throw new ArgumentException($"AddAssociatedType type must be either MethodDef or TypeDef", "type"); } if (si == null) { return; //Should never happen in a working version. More for testing } scannedItems.Add(si); } si.AddAssociation(associatedType); }
internal override void Process(ScannedMethod method, Instruction instruction, MemberRef operand) { Debug.Assert(method != null, $"{nameof(method)} != null"); Debug.Assert(instruction != null, $"{nameof(instruction)} != null"); Debug.Assert(operand != null, $"{nameof(operand)} != null"); // Scrambling member references only works for constructors without parameters currently. if (instruction.OpCode != OpCodes.Newobj) { return; } if (operand.MethodSig.Params.Count > 0) { return; } TypeSig sig = null; if (operand.Class is TypeRef typeRef) { sig = typeRef.ToTypeSig(); } if (operand.Class is TypeSpec typeSpec) { sig = typeSpec.ToTypeSig(); } if (sig != null) { method.RegisterGeneric(sig); } }
internal override void Process(ScannedMethod method, Instruction instruction, TypeRef operand) { Debug.Assert(method != null, $"{nameof(method)} != null"); Debug.Assert(instruction != null, $"{nameof(instruction)} != null"); Debug.Assert(operand != null, $"{nameof(operand)} != null"); method.RegisterGeneric(operand.ToTypeSig()); }
public void AddScannedItem(ScannedMethod m) { ScannedItem typescan; if (GenericsMapper.TryGetValue(m.TargetMethod.DeclaringType.MDToken, out typescan)) { m.GenericCount += typescan.GenericCount; } AddScannedItemGeneral(m); }
internal override void Process(ScannedMethod method, Instruction instruction, MethodSpec operand) { Debug.Assert(method != null, $"{nameof(method)} != null"); Debug.Assert(instruction != null, $"{nameof(instruction)} != null"); Debug.Assert(operand != null, $"{nameof(operand)} != null"); foreach (var t in operand.GenericInstMethodSig.GenericArguments) { method.RegisterGeneric(t); } }
public override void ProcessOperand(TypeService service, MethodDef method, IList <Instruction> body, ref int index, MethodSpec operand) { ScannedMethod t = service.GetItem(method.MDToken) as ScannedMethod; if (t != null) { var generics = operand.GenericInstMethodSig.GenericArguments.Select(x => t.ConvertToGenericIfAvalible(x)); operand.GenericInstMethodSig = new GenericInstMethodSig(generics.ToArray()); } }
public override void ProcessOperand(TypeService service, MethodDef method, IList <Instruction> body, ref int index, MethodDef operand) { ScannedMethod tMethod = service.GetItem(operand.MDToken) as ScannedMethod; ScannedItem currentMethod = service.GetItem(method.MDToken) as ScannedMethod; if (tMethod != null) { var newspec = new MethodSpecUser(tMethod.TargetMethod, tMethod.CreateGenericMethodSig(currentMethod)); body[index].Operand = newspec; } }
public override void Process(ScannedMethod m, MethodDef o) { var sc = service.GetItem(o.MDToken) as ScannedMethod; if (sc != null) { foreach (var regTypes in sc.TrueTypes) { m.RegisterGeneric(regTypes); } } }
internal override void Process(ScannedMethod method, Instruction instruction, MethodDef operand) { Debug.Assert(method != null, $"{nameof(method)} != null"); Debug.Assert(instruction != null, $"{nameof(instruction)} != null"); Debug.Assert(operand != null, $"{nameof(operand)} != null"); var sc = Service.GetItem(operand); if (sc?.IsScambled == true) { foreach (var regTypes in sc.TrueTypes) { method.RegisterGeneric(regTypes); } } }
public override void Process(ScannedMethod m, MemberRef o) { TypeSig sig = null; if (o.Class is TypeRef) { sig = (o.Class as TypeRef)?.ToTypeSig(); } if (o.Class is TypeSpec) { sig = (o.Class as TypeSpec)?.ToTypeSig(); } if (sig != null) { m.RegisterGeneric(sig); } }
public abstract void ProcessOperand(ScannedMethod m, object o);
public ContextAnalyzerFactory(ScannedMethod m) { targetMethod = m; }
internal abstract void ProcessOperand(ScannedMethod method, Instruction instruction, object operand);
public override void Process(ScannedMethod m, TypeRef o) { m.RegisterGeneric(o.ToTypeSig()); }
internal ContextAnalyzerFactory(ScannedMethod method) { Debug.Assert(method != null, $"{nameof(method)} != null"); TargetMethod = method; }
internal void AddScannedItem(ScannedMethod m) => AddScannedItemGeneral(m);
public override void ProcessOperand(TypeService service, MethodDef method, IList <Instruction> body, ref int index, MemberRef operand) { ScannedMethod current = service.GetItem(method.MDToken) as ScannedMethod; if (operand.MethodSig.Params.Count > 0 || current == null || body[index].OpCode != OpCodes.Newobj) { return; } ModuleDef mod = method.Module; var gettype = typeof(Type).GetMethod("GetTypeFromHandle"); var createInstance = typeof(Activator).GetMethod("CreateInstance", new Type[] { typeof(Type) }); var createInstanceArgs = typeof(Activator).GetMethod("CreateInstance", new Type[] { typeof(Type), typeof(object[]) }); TypeSig sig = null; if (operand.Class is TypeRef) { sig = (operand.Class as TypeRef)?.ToTypeSig(); } if (operand.Class is TypeSpec) { sig = (operand.Class as TypeSpec)?.ToTypeSig(); } if (sig != null) { //ScannedItem t = service.GetItem(operand.MDToken); //if (t != null) { // sig = t.CreateGenericTypeSig(service.GetItem(method.DeclaringType.MDToken)); // } var paramCount = operand.MethodSig.Params.Count; var gen = current.GetGeneric(sig); body[index].OpCode = OpCodes.Ldtoken; TypeSpecUser newTypeSpec = null; if (gen != null) { newTypeSpec = new TypeSpecUser(new GenericMVar(gen.Number)); } else { newTypeSpec = new TypeSpecUser(sig); } body[index].Operand = newTypeSpec; /* * var genericCallSig = new GenericInstMethodSig( new TypeSig[] { current.ConvertToGenericIfAvalible(sig) }); * foreach(var param in operand.MethodSig.Params.Select(x => current.ConvertToGenericIfAvalible(x))) { * genericCallSig.GenericArguments.Add(param); * } * * // tgtMethod.GenericInstMethodSig = genericCallSig; * var spec = new MethodSpecUser(tgtMethod, genericCallSig); * * body[index].OpCode = OpCodes.Call; * body[index].Operand = tgtMethod; */ body.Insert(++index, Instruction.Create(OpCodes.Call, mod.Import(gettype))); body.Insert(++index, Instruction.Create(OpCodes.Call, mod.Import(createInstance))); } }
internal override void ProcessOperand(ScannedMethod method, Instruction instruction, object operand) => Process(method, instruction, (T)operand);
internal abstract void Process(ScannedMethod method, Instruction instruction, T operand);