[wasm] Initial signal handler

test/mjsunit/wasm/grow-memory.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --expose-wasm --stress-compaction
 
 load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
 
 var kPageSize = 0x10000;
@@ skipping 24 matching lines @@
   builder.addFunction("store8", kSig_i_ii)
       .addBody([kExprGetLocal, 0, kExprGetLocal, 1, kExprI32StoreMem8, 0, 0,
                 kExprGetLocal, 1])
       .exportFunc();
   return builder;
 }
 
 // TODO(gdeepti): Generate tests programatically for all the sizes instead of
 // current implementation.
 function testGrowMemoryReadWrite32() {
+  print('testGrowMemoryReadWrite32');

[Mark Seaborn, 2017/02/17 21:41:12]

Is this debugging that should be removed?

[Eric Holk, 2017/02/23 02:16:57]

We're inconsistent about this; some tests print the name of each subtest and
others don't. I prefer it when they do, but that is not really relevant to this
CL so I will change it back.

   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset;
   function peek() { return module.exports.load(offset); }
   function poke(value) { return module.exports.store(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   for(offset = 0; offset <= (kPageSize - 4); offset+=4) {
     poke(20);
@@ skipping 27 matching lines @@
   }
   for (offset = 19*kPageSize - 3; offset < 19*kPageSize + 5; offset++) {
     assertTraps(kTrapMemOutOfBounds, poke);
     assertTraps(kTrapMemOutOfBounds, peek);
   }
 }
 
 testGrowMemoryReadWrite32();
 
 function testGrowMemoryReadWrite16() {
+  print('testGrowMemoryReadWrite16');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset;
   function peek() { return module.exports.load16(offset); }
   function poke(value) { return module.exports.store16(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   for(offset = 0; offset <= (kPageSize - 2); offset+=2) {
     poke(20);
@@ skipping 27 matching lines @@
   }
   for (offset = 19*kPageSize - 1; offset < 19*kPageSize + 5; offset++) {
     assertTraps(kTrapMemOutOfBounds, poke);
     assertTraps(kTrapMemOutOfBounds, peek);
   }
 }
 
 testGrowMemoryReadWrite16();
 
 function testGrowMemoryReadWrite8() {
+  print('testGrowMemoryReadWrite8');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset;
   function peek() { return module.exports.load8(offset); }
   function poke(value) { return module.exports.store8(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   for(offset = 0; offset <= kPageSize - 1; offset++) {
     poke(20);
@@ skipping 27 matching lines @@
   }
   for (offset = 19*kPageSize; offset < 19*kPageSize + 5; offset++) {
     assertTraps(kTrapMemOutOfBounds, poke);
     assertTraps(kTrapMemOutOfBounds, peek);
   }
 }
 
 testGrowMemoryReadWrite8();
 
 function testGrowMemoryZeroInitialSize() {
+  print('testGrowMemoryZeroInitialSize');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(0, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset;
   function peek() { return module.exports.load(offset); }
   function poke(value) { return module.exports.store(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   assertTraps(kTrapMemOutOfBounds, peek);
   assertTraps(kTrapMemOutOfBounds, poke);
@@ skipping 14 matching lines @@
     assertTraps(kTrapMemOutOfBounds, poke);
     assertEquals(i, growMem(1));
   }
   poke(20);
   assertEquals(20, peek());
 }
 
 testGrowMemoryZeroInitialSize();
 
 function testGrowMemoryZeroInitialSize32() {
+  print('testGrowMemoryZeroInitialSize32');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(0, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset;
   function peek() { return module.exports.load(offset); }
   function poke(value) { return module.exports.store(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   assertTraps(kTrapMemOutOfBounds, peek);
   assertTraps(kTrapMemOutOfBounds, poke);
 
   assertEquals(0, growMem(1));
 
   for(offset = 0; offset <= kPageSize - 4; offset++) {
     poke(20);
     assertEquals(20, peek());
   }
 
   for(offset = kPageSize - 3; offset <= kPageSize + 5; offset++) {
     assertTraps(kTrapMemOutOfBounds, peek);
   }
 }
 
 testGrowMemoryZeroInitialSize32();
 
 function testGrowMemoryZeroInitialSize16() {
+  print('testGrowMemoryZeroInitialSize16');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(0, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset;
   function peek() { return module.exports.load16(offset); }
   function poke(value) { return module.exports.store16(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   assertTraps(kTrapMemOutOfBounds, peek);
   assertTraps(kTrapMemOutOfBounds, poke);
 
   assertEquals(0, growMem(1));
 
   for(offset = 0; offset <= kPageSize - 2; offset++) {
     poke(20);
     assertEquals(20, peek());
   }
 
   for(offset = kPageSize - 1; offset <= kPageSize + 5; offset++) {
     assertTraps(kTrapMemOutOfBounds, peek);
   }
 }
 
 testGrowMemoryZeroInitialSize16();
 
 function testGrowMemoryZeroInitialSize8() {
+  print('testGrowMemoryZeroInitialSize8');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(0, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset;
   function peek() { return module.exports.load8(offset); }
   function poke(value) { return module.exports.store8(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   assertTraps(kTrapMemOutOfBounds, peek);
   assertTraps(kTrapMemOutOfBounds, poke);
 
   assertEquals(0, growMem(1));
 
   for(offset = 0; offset <= kPageSize - 1; offset++) {
     poke(20);
     assertEquals(20, peek());
   }
 
   for(offset = kPageSize; offset <= kPageSize + 5; offset++) {
     assertTraps(kTrapMemOutOfBounds, peek);
   }
 }
 
 testGrowMemoryZeroInitialSize8();
 
 function testGrowMemoryTrapMaxPagesZeroInitialMemory() {
+  print('testGrowMemoryTrapMaxPagesZeroInitialMemory');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(0, kV8MaxPages, false);
   var module = builder.instantiate();
   var maxPages = 16385;
   function growMem(pages) { return module.exports.grow_memory(pages); }
   assertEquals(-1, growMem(maxPages));
 }
 
 testGrowMemoryTrapMaxPagesZeroInitialMemory();
 
 function testGrowMemoryTrapMaxPages() {
+  print('testGrowMemoryTrapMaxPages');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, 1, false);
   var module = builder.instantiate();
   var maxPages = 16384;
   function growMem(pages) { return module.exports.grow_memory(pages); }
   assertEquals(-1, growMem(maxPages));
 }
 
 testGrowMemoryTrapMaxPages();
 
 function testGrowMemoryTrapsWithNonSmiInput() {
+  print('testGrowMemoryTrapsWithNonSmiInput');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(0, kV8MaxPages, false);
   var module = builder.instantiate();
   function growMem(pages) { return module.exports.grow_memory(pages); }
   // The parameter of grow_memory is unsigned. Therefore -1 stands for
   // UINT32_MIN, which cannot be represented as SMI.
   assertEquals(-1, growMem(-1));
 };
 
 testGrowMemoryTrapsWithNonSmiInput();
 
 function testGrowMemoryCurrentMemory() {
+  print('testGrowMemoryCurrentMemory');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, kV8MaxPages, false);
   builder.addFunction("memory_size", kSig_i_v)
       .addBody([kExprMemorySize, kMemoryZero])
       .exportFunc();
   var module = builder.instantiate();
   function growMem(pages) { return module.exports.grow_memory(pages); }
   function MemSize() { return module.exports.memory_size(); }
   assertEquals(1, MemSize());
   assertEquals(1, growMem(1));
   assertEquals(2, MemSize());
 }
 
 testGrowMemoryCurrentMemory();
 
 function testGrowMemoryPreservesDataMemOp32() {
+  print('testGrowMemoryPreservesDataMemOp32');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset, val;
   function peek() { return module.exports.load(offset); }
   function poke(value) { return module.exports.store(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   for(offset = 0; offset <= (kPageSize - 4); offset+=4) {
     poke(100000 - offset);
     assertEquals(100000 - offset, peek());
   }
 
   assertEquals(1, growMem(3));
 
   for(offset = 0; offset <= (kPageSize - 4); offset+=4) {
     assertEquals(100000 - offset, peek());
   }
 }
 
 testGrowMemoryPreservesDataMemOp32();
 
 function testGrowMemoryPreservesDataMemOp16() {
+  print('testGrowMemoryPreservesDataMemOp16');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset, val;
   function peek() { return module.exports.load16(offset); }
   function poke(value) { return module.exports.store16(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   for(offset = 0; offset <= (kPageSize - 2); offset+=2) {
     poke(65535 - offset);
     assertEquals(65535 - offset, peek());
   }
 
   assertEquals(1, growMem(3));
 
   for(offset = 0; offset <= (kPageSize - 2); offset+=2) {
     assertEquals(65535 - offset, peek());
   }
 }
 
 testGrowMemoryPreservesDataMemOp16();
 
 function testGrowMemoryPreservesDataMemOp8() {
+  print('testGrowMemoryPreservesDataMemOp8');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset, val = 0;
   function peek() { return module.exports.load8(offset); }
   function poke(value) { return module.exports.store8(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   for(offset = 0; offset <= (kPageSize - 1); offset++, val++) {
     poke(val);
     assertEquals(val, peek());
     if (val == 255) val = 0;
   }
 
   assertEquals(1, growMem(3));
 
   val = 0;
 
   for(offset = 0; offset <= (kPageSize - 1); offset++, val++) {
     assertEquals(val, peek());
     if (val == 255) val = 0;
   }
 }
 
 testGrowMemoryPreservesDataMemOp8();
 
 function testGrowMemoryOutOfBoundsOffset() {
+  print('testGrowMemoryOutOfBoundsOffset');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, kV8MaxPages, false);
   var module = builder.instantiate();
   var offset, val;
   function peek() { return module.exports.load(offset); }
   function poke(value) { return module.exports.store(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
 
   offset = 3*kPageSize + 4;
   assertTraps(kTrapMemOutOfBounds, poke);
@@ skipping 12 matching lines @@
   }
 
   for (offset = 4*kPageSize - 3; offset <= 4*kPageSize + 4; offset++) {
     assertTraps(kTrapMemOutOfBounds, poke);
   }
 }
 
 testGrowMemoryOutOfBoundsOffset();
 
 function testGrowMemoryOutOfBoundsOffset2() {
+  print('testGrowMemoryOutOfBoundsOffset2');
   var builder = new WasmModuleBuilder();
   builder.addMemory(16, 128, false);
   builder.addFunction("main", kSig_v_v)
       .addBody([
           kExprI32Const, 20,
           kExprI32Const, 29,
           kExprGrowMemory, kMemoryZero,
           kExprI32StoreMem, 0, 0xFF, 0xFF, 0xFF, 0x3a
           ])
       .exportAs("main");
   var module = builder.instantiate();
   assertTraps(kTrapMemOutOfBounds, module.exports.main);
 }
 
 testGrowMemoryOutOfBoundsOffset2();
 
 function testGrowMemoryDeclaredMaxTraps() {
+  print('testGrowMemoryDeclaredMaxTraps');
   var builder = genGrowMemoryBuilder();
   builder.addMemory(1, 16, false);
   var module = builder.instantiate();
   function growMem(pages) { return module.exports.grow_memory(pages); }
   assertEquals(1, growMem(5));
   assertEquals(6, growMem(5));
   assertEquals(-1, growMem(6));
 }
 
 testGrowMemoryDeclaredMaxTraps();
 
 function testGrowMemoryDeclaredSpecMaxTraps() {
+  print('testGrowMemoryDeclaredSpecMaxTraps');
   // The spec maximum is higher than the internal V8 maximum. This test only
   // checks that grow_memory does not grow past the internally defined maximum
   // to reflect the currentl implementation.
   var builder = genGrowMemoryBuilder();
   var kSpecMaxPages = 65535;
   builder.addMemory(1, kSpecMaxPages, false);
   var module = builder.instantiate();
   function poke(value) { return module.exports.store(offset, value); }
   function growMem(pages) { return module.exports.grow_memory(pages); }
   assertEquals(1, growMem(20));
   assertEquals(-1, growMem(kV8MaxPages - 20));
 }
 
 testGrowMemoryDeclaredSpecMaxTraps();