diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/AnalysisObjectScanningObserver.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/AnalysisObjectScanningObserver.java index 78b5a4f97f22..a7d288e026bf 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/AnalysisObjectScanningObserver.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/AnalysisObjectScanningObserver.java @@ -83,7 +83,7 @@ public boolean forPrimitiveFieldValue(JavaConstant receiver, AnalysisField field /* Add the constant value object to the field's type flow. */ FieldTypeFlow fieldTypeFlow = getFieldTypeFlow(field, receiver); /* Add the new constant to the field's flow state. */ - return fieldTypeFlow.addState(analysis, TypeState.forPrimitiveConstant(fieldValue.asLong())); + return fieldTypeFlow.addState(analysis, TypeState.forPrimitiveConstant(analysis, fieldValue.asLong())); } /** diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanCheckTypeFlow.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanCheckTypeFlow.java index e6a0ee790779..9d262c6157c2 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanCheckTypeFlow.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanCheckTypeFlow.java @@ -46,19 +46,19 @@ protected BooleanCheckTypeFlow(BooleanCheckTypeFlow original, MethodFlowsGraph m super(original, methodFlows); } - protected static TypeState convertToBoolean(boolean canBeTrue, boolean canBeFalse) { + protected static TypeState convertToBoolean(PointsToAnalysis bb, boolean canBeTrue, boolean canBeFalse) { if (canBeTrue && canBeFalse) { return TypeState.anyPrimitiveState(); } else if (canBeTrue) { - return TypeState.forBoolean(true); + return TypeState.forBoolean(bb, true); } else if (canBeFalse) { - return TypeState.forBoolean(false); + return TypeState.forBoolean(bb, false); } return TypeState.forEmpty(); } - protected static TypeState convertToBoolean(TypeState trueState, TypeState falseState) { - return convertToBoolean(trueState.isNotEmpty(), falseState.isNotEmpty()); + protected static TypeState convertToBoolean(PointsToAnalysis bb, TypeState trueState, TypeState falseState) { + return convertToBoolean(bb, trueState.isNotEmpty(), falseState.isNotEmpty()); } @Override diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanInstanceOfCheckTypeFlow.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanInstanceOfCheckTypeFlow.java index 0db031d0fb02..0d9e851b34f0 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanInstanceOfCheckTypeFlow.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanInstanceOfCheckTypeFlow.java @@ -68,6 +68,6 @@ public TypeState filter(PointsToAnalysis bb, TypeState update) { canBeTrue = TypeState.forIntersection(bb, update, checkedType.getAssignableTypes(includeNull)); canBeFalse = TypeState.forSubtraction(bb, update, checkedType.getAssignableTypes(includeNull)); } - return convertToBoolean(canBeTrue, canBeFalse); + return convertToBoolean(bb, canBeTrue, canBeFalse); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanNullCheckTypeFlow.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanNullCheckTypeFlow.java index cda0e675cac2..e66fbba961bb 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanNullCheckTypeFlow.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanNullCheckTypeFlow.java @@ -52,6 +52,6 @@ public TypeFlow copy(PointsToAnalysis bb, MethodFlowsGraph met public TypeState filter(PointsToAnalysis bb, TypeState newState) { var hasNull = newState.canBeNull(); var hasTypes = newState.typesCount() > 0; - return convertToBoolean(hasNull, hasTypes); + return convertToBoolean(bb, hasNull, hasTypes); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanPrimitiveCheckTypeFlow.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanPrimitiveCheckTypeFlow.java index ea2f4bad2a80..d930927cc28e 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanPrimitiveCheckTypeFlow.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/BooleanPrimitiveCheckTypeFlow.java @@ -86,6 +86,6 @@ public TypeState eval(PointsToAnalysis bb) { } assert leftState.isPrimitive() : left; assert rightState.isPrimitive() : right; - return convertToBoolean(TypeState.filter(leftState, comparison, rightState), TypeState.filter(leftState, comparison.negate(), rightState)); + return convertToBoolean(bb, TypeState.filter(leftState, comparison, rightState), TypeState.filter(leftState, comparison.negate(), rightState)); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/ConstantPrimitiveSourceTypeFlow.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/ConstantPrimitiveSourceTypeFlow.java index 3b547a4e89fc..4cb1b30636cd 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/ConstantPrimitiveSourceTypeFlow.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/ConstantPrimitiveSourceTypeFlow.java @@ -32,8 +32,8 @@ public class ConstantPrimitiveSourceTypeFlow extends TypeFlow implements PrimitiveFlow { - public ConstantPrimitiveSourceTypeFlow(BytecodePosition source, AnalysisType type, long value) { - super(source, type, TypeState.forPrimitiveConstant(value)); + public ConstantPrimitiveSourceTypeFlow(BytecodePosition source, AnalysisType type, TypeState state) { + super(source, type, state); } public ConstantPrimitiveSourceTypeFlow(ConstantPrimitiveSourceTypeFlow original, MethodFlowsGraph methodFlows) { diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java index 73684a329469..6d328cb805bb 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java @@ -294,7 +294,7 @@ public static void registerUsedElements(PointsToAnalysis bb, StructuredGraph gra type.registerAsInstantiated(AbstractAnalysisEngine.sourcePosition(node)); for (var f : type.getInstanceFields(true)) { var field = (AnalysisField) f; - field.getInitialFlow().addState(bb, TypeState.defaultValueForKind(field.getStorageKind())); + field.getInitialFlow().addState(bb, TypeState.defaultValueForKind(bb, field.getStorageKind())); } } @@ -829,7 +829,7 @@ protected TypeFlowBuilder handleIntegerStamp(IntegerStamp stamp, ValueNode no long hi = stamp.upperBound(); if (lo == hi) { return TypeFlowBuilder.create(bb, method, getPredicate(), node, ConstantPrimitiveSourceTypeFlow.class, () -> { - var flow = new ConstantPrimitiveSourceTypeFlow(AbstractAnalysisEngine.sourcePosition(node), type, lo); + var flow = new ConstantPrimitiveSourceTypeFlow(AbstractAnalysisEngine.sourcePosition(node), type, TypeState.forPrimitiveConstant(bb, lo)); flowsGraph.addMiscEntryFlow(flow); return flow; }); @@ -1947,7 +1947,7 @@ protected void processCommitAllocation(CommitAllocationNode commitAllocationNode } else { if (!type.isArray()) { AnalysisField field = (AnalysisField) ((VirtualInstanceNode) virtualObject).field(i); - field.getInitialFlow().addState(bb, TypeState.defaultValueForKind(field.getStorageKind())); + field.getInitialFlow().addState(bb, TypeState.defaultValueForKind(bb, field.getStorageKind())); } } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/NewInstanceTypeFlow.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/NewInstanceTypeFlow.java index 9d9002e712ab..844ef9c9e2cf 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/NewInstanceTypeFlow.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/NewInstanceTypeFlow.java @@ -77,7 +77,7 @@ protected void onFlowEnabled(PointsToAnalysis bb) { if (insertDefaultFieldValues) { for (var f : declaredType.getInstanceFields(true)) { var field = (AnalysisField) f; - field.getInitialFlow().addState(bb, TypeState.defaultValueForKind(field.getStorageKind())); + field.getInitialFlow().addState(bb, TypeState.defaultValueForKind(bb, field.getStorageKind())); } } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/BytecodeSensitiveAnalysisPolicy.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/BytecodeSensitiveAnalysisPolicy.java index 8ceac63b9ed6..024a1952d1e6 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/BytecodeSensitiveAnalysisPolicy.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/BytecodeSensitiveAnalysisPolicy.java @@ -430,12 +430,12 @@ public TypeState forContextInsensitiveTypeState(PointsToAnalysis bb, TypeState s @Override public SingleTypeState singleTypeState(PointsToAnalysis bb, boolean canBeNull, AnalysisType type, AnalysisObject... objects) { - return new ContextSensitiveSingleTypeState(bb, canBeNull, type, objects); + return PointsToStats.registerTypeState(bb, new ContextSensitiveSingleTypeState(canBeNull, type, objects)); } @Override public MultiTypeState multiTypeState(PointsToAnalysis bb, boolean canBeNull, BitSet typesBitSet, int typesCount, AnalysisObject... objects) { - return new ContextSensitiveMultiTypeState(bb, canBeNull, typesBitSet, typesCount, objects); + return PointsToStats.registerTypeState(bb, new ContextSensitiveMultiTypeState(canBeNull, typesBitSet, typesCount, objects)); } @Override @@ -466,7 +466,7 @@ public TypeState doUnion(PointsToAnalysis bb, SingleTypeState state1, SingleType assert !Arrays.equals(resultObjects, s1.objects) && !Arrays.equals(resultObjects, s2.objects) : resultObjects; /* Create the resulting exact type state. */ - SingleTypeState result = new ContextSensitiveSingleTypeState(bb, resultCanBeNull, s1.exactType(), resultObjects); + SingleTypeState result = singleTypeState(bb, resultCanBeNull, s1.exactType(), resultObjects); assert !s1.equals(result) && !s2.equals(result) : result; PointsToStats.registerUnionOperation(bb, s1, s2, result); return result; @@ -482,7 +482,7 @@ public TypeState doUnion(PointsToAnalysis bb, SingleTypeState state1, SingleType /* We know the types, construct the types bit set without walking the objects. */ BitSet typesBitSet = TypeStateUtils.newBitSet(s1.exactType().getId(), s2.exactType().getId()); assert typesBitSet.cardinality() == 2 : typesBitSet; - TypeState result = new ContextSensitiveMultiTypeState(bb, resultCanBeNull, typesBitSet, 2, resultObjects); + TypeState result = multiTypeState(bb, resultCanBeNull, typesBitSet, 2, resultObjects); PointsToStats.registerUnionOperation(bb, s1, s2, result); return result; } @@ -542,7 +542,7 @@ public TypeState doUnion(PointsToAnalysis bb, MultiTypeState state1, SingleTypeS System.arraycopy(so1, typeRange.right(), resultObjects, typeRange.left() + unionObjects.length, so1.length - typeRange.right()); /* The types bit set of the result and s1 are the same. */ - MultiTypeState result = new ContextSensitiveMultiTypeState(bb, resultCanBeNull, s1.bitSet(), s1.typesCount(), resultObjects); + MultiTypeState result = multiTypeState(bb, resultCanBeNull, s1.bitSet(), s1.typesCount(), resultObjects); assert !result.equals(s1) : result; /* * No need to check the result size against the all-instantiated since the type count @@ -576,7 +576,7 @@ public TypeState doUnion(PointsToAnalysis bb, MultiTypeState state1, SingleTypeS BitSet typesBitSet = TypeStateUtils.set(s1.bitSet(), s2.exactType().getId()); int typesCount = s1.typesCount() + 1; assert typesCount == typesBitSet.cardinality() : typesCount; - MultiTypeState result = new ContextSensitiveMultiTypeState(bb, resultCanBeNull, typesBitSet, typesCount, resultObjects); + MultiTypeState result = multiTypeState(bb, resultCanBeNull, typesBitSet, typesCount, resultObjects); PointsToStats.registerUnionOperation(bb, s1, s2, result); return result; } @@ -621,7 +621,7 @@ private TypeState doUnion0(PointsToAnalysis bb, ContextSensitiveMultiTypeState s BitSet resultTypesBitSet = TypeStateUtils.or(s1.bitSet(), s2.bitSet()); int typesCount = s1.typesCount() + s2.typesCount(); assert typesCount == resultTypesBitSet.cardinality() : typesCount; - MultiTypeState result = new ContextSensitiveMultiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount, resultObjects); + MultiTypeState result = multiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount, resultObjects); PointsToStats.registerUnionOperation(bb, s1, s2, result); return result; @@ -635,7 +635,7 @@ private TypeState doUnion0(PointsToAnalysis bb, ContextSensitiveMultiTypeState s BitSet resultTypesBitSet = TypeStateUtils.or(s1.bitSet(), s2.bitSet()); int typesCount = s1.typesCount() + s2.typesCount(); assert typesCount == resultTypesBitSet.cardinality() : typesCount; - MultiTypeState result = new ContextSensitiveMultiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount, resultObjects); + MultiTypeState result = multiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount, resultObjects); PointsToStats.registerUnionOperation(bb, s1, s2, result); return result; } @@ -824,7 +824,7 @@ private TypeState doUnion2(PointsToAnalysis bb, ContextSensitiveMultiTypeState s /* Logical OR the type bit sets. */ BitSet resultTypesBitSet = TypeStateUtils.or(s1.bitSet(), s2.bitSet()); - MultiTypeState result = new ContextSensitiveMultiTypeState(bb, resultCanBeNull, resultTypesBitSet, resultTypesBitSet.cardinality(), + MultiTypeState result = multiTypeState(bb, resultCanBeNull, resultTypesBitSet, resultTypesBitSet.cardinality(), resultObjects.copyToArray(new AnalysisObject[resultObjects.size()])); assert !result.equals(s1) : "speculation code should prevent this case"; @@ -874,7 +874,7 @@ public TypeState doIntersection(PointsToAnalysis bb, MultiTypeState s1, SingleTy AnalysisObject[] resultObjects = ((ContextSensitiveMultiTypeState) s1).objectsArray(s2.exactType()); /* All objects must have the same type. */ assert TypeStateUtils.holdsSingleTypeState(resultObjects); - return new ContextSensitiveSingleTypeState(bb, resultCanBeNull, s2.exactType(), resultObjects); + return singleTypeState(bb, resultCanBeNull, s2.exactType(), resultObjects); } else { return TypeState.forEmpty().forCanBeNull(bb, resultCanBeNull); } @@ -900,7 +900,7 @@ public TypeState doIntersection(PointsToAnalysis bb, MultiTypeState state1, Mult return doIntersection0(bb, s1, s2, resultCanBeNull); } - private static TypeState doIntersection0(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull) { + private TypeState doIntersection0(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull) { /* Speculate that s1 and s2 have either the same types, or no types in common. */ if (s1.bitSet().equals(s2.bitSet())) { @@ -916,7 +916,7 @@ private static TypeState doIntersection0(PointsToAnalysis bb, ContextSensitiveMu return doIntersection1(bb, s1, s2, resultCanBeNull); } - private static TypeState doIntersection1(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull) { + private TypeState doIntersection1(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull) { /* * Speculate that s2 contains all types of s1, i.e., the filter is broader than s1, thus the * result is s1. @@ -964,7 +964,7 @@ private static TypeState doIntersection1(PointsToAnalysis bb, ContextSensitiveMu private static ThreadLocal> intersectionArrayListTL = new ThreadLocal<>(); - private static TypeState doIntersection2(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull, int idx1Param, int idx2Param) { + private TypeState doIntersection2(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull, int idx1Param, int idx2Param) { try (ListUtils.UnsafeArrayListClosable tlArrayClosable = ListUtils.getTLArrayList(intersectionArrayListTL, 256)) { ListUtils.UnsafeArrayList resultObjects = tlArrayClosable.list(); @@ -1007,11 +1007,11 @@ private static TypeState doIntersection2(PointsToAnalysis bb, ContextSensitiveMu if (TypeStateUtils.holdsSingleTypeState(objects, objects.length)) { /* Multiple objects of the same type. */ - return new ContextSensitiveSingleTypeState(bb, resultCanBeNull, objects[0].type(), objects); + return singleTypeState(bb, resultCanBeNull, objects[0].type(), objects); } else { /* Logical AND the type bit sets. */ BitSet resultTypesBitSet = TypeStateUtils.and(s1.bitSet(), s2.bitSet()); - MultiTypeState result = new ContextSensitiveMultiTypeState(bb, resultCanBeNull, resultTypesBitSet, resultTypesBitSet.cardinality(), objects); + MultiTypeState result = multiTypeState(bb, resultCanBeNull, resultTypesBitSet, resultTypesBitSet.cardinality(), objects); /* * The result can be equal to s1 if and only if s1 and s2 have the same type @@ -1077,15 +1077,15 @@ public TypeState doSubtraction(PointsToAnalysis bb, MultiTypeState state1, Singl System.arraycopy(s1.objects, typeRange.right(), resultObjects, typeRange.left(), s1.objects.length - typeRange.right()); if (resultObjects.length == 1) { - return new ContextSensitiveSingleTypeState(bb, resultCanBeNull, resultObjects[0].type(), resultObjects[0]); + return singleTypeState(bb, resultCanBeNull, resultObjects[0].type(), resultObjects[0]); } else if (TypeStateUtils.holdsSingleTypeState(resultObjects)) { /* Multiple objects of the same type. */ - return new ContextSensitiveSingleTypeState(bb, resultCanBeNull, resultObjects[0].type(), resultObjects); + return singleTypeState(bb, resultCanBeNull, resultObjects[0].type(), resultObjects); } else { BitSet resultTypesBitSet = TypeStateUtils.clear(s1.bitSet(), s2.exactType().getId()); int typesCount = s1.typesCount() - 1; assert typesCount == resultTypesBitSet.cardinality() : typesCount; - return new ContextSensitiveMultiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount, resultObjects); + return multiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount, resultObjects); } } else { @@ -1110,7 +1110,7 @@ public TypeState doSubtraction(PointsToAnalysis bb, MultiTypeState state1, Multi return doSubtraction0(bb, s1, s2, resultCanBeNull); } - private static TypeState doSubtraction0(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull) { + private TypeState doSubtraction0(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull) { /* Speculate that s1 and s2 have either the same types, or no types in common. */ if (s1.bitSet().equals(s2.bitSet())) { @@ -1126,7 +1126,7 @@ private static TypeState doSubtraction0(PointsToAnalysis bb, ContextSensitiveMul return doSubtraction1(bb, s1, s2, resultCanBeNull); } - private static TypeState doSubtraction1(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull) { + private TypeState doSubtraction1(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull) { /* * Speculate that s1 and s2 have no overlap, i.e., they don't have any objects in common. In * that case, the result is just s1. @@ -1162,7 +1162,7 @@ private static TypeState doSubtraction1(PointsToAnalysis bb, ContextSensitiveMul return doSubtraction2(bb, s1, s2, resultCanBeNull, idx1, idx2); } - private static TypeState doSubtraction2(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull, int idx1Param, int idx2Param) { + private TypeState doSubtraction2(PointsToAnalysis bb, ContextSensitiveMultiTypeState s1, ContextSensitiveMultiTypeState s2, boolean resultCanBeNull, int idx1Param, int idx2Param) { try (ListUtils.UnsafeArrayListClosable tlArrayClosable = ListUtils.getTLArrayList(intersectionArrayListTL, 256)) { ListUtils.UnsafeArrayList resultObjects = tlArrayClosable.list(); @@ -1207,14 +1207,14 @@ private static TypeState doSubtraction2(PointsToAnalysis bb, ContextSensitiveMul if (TypeStateUtils.holdsSingleTypeState(objects, totalLength)) { /* Multiple objects of the same type. */ - return new ContextSensitiveSingleTypeState(bb, resultCanBeNull, objects[0].type(), objects); + return singleTypeState(bb, resultCanBeNull, objects[0].type(), objects); } else { BitSet resultTypesBitSet = TypeStateUtils.andNot(s1.bitSet(), s2.bitSet()); /* * Don't need to check if the result is close-to-all-instantiated since result * <= s1. */ - return new ContextSensitiveMultiTypeState(bb, resultCanBeNull, resultTypesBitSet, resultTypesBitSet.cardinality(), objects); + return multiTypeState(bb, resultCanBeNull, resultTypesBitSet, resultTypesBitSet.cardinality(), objects); } } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/ContextSensitiveMultiTypeState.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/ContextSensitiveMultiTypeState.java index 0d6b637afb28..e6835aca3fec 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/ContextSensitiveMultiTypeState.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/ContextSensitiveMultiTypeState.java @@ -33,6 +33,7 @@ import com.oracle.graal.pointsto.flow.context.object.AnalysisObject; import com.oracle.graal.pointsto.meta.AnalysisType; import com.oracle.graal.pointsto.typestate.MultiTypeState; +import com.oracle.graal.pointsto.typestate.PointsToStats; import com.oracle.graal.pointsto.typestate.TypeState; public class ContextSensitiveMultiTypeState extends MultiTypeState { @@ -43,16 +44,16 @@ public class ContextSensitiveMultiTypeState extends MultiTypeState { protected int[] objectTypeIds; /** Creates a new type state using the provided types bit set and objects. */ - public ContextSensitiveMultiTypeState(PointsToAnalysis bb, boolean canBeNull, BitSet typesBitSet, int typesCount, AnalysisObject... objects) { - super(bb, canBeNull, typesBitSet, typesCount); + public ContextSensitiveMultiTypeState(boolean canBeNull, BitSet typesBitSet, int typesCount, AnalysisObject... objects) { + super(canBeNull, typesBitSet, typesCount); this.objects = objects; assert objects.length > 1 : "Multi type state with single object."; assert checkObjects(); } /** Create a type state with the same content and a reversed canBeNull value. */ - protected ContextSensitiveMultiTypeState(PointsToAnalysis bb, boolean canBeNull, ContextSensitiveMultiTypeState other) { - super(bb, canBeNull, other); + protected ContextSensitiveMultiTypeState(boolean canBeNull, ContextSensitiveMultiTypeState other) { + super(canBeNull, other); this.objects = other.objects; this.merged = other.merged; } @@ -128,7 +129,7 @@ public TypeState forCanBeNull(PointsToAnalysis bb, boolean resultCanBeNull) { return this; } else { /* Just flip the canBeNull flag and copy the rest of the values from this. */ - return new ContextSensitiveMultiTypeState(bb, resultCanBeNull, this); + return PointsToStats.registerTypeState(bb, new ContextSensitiveMultiTypeState(resultCanBeNull, this)); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/ContextSensitiveSingleTypeState.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/ContextSensitiveSingleTypeState.java index 850dfbc59711..975a661ee059 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/ContextSensitiveSingleTypeState.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/context/bytecode/ContextSensitiveSingleTypeState.java @@ -31,6 +31,7 @@ import com.oracle.graal.pointsto.PointsToAnalysis; import com.oracle.graal.pointsto.flow.context.object.AnalysisObject; import com.oracle.graal.pointsto.meta.AnalysisType; +import com.oracle.graal.pointsto.typestate.PointsToStats; import com.oracle.graal.pointsto.typestate.SingleTypeState; import com.oracle.graal.pointsto.typestate.TypeState; @@ -41,20 +42,19 @@ public class ContextSensitiveSingleTypeState extends SingleTypeState { protected final AnalysisObject[] objects; /** Creates a new type state from incoming objects. */ - @SuppressWarnings("this-escape") - public ContextSensitiveSingleTypeState(PointsToAnalysis bb, boolean canBeNull, AnalysisType type, AnalysisObject... objects) { - super(bb, canBeNull, type); + public ContextSensitiveSingleTypeState(boolean canBeNull, AnalysisType type, AnalysisObject... objects) { + super(canBeNull, type); this.objects = objects; - assert checkObjects(); + assert checkObjects(objects); } /** Create a type state with the same content and a reversed canBeNull value. */ - protected ContextSensitiveSingleTypeState(PointsToAnalysis bb, boolean canBeNull, ContextSensitiveSingleTypeState other) { - super(bb, canBeNull, other); + protected ContextSensitiveSingleTypeState(boolean canBeNull, ContextSensitiveSingleTypeState other) { + super(canBeNull, other); this.objects = other.objects; } - protected boolean checkObjects() { + private static boolean checkObjects(AnalysisObject[] objects) { /* Check that the objects array are sorted by type. */ for (int idx = 0; idx < objects.length - 1; idx++) { AnalysisObject o0 = objects[idx]; @@ -107,7 +107,7 @@ public TypeState forCanBeNull(PointsToAnalysis bb, boolean stateCanBeNull) { if (stateCanBeNull == this.canBeNull()) { return this; } else { - return new ContextSensitiveSingleTypeState(bb, stateCanBeNull, this); + return PointsToStats.registerTypeState(bb, new ContextSensitiveSingleTypeState(stateCanBeNull, this)); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/PointsToAnalysisType.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/PointsToAnalysisType.java index 4e0c7b99e11f..dd7bfc2f0ccd 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/PointsToAnalysisType.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/PointsToAnalysisType.java @@ -62,7 +62,7 @@ public boolean registerAsUnsafeAllocated(Object reason) { var bb = (PointsToAnalysis) universe.getBigbang(); for (var f : getInstanceFields(true)) { var field = (AnalysisField) f; - field.getInitialFlow().addState(bb, TypeState.defaultValueForKind(field.getStorageKind())); + field.getInitialFlow().addState(bb, TypeState.defaultValueForKind(bb, field.getStorageKind())); } } return result; diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/ConstantTypeState.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/ConstantTypeState.java index 1303d7f1b709..efc44840e320 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/ConstantTypeState.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/ConstantTypeState.java @@ -48,15 +48,15 @@ public class ConstantTypeState extends SingleTypeState { /** Creates a new type state from incoming objects. */ public ConstantTypeState(PointsToAnalysis bb, AnalysisType type, JavaConstant constant) { - super(bb, false, type); + super(false, type); assert !bb.analysisPolicy().isContextSensitiveAnalysis() : "The ConstantTypeState is indented to be used with a context insensitive analysis."; assert !(constant instanceof ImageHeapRelocatableConstant) : "relocatable constants have an unknown state and should not be represented by a constant type state: " + constant; - this.constant = constant; + this.constant = Objects.requireNonNull(constant); } /** Create a type state with the same content and a reversed canBeNull value. */ - protected ConstantTypeState(PointsToAnalysis bb, boolean canBeNull, ConstantTypeState other) { - super(bb, canBeNull, other); + protected ConstantTypeState(boolean canBeNull, ConstantTypeState other) { + super(canBeNull, other); this.constant = other.constant; } @@ -69,7 +69,7 @@ public TypeState forCanBeNull(PointsToAnalysis bb, boolean stateCanBeNull) { if (stateCanBeNull == this.canBeNull()) { return this; } else { - return new ConstantTypeState(bb, stateCanBeNull, this); + return PointsToStats.registerTypeState(bb, new ConstantTypeState(stateCanBeNull, this)); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/DefaultAnalysisPolicy.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/DefaultAnalysisPolicy.java index 4d8466da972c..6bce082b74be 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/DefaultAnalysisPolicy.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/DefaultAnalysisPolicy.java @@ -138,7 +138,7 @@ public TypeState constantTypeState(PointsToAnalysis bb, JavaConstant constant, A */ return TypeState.forType(bb, relocatableConstant.getType(), false); } - return new ConstantTypeState(bb, exactType, constant); + return PointsToStats.registerTypeState(bb, new ConstantTypeState(bb, exactType, constant)); } @Override @@ -271,12 +271,12 @@ public TypeState forContextInsensitiveTypeState(PointsToAnalysis bb, TypeState s @Override public SingleTypeState singleTypeState(PointsToAnalysis bb, boolean canBeNull, AnalysisType type, AnalysisObject... objects) { - return new SingleTypeState(bb, canBeNull, type); + return PointsToStats.registerTypeState(bb, new SingleTypeState(canBeNull, type)); } @Override public MultiTypeState multiTypeState(PointsToAnalysis bb, boolean canBeNull, BitSet typesBitSet, int typesCount, AnalysisObject... objects) { - return new MultiTypeState(bb, canBeNull, typesBitSet, typesCount); + return PointsToStats.registerTypeState(bb, new MultiTypeState(canBeNull, typesBitSet, typesCount)); } /* @@ -324,7 +324,7 @@ public TypeState doUnion(PointsToAnalysis bb, SingleTypeState state1, SingleType */ BitSet typesBitSet = TypeStateUtils.newBitSet(s1.exactType().getId(), s2.exactType().getId()); assert typesBitSet.cardinality() == 2 : typesBitSet; - TypeState result = new MultiTypeState(bb, resultCanBeNull, typesBitSet, 2); + TypeState result = multiTypeState(bb, resultCanBeNull, typesBitSet, 2); PointsToStats.registerUnionOperation(bb, s1, s2, result); return result; } @@ -344,7 +344,7 @@ public TypeState doUnion(PointsToAnalysis bb, MultiTypeState s1, SingleTypeState BitSet typesBitSet = TypeStateUtils.set(s1.typesBitSet(), s2.exactType().getId()); int typesCount = s1.typesCount() + 1; assert typesCount == typesBitSet.cardinality() : typesBitSet; - MultiTypeState result = new MultiTypeState(bb, resultCanBeNull, typesBitSet, typesCount); + MultiTypeState result = multiTypeState(bb, resultCanBeNull, typesBitSet, typesCount); PointsToStats.registerUnionOperation(bb, s1, s2, result); return result; } @@ -372,7 +372,7 @@ public TypeState doUnion(PointsToAnalysis bb, MultiTypeState s1, MultiTypeState /* Logical OR the type bit sets. */ BitSet resultTypesBitSet = TypeStateUtils.or(s1.typesBitSet(), s2.typesBitSet()); - MultiTypeState result = new MultiTypeState(bb, resultCanBeNull, resultTypesBitSet, resultTypesBitSet.cardinality()); + MultiTypeState result = multiTypeState(bb, resultCanBeNull, resultTypesBitSet, resultTypesBitSet.cardinality()); assert !result.equals(s1) && !result.equals(s2) : result; PointsToStats.registerUnionOperation(bb, s1, s2, result); return result; @@ -419,9 +419,9 @@ public TypeState doIntersection(PointsToAnalysis bb, MultiTypeState s1, MultiTyp return TypeState.forEmpty().forCanBeNull(bb, resultCanBeNull); } else if (typesCount == 1) { AnalysisType type = bb.getUniverse().getType(resultTypesBitSet.nextSetBit(0)); - return new SingleTypeState(bb, resultCanBeNull, type); + return singleTypeState(bb, resultCanBeNull, type); } else { - MultiTypeState result = new MultiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount); + MultiTypeState result = multiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount); assert !result.equals(s1) : result; return result; } @@ -437,9 +437,9 @@ public TypeState doSubtraction(PointsToAnalysis bb, MultiTypeState s1, SingleTyp assert typesCount > 0 : typesCount; if (typesCount == 1) { AnalysisType type = bb.getUniverse().getType(resultTypesBitSet.nextSetBit(0)); - return new SingleTypeState(bb, resultCanBeNull, type); + return singleTypeState(bb, resultCanBeNull, type); } else { - return new MultiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount); + return multiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount); } } else { return s1.forCanBeNull(bb, resultCanBeNull); @@ -476,9 +476,9 @@ public TypeState doSubtraction(PointsToAnalysis bb, MultiTypeState s1, MultiType return TypeState.forEmpty().forCanBeNull(bb, resultCanBeNull); } else if (typesCount == 1) { AnalysisType type = bb.getUniverse().getType(resultTypesBitSet.nextSetBit(0)); - return new SingleTypeState(bb, resultCanBeNull, type); + return singleTypeState(bb, resultCanBeNull, type); } else { - return new MultiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount); + return multiTypeState(bb, resultCanBeNull, resultTypesBitSet, typesCount); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/MultiTypeState.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/MultiTypeState.java index 67e7ceda19fa..a0f3431e9a6c 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/MultiTypeState.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/MultiTypeState.java @@ -48,25 +48,21 @@ public class MultiTypeState extends TypeState { protected boolean merged; /** Creates a new type state using the provided types bit set and objects. */ - @SuppressWarnings("this-escape") - public MultiTypeState(PointsToAnalysis bb, boolean canBeNull, BitSet typesBitSet, int typesCount) { + public MultiTypeState(boolean canBeNull, BitSet typesBitSet, int typesCount) { assert !TypeStateUtils.needsTrim(typesBitSet) : typesBitSet; this.typesBitSet = typesBitSet; this.typesCount = typesCount; this.canBeNull = canBeNull; this.merged = false; assert this.typesCount > 1 : "Multi type state with single type."; - PointsToStats.registerTypeState(bb, this); } /** Create a type state with the same content and a reversed canBeNull value. */ - @SuppressWarnings("this-escape") - protected MultiTypeState(PointsToAnalysis bb, boolean canBeNull, MultiTypeState other) { + protected MultiTypeState(boolean canBeNull, MultiTypeState other) { this.typesBitSet = other.typesBitSet; this.typesCount = other.typesCount; this.canBeNull = canBeNull; this.merged = other.merged; - PointsToStats.registerTypeState(bb, this); } /** Get the number of objects. */ @@ -141,7 +137,7 @@ public TypeState forCanBeNull(PointsToAnalysis bb, boolean resultCanBeNull) { return this; } else { /* Just flip the canBeNull flag and copy the rest of the values from this. */ - return new MultiTypeState(bb, resultCanBeNull, this); + return PointsToStats.registerTypeState(bb, new MultiTypeState(resultCanBeNull, this)); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/PointsToStats.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/PointsToStats.java index cb4c1427581c..eaa3923ca94a 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/PointsToStats.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/PointsToStats.java @@ -75,6 +75,7 @@ import com.oracle.graal.pointsto.flow.builder.TypeFlowBuilder; import com.oracle.graal.pointsto.meta.AnalysisField; import com.oracle.graal.pointsto.meta.AnalysisType; +import com.oracle.graal.pointsto.util.AnalysisError; import com.oracle.svm.util.ClassUtil; import jdk.graal.compiler.graph.NodeSourcePosition; @@ -91,6 +92,8 @@ public class PointsToStats { public static void init(PointsToAnalysis bb) { registerTypeState(bb, EmptyTypeState.SINGLETON); registerTypeState(bb, NullTypeState.SINGLETON); + registerTypeState(bb, AnyPrimitiveTypeState.SINGLETON); + PrimitiveConstantTypeState.registerCachedTypeStates(bb); reportStatistics = bb.reportAnalysisStatistics(); } @@ -162,7 +165,7 @@ private static void reportPrunedTypeFlows(BufferedWriter out) { sourceStr = value.toString() + " @ " + value.graph().method().format("%H.%n(%p)"); } } else { - sourceStr = source.toString(); + sourceStr = source != null ? source.toString() : "null"; } doWrite(out, String.format("%-35s\t%-10s%n", ClassUtil.getUnqualifiedName(provider.getFlowClass()), sourceStr)); @@ -314,23 +317,30 @@ private static void reportTypeFlowStats(BufferedWriter out) { private static final AtomicInteger nextStateId = new AtomicInteger(); private static ConcurrentHashMap typeStateStats = new ConcurrentHashMap<>(); - public static void registerTypeState(PointsToAnalysis bb, TypeState state) { + public static T registerTypeState(PointsToAnalysis bb, T state) { if (!bb.reportAnalysisStatistics()) { - return; + return state; } Integer id = stateToId.computeIfAbsent(state, (s) -> nextStateId.incrementAndGet()); TypeState actualState = idToState.computeIfAbsent(id, (i) -> state); typeStateStats.computeIfAbsent(actualState, (s) -> new AtomicInteger()).incrementAndGet(); + return state; } private static int objectsCount(TypeState state) { + if (state.isPrimitive()) { + return 0; + } return state.objectsCount(); } private static int typesCount(TypeState state) { + if (state.isPrimitive()) { + return 0; + } return state.typesCount(); } @@ -541,7 +551,7 @@ private static String formatType(AnalysisType type) { } private static String formatType(AnalysisType type, boolean qualified) { - return type.toJavaName(qualified); + return type != null ? type.toJavaName(qualified) : "null"; } @SuppressWarnings("unused") @@ -567,6 +577,13 @@ public static String asString(TypeState s) { if (s.isNull()) { return ""; } + if (s.isPrimitive()) { + return switch (s) { + case AnyPrimitiveTypeState ignored -> ""; + case PrimitiveConstantTypeState constant -> ""; + default -> throw AnalysisError.shouldNotReachHere("Unknown primitive type state: " + s.getClass()); + }; + } String sKind = s.isAllocation() ? "Alloc" : s.asConstant() != null ? "Const" : s instanceof SingleTypeState ? "Single" : s instanceof MultiTypeState ? "Multi" : ""; String sSizeOrType = s instanceof MultiTypeState ? s.typesCount() + "" : s.exactType().toJavaName(false); diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/PrimitiveConstantTypeState.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/PrimitiveConstantTypeState.java index 862e87623aad..e837d54c326e 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/PrimitiveConstantTypeState.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/PrimitiveConstantTypeState.java @@ -26,6 +26,8 @@ import java.util.Objects; +import com.oracle.graal.pointsto.PointsToAnalysis; + /** * Represents a primitive constant that is propagated through the type flow graph. Instances for * corresponding primitive values are accessible via a factory method @@ -43,13 +45,19 @@ public final class PrimitiveConstantTypeState extends PrimitiveTypeState { } } + public static void registerCachedTypeStates(PointsToAnalysis bb) { + for (var typeState : CACHE) { + PointsToStats.registerTypeState(bb, typeState); + } + } + private final long value; - public static TypeState forValue(long value) { + public static TypeState forValue(PointsToAnalysis bb, long value) { if (value >= 0 && value < CACHE_SIZE) { return CACHE[(int) value]; } - return new PrimitiveConstantTypeState(value); + return PointsToStats.registerTypeState(bb, new PrimitiveConstantTypeState(value)); } private PrimitiveConstantTypeState(long value) { diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/SingleTypeState.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/SingleTypeState.java index 57c4470ca40d..b1be10e01be0 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/SingleTypeState.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/SingleTypeState.java @@ -40,23 +40,17 @@ public class SingleTypeState extends TypeState { protected boolean merged; /** Creates a new type state from incoming objects. */ - @SuppressWarnings("this-escape") - public SingleTypeState(PointsToAnalysis bb, boolean canBeNull, AnalysisType type) { + public SingleTypeState(boolean canBeNull, AnalysisType type) { this.type = type; this.canBeNull = canBeNull; this.merged = false; - - PointsToStats.registerTypeState(bb, this); } /** Create a type state with the same content and a reversed canBeNull value. */ - @SuppressWarnings("this-escape") - protected SingleTypeState(PointsToAnalysis bb, boolean canBeNull, SingleTypeState other) { + protected SingleTypeState(boolean canBeNull, SingleTypeState other) { this.type = other.type; this.canBeNull = canBeNull; this.merged = other.merged; - - PointsToStats.registerTypeState(bb, this); } @Override @@ -121,7 +115,7 @@ public TypeState forCanBeNull(PointsToAnalysis bb, boolean stateCanBeNull) { if (stateCanBeNull == this.canBeNull()) { return this; } else { - return new SingleTypeState(bb, stateCanBeNull, this); + return PointsToStats.registerTypeState(bb, new SingleTypeState(stateCanBeNull, this)); } } diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/TypeState.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/TypeState.java index c5b95038ac30..6799149a4e0e 100644 --- a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/TypeState.java +++ b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/typestate/TypeState.java @@ -150,20 +150,20 @@ public static TypeState forNull() { return NullTypeState.SINGLETON; } - public static TypeState defaultValueForKind(JavaKind javaKind) { + public static TypeState defaultValueForKind(PointsToAnalysis bb, JavaKind javaKind) { if (javaKind.isPrimitive()) { - return TypeState.forPrimitiveConstant(0); + return TypeState.forPrimitiveConstant(bb, 0); } else { return TypeState.forNull(); } } - public static TypeState forPrimitiveConstant(long value) { - return PrimitiveConstantTypeState.forValue(value); + public static TypeState forPrimitiveConstant(PointsToAnalysis bb, long value) { + return PrimitiveConstantTypeState.forValue(bb, value); } - public static TypeState forBoolean(boolean value) { - return value ? TypeState.forPrimitiveConstant(1) : TypeState.forPrimitiveConstant(0); + public static TypeState forBoolean(PointsToAnalysis bb, boolean value) { + return value ? TypeState.forPrimitiveConstant(bb, 1) : TypeState.forPrimitiveConstant(bb, 0); } public static TypeState anyPrimitiveState() {