OLD | NEW |
1 // Copyright 2016 the V8 project authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // Flags: --validate-asm --allow-natives-syntax | 5 // Flags: --validate-asm --allow-natives-syntax |
6 | 6 |
7 function IsAlwaysOpt(module) { | 7 function assertValidAsm(func) { |
8 return %GetOptimizationStatus(module) === 3; | 8 assertTrue(%IsAsmWasmCode(func)); |
9 } | 9 } |
10 | 10 |
11 (function TestModuleArgs() { | 11 (function TestModuleArgs() { |
12 function Module1(stdlib) { | 12 function Module1(stdlib) { |
13 "use asm"; | 13 "use asm"; |
14 function foo() { } | 14 function foo() { } |
15 return { foo: foo }; | 15 return { foo: foo }; |
16 } | 16 } |
17 function Module2(stdlib, ffi) { | 17 function Module2(stdlib, ffi) { |
18 "use asm"; | 18 "use asm"; |
19 function foo() { } | 19 function foo() { } |
20 return { foo: foo }; | 20 return { foo: foo }; |
21 } | 21 } |
22 function Module3(stdlib, ffi, heap) { | 22 function Module3(stdlib, ffi, heap) { |
23 "use asm"; | 23 "use asm"; |
24 function foo() { } | 24 function foo() { } |
25 return { foo: foo }; | 25 return { foo: foo }; |
26 } | 26 } |
27 var modules = [Module1, Module2, Module3]; | 27 var modules = [Module1, Module2, Module3]; |
28 var heap = new ArrayBuffer(1024 * 1024); | 28 var heap = new ArrayBuffer(1024 * 1024); |
29 for (var i = 0; i < modules.length; ++i) { | 29 for (var i = 0; i < modules.length; ++i) { |
30 print('Module' + (i + 1)); | 30 print('Module' + (i + 1)); |
31 var module = modules[i]; | 31 var module = modules[i]; |
32 // TODO(bradnelson): Support modules without the stdlib. | 32 var m = module(); |
| 33 assertValidAsm(module); |
33 var m = module({}); | 34 var m = module({}); |
34 assertTrue(%IsAsmWasmCode(module) || IsAlwaysOpt(module)); | 35 assertValidAsm(module); |
35 var m = module({}, {}); | 36 var m = module({}, {}); |
36 assertTrue(%IsAsmWasmCode(module) || IsAlwaysOpt(module)); | 37 assertValidAsm(module); |
37 var m = module({}, {}, heap); | 38 var m = module({}, {}, heap); |
38 assertTrue(%IsAsmWasmCode(module) || IsAlwaysOpt(module)); | 39 assertValidAsm(module); |
39 var m = module({}, {}, heap, {}); | 40 var m = module({}, {}, heap, {}); |
40 assertTrue(%IsAsmWasmCode(module) || IsAlwaysOpt(module)); | 41 assertValidAsm(module); |
41 } | 42 } |
42 })(); | 43 })(); |
43 | 44 |
44 (function TestBadModule() { | 45 (function TestBadModule() { |
45 function Module(stdlib, ffi, heap) { | 46 function Module(stdlib, ffi, heap) { |
46 "use asm"; | 47 "use asm"; |
47 function foo() { var y = 3; var x = 1 + y; return 123; } | 48 function foo() { var y = 3; var x = 1 + y; return 123; } |
48 return { foo: foo }; | 49 return { foo: foo }; |
49 } | 50 } |
50 var m = Module({}); | 51 var m = Module({}); |
51 assertFalse(%IsAsmWasmCode(Module)); | 52 assertTrue(%IsNotAsmWasmCode(Module)); |
52 assertEquals(123, m.foo()); | 53 assertEquals(123, m.foo()); |
53 })(); | 54 })(); |
54 | 55 |
55 (function TestBadArgTypes() { | 56 (function TestBadArgTypes() { |
56 function Module(a, b, c) { | 57 function Module(a, b, c) { |
57 "use asm"; | 58 "use asm"; |
| 59 var NaN = a.NaN; |
58 return {}; | 60 return {}; |
59 } | 61 } |
60 var m = Module(1, 2, 3); | 62 var m = Module(1, 2, 3); |
61 assertFalse(%IsAsmWasmCode(Module)); | 63 assertTrue(%IsNotAsmWasmCode(Module)); |
62 assertEquals({}, m); | 64 assertEquals({}, m); |
63 })(); | 65 })(); |
64 | 66 |
65 (function TestBadArgTypesMismatch() { | 67 (function TestBadArgTypesMismatch() { |
66 function Module(a, b, c) { | 68 function Module(a, b, c) { |
67 "use asm"; | 69 "use asm"; |
| 70 var NaN = a.NaN; |
68 return {}; | 71 return {}; |
69 } | 72 } |
70 var m = Module(1, 2); | 73 var m = Module(1, 2); |
71 assertFalse(%IsAsmWasmCode(Module)); | 74 assertTrue(%IsNotAsmWasmCode(Module)); |
72 assertEquals({}, m); | 75 assertEquals({}, m); |
73 })(); | 76 })(); |
74 | 77 |
75 (function TestModuleNoStdlib() { | 78 (function TestModuleNoStdlib() { |
76 // TODO(bradnelson): | |
77 // Support modules like this if they don't use the whole stdlib. | |
78 function Module() { | 79 function Module() { |
79 "use asm"; | 80 "use asm"; |
80 function foo() { return 123; } | 81 function foo() { return 123; } |
81 return { foo: foo }; | 82 return { foo: foo }; |
82 } | 83 } |
83 var m = Module({}); | 84 var m = Module({}); |
84 assertFalse(%IsAsmWasmCode(Module)); | 85 assertValidAsm(Module); |
85 assertEquals(123, m.foo()); | 86 assertEquals(123, m.foo()); |
86 })(); | 87 })(); |
87 | 88 |
88 (function TestModuleWith5() { | 89 (function TestModuleWith5() { |
89 function Module(a, b, c, d, e) { | 90 function Module(a, b, c, d, e) { |
90 "use asm"; | 91 "use asm"; |
91 function foo() { return 123; } | 92 function foo() { return 123; } |
92 return { foo: foo }; | 93 return { foo: foo }; |
93 } | 94 } |
94 var heap = new ArrayBuffer(1024 * 1024); | 95 var heap = new ArrayBuffer(1024 * 1024); |
95 var m = Module({}, {}, heap); | 96 var m = Module({}, {}, heap); |
96 assertFalse(%IsAsmWasmCode(Module)); | 97 assertTrue(%IsNotAsmWasmCode(Module)); |
97 assertEquals(123, m.foo()); | 98 assertEquals(123, m.foo()); |
98 })(); | 99 })(); |
99 | 100 |
100 (function TestModuleNoStdlibCall() { | 101 (function TestModuleNoStdlibCall() { |
101 function Module(stdlib, ffi, heap) { | 102 function Module(stdlib, ffi, heap) { |
102 "use asm"; | 103 "use asm"; |
103 function foo() { return 123; } | 104 function foo() { return 123; } |
104 return { foo: foo }; | 105 return { foo: foo }; |
105 } | 106 } |
106 // TODO(bradnelson): Support instantiation like this if stdlib is unused. | |
107 var m = Module(); | 107 var m = Module(); |
108 assertFalse(%IsAsmWasmCode(Module)); | 108 assertValidAsm(Module); |
109 assertEquals(123, m.foo()); | 109 assertEquals(123, m.foo()); |
110 })(); | 110 })(); |
111 | 111 |
112 (function TestModuleNew() { | 112 (function TestModuleNew() { |
113 function Module(stdlib, ffi, heap) { | 113 function Module(stdlib, ffi, heap) { |
114 "use asm"; | 114 "use asm"; |
115 function foo() { return 123; } | 115 function foo() { return 123; } |
116 return { foo: foo }; | 116 return { foo: foo }; |
117 } | 117 } |
118 var m = new Module({}, {}); | 118 var m = new Module({}, {}); |
119 assertTrue(%IsAsmWasmCode(Module) || IsAlwaysOpt(Module)); | 119 assertValidAsm(Module); |
120 assertEquals(123, m.foo()); | 120 assertEquals(123, m.foo()); |
121 })(); | 121 })(); |
122 | 122 |
123 (function TestMultipleFailures() { | 123 (function TestMultipleFailures() { |
124 function Module(stdlib) { | 124 function Module(stdlib) { |
125 "use asm"; | 125 "use asm"; |
| 126 var NaN = stdlib.NaN; |
126 function foo() { return 123; } | 127 function foo() { return 123; } |
127 return { foo: foo }; | 128 return { foo: foo }; |
128 } | 129 } |
129 var m1 = Module(1, 2, 3); | 130 var m1 = Module(1, 2, 3); |
130 assertFalse(%IsAsmWasmCode(Module)); | 131 assertTrue(%IsNotAsmWasmCode(Module)); |
131 var m2 = Module(1, 2, 3); | 132 var m2 = Module(1, 2, 3); |
132 assertFalse(%IsAsmWasmCode(Module)); | 133 assertTrue(%IsNotAsmWasmCode(Module)); |
133 assertEquals(123, m1.foo()); | 134 assertEquals(123, m1.foo()); |
134 assertEquals(123, m2.foo()); | 135 assertEquals(123, m2.foo()); |
135 })(); | 136 })(); |
136 | 137 |
137 (function TestFailureThenSuccess() { | 138 (function TestFailureThenSuccess() { |
138 function MkModule() { | 139 function MkModule() { |
139 function Module(stdlib, ffi, heap) { | 140 function Module(stdlib, ffi, heap) { |
140 "use asm"; | 141 "use asm"; |
| 142 var NaN = stdlib.NaN; |
141 function foo() { return 123; } | 143 function foo() { return 123; } |
142 return { foo: foo }; | 144 return { foo: foo }; |
143 } | 145 } |
144 return Module; | 146 return Module; |
145 } | 147 } |
146 var Module1 = MkModule(); | 148 var Module1 = MkModule(); |
147 var Module2 = MkModule(); | 149 var Module2 = MkModule(); |
148 var heap = new ArrayBuffer(1024 * 1024); | 150 var heap = new ArrayBuffer(1024 * 1024); |
149 var m1 = Module1(1, 2, 3); | 151 var m1 = Module1(1, 2, 3); |
150 assertFalse(%IsAsmWasmCode(Module1)); | 152 assertTrue(%IsNotAsmWasmCode(Module1)); |
151 var m2 = Module2({}, {}, heap); | 153 var m2 = Module2({}, {}, heap); |
152 assertFalse(%IsAsmWasmCode(Module2)); | 154 assertTrue(%IsNotAsmWasmCode(Module2)); |
153 assertEquals(123, m1.foo()); | 155 assertEquals(123, m1.foo()); |
154 assertEquals(123, m2.foo()); | 156 assertEquals(123, m2.foo()); |
155 })(); | 157 })(); |
156 | 158 |
157 (function TestSuccessThenFailure() { | 159 (function TestSuccessThenFailure() { |
158 function MkModule() { | 160 function MkModule() { |
159 function Module(stdlib, ffi, heap) { | 161 function Module(stdlib, ffi, heap) { |
160 "use asm"; | 162 "use asm"; |
| 163 var NaN = stdlib.NaN; |
161 function foo() { return 123; } | 164 function foo() { return 123; } |
162 return { foo: foo }; | 165 return { foo: foo }; |
163 } | 166 } |
164 return Module; | 167 return Module; |
165 } | 168 } |
166 var Module1 = MkModule(); | 169 var Module1 = MkModule(); |
167 var Module2 = MkModule(); | 170 var Module2 = MkModule(); |
168 var heap = new ArrayBuffer(1024 * 1024); | 171 var heap = new ArrayBuffer(1024 * 1024); |
169 var m1 = Module1({}, {}, heap); | 172 var m1 = Module1({NaN: NaN}, {}, heap); |
170 assertTrue(%IsAsmWasmCode(Module1) || IsAlwaysOpt(Module1)); | 173 assertValidAsm(Module1); |
171 var m2 = Module2(1, 2, 3); | 174 var m2 = Module2(1, 2, 3); |
172 assertFalse(%IsAsmWasmCode(Module2)); | 175 assertTrue(%IsNotAsmWasmCode(Module2)); |
173 assertEquals(123, m1.foo()); | 176 assertEquals(123, m1.foo()); |
174 assertEquals(123, m2.foo()); | 177 assertEquals(123, m2.foo()); |
175 })(); | 178 })(); |
176 | 179 |
177 (function TestSuccessThenFailureThenRetry() { | 180 (function TestSuccessThenFailureThenRetry() { |
178 function MkModule() { | 181 function MkModule() { |
179 function Module(stdlib, ffi, heap) { | 182 function Module(stdlib, ffi, heap) { |
180 "use asm"; | 183 "use asm"; |
| 184 var NaN = stdlib.NaN; |
181 function foo() { return 123; } | 185 function foo() { return 123; } |
182 return { foo: foo }; | 186 return { foo: foo }; |
183 } | 187 } |
184 return Module; | 188 return Module; |
185 } | 189 } |
186 var Module1 = MkModule(); | 190 var Module1 = MkModule(); |
187 var Module2 = MkModule(); | 191 var Module2 = MkModule(); |
188 var heap = new ArrayBuffer(1024 * 1024); | 192 var heap = new ArrayBuffer(1024 * 1024); |
189 var m1a = Module1({}, {}, heap); | 193 var m1a = Module1({NaN: NaN}, {}, heap); |
190 assertTrue(%IsAsmWasmCode(Module1) || IsAlwaysOpt(Module1)); | 194 assertValidAsm(Module1); |
191 var m2 = Module2(1, 2, 3); | 195 var m2 = Module2(1, 2, 3); |
192 assertFalse(%IsAsmWasmCode(Module2)); | 196 assertTrue(%IsNotAsmWasmCode(Module2)); |
193 var m1b = Module1({}, {}, heap); | 197 var m1b = Module1({NaN: NaN}, {}, heap); |
194 assertFalse(%IsAsmWasmCode(Module1)); | 198 assertTrue(%IsNotAsmWasmCode(Module1)); |
195 assertEquals(123, m1a.foo()); | 199 assertEquals(123, m1a.foo()); |
196 assertEquals(123, m1b.foo()); | 200 assertEquals(123, m1b.foo()); |
197 assertEquals(123, m2.foo()); | 201 assertEquals(123, m2.foo()); |
198 })(); | 202 })(); |
199 | 203 |
200 (function TestBoundFunction() { | 204 (function TestBoundFunction() { |
201 function Module(stdlib, ffi, heap) { | 205 function Module(stdlib, ffi, heap) { |
202 "use asm"; | 206 "use asm"; |
203 function foo() { return 123; } | 207 function foo() { return 123; } |
204 return { foo: foo }; | 208 return { foo: foo }; |
205 } | 209 } |
206 var heap = new ArrayBuffer(1024 * 1024); | 210 var heap = new ArrayBuffer(1024 * 1024); |
207 var ModuleBound = Module.bind(this, {}, {}, heap); | 211 var ModuleBound = Module.bind(this, {}, {}, heap); |
208 var m = ModuleBound(); | 212 var m = ModuleBound(); |
209 assertTrue(%IsAsmWasmCode(Module) || IsAlwaysOpt(Module)); | 213 assertValidAsm(Module); |
210 assertEquals(123, m.foo()); | 214 assertEquals(123, m.foo()); |
211 })(); | 215 })(); |
OLD | NEW |