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: --expose-wasm | 5 // Flags: --expose-wasm |
6 | 6 |
7 load("test/mjsunit/wasm/wasm-constants.js"); | 7 load("test/mjsunit/wasm/wasm-constants.js"); |
8 load("test/mjsunit/wasm/wasm-module-builder.js"); | 8 load("test/mjsunit/wasm/wasm-module-builder.js"); |
9 | 9 |
10 (function TestOne() { | 10 (function TestOne() { |
11 print("TestOne"); | 11 print("TestOne"); |
12 let memory = new WebAssembly.Memory({initial: 1}); | 12 let memory = new WebAssembly.Memory({initial: 1}); |
13 assertEquals(kPageSize, memory.buffer.byteLength); | 13 assertEquals(kPageSize, memory.buffer.byteLength); |
14 let i32 = new Int32Array(memory.buffer); | 14 let i32 = new Int32Array(memory.buffer); |
15 let builder = new WasmModuleBuilder(); | 15 let builder = new WasmModuleBuilder(); |
16 builder.addImportedMemory("mine"); | 16 builder.addImportedMemory("mod", "mine"); |
17 builder.addFunction("main", kSig_i_v) | 17 builder.addFunction("main", kSig_i_v) |
18 .addBody([ | 18 .addBody([ |
19 kExprI32Const, 0, | 19 kExprI32Const, 0, |
20 kExprI32LoadMem, 0, 0]) | 20 kExprI32LoadMem, 0, 0]) |
21 .exportAs("main"); | 21 .exportAs("main"); |
22 | 22 |
23 let main = builder.instantiate({mine: memory}).exports.main; | 23 let main = builder.instantiate({mod: {mine: memory}}).exports.main; |
24 assertEquals(0, main()); | 24 assertEquals(0, main()); |
25 | 25 |
26 i32[0] = 993377; | 26 i32[0] = 993377; |
27 | 27 |
28 assertEquals(993377, main()); | 28 assertEquals(993377, main()); |
29 })(); | 29 })(); |
30 | 30 |
31 (function TestIdentity() { | 31 (function TestIdentity() { |
32 print("TestIdentity"); | 32 print("TestIdentity"); |
33 let memory = new WebAssembly.Memory({initial: 1}); | 33 let memory = new WebAssembly.Memory({initial: 1}); |
34 let i32 = new Int32Array(memory.buffer); | 34 let i32 = new Int32Array(memory.buffer); |
35 let builder = new WasmModuleBuilder(); | 35 let builder = new WasmModuleBuilder(); |
36 builder.addImportedMemory("garg"); | 36 builder.addImportedMemory("dad", "garg"); |
37 builder.exportMemoryAs("daggle"); | 37 builder.exportMemoryAs("daggle"); |
38 | 38 |
39 let instance = builder.instantiate({garg: memory}); | 39 let instance = builder.instantiate({dad: {garg: memory}}); |
40 assertSame(memory, instance.exports.daggle); | 40 assertSame(memory, instance.exports.daggle); |
41 })(); | 41 })(); |
42 | 42 |
43 (function TestImportExport() { | 43 (function TestImportExport() { |
44 print("TestImportExport"); | 44 print("TestImportExport"); |
45 var i1; | 45 var i1; |
46 { | 46 { |
47 let builder = new WasmModuleBuilder(); | 47 let builder = new WasmModuleBuilder(); |
48 builder.addMemory(1, 1, false); | 48 builder.addMemory(1, 1, false); |
49 builder.exportMemoryAs("exported_mem"); | 49 builder.exportMemoryAs("exported_mem"); |
50 builder.addFunction("foo", kSig_i_i) | 50 builder.addFunction("foo", kSig_i_i) |
51 .addBody([ | 51 .addBody([ |
52 kExprGetLocal, 0, | 52 kExprGetLocal, 0, |
53 kExprI32LoadMem, 0, 0]) | 53 kExprI32LoadMem, 0, 0]) |
54 .exportAs("foo"); | 54 .exportAs("foo"); |
55 i1 = builder.instantiate(); | 55 i1 = builder.instantiate(); |
56 } | 56 } |
57 | 57 |
58 var i2; | 58 var i2; |
59 { | 59 { |
60 let builder = new WasmModuleBuilder(); | 60 let builder = new WasmModuleBuilder(); |
61 builder.addMemory(1, 1, false); | 61 builder.addMemory(1, 1, false); |
62 builder.addImportedMemory("imported_mem"); | 62 builder.addImportedMemory("fil", "imported_mem"); |
63 builder.addFunction("bar", kSig_i_i) | 63 builder.addFunction("bar", kSig_i_i) |
64 .addBody([ | 64 .addBody([ |
65 kExprGetLocal, 0, | 65 kExprGetLocal, 0, |
66 kExprI32LoadMem, 0, 0]) | 66 kExprI32LoadMem, 0, 0]) |
67 .exportAs("bar"); | 67 .exportAs("bar"); |
68 i2 = builder.instantiate({imported_mem: i1.exports.exported_mem}); | 68 i2 = builder.instantiate({fil: {imported_mem: i1.exports.exported_mem}}); |
69 } | 69 } |
70 | 70 |
71 let i32 = new Int32Array(i1.exports.exported_mem.buffer); | 71 let i32 = new Int32Array(i1.exports.exported_mem.buffer); |
72 | 72 |
73 for (var i = 0; i < 1e11; i = i * 3 + 5) { | 73 for (var i = 0; i < 1e11; i = i * 3 + 5) { |
74 for (var j = 0; j < 10; j++) { | 74 for (var j = 0; j < 10; j++) { |
75 var val = i + 99077 + j; | 75 var val = i + 99077 + j; |
76 i32[j] = val; | 76 i32[j] = val; |
77 assertEquals(val | 0, i1.exports.foo(j * 4)); | 77 assertEquals(val | 0, i1.exports.foo(j * 4)); |
78 assertEquals(val | 0, i2.exports.bar(j * 4)); | 78 assertEquals(val | 0, i2.exports.bar(j * 4)); |
79 } | 79 } |
80 } | 80 } |
81 })(); | 81 })(); |
82 | 82 |
83 (function ValidateBoundsCheck() { | 83 (function ValidateBoundsCheck() { |
84 print("ValidateBoundsCheck"); | 84 print("ValidateBoundsCheck"); |
85 let memory = new WebAssembly.Memory({initial: 1, maximum: 5}); | 85 let memory = new WebAssembly.Memory({initial: 1, maximum: 5}); |
86 assertEquals(kPageSize, memory.buffer.byteLength); | 86 assertEquals(kPageSize, memory.buffer.byteLength); |
87 let i32 = new Int32Array(memory.buffer); | 87 let i32 = new Int32Array(memory.buffer); |
88 let builder = new WasmModuleBuilder(); | 88 let builder = new WasmModuleBuilder(); |
89 // builder.addImportedMemory("mine"); | 89 builder.addImportedMemory("gaz", "mine"); |
90 builder.addImportedMemory("mine"); | |
91 builder.addFunction("load", kSig_i_i) | 90 builder.addFunction("load", kSig_i_i) |
92 .addBody([kExprGetLocal, 0, kExprI32LoadMem, 0, 0]) | 91 .addBody([kExprGetLocal, 0, kExprI32LoadMem, 0, 0]) |
93 .exportFunc(); | 92 .exportFunc(); |
94 builder.addFunction("store", kSig_i_ii) | 93 builder.addFunction("store", kSig_i_ii) |
95 .addBody([kExprGetLocal, 0, kExprGetLocal, 1, kExprI32StoreMem, 0, 0, | 94 .addBody([kExprGetLocal, 0, kExprGetLocal, 1, kExprI32StoreMem, 0, 0, |
96 kExprGetLocal, 1]) | 95 kExprGetLocal, 1]) |
97 .exportFunc(); | 96 .exportFunc(); |
98 var offset; | 97 var offset; |
99 let instance = builder.instantiate({mine: memory}); | 98 let instance = builder.instantiate({gaz: {mine: memory}}); |
100 function load() { return instance.exports.load(offset); } | 99 function load() { return instance.exports.load(offset); } |
101 function store(value) { return instance.exports.store(offset, value); } | 100 function store(value) { return instance.exports.store(offset, value); } |
102 | 101 |
103 for (offset = 0; offset < kPageSize - 3; offset+=4) { | 102 for (offset = 0; offset < kPageSize - 3; offset+=4) { |
104 store(offset); | 103 store(offset); |
105 } | 104 } |
106 for (offset = 0; offset < kPageSize - 3; offset+=4) { | 105 for (offset = 0; offset < kPageSize - 3; offset+=4) { |
107 assertEquals(offset, load()); | 106 assertEquals(offset, load()); |
108 } | 107 } |
109 for (offset = kPageSize - 3; offset < kPageSize + 4; offset++) { | 108 for (offset = kPageSize - 3; offset < kPageSize + 4; offset++) { |
110 assertTraps(kTrapMemOutOfBounds, load); | 109 assertTraps(kTrapMemOutOfBounds, load); |
111 } | 110 } |
112 })(); | 111 })(); |
113 | 112 |
114 (function TestGrowMemoryMaxDesc() { | 113 (function TestGrowMemoryMaxDesc() { |
115 print("MaximumDescriptor"); | 114 print("MaximumDescriptor"); |
116 let memory = new WebAssembly.Memory({initial: 1, maximum: 5}); | 115 let memory = new WebAssembly.Memory({initial: 1, maximum: 5}); |
117 assertEquals(kPageSize, memory.buffer.byteLength); | 116 assertEquals(kPageSize, memory.buffer.byteLength); |
118 let i32 = new Int32Array(memory.buffer); | 117 let i32 = new Int32Array(memory.buffer); |
119 let builder = new WasmModuleBuilder(); | 118 let builder = new WasmModuleBuilder(); |
120 builder.addImportedMemory("mine", "", 0, 20); | 119 builder.addImportedMemory("mine", "dog", 0, 20); |
121 builder.addFunction("load", kSig_i_i) | 120 builder.addFunction("load", kSig_i_i) |
122 .addBody([kExprGetLocal, 0, kExprI32LoadMem, 0, 0]) | 121 .addBody([kExprGetLocal, 0, kExprI32LoadMem, 0, 0]) |
123 .exportFunc(); | 122 .exportFunc(); |
124 builder.addFunction("store", kSig_i_ii) | 123 builder.addFunction("store", kSig_i_ii) |
125 .addBody([kExprGetLocal, 0, kExprGetLocal, 1, kExprI32StoreMem, 0, 0, | 124 .addBody([kExprGetLocal, 0, kExprGetLocal, 1, kExprI32StoreMem, 0, 0, |
126 kExprGetLocal, 1]) | 125 kExprGetLocal, 1]) |
127 .exportFunc(); | 126 .exportFunc(); |
128 var offset; | 127 var offset; |
129 let instance = builder.instantiate({mine: memory}); | 128 let instance = builder.instantiate({mine: {dog: memory}}); |
130 function load() { return instance.exports.load(offset); } | 129 function load() { return instance.exports.load(offset); } |
131 function store(value) { return instance.exports.store(offset, value); } | 130 function store(value) { return instance.exports.store(offset, value); } |
132 | 131 |
133 for (var i = 1; i < 5; i++) { | 132 for (var i = 1; i < 5; i++) { |
134 for (offset = (i - 1) * kPageSize; offset < i * kPageSize - 3; offset+=4) { | 133 for (offset = (i - 1) * kPageSize; offset < i * kPageSize - 3; offset+=4) { |
135 store(offset * 2); | 134 store(offset * 2); |
136 } | 135 } |
137 assertEquals(i, memory.grow(1)); | 136 assertEquals(i, memory.grow(1)); |
138 assertEquals((i + 1) * kPageSize, memory.buffer.byteLength); | 137 assertEquals((i + 1) * kPageSize, memory.buffer.byteLength); |
139 } | 138 } |
140 for (offset = 4 * kPageSize; offset < 5 * kPageSize - 3; offset+=4) { | 139 for (offset = 4 * kPageSize; offset < 5 * kPageSize - 3; offset+=4) { |
141 store(offset * 2); | 140 store(offset * 2); |
142 } | 141 } |
143 for (offset = 0; offset < 5 * kPageSize - 3; offset+=4) { | 142 for (offset = 0; offset < 5 * kPageSize - 3; offset+=4) { |
144 assertEquals(offset * 2, load()); | 143 assertEquals(offset * 2, load()); |
145 } | 144 } |
146 for (offset = 5 * kPageSize; offset < 5 * kPageSize + 4; offset++) { | 145 for (offset = 5 * kPageSize; offset < 5 * kPageSize + 4; offset++) { |
147 assertThrows(load); | 146 assertThrows(load); |
148 } | 147 } |
149 assertThrows(() => memory.grow(1)); | 148 assertThrows(() => memory.grow(1)); |
150 })(); | 149 })(); |
151 | 150 |
152 (function TestGrowMemoryZeroInitialMemory() { | 151 (function TestGrowMemoryZeroInitialMemory() { |
153 print("ZeroInitialMemory"); | 152 print("ZeroInitialMemory"); |
154 let memory = new WebAssembly.Memory({initial: 0}); | 153 let memory = new WebAssembly.Memory({initial: 0}); |
155 assertEquals(0, memory.buffer.byteLength); | 154 assertEquals(0, memory.buffer.byteLength); |
156 let i32 = new Int32Array(memory.buffer); | 155 let i32 = new Int32Array(memory.buffer); |
157 let builder = new WasmModuleBuilder(); | 156 let builder = new WasmModuleBuilder(); |
158 builder.addImportedMemory("mine"); | 157 builder.addImportedMemory("mine", "fro"); |
159 builder.addFunction("load", kSig_i_i) | 158 builder.addFunction("load", kSig_i_i) |
160 .addBody([kExprGetLocal, 0, kExprI32LoadMem, 0, 0]) | 159 .addBody([kExprGetLocal, 0, kExprI32LoadMem, 0, 0]) |
161 .exportFunc(); | 160 .exportFunc(); |
162 builder.addFunction("store", kSig_i_ii) | 161 builder.addFunction("store", kSig_i_ii) |
163 .addBody([kExprGetLocal, 0, kExprGetLocal, 1, kExprI32StoreMem, 0, 0, | 162 .addBody([kExprGetLocal, 0, kExprGetLocal, 1, kExprI32StoreMem, 0, 0, |
164 kExprGetLocal, 1]) | 163 kExprGetLocal, 1]) |
165 .exportFunc(); | 164 .exportFunc(); |
166 var offset; | 165 var offset; |
167 let instance = builder.instantiate({mine: memory}); | 166 let instance = builder.instantiate({mine: {fro: memory}}); |
168 function load() { return instance.exports.load(offset); } | 167 function load() { return instance.exports.load(offset); } |
169 function store(value) { return instance.exports.store(offset, value); } | 168 function store(value) { return instance.exports.store(offset, value); } |
170 | 169 |
171 for (var i = 1; i < 5; i++) { | 170 for (var i = 1; i < 5; i++) { |
172 assertEquals(i - 1, memory.grow(1)); | 171 assertEquals(i - 1, memory.grow(1)); |
173 assertEquals(i * kPageSize, memory.buffer.byteLength); | 172 assertEquals(i * kPageSize, memory.buffer.byteLength); |
174 for (offset = (i - 1) * kPageSize; offset < i * kPageSize - 3; offset++) { | 173 for (offset = (i - 1) * kPageSize; offset < i * kPageSize - 3; offset++) { |
175 store(offset * 2); | 174 store(offset * 2); |
176 } | 175 } |
177 } | 176 } |
178 for (offset = 5 * kPageSize; offset < 5 * kPageSize + 4; offset++) { | 177 for (offset = 5 * kPageSize; offset < 5 * kPageSize + 4; offset++) { |
179 assertThrows(load); | 178 assertThrows(load); |
180 } | 179 } |
181 assertThrows(() => memory.grow(16381)); | 180 assertThrows(() => memory.grow(16381)); |
182 })(); | 181 })(); |
183 | 182 |
184 (function ImportedMemoryBufferLength() { | 183 (function ImportedMemoryBufferLength() { |
185 print("ImportedMemoryBufferLength"); | 184 print("ImportedMemoryBufferLength"); |
186 let memory = new WebAssembly.Memory({initial: 2, maximum: 10}); | 185 let memory = new WebAssembly.Memory({initial: 2, maximum: 10}); |
187 assertEquals(2*kPageSize, memory.buffer.byteLength); | 186 assertEquals(2*kPageSize, memory.buffer.byteLength); |
188 let builder = new WasmModuleBuilder(); | 187 let builder = new WasmModuleBuilder(); |
189 builder.addFunction("grow", kSig_i_i) | 188 builder.addFunction("grow", kSig_i_i) |
190 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) | 189 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) |
191 .exportFunc(); | 190 .exportFunc(); |
192 builder.addImportedMemory("mine"); | 191 builder.addImportedMemory("cat", "mine"); |
193 let instance = builder.instantiate({mine: memory}); | 192 let instance = builder.instantiate({cat: {mine: memory}}); |
194 function grow(pages) { return instance.exports.grow(pages); } | 193 function grow(pages) { return instance.exports.grow(pages); } |
195 assertEquals(2, grow(3)); | 194 assertEquals(2, grow(3)); |
196 assertEquals(5*kPageSize, memory.buffer.byteLength); | 195 assertEquals(5*kPageSize, memory.buffer.byteLength); |
197 assertEquals(5, grow(5)); | 196 assertEquals(5, grow(5)); |
198 assertEquals(10*kPageSize, memory.buffer.byteLength); | 197 assertEquals(10*kPageSize, memory.buffer.byteLength); |
199 assertThrows(() => memory.grow(1)); | 198 assertThrows(() => memory.grow(1)); |
200 })(); | 199 })(); |
201 | 200 |
202 (function TestGrowMemoryExportedMaximum() { | 201 (function TestGrowMemoryExportedMaximum() { |
203 print("TestGrowMemoryExportedMaximum"); | 202 print("TestGrowMemoryExportedMaximum"); |
204 let initial_size = 1, maximum_size = 10; | 203 let initial_size = 1, maximum_size = 10; |
205 var exp_instance; | 204 var exp_instance; |
206 { | 205 { |
207 let builder = new WasmModuleBuilder(); | 206 let builder = new WasmModuleBuilder(); |
208 builder.addMemory(initial_size, maximum_size, true); | 207 builder.addMemory(initial_size, maximum_size, true); |
209 builder.exportMemoryAs("exported_mem"); | 208 builder.exportMemoryAs("exported_mem"); |
210 exp_instance = builder.instantiate(); | 209 exp_instance = builder.instantiate(); |
211 } | 210 } |
212 var instance; | 211 var instance; |
213 { | 212 { |
214 var builder = new WasmModuleBuilder(); | 213 var builder = new WasmModuleBuilder(); |
215 builder.addImportedMemory("imported_mem"); | 214 builder.addImportedMemory("fur", "imported_mem"); |
216 builder.addFunction("mem_size", kSig_i_v) | 215 builder.addFunction("mem_size", kSig_i_v) |
217 .addBody([kExprMemorySize, kMemoryZero]) | 216 .addBody([kExprMemorySize, kMemoryZero]) |
218 .exportFunc(); | 217 .exportFunc(); |
219 builder.addFunction("grow", kSig_i_i) | 218 builder.addFunction("grow", kSig_i_i) |
220 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) | 219 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) |
221 .exportFunc(); | 220 .exportFunc(); |
222 instance = builder.instantiate({ | 221 instance = builder.instantiate({fur: { |
223 imported_mem: exp_instance.exports.exported_mem}); | 222 imported_mem: exp_instance.exports.exported_mem}}); |
224 } | 223 } |
225 for (var i = initial_size; i < maximum_size; i++) { | 224 for (var i = initial_size; i < maximum_size; i++) { |
226 assertEquals(i, instance.exports.grow(1)); | 225 assertEquals(i, instance.exports.grow(1)); |
227 assertEquals((i+1), instance.exports.mem_size()); | 226 assertEquals((i+1), instance.exports.mem_size()); |
228 } | 227 } |
229 assertEquals(-1, instance.exports.grow(1)); | 228 assertEquals(-1, instance.exports.grow(1)); |
230 })(); | 229 })(); |
231 | 230 |
232 (function TestMemoryGrowWebAssemblyInstances() { | 231 (function TestMemoryGrowWebAssemblyInstances() { |
233 print("TestMemoryGrowWebAssemblyInstances"); | 232 print("TestMemoryGrowWebAssemblyInstances"); |
234 let memory = new WebAssembly.Memory({initial: 1, maximum: 15}); | 233 let memory = new WebAssembly.Memory({initial: 1, maximum: 15}); |
235 var builder = new WasmModuleBuilder(); | 234 var builder = new WasmModuleBuilder(); |
236 builder.addImportedMemory("imported_mem"); | 235 builder.addImportedMemory("lit", "imported_mem"); |
237 builder.addFunction("mem_size", kSig_i_v) | 236 builder.addFunction("mem_size", kSig_i_v) |
238 .addBody([kExprMemorySize, kMemoryZero]) | 237 .addBody([kExprMemorySize, kMemoryZero]) |
239 .exportAs("mem_size"); | 238 .exportAs("mem_size"); |
240 builder.addFunction("grow", kSig_i_i) | 239 builder.addFunction("grow", kSig_i_i) |
241 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) | 240 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) |
242 .exportFunc(); | 241 .exportFunc(); |
243 var module = new WebAssembly.Module(builder.toBuffer()); | 242 var module = new WebAssembly.Module(builder.toBuffer()); |
244 var instances = []; | 243 var instances = []; |
245 for (var i = 0; i < 6; i++) { | 244 for (var i = 0; i < 6; i++) { |
246 instances.push(new WebAssembly.Instance(module, {imported_mem: memory})); | 245 instances.push(new WebAssembly.Instance(module, {lit: {imported_mem: memory}
})); |
247 } | 246 } |
248 function verify_mem_size(expected_pages) { | 247 function verify_mem_size(expected_pages) { |
249 assertEquals(expected_pages*kPageSize, | 248 assertEquals(expected_pages*kPageSize, |
250 memory.buffer.byteLength); | 249 memory.buffer.byteLength); |
251 for (var i = 0; i < 6; i++) { | 250 for (var i = 0; i < 6; i++) { |
252 assertEquals(expected_pages, instances[i].exports.mem_size()); | 251 assertEquals(expected_pages, instances[i].exports.mem_size()); |
253 } | 252 } |
254 } | 253 } |
255 | 254 |
256 // Verify initial memory size | 255 // Verify initial memory size |
(...skipping 10 matching lines...) Expand all Loading... |
267 verify_mem_size(++current_mem_size); | 266 verify_mem_size(++current_mem_size); |
268 } | 267 } |
269 | 268 |
270 assertThrows(() => memory.grow(5)); | 269 assertThrows(() => memory.grow(5)); |
271 })(); | 270 })(); |
272 | 271 |
273 (function TestImportedMemoryGrowMultipleInstances() { | 272 (function TestImportedMemoryGrowMultipleInstances() { |
274 print("TestImportMemoryMultipleInstances"); | 273 print("TestImportMemoryMultipleInstances"); |
275 let memory = new WebAssembly.Memory({initial: 5, maximum: 100}); | 274 let memory = new WebAssembly.Memory({initial: 5, maximum: 100}); |
276 var builder = new WasmModuleBuilder(); | 275 var builder = new WasmModuleBuilder(); |
277 builder.addImportedMemory("imported_mem"); | 276 builder.addImportedMemory("nob", "imported_mem"); |
278 builder.addFunction("mem_size", kSig_i_v) | 277 builder.addFunction("mem_size", kSig_i_v) |
279 .addBody([kExprMemorySize, kMemoryZero]) | 278 .addBody([kExprMemorySize, kMemoryZero]) |
280 .exportFunc(); | 279 .exportFunc(); |
281 builder.addFunction("grow", kSig_i_i) | 280 builder.addFunction("grow", kSig_i_i) |
282 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) | 281 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) |
283 .exportFunc(); | 282 .exportFunc(); |
284 var instances = []; | 283 var instances = []; |
285 for (var i = 0; i < 5; i++) { | 284 for (var i = 0; i < 5; i++) { |
286 instances.push(builder.instantiate({imported_mem: memory})); | 285 instances.push(builder.instantiate({nob: {imported_mem: memory}})); |
287 } | 286 } |
288 function grow_instance_0(pages) { return instances[0].exports.grow(pages); } | 287 function grow_instance_0(pages) { return instances[0].exports.grow(pages); } |
289 function grow_instance_1(pages) { return instances[1].exports.grow(pages); } | 288 function grow_instance_1(pages) { return instances[1].exports.grow(pages); } |
290 function grow_instance_2(pages) { return instances[2].exports.grow(pages); } | 289 function grow_instance_2(pages) { return instances[2].exports.grow(pages); } |
291 function grow_instance_3(pages) { return instances[3].exports.grow(pages); } | 290 function grow_instance_3(pages) { return instances[3].exports.grow(pages); } |
292 function grow_instance_4(pages) { return instances[4].exports.grow(pages); } | 291 function grow_instance_4(pages) { return instances[4].exports.grow(pages); } |
293 | 292 |
294 function verify_mem_size(expected_pages) { | 293 function verify_mem_size(expected_pages) { |
295 assertEquals(expected_pages*kPageSize, memory.buffer.byteLength); | 294 assertEquals(expected_pages*kPageSize, memory.buffer.byteLength); |
296 for (var i = 0; i < 5; i++) { | 295 for (var i = 0; i < 5; i++) { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
335 { | 334 { |
336 let builder = new WasmModuleBuilder(); | 335 let builder = new WasmModuleBuilder(); |
337 builder.addMemory(1, 11, true); | 336 builder.addMemory(1, 11, true); |
338 builder.exportMemoryAs("exported_mem"); | 337 builder.exportMemoryAs("exported_mem"); |
339 builder.addFunction("mem_size", kSig_i_v) | 338 builder.addFunction("mem_size", kSig_i_v) |
340 .addBody([kExprMemorySize, kMemoryZero]) | 339 .addBody([kExprMemorySize, kMemoryZero]) |
341 .exportFunc(); | 340 .exportFunc(); |
342 instance = builder.instantiate(); | 341 instance = builder.instantiate(); |
343 } | 342 } |
344 var builder = new WasmModuleBuilder(); | 343 var builder = new WasmModuleBuilder(); |
345 builder.addImportedMemory("imported_mem"); | 344 builder.addImportedMemory("doo", "imported_mem"); |
346 builder.addFunction("mem_size", kSig_i_v) | 345 builder.addFunction("mem_size", kSig_i_v) |
347 .addBody([kExprMemorySize, kMemoryZero]) | 346 .addBody([kExprMemorySize, kMemoryZero]) |
348 .exportFunc(); | 347 .exportFunc(); |
349 builder.addFunction("grow", kSig_i_i) | 348 builder.addFunction("grow", kSig_i_i) |
350 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) | 349 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) |
351 .exportFunc(); | 350 .exportFunc(); |
352 var instances = []; | 351 var instances = []; |
353 for (var i = 0; i < 10; i++) { | 352 for (var i = 0; i < 10; i++) { |
354 instances.push(builder.instantiate({ | 353 instances.push(builder.instantiate({ |
355 imported_mem: instance.exports.exported_mem})); | 354 doo: {imported_mem: instance.exports.exported_mem}})); |
356 } | 355 } |
357 function verify_mem_size(expected_pages) { | 356 function verify_mem_size(expected_pages) { |
358 for (var i = 0; i < 10; i++) { | 357 for (var i = 0; i < 10; i++) { |
359 assertEquals(expected_pages, instances[i].exports.mem_size()); | 358 assertEquals(expected_pages, instances[i].exports.mem_size()); |
360 } | 359 } |
361 } | 360 } |
362 var current_mem_size = 1; | 361 var current_mem_size = 1; |
363 for (var i = 0; i < 10; i++) { | 362 for (var i = 0; i < 10; i++) { |
364 function grow(pages) { return instances[i].exports.grow(pages); } | 363 function grow(pages) { return instances[i].exports.grow(pages); } |
365 assertEquals(current_mem_size, instances[i].exports.grow(1)); | 364 assertEquals(current_mem_size, instances[i].exports.grow(1)); |
(...skipping 11 matching lines...) Expand all Loading... |
377 .exportFunc(); | 376 .exportFunc(); |
378 builder.addFunction("grow", kSig_i_i) | 377 builder.addFunction("grow", kSig_i_i) |
379 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) | 378 .addBody([kExprGetLocal, 0, kExprGrowMemory, kMemoryZero]) |
380 .exportFunc(); | 379 .exportFunc(); |
381 instance = builder.instantiate(); | 380 instance = builder.instantiate(); |
382 assertEquals(kPageSize, instance.exports.exported_mem.buffer.byteLength); | 381 assertEquals(kPageSize, instance.exports.exported_mem.buffer.byteLength); |
383 assertEquals(1, instance.exports.grow(2)); | 382 assertEquals(1, instance.exports.grow(2)); |
384 assertEquals(3, instance.exports.mem_size()); | 383 assertEquals(3, instance.exports.mem_size()); |
385 assertEquals(3*kPageSize, instance.exports.exported_mem.buffer.byteLength); | 384 assertEquals(3*kPageSize, instance.exports.exported_mem.buffer.byteLength); |
386 })(); | 385 })(); |
OLD | NEW |