Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 1 | // Copyright 2016 the V8 project authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | // Flags: --expose-wasm |
| 6 | |
| 7 | function RunThreeWayTest(asmfunc, expect) { |
| 8 | var asm_source = asmfunc.toString(); |
| 9 | var nonasm_source = asm_source.replace(new RegExp("use asm"), ""); |
| 10 | var stdlib = {Math: Math}; |
| 11 | |
| 12 | var js_module = eval("(" + nonasm_source + ")")(stdlib); |
| 13 | print("Testing " + asmfunc.name + " (js)..."); |
| 14 | expect(js_module); |
| 15 | |
| 16 | print("Testing " + asmfunc.name + " (asm.js)..."); |
| 17 | var asm_module = asmfunc(stdlib); |
| 18 | expect(asm_module); |
| 19 | |
| 20 | print("Testing " + asmfunc.name + " (wasm)..."); |
| 21 | var wasm_module = Wasm.instantiateModuleFromAsm(asm_source, stdlib); |
| 22 | expect(wasm_module); |
| 23 | } |
| 24 | |
| 25 | function PositiveIntLiterals() { |
| 26 | "use asm"; |
| 27 | function f0() { return 0; } |
| 28 | function f1() { return 1; } |
| 29 | function f4() { return 4; } |
| 30 | function f64() { return 64; } |
| 31 | function f127() { return 127; } |
| 32 | function f128() { return 128; } |
| 33 | function f256() { return 256; } |
| 34 | function f1000() { return 1000; } |
| 35 | function f2000000() { return 2000000; } |
| 36 | function fmax() { return 2147483647; } |
| 37 | return {f0: f0, f1: f1, f4: f4, f64: f64, f127: f127, f128: f128, |
| 38 | f256: f256, f1000: f1000, f2000000, fmax: fmax}; |
| 39 | } |
| 40 | |
| 41 | RunThreeWayTest(PositiveIntLiterals, function(module) { |
| 42 | assertEquals(0, module.f0()); |
| 43 | assertEquals(1, module.f1()); |
| 44 | assertEquals(4, module.f4()); |
| 45 | assertEquals(64, module.f64()); |
| 46 | assertEquals(128, module.f128()); |
| 47 | assertEquals(256, module.f256()); |
| 48 | assertEquals(1000, module.f1000()); |
| 49 | assertEquals(2000000, module.f2000000()); |
| 50 | assertEquals(2147483647, module.fmax()); |
| 51 | }); |
| 52 | |
| 53 | function NegativeIntLiterals() { |
| 54 | "use asm"; |
| 55 | function f1() { return -1; } |
| 56 | function f4() { return -4; } |
| 57 | function f64() { return -64; } |
| 58 | function f127() { return -127; } |
| 59 | function f128() { return -128; } |
| 60 | function f256() { return -256; } |
| 61 | function f1000() { return -1000; } |
| 62 | function f2000000() { return -2000000; } |
| 63 | function fmin() { return -2147483648; } |
| 64 | return {f1: f1, f4: f4, f64: f64, f127: f127, f128: f128, |
| 65 | f256: f256, f1000: f1000, f2000000, fmin: fmin}; |
| 66 | } |
| 67 | |
| 68 | RunThreeWayTest(NegativeIntLiterals, function (module) { |
| 69 | assertEquals(-1, module.f1()); |
| 70 | assertEquals(-4, module.f4()); |
| 71 | assertEquals(-64, module.f64()); |
| 72 | assertEquals(-127, module.f127()); |
| 73 | assertEquals(-128, module.f128()); |
| 74 | assertEquals(-256, module.f256()); |
| 75 | assertEquals(-1000, module.f1000()); |
| 76 | assertEquals(-2000000, module.f2000000()); |
| 77 | assertEquals(-2147483648, module.fmin()); |
| 78 | }); |
| 79 | |
| 80 | function PositiveUnsignedLiterals() { |
| 81 | "use asm"; |
| 82 | function f0() { return 0 >>> 0; } |
| 83 | function f1() { return 1 >>> 0; } |
| 84 | function f4() { return 4 >>> 0; } |
| 85 | function f64() { return 64 >>> 0; } |
| 86 | function f127() { return 127 >>> 0; } |
| 87 | function f128() { return 128 >>> 0; } |
| 88 | function f256() { return 256 >>> 0; } |
| 89 | function f1000() { return 1000 >>> 0; } |
| 90 | function f2000000() { return 2000000 >>> 0; } |
| 91 | function fmax() { return 2147483647 >>> 0; } |
| 92 | return {f0: f0, f1: f1, f4: f4, f64: f64, f127: f127, f128: f128, |
| 93 | f256: f256, f1000: f1000, f2000000, fmax: fmax}; |
| 94 | } |
| 95 | |
| 96 | RunThreeWayTest(PositiveUnsignedLiterals, function (module) { |
| 97 | assertEquals(0, module.f0()); |
| 98 | assertEquals(1, module.f1()); |
| 99 | assertEquals(4, module.f4()); |
| 100 | assertEquals(64, module.f64()); |
| 101 | assertEquals(128, module.f128()); |
| 102 | assertEquals(256, module.f256()); |
| 103 | assertEquals(1000, module.f1000()); |
| 104 | assertEquals(2000000, module.f2000000()); |
| 105 | assertEquals(2147483647, module.fmax()); |
| 106 | }); |
| 107 | |
| 108 | function LargeUnsignedLiterals() { |
| 109 | "use asm"; |
| 110 | function a() { |
| 111 | var x = 2147483648; |
| 112 | return +(x >>> 0); |
| 113 | } |
| 114 | function b() { |
| 115 | var x = 2147483649; |
| 116 | return +(x >>> 0); |
| 117 | } |
| 118 | function c() { |
| 119 | var x = 0x80000000; |
| 120 | return +(x >>> 0); |
| 121 | } |
| 122 | function d() { |
| 123 | var x = 0x80000001; |
| 124 | return +(x >>> 0); |
| 125 | } |
| 126 | function e() { |
| 127 | var x = 0xffffffff; |
| 128 | return +(x >>> 0); |
| 129 | } |
| 130 | return {a: a, b: b, c: c, d: d, e: e}; |
| 131 | } |
| 132 | |
| 133 | RunThreeWayTest(LargeUnsignedLiterals, function(module) { |
| 134 | assertEquals(2147483648, module.a()); |
| 135 | assertEquals(2147483649, module.b()); |
| 136 | assertEquals(0x80000000, module.c()); |
| 137 | assertEquals(0x80000001, module.d()); |
| 138 | assertEquals(0xffffffff, module.e()); |
| 139 | }); |
| 140 | |
| 141 | function ManyI32() { |
| 142 | "use asm"; |
| 143 | function main() { |
| 144 | var a = 1 + -2 + 3 + -4 | 0; |
| 145 | var b = 11 + -22 + 33 + -44 | 0; |
| 146 | var c = 111 + -222 + 333 + -444 | 0; |
| 147 | var d = 1111 + -2222 + 3333 + -4444 | 0; |
| 148 | var e = 11111 + -22222 + 33333 + -44444 | 0; |
| 149 | var f = 155555 + -266666 + 377777 + -488888 | 0; |
| 150 | var g = 1155555 + -2266666 + 3377777 + -4488888 | 0; |
| 151 | var h = 11155555 + -22266666 + 33377777 + -44488888 | 0; |
| 152 | var i = 111155555 + -222266666 + 333377777 + -444488888 | 0; |
| 153 | var j = ( |
| 154 | 0x1 + 0x2 + 0x4 + 0x8 + |
| 155 | 0x10 + 0x20 + 0x40 + 0x80 + |
| 156 | 0x10F + 0x200 + 0x400 + 0x800 + |
| 157 | 0x10E0 + 0x20F0 + 0x4000 + 0x8000 + |
| 158 | 0x10D00 + 0x20E00 + 0x400F0 + 0x80002 + |
| 159 | 0x10C000 + 0x20D000 + 0x400E00 + 0x800030 + |
| 160 | 0x10B0000 + 0x20C0000 + 0x400D000 + 0x8000400 + |
| 161 | 0x10A00000 + 0x20B00000 + 0x400C0000 + 0x80005000 |
| 162 | ) | 0; |
| 163 | return (a + b + c + d + e + f + g + h + i + j) | 0; |
| 164 | } |
| 165 | return {main: main}; |
| 166 | } |
| 167 | |
| 168 | RunThreeWayTest(ManyI32, function(module) { |
| 169 | assertEquals(-222411306, module.main()); |
| 170 | }); |
| 171 | |
| 172 | |
| 173 | function ManyF64a() { |
| 174 | "use asm"; |
| 175 | function main() { |
| 176 | var a = +( 0.1 + -0.2 + 0.3 + -0.4); |
| 177 | var b = +( 1.1 + -2.2 + 0.33 + -4.4); |
| 178 | var c = +( 11.1 + -22.2 + 3.33 + -4.44); |
| 179 | var d = +( 111.1 + -222.2 + 33.33 + -4.444); |
| 180 | var e = +( 1111.1 + -2222.2 + 333.33 + -4.4444); |
| 181 | var f = +( 15555.5 + -26666.6 + 3777.77 + -4.88888); |
| 182 | var g = +( 115555.5 + -226666.6 + 33777.77 + -4.488888); |
| 183 | var h = +( 1115555.5 + -2226666.6 + 333777.77 + -4.4488888); |
| 184 | var i = +(11115555.5 + -22226666.6 + 3333777.77 + -4.44488888); |
| 185 | return +(a + b + c + d + e + f + g + h + i); |
| 186 | } |
| 187 | return {main: main}; |
| 188 | } |
| 189 | |
| 190 | RunThreeWayTest(ManyF64a, function(module) { |
| 191 | assertEquals(-8640233.599945681, module.main()); |
| 192 | }); |
| 193 | |
| 194 | function ManyF64b() { |
| 195 | "use asm"; |
| 196 | function k1() { return +(1.0e-25 + 3.0e-25 + 5.0e-25 + 6.0e-25 + 9.0e-25); } |
| 197 | function k2() { return +(1.0e-20 + 3.0e-20 + 5.0e-20 + 6.0e-20 + 9.0e-20); } |
| 198 | function k3() { return +(1.0e-15 + 3.0e-15 + 5.0e-15 + 6.0e-15 + 9.0e-15); } |
| 199 | function k4() { return +(1.0e-10 + 3.0e-10 + 5.0e-10 + 6.0e-10 + 9.0e-10); } |
| 200 | function k5() { return +(1.0e-5 + 3.0e-5 + 5.0e-5 + 6.0e-5 + 9.0e-5); } |
| 201 | function k6() { return +(1.1e+0 + 3.1e+0 + 5.1e+0 + 6.1e+0 + 9.1e+0); } |
| 202 | |
| 203 | return {k1: k1, k2: k2, k3: k3, k4: k4, k5: k5, k6: k6}; |
| 204 | } |
| 205 | |
| 206 | RunThreeWayTest(ManyF64b, function(module) { |
| 207 | assertEquals(2.4e-24, module.k1()); |
| 208 | assertEquals(2.4e-19, module.k2()); |
| 209 | assertEquals(2.4e-14, module.k3()); |
| 210 | assertEquals(2.4e-9, module.k4()); |
| 211 | assertEquals(0.00024000000000000003, module.k5()); |
| 212 | assertEquals(24.5, module.k6()); |
| 213 | }); |
| 214 | |
| 215 | |
| 216 | function ManyF64c() { |
| 217 | "use asm"; |
| 218 | function k1() { return +(1.0e+25 + 3.0e+25 + 5.0e+25 + 6.0e+25 + 9.0e+25); } |
| 219 | function k2() { return +(1.0e+20 + 3.0e+20 + 5.0e+20 + 6.0e+20 + 9.0e+20); } |
| 220 | function k3() { return +(1.0e+15 + 3.0e+15 + 5.0e+15 + 6.0e+15 + 9.0e+15); } |
| 221 | function k4() { return +(1.0e+10 + 3.0e+10 + 5.0e+10 + 6.0e+10 + 9.0e+10); } |
| 222 | function k5() { return +(1.0e+5 + 3.0e+5 + 5.0e+5 + 6.0e+5 + 9.0e+5); } |
| 223 | function k6() { return +(1.4e+0 + 3.4e+0 + 5.4e+0 + 6.4e+0 + 9.4e+0); } |
| 224 | |
| 225 | return {k1: k1, k2: k2, k3: k3, k4: k4, k5: k5, k6: k6}; |
| 226 | } |
| 227 | |
| 228 | RunThreeWayTest(ManyF64c, function(module) { |
| 229 | assertEquals(2.4000000000000004e+26, module.k1()); |
| 230 | assertEquals(2.4e+21, module.k2()); |
| 231 | assertEquals(2.4e+16, module.k3()); |
| 232 | assertEquals(2.4e+11, module.k4()); |
| 233 | assertEquals(2.4e+6, module.k5()); |
| 234 | assertEquals(26, module.k6()); |
| 235 | }); |
| 236 | |
| 237 | function ManyF32a(stdlib) { |
| 238 | "use asm"; |
| 239 | var F = stdlib.Math.fround; |
| 240 | |
| 241 | function k1() { return F(F(1.0e-25) + F(5.0e-25) + F(6.0e-25) + F(9.0e-25)); } |
| 242 | function k2() { return F(F(1.0e-20) + F(5.0e-20) + F(6.0e-20) + F(9.0e-20)); } |
| 243 | function k3() { return F(F(1.0e-15) + F(5.0e-15) + F(6.0e-15) + F(9.0e-15)); } |
| 244 | function k4() { return F(F(1.0e-10) + F(5.0e-10) + F(6.0e-10) + F(9.0e-10)); } |
| 245 | function k5() { return F(F(1.0e-5) + F(5.0e-5) + F(6.0e-5) + F(9.0e-5)); } |
| 246 | function k6() { return F(F(1.1e+0) + F(5.1e+0) + F(6.1e+0) + F(9.1e+0)); } |
| 247 | |
| 248 | return {k1: k1, k2: k2, k3: k3, k4: k4, k5: k5, k6: k6}; |
| 249 | } |
| 250 | |
| 251 | if (false) { |
| 252 | // TODO(bradnelson): fails validation of F32 literals somehow. |
| 253 | RunThreeWayTest(ManyF32a, function(module) { |
| 254 | assertEquals(2.0999999917333043e-24, module.k1()); |
| 255 | assertEquals(2.099999868734112e-19, module.k2()); |
| 256 | assertEquals(2.099999997029825e-14, module.k3()); |
| 257 | assertEquals(2.099999951710174e-9, module.k4()); |
| 258 | assertEquals(0.0002099999983329326, module.k5()); |
| 259 | assertEquals(21.399999618530273, module.k6()); |
| 260 | }); |
| 261 | } |