@Override public PointerKey getPointerKeyForLocal(CGNode node, int valueNumber) { return h.getPointerKeyForLocal(node, valueNumber); }
@Override public PointerKey getPointerKeyForInstanceField(InstanceKey I, IField field) { return delegate.getPointerKeyForInstanceField(I, field); }
@Override public PointerKey getPointerKeyForArrayContents(InstanceKey I) { return delegate.getPointerKeyForArrayContents(I); }
@Override public PointerKey getPointerKeyForLocal(CGNode node, int valueNumber) { if (!node.getMethod().isStatic() && valueNumber == 1) { return delegate.getFilteredPointerKeyForLocal(node, valueNumber, getFilter(node)); } else { return delegate.getPointerKeyForLocal(node, valueNumber); } }
public void visitPutInternal(int rval, int ref, boolean isStatic, FieldReference field) { IField f = cg.getClassHierarchy().resolveField(field); if (f == null) { return; } PointerKey use = heapModel.getPointerKeyForLocal(node, rval); assert use != null; if (isStatic) { PointerKey fKey = heapModel.getPointerKeyForStaticField(f); addNode(use); addNode(fKey); // TODO assign global edge addEdge(fKey, use, AssignGlobalLabel.v()); } else { PointerKey refKey = heapModel.getPointerKeyForLocal(node, ref); addNode(use); addNode(refKey); addEdge(refKey, use, PutFieldLabel.make(f)); } }
InstanceKey iKey = heapModel.getInstanceKeyForAllocation(node, instruction.getNewSite()); if (iKey == null) { return null; PointerKey def = heapModel.getPointerKeyForLocal(node, instruction.getDef()); InstanceKey ik = heapModel.getInstanceKeyForMultiNewArray(node, instruction.getNewSite(), dim); PointerKey pk = heapModel.getPointerKeyForArrayContents(lastInstance);
for (IField sf : staticFields) { if (sf.getFieldTypeReference().isReferenceType()) { escapeAnalysisRoots.add(heapModel.getPointerKeyForStaticField(sf)); Set<CGNode> nodes = cg.getNodes(m.getReference()); for (CGNode n : nodes) { escapeAnalysisRoots.add(heapModel.getPointerKeyForLocal(n, 1)); if (type.isArrayClass()) { if (((ArrayClass) type).getElementClass() != null) { PointerKey fk = heapModel.getPointerKeyForArrayContents(key); OrdinalSet<? extends InstanceKey> fobjects = pa.getPointsToSet(fk); for (InstanceKey fobj : fobjects) { for (IField f : fields) { if (f.getFieldTypeReference().isReferenceType()) { PointerKey fk = heapModel.getPointerKeyForInstanceField(key, f); OrdinalSet<? extends InstanceKey> fobjects = pa.getPointsToSet(fk); for (InstanceKey fobj : fobjects) {
/** * convert a pointer key to one in the memory access map's heap model * * TODO move this somewhere more appropriate * * @throws UnsupportedOperationException if it doesn't know how to handle a {@link PointerKey} */ public static PointerKey convertPointerKeyToHeapModel(PointerKey pk, HeapModel h) { if (pk == null) { throw new IllegalArgumentException("null pk"); } if (pk instanceof LocalPointerKey) { LocalPointerKey lpk = (LocalPointerKey) pk; return h.getPointerKeyForLocal(lpk.getNode(), lpk.getValueNumber()); } else if (pk instanceof ArrayContentsKey) { ArrayContentsKey ack = (ArrayContentsKey) pk; InstanceKey ik = ack.getInstanceKey(); if (ik instanceof NormalAllocationInNode) { NormalAllocationInNode nain = (NormalAllocationInNode) ik; ik = h.getInstanceKeyForAllocation(nain.getNode(), nain.getSite()); } else { assert false : "need to handle " + ik.getClass(); } return h.getPointerKeyForArrayContents(ik); } else if (pk instanceof ReturnValueKey) { ReturnValueKey rvk = (ReturnValueKey) pk; return h.getPointerKeyForReturnValue(rvk.getNode()); } throw new UnsupportedOperationException("need to handle " + pk.getClass()); }
PointerKey p = getHeapModel().getPointerKeyForArrayContents(I); if (p == null || !nodeManager.containsNode(p)) { return null; IClass klass = getHeapModel().getClassHierarchy().lookupClass(T); assert klass != null : "null klass for type " + T; MutableSparseIntSet result = MutableSparseIntSet.makeEmpty(); for (IField f : klass.getAllInstanceFields()) { if (!f.getReference().getFieldType().isPrimitiveType()) { PointerKey p = getHeapModel().getPointerKeyForInstanceField(I, f); if (p != null && nodeManager.containsNode(p)) { result.add(nodeManager.getNumber(p));
PointerKey objKey = fbPA.getHeapModel().getPointerKeyForLocal(node, obj); OrdinalSet<ObjectVertex> objPtrs = fbPA.getPointsToSet(objKey); for(ObjectVertex o : objPtrs) { PointerKey propKey = fbPA.getHeapModel().getPointerKeyForInstanceField(o, new AstDynamicField(false, o.getConcreteType(), Atom.findOrCreateUnicodeAtom(p), JavaScriptTypes.Root)); Assert.assertTrue("object " + o + " should have field " + propKey, hg.hasEdge(o, propKey)); PointerKey valKey = fbPA.getHeapModel().getPointerKeyForLocal(node, val); OrdinalSet<ObjectVertex> valPtrs = fbPA.getPointsToSet(valKey); for(ObjectVertex v : valPtrs) { String propName = ((AstGlobalWrite) inst).getGlobalName(); propName = propName.substring("global ".length()); PointerKey propKey = fbPA.getHeapModel().getPointerKeyForInstanceField(null, new AstDynamicField(false, null, Atom.findOrCreateUnicodeAtom(propName), JavaScriptTypes.Root)); Assert.assertTrue("global " + propName + " should exist", hg.hasEdge(GlobalVertex.instance(), propKey)); for(String f : new String[]{ "__proto__", "prototype" }) { boolean dump = false; PointerKey pointerKeyForInstanceField = fbPA.getHeapModel().getPointerKeyForInstanceField(k, new AstDynamicField(false, k.getConcreteType(), Atom.findOrCreateUnicodeAtom(f), JavaScriptTypes.Root)); if (! hg.containsNode(pointerKeyForInstanceField)) { dump = true;
@Override public void visitNew(SSANewInstruction instruction) { InstanceKey iKey = heapModel.getInstanceKeyForAllocation(node, instruction.getNewSite()); if (iKey == null) { // something went wrong. I hope someone raised a warning. return; } PointerKey def = heapModel.getPointerKeyForLocal(node, instruction.getDef()); g.addNode(iKey); g.addNode(def); g.addEdge(def, iKey, NewLabel.v()); NewMultiDimInfo multiDimInfo = getInfoForNewMultiDim(instruction, heapModel, node); if (multiDimInfo != null) { for (Pair<PointerKey, InstanceKey> newInstr : multiDimInfo.newInstrs) { g.addNode(newInstr.fst); g.addNode(newInstr.snd); g.addEdge(newInstr.fst, newInstr.snd, NewLabel.v()); } for (Pair<PointerKey, PointerKey> arrStoreInstr : multiDimInfo.arrStoreInstrs) { g.addNode(arrStoreInstr.fst); g.addNode(arrStoreInstr.snd); g.addEdge(arrStoreInstr.fst, arrStoreInstr.snd, PutFieldLabel.make(ArrayContents.v())); } } }
pa.getPointsToSet(pa.getHeapModel().getPointerKeyForArrayContents(ik)); if (pointsToSet.isEmpty()) { continue; } else if (fieldTypeRef.isArrayType()) { PointerKey pk = pa.getHeapModel().getPointerKeyForInstanceField(ik, field); final OrdinalSet<InstanceKey> pointsToSet = pa.getPointsToSet(pk); if (pointsToSet.isEmpty()) { PointerKey pk = pa.getHeapModel().getPointerKeyForInstanceField(ik, field); final OrdinalSet<InstanceKey> pointsToSet = pa.getPointsToSet(pk); if (pointsToSet.isEmpty() && !analysisContext.getClassHierarchy().isInterface(fieldTypeRef)) {
@Test public void testZeroLengthArray() throws ClassHierarchyException, IllegalArgumentException, CancelException, IOException { AnalysisScope scope = CallGraphTestUtil.makeJ2SEAnalysisScope(TestConstants.WALA_TESTDATA, CallGraphTestUtil.REGRESSION_EXCLUSIONS); ClassHierarchy cha = ClassHierarchyFactory.make(scope); Iterable<Entrypoint> entrypoints = com.ibm.wala.ipa.callgraph.impl.Util.makeMainEntrypoints(scope, cha, TestConstants.ZERO_LENGTH_ARRAY_MAIN); AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints); CallGraphBuilder<InstanceKey> builder = Util.makeVanillaZeroOneCFABuilder(Language.JAVA, options, new AnalysisCacheImpl(), cha, scope); CallGraph cg = builder.makeCallGraph(options, null); PointerAnalysis<InstanceKey> pa = builder.getPointerAnalysis(); // System.err.println(pa); HeapModel heapModel = pa.getHeapModel(); CGNode mainNode = cg.getNode( cha.resolveMethod(MethodReference.findOrCreate( TypeReference.findOrCreate(ClassLoaderReference.Application, TestConstants.ZERO_LENGTH_ARRAY_MAIN), Selector.make("main([Ljava/lang/String;)V"))), Everywhere.EVERYWHERE); OrdinalSet<InstanceKey> pointsToSet = pa.getPointsToSet(heapModel.getPointerKeyForLocal(mainNode, 4)); Assert.assertEquals(1, pointsToSet.size()); InstanceKey arrayKey = pointsToSet.iterator().next(); OrdinalSet<InstanceKey> arrayContents = pa.getPointsToSet(heapModel.getPointerKeyForArrayContents(arrayKey)); System.err.println(arrayContents); Assert.assertEquals(0, arrayContents.size()); } }
@Override public void visitLoadMetadata(SSALoadMetadataInstruction instruction) { PointerKey def = heapModel.getPointerKeyForLocal(node, instruction.getDef()); assert instruction.getType() == TypeReference.JavaLangClass; InstanceKey iKey = heapModel.getInstanceKeyForMetadataObject(instruction.getToken(), (TypeReference) instruction.getToken()); g.addNode(iKey); g.addNode(def); g.addEdge(def, iKey, NewLabel.v()); } }
@Override public PointerKey getPointerKeyForStaticField(IField f) { return h.getPointerKeyForStaticField(f); }
@Override public InstanceKey getInstanceKeyForAllocation(CGNode node, NewSiteReference allocation) { return delegate.getInstanceKeyForAllocation(node, allocation); }
public static InstanceKey mapInstKey(InstanceKey ik, CallGraph fromCG, CallGraph toCG, HeapModel heapModel) throws UnimplementedError, NullPointerException { InstanceKey ret = null; if (ik instanceof InstanceKeyWithNode) { CGNode oldCGNode = ((InstanceKeyWithNode) ik).getNode(); CGNode newCGNode = mapCGNode(oldCGNode, fromCG, toCG); if (newCGNode == null) { return null; } if (ik instanceof AllocationSiteInNode) { if (ik instanceof NormalAllocationInNode) { ret = heapModel.getInstanceKeyForAllocation(newCGNode, ((AllocationSiteInNode) ik).getSite()); } else if (ik instanceof MultiNewArrayInNode) { MultiNewArrayInNode mnik = (MultiNewArrayInNode) ik; ret = heapModel.getInstanceKeyForMultiNewArray(newCGNode, mnik.getSite(), mnik.getDim()); } else { Assertions.UNREACHABLE(); } } else { Assertions.UNREACHABLE(); } } else if (ik instanceof ConcreteTypeKey) { return ik; } else { Assertions.UNREACHABLE(); } assert ret != null; assert ret.getClass() == ik.getClass(); return ret; }
return new InstanceKey[0]; InstanceKey ik = hm.getInstanceKeyForConstant(type, S); if (ik != null) { result = new InstanceKey[] { ik }; return new InstanceKey[0]; InstanceKey ik = hm.getInstanceKeyForConstant(type, x); if (ik != null) { result = new InstanceKey[] { ik }; InstanceKey iKey = hm.getInstanceKeyForAllocation(node, def.getNewSite()); result = (iKey == null) ? new InstanceKey[0] : new InstanceKey[] { iKey };
@Override public IClassHierarchy getClassHierarchy() { return h.getClassHierarchy(); }
@Override public FilteredPointerKey getFilteredPointerKeyForLocal(CGNode node, int valueNumber, TypeFilter filter) { return delegate.getFilteredPointerKeyForLocal(node, valueNumber, filter); }