Function BasicMemory64Tests

deps/v8/test/mjsunit/wasm/memory64.js:15–101

(num_pages, use_atomic_ops)

const max_num_pages = 16 * GB / kPageSize;

function BasicMemory64Tests(num_pages, use_atomic_ops) {
  const num_bytes = num_pages * kPageSize;
  print(`Testing ${num_bytes} bytes (${num_pages} pages) on ${
      use_atomic_ops ? '' : 'non-'}atomic memory`);

  let builder = new WasmModuleBuilder();
  builder.addMemory64(num_pages, num_pages);
  builder.exportMemoryAs('memory');

  // A memory operation with alignment (2) and offset (0).
  let op = (non_atomic, atomic) => use_atomic_ops ?
      [kAtomicPrefix, atomic, 2, 0] :
      [non_atomic, 2, 0];
  builder.addFunction('load', makeSig([kWasmF64], [kWasmI32]))
      .addBody([
        kExprLocalGet, 0,                           // local.get 0
        kExprI64UConvertF64,                        // i64.uconvert_sat.f64
        ...op(kExprI32LoadMem, kExprI32AtomicLoad)  // load
      ])
      .exportFunc();
  builder.addFunction('store', makeSig([kWasmF64, kWasmI32], []))
      .addBody([
        kExprLocalGet, 0,                             // local.get 0
        kExprI64UConvertF64,                          // i64.uconvert_sat.f64
        kExprLocalGet, 1,                             // local.get 1
        ...op(kExprI32StoreMem, kExprI32AtomicStore)  // store
      ])
      .exportFunc();

  let module = builder.instantiate();
  let memory = module.exports.memory;
  let load = module.exports.load;
  let store = module.exports.store;

  assertEquals(num_bytes, memory.buffer.byteLength);
  // Test that we can create a TypedArray from that large buffer.
  let array = new Int8Array(memory.buffer);
  assertEquals(num_bytes, array.length);

  const GB = Math.pow(2, 30);
  let unalignedAndOobTrap =
    use_atomic_ops ? kTrapUnalignedAccess : kTrapMemOutOfBounds;
  assertEquals(0, load(num_bytes - 4));
  assertTraps(kTrapMemOutOfBounds, () => load(num_bytes));
  assertTraps(unalignedAndOobTrap, () => load(num_bytes - 3));
  assertTraps(kTrapMemOutOfBounds, () => load(num_bytes - 4 + 4 * GB));
  assertTraps(kTrapMemOutOfBounds, () => store(num_bytes));
  assertTraps(unalignedAndOobTrap, () => store(num_bytes - 3));
  assertTraps(kTrapMemOutOfBounds, () => store(num_bytes - 4 + 4 * GB));
  if (use_atomic_ops) {
    assertTraps(kTrapUnalignedAccess, () => load(num_bytes - 7));
    assertTraps(kTrapUnalignedAccess, () => store(num_bytes - 7));
  }

  store(num_bytes - 4, 0x12345678);
  assertEquals(0x12345678, load(num_bytes - 4));

  let kStoreOffset = use_atomic_ops ? 40 : 27;