示例#1
0
		public void VisitCompare(Compare compare)
		{
			if (m_offset < 0)
			{
				if (DoMatch2(compare.Index))
				{
					m_offset = compare.Untyped.Offset;						
					Log.DebugLine(this, "DoMatch2 matched at {0:X2}", m_offset);				
				}
				else if (DoMatch2b(compare.Index))
				{
					m_offset = compare.Untyped.Offset;						
					Log.DebugLine(this, "DoMatch2b matched at {0:X2}", m_offset);				
				}
			}
		}
示例#2
0
		public void VisitCompare(Compare op)
		{
			// Compiler sometimes generates this code to return true.
			if (op.Index >= 2)
			{
				// ldc.i4.0 
				// ldc.i4.0 
				// ceq 
				LoadConstantInt rhs = m_info.Instructions[op.Index - 1] as LoadConstantInt;
				LoadConstantInt lhs = m_info.Instructions[op.Index - 2] as LoadConstantInt;
				if (lhs != null && rhs != null && lhs.Value == 0 && rhs.Value == 0)
					return;
			}
			
			if (m_offset < 0)
				DoCheck(op);
		}
示例#3
0
        private TypedInstruction DoGetTyped(MethodDefinition method, Instruction untyped, int index)
        {
            TypedInstruction instruction = null;

            switch (untyped.OpCode.Code)
            {
            case Code.Add:
            case Code.Add_Ovf:
            case Code.Add_Ovf_Un:
            case Code.And:
            case Code.Div:
            case Code.Div_Un:
            case Code.Mul:
            case Code.Mul_Ovf:
            case Code.Mul_Ovf_Un:
            case Code.Or:
            case Code.Rem:
            case Code.Rem_Un:
            case Code.Shl:
            case Code.Shr:
            case Code.Shr_Un:
            case Code.Sub:
            case Code.Sub_Ovf:
            case Code.Sub_Ovf_Un:
            case Code.Xor:
                instruction = new BinaryOp(untyped, index);
                break;

            case Code.Beq:
            case Code.Beq_S:
            case Code.Bge:
            case Code.Bge_S:
            case Code.Bge_Un:
            case Code.Bge_Un_S:
            case Code.Bgt:
            case Code.Bgt_S:
            case Code.Bgt_Un:
            case Code.Bgt_Un_S:
            case Code.Ble:
            case Code.Ble_S:
            case Code.Ble_Un:
            case Code.Ble_Un_S:
            case Code.Blt:
            case Code.Blt_S:
            case Code.Blt_Un:
            case Code.Blt_Un_S:
            case Code.Bne_Un:
            case Code.Bne_Un_S:
            case Code.Brfalse:
            case Code.Brfalse_S:
            case Code.Brtrue:
            case Code.Brtrue_S:
                instruction = new ConditionalBranch(untyped, index);
                break;

            case Code.Box:
                instruction = new Box(untyped, index);
                break;

            case Code.Br:
            case Code.Br_S:
            case Code.Leave:
            case Code.Leave_S:
                instruction = new UnconditionalBranch(untyped, index);
                break;

            case Code.Call:
            case Code.Callvirt:
                instruction = new Call(untyped, index);
                break;

            case Code.Castclass:
            case Code.Isinst:
                instruction = new CastClass(untyped, index);
                break;

            case Code.Ceq:
                instruction = new Ceq(untyped, index);
                break;

            case Code.Cgt:
            case Code.Cgt_Un:
            case Code.Clt:
            case Code.Clt_Un:
                instruction = new Compare(untyped, index);
                break;

            case Code.Conv_I1:
            case Code.Conv_I2:
            case Code.Conv_I4:
            case Code.Conv_I8:
            case Code.Conv_R4:
            case Code.Conv_R8:
            case Code.Conv_U4:
            case Code.Conv_U8:
            case Code.Conv_R_Un:
            case Code.Conv_Ovf_I1_Un:
            case Code.Conv_Ovf_I2_Un:
            case Code.Conv_Ovf_I4_Un:
            case Code.Conv_Ovf_I8_Un:
            case Code.Conv_Ovf_U1_Un:
            case Code.Conv_Ovf_U2_Un:
            case Code.Conv_Ovf_U4_Un:
            case Code.Conv_Ovf_U8_Un:
            case Code.Conv_Ovf_I_Un:
            case Code.Conv_Ovf_U_Un:
            case Code.Conv_Ovf_I1:
            case Code.Conv_Ovf_U1:
            case Code.Conv_Ovf_I2:
            case Code.Conv_Ovf_U2:
            case Code.Conv_Ovf_I4:
            case Code.Conv_Ovf_U4:
            case Code.Conv_Ovf_I8:
            case Code.Conv_Ovf_U8:
            case Code.Conv_U2:
            case Code.Conv_U1:
            case Code.Conv_I:
            case Code.Conv_Ovf_I:
            case Code.Conv_Ovf_U:
            case Code.Conv_U:
                instruction = new Conv(untyped, index);
                break;

            case Code.Endfilter:
            case Code.Endfinally:
            case Code.Ret:
            case Code.Rethrow:
                instruction = new End(untyped, index);
                break;

            case Code.Initobj:
                instruction = new InitObj(untyped, index);
                break;

            case Code.Ldarg_0:
            case Code.Ldarg_1:
            case Code.Ldarg_2:
            case Code.Ldarg_3:
            case Code.Ldarg:
            case Code.Ldarg_S:
                instruction = new LoadArg(method, untyped, index);
                break;

            case Code.Ldarga:
            case Code.Ldarga_S:
                instruction = new LoadArgAddress(method, untyped, index);
                break;

            case Code.Ldc_I4_M1:
            case Code.Ldc_I4_0:
            case Code.Ldc_I4_1:
            case Code.Ldc_I4_2:
            case Code.Ldc_I4_3:
            case Code.Ldc_I4_4:
            case Code.Ldc_I4_5:
            case Code.Ldc_I4_6:
            case Code.Ldc_I4_7:
            case Code.Ldc_I4_8:
            case Code.Ldc_I4_S:
            case Code.Ldc_I4:
            case Code.Ldc_I8:
                instruction = new LoadConstantInt(untyped, index);
                break;

            case Code.Ldc_R4:
            case Code.Ldc_R8:
                instruction = new LoadConstantFloat(untyped, index);
                break;

            case Code.Ldelema:
            case Code.Ldtoken:
                instruction = new LoadPointer(untyped, index);
                break;

            case Code.Ldelem_I1:
            case Code.Ldelem_U1:
            case Code.Ldelem_I2:
            case Code.Ldelem_U2:
            case Code.Ldelem_I4:
            case Code.Ldelem_U4:
            case Code.Ldelem_I8:
            case Code.Ldelem_I:
            case Code.Ldelem_R4:
            case Code.Ldelem_R8:
            case Code.Ldelem_Ref:
            case Code.Ldelem_Any:
            case Code.Ldind_I1:
            case Code.Ldind_U1:
            case Code.Ldind_I2:
            case Code.Ldind_U2:
            case Code.Ldind_I4:
            case Code.Ldind_U4:
            case Code.Ldind_I8:
            case Code.Ldind_I:
            case Code.Ldind_R4:
            case Code.Ldind_R8:
            case Code.Ldind_Ref:
            case Code.Ldlen:
                instruction = new Load(untyped, index);
                break;

            case Code.Ldfld:
                instruction = new LoadField(untyped, index);
                break;

            case Code.Ldflda:
                instruction = new LoadFieldAddress(untyped, index);
                break;

            case Code.Ldftn:
            case Code.Ldvirtftn:
                instruction = new LoadFunctionAddress(untyped, index);
                break;

            case Code.Ldloc_0:
            case Code.Ldloc_1:
            case Code.Ldloc_2:
            case Code.Ldloc_3:
            case Code.Ldloc:
            case Code.Ldloc_S:
                instruction = new LoadLocal(m_symbols, method, untyped, index);
                break;

            case Code.Ldloca:
            case Code.Ldloca_S:
                instruction = new LoadLocalAddress(m_symbols, method, untyped, index);
                break;

            case Code.Ldnull:
                instruction = new LoadNull(untyped, index);
                break;

            case Code.Ldsfld:
                instruction = new LoadStaticField(untyped, index);
                break;

            case Code.Ldsflda:
                instruction = new LoadStaticFieldAddress(untyped, index);
                break;

            case Code.Ldstr:
                instruction = new LoadString(untyped, index);
                break;

            case Code.Newarr:
                instruction = new NewArr(untyped, index);
                break;

            case Code.Newobj:
                instruction = new NewObj(untyped, index);
                break;

            case Code.Starg:
            case Code.Starg_S:
                instruction = new StoreArg(method, untyped, index);
                break;

            case Code.Stelem_I:
            case Code.Stelem_I1:
            case Code.Stelem_I2:
            case Code.Stelem_I4:
            case Code.Stelem_I8:
            case Code.Stelem_R4:
            case Code.Stelem_R8:
            case Code.Stelem_Ref:
            case Code.Stelem_Any:
            case Code.Stind_I:
            case Code.Stind_I1:
            case Code.Stind_I2:
            case Code.Stind_I4:
            case Code.Stind_I8:
            case Code.Stind_R4:
            case Code.Stind_R8:
            case Code.Stobj:
                instruction = new Store(untyped, index);
                break;

            case Code.Stfld:
                instruction = new StoreField(untyped, index);
                break;

            case Code.Stloc_0:
            case Code.Stloc_1:
            case Code.Stloc_2:
            case Code.Stloc_3:
            case Code.Stloc:
            case Code.Stloc_S:
                instruction = new StoreLocal(m_symbols, method, untyped, index);
                break;

            case Code.Stsfld:
                instruction = new StoreStaticField(untyped, index);
                break;

            case Code.Switch:
                instruction = new Switch(untyped, index);
                break;

            case Code.Throw:
                instruction = new Throw(untyped, index);
                break;

            case Code.Unbox:
            case Code.Unbox_Any:
                instruction = new Unbox(untyped, index);
                break;

            default:
                instruction = new CatchAll(untyped, index);
                break;
            }

            return(instruction);
        }