Dataflow<LockCount> dataflow = getLockCountDataflow(cfg, methodGen);
Dataflow<LockCount, LockCountAnalysis> dataflow = getLockCountDataflow(cfg, methodGen);
	public void startClass(ClassContext classContext) {		JavaClass jclass = classContext.getJavaClass();		String className = jclass.getClassName();		//System.out.println("********** " + className + " *************");		// Examine fields of this class so we know which ones are public, volatile, and/or final.		// We don't bother finding this out for other fields (since that would involve looking		// at other classes).		org.apache.bcel.classfile.Field[] jfields = jclass.getFields();		for (int i = 0; i < jfields.length; ++i) {			org.apache.bcel.classfile.Field jfield = jfields[i];			String fieldName = jfield.getName();			String fieldSig = jfield.getSignature();			boolean isStatic = jfield.isStatic();			if (jfield.isPublic())				publicFields.add(new FieldAnnotation(className, fieldName, fieldSig, isStatic));			else if (jfield.isVolatile() || jfield.isFinal())				volatileAndFinalFields.add(new FieldAnnotation(className, fieldName, fieldSig, isStatic));		}		// If fis.ignorecallsites property is set, then default to old behavior		// of not looking at where private methods are called from.		if (IGNORE_CALL_SITES)			return;		// Build map of sites of self calls.		// We are only interested in calls to non-public methods.		this.selfCalls = new SelfCalls(classContext) {			public boolean wantCallsFor(Method method) {				return !method.isPublic();			}		};		try {			selfCalls.execute();		} catch (CFGBuilderException e) {			throw new AnalysisException(e.getMessage());		}		// If the class contains ABSOLUTELY NO EXPLICIT SYNCHRONIZATION,		// then don't bother examining call sites.  That would only confuse matters.		if (!selfCalls.hasSynchronization())			return;		try {			// Build set of private methods all of whose self-call sites have			// an interesting lock held.  This is a common idiom in Java code,			// and we can (hopefully) eliminate a lot of false positives by			// considering field accesses in such methods as locked, rather			// than unlocked.			for (Iterator<Method> i = selfCalls.calledMethodIterator(); i.hasNext(); ) {				Method called = i.next();				Set<CallSite> callSiteSet = selfCalls.getCallSites(called);				boolean allSitesLocked = true;			siteLoop:				for (Iterator<CallSite> j = callSiteSet.iterator(); j.hasNext(); ) {					CallSite callSite = j.next();					Method method = callSite.getMethod();					BasicBlock basicBlock = callSite.getBasicBlock();					InstructionHandle handle = callSite.getHandle();					// If call site is constructor, ignore					if (isConstructor(method.getName()))						continue siteLoop;					// Get lock counts for call site method					CFG cfg;					try {						cfg = classContext.getCFG(method);					} catch (CFGBuilderException e) {						throw new AnalysisException(e.getMessage());					}					MethodGen methodGen = classContext.getMethodGen(method);					Dataflow<LockCount> dataflow = getLockCountDataflow(cfg, methodGen);					// Is the call site locked?					LockCount lockCount = getLockCount(dataflow, handle, basicBlock);					if (lockCount.getCount() <= 0) {						// No lock held at this site						if (DEBUG) System.out.println("Unlocked call to " + jclass.getClassName() + "." + called.getName()  +							" from method " +methodGen.getClassName() + "." + methodGen.getName() );						allSitesLocked = false;						break siteLoop;					}				}				if (allSitesLocked) {					MethodGen calledMG = classContext.getMethodGen(called);					if (DEBUG) System.out.println("All call sites locked for " + calledMG.getClassName() + "." + calledMG.getName());					lockedPrivateMethods.add(calledMG);				}			}		} catch (DataflowAnalysisException e) {			throw new AnalysisException(e.toString());		}	}