/** * @param method * @return the receiver class for this method. */ private IClass getReceiverClass(IMethod method) { TypeReference formalType = method.getParameterType(0); IClass C = cha.lookupClass(formalType); if (method.isStatic()) { Assertions.UNREACHABLE("asked for receiver of static method " + method); } if (C == null) { Assertions.UNREACHABLE("no class found for " + formalType + " recv of " + method); } return C; }
/* * @see com.ibm.wala.dataflow.IFDS.ISupergraph#isCall(java.lang.Object) */ public boolean isCall(Statement n) { switch (n.getKind()) { case EXC_RET_CALLEE: case EXC_RET_CALLER: case HEAP_PARAM_CALLEE: case NORMAL_RET_CALLEE: case NORMAL_RET_CALLER: case PARAM_CALLEE: case PHI: case HEAP_RET_CALLEE: case HEAP_RET_CALLER: case METHOD_ENTRY: case METHOD_EXIT: case CATCH: case PI: return false; case HEAP_PARAM_CALLER: case PARAM_CALLER: return true; case NORMAL: if (sdg.getCOptions().equals(ControlDependenceOptions.NONE)) { return false; } else { NormalStatement s = (NormalStatement) n; return s.getInstruction() instanceof SSAAbstractInvokeInstruction; } default: Assertions.UNREACHABLE(n.getKind() + " " + n.toString()); return false; } }
/* * @see com.ibm.wala.dataflow.IFDS.ISupergraph#getReturnSites(java.lang.Object) */ public Iterator<? extends Statement> getReturnSites(Statement call, PDG callee) { switch (call.getKind()) { case PARAM_CALLER: { ParamCaller n = (ParamCaller) call; SSAAbstractInvokeInstruction st = n.getInstruction(); PDG pdg = getProcOf(call); return pdg.getCallerReturnStatements(st).iterator(); } case HEAP_PARAM_CALLER: { HeapStatement.HeapParamCaller n = (HeapStatement.HeapParamCaller) call; SSAAbstractInvokeInstruction st = n.getCall(); PDG pdg = getProcOf(call); return pdg.getCallerReturnStatements(st).iterator(); } case NORMAL: { NormalStatement n = (NormalStatement) call; SSAAbstractInvokeInstruction st = (SSAAbstractInvokeInstruction) n.getInstruction(); PDG pdg = getProcOf(call); return pdg.getCallerReturnStatements(st).iterator(); } default: Assertions.UNREACHABLE(call.getKind().toString()); return null; } }
/* * @see com.ibm.wala.dataflow.IFDS.ISupergraph#getCallSites(java.lang.Object) */ public Iterator<? extends Statement> getCallSites(Statement r, PDG callee) { switch (r.getKind()) { case EXC_RET_CALLER: { ExceptionalReturnCaller n = (ExceptionalReturnCaller) r; SSAAbstractInvokeInstruction call = n.getInstruction(); PDG pdg = getProcOf(r); return pdg.getCallStatements(call).iterator(); } case NORMAL_RET_CALLER: { NormalReturnCaller n = (NormalReturnCaller) r; SSAAbstractInvokeInstruction call = n.getInstruction(); PDG pdg = getProcOf(r); return pdg.getCallStatements(call).iterator(); } case HEAP_RET_CALLER: { HeapStatement.HeapReturnCaller n = (HeapStatement.HeapReturnCaller) r; SSAAbstractInvokeInstruction call = n.getCall(); PDG pdg = getProcOf(r); return pdg.getCallStatements(call).iterator(); } default: Assertions.UNREACHABLE(r.getKind().toString()); return null; } }
public boolean isExit(Statement n) { switch (n.getKind()) { case PARAM_CALLEE: case HEAP_PARAM_CALLEE: case HEAP_PARAM_CALLER: case PHI: case PI: case NORMAL_RET_CALLER: case PARAM_CALLER: case HEAP_RET_CALLER: case NORMAL: case EXC_RET_CALLER: case METHOD_ENTRY: case CATCH: return false; case HEAP_RET_CALLEE: case EXC_RET_CALLEE: case NORMAL_RET_CALLEE: case METHOD_EXIT: return true; default: Assertions.UNREACHABLE(n.toString()); return false; } }
/* * @see com.ibm.wala.dataflow.IFDS.ISupergraph#getProcOf(java.lang.Object) */ public PDG getProcOf(Statement n) { CGNode node = n.getNode(); PDG result = sdg.getPDG(node); if (result == null) { Assertions.UNREACHABLE("panic: " + n + " " + node); } return result; }
/* * @see com.ibm.wala.dataflow.IFDS.ISupergraph#getNormalSuccessors(java.lang.Object) */ public Iterator<Statement> getNormalSuccessors(Statement call) { if (!backward) { return EmptyIterator.instance(); } else { Assertions.UNREACHABLE(); return null; } }
/** * @param type * @return a TypeAbstraction object representing this type. We just use ConeTypes by default, * since we don't propagate information allowing us to distinguish between points and cones * yet. */ protected TypeAbstraction typeRef2TypeAbstraction(IClassHierarchy cha, TypeReference type) { IClass klass = cha.lookupClass(type); if (klass != null) { return new ConeType(klass); } Assertions.UNREACHABLE(type.toString()); return null; }
static { try { p = WalaProperties.loadProperties(); p.putAll(WalaExamplesProperties.loadProperties()); } catch (WalaException e) { e.printStackTrace(); Assertions.UNREACHABLE(); } }
/* * @see com.ibm.capa.util.graph.AbstractGraph#getSuccNodeCount(java.lang.Object) */ @Override public int getSuccNodeCount(Object N) throws UnimplementedError { if (N instanceof StaticFieldKey) { Assertions.UNREACHABLE(); return -1; } else { return super.getSuccNodeCount(N); } }
/* * @see com.ibm.capa.util.graph.AbstractNumberedGraph#getPredNodeNumbers(java.lang.Object) */ @Override public IntSet getPredNodeNumbers(Object node) throws UnimplementedError { if (node instanceof StaticFieldKey) { Assertions.UNREACHABLE(); return null; } else { return super.getPredNodeNumbers(node); } }
public IInstruction[] getInstructions() { try { return method.getInstructions(); } catch (InvalidClassFileException e) { e.printStackTrace(); Assertions.UNREACHABLE(); return null; } }
/* * (non-Javadoc) * * @see com.ibm.domo.ssa.SSAInstruction.Visitor#visitPi(com.ibm.domo.ssa.SSAPiInstruction) */ @Override public void visitPi(SSAPiInstruction instruction) { Assertions.UNREACHABLE(); // int dir; // ControlFlowGraph CFG = ir.getControlFlowGraph(); // PointerKey src = getPointerKeyForLocal(node, instruction.getVal()); // if (hasNoInterestingUses(instruction.getDef(), du)) { // PointerKey dst = getPointerKeyForLocal(node, instruction.getDef()); // system.recordImplicitPointsToSet(dst); // } else { // if (com.ibm.domo.cfg.Util.endsWithConditionalBranch(CFG, // getBasicBlock()) && CFG.getSuccNodeCount(getBasicBlock()) == 2) { // SSAConditionalBranchInstruction cond = // com.ibm.domo.cfg.Util.getConditionalBranch(CFG, getBasicBlock()); // SSAInstruction cause = instruction.getCause(); // BasicBlock target = (BasicBlock) // CFG.getNode(instruction.getSuccessor()); // if ((cause instanceof SSAInstanceofInstruction) && ((dir = // booleanConstantTest(cond, cause.getDef())) != 0)) { // TypeReference type = ((SSAInstanceofInstruction) // cause).getCheckedType(); // IClass cls = cha.lookupClass(type); // if (cls == null) { // getWarnings().add(ResolutionFailure.create(node, type)); // PointerKey dst = getPointerKeyForLocal(node, instruction.getDef()); // system.newConstraint(dst, assignOperator, src); // } else { // PointerKey dst = getFilteredPointerKeyForLocal(node, // instruction.getDef(), cls); // if ((target == com.ibm.domo.cfg.Util.getTrueSuccessor(CFG, // getBasicBlock()) && dir == 1) // || (target == com.ibm.domo.cfg.Util.getFalseSuccessor(CFG, // getBasicBlock()) && dir == -1)) { // system.newConstraint(dst, filterOperator, src); // // System.err.println("PI " + dst + " " + src); // } else { // system.newConstraint(dst, inverseFilterOperator, src); // } // } // } else if ((dir = nullConstantTest(cond, instruction.getVal())) != 0) { // if ((target == com.ibm.domo.cfg.Util.getTrueSuccessor(CFG, // getBasicBlock()) && dir == -1) // || (target == com.ibm.domo.cfg.Util.getFalseSuccessor(CFG, // getBasicBlock()) && dir == 1)) { // PointerKey dst = getPointerKeyForLocal(node, instruction.getDef()); // system.newConstraint(dst, assignOperator, src); // } // } else { // PointerKey dst = getPointerKeyForLocal(node, instruction.getDef()); // system.newConstraint(dst, assignOperator, src); // } // } else { // PointerKey dst = getPointerKeyForLocal(node, instruction.getDef()); // system.newConstraint(dst, assignOperator, src); // } // } }
/* * @see com.ibm.wala.cfg.ControlFlowGraph#getProgramCounter(int) */ public int getProgramCounter(int index) { try { return method.getBytecodeIndex(index); } catch (InvalidClassFileException e) { e.printStackTrace(); Assertions.UNREACHABLE(); return -1; } }
@Override public InputStream getInputStream() { try { return url.openConnection().getInputStream(); } catch (IOException e) { Assertions.UNREACHABLE(); return null; } }
protected void declareFunction(CAstEntity N, WalkContext context) { String fnName = composeEntityName(context, N); if (N.getKind() == CAstEntity.SCRIPT_ENTITY) { ((JavaScriptLoader) loader).defineScriptType("L" + fnName, N.getPosition(), N, context); } else if (N.getKind() == CAstEntity.FUNCTION_ENTITY) { ((JavaScriptLoader) loader).defineFunctionType("L" + fnName, N.getPosition(), N, context); } else { Assertions.UNREACHABLE(); } }
/* * @see com.ibm.wala.classLoader.IClass#getDeclaredMethods() */ @Override public Collection<IMethod> getDeclaredMethods() { try { computeMethodMapIfNeeded(); } catch (InvalidClassFileException e) { e.printStackTrace(); Assertions.UNREACHABLE(); } return Collections.unmodifiableCollection(methodMap.values()); }
@Override public String getName() { try { URLConnection con = url.openConnection(); if (con instanceof JarURLConnection) return ((JarURLConnection) con).getEntryName(); else return (new FileProvider()).filePathFromURL(url); } catch (IOException e) { Assertions.UNREACHABLE(); return null; } }
private ExceptionHandler[] getExceptionHandlers() { ExceptionHandler[][] handlers; try { handlers = method.getHandlers(); } catch (InvalidClassFileException e) { e.printStackTrace(); Assertions.UNREACHABLE(); handlers = null; } ExceptionHandler[] hs = handlers[getLastInstructionIndex()]; return hs; }
/* * @see com.ibm.wala.classLoader.IClass#getMethod(com.ibm.wala.types.Selector) */ @Override public IMethod getMethod(Selector selector) { try { computeMethodMapIfNeeded(); } catch (InvalidClassFileException e1) { e1.printStackTrace(); Assertions.UNREACHABLE(); } // my methods + cached parent stuff IMethod result = methodMap.get(selector); if (result != null) { return result; } if (inheritCache != null) { result = inheritCache.get(selector); if (result != null) { return result; } } // check parent, caching if found if (!selector.equals(MethodReference.clinitSelector) && !selector.equals(MethodReference.initSelector)) { IClass superclass = getSuperclass(); if (superclass != null) { IMethod inherit = superclass.getMethod(selector); if (inherit != null) { if (inheritCache == null) { inheritCache = new BimodalMap<Selector, IMethod>(5); } inheritCache.put(selector, inherit); return inherit; } } } // didn't find it yet. special logic for interfaces if (isInterface() || isAbstract()) { final Iterator<IClass> it = getAllImplementedInterfaces().iterator(); // try each superinterface while (it.hasNext()) { IClass k = it.next(); result = k.getMethod(selector); if (result != null) { return result; } } } return null; }
/** * @param args * @throws CancelException * @throws IllegalArgumentException * @throws IOException */ public static void main(String[] args) throws IllegalArgumentException, CancelException, IOException { try { Properties p = new Properties(); p.putAll(WalaProperties.loadProperties()); } catch (WalaException e) { e.printStackTrace(); Assertions.UNREACHABLE(); } runTestCase(TestConstants.JLEX_MAIN, TestConstants.JLEX, "JLex"); // runTestCase(TestConstants.HELLO_MAIN, TestConstants.HELLO, "Hello"); }
@Override public void visitLoadMetadata(SSALoadMetadataInstruction instruction) { Assertions.UNREACHABLE(); // PointerKey def = getPointerKeyForLocal(node, instruction.getDef()); // InstanceKey iKey = // getInstanceKeyForClassObject(instruction.getLoadedClass()); // // if (!contentsAreInvariant(symbolTable, du, instruction.getDef())) { // system.newConstraint(def, iKey); // } else { // system.findOrCreateIndexForInstanceKey(iKey); // system.recordImplicitPointsToSet(def); // } }
/** * Package-visible constructor; only for use by ArrayClassLoader class. 'loader' must be the * Primordial IClassLoader. * * <p>[WHY? -- array classes are loaded by the element classloader??] */ ArrayClass(TypeReference type, IClassLoader loader, IClassHierarchy cha) { this.type = type; this.loader = loader; this.cha = cha; TypeReference elementType = type.getInnermostElementType(); if (!elementType.isPrimitiveType()) { IClass klass = loader.lookupClass(elementType.getName()); if (klass == null) { Assertions.UNREACHABLE("caller should not attempt to create an array with type " + type); } } else { // assert loader.getReference().equals(ClassLoaderReference.Primordial); } }
/** * @param elements List<PathElement> * @return canonical AccessPath object */ public AccessPath findOrCreate(List<PathElement> elements) { if (PARANOID) { for (Iterator<PathElement> it = elements.iterator(); it.hasNext(); ) { if (!(it.next() instanceof PathElement)) { Assertions.UNREACHABLE(); } } } APKey k = new APKey(elements); AccessPath result = map.get(k); if (result == null) { int id = vector.getMaxIndex() + 1; result = new AccessPath(k, id); map.put(k, result); vector.set(id, result); findOrCreateStartsWith(result.getHead()).add(id); } return result; }
/* * @see com.ibm.wala.dataflow.IFDS.ISupergraph#getCalledNodes(java.lang.Object) */ public Iterator<? extends Statement> getCalledNodes(Statement call) { switch (call.getKind()) { case NORMAL: Filter f = new Filter() { public boolean accepts(Object o) { Statement s = (Statement) o; return isEntry(s); } }; return new FilterIterator<Statement>(getSuccNodes(call), f); case PARAM_CALLER: case HEAP_PARAM_CALLER: return getSuccNodes(call); default: Assertions.UNREACHABLE(call.getKind().toString()); return null; } }
/** * @see * com.ibm.wala.ipa.callgraph.propagation.SSAContextInterpreter#getIR(com.ibm.wala.ipa.callgraph.CGNode) */ @Override public IR getIR(CGNode node) { if (node == null) { throw new IllegalArgumentException("node is null"); } assert understands(node); if (DEBUG) { System.err.println("generating IR for " + node); } IMethod method = node.getMethod(); GetMethodContext context = (GetMethodContext) node.getContext(); Map<Integer, ConstantValue> constants = HashMapFactory.make(); if (method.getReference().equals(GET_METHOD)) { Atom name = Atom.findOrCreateAsciiAtom(context.getName()); SSAInstruction instrs[] = makeGetMethodStatements(context, constants, name); return new SyntheticIR( method, context, new InducedCFG(instrs, method, context), instrs, SSAOptions.defaultOptions(), constants); } if (method.getReference().equals(GET_DECLARED_METHOD)) { Atom name = Atom.findOrCreateAsciiAtom(context.getName()); SSAInstruction instrs[] = makeGetDeclaredMethodStatements(context, constants, name); return new SyntheticIR( method, context, new InducedCFG(instrs, method, context), instrs, SSAOptions.defaultOptions(), constants); } Assertions.UNREACHABLE("Unexpected method " + node); return null; }
/** * Add any exceptional edges generated by the last instruction in a basic block. * * @param last the last instruction in a basic block. */ protected void addExceptionalEdges(IInstruction last) { IClassHierarchy cha = getMethod().getClassHierarchy(); if (last.isPEI()) { Collection<TypeReference> exceptionTypes = null; boolean goToAllHandlers = false; ExceptionHandler[] hs = getExceptionHandlers(); if (last instanceof ThrowInstruction) { // this class does not have the type information needed // to determine what the athrow throws. So, add an // edge to all reachable handlers. Better information can // be obtained later with SSA type propagation. // TODO: consider pruning to only the exception types that // this method either catches or allocates, since these are // the only types that can flow to an athrow. goToAllHandlers = true; } else { if (hs != null && hs.length > 0) { IClassLoader loader = getMethod().getDeclaringClass().getClassLoader(); BytecodeLanguage l = (BytecodeLanguage) loader.getLanguage(); exceptionTypes = l.getImplicitExceptionTypes(last); if (last instanceof IInvokeInstruction) { IInvokeInstruction call = (IInvokeInstruction) last; exceptionTypes = HashSetFactory.make(exceptionTypes); MethodReference target = MethodReference.findOrCreate( l, loader.getReference(), call.getClassType(), call.getMethodName(), call.getMethodSignature()); try { exceptionTypes.addAll(l.inferInvokeExceptions(target, cha)); } catch (InvalidClassFileException e) { e.printStackTrace(); Assertions.UNREACHABLE(); } } } } if (hs != null && hs.length > 0) { // found a handler for this PEI // create a mutable copy if (!goToAllHandlers) { exceptionTypes = HashSetFactory.make(exceptionTypes); } // this var gets set to false if goToAllHandlers is true but some enclosing exception // handler catches all // exceptions. in such a case, we need not add an exceptional edge to the method exit boolean needEdgeToExitForAllHandlers = true; for (int j = 0; j < hs.length; j++) { if (DEBUG) { System.err.println(" handler " + hs[j]); } BasicBlock b = getBlockForInstruction(hs[j].getHandler()); if (DEBUG) { System.err.println(" target " + b); } if (goToAllHandlers) { // add an edge to the catch block. if (DEBUG) { System.err.println(" gotoAllHandlers " + b); } addExceptionalEdgeTo(b); // if the handler catches all exceptions, we don't need to add an edge to the exit or // any other handlers if (hs[j].getCatchClass() == null) { needEdgeToExitForAllHandlers = false; break; } } else { TypeReference caughtException = null; if (hs[j].getCatchClass() != null) { ClassLoaderReference loader = ShrikeCFG.this.getMethod().getDeclaringClass().getReference().getClassLoader(); caughtException = ShrikeUtil.makeTypeReference(loader, hs[j].getCatchClass()); if (DEBUG) { System.err.println(" caughtException " + caughtException); } IClass caughtClass = cha.lookupClass(caughtException); if (caughtClass == null) { // conservatively add the edge, and raise a warning addExceptionalEdgeTo(b); Warnings.add(FailedExceptionResolutionWarning.create(caughtException)); // null out caughtException, to avoid attempting to process it caughtException = null; } } else { if (DEBUG) { System.err.println(" catchClass() == null"); } // hs[j].getCatchClass() == null. // this means that the handler catches all exceptions. // add the edge and null out all types if (!exceptionTypes.isEmpty()) { addExceptionalEdgeTo(b); exceptionTypes.clear(); caughtException = null; } } if (caughtException != null) { IClass caughtClass = cha.lookupClass(caughtException); // the set "caught" should be the set of exceptions that MUST // have been caught by the handlers in scope ArrayList<TypeReference> caught = new ArrayList<TypeReference>(exceptionTypes.size()); // check if we should add an edge to the catch block. for (TypeReference t : exceptionTypes) { if (t != null) { IClass klass = cha.lookupClass(t); if (klass == null) { Warnings.add(FailedExceptionResolutionWarning.create(caughtException)); // conservatively add an edge addExceptionalEdgeTo(b); } else { boolean subtype1 = cha.isSubclassOf(klass, caughtClass); if (subtype1 || cha.isSubclassOf(caughtClass, klass)) { // add the edge and null out the type from the array addExceptionalEdgeTo(b); if (subtype1) { caught.add(t); } } } } } exceptionTypes.removeAll(caught); } } } // if needed, add an edge to the exit block. if ((exceptionTypes == null && needEdgeToExitForAllHandlers) || (exceptionTypes != null && !exceptionTypes.isEmpty())) { BasicBlock exit = exit(); addExceptionalEdgeTo(exit); } } else { // found no handler for this PEI ... link to the exit block. BasicBlock exit = exit(); addExceptionalEdgeTo(exit); } } }
private void makeBasicBlocks() { ExceptionHandler[][] handlers; try { handlers = method.getHandlers(); } catch (InvalidClassFileException e) { e.printStackTrace(); Assertions.UNREACHABLE(); handlers = null; } boolean[] r = new boolean[getInstructions().length]; boolean[] catchers = new boolean[getInstructions().length]; // we initially start with both the entry and exit block. int blockCount = 2; // Compute r so r[i] == true iff instruction i begins a basic block. // While doing so count the number of blocks. r[0] = true; IInstruction[] instructions = getInstructions(); for (int i = 0; i < instructions.length; i++) { int[] targets = instructions[i].getBranchTargets(); // if there are any targets, then break the basic block here. // also break the basic block after a return if (targets.length > 0 || !instructions[i].isFallThrough()) { if (i + 1 < instructions.length && !r[i + 1]) { r[i + 1] = true; blockCount++; } } for (int j = 0; j < targets.length; j++) { if (!r[targets[j]]) { r[targets[j]] = true; blockCount++; } } if (instructions[i].isPEI()) { ExceptionHandler[] hs = handlers[i]; // break the basic block here. if (i + 1 < instructions.length && !r[i + 1]) { r[i + 1] = true; blockCount++; } if (hs != null && hs.length > 0) { for (int j = 0; j < hs.length; j++) { exceptionHandlers.add(hs[j]); if (!r[hs[j].getHandler()]) { // we have not discovered the catch block yet. // form a new basic block r[hs[j].getHandler()] = true; blockCount++; } catchers[hs[j].getHandler()] = true; } } } } BasicBlock entry = new BasicBlock(-1); addNode(entry); int j = 1; for (int i = 0; i < r.length; i++) { if (r[i]) { BasicBlock b = new BasicBlock(i); addNode(b); if (catchers[i]) { setCatchBlock(j); } j++; } } BasicBlock exit = new BasicBlock(-1); addNode(exit); }
private static List<Pair<CGNode, SSACheckCastInstruction>> findFailingCasts( CallGraph cg, DemandRefinementPointsTo dmp) { final IClassHierarchy cha = dmp.getClassHierarchy(); List<Pair<CGNode, SSACheckCastInstruction>> failing = new ArrayList<Pair<CGNode, SSACheckCastInstruction>>(); int numSafe = 0, numMightFail = 0; outer: for (Iterator<? extends CGNode> nodeIter = cg.iterator(); nodeIter.hasNext(); ) { CGNode node = nodeIter.next(); TypeReference declaringClass = node.getMethod().getReference().getDeclaringClass(); // skip library classes if (declaringClass.getClassLoader().equals(ClassLoaderReference.Primordial)) { continue; } IR ir = node.getIR(); if (ir == null) continue; SSAInstruction[] instrs = ir.getInstructions(); for (int i = 0; i < instrs.length; i++) { if (numSafe + numMightFail > MAX_CASTS) break outer; SSAInstruction instruction = instrs[i]; if (instruction instanceof SSACheckCastInstruction) { SSACheckCastInstruction castInstr = (SSACheckCastInstruction) instruction; final TypeReference[] declaredResultTypes = castInstr.getDeclaredResultTypes(); boolean primOnly = true; for (TypeReference t : declaredResultTypes) { if (!t.isPrimitiveType()) { primOnly = false; } } if (primOnly) { continue; } System.err.println("CHECKING " + castInstr + " in " + node.getMethod()); PointerKey castedPk = heapModel.getPointerKeyForLocal(node, castInstr.getUse(0)); Predicate<InstanceKey> castPred = new Predicate<InstanceKey>() { @Override public boolean test(InstanceKey ik) { TypeReference ikTypeRef = ik.getConcreteType().getReference(); for (TypeReference t : declaredResultTypes) { if (cha.isAssignableFrom(cha.lookupClass(t), cha.lookupClass(ikTypeRef))) { return true; } } return false; } }; long startTime = System.currentTimeMillis(); Pair<PointsToResult, Collection<InstanceKey>> queryResult = dmp.getPointsTo(castedPk, castPred); long runningTime = System.currentTimeMillis() - startTime; System.err.println("running time: " + runningTime + "ms"); final FieldRefinePolicy fieldRefinePolicy = dmp.getRefinementPolicy().getFieldRefinePolicy(); switch (queryResult.fst) { case SUCCESS: System.err.println("SAFE: " + castInstr + " in " + node.getMethod()); if (fieldRefinePolicy instanceof ManualFieldPolicy) { ManualFieldPolicy hackedFieldPolicy = (ManualFieldPolicy) fieldRefinePolicy; System.err.println(hackedFieldPolicy.getHistory()); } System.err.println("TRAVERSED " + dmp.getNumNodesTraversed() + " nodes"); numSafe++; break; case NOMOREREFINE: if (queryResult.snd != null) { System.err.println( "MIGHT FAIL: no more refinement possible for " + castInstr + " in " + node.getMethod()); } else { System.err.println( "MIGHT FAIL: exceeded budget for " + castInstr + " in " + node.getMethod()); } failing.add(Pair.make(node, castInstr)); numMightFail++; break; case BUDGETEXCEEDED: System.err.println( "MIGHT FAIL: exceeded budget for " + castInstr + " in " + node.getMethod()); failing.add(Pair.make(node, castInstr)); numMightFail++; break; default: Assertions.UNREACHABLE(); } } } // break outer; } System.err.println("TOTAL SAFE: " + numSafe); System.err.println("TOTAL MIGHT FAIL: " + numMightFail); return failing; }
/* * @see com.ibm.wala.classLoader.IClass#getAllFields() */ @Override public Collection<IField> getAllFields() { Assertions.UNREACHABLE(); return null; }