public MethodCallInstruction(uint offset, IVariable result, MethodCallOperation operation, IMethodReference method, IEnumerable <IVariable> arguments)
: base(offset, result)
{
this.Arguments = new List <IVariable>(arguments);
this.Operation = operation;
this.Method = method;
}
public static IList <IMethodReference> PotentialCalleesUsingCHA(IMethodReference unsolvedCallee, IVariable receiver,
MethodCallOperation operation, ClassHierarchyAnalysis CHA)
{
var result = new List <IMethodReference>();
// var unsolvedCallee = invocation.Method;
if (unsolvedCallee.Name.Value.Contains("GetEnumerator"))
{
}
switch (operation)
{
case MethodCallOperation.Static:
result.Add(unsolvedCallee);
break;
case MethodCallOperation.Virtual:
//var receiver = invocation.Arguments[0];
var type = (receiver.Type is IGenericTypeInstanceReference) ? (receiver.Type as IGenericTypeInstanceReference).GenericType : receiver.Type;
if (type is IManagedPointerTypeReference)
{
type = (type as IManagedPointerTypeReference).TargetType;
type = TypeHelper.UninstantiateAndUnspecialize(type);
//type = (type is IGenericTypeInstanceReference) ? (type as IGenericTypeInstanceReference).GenericType : type;
}
var calleeTypes = new List <ITypeReference>(CHA.GetAllSubtypes(type));
//// Hack to get the type from CollectionStubs
//var typeCHA = CHA.Types.SingleOrDefault(t => t.ToString() == type.ToString());
//if (typeCHA != null)
// type = typeCHA;
calleeTypes.Add(type);
var candidateCalless = calleeTypes.Select(t => t.FindMethodImplementationForGenerics(unsolvedCallee)).Where(t => t != null);
var candidateCalless2 = calleeTypes.Select(t => t.FindMethodImplementation(unsolvedCallee)).Where(t => t != null);
candidateCalless = candidateCalless.Union(candidateCalless2);
foreach (var candidate in candidateCalless) // improved this
{
if (!result.Contains(candidate))
{
result.Add(candidate);
}
}
//result.AddRange(candidateCalless);
break;
}
result.Sort(new SubtypeComparer()); // improved this
return(result);
}
public static IList <IMethodReference> PotentialCalleesUsingCHA(IMethodReference unsolvedCallee, IVariable receiver,
MethodCallOperation operation, ClassHierarchyAnalysis CHA)
{
var result = new List <IMethodReference>();
switch (operation)
{
case MethodCallOperation.Static:
result.Add(unsolvedCallee);
break;
case MethodCallOperation.Virtual:
//var receiver = invocation.Arguments[0];
var type = (receiver.Type is IGenericTypeInstanceReference) ? (receiver.Type as IGenericTypeInstanceReference).GenericType : receiver.Type;
if (type is IManagedPointerTypeReference)
{
type = (type as IManagedPointerTypeReference).TargetType;
type = TypeHelper.UninstantiateAndUnspecialize(type);
}
var calleeTypes = new List <ITypeReference>(CHA.GetAllSubtypes(type));
calleeTypes.Add(type);
var candidateCalless = calleeTypes.Select(t => t.FindMethodImplementationForGenerics(unsolvedCallee)).Where(t => t != null);
var candidateCalless2 = calleeTypes.Select(t => t.FindMethodImplementation(unsolvedCallee)).Where(t => t != null);
candidateCalless = candidateCalless.Union(candidateCalless2);
foreach (var candidate in candidateCalless) // improved this
{
if (!result.Contains(candidate))
{
result.Add(candidate);
}
}
break;
}
result.Sort(new SubtypeComparer()); // improved this
return(result);
}
public void VisitMethod(MethodBody mBody, ControlFlowGraph cfg)
{
VisitLocals(mBody);
// Going through the instructions via cfg nodes instead of directly iterating over the instructions
// of the methodBody becuase Phi instructions may not have been inserted in the insts of the methodBody.
foreach (var node in cfg.Nodes)
{
foreach (var instruction in node.Instructions)
{
// System.Console.WriteLine("{0}", instruction.ToString());
// System.Console.WriteLine("{0}", instruction.GetType().FullName());
// System.Console.WriteLine();
if (instruction is LoadInstruction)
{
LoadInstruction lInst = instruction as LoadInstruction;
IValue rhsOperand = lInst.Operand;
if (rhsOperand is StaticFieldAccess)
{
StaticFieldAccess rhsAcc = rhsOperand as StaticFieldAccess;
IFieldReference fld = rhsAcc.Field;
ITypeDefinition fldType = fld.ContainingType.ResolvedType;
Stubber.CheckAndAdd(fldType);
}
// Note: calls to static methods and instance methods appear as a StaticMethodReference
else if (rhsOperand is StaticMethodReference)
{
StaticMethodReference sMethAddr = rhsOperand as StaticMethodReference;
IMethodDefinition tgtMeth = sMethAddr.Method.ResolvedMethod;
ITypeDefinition containingTy = tgtMeth.ContainingTypeDefinition;
Stubber.CheckAndAdd(containingTy);
IMethodDefinition addedMeth = Stubber.CheckAndAdd(tgtMeth);
// addrTakenMethods do not contain templates.
if (addedMeth != null)
{
addrTakenMethods.Add(addedMeth);
}
}
//Note: calls to virtual, abstract or interface methods appear as VirtualMethodReference
else if (rhsOperand is VirtualMethodReference)
{
VirtualMethodReference sMethAddr = rhsOperand as VirtualMethodReference;
IMethodDefinition tgtMeth = sMethAddr.Method.ResolvedMethod;
ITypeDefinition containingTy = tgtMeth.ContainingTypeDefinition;
ITypeDefinition addedTy = Stubber.CheckAndAdd(containingTy);
IMethodDefinition addedMeth = Stubber.CheckAndAdd(tgtMeth);
if (addedTy != null && addedMeth != null)
{
// addrTakenMethods do not contain templates.
addrTakenMethods.Add(addedMeth);
ProcessVirtualInvoke(addedMeth, addedTy, true);
}
}
else if (rhsOperand is Reference)
{
Reference rhsRef = rhsOperand as Reference;
IReferenceable refOf = rhsRef.Value;
if (refOf is StaticFieldAccess)
{
StaticFieldAccess refAcc = refOf as StaticFieldAccess;
IFieldDefinition fld = refAcc.Field.ResolvedField;
ITypeDefinition fldType = fld.ContainingType.ResolvedType;
Stubber.CheckAndAdd(fldType);
addrTakenStatFlds.Add(fld);
}
else if (refOf is IVariable)
{
IVariable refVar = refOf as IVariable;
if (!refVar.Type.IsValueType || refVar.Type.ResolvedType.IsStruct)
{
addrTakenLocals.Add(refVar);
}
}
else if (refOf is InstanceFieldAccess)
{
InstanceFieldAccess refAcc = refOf as InstanceFieldAccess;
IFieldDefinition fld = refAcc.Field.ResolvedField;
addrTakenInstFlds.Add(fld);
}
else if (refOf is ArrayElementAccess)
{
// All arrays will be added into domX as potential address taken.
}
}
}
else if (instruction is StoreInstruction)
{
StoreInstruction sInst = instruction as StoreInstruction;
IAssignableValue lhs = sInst.Result;
if (lhs is StaticFieldAccess)
{
StaticFieldAccess lhsAcc = lhs as StaticFieldAccess;
IFieldReference fld = lhsAcc.Field;
ITypeDefinition fldType = fld.ContainingType.ResolvedType;
Stubber.CheckAndAdd(fldType);
}
}
else if (instruction is CreateObjectInstruction)
{
CreateObjectInstruction newObjInst = instruction as CreateObjectInstruction;
ITypeReference objType = newObjInst.AllocationType;
ITypeDefinition objTypeDef = objType.ResolvedType;
if (objTypeDef is IGenericTypeInstance)
{
objTypeDef = objTypeDef.ResolvedType;
}
ITypeDefinition addedTy = Stubber.CheckAndAdd(objTypeDef);
if (addedTy != null && !allocClasses.Contains(addedTy))
{
allocClasses.Add(addedTy);
}
}
else if (instruction is CreateArrayInstruction)
{
CreateArrayInstruction newArrInst = instruction as CreateArrayInstruction;
ITypeReference elemType = newArrInst.ElementType;
ITypeDefinition elemTypeDef = elemType.ResolvedType;
ITypeDefinition addedTy = Stubber.CheckAndAdd(elemTypeDef);
if (addedTy != null && !allocClasses.Contains(addedTy))
{
allocClasses.Add(addedTy);
}
}
else if (instruction is MethodCallInstruction)
{
MethodCallInstruction invkInst = instruction as MethodCallInstruction;
IMethodReference callTgt = invkInst.Method;
ITypeReference containingType = callTgt.ContainingType;
ITypeDefinition declType = containingType.ResolvedType;
IMethodDefinition callTgtDef = callTgt.ResolvedMethod;
ITypeDefinition addedType = Stubber.CheckAndAdd(declType);
IMethodDefinition addedMeth = Stubber.CheckAndAdd(callTgtDef);
MethodCallOperation callType = invkInst.Operation;
if (callType == MethodCallOperation.Virtual && addedType != null && addedMeth != null)
{
ProcessVirtualInvoke(addedMeth, addedType, false);
}
}
else
{
// System.Console.WriteLine("{0}", instruction.ToString());
// System.Console.WriteLine("Not currently handled: {0}", instruction.GetType().ToString());
// System.Console.WriteLine();
}
}
}
}