Mercurial > hg > truffle
changeset 15131:9c1e53adc159
Remove unsigned flag from IntegerStamp.
line wrap: on
line diff
--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/ea/EscapeAnalysisTest.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/ea/EscapeAnalysisTest.java Tue Apr 15 19:08:29 2014 +0200 @@ -279,7 +279,7 @@ @SuppressWarnings("unused") public static void testNewNodeSnippet() { - new IntegerAddNode(new IntegerStamp(32, false, Integer.MIN_VALUE, Integer.MAX_VALUE, 0, 0xFFFFFFFF), null, null); + new IntegerAddNode(new IntegerStamp(32, Integer.MIN_VALUE, Integer.MAX_VALUE, 0, 0xFFFFFFFF), null, null); } /**
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGenerator.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGenerator.java Tue Apr 15 19:08:29 2014 +0200 @@ -581,7 +581,7 @@ return stamp.getPlatformKind(this); } - public PlatformKind getIntegerKind(int bits, boolean unsigned) { + public PlatformKind getIntegerKind(int bits) { if (bits <= 8) { return Kind.Byte; } else if (bits <= 16) {
--- a/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Tue Apr 15 19:08:29 2014 +0200 @@ -905,7 +905,7 @@ int longSize = providers.getCodeCache().getTarget().arch.getSizeInBytes(Kind.Long); long offset = config.hsailFrameSaveAreaOffset + longSize * (regNumber - HSAIL.d0.number); LocationNode numSRegsLocation = ConstantLocationNode.create(FINAL_LOCATION, Kind.Byte, config.hsailFrameNumSRegOffset, hostGraph); - ValueNode numSRegs = hostGraph.unique(new FloatingReadNode(hsailFrame, numSRegsLocation, null, StampFactory.forInteger(8, false))); + ValueNode numSRegs = hostGraph.unique(new FloatingReadNode(hsailFrame, numSRegsLocation, null, StampFactory.forInteger(8))); numSRegs = SignExtendNode.convert(numSRegs, StampFactory.forKind(Kind.Byte)); location = IndexedLocationNode.create(FINAL_LOCATION, valueKind, offset, numSRegs, hostGraph, 4); } else {
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/CompressionNode.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/CompressionNode.java Tue Apr 15 19:08:29 2014 +0200 @@ -73,7 +73,7 @@ } else if (input instanceof IntegerStamp) { // compressed metaspace pointer assert PrimitiveStamp.getBits(input) == 64; - return StampFactory.forInteger(32, false); + return StampFactory.forInteger(32); } break; case Uncompress: @@ -84,7 +84,7 @@ } else if (input instanceof IntegerStamp) { // metaspace pointer assert PrimitiveStamp.getBits(input) == 32; - return StampFactory.forInteger(64, false); + return StampFactory.forInteger(64); } break; }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/CountedLoopInfo.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/CountedLoopInfo.java Tue Apr 15 19:08:29 2014 +0200 @@ -143,14 +143,14 @@ CompareNode cond; // we use a negated guard with a < condition to achieve a >= ConstantNode one = ConstantNode.forIntegerStamp(stamp, 1, graph); if (iv.direction() == Direction.Up) { - IntegerArithmeticNode v1 = sub(graph, ConstantNode.forIntegerStamp(stamp, IntegerStamp.defaultMaxValue(stamp.getBits(), stamp.isUnsigned()), graph), sub(graph, iv.strideNode(), one)); + IntegerArithmeticNode v1 = sub(graph, ConstantNode.forIntegerStamp(stamp, IntegerStamp.defaultMaxValue(stamp.getBits()), graph), sub(graph, iv.strideNode(), one)); if (oneOff) { v1 = sub(graph, v1, one); } cond = graph.unique(new IntegerLessThanNode(v1, end)); } else { assert iv.direction() == Direction.Down; - IntegerArithmeticNode v1 = add(graph, ConstantNode.forIntegerStamp(stamp, IntegerStamp.defaultMinValue(stamp.getBits(), stamp.isUnsigned()), graph), sub(graph, one, iv.strideNode())); + IntegerArithmeticNode v1 = add(graph, ConstantNode.forIntegerStamp(stamp, IntegerStamp.defaultMinValue(stamp.getBits()), graph), sub(graph, one, iv.strideNode())); if (oneOff) { v1 = add(graph, v1, one); }
--- a/graal/com.oracle.graal.nodes.test/src/com/oracle/graal/nodes/test/IntegerStampTest.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.nodes.test/src/com/oracle/graal/nodes/test/IntegerStampTest.java Tue Apr 15 19:08:29 2014 +0200 @@ -44,83 +44,83 @@ @Test public void testBooleanConstant() { - assertEquals(new IntegerStamp(32, false, 1, 1, 0x1, 0x1), ConstantNode.forBoolean(true, graph).stamp()); - assertEquals(new IntegerStamp(32, false, 0, 0, 0x0, 0x0), ConstantNode.forBoolean(false, graph).stamp()); + assertEquals(new IntegerStamp(32, 1, 1, 0x1, 0x1), ConstantNode.forBoolean(true, graph).stamp()); + assertEquals(new IntegerStamp(32, 0, 0, 0x0, 0x0), ConstantNode.forBoolean(false, graph).stamp()); } @Test public void testByteConstant() { - assertEquals(new IntegerStamp(32, false, 0, 0, 0x0, 0x0), ConstantNode.forByte((byte) 0, graph).stamp()); - assertEquals(new IntegerStamp(32, false, 16, 16, 0x10, 0x10), ConstantNode.forByte((byte) 16, graph).stamp()); - assertEquals(new IntegerStamp(32, false, -16, -16, 0xfffffff0L, 0xfffffff0L), ConstantNode.forByte((byte) -16, graph).stamp()); - assertEquals(new IntegerStamp(32, false, 127, 127, 0x7f, 0x7f), ConstantNode.forByte((byte) 127, graph).stamp()); - assertEquals(new IntegerStamp(32, false, -128, -128, 0xffffff80L, 0xffffff80L), ConstantNode.forByte((byte) -128, graph).stamp()); + assertEquals(new IntegerStamp(32, 0, 0, 0x0, 0x0), ConstantNode.forByte((byte) 0, graph).stamp()); + assertEquals(new IntegerStamp(32, 16, 16, 0x10, 0x10), ConstantNode.forByte((byte) 16, graph).stamp()); + assertEquals(new IntegerStamp(32, -16, -16, 0xfffffff0L, 0xfffffff0L), ConstantNode.forByte((byte) -16, graph).stamp()); + assertEquals(new IntegerStamp(32, 127, 127, 0x7f, 0x7f), ConstantNode.forByte((byte) 127, graph).stamp()); + assertEquals(new IntegerStamp(32, -128, -128, 0xffffff80L, 0xffffff80L), ConstantNode.forByte((byte) -128, graph).stamp()); } @Test public void testShortConstant() { - assertEquals(new IntegerStamp(32, false, 0, 0, 0x0, 0x0), ConstantNode.forShort((short) 0, graph).stamp()); - assertEquals(new IntegerStamp(32, false, 128, 128, 0x80, 0x80), ConstantNode.forShort((short) 128, graph).stamp()); - assertEquals(new IntegerStamp(32, false, -128, -128, 0xffffff80L, 0xffffff80L), ConstantNode.forShort((short) -128, graph).stamp()); - assertEquals(new IntegerStamp(32, false, 32767, 32767, 0x7fff, 0x7fff), ConstantNode.forShort((short) 32767, graph).stamp()); - assertEquals(new IntegerStamp(32, false, -32768, -32768, 0xffff8000L, 0xffff8000L), ConstantNode.forShort((short) -32768, graph).stamp()); + assertEquals(new IntegerStamp(32, 0, 0, 0x0, 0x0), ConstantNode.forShort((short) 0, graph).stamp()); + assertEquals(new IntegerStamp(32, 128, 128, 0x80, 0x80), ConstantNode.forShort((short) 128, graph).stamp()); + assertEquals(new IntegerStamp(32, -128, -128, 0xffffff80L, 0xffffff80L), ConstantNode.forShort((short) -128, graph).stamp()); + assertEquals(new IntegerStamp(32, 32767, 32767, 0x7fff, 0x7fff), ConstantNode.forShort((short) 32767, graph).stamp()); + assertEquals(new IntegerStamp(32, -32768, -32768, 0xffff8000L, 0xffff8000L), ConstantNode.forShort((short) -32768, graph).stamp()); } @Test public void testCharConstant() { - assertEquals(new IntegerStamp(32, false, 0, 0, 0x0, 0x0), ConstantNode.forChar((char) 0, graph).stamp()); - assertEquals(new IntegerStamp(32, false, 'A', 'A', 'A', 'A'), ConstantNode.forChar('A', graph).stamp()); - assertEquals(new IntegerStamp(32, false, 128, 128, 0x80, 0x80), ConstantNode.forChar((char) 128, graph).stamp()); - assertEquals(new IntegerStamp(32, false, 65535, 65535, 0xffff, 0xffff), ConstantNode.forChar((char) 65535, graph).stamp()); + assertEquals(new IntegerStamp(32, 0, 0, 0x0, 0x0), ConstantNode.forChar((char) 0, graph).stamp()); + assertEquals(new IntegerStamp(32, 'A', 'A', 'A', 'A'), ConstantNode.forChar('A', graph).stamp()); + assertEquals(new IntegerStamp(32, 128, 128, 0x80, 0x80), ConstantNode.forChar((char) 128, graph).stamp()); + assertEquals(new IntegerStamp(32, 65535, 65535, 0xffff, 0xffff), ConstantNode.forChar((char) 65535, graph).stamp()); } @Test public void testIntConstant() { - assertEquals(new IntegerStamp(32, false, 0, 0, 0x0, 0x0), ConstantNode.forInt(0, graph).stamp()); - assertEquals(new IntegerStamp(32, false, 128, 128, 0x80, 0x80), ConstantNode.forInt(128, graph).stamp()); - assertEquals(new IntegerStamp(32, false, -128, -128, 0xffffff80L, 0xffffff80L), ConstantNode.forInt(-128, graph).stamp()); - assertEquals(new IntegerStamp(32, false, Integer.MAX_VALUE, Integer.MAX_VALUE, 0x7fffffff, 0x7fffffff), ConstantNode.forInt(Integer.MAX_VALUE, graph).stamp()); - assertEquals(new IntegerStamp(32, false, Integer.MIN_VALUE, Integer.MIN_VALUE, 0x80000000L, 0x80000000L), ConstantNode.forInt(Integer.MIN_VALUE, graph).stamp()); + assertEquals(new IntegerStamp(32, 0, 0, 0x0, 0x0), ConstantNode.forInt(0, graph).stamp()); + assertEquals(new IntegerStamp(32, 128, 128, 0x80, 0x80), ConstantNode.forInt(128, graph).stamp()); + assertEquals(new IntegerStamp(32, -128, -128, 0xffffff80L, 0xffffff80L), ConstantNode.forInt(-128, graph).stamp()); + assertEquals(new IntegerStamp(32, Integer.MAX_VALUE, Integer.MAX_VALUE, 0x7fffffff, 0x7fffffff), ConstantNode.forInt(Integer.MAX_VALUE, graph).stamp()); + assertEquals(new IntegerStamp(32, Integer.MIN_VALUE, Integer.MIN_VALUE, 0x80000000L, 0x80000000L), ConstantNode.forInt(Integer.MIN_VALUE, graph).stamp()); } @Test public void testLongConstant() { - assertEquals(new IntegerStamp(64, false, 0, 0, 0x0, 0x0), ConstantNode.forLong(0, graph).stamp()); - assertEquals(new IntegerStamp(64, false, 128, 128, 0x80, 0x80), ConstantNode.forLong(128, graph).stamp()); - assertEquals(new IntegerStamp(64, false, -128, -128, 0xffffffffffffff80L, 0xffffffffffffff80L), ConstantNode.forLong(-128, graph).stamp()); - assertEquals(new IntegerStamp(64, false, Long.MAX_VALUE, Long.MAX_VALUE, 0x7fffffffffffffffL, 0x7fffffffffffffffL), ConstantNode.forLong(Long.MAX_VALUE, graph).stamp()); - assertEquals(new IntegerStamp(64, false, Long.MIN_VALUE, Long.MIN_VALUE, 0x8000000000000000L, 0x8000000000000000L), ConstantNode.forLong(Long.MIN_VALUE, graph).stamp()); + assertEquals(new IntegerStamp(64, 0, 0, 0x0, 0x0), ConstantNode.forLong(0, graph).stamp()); + assertEquals(new IntegerStamp(64, 128, 128, 0x80, 0x80), ConstantNode.forLong(128, graph).stamp()); + assertEquals(new IntegerStamp(64, -128, -128, 0xffffffffffffff80L, 0xffffffffffffff80L), ConstantNode.forLong(-128, graph).stamp()); + assertEquals(new IntegerStamp(64, Long.MAX_VALUE, Long.MAX_VALUE, 0x7fffffffffffffffL, 0x7fffffffffffffffL), ConstantNode.forLong(Long.MAX_VALUE, graph).stamp()); + assertEquals(new IntegerStamp(64, Long.MIN_VALUE, Long.MIN_VALUE, 0x8000000000000000L, 0x8000000000000000L), ConstantNode.forLong(Long.MIN_VALUE, graph).stamp()); } @Test public void testPositiveRanges() { - assertEquals(new IntegerStamp(32, false, 0, 0, 0, 0), StampFactory.forInteger(Kind.Int, 0, 0)); - assertEquals(new IntegerStamp(32, false, 0, 1, 0, 1), StampFactory.forInteger(Kind.Int, 0, 1)); - assertEquals(new IntegerStamp(32, false, 0, 0x123, 0, 0x1ff), StampFactory.forInteger(Kind.Int, 0, 0x123)); - assertEquals(new IntegerStamp(32, false, 0x120, 0x123, 0x120, 0x123), StampFactory.forInteger(Kind.Int, 0x120, 0x123)); - assertEquals(new IntegerStamp(32, false, 10000, 15000, 0x2000, 0x3fff), StampFactory.forInteger(Kind.Int, 10000, 15000)); - assertEquals(new IntegerStamp(64, false, 0, 1, 0, 1), StampFactory.forInteger(Kind.Long, 0, 1)); - assertEquals(new IntegerStamp(64, false, 10000, 15000, 0x2000, 0x3fff), StampFactory.forInteger(Kind.Long, 10000, 15000)); - assertEquals(new IntegerStamp(64, false, 140000000000L, 150000000000L, 0x2000000000L, 0x23ffffffffL), StampFactory.forInteger(Kind.Long, 140000000000L, 150000000000L)); + assertEquals(new IntegerStamp(32, 0, 0, 0, 0), StampFactory.forInteger(Kind.Int, 0, 0)); + assertEquals(new IntegerStamp(32, 0, 1, 0, 1), StampFactory.forInteger(Kind.Int, 0, 1)); + assertEquals(new IntegerStamp(32, 0, 0x123, 0, 0x1ff), StampFactory.forInteger(Kind.Int, 0, 0x123)); + assertEquals(new IntegerStamp(32, 0x120, 0x123, 0x120, 0x123), StampFactory.forInteger(Kind.Int, 0x120, 0x123)); + assertEquals(new IntegerStamp(32, 10000, 15000, 0x2000, 0x3fff), StampFactory.forInteger(Kind.Int, 10000, 15000)); + assertEquals(new IntegerStamp(64, 0, 1, 0, 1), StampFactory.forInteger(Kind.Long, 0, 1)); + assertEquals(new IntegerStamp(64, 10000, 15000, 0x2000, 0x3fff), StampFactory.forInteger(Kind.Long, 10000, 15000)); + assertEquals(new IntegerStamp(64, 140000000000L, 150000000000L, 0x2000000000L, 0x23ffffffffL), StampFactory.forInteger(Kind.Long, 140000000000L, 150000000000L)); } @Test public void testNegativeRanges() { - assertEquals(new IntegerStamp(32, false, -2, -1, 0xfffffffeL, 0xffffffffL), StampFactory.forInteger(Kind.Int, -2, -1)); - assertEquals(new IntegerStamp(32, false, -20, -10, 0xffffffe0L, 0xffffffffL), StampFactory.forInteger(Kind.Int, -20, -10)); - assertEquals(new IntegerStamp(32, false, -10000, 0, 0, 0xffffffffL), StampFactory.forInteger(Kind.Int, -10000, 0)); - assertEquals(new IntegerStamp(32, false, -10000, -1, 0xffffc000L, 0xffffffffL), StampFactory.forInteger(Kind.Int, -10000, -1)); - assertEquals(new IntegerStamp(32, false, -10010, -10000, 0xffffd8e0L, 0xffffd8ffL), StampFactory.forInteger(Kind.Int, -10010, -10000)); - assertEquals(new IntegerStamp(64, false, -2, -1, 0xfffffffffffffffeL, 0xffffffffffffffffL), StampFactory.forInteger(Kind.Long, -2, -1)); - assertEquals(new IntegerStamp(64, false, -10010, -10000, 0xffffffffffffd8e0L, 0xffffffffffffd8ffL), StampFactory.forInteger(Kind.Long, -10010, -10000)); - assertEquals(new IntegerStamp(64, false, -150000000000L, -140000000000L, 0xffffffdc00000000L, 0xffffffdfffffffffL), StampFactory.forInteger(Kind.Long, -150000000000L, -140000000000L)); + assertEquals(new IntegerStamp(32, -2, -1, 0xfffffffeL, 0xffffffffL), StampFactory.forInteger(Kind.Int, -2, -1)); + assertEquals(new IntegerStamp(32, -20, -10, 0xffffffe0L, 0xffffffffL), StampFactory.forInteger(Kind.Int, -20, -10)); + assertEquals(new IntegerStamp(32, -10000, 0, 0, 0xffffffffL), StampFactory.forInteger(Kind.Int, -10000, 0)); + assertEquals(new IntegerStamp(32, -10000, -1, 0xffffc000L, 0xffffffffL), StampFactory.forInteger(Kind.Int, -10000, -1)); + assertEquals(new IntegerStamp(32, -10010, -10000, 0xffffd8e0L, 0xffffd8ffL), StampFactory.forInteger(Kind.Int, -10010, -10000)); + assertEquals(new IntegerStamp(64, -2, -1, 0xfffffffffffffffeL, 0xffffffffffffffffL), StampFactory.forInteger(Kind.Long, -2, -1)); + assertEquals(new IntegerStamp(64, -10010, -10000, 0xffffffffffffd8e0L, 0xffffffffffffd8ffL), StampFactory.forInteger(Kind.Long, -10010, -10000)); + assertEquals(new IntegerStamp(64, -150000000000L, -140000000000L, 0xffffffdc00000000L, 0xffffffdfffffffffL), StampFactory.forInteger(Kind.Long, -150000000000L, -140000000000L)); } @Test public void testMixedRanges() { - assertEquals(new IntegerStamp(32, false, -1, 0, 0, 0xffffffffL), StampFactory.forInteger(Kind.Int, -1, 0)); - assertEquals(new IntegerStamp(32, false, -10000, 1000, 0, 0xffffffffL), StampFactory.forInteger(Kind.Int, -10000, 1000)); - assertEquals(new IntegerStamp(64, false, -10000, 1000, 0, 0xffffffffffffffffL), StampFactory.forInteger(Kind.Long, -10000, 1000)); + assertEquals(new IntegerStamp(32, -1, 0, 0, 0xffffffffL), StampFactory.forInteger(Kind.Int, -1, 0)); + assertEquals(new IntegerStamp(32, -10000, 1000, 0, 0xffffffffL), StampFactory.forInteger(Kind.Int, -10000, 1000)); + assertEquals(new IntegerStamp(64, -10000, 1000, 0, 0xffffffffffffffffL), StampFactory.forInteger(Kind.Long, -10000, 1000)); } @Test @@ -159,15 +159,15 @@ @Test public void testXor() { - assertEquals(new IntegerStamp(32, false, 0, 0xff, 0, 0xff), StampTool.xor(new IntegerStamp(32, false, 0, 0, 0, 0), new IntegerStamp(32, false, 0, 0xff, 0, 0xff))); - assertEquals(new IntegerStamp(32, false, 0x10, 0x1f, 0x10, 0x1f), StampTool.xor(new IntegerStamp(32, false, 0, 0, 0, 0), new IntegerStamp(32, false, 0x10, 0x1f, 0x10, 0x1f))); - assertEquals(new IntegerStamp(32, false, 0x0, 0xf, 0x0, 0xf), StampTool.xor(new IntegerStamp(32, false, 0x10, 0x10, 0x10, 0x10), new IntegerStamp(32, false, 0x10, 0x1f, 0x10, 0x1f))); - assertEquals(new IntegerStamp(32, false, 0x10, 0x1f, 0x10, 0x1f), StampTool.xor(new IntegerStamp(32, false, 0x10, 0x10, 0x10, 0x10), new IntegerStamp(32, false, 0x0, 0xf, 0x0, 0xf))); + assertEquals(new IntegerStamp(32, 0, 0xff, 0, 0xff), StampTool.xor(new IntegerStamp(32, 0, 0, 0, 0), new IntegerStamp(32, 0, 0xff, 0, 0xff))); + assertEquals(new IntegerStamp(32, 0x10, 0x1f, 0x10, 0x1f), StampTool.xor(new IntegerStamp(32, 0, 0, 0, 0), new IntegerStamp(32, 0x10, 0x1f, 0x10, 0x1f))); + assertEquals(new IntegerStamp(32, 0x0, 0xf, 0x0, 0xf), StampTool.xor(new IntegerStamp(32, 0x10, 0x10, 0x10, 0x10), new IntegerStamp(32, 0x10, 0x1f, 0x10, 0x1f))); + assertEquals(new IntegerStamp(32, 0x10, 0x1f, 0x10, 0x1f), StampTool.xor(new IntegerStamp(32, 0x10, 0x10, 0x10, 0x10), new IntegerStamp(32, 0x0, 0xf, 0x0, 0xf))); } @Test public void testNot() { - assertEquals(new IntegerStamp(32, false, -11, -1, 0xffff_fff0L, 0xffff_ffffL), StampTool.not(new IntegerStamp(32, false, 0, 10, 0, 0xf))); + assertEquals(new IntegerStamp(32, -11, -1, 0xffff_fff0L, 0xffff_ffffL), StampTool.not(new IntegerStamp(32, 0, 10, 0, 0xf))); } @Test @@ -258,13 +258,13 @@ @Test public void testAnd() { - assertEquals(new IntegerStamp(32, false, Integer.MIN_VALUE, 0x40000000L, 0, 0xc0000000L), StampTool.and(StampFactory.forKind(Kind.Int), StampFactory.forConstant(Constant.forInt(0xc0000000)))); + assertEquals(new IntegerStamp(32, Integer.MIN_VALUE, 0x40000000L, 0, 0xc0000000L), StampTool.and(StampFactory.forKind(Kind.Int), StampFactory.forConstant(Constant.forInt(0xc0000000)))); } private static void testSignExtendShort(long lower, long upper) { - Stamp shortStamp = StampFactory.forInteger(16, false, lower, upper); + Stamp shortStamp = StampFactory.forInteger(16, lower, upper); Stamp intStamp = StampTool.signExtend(shortStamp, 32); - assertEquals(StampFactory.forInteger(32, false, lower, upper), intStamp); + assertEquals(StampFactory.forInteger(32, lower, upper), intStamp); } @Test @@ -278,9 +278,9 @@ } private static void testZeroExtendShort(long lower, long upper, long newLower, long newUpper) { - Stamp shortStamp = StampFactory.forInteger(16, false, lower, upper); + Stamp shortStamp = StampFactory.forInteger(16, lower, upper); Stamp intStamp = StampTool.zeroExtend(shortStamp, 32); - assertEquals(StampFactory.forInteger(32, false, newLower, newUpper), intStamp); + assertEquals(StampFactory.forInteger(32, newLower, newUpper), intStamp); } @Test @@ -292,36 +292,4 @@ testZeroExtendShort(-1, 1, 0, 0xFFFF); testZeroExtendShort(Short.MIN_VALUE, Short.MAX_VALUE, 0, 0xFFFF); } - - private static void testSignExtendChar(long lower, long upper, long newLower, long newUpper) { - Stamp charStamp = StampFactory.forInteger(16, true, lower, upper); - Stamp uintStamp = StampTool.signExtend(charStamp, 32); - assertEquals(StampFactory.forInteger(32, true, newLower, newUpper), uintStamp); - } - - @Test - public void testSignExtendUnsigned() { - testSignExtendChar(5, 7, 5, 7); - testSignExtendChar(0, 42, 0, 42); - testSignExtendChar(5, 0xF000, 5, 0xFFFFF000L); - testSignExtendChar(0, 0xF000, 0, 0xFFFFF000L); - testSignExtendChar(0xF000, Character.MAX_VALUE, 0xFFFFF000L, 0xFFFFFFFFL); - testSignExtendChar(Character.MIN_VALUE, Character.MAX_VALUE, 0, 0xFFFFFFFFL); - } - - private static void testZeroExtendChar(long lower, long upper) { - Stamp charStamp = StampFactory.forInteger(16, true, lower, upper); - Stamp uintStamp = StampTool.zeroExtend(charStamp, 32); - assertEquals(StampFactory.forInteger(32, true, lower, upper), uintStamp); - } - - @Test - public void testZeroExtendUnsigned() { - testZeroExtendChar(5, 7); - testZeroExtendChar(0, 42); - testZeroExtendChar(5, 0xF000); - testZeroExtendChar(0, 0xF000); - testZeroExtendChar(0xF000, Character.MAX_VALUE); - testZeroExtendChar(Character.MIN_VALUE, Character.MAX_VALUE); - } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ConstantNode.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ConstantNode.java Tue Apr 15 19:08:29 2014 +0200 @@ -49,7 +49,7 @@ /** * Constructs a new node representing the specified constant. - * + * * @param value the constant */ protected ConstantNode(Constant value, Stamp stamp) { @@ -184,7 +184,7 @@ /** * Returns a node for a double constant. - * + * * @param d the double value for which to create the instruction * @return a node for a double constant */ @@ -194,7 +194,7 @@ /** * Returns a node for a float constant. - * + * * @param f the float value for which to create the instruction * @return a node for a float constant */ @@ -204,7 +204,7 @@ /** * Returns a node for an long constant. - * + * * @param i the long value for which to create the instruction * @return a node for an long constant */ @@ -214,7 +214,7 @@ /** * Returns a node for an integer constant. - * + * * @param i the integer value for which to create the instruction * @return a node for an integer constant */ @@ -224,7 +224,7 @@ /** * Returns a node for a boolean constant. - * + * * @param i the boolean value for which to create the instruction * @return a node representing the boolean */ @@ -234,7 +234,7 @@ /** * Returns a node for a byte constant. - * + * * @param i the byte value for which to create the instruction * @return a node representing the byte */ @@ -244,7 +244,7 @@ /** * Returns a node for a char constant. - * + * * @param i the char value for which to create the instruction * @return a node representing the char */ @@ -254,7 +254,7 @@ /** * Returns a node for a short constant. - * + * * @param i the short value for which to create the instruction * @return a node representing the short */ @@ -264,7 +264,7 @@ /** * Returns a node for an object constant. - * + * * @param o the object value for which to create the instruction * @return a node representing the object */ @@ -282,15 +282,10 @@ * Returns a node for a constant integer that's not directly representable as Java primitive * (e.g. short). */ - public static ConstantNode forIntegerBits(int bits, boolean unsigned, long value, StructuredGraph graph) { + public static ConstantNode forIntegerBits(int bits, long value, StructuredGraph graph) { Constant constant = Constant.forPrimitiveInt(bits, value); - long bounds; - if (unsigned) { - bounds = ZeroExtendNode.zeroExtend(value, bits); - } else { - bounds = SignExtendNode.signExtend(value, bits); - } - return unique(graph, new ConstantNode(constant, StampFactory.forInteger(bits, unsigned, bounds, bounds))); + long bounds = SignExtendNode.signExtend(value, bits); + return unique(graph, new ConstantNode(constant, StampFactory.forInteger(bits, bounds, bounds))); } /** @@ -299,7 +294,7 @@ public static ConstantNode forIntegerStamp(Stamp stamp, long value, StructuredGraph graph) { if (stamp instanceof IntegerStamp) { IntegerStamp intStamp = (IntegerStamp) stamp; - return forIntegerBits(intStamp.getBits(), intStamp.isUnsigned(), value, graph); + return forIntegerBits(intStamp.getBits(), value, graph); } else { return forIntegerKind(stamp.getStackKind(), value, graph); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerConvertNode.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerConvertNode.java Tue Apr 15 19:08:29 2014 +0200 @@ -67,7 +67,7 @@ return getInput(); } else if (getInput().isConstant()) { Constant ret = evalConst(getInput().asConstant()); - return ConstantNode.forIntegerBits(resultBits, false, ret.asLong(), graph()); + return ConstantNode.forIntegerBits(resultBits, ret.asLong(), graph()); } } @@ -86,19 +86,11 @@ result = graph.unique(new NarrowNode(input, toStamp.getBits())); } else { // toStamp.getBits() > fromStamp.getBits() - if (fromStamp.isUnsigned()) { - result = graph.unique(new ZeroExtendNode(input, toStamp.getBits())); - } else { - result = graph.unique(new SignExtendNode(input, toStamp.getBits())); - } + result = graph.unique(new SignExtendNode(input, toStamp.getBits())); } IntegerStamp resultStamp = (IntegerStamp) result.stamp(); assert toStamp.getBits() == resultStamp.getBits(); - if (toStamp.isUnsigned() == resultStamp.isUnsigned()) { - return result; - } else { - return graph.unique(new ReinterpretNode(toStamp, result)); - } + return result; } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/NarrowNode.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/NarrowNode.java Tue Apr 15 19:08:29 2014 +0200 @@ -50,13 +50,7 @@ @Override public Constant reverse(Constant input) { - IntegerStamp stamp = (IntegerStamp) stamp(); - long result; - if (stamp.isUnsigned()) { - result = ZeroExtendNode.zeroExtend(input.asLong(), getResultBits()); - } else { - result = SignExtendNode.signExtend(input.asLong(), getResultBits()); - } + long result = SignExtendNode.signExtend(input.asLong(), getResultBits()); return Constant.forPrimitiveInt(getInputBits(), result); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/LIRTypeTool.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/LIRTypeTool.java Tue Apr 15 19:08:29 2014 +0200 @@ -29,7 +29,7 @@ */ public interface LIRTypeTool { - PlatformKind getIntegerKind(int bits, boolean unsigned); + PlatformKind getIntegerKind(int bits); PlatformKind getFloatingKind(int bits);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/type/IntegerStamp.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/type/IntegerStamp.java Tue Apr 15 19:08:29 2014 +0200 @@ -31,29 +31,26 @@ /** * Describes the possible values of a {@link ValueNode} that produces an int or long result. - * + * * The description consists of (inclusive) lower and upper bounds and up (may be set) and down * (always set) bit-masks. */ public class IntegerStamp extends PrimitiveStamp { - private final boolean unsigned; - private final long lowerBound; private final long upperBound; private final long downMask; private final long upMask; - public IntegerStamp(int bits, boolean unsigned, long lowerBound, long upperBound, long downMask, long upMask) { + public IntegerStamp(int bits, long lowerBound, long upperBound, long downMask, long upMask) { super(bits); - this.unsigned = unsigned; this.lowerBound = lowerBound; this.upperBound = upperBound; this.downMask = downMask; this.upMask = upMask; assert lowerBound <= upperBound : this; - assert lowerBound >= defaultMinValue(bits, unsigned) : this; - assert upperBound <= defaultMaxValue(bits, unsigned) : this; + assert lowerBound >= defaultMinValue(bits) : this; + assert upperBound <= defaultMaxValue(bits) : this; assert (downMask & defaultMask(bits)) == downMask : this; assert (upMask & defaultMask(bits)) == upMask : this; assert (lowerBound & downMask) == downMask : this; @@ -62,7 +59,7 @@ @Override public Stamp unrestricted() { - return new IntegerStamp(getBits(), unsigned, defaultMinValue(getBits(), unsigned), defaultMaxValue(getBits(), unsigned), 0, defaultMask(getBits())); + return new IntegerStamp(getBits(), defaultMinValue(getBits()), defaultMaxValue(getBits()), 0, defaultMask(getBits())); } @Override @@ -76,29 +73,21 @@ @Override public PlatformKind getPlatformKind(LIRTypeTool tool) { - return tool.getIntegerKind(getBits(), unsigned); + return tool.getIntegerKind(getBits()); } @Override public ResolvedJavaType javaType(MetaAccessProvider metaAccess) { switch (getBits()) { case 1: - assert unsigned; return metaAccess.lookupJavaType(Boolean.TYPE); case 8: - assert !unsigned; return metaAccess.lookupJavaType(Byte.TYPE); case 16: - if (unsigned) { - return metaAccess.lookupJavaType(Character.TYPE); - } else { - return metaAccess.lookupJavaType(Short.TYPE); - } + return metaAccess.lookupJavaType(Short.TYPE); case 32: - assert !unsigned; return metaAccess.lookupJavaType(Integer.TYPE); case 64: - assert !unsigned; return metaAccess.lookupJavaType(Long.TYPE); default: throw GraalInternalError.shouldNotReachHere(); @@ -106,21 +95,14 @@ } /** - * Check whether the value described by this stamp is unsigned. - */ - public boolean isUnsigned() { - return unsigned; - } - - /** - * The (inclusive) lower bound on the value described by this stamp. + * The signed inclusive lower bound on the value described by this stamp. */ public long lowerBound() { return lowerBound; } /** - * The (inclusive) upper bound on the value described by this stamp. + * The signed inclusive upper bound on the value described by this stamp. */ public long upperBound() { return upperBound; @@ -141,7 +123,7 @@ } public boolean isUnrestricted() { - return lowerBound == defaultMinValue(getBits(), unsigned) && upperBound == defaultMaxValue(getBits(), unsigned) && downMask == 0 && upMask == defaultMask(getBits()); + return lowerBound == defaultMinValue(getBits()) && upperBound == defaultMaxValue(getBits()) && downMask == 0 && upMask == defaultMask(getBits()); } public boolean contains(long value) { @@ -175,11 +157,11 @@ @Override public String toString() { StringBuilder str = new StringBuilder(); - str.append(unsigned ? 'u' : 'i'); + str.append('i'); str.append(getBits()); if (lowerBound == upperBound) { str.append(" [").append(lowerBound).append(']'); - } else if (lowerBound != defaultMinValue(getBits(), unsigned) || upperBound != defaultMaxValue(getBits(), unsigned)) { + } else if (lowerBound != defaultMinValue(getBits()) || upperBound != defaultMaxValue(getBits())) { str.append(" [").append(lowerBound).append(" - ").append(upperBound).append(']'); } if (downMask != 0) { @@ -194,7 +176,7 @@ } private Stamp createStamp(IntegerStamp other, long newUpperBound, long newLowerBound, long newDownMask, long newUpMask) { - assert getBits() == other.getBits() && unsigned == other.unsigned; + assert getBits() == other.getBits(); if (newLowerBound > newUpperBound || (newDownMask & (~newUpMask)) != 0) { return illegal(); } else if (newLowerBound == lowerBound && newUpperBound == upperBound && newDownMask == downMask && newUpMask == upMask) { @@ -202,7 +184,7 @@ } else if (newLowerBound == other.lowerBound && newUpperBound == other.upperBound && newDownMask == other.downMask && newUpMask == other.upMask) { return other; } else { - return new IntegerStamp(getBits(), unsigned, newLowerBound, newUpperBound, newDownMask, newUpMask); + return new IntegerStamp(getBits(), newLowerBound, newUpperBound, newDownMask, newUpMask); } } @@ -245,7 +227,7 @@ } if (stamp instanceof IntegerStamp) { IntegerStamp other = (IntegerStamp) stamp; - return getBits() == other.getBits() && unsigned == other.unsigned; + return getBits() == other.getBits(); } return false; } @@ -278,7 +260,7 @@ } public static long defaultMask(int bits) { - assert 0 < bits && bits <= 64; + assert 0 <= bits && bits <= 64; if (bits == 64) { return 0xffffffffffffffffL; } else { @@ -286,16 +268,12 @@ } } - public static long defaultMinValue(int bits, boolean unsigned) { - if (unsigned) { - return 0; - } else { - return -1L << (bits - 1); - } + public static long defaultMinValue(int bits) { + return -1L << (bits - 1); } - public static long defaultMaxValue(int bits, boolean unsigned) { - return defaultMask(unsigned ? bits : bits - 1); + public static long defaultMaxValue(int bits) { + return defaultMask(bits - 1); } public static long upMaskFor(int bits, long lowerBound, long upperBound) { @@ -310,7 +288,7 @@ /** * Checks if the 2 stamps represent values of the same sign. Returns true if the two stamps are * both positive of null or if they are both strictly negative - * + * * @return true if the two stamps are both positive of null or if they are both strictly * negative */ @@ -327,11 +305,7 @@ case 8: return Constant.forByte((byte) lowerBound); case 16: - if (unsigned) { - return Constant.forChar((char) lowerBound); - } else { - return Constant.forShort((short) lowerBound); - } + return Constant.forShort((short) lowerBound); case 32: return Constant.forInt((int) lowerBound); case 64:
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/type/StampFactory.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/type/StampFactory.java Tue Apr 15 19:08:29 2014 +0200 @@ -53,7 +53,7 @@ } else { mask = IntegerStamp.defaultMask(bits); } - setCache(kind, new IntegerStamp(bits, false, kind.getMinValue(), kind.getMaxValue(), 0, mask)); + setCache(kind, new IntegerStamp(bits, kind.getMinValue(), kind.getMaxValue(), 0, mask)); } private static void setFloatCache(Kind kind) { @@ -127,21 +127,21 @@ } public static IntegerStamp forInteger(Kind kind, long lowerBound, long upperBound, long downMask, long upMask) { - return new IntegerStamp(kind.getBitCount(), kind.isUnsigned(), lowerBound, upperBound, downMask, upMask); + return new IntegerStamp(kind.getBitCount(), lowerBound, upperBound, downMask, upMask); } public static IntegerStamp forInteger(Kind kind, long lowerBound, long upperBound) { - return forInteger(kind.getBitCount(), kind.isUnsigned(), lowerBound, upperBound); + return forInteger(kind.getBitCount(), lowerBound, upperBound); } - public static IntegerStamp forInteger(int bits, boolean unsigned) { - return new IntegerStamp(bits, unsigned, IntegerStamp.defaultMinValue(bits, unsigned), IntegerStamp.defaultMaxValue(bits, unsigned), 0, IntegerStamp.defaultMask(bits)); + public static IntegerStamp forInteger(int bits) { + return new IntegerStamp(bits, IntegerStamp.defaultMinValue(bits), IntegerStamp.defaultMaxValue(bits), 0, IntegerStamp.defaultMask(bits)); } - public static IntegerStamp forInteger(int bits, boolean unsigned, long lowerBound, long upperBound) { + public static IntegerStamp forInteger(int bits, long lowerBound, long upperBound) { long defaultMask = IntegerStamp.defaultMask(bits); if (lowerBound == upperBound) { - return new IntegerStamp(bits, unsigned, lowerBound, lowerBound, lowerBound & defaultMask, lowerBound & defaultMask); + return new IntegerStamp(bits, lowerBound, lowerBound, lowerBound & defaultMask, lowerBound & defaultMask); } final long downMask; final long upMask; @@ -165,7 +165,7 @@ downMask = lowerBound & ~(-1L >>> (lowerBoundLeadingOnes + sameBitCount)) | ~(-1L >>> lowerBoundLeadingOnes); } } - return new IntegerStamp(bits, unsigned, lowerBound, upperBound, downMask & defaultMask, upMask & defaultMask); + return new IntegerStamp(bits, lowerBound, upperBound, downMask & defaultMask, upMask & defaultMask); } public static FloatStamp forFloat(Kind kind, double lowerBound, double upperBound, boolean nonNaN) {
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/type/StampTool.java Wed Apr 16 13:52:43 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/type/StampTool.java Tue Apr 15 19:08:29 2014 +0200 @@ -53,9 +53,9 @@ if (stamp instanceof IntegerStamp) { IntegerStamp integerStamp = (IntegerStamp) stamp; int bits = integerStamp.getBits(); - if (integerStamp.lowerBound() != IntegerStamp.defaultMinValue(bits, false)) { + if (integerStamp.lowerBound() != IntegerStamp.defaultMinValue(bits)) { // TODO(ls) check if the mask calculation is correct... - return StampFactory.forInteger(bits, false, -integerStamp.upperBound(), -integerStamp.lowerBound()); + return StampFactory.forInteger(bits, -integerStamp.upperBound(), -integerStamp.lowerBound()); } } else if (stamp instanceof FloatStamp) { FloatStamp floatStamp = (FloatStamp) stamp; @@ -70,8 +70,7 @@ IntegerStamp integerStamp = (IntegerStamp) stamp; int bits = integerStamp.getBits(); long defaultMask = IntegerStamp.defaultMask(bits); - return new IntegerStamp(bits, integerStamp.isUnsigned(), ~integerStamp.upperBound(), ~integerStamp.lowerBound(), (~integerStamp.upMask()) & defaultMask, (~integerStamp.downMask()) & - defaultMask); + return new IntegerStamp(bits, ~integerStamp.upperBound(), ~integerStamp.lowerBound(), (~integerStamp.upMask()) & defaultMask, (~integerStamp.downMask()) & defaultMask); } return stamp.unrestricted(); } @@ -112,45 +111,36 @@ } public static Stamp div(IntegerStamp stamp1, IntegerStamp stamp2) { - assert stamp1.getBits() == stamp2.getBits() && stamp1.isUnsigned() == stamp2.isUnsigned(); + assert stamp1.getBits() == stamp2.getBits(); if (stamp2.isStrictlyPositive()) { long lowerBound = stamp1.lowerBound() / stamp2.lowerBound(); long upperBound = stamp1.upperBound() / stamp2.lowerBound(); - return StampFactory.forInteger(stamp1.getBits(), stamp1.isUnsigned(), lowerBound, upperBound); + return StampFactory.forInteger(stamp1.getBits(), lowerBound, upperBound); } return stamp1.unrestricted(); } - private static boolean addOverflowsPositively(long x, long y, int bits, boolean unsigned) { + private static boolean addOverflowsPositively(long x, long y, int bits) { long result = x + y; if (bits == 64) { - if (unsigned) { - return ((x | y) & ~result) < 0; - } else { - return (~x & ~y & result) < 0; - } + return (~x & ~y & result) < 0; } else { - return result > IntegerStamp.defaultMaxValue(bits, unsigned); + return result > IntegerStamp.defaultMaxValue(bits); } } - private static boolean addOverflowsNegatively(long x, long y, int bits, boolean unsigned) { - if (unsigned) { - return false; - } - + private static boolean addOverflowsNegatively(long x, long y, int bits) { long result = x + y; if (bits == 64) { return (x & y & ~result) < 0; } else { - return result < IntegerStamp.defaultMinValue(bits, unsigned); + return result < IntegerStamp.defaultMinValue(bits); } } public static IntegerStamp add(IntegerStamp stamp1, IntegerStamp stamp2) { int bits = stamp1.getBits(); - boolean unsigned = stamp1.isUnsigned(); - assert bits == stamp2.getBits() && unsigned == stamp2.isUnsigned(); + assert bits == stamp2.getBits(); if (stamp1.isUnrestricted()) { return stamp1; @@ -168,30 +158,23 @@ long lowerBound; long upperBound; - boolean lowerOverflowsPositively = addOverflowsPositively(stamp1.lowerBound(), stamp2.lowerBound(), bits, unsigned); - boolean upperOverflowsPositively = addOverflowsPositively(stamp1.upperBound(), stamp2.upperBound(), bits, unsigned); - boolean lowerOverflowsNegatively = addOverflowsNegatively(stamp1.lowerBound(), stamp2.lowerBound(), bits, unsigned); - boolean upperOverflowsNegatively = addOverflowsNegatively(stamp1.upperBound(), stamp2.upperBound(), bits, unsigned); + boolean lowerOverflowsPositively = addOverflowsPositively(stamp1.lowerBound(), stamp2.lowerBound(), bits); + boolean upperOverflowsPositively = addOverflowsPositively(stamp1.upperBound(), stamp2.upperBound(), bits); + boolean lowerOverflowsNegatively = addOverflowsNegatively(stamp1.lowerBound(), stamp2.lowerBound(), bits); + boolean upperOverflowsNegatively = addOverflowsNegatively(stamp1.upperBound(), stamp2.upperBound(), bits); if ((lowerOverflowsNegatively && !upperOverflowsNegatively) || (!lowerOverflowsPositively && upperOverflowsPositively)) { - lowerBound = IntegerStamp.defaultMinValue(bits, unsigned); - upperBound = IntegerStamp.defaultMaxValue(bits, unsigned); + lowerBound = IntegerStamp.defaultMinValue(bits); + upperBound = IntegerStamp.defaultMaxValue(bits); } else { - lowerBound = (stamp1.lowerBound() + stamp2.lowerBound()) & defaultMask; - upperBound = (stamp1.upperBound() + stamp2.upperBound()) & defaultMask; - if (!unsigned) { - lowerBound = SignExtendNode.signExtend(lowerBound, bits); - upperBound = SignExtendNode.signExtend(upperBound, bits); - } + lowerBound = SignExtendNode.signExtend((stamp1.lowerBound() + stamp2.lowerBound()) & defaultMask, bits); + upperBound = SignExtendNode.signExtend((stamp1.upperBound() + stamp2.upperBound()) & defaultMask, bits); } - IntegerStamp limit = StampFactory.forInteger(bits, unsigned, lowerBound, upperBound); + IntegerStamp limit = StampFactory.forInteger(bits, lowerBound, upperBound); newUpMask &= limit.upMask(); - upperBound &= newUpMask; - if (!unsigned) { - upperBound = SignExtendNode.signExtend(upperBound, bits); - } + upperBound = SignExtendNode.signExtend(upperBound & newUpMask, bits); newDownMask |= limit.downMask(); lowerBound |= newDownMask; - return new IntegerStamp(bits, unsigned, lowerBound, upperBound, newDownMask, newUpMask); + return new IntegerStamp(bits, lowerBound, upperBound, newDownMask, newUpMask); } public static Stamp sub(IntegerStamp stamp1, IntegerStamp stamp2) { @@ -212,11 +195,11 @@ upperBound = upMask; } else { lowerBound = downMask | (-1L << (bits - 1)); - upperBound = IntegerStamp.defaultMaxValue(bits, false) & upMask; + upperBound = IntegerStamp.defaultMaxValue(bits) & upMask; } lowerBound = IntegerConvertNode.convert(lowerBound, bits, false); upperBound = IntegerConvertNode.convert(upperBound, bits, false); - return new IntegerStamp(bits, false, lowerBound, upperBound, downMask, upMask); + return new IntegerStamp(bits, lowerBound, upperBound, downMask, upMask); } public static Stamp and(Stamp stamp1, Stamp stamp2) { @@ -282,7 +265,7 @@ lowerBound = value.lowerBound() >>> shiftCount; upperBound = value.upperBound() >>> shiftCount; } - return new IntegerStamp(bits, value.isUnsigned(), lowerBound, upperBound, downMask, upMask); + return new IntegerStamp(bits, lowerBound, upperBound, downMask, upMask); } } long mask = IntegerStamp.upMaskFor(bits, value.lowerBound(), value.upperBound()); @@ -329,17 +312,7 @@ long downMask = SignExtendNode.signExtend(inputStamp.downMask(), inputBits) & defaultMask; long upMask = SignExtendNode.signExtend(inputStamp.upMask(), inputBits) & defaultMask; - long lowerBound; - long upperBound; - if (inputStamp.isUnsigned()) { - lowerBound = SignExtendNode.signExtend(inputStamp.lowerBound(), inputBits) & defaultMask; - upperBound = SignExtendNode.signExtend(inputStamp.upperBound(), inputBits) & defaultMask; - } else { - lowerBound = inputStamp.lowerBound(); - upperBound = inputStamp.upperBound(); - } - - return new IntegerStamp(resultBits, inputStamp.isUnsigned(), lowerBound, upperBound, downMask, upMask); + return new IntegerStamp(resultBits, inputStamp.lowerBound(), inputStamp.upperBound(), downMask, upMask); } else { return input.illegal(); } @@ -363,7 +336,7 @@ long lowerBound = ZeroExtendNode.zeroExtend(inputStamp.lowerBound(), inputBits); long upperBound = ZeroExtendNode.zeroExtend(inputStamp.upperBound(), inputBits); - return new IntegerStamp(resultBits, inputStamp.isUnsigned(), lowerBound, upperBound, downMask, upMask); + return new IntegerStamp(resultBits, lowerBound, upperBound, downMask, upMask); } else { return input.illegal(); } @@ -372,7 +345,6 @@ public static Stamp narrowingConversion(Stamp input, int resultBits) { if (input instanceof IntegerStamp) { IntegerStamp inputStamp = (IntegerStamp) input; - boolean unsigned = inputStamp.isUnsigned(); int inputBits = inputStamp.getBits(); assert resultBits <= inputBits; if (resultBits == inputBits) { @@ -380,28 +352,24 @@ } final long upperBound; - if (inputStamp.lowerBound() < IntegerStamp.defaultMinValue(resultBits, unsigned)) { - upperBound = IntegerStamp.defaultMaxValue(resultBits, unsigned); + if (inputStamp.lowerBound() < IntegerStamp.defaultMinValue(resultBits)) { + upperBound = IntegerStamp.defaultMaxValue(resultBits); } else { - upperBound = saturate(inputStamp.upperBound(), resultBits, unsigned); + upperBound = saturate(inputStamp.upperBound(), resultBits); } final long lowerBound; - if (inputStamp.upperBound() > IntegerStamp.defaultMaxValue(resultBits, unsigned)) { - lowerBound = IntegerStamp.defaultMinValue(resultBits, unsigned); + if (inputStamp.upperBound() > IntegerStamp.defaultMaxValue(resultBits)) { + lowerBound = IntegerStamp.defaultMinValue(resultBits); } else { - lowerBound = saturate(inputStamp.lowerBound(), resultBits, unsigned); + lowerBound = saturate(inputStamp.lowerBound(), resultBits); } long defaultMask = IntegerStamp.defaultMask(resultBits); long newDownMask = inputStamp.downMask() & defaultMask; long newUpMask = inputStamp.upMask() & defaultMask; - long newLowerBound = (lowerBound | newDownMask) & newUpMask; - long newUpperBound = (upperBound | newDownMask) & newUpMask; - if (!unsigned) { - newLowerBound = SignExtendNode.signExtend(newLowerBound, resultBits); - newUpperBound = SignExtendNode.signExtend(newUpperBound, resultBits); - } - return new IntegerStamp(resultBits, unsigned, newLowerBound, newUpperBound, newDownMask, newUpMask); + long newLowerBound = SignExtendNode.signExtend((lowerBound | newDownMask) & newUpMask, resultBits); + long newUpperBound = SignExtendNode.signExtend((upperBound | newDownMask) & newUpMask, resultBits); + return new IntegerStamp(resultBits, newLowerBound, newUpperBound, newDownMask, newUpMask); } else { return input.illegal(); } @@ -426,7 +394,7 @@ long intMask = IntegerStamp.defaultMask(32); long newUpMask = signExtend(fromStamp.upMask() & defaultMask, toKind) & intMask; long newDownMask = signExtend(fromStamp.downMask() & defaultMask, toKind) & intMask; - return new IntegerStamp(toKind.getStackKind().getBitCount(), false, (int) ((lowerBound | newDownMask) & newUpMask), (int) ((upperBound | newDownMask) & newUpMask), newDownMask, newUpMask); + return new IntegerStamp(toKind.getStackKind().getBitCount(), (int) ((lowerBound | newDownMask) & newUpMask), (int) ((upperBound | newDownMask) & newUpMask), newDownMask, newUpMask); } private static long signExtend(long value, Kind valueKind) { @@ -437,13 +405,13 @@ } } - private static long saturate(long v, int bits, boolean unsigned) { + private static long saturate(long v, int bits) { if (bits < 64) { - long max = IntegerStamp.defaultMaxValue(bits, unsigned); + long max = IntegerStamp.defaultMaxValue(bits); if (v > max) { return max; } - long min = IntegerStamp.defaultMinValue(bits, unsigned); + long min = IntegerStamp.defaultMinValue(bits); if (v < min) { return min; } @@ -465,7 +433,7 @@ /** * Compute the stamp resulting from the unsigned comparison being true. - * + * * @return null if it's can't be true or it nothing useful can be encoded. */ public static Stamp unsignedCompare(Stamp stamp, Stamp stamp2) { @@ -488,14 +456,14 @@ } // If the test succeeds then this proves that n is at greater than c so the bounds // are [c+1..-n.upperBound)]. - return StampFactory.forInteger(x.getBits(), false, x.lowerBound() + 1, y.upperBound()); + return StampFactory.forInteger(x.getBits(), x.lowerBound() + 1, y.upperBound()); } return null; } // n <| c, where c is a strictly positive constant if (y.lowerBound() == y.upperBound() && y.isStrictlyPositive()) { // The test proves that n is positive and less than c, [0..c-1] - return StampFactory.forInteger(y.getBits(), false, 0, y.lowerBound() - 1); + return StampFactory.forInteger(y.getBits(), 0, y.lowerBound() - 1); } return null; }