From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 21:33:14 +0200
Subject: Adding upstream version 115.7.0esr.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 js/src/jit-test/tests/ion/pow-base-power-of-two.js | 75 ++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 js/src/jit-test/tests/ion/pow-base-power-of-two.js

(limited to 'js/src/jit-test/tests/ion/pow-base-power-of-two.js')

diff --git a/js/src/jit-test/tests/ion/pow-base-power-of-two.js b/js/src/jit-test/tests/ion/pow-base-power-of-two.js
new file mode 100644
index 0000000000..7e3baf82ef
--- /dev/null
+++ b/js/src/jit-test/tests/ion/pow-base-power-of-two.js
@@ -0,0 +1,75 @@
+// Lowering provides a specialisation when the base operand is a constant which
+// is a power of two.
+
+load(libdir + "math.js");
+
+function test(x, y, z) {
+    function pow(x, y) { return `Math.pow(${x}, ${y})` };
+    function exp(x, y) { return `((${x}) ** ${y})` };
+
+    function make(fn, x, y, z) {
+        return Function(`
+            // Load from array to prevent constant-folding.
+            // (Ion is currently not smart enough to realise that both array
+            // values are the same.)
+            var ys = [${y}, ${y}];
+            var zs = [${z}, ${z}];
+            for (var i = 0; i < 1000; ++i) {
+                assertNear(${fn(x, "ys[i & 1]")}, zs[i & 1]);
+            }
+        `);
+    }
+
+    function double(v) {
+        // NB: numberToDouble() always returns a double value.
+        return `numberToDouble(${v})`;
+    }
+
+    function addTests(fn) {
+        tests.push(make(fn, x, y, z));
+        tests.push(make(fn, x, double(y), z));
+        tests.push(make(fn, double(x), y, z));
+        tests.push(make(fn, double(x), double(y), z));
+    }
+
+    var tests = [];
+    addTests(pow);
+    addTests(exp);
+
+    for (var i = 0; i < tests.length; ++i) {
+        for (var j = 0; j < 2; ++j) {
+            tests[i]();
+        }
+    }
+}
+
+function* range(a, b, fn) {
+    for (var i = a; i <= b; ++i) {
+        yield fn(i);
+    }
+}
+
+// Only 2^i with |i| ∈ {1..8} currently triggers the optimisation, but also test
+// the next power-of-two values, 1 and 0, and negative base-of-two values.
+var values = [
+    ...range(1, 10, i => 2 ** i),
+    1,
+    0,
+    ...range(1, 4, i => -(2 ** i)),
+];
+
+for (var x of values) {
+    test(x, 0, 1);
+    test(x, 1, x);
+    test(x, 2, x * x);
+
+    // 0**(negative) is Infinity, 1**(negative) is 1.
+    if (Math.abs(x) > 1) {
+        test(x, -1076, 0);
+    }
+
+    // (negative)**(odd-negative) is -0.
+    if (x > 1) {
+        test(x, -1075, 0);
+    }
+}
-- 
cgit v1.2.3