コード例 #1
0
		// We no longer have the machinery in place to do this right so what we'll
		// do is catch the most common failures which tend to be simple mistakes
		// like recursive properties. We'll do this by failing if we have a recursive
		// call and no early returns or branches.
		public void VisitReturn(End end)
		{
			if (!m_hasBranch && end.Index < m_info.Instructions.Length - 1)
			{
				m_hasBranch = true;
				Log.DebugLine(this, "early return at {0:X2}", end.Untyped.Offset); 
			}
		}
コード例 #2
0
ファイル: ExitCodeRule.cs プロジェクト: dbremner/smokey
		public void VisitRet(End end)
		{
			if (m_isMain && m_offset < 0 && end.Index > 0)
			{
				if (end.Untyped.OpCode.Code == Code.Ret)
				{
					Log.DebugLine(this, "checking {0}", end);	
					DoCheckLoad(end);
				}
			}
		}
コード例 #3
0
		// match:
		// 		ldsfld     field
		// 		ret        
		public void VisitRet(End end)	
		{
			if (m_needsCheck && !m_foundRet && m_foundSingle)
			{
				if (end.Untyped.OpCode.Code == Code.Ret && end.Index > 1)
				{
					LoadStaticField load = m_info.Instructions[end.Index - 1] as LoadStaticField;
					if (load != null && load.Field == m_field)
					{
						Log.DebugLine(this, "found return at {0:X2}", end.Untyped.Offset);
						m_foundRet = true;
					}
				}
			}
		}
コード例 #4
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);
        }
コード例 #5
0
		// In general an Equals method will be either completely wrong or correct.
		// But correct methods often have a lot of control flow with early returns
		// which make them difficult to analyze. So, we'll be conservative and
		// consider a method OK if it contains an early return or is check.
		public void VisitReturn(End end)
		{
			if (m_needsCheck && !m_foundEarlyReturn && end.Index < m_info.Instructions.Length - 1 && m_offset < 0)
			{
				m_foundEarlyReturn = true;
				Log.DebugLine(this, "early return {0:X2}", end.Untyped.Offset); 
			}
		}