public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_offset = DoHasBadDemand(begin.Info.Method) ? 0 : -1;
}
public void VisitMethod(BeginMethod begin)
{
foreach (ParameterDefinition p in begin.Info.Method.Parameters)
{
DoAdd(p.Name);
}
}
public void VisitBegin(BeginMethod method)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", method.Info.Instructions);
// Loop through each try block,
int offset = -1;
for (int i = 0; i < method.Info.Instructions.TryCatchCollection.Length && offset < 0; ++i)
{
TryCatch tc = method.Info.Instructions.TryCatchCollection[i];
// and the associated catch blocks,
for (int j = 0; j < tc.Catchers.Count && offset < 0; ++j)
{
CatchBlock cb = tc.Catchers[j];
// if the first instruction in a catch is a store local then the code
// is storing a reference to the exception object and we need to check
// to see if it's being rethrown.
StoreLocal store = method.Info.Instructions[cb.Index] as StoreLocal;
if (store != null)
offset = DoCheckCatch(method.Info.Instructions, cb, store.Variable);
}
}
if (offset >= 0)
Reporter.MethodFailed(method.Info.Method, CheckID, offset, string.Empty);
}
public void VisitMethodBegin(BeginMethod begin)
{
m_inDispose = false;
if (m_disposable)
{
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
MethodDefinition method = begin.Info.Method;
if (method.Name == "Finalize")
{
MethodDefinition previous = method.GetBasestMethod(Cache);
if (previous != null && previous != method)
{
Log.DebugLine(this, "finalizer overrides {0}", previous);
m_hasFinalizer = true;
}
}
if (method.Matches("System.Void", "Dispose"))
{
Log.DebugLine(this, "has Dispose()");
m_hasDispose = true;
}
if (method.Matches("System.Void", "Dispose", "System.Boolean"))
{
Log.DebugLine(this, "has Dispose(bool)");
m_disposeMethod = method;
m_inDispose = true;
}
}
}
public void VisitBeginMethod(BeginMethod begin)
{
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_info = begin.Info;
m_offset = -1;
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_numVirtuals = 0.0f;
m_needsCheck = false;
m_type = begin.Info.Type;
m_virtuals.Clear();
MethodDefinition method = begin.Info.Method;
if (method.IsVirtual && !method.IsFinal && method.IsNewSlot)
if (!m_type.IsSealed && !m_type.IsNestedPrivate)
if (method.Body != null)
if (method.Body.Instructions.Count >= m_limit/4)
m_needsCheck = true;
if (m_needsCheck)
foreach (MethodDefinition m in m_type.Methods)
if (m.IsVirtual && !m.IsFinal)
m_virtuals.Add(m.MetadataToken);
if (method.Body != null)
Log.DebugLine(this, "numInstructions: {0}", method.Body.Instructions.Count);
}
public void VisitBegin(BeginMethod begin)
{
if (m_needsCheck)
{
m_failed = DoHasAssert(begin.Info.Method.SecurityDeclarations);
}
}
public void VisitMethod(BeginMethod begin)
{
Log.DebugLine(this, "++++++++++++++++++++++++");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_type = begin.Info.Type;
}
public void VisitBegin(BeginMethod method)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", method.Info.Instructions);
m_offset = -1;
}
public void VisitBegin(BeginMethod begin)
{
m_offset = -1;
m_info = begin.Info;
m_badArg = null;
m_needsCheck = OnNeedsCheck(m_info.Type) && OnNeedsCheck(m_info.Type, m_info.Method);
m_table.Clear();
if (m_needsCheck)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
foreach (ParameterDefinition p in m_info.Method.Parameters)
{
if (!p.ParameterType.IsValueType)
{
Log.DebugLine(this, "{0} is a reference type", p.Name);
m_table.Add(p.Name, false);
}
}
}
if (m_table.Count == 0)
m_needsCheck = false;
}
internal void Dispatch(MethodInfo info)
{
DoSetExcluding(info.Method.ToString());
BeginMethod begin = new BeginMethod();
begin.Info = info;
DoVisit(begin);
m_visited.Clear();
if (info.Method.Body != null)
{
for (int i = 0; i < info.Graph.Roots.Length; ++i)
{
if (m_visited.IndexOf(info.Graph.Roots[i]) < 0)
{
DoVisit(info.Instructions, info.Graph.Roots[i], info.Instructions.Length - 1, 0, int.MinValue);
}
}
}
EndMethod end = new EndMethod();
end.Info = info;
DoVisit(end);
info.Reset(); // free up large objects we won't use again
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "checking {0}", begin.Info.Method);
TypeReference type = begin.Info.Method.GetDeclaredIn(Cache);
if (type != null)
{
TypeDefinition td = Cache.FindType(type);
if (td != null && td.IsInterface && !td.IsPublic && !td.IsNestedPublic)
{
Log.DebugLine(this, " implements {0}", type);
if (begin.Info.Type.ExternallyVisible(Cache))
{
Log.DebugLine(this, " declaring type is externally visible");
if (begin.Info.Method.IsVirtual && !begin.Info.Method.IsFinal)
{
Log.DebugLine(this, " is virtual");
if (DoHasPublicCtor(begin.Info.Type))
{
Log.DebugLine(this, " has public ctor");
string details = "Interface: " + type.FullName;
Reporter.MethodFailed(begin.Info.Method, CheckID, 0, details);
}
}
}
}
}
}
public void VisitBegin(BeginMethod begin)
{
m_needsCheck = false;
m_missingBaseCall = true;
m_type = begin.Info.Type;
m_method = begin.Info.Method;
if (m_method.IsConstructor)
{
if (m_type.ExternallyVisible(Cache))
{
if (m_type.BaseImplements("System.Runtime.Serialization.ISerializable", Cache))
{
if (m_method.Parameters.Count == 2)
{
if (m_method.Parameters[0].ParameterType.FullName == "System.Runtime.Serialization.SerializationInfo" &&
m_method.Parameters[1].ParameterType.FullName == "System.Runtime.Serialization.StreamingContext")
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_needsCheck = true;
}
}
}
}
}
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "---------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_info = begin.Info;
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_offset = -1;
m_info = begin.Info;
m_args.Clear();
bool badNames = false;
for (int i = 0; i < begin.Info.Method.Parameters.Count; ++i)
{
ParameterReference p = begin.Info.Method.Parameters[i];
if (!p.Name.StartsWith("A_"))
{
Log.DebugLine(this, "adding {0}", p.Name);
m_args.Add(p.Name);
}
else
{
Log.DebugLine(this, "skipping {0}", p.Name);
badNames = true;
}
}
if (begin.Info.Method.Name.StartsWith("set_"))
{
m_args.Add(begin.Info.Method.Name.Substring(4));
m_args.Add("value");
Log.DebugLine(this, "added value and {0}", begin.Info.Method.Name.Substring(4));
}
if (badNames)
m_args.Clear();
}
public void VisitBegin(BeginMethod begin)
{
if (!begin.Info.Method.IsVirtual)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0}", begin.Info.Instructions);
string details = string.Empty;
List<MethodDefinition> methods = new List<MethodDefinition>();
if (begin.Info.Type.BaseType != null)
DoGetBaseMethods(begin.Info.Type.BaseType, begin.Info.Method, methods);
foreach (MethodDefinition method in methods)
{
if (DoLeftHidesRight(begin.Info.Method, method))
details = string.Format("{0} hides {1}. {2}", begin.Info.Method, method, details);
}
if (details.Length > 0)
{
Log.DebugLine(this, details);
Reporter.MethodFailed(begin.Info.Method, CheckID, 0, details);
}
}
}
public void VisitMethod(BeginMethod begin)
{
if (m_table.TryGetValue(begin.Info.Method, out m_entry))
{
Log.DebugLine(this, "{0}", begin.Info.Method);
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
}
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_offset = -1;
m_numUnboxes = 0;
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_needsCheck = !begin.Info.Type.Name.Contains("Permission");
m_offset = -1;
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_newOffsets.Clear();
m_setCount = 0;
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_offset = -1;
m_details = string.Empty;
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_needsCheck = begin.Info.Method.Name.StartsWith("set_");
m_found1 = false;
m_found2 = false;
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_offset = -1;
m_foundCtor = false;
m_foundLocale = false;
}
protected virtual bool OnNeedsCheck(BeginMethod begin)
{
bool needs = false;
if (begin.Info.Method.Body != null && begin.Info.Method.Body.ExceptionHandlers.Count == 0)
if (begin.Info.Method.Reuses("System.Boolean", "Equals", "System.Object"))
needs = true;
return needs;
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_offset = -1;
m_bad = null;
m_info = begin.Info;
m_needsCheck = !begin.Info.Method.IsCompilerGenerated(); // TODO: why are we even called for these?
}
public void VisitMethodBegin(BeginMethod begin)
{
if (m_disposable)
{
MethodDefinition method = begin.Info.Method;
if (method.Matches("System.Void", "Dispose", "System.Boolean"))
m_hasUnaryDispose = true;
}
}
public void VisitBegin(BeginMethod begin)
{
m_needsCheck = true;
m_offset = -1;
if (m_needsCheck)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
}
}
public void VisitBegin(BeginMethod begin)
{
m_needsCheck = m_gui && !begin.Info.Method.CustomAttributes.Has("ConditionalAttribute");
m_offset = -1;
if (m_needsCheck)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
}
}
public void VisitBegin(BeginMethod method)
{
m_offset = -1;
m_needsCheck = method.Info.Method.Reuses("System.Int32", "GetHashCode") && !method.Info.Method.IsCompilerGenerated();
if (m_needsCheck)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", method.Info.Instructions);
}
}
public void VisitBegin(BeginMethod begin)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", begin.Info.Instructions);
m_offset = -1;
m_info = begin.Info;
m_isMain = Cache.Assembly.EntryPoint == begin.Info.Method;
m_stores.Clear();
m_candidateLoads.Clear();
}
public void VisitBegin(BeginMethod method)
{
Log.DebugLine(this, "-----------------------------------");
Log.DebugLine(this, "{0:F}", method.Info.Instructions);
m_max = DoIsIFormattableToString(method.Info.Method) ? 1 : 0;
Log.DebugLine(this, "m_max = {0}", m_max);
m_offset = -1;
m_count = 0;
}
