JezK
Edit File: constant-folding.js
// Copyright 2009 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following // disclaimer in the documentation and/or other materials provided // with the distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived // from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Test operations that involve one or more constants. // The code generator now handles compile-time constants specially. // Test the code generated when operands are known at compile time // Test count operations involving constants function test_count() { var x = "foo"; var y = "3"; x += x++; // ++ and -- apply ToNumber to their operand, even for postfix. assertEquals(x, "fooNaN", "fooNaN test"); x = "luft"; x += ++x; assertEquals(x, "luftNaN", "luftNaN test"); assertTrue(y++ === 3, "y++ === 3, where y = \"3\""); y = 3; assertEquals(y++, 3, "y++ == 3, where y = 3"); y = "7.1"; assertTrue(y++ === 7.1, "y++ === 7.1, where y = \"7.1\""); var z = y = x = "9"; assertEquals( z++ + (++y) + x++, 28, "z++ + (++y) + x++ == 28"); z = y = x = 13; assertEquals( z++ + (++y) + x++, 40, "z++ + (++y) + x++ == 40"); z = y = x = -5.5; assertEquals( z++ + (++y) + x++, -15.5, "z++ + (++y) + x++ == -15.5"); assertEquals(y, -4.5); z = y; z++; assertEquals(y, -4.5); z = y; y++; assertEquals(z, -4.5); y = 20; z = y; z++; assertEquals(y, 20); z = y; y++; assertEquals(z, 20); const w = 30; assertEquals(w++, 30); assertEquals(++w, 31); assertEquals(++w, 31); } test_count(); // Test comparison operations that involve one or two constant smis. function test() { var i = 5; var j = 3; assertTrue( j < i ); i = 5; j = 3; assertTrue( j <= i ); i = 5; j = 3; assertTrue( i > j ); i = 5; j = 3; assertTrue( i >= j ); i = 5; j = 3; assertTrue( i != j ); i = 5; j = 3; assertTrue( i == i ); i = 5; j = 3; assertFalse( i < j ); i = 5; j = 3; assertFalse( i <= j ); i = 5; j = 3; assertFalse( j > i ); i = 5; j = 3; assertFalse(j >= i ); i = 5; j = 3; assertFalse( j == i); i = 5; j = 3; assertFalse( i != i); i = 10 * 10; while ( i < 107 ) { ++i; } j = 21; assertTrue( j < i ); j = 21; assertTrue( j <= i ); j = 21; assertTrue( i > j ); j = 21; assertTrue( i >= j ); j = 21; assertTrue( i != j ); j = 21; assertTrue( i == i ); j = 21; assertFalse( i < j ); j = 21; assertFalse( i <= j ); j = 21; assertFalse( j > i ); j = 21; assertFalse(j >= i ); j = 21; assertFalse( j == i); j = 21; assertFalse( i != i); j = 21; assertTrue( j == j ); j = 21; assertFalse( j != j ); assertTrue( 100 > 99 ); assertTrue( 101 >= 90 ); assertTrue( 11111 > -234 ); assertTrue( -888 <= -20 ); while ( 234 > 456 ) { i = i + 1; } switch(3) { case 5: assertUnreachable(); break; case 3: j = 13; default: i = 2; case 7: j = 17; break; case 9: j = 19; assertUnreachable(); break; } assertEquals(17, j, "switch with constant value"); } function TrueToString() { return true.toString(); } function FalseToString() { return false.toString(); } function BoolTest() { assertEquals("true", TrueToString()); assertEquals("true", TrueToString()); assertEquals("true", TrueToString()); assertEquals("false", FalseToString()); assertEquals("false", FalseToString()); assertEquals("false", FalseToString()); Boolean.prototype.toString = function() { return "foo"; } assertEquals("foo", TrueToString()); assertEquals("foo", FalseToString()); } // Some tests of shifts that get into the corners in terms of coverage. // We generate different code for the case where the operand is a constant. function ShiftTest() { var x = 123; assertEquals(x, x >> 0); assertEquals(x, x << 0); assertEquals(x, x >>> 0); assertEquals(61, x >> 1); assertEquals(246, x << 1); assertEquals(61, x >>> 1); x = -123; assertEquals(x, x >> 0); assertEquals(x, x << 0); assertEquals(0x10000 * 0x10000 + x, x >>> 0); assertEquals(-62, x >> 1); assertEquals(-246, x << 1); assertEquals(0x10000 * 0x8000 - 62, x >>> 1); // Answer is non-Smi so the subtraction is not folded in the code // generator. assertEquals(-0x40000001, -0x3fffffff - 2); x = 123; assertEquals(0, x & 0); // Answer is non-smi and lhs of << is a temporary heap number that we can // overwrite. x = 123.0001; assertEquals(1073741824, (x * x) << 30); x = 123; // Answer is non-smi and lhs of << is a temporary heap number that we think // we can overwrite (but we can't because it's a Smi). assertEquals(1073741824, (x * x) << 30); } test(); BoolTest(); ShiftTest();