From 6e92ca411ba262693e49c6012d02698567ec3401 Mon Sep 17 00:00:00 2001 From: msridhar1 Date: Tue, 11 Mar 2008 17:56:22 +0000 Subject: [PATCH] fixed bug in handling of arrays in TypeBasedPointerAnalysis git-svn-id: https://wala.svn.sourceforge.net/svnroot/wala/trunk@2693 f5eafffb-2e1d-0410-98e4-8ec43c5233c4 --- .../src/arrayAlias/TestArrayAlias.java | 33 +++++++ .../tests/ptrs/TypeBasedArrayAliasTest.java | 93 +++++++++++++++++++ .../wala/core/tests/util/TestConstants.java | 2 + .../rta/TypeBasedPointerAnalysis.java | 27 +++--- 4 files changed, 143 insertions(+), 12 deletions(-) create mode 100644 com.ibm.wala.core.testdata/src/arrayAlias/TestArrayAlias.java create mode 100644 com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/ptrs/TypeBasedArrayAliasTest.java diff --git a/com.ibm.wala.core.testdata/src/arrayAlias/TestArrayAlias.java b/com.ibm.wala.core.testdata/src/arrayAlias/TestArrayAlias.java new file mode 100644 index 000000000..acf844676 --- /dev/null +++ b/com.ibm.wala.core.testdata/src/arrayAlias/TestArrayAlias.java @@ -0,0 +1,33 @@ +/******************************************************************************* + * Copyright (c) 2008 IBM Corporation. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package arrayAlias; + +public class TestArrayAlias { + + public static void main(String[] args) { + Object[] o = new Integer[10]; + testMayAlias1(o, (Integer[])o); + Object[] o2 = new Object[20]; + testMayAlias2(o2, (Object[][]) o2); + testMayAlias3((Integer[])o, (String[])o); + } + + private static void testMayAlias1(Object[] o, Integer[] o2) { + } + + private static void testMayAlias2(Object[] o, Object[][] o2) { + + } + + private static void testMayAlias3(Integer[] o, String[] o2) { + + } +} diff --git a/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/ptrs/TypeBasedArrayAliasTest.java b/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/ptrs/TypeBasedArrayAliasTest.java new file mode 100644 index 000000000..4dd2ba7af --- /dev/null +++ b/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/ptrs/TypeBasedArrayAliasTest.java @@ -0,0 +1,93 @@ +/******************************************************************************* + * Copyright (c) 2008 IBM Corporation. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package com.ibm.wala.core.tests.ptrs; + +import java.io.IOException; +import java.util.Iterator; + +import com.ibm.wala.core.tests.callGraph.CallGraphTestUtil; +import com.ibm.wala.core.tests.util.TestConstants; +import com.ibm.wala.core.tests.util.WalaTestCase; +import com.ibm.wala.eclipse.util.CancelException; +import com.ibm.wala.ipa.callgraph.AnalysisCache; +import com.ibm.wala.ipa.callgraph.AnalysisOptions; +import com.ibm.wala.ipa.callgraph.AnalysisScope; +import com.ibm.wala.ipa.callgraph.CGNode; +import com.ibm.wala.ipa.callgraph.CallGraph; +import com.ibm.wala.ipa.callgraph.CallGraphBuilder; +import com.ibm.wala.ipa.callgraph.Entrypoint; +import com.ibm.wala.ipa.callgraph.impl.Util; +import com.ibm.wala.ipa.callgraph.propagation.InstanceKey; +import com.ibm.wala.ipa.callgraph.propagation.PointerAnalysis; +import com.ibm.wala.ipa.callgraph.propagation.PointerKey; +import com.ibm.wala.ipa.cha.ClassHierarchy; +import com.ibm.wala.ipa.cha.ClassHierarchyException; +import com.ibm.wala.util.debug.Assertions; +import com.ibm.wala.util.intset.OrdinalSet; + +public class TypeBasedArrayAliasTest extends WalaTestCase { + + public void testTypeBasedArrayAlias() throws ClassHierarchyException, IllegalArgumentException, CancelException, IOException { + AnalysisScope scope = CallGraphTestUtil.makeJ2SEAnalysisScope(TestConstants.WALA_TESTDATA, CallGraphTestUtil.REGRESSION_EXCLUSIONS); + ClassHierarchy cha = ClassHierarchy.make(scope); + Iterable entrypoints = com.ibm.wala.ipa.callgraph.impl.Util + .makeMainEntrypoints(scope, cha, TestConstants.ARRAY_ALIAS_MAIN); + AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints); + + // RTA yields a TypeBasedPointerAnalysis + CallGraphBuilder builder = Util.makeRTABuilder(options, new AnalysisCache(),cha, scope); + CallGraph cg = builder.makeCallGraph(options, null); + PointerAnalysis pa = builder.getPointerAnalysis(); + + CGNode node = findNode(cg, "testMayAlias1"); + PointerKey pk1 = pa.getHeapModel().getPointerKeyForLocal(node, 1); + PointerKey pk2 = pa.getHeapModel().getPointerKeyForLocal(node, 2); + assertTrue(mayAliased(pk1, pk2, pa)); + + node = findNode(cg, "testMayAlias2"); + pk1 = pa.getHeapModel().getPointerKeyForLocal(node, 1); + pk2 = pa.getHeapModel().getPointerKeyForLocal(node, 2); + assertTrue(mayAliased(pk1, pk2, pa)); + + node = findNode(cg, "testMayAlias3"); + pk1 = pa.getHeapModel().getPointerKeyForLocal(node, 1); + pk2 = pa.getHeapModel().getPointerKeyForLocal(node, 2); + assertTrue(mayAliased(pk1, pk2, pa)); + } + + private final static CGNode findNode(CallGraph cg, String methodName) { + for (Iterator it = cg.iterator(); it.hasNext(); ) { + CGNode n = it.next(); + if (n.getMethod().getName().toString().equals(methodName)) { + return n; + } + } + Assertions.UNREACHABLE("Unexpected: failed to find " + methodName + " node"); + return null; + } + + private static boolean mayAliased(PointerKey pk1, PointerKey pk2, PointerAnalysis pa) { + OrdinalSet ptsTo1 = pa.getPointsToSet(pk1); + OrdinalSet ptsTo2 = pa.getPointsToSet(pk2); + boolean foundIntersection = false; + outer: for (InstanceKey i : ptsTo1) { + for (InstanceKey j : ptsTo2) { + if (i.equals(j)) { + foundIntersection = true; + break outer; + } + } + } + return foundIntersection; + } + + +} diff --git a/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/TestConstants.java b/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/TestConstants.java index 01792abbf..cc31731e0 100644 --- a/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/TestConstants.java +++ b/com.ibm.wala.core.tests/src/com/ibm/wala/core/tests/util/TestConstants.java @@ -38,6 +38,8 @@ public interface TestConstants { public final static String MULTI_DIM_MAIN = "LmultiDim/TestMultiDim"; + public final static String ARRAY_ALIAS_MAIN = "LarrayAlias/TestArrayAlias"; + public final static String REFLECT1_MAIN = "Lreflection/Reflect1"; public final static String REFLECT2_MAIN = "Lreflection/Reflect2"; diff --git a/com.ibm.wala.core/src/com/ibm/wala/ipa/callgraph/propagation/rta/TypeBasedPointerAnalysis.java b/com.ibm.wala.core/src/com/ibm/wala/ipa/callgraph/propagation/rta/TypeBasedPointerAnalysis.java index 01aeea608..b798a37ca 100644 --- a/com.ibm.wala.core/src/com/ibm/wala/ipa/callgraph/propagation/rta/TypeBasedPointerAnalysis.java +++ b/com.ibm.wala.core/src/com/ibm/wala/ipa/callgraph/propagation/rta/TypeBasedPointerAnalysis.java @@ -28,6 +28,7 @@ import com.ibm.wala.ipa.callgraph.propagation.LocalPointerKeyWithFilter; import com.ibm.wala.ipa.callgraph.propagation.PointerKey; import com.ibm.wala.ipa.callgraph.propagation.StaticFieldKey; import com.ibm.wala.ipa.cha.IClassHierarchy; +import com.ibm.wala.types.TypeReference; import com.ibm.wala.util.collections.HashMapFactory; import com.ibm.wala.util.collections.HashSetFactory; import com.ibm.wala.util.collections.Iterator2Collection; @@ -38,15 +39,14 @@ import com.ibm.wala.util.intset.OrdinalSet; /** * - * A trivial field-based pointer analysis solution, which only uses the - * information of which types (classes) are live. + * A trivial field-based pointer analysis solution, which only uses the information of which types (classes) are live. * * @author sfink */ public class TypeBasedPointerAnalysis extends AbstractPointerAnalysis { private final Collection klasses; - + private final TypeBasedHeapModel heapModel; /** @@ -55,10 +55,8 @@ public class TypeBasedPointerAnalysis extends AbstractPointerAnalysis { private final Map> pointsTo = HashMapFactory.make(); /** - * @param klasses - * Collection - * @throws AssertionError - * if klasses is null + * @param klasses Collection + * @throws AssertionError if klasses is null */ private TypeBasedPointerAnalysis(AnalysisOptions options, Collection klasses, CallGraph cg) throws AssertionError { super(cg, makeInstanceKeys(klasses)); @@ -67,8 +65,7 @@ public class TypeBasedPointerAnalysis extends AbstractPointerAnalysis { } /** - * @param c - * Collection + * @param c Collection */ private static MutableMapping makeInstanceKeys(Collection c) { assert c != null; @@ -105,8 +102,7 @@ public class TypeBasedPointerAnalysis extends AbstractPointerAnalysis { } /** - * Compute the set of {@link InstanceKey}s which may represent a particular - * type. + * Compute the set of {@link InstanceKey}s which may represent a particular type. */ private OrdinalSet computeOrdinalInstanceSet(IClass type) { Collection klasses = null; @@ -124,7 +120,14 @@ public class TypeBasedPointerAnalysis extends AbstractPointerAnalysis { Collection c = HashSetFactory.make(); for (IClass klass : klasses) { if (klass.isArrayClass()) { - c.add(klass); + TypeReference elementType = klass.getReference().getArrayElementType(); + if (elementType.isPrimitiveType()) { + c.add(klass); + } else { + // just add Object[], since with array typing rules we have no idea + // the exact type of array the reference is pointing to + c.add(klass.getClassHierarchy().lookupClass(TypeReference.JavaLangObject.getArrayTypeForElementType())); + } } else if (this.klasses.contains(klass)) { c.add(klass); }