public void Bitmask() { OpCodeBitmask branches = new OpCodeBitmask(); branches.Set(Code.Beq); branches.Set(Code.Beq_S); branches.Set(Code.Bge); branches.Set(Code.Bge_S); branches.Set(Code.Bge_Un); branches.Set(Code.Bge_Un_S); branches.Set(Code.Bgt); branches.Set(Code.Bgt_S); branches.Set(Code.Bgt_Un); branches.Set(Code.Bgt_Un_S); branches.Set(Code.Ble); branches.Set(Code.Ble_S); branches.Set(Code.Ble_Un); branches.Set(Code.Ble_Un_S); branches.Set(Code.Blt); branches.Set(Code.Blt_S); branches.Set(Code.Blt_Un); branches.Set(Code.Blt_Un_S); branches.Set(Code.Bne_Un); branches.Set(Code.Bne_Un_S); branches.Set(Code.Br); branches.Set(Code.Br_S); branches.Set(Code.Brfalse); branches.Set(Code.Brfalse_S); branches.Set(Code.Brtrue); branches.Set(Code.Brtrue_S); Console.WriteLine(branches); }
static protected bool IsApplicable(MethodDefinition method) { // we only check methods with a body if ((method == null) || !method.HasBody) { return(false); } // we don't check System.Single and System.Double // special case for handling mscorlib.dll if (method.DeclaringType.IsFloatingPoint()) { return(false); } // rule applies only if the method contains Call[virt] (calls to Equals) OpCodeBitmask mask = OpCodeEngine.GetBitmask(method); if (OpCodeBitmask.Calls.Intersect(mask)) { return(true); } // *or* Ceq instructions return(mask.Get(Code.Ceq)); }
public RuleResult CheckMethod(MethodDefinition method) { // Rule does not apply if the method has no IL if (!method.HasBody) { return(RuleResult.DoesNotApply); } // // We need to check all methods which has any of the following opcodes: call, stfld or stsfld. // OpCodeBitmask bitmask = OpCodeEngine.GetBitmask(method); if (!applicable_method_bitmask.Intersect(bitmask)) { return(RuleResult.DoesNotApply); } /* Unfortunately it's possible to generate IL this rule will choke on, especially when * using non-standard compilers or obfuscators. */ try { return(CheckMethodUnsafe(method)); } catch (Exception ex) { // FIXME: This problem should be reported some other way, it's not really a failure. // Pending implementation of "analysis warnings", as mentioned here (post #21): // http://groups.google.com/group/gendarme/browse_frm/thread/c37d157ae0c9682/57f89f3abf14f2fd?tvc=1&q=Gendarme+2.6+Preview+1+is+ready+for+download#57f89f3abf14f2fd Runner.Report(method, Severity.Low, Confidence.Low, String.Format(CultureInfo.CurrentCulture, "An exception occurred while verifying this method. " + "This failure can probably be ignored, it's most likely due to an " + "uncommon code sequence in the method the rule didn't understand. {0}", ex.Message)); return(RuleResult.Failure); } }
public void Bitmask () { OpCodeBitmask unbox = new OpCodeBitmask (); unbox.Set (Code.Unbox); unbox.Set (Code.Unbox_Any); Console.WriteLine (unbox); }
public void GenerateBitmask() { OpCodeBitmask throwers = new OpCodeBitmask(); OpCodeBitmask alwaysBad = new OpCodeBitmask(); OpCodeBitmask overflow = new OpCodeBitmask(); OpCodeBitmask casts = new OpCodeBitmask(); foreach (Code code in AlwaysBad) { throwers.Set(code); alwaysBad.Set(code); } foreach (Code code in Casts) { casts.Set(code); throwers.Set(code); } throwers.Set(Code.Throw); foreach (Code code in Overflow) { throwers.Set(code); overflow.Set(code); } Console.WriteLine("throwers: {0}", throwers); Console.WriteLine("alwaysBad: {0}", alwaysBad); Console.WriteLine("overflow: {0}", overflow); Console.WriteLine("casts: {0}", casts); }
public RuleResult CheckMethod(MethodDefinition method) { // rule only applies to methods with IL and exceptions handlers if (!method.HasBody || !method.Body.HasExceptionHandlers) { return(RuleResult.DoesNotApply); } // and when the IL contains a Throw instruction (Rethrow is fine) OpCodeBitmask mask = OpCodeEngine.GetBitmask(method); if (!mask.Get(Code.Throw)) { return(RuleResult.DoesNotApply); } // we can use a faster code path when no branches are present in the method if (mask.Intersect(branches)) { Branches(method); } else { Branchless(method); } warned_offsets_in_method.Clear(); return(Runner.CurrentRuleResult); }
public RuleResult CheckMethod(MethodDefinition method) { if (!method.HasBody) { return(RuleResult.DoesNotApply); } //is there any interesting opcode in the method? OpCodeBitmask calls = OpCodeBitmask.Calls; if (!calls.Intersect(OpCodeEngine.GetBitmask(method))) { return(RuleResult.DoesNotApply); } foreach (Instruction ins in method.Body.Instructions) { if (!calls.Get(ins.OpCode.Code)) { continue; } CheckCall(method, ins, (MethodReference)ins.Operand); } return(Runner.CurrentRuleResult); }
public void Bitmask() { OpCodeBitmask constant = new OpCodeBitmask(); constant.Set(Code.Ldstr); constant.Set(Code.Ldc_I4); constant.Set(Code.Ldc_I4_0); constant.Set(Code.Ldc_I4_1); constant.Set(Code.Ldc_I4_2); constant.Set(Code.Ldc_I4_3); constant.Set(Code.Ldc_I4_4); constant.Set(Code.Ldc_I4_5); constant.Set(Code.Ldc_I4_6); constant.Set(Code.Ldc_I4_7); constant.Set(Code.Ldc_I4_8); constant.Set(Code.Ldc_I4_M1); constant.Set(Code.Ldc_I4_S); constant.Set(Code.Ldc_I8); constant.Set(Code.Ldc_R4); constant.Set(Code.Ldc_R8); Console.WriteLine(constant); OpCodeBitmask convert = new OpCodeBitmask(); convert.Set(Code.Conv_I); convert.Set(Code.Conv_I1); convert.Set(Code.Conv_I2); convert.Set(Code.Conv_I4); convert.Set(Code.Conv_I8); convert.Set(Code.Conv_Ovf_I); convert.Set(Code.Conv_Ovf_I_Un); convert.Set(Code.Conv_Ovf_I1); convert.Set(Code.Conv_Ovf_I1_Un); convert.Set(Code.Conv_Ovf_I2); convert.Set(Code.Conv_Ovf_I2_Un); convert.Set(Code.Conv_Ovf_I4); convert.Set(Code.Conv_Ovf_I4_Un); convert.Set(Code.Conv_Ovf_I8); convert.Set(Code.Conv_Ovf_I8_Un); convert.Set(Code.Conv_Ovf_U); convert.Set(Code.Conv_Ovf_U_Un); convert.Set(Code.Conv_Ovf_U1); convert.Set(Code.Conv_Ovf_U1_Un); convert.Set(Code.Conv_Ovf_U2); convert.Set(Code.Conv_Ovf_U2_Un); convert.Set(Code.Conv_Ovf_U4); convert.Set(Code.Conv_Ovf_U4_Un); convert.Set(Code.Conv_Ovf_U8); convert.Set(Code.Conv_Ovf_U8_Un); convert.Set(Code.Conv_R_Un); convert.Set(Code.Conv_R4); convert.Set(Code.Conv_R8); convert.Set(Code.Conv_U); convert.Set(Code.Conv_U1); convert.Set(Code.Conv_U2); convert.Set(Code.Conv_U4); convert.Set(Code.Conv_U8); Console.WriteLine(convert); }
public void Bitmask() { OpCodeBitmask mask = new OpCodeBitmask(); mask.Set(Code.Div); mask.Set(Code.Div_Un); Console.WriteLine(mask); }
public void Bitmask() { OpCodeBitmask mask = new OpCodeBitmask(); mask.Set(Code.Stfld); mask.Set(Code.Stelem_Ref); Console.WriteLine(mask); }
public void GenerateBitmask() { OpCodeBitmask bitmask = new OpCodeBitmask(); bitmask.Set(Code.Newobj); bitmask.Set(Code.Throw); Console.WriteLine(bitmask); }
public void Bitmask() { OpCodeBitmask casts = new OpCodeBitmask(); casts.Set(Code.Castclass); casts.Set(Code.Isinst); Console.WriteLine(casts); }
public void BuildRemainder() { OpCodeBitmask remainder = new OpCodeBitmask(); remainder.Set(Code.Rem); remainder.Set(Code.Rem_Un); Console.WriteLine(remainder); }
public void Bitmask() { OpCodeBitmask mask = new OpCodeBitmask(); mask.Set(Code.Isinst); mask.Set(Code.Ldnull); Console.WriteLine(mask); }
public void Bitmask() { OpCodeBitmask mask = new OpCodeBitmask(); mask.Set(Code.Mul); mask.Set(Code.Mul_Ovf); mask.Set(Code.Mul_Ovf_Un); Console.WriteLine(mask); }
public void Bitmask() { OpCodeBitmask zero = new OpCodeBitmask(); zero.Set(Code.Ldc_I4); zero.Set(Code.Ldc_I4_S); zero.Set(Code.Ldc_I4_0); Console.WriteLine(zero); }
private void Bitmask() { OpCodeBitmask opcodes_mask = new OpCodeBitmask(); opcodes_mask.Set(Code.Ldftn); opcodes_mask.Set(Code.Call); opcodes_mask.Set(Code.Callvirt); Console.WriteLine(opcodes_mask); }
static OpCodeBitmask BuildCallsAndNewobjOpCodeBitmask() { #if true return(new OpCodeBitmask(0x8000000000, 0x4400000000000, 0x0, 0x0)); #else OpCodeBitmask mask = new OpCodeBitmask(); mask.UnionWith(OpCodeBitmask.Calls); mask.Set(Code.Newobj); return(mask); #endif }
private static OpCodeBitmask ConditionsBitmask() { OpCodeBitmask mask = new OpCodeBitmask(); mask.Set(Code.Brtrue); mask.Set(Code.Brtrue_S); mask.Set(Code.Brfalse); mask.Set(Code.Brfalse_S); Console.WriteLine("ConditionsBitmask : " + mask); return(mask); }
public void Bitmask() { OpCodeBitmask fields = new OpCodeBitmask(); fields.Set(Code.Ldfld); fields.Set(Code.Ldflda); fields.Set(Code.Ldsfld); fields.Set(Code.Ldsflda); fields.Set(Code.Stfld); fields.Set(Code.Stsfld); Console.WriteLine(fields); }
private void Bitmask() { OpCodeBitmask mask = new OpCodeBitmask(); mask.Set(Code.Call); mask.Set(Code.Callvirt); mask.Set(Code.Ldfld); mask.Set(Code.Ldflda); mask.Set(Code.Stfld); mask.Set(Code.Newobj); Console.WriteLine(mask); }
public void Convert() { OpCodeBitmask Convert8 = new OpCodeBitmask(0x0, 0x0, 0x0, 0x0); Convert8.Set(Code.Conv_I8); Convert8.Set(Code.Conv_U8); Convert8.Set(Code.Conv_Ovf_I8); Convert8.Set(Code.Conv_Ovf_I8_Un); Convert8.Set(Code.Conv_Ovf_U8); Convert8.Set(Code.Conv_Ovf_U8_Un); Console.WriteLine(Convert8); }
private static OpCodeBitmask BuildInterlockedFriendlyOpCodeBitmask() { #if true return(new OpCodeBitmask(0x80063FFFFFFFFF, 0x3f00000001800000, 0x1F30000000000000, 0x5F80)); #else OpCodeBitmask mask = new OpCodeBitmask(); mask.UnionWith(OpCodeBitmask.FlowControlBranch); mask.UnionWith(OpCodeBitmask.FlowControlReturn); //locals mask.UnionWith(OpCodeBitmask.LoadLocal); mask.UnionWith(OpCodeBitmask.StoreLocal); //arguments mask.UnionWith(OpCodeBitmask.LoadArgument); mask.UnionWith(OpCodeBitmask.StoreArgument); //fields mask.Set(Code.Ldfld); mask.Set(Code.Ldflda); mask.Set(Code.Stfld); mask.Set(Code.Ldsfld); mask.Set(Code.Ldsflda); mask.Set(Code.Stsfld); //constants mask.Set(Code.Ldnull); mask.Set(Code.Ldc_I4_M1); mask.Set(Code.Ldc_I4_0); mask.Set(Code.Ldc_I4_1); mask.Set(Code.Ldc_I4_2); mask.Set(Code.Ldc_I4_3); mask.Set(Code.Ldc_I4_4); mask.Set(Code.Ldc_I4_5); mask.Set(Code.Ldc_I4_6); mask.Set(Code.Ldc_I4_7); mask.Set(Code.Ldc_I4_8); mask.Set(Code.Ldc_I4_S); mask.Set(Code.Ldc_I4); mask.Set(Code.Ldc_I8); mask.Set(Code.Ldc_R4); mask.Set(Code.Ldc_R8); //safe mask.Set(Code.Dup); mask.Set(Code.Pop); mask.Set(Code.Nop); mask.Set(Code.Break); //could be replace by interlocked call mask.Set(Code.Add); mask.Set(Code.Add_Ovf); mask.Set(Code.Add_Ovf_Un); mask.Set(Code.Sub); mask.Set(Code.Sub_Ovf); mask.Set(Code.Sub_Ovf_Un); return(mask); #endif }
private static OpCodeBitmask ComparisonsBitmask() { OpCodeBitmask mask = new OpCodeBitmask(); mask.Set(Code.Cgt); mask.Set(Code.Ceq); mask.Set(Code.Clt); mask.Set(Code.Ble); mask.Set(Code.Ble_S); mask.Set(Code.Bge); mask.Set(Code.Bge_S); Console.WriteLine("ComparisonsBitmask : " + mask); return(mask); }
protected override void CheckMethod(MethodDefinition method, bool abstractWarning) { if ((method == null) || !method.HasBody) { return; } OpCodeBitmask bitmask = OpCodeEngine.GetBitmask(method); // method must have a CALL[VIRT] and either STFLD or STELEM_REF if (!bitmask.Intersect(OpCodeBitmask.Calls) || !bitmask.Intersect(StoreFieldBitmask)) { return; } foreach (Instruction ins in method.Body.Instructions) { MethodReference mr = (ins.Operand as MethodReference); if (mr == null || mr.DeclaringType.IsNative()) { continue; } FieldDefinition field = null; Instruction next = ins.Next; if (next.Is(Code.Stfld)) { field = next.Operand as FieldDefinition; } else if (next.Is(Code.Stobj) || next.Is(Code.Stind_I)) { Instruction origin = next.TraceBack(method); if (origin.Is(Code.Ldelema)) { origin = origin.TraceBack(method); if (origin != null) { field = origin.Operand as FieldDefinition; } } } if (field != null && FieldCandidates.Contains(field)) { Runner.Report(field, Severity.High, Confidence.High, abstractWarning ? AbstractTypeMessage : TypeMessage); } } }
void OnMethodBody (object sender, EngineEventArgs e) { MethodBody body = (sender as MethodBody); MethodDefinition method = body.Method; // some runners, like the wizard, can run this engine several times // and, in this case, the result won't change if (bitmasks.ContainsKey (method)) return; OpCodeBitmask mask = new OpCodeBitmask (); foreach (Instruction ins in body.Instructions) { mask.Set (ins.OpCode.Code); } bitmasks.Add (method, mask); }
public RuleResult CheckMethod(MethodDefinition method) { if (!method.HasBody) { return(RuleResult.DoesNotApply); } // exclude methods that don't have calls OpCodeBitmask mask = OpCodeEngine.GetBitmask(method); if (!OpCodeBitmask.Calls.Intersect(mask)) { return(RuleResult.DoesNotApply); } // *and* methods that don't convert into an [u]int64 if (!Convert8.Intersect(mask)) { return(RuleResult.DoesNotApply); } foreach (Instruction ins in method.Body.Instructions) { if (ins.OpCode.FlowControl != FlowControl.Call) { continue; } if (!IsInt64BitsToDouble(ins.Operand as MethodReference)) { continue; } // if the previous call convert a value into a long (int64) // then it's likely that the API is being misused switch (ins.Previous.OpCode.Code) { case Code.Conv_I8: case Code.Conv_U8: case Code.Conv_Ovf_I8: case Code.Conv_Ovf_I8_Un: case Code.Conv_Ovf_U8: case Code.Conv_Ovf_U8_Un: Runner.Report(method, ins, Severity.High, Confidence.High); break; } } return(Runner.CurrentRuleResult); }
private void Bitmask() { OpCodeBitmask mask = new OpCodeBitmask(); mask.Set(Code.Starg); mask.Set(Code.Starg_S); mask.Set(Code.Stloc_0); mask.Set(Code.Stloc_1); mask.Set(Code.Stloc_2); mask.Set(Code.Stloc_3); mask.Set(Code.Stloc); mask.Set(Code.Stloc_S); mask.Set(Code.Stfld); mask.Set(Code.Stsfld); Console.WriteLine(mask); }
public RuleResult CheckMethod(MethodDefinition method) { if (!method.HasBody) { return(RuleResult.DoesNotApply); } OpCodeBitmask bitmask = OpCodeEngine.GetBitmask(method); // is there any Call or Callvirt instructions in the method ? if (!OpCodeBitmask.Calls.Intersect(bitmask)) { return(RuleResult.DoesNotApply); } // is there a Ldnull instruction in the method ? if (!bitmask.Get(Code.Ldnull)) { return(RuleResult.DoesNotApply); } foreach (Instruction ins in method.Body.Instructions) { switch (ins.OpCode.Code) { case Code.Call: case Code.Callvirt: // if we're calling bool type.Equals({anytype}) if (!Equals.Matches(ins.Operand as MethodReference)) { continue; } // and that the previous, real, instruction is loading a null value // note: check the first parameter (not the instance) Instruction source = ins.TraceBack(method, -1); if ((source != null) && (source.OpCode.Code == Code.Ldnull)) { Runner.Report(method, ins, Severity.Low, Confidence.High); } break; } } return(Runner.CurrentRuleResult); }
public RuleResult CheckMethod(MethodDefinition method) { // rule doesn't not apply to methods without code (e.g. p/invokes) if (!method.HasBody) { return(RuleResult.DoesNotApply); } // is there any Call or Callvirt instructions in the method OpCodeBitmask calls = OpCodeBitmask.Calls; if (!calls.Intersect(OpCodeEngine.GetBitmask(method))) { return(RuleResult.DoesNotApply); } // go! // we look for a call to String.Length property (since it's much easier // than checking a string being compared to null) foreach (Instruction current in method.Body.Instructions) { if (!calls.Get(current.OpCode.Code)) { continue; } MethodReference mr = (current.Operand as MethodReference); if (mr.IsNamed("System", "String", "get_Length")) { // now that we found it we check that // 1 - we previously did a check null on the same value (that we already know is a string) Instruction branch = PreLengthCheck(method, current.Previous); if (branch == null) { continue; } // 2 - we compare the return value (length) with 0 if (PostLengthCheck(current.Next, branch)) { Runner.Report(method, current, Severity.Medium, Confidence.High); } } } return(Runner.CurrentRuleResult); }
public void BuildBitmask() { OpCodeBitmask bitmask = new OpCodeBitmask(); bitmask.Set(Code.Ldind_I); bitmask.Set(Code.Ldind_I1); bitmask.Set(Code.Ldind_I2); bitmask.Set(Code.Ldind_I4); bitmask.Set(Code.Ldind_I8); bitmask.Set(Code.Ldind_R4); bitmask.Set(Code.Ldind_R8); bitmask.Set(Code.Ldind_U1); bitmask.Set(Code.Ldind_U2); bitmask.Set(Code.Ldind_U4); Console.WriteLine("LoadIndirect = {0}", bitmask); bitmask.ClearAll(); bitmask.Set(Code.Stind_I); bitmask.Set(Code.Stind_I1); bitmask.Set(Code.Stind_I2); bitmask.Set(Code.Stind_I4); bitmask.Set(Code.Stind_I8); bitmask.Set(Code.Stind_R4); bitmask.Set(Code.Stind_R8); Console.WriteLine("StoreIndirect = {0}", bitmask); bitmask.ClearAll(); bitmask.Set(Code.Bge); bitmask.Set(Code.Bge_S); bitmask.Set(Code.Bge_Un); bitmask.Set(Code.Bge_Un_S); bitmask.Set(Code.Bgt); bitmask.Set(Code.Bgt_S); bitmask.Set(Code.Bgt_Un); bitmask.Set(Code.Bgt_Un_S); bitmask.Set(Code.Ble); bitmask.Set(Code.Ble_S); bitmask.Set(Code.Ble_Un); bitmask.Set(Code.Ble_Un_S); bitmask.Set(Code.Blt); bitmask.Set(Code.Blt_S); bitmask.Set(Code.Blt_Un); bitmask.Set(Code.Blt_Un_S); Console.WriteLine("GreaterOrLesserThan = {0}", bitmask); }
public void Bitmask () { OpCodeBitmask constant = new OpCodeBitmask (); constant.Set (Code.Ldstr); constant.Set (Code.Ldc_I4); constant.Set (Code.Ldc_I4_0); constant.Set (Code.Ldc_I4_1); constant.Set (Code.Ldc_I4_2); constant.Set (Code.Ldc_I4_3); constant.Set (Code.Ldc_I4_4); constant.Set (Code.Ldc_I4_5); constant.Set (Code.Ldc_I4_6); constant.Set (Code.Ldc_I4_7); constant.Set (Code.Ldc_I4_8); constant.Set (Code.Ldc_I4_M1); constant.Set (Code.Ldc_I4_S); constant.Set (Code.Ldc_I8); constant.Set (Code.Ldc_R4); constant.Set (Code.Ldc_R8); Console.WriteLine (constant); OpCodeBitmask convert = new OpCodeBitmask (); convert.Set (Code.Conv_I); convert.Set (Code.Conv_I1); convert.Set (Code.Conv_I2); convert.Set (Code.Conv_I4); convert.Set (Code.Conv_I8); convert.Set (Code.Conv_Ovf_I); convert.Set (Code.Conv_Ovf_I_Un); convert.Set (Code.Conv_Ovf_I1); convert.Set (Code.Conv_Ovf_I1_Un); convert.Set (Code.Conv_Ovf_I2); convert.Set (Code.Conv_Ovf_I2_Un); convert.Set (Code.Conv_Ovf_I4); convert.Set (Code.Conv_Ovf_I4_Un); convert.Set (Code.Conv_Ovf_I8); convert.Set (Code.Conv_Ovf_I8_Un); convert.Set (Code.Conv_Ovf_U); convert.Set (Code.Conv_Ovf_U_Un); convert.Set (Code.Conv_Ovf_U1); convert.Set (Code.Conv_Ovf_U1_Un); convert.Set (Code.Conv_Ovf_U2); convert.Set (Code.Conv_Ovf_U2_Un); convert.Set (Code.Conv_Ovf_U4); convert.Set (Code.Conv_Ovf_U4_Un); convert.Set (Code.Conv_Ovf_U8); convert.Set (Code.Conv_Ovf_U8_Un); convert.Set (Code.Conv_R_Un); convert.Set (Code.Conv_R4); convert.Set (Code.Conv_R8); convert.Set (Code.Conv_U); convert.Set (Code.Conv_U1); convert.Set (Code.Conv_U2); convert.Set (Code.Conv_U4); convert.Set (Code.Conv_U8); Console.WriteLine (convert); }
private void Bitmask () { OpCodeBitmask mask = new OpCodeBitmask (); mask.Set (Code.Call); mask.Set (Code.Callvirt); mask.Set (Code.Ldfld); mask.Set (Code.Ldflda); mask.Set (Code.Stfld); mask.Set (Code.Newobj); Console.WriteLine (mask); }
public void Bitmask () { OpCodeBitmask bitmask = new OpCodeBitmask (); bitmask.Set (Code.Isinst); bitmask.Set (Code.Ldnull); bitmask.Set (Code.Ceq); Console.WriteLine (bitmask); }
public void Bitmask () { OpCodeBitmask fields = new OpCodeBitmask (); fields.Set (Code.Ldfld); fields.Set (Code.Ldflda); fields.Set (Code.Ldsfld); fields.Set (Code.Ldsflda); fields.Set (Code.Stfld); fields.Set (Code.Stsfld); Console.WriteLine (fields); }
public void Bitmask () { OpCodeBitmask mask = new OpCodeBitmask (); mask.Set (Code.Ldarg); mask.Set (Code.Ldarg_0); mask.Set (Code.Ldarg_1); mask.Set (Code.Ldarg_2); mask.Set (Code.Ldarg_3); mask.Set (Code.Ldarg_S); mask.Set (Code.Ldarga); mask.Set (Code.Ldarga_S); mask.Set (Code.Ldc_I4); mask.Set (Code.Ldc_I4_0); mask.Set (Code.Ldc_I4_1); mask.Set (Code.Ldc_I4_2); mask.Set (Code.Ldc_I4_3); mask.Set (Code.Ldc_I4_4); mask.Set (Code.Ldc_I4_5); mask.Set (Code.Ldc_I4_6); mask.Set (Code.Ldc_I4_7); mask.Set (Code.Ldc_I4_8); mask.Set (Code.Ldc_I4_M1); mask.Set (Code.Ldc_I4_S); mask.Set (Code.Ldc_I8); mask.Set (Code.Ldc_R4); mask.Set (Code.Ldc_R8); mask.Set (Code.Ldelem_Any); mask.Set (Code.Ldelem_I); mask.Set (Code.Ldelem_I1); mask.Set (Code.Ldelem_I2); mask.Set (Code.Ldelem_I4); mask.Set (Code.Ldelem_I8); mask.Set (Code.Ldelem_R4); mask.Set (Code.Ldelem_R8); mask.Set (Code.Ldelem_Ref); mask.Set (Code.Ldelem_U1); mask.Set (Code.Ldelem_U2); mask.Set (Code.Ldelem_U4); mask.Set (Code.Ldelema); mask.Set (Code.Ldfld); mask.Set (Code.Ldflda); mask.Set (Code.Ldftn); mask.Set (Code.Ldind_I); mask.Set (Code.Ldind_I1); mask.Set (Code.Ldind_I2); mask.Set (Code.Ldind_I4); mask.Set (Code.Ldind_I8); mask.Set (Code.Ldind_R4); mask.Set (Code.Ldind_R8); mask.Set (Code.Ldind_Ref); mask.Set (Code.Ldind_U1); mask.Set (Code.Ldind_U2); mask.Set (Code.Ldind_U4); mask.Set (Code.Ldlen); mask.Set (Code.Ldloc); mask.Set (Code.Ldloc_0); mask.Set (Code.Ldloc_1); mask.Set (Code.Ldloc_2); mask.Set (Code.Ldloc_3); mask.Set (Code.Ldloc_S); mask.Set (Code.Ldloca); mask.Set (Code.Ldloca_S); mask.Set (Code.Ldnull); mask.Set (Code.Ldobj); mask.Set (Code.Ldsfld); mask.Set (Code.Ldsflda); mask.Set (Code.Ldstr); mask.Set (Code.Ldtoken); mask.Set (Code.Ldvirtftn); Console.WriteLine (mask); }
public void Bitmask () { OpCodeBitmask mask = new OpCodeBitmask (); mask.Set (Code.Stfld); mask.Set (Code.Stelem_Ref); Console.WriteLine (mask); }
private void Bitmask () { OpCodeBitmask opcodes_mask = new OpCodeBitmask (); opcodes_mask.Set (Code.Ldftn); opcodes_mask.Set (Code.Call); opcodes_mask.Set (Code.Callvirt); Console.WriteLine (opcodes_mask); }
public void BuildBitmask () { OpCodeBitmask bitmask = new OpCodeBitmask (); bitmask.Set (Code.Ldind_I); bitmask.Set (Code.Ldind_I1); bitmask.Set (Code.Ldind_I2); bitmask.Set (Code.Ldind_I4); bitmask.Set (Code.Ldind_I8); bitmask.Set (Code.Ldind_R4); bitmask.Set (Code.Ldind_R8); bitmask.Set (Code.Ldind_U1); bitmask.Set (Code.Ldind_U2); bitmask.Set (Code.Ldind_U4); Console.WriteLine ("LoadIndirect = {0}", bitmask); bitmask.ClearAll (); bitmask.Set (Code.Stind_I); bitmask.Set (Code.Stind_I1); bitmask.Set (Code.Stind_I2); bitmask.Set (Code.Stind_I4); bitmask.Set (Code.Stind_I8); bitmask.Set (Code.Stind_R4); bitmask.Set (Code.Stind_R8); Console.WriteLine ("StoreIndirect = {0}", bitmask); bitmask.ClearAll (); bitmask.Set (Code.Bge); bitmask.Set (Code.Bge_S); bitmask.Set (Code.Bge_Un); bitmask.Set (Code.Bge_Un_S); bitmask.Set (Code.Bgt); bitmask.Set (Code.Bgt_S); bitmask.Set (Code.Bgt_Un); bitmask.Set (Code.Bgt_Un_S); bitmask.Set (Code.Ble); bitmask.Set (Code.Ble_S); bitmask.Set (Code.Ble_Un); bitmask.Set (Code.Ble_Un_S); bitmask.Set (Code.Blt); bitmask.Set (Code.Blt_S); bitmask.Set (Code.Blt_Un); bitmask.Set (Code.Blt_Un_S); Console.WriteLine ("GreaterOrLesserThan = {0}", bitmask); }
public void BuildConversion () { OpCodeBitmask convert = new OpCodeBitmask (); convert.Set (Code.Conv_I); convert.Set (Code.Conv_I1); convert.Set (Code.Conv_I2); convert.Set (Code.Conv_I4); convert.Set (Code.Conv_I8); convert.Set (Code.Conv_Ovf_I); convert.Set (Code.Conv_Ovf_I_Un); convert.Set (Code.Conv_Ovf_I1); convert.Set (Code.Conv_Ovf_I1_Un); convert.Set (Code.Conv_Ovf_I2); convert.Set (Code.Conv_Ovf_I2_Un); convert.Set (Code.Conv_Ovf_I4); convert.Set (Code.Conv_Ovf_I4_Un); convert.Set (Code.Conv_Ovf_I8); convert.Set (Code.Conv_Ovf_I8_Un); convert.Set (Code.Conv_Ovf_U); convert.Set (Code.Conv_Ovf_U_Un); convert.Set (Code.Conv_Ovf_U1); convert.Set (Code.Conv_Ovf_U1_Un); convert.Set (Code.Conv_Ovf_U2); convert.Set (Code.Conv_Ovf_U2_Un); convert.Set (Code.Conv_Ovf_U4); convert.Set (Code.Conv_Ovf_U4_Un); convert.Set (Code.Conv_Ovf_U8); convert.Set (Code.Conv_Ovf_U8_Un); convert.Set (Code.Conv_Ovf_U); convert.Set (Code.Conv_Ovf_U1); convert.Set (Code.Conv_Ovf_U2); convert.Set (Code.Conv_Ovf_U4); convert.Set (Code.Conv_Ovf_U8); Console.WriteLine (convert); }
public void Bitmask () { OpCodeBitmask mask = new OpCodeBitmask (); mask.Set (Code.Stfld); mask.Set (Code.Stsfld); /* if/when the local variables case is fixed mask.Set (Code.Stloc_0); mask.Set (Code.Stloc_1); mask.Set (Code.Stloc_2); mask.Set (Code.Stloc_3); mask.Set (Code.Stloc); mask.Set (Code.Stloc_S); */ mask.Set (Code.Starg); mask.Set (Code.Starg_S); Console.WriteLine (mask); }
public void Bitmask () { OpCodeBitmask zero = new OpCodeBitmask (); zero.Set (Code.Ldc_I4); zero.Set (Code.Ldc_I4_S); zero.Set (Code.Ldc_I4_0); Console.WriteLine (zero); }
public void Bitmask () { OpCodeBitmask mask = new OpCodeBitmask (); mask.Set (Code.Mul); mask.Set (Code.Mul_Ovf); mask.Set (Code.Mul_Ovf_Un); Console.WriteLine (mask); }
public void BuildRemainder () { OpCodeBitmask remainder = new OpCodeBitmask (); remainder.Set (Code.Rem); remainder.Set (Code.Rem_Un); Console.WriteLine (remainder); }
public void Bitmask () { OpCodeBitmask casts = new OpCodeBitmask (); casts.Set (Code.Castclass); casts.Set (Code.Isinst); Console.WriteLine (casts); }
public void Convert () { OpCodeBitmask Convert8 = new OpCodeBitmask (0x0, 0x0, 0x0, 0x0); Convert8.Set (Code.Conv_I8); Convert8.Set (Code.Conv_U8); Convert8.Set (Code.Conv_Ovf_I8); Convert8.Set (Code.Conv_Ovf_I8_Un); Convert8.Set (Code.Conv_Ovf_U8); Convert8.Set (Code.Conv_Ovf_U8_Un); Console.WriteLine (Convert8); }
static OpCodeBitmask BuildCallsAndNewobjOpCodeBitmask () { #if true return new OpCodeBitmask (0x8000000000, 0x4400000000000, 0x0, 0x0); #else OpCodeBitmask mask = new OpCodeBitmask (); mask.UnionWith (OpCodeBitmask.Calls); mask.Set (Code.Newobj); return mask; #endif }
private static OpCodeBitmask ComparisonsBitmask() { OpCodeBitmask mask = new OpCodeBitmask (); mask.Set (Code.Cgt); mask.Set (Code.Ceq); mask.Set (Code.Clt); mask.Set (Code.Ble); mask.Set (Code.Ble_S); mask.Set (Code.Bge); mask.Set (Code.Bge_S); Console.WriteLine ("ComparisonsBitmask : " + mask); return mask; }
private static OpCodeBitmask BuildInterlockedFriendlyOpCodeBitmask () { #if true return new OpCodeBitmask (0x80063FFFFFFFFF, 0x3f00000001800000, 0x1F30000000000000, 0x5F80); #else OpCodeBitmask mask = new OpCodeBitmask (); mask.UnionWith (OpCodeBitmask.FlowControlBranch); mask.UnionWith (OpCodeBitmask.FlowControlReturn); //locals mask.UnionWith (OpCodeBitmask.LoadLocal); mask.UnionWith (OpCodeBitmask.StoreLocal); //arguments mask.UnionWith (OpCodeBitmask.LoadArgument); mask.UnionWith (OpCodeBitmask.StoreArgument); //fields mask.Set (Code.Ldfld); mask.Set (Code.Ldflda); mask.Set (Code.Stfld); mask.Set (Code.Ldsfld); mask.Set (Code.Ldsflda); mask.Set (Code.Stsfld); //constants mask.Set (Code.Ldnull); mask.Set (Code.Ldc_I4_M1); mask.Set (Code.Ldc_I4_0); mask.Set (Code.Ldc_I4_1); mask.Set (Code.Ldc_I4_2); mask.Set (Code.Ldc_I4_3); mask.Set (Code.Ldc_I4_4); mask.Set (Code.Ldc_I4_5); mask.Set (Code.Ldc_I4_6); mask.Set (Code.Ldc_I4_7); mask.Set (Code.Ldc_I4_8); mask.Set (Code.Ldc_I4_S); mask.Set (Code.Ldc_I4); mask.Set (Code.Ldc_I8); mask.Set (Code.Ldc_R4); mask.Set (Code.Ldc_R8); //safe mask.Set (Code.Dup); mask.Set (Code.Pop); mask.Set (Code.Nop); mask.Set (Code.Break); //could be replace by interlocked call mask.Set (Code.Add); mask.Set (Code.Add_Ovf); mask.Set (Code.Add_Ovf_Un); mask.Set (Code.Sub); mask.Set (Code.Sub_Ovf); mask.Set (Code.Sub_Ovf_Un); return mask; #endif }
public void GenerateBitmask () { OpCodeBitmask bitmask = new OpCodeBitmask (); bitmask.Set (Code.Newobj); bitmask.Set (Code.Throw); Console.WriteLine (bitmask); }
public void Bitmask () { OpCodeBitmask null_compare = new OpCodeBitmask (); null_compare.Set (Code.Brfalse); null_compare.Set (Code.Brfalse_S); null_compare.Set (Code.Brtrue); null_compare.Set (Code.Brtrue_S); Console.WriteLine (null_compare); OpCodeBitmask check = new OpCodeBitmask (); check.UnionWith (OpCodeBitmask.LoadElement); check.UnionWith (OpCodeBitmask.LoadIndirect); check.Set (Code.Ldlen); check.Set (Code.Ldfld); check.Set (Code.Ldflda); check.Set (Code.Stfld); Console.WriteLine (check); }
public void Bitmask () { OpCodeBitmask mask = new OpCodeBitmask (); mask.Set (Code.Div); mask.Set (Code.Div_Un); Console.WriteLine (mask); }
private void Bitmask () { OpCodeBitmask mask = new OpCodeBitmask (); mask.Set (Code.Starg); mask.Set (Code.Starg_S); mask.Set (Code.Stloc_0); mask.Set (Code.Stloc_1); mask.Set (Code.Stloc_2); mask.Set (Code.Stloc_3); mask.Set (Code.Stloc); mask.Set (Code.Stloc_S); mask.Set (Code.Stfld); mask.Set (Code.Stsfld); Console.WriteLine (mask); }
public void Bitmask () { OpCodeBitmask branches = new OpCodeBitmask (); branches.Set (Code.Brfalse); branches.Set (Code.Brfalse_S); branches.Set (Code.Brtrue); branches.Set (Code.Brtrue_S); branches.Set (Code.Bne_Un); branches.Set (Code.Bne_Un_S); branches.Set (Code.Beq); branches.Set (Code.Beq_S); Console.WriteLine (branches); }
private static OpCodeBitmask ConditionsBitmask() { OpCodeBitmask mask = new OpCodeBitmask (); mask.Set (Code.Brtrue); mask.Set (Code.Brtrue_S); mask.Set (Code.Brfalse); mask.Set (Code.Brfalse_S); Console.WriteLine ("ConditionsBitmask : " + mask); return mask; }
public static void GenerateBitmasks () { OpCodeBitmask bitmask; bitmask = new OpCodeBitmask (); bitmask.Set (Code.Stfld); bitmask.Set (Code.Stsfld); bitmask.Set (Code.Call); bitmask.Set (Code.Callvirt); applicable_method_bitmask = bitmask; Console.WriteLine ("applicable_method_bitmask: {0}", bitmask); bitmask = new OpCodeBitmask (); // a list of safe instructions, which under no circumstances // (for verifiable code) can cause an exception to be raised. bitmask = new OpCodeBitmask (); bitmask.Set (Code.Nop); bitmask.Set (Code.Ret); bitmask.Set (Code.Ldloc); bitmask.Set (Code.Ldloc_0); bitmask.Set (Code.Ldloc_1); bitmask.Set (Code.Ldloc_2); bitmask.Set (Code.Ldloc_3); bitmask.Set (Code.Ldloc_S); bitmask.Set (Code.Ldloca); bitmask.Set (Code.Ldloca_S); // This one is needed to load static fields for return values // a method which returns IntPtr should be able to ldsfld IntPtr.Zero bitmask.Set (Code.Ldsfld); // bitmask.Set (Code.Ldsflda); // Not quite sure about this one, leaving it out for now. bitmask.Set (Code.Leave); bitmask.Set (Code.Leave_S); bitmask.Set (Code.Endfilter); bitmask.Set (Code.Endfinally); bitmask.Set (Code.Ldc_I4); bitmask.Set (Code.Ldc_I4_0); bitmask.Set (Code.Ldc_I4_1); bitmask.Set (Code.Ldc_I4_2); bitmask.Set (Code.Ldc_I4_3); bitmask.Set (Code.Ldc_I4_4); bitmask.Set (Code.Ldc_I4_5); bitmask.Set (Code.Ldc_I4_6); bitmask.Set (Code.Ldc_I4_7); bitmask.Set (Code.Ldc_I4_8); bitmask.Set (Code.Ldc_I4_M1); bitmask.Set (Code.Ldc_I8); bitmask.Set (Code.Ldc_R4); bitmask.Set (Code.Ldc_R8); bitmask.Set (Code.Ldarg); bitmask.Set (Code.Ldarg_0); bitmask.Set (Code.Ldarg_1); bitmask.Set (Code.Ldarg_2); bitmask.Set (Code.Ldarg_3); bitmask.Set (Code.Ldarg_S); bitmask.Set (Code.Stloc); bitmask.Set (Code.Stloc_0); bitmask.Set (Code.Stloc_1); bitmask.Set (Code.Stloc_2); bitmask.Set (Code.Stloc_3); bitmask.Set (Code.Stloc_S); bitmask.Set (Code.Stobj); /* Can throw TypeLoadException. This is required to properly initialize out parameters which are ValueTypes */ bitmask.Set (Code.Ldnull); bitmask.Set (Code.Initobj); bitmask.Set (Code.Pop); // The stind* instructions can raise an exception: // "NullReferenceException is thrown if addr is not naturally aligned for the argument type implied by the instruction suffix." // Not sure how we can verify that the alignment is correct, and this instruction is emitted by the compiler for byref/out parameters. // Not marking this instructions as safe would mean that it would be impossible to fix a delegate that takes // a byref/out parameter. bitmask.Set (Code.Stind_I); bitmask.Set (Code.Stind_I1); bitmask.Set (Code.Stind_I2); bitmask.Set (Code.Stind_I4); bitmask.Set (Code.Stind_I8); bitmask.Set (Code.Stind_R4); bitmask.Set (Code.Stind_R8); bitmask.Set (Code.Stind_Ref); safe_instructions = bitmask; Console.WriteLine ("safe_instructions: {0}", bitmask); }