Java Examples for com.ibm.wala.classLoader.CallSiteReference

//-------------------------------------------
// MethodAnnotationIteratorDelegate Methods
//-------------------------------------------
//	/**
//	 * Delegate called by the class in order to parse the method annotations.
//	 */
//	public void processMethodAnnotations(MethodIdItem mIdItem,
//			AnnotationSetItem anoSet) {
//		//System.out.println("DexIMethod: processMethodAnnotations()");
//		if ( mIdItem.equals(eMethod.method) ){
//			AnnotationItem[] items = anoSet.getAnnotations();
//			for (AnnotationItem item : items) {
//				logger.debug("ANNOTATION"+item.toString());
//			}
//
//		}
//	}
/**
     *
     * @throws InvalidClassFileException
     * @throws UnsupportedOperationException
     *
     * @todo    Review this implementation - it may be horribly wrong!
     */
@Override
public Collection<CallSiteReference> getCallSites() throws InvalidClassFileException {
    Collection<CallSiteReference> empty = Collections.emptySet();
    if (isNative()) {
        return empty;
    }
    // assert(false) : "Please review getCallSites-Implementation before use!";        // TODO
    ArrayList<CallSiteReference> csites = new ArrayList<CallSiteReference>();
    // XXX The call Sites in this method or to this method?!!!
    for (Instruction inst : instructions()) {
        if (inst instanceof Invoke) {
            // Locate the Target
            MethodReference target = MethodReference.findOrCreate(// XXX: Is this the correct class loader?
            getDeclaringClass().getClassLoader().getReference(), ((Invoke) inst).clazzName, ((Invoke) inst).methodName, ((Invoke) inst).descriptor);
            csites.add(CallSiteReference.make(// programCounter
            inst.pc, // declaredTarget
            target, // invocationCode
            ((Invoke) inst).getInvocationCode()));
            logger.info("\tClass Name:\t" + ((Invoke) inst).clazzName);
            logger.info("\tMethod Name:\t" + ((Invoke) inst).methodName);
            logger.info("\tSignature:\t" + ((Invoke) inst).descriptor);
        }
    }
    return Collections.unmodifiableCollection(csites);
}

/*
	 * The method Object.getClass() has a normal allocation instruction. This
	 * method look for the predecessors of the CGNode containing the normal
	 * allocation instruction. These predecessors make calls to
	 * Object.getClass(). This method iterates over all such invocations and
	 * returns the type names of the receivers of all such method invocations.
	 * This method is an attempt to make the analysis independent of receiver
	 * instance context. But, we encountered several problems while using this
	 * method on contexts lighter than the receiver instance context. For
	 * example, cheaper contexts are less precise and thus report too many
	 * predecessors for a the CGNode of Object.getClass(). And, too many
	 * predecessors result in too many type names to be reported as potential
	 * receivers of a call to getClass. Specifically, several exception classes
	 * get reported as the type names of the receivers of the call to
	 * Object.getClass.
	 */
@Deprecated
private void addSynchronizedClassTypeNames(Set<String> result, NormalAllocationInNode normalAllocationInNode) {
    {
        CGNode normalAllocationCGNode = normalAllocationInNode.getNode();
        Iterator<CGNode> predNodesIterator = basicAnalysisData.callGraph.getPredNodes(normalAllocationCGNode);
        while (predNodesIterator.hasNext()) {
            CGNode predNode = predNodesIterator.next();
            Iterator<CallSiteReference> possibleSitesIterator = basicAnalysisData.callGraph.getPossibleSites(predNode, normalAllocationCGNode);
            while (possibleSitesIterator.hasNext()) {
                CallSiteReference possibleSite = possibleSitesIterator.next();
                SSAAbstractInvokeInstruction[] calls = predNode.getIR().getCalls(possibleSite);
                for (SSAAbstractInvokeInstruction invokeInstruction : calls) {
                    int invocationReceiverValueNumber = invokeInstruction.getReceiver();
                    PointerKey pointerKeyForReceiver = getPointerForValueNumber(predNode, invocationReceiverValueNumber);
                    OrdinalSet<InstanceKey> receiverObjects = basicAnalysisData.pointerAnalysis.getPointsToSet(pointerKeyForReceiver);
                    for (InstanceKey receiverInstanceKey : receiverObjects) {
                        result.add(getJavaClassName(receiverInstanceKey.getConcreteType().getName()));
                    }
                }
            }
        }
    }
}

//do something like: have a base context selector (probably a default one). 
//ask the base selector for a context
//check for the task context of the caller and add the tasks up to some length n
//combine the task string and the base context into a single context
//pretty much, steal from the nCFAContextSelector and its superclass CallStringContextSelector
@Override
public Context getCalleeTarget(CGNode caller, CallSiteReference site, IMethod callee, InstanceKey receiver) {
    Context baseContext = base.getCalleeTarget(caller, site, callee, receiver);
    IR ir = caller.getIR();
    if (WalaConstants.isTaskMethod(site.getDeclaredTarget())) {
        SSAAbstractInvokeInstruction[] invokes = ir.getCalls(site);
        assert invokes.length == 1;
        //0 is the "this" of the invoke, 1 is the "now" parameter (1st param)
        int now = invokes[0].getUse(1);
        SSAInstruction creationSite = caller.getDU().getDef(now);
        TaskCreationSite tcs = new TaskCreationSite(caller.getMethod(), (SSANewInstruction) creationSite);
        return new TaskContextPair(tcs, baseContext);
    } else {
        //normal call
        TaskCreationSite tcs = (TaskCreationSite) caller.getContext().get(TASK_CREATION_SITE);
        return new TaskContextPair(tcs, baseContext);
    }
}