Update testsuite and implement table64

See WebAssembly/memory64#51

Author: sbc100

include/wabt/interp/interp.h

@@ -1123,6 +1123,9 @@ class Thread {
   T WABT_VECTORCALL Pop();
   Value Pop();
   u64 PopPtr(const Memory::Ptr& memory);
+  u64 PopPtr(const Table::Ptr& table);
+  void PushPtr(const Memory::Ptr& memory, u64 value);
+  void PushPtr(const Table::Ptr& table, u64 value);
 
   template <typename T>
   void WABT_VECTORCALL Push(T);

include/wabt/type-checker.h

@@ -77,7 +77,8 @@ class TypeChecker {
   Result EndBrTable();
   Result OnCall(const TypeVector& param_types, const TypeVector& result_types);
   Result OnCallIndirect(const TypeVector& param_types,
-                        const TypeVector& result_types);
+                        const TypeVector& result_types,
+                        const Limits& table_limits);
   Result OnIndexedFuncRef(Index* out_index);
   Result OnReturnCall(const TypeVector& param_types,
                       const TypeVector& result_types);
@@ -99,20 +100,20 @@ class TypeChecker {
   Result OnLocalSet(Type);
   Result OnLocalTee(Type);
   Result OnLoop(const TypeVector& param_types, const TypeVector& result_types);
-  Result OnMemoryCopy(const Limits& dstlimits, const Limits& srclimits);
+  Result OnMemoryCopy(const Limits& dst_limits, const Limits& src_limits);
   Result OnDataDrop(Index);
   Result OnMemoryFill(const Limits& limits);
   Result OnMemoryGrow(const Limits& limits);
   Result OnMemoryInit(Index, const Limits& limits);
   Result OnMemorySize(const Limits& limits);
-  Result OnTableCopy();
+  Result OnTableCopy(const Limits& dst_limits, const Limits& src_limits);
   Result OnElemDrop(Index);
-  Result OnTableInit(Index, Index);
-  Result OnTableGet(Type elem_type);
-  Result OnTableSet(Type elem_type);
-  Result OnTableGrow(Type elem_type);
-  Result OnTableSize();
-  Result OnTableFill(Type elem_type);
+  Result OnTableInit(Index, const Limits& limits);
+  Result OnTableGet(Type elem_type, const Limits& limits);
+  Result OnTableSet(Type elem_type, const Limits& limits);
+  Result OnTableGrow(Type elem_type, const Limits& limits);
+  Result OnTableSize(const Limits& limits);
+  Result OnTableFill(Type elem_type, const Limits& limits);
   Result OnRefFuncExpr(Index func_type, bool force_generic_funcref);
   Result OnRefNullExpr(Type type);
   Result OnRefIsNullExpr();

src/binary-reader.cc

@@ -582,14 +582,16 @@ Result BinaryReader::ReadTable(Type* out_elem_type, Limits* out_elem_limits) {
   bool is_64 = flags & WABT_BINARY_LIMITS_IS_64_FLAG;
   const uint8_t unknown_flags = flags & ~WABT_BINARY_LIMITS_ALL_FLAGS;
   ERROR_IF(is_shared, "tables may not be shared");
-  ERROR_IF(is_64, "tables may not be 64-bit");
+  ERROR_IF(is_64 && !options_.features.memory64_enabled(),
+           "memory64 not allowed");
   ERROR_UNLESS(unknown_flags == 0, "malformed table limits flag: %d", flags);
   CHECK_RESULT(ReadU32Leb128(&initial, "table initial elem count"));
   if (has_max) {
     CHECK_RESULT(ReadU32Leb128(&max, "table max elem count"));
   }
 
   out_elem_limits->has_max = has_max;
+  out_elem_limits->is_64 = is_64;
   out_elem_limits->initial = initial;
   out_elem_limits->max = max;
   return Result::Ok;

src/interp/binary-reader-interp.cc

@@ -306,7 +306,7 @@ class BinaryReaderInterp : public BinaryReaderNop {
                                     Index keep_extra,
                                     Index* out_drop_count,
                                     Index* out_keep_count);
-  Result BeginInitExpr(Type type, FuncDesc* init_func);
+  Result BeginInitExpr(FuncDesc* init_func);
   Result EndInitExpr();
 
   void EmitBr(Index depth,
@@ -631,7 +631,7 @@ Result BinaryReaderInterp::BeginGlobal(Index index, Type type, bool mutable_) {
 
 Result BinaryReaderInterp::BeginGlobalInitExpr(Index index) {
   GlobalDesc& global = module_.globals.back();
-  return BeginInitExpr(global.type.type, &global.init_func);
+  return BeginInitExpr(&global.init_func);
 }
 
 Result BinaryReaderInterp::EndInitExpr() {
@@ -642,10 +642,11 @@ Result BinaryReaderInterp::EndInitExpr() {
   return Result::Ok;
 }
 
-Result BinaryReaderInterp::BeginInitExpr(Type type, FuncDesc* func) {
+Result BinaryReaderInterp::BeginInitExpr(FuncDesc* func) {
   label_stack_.clear();
   func_ = func;
   func_->code_offset = istream_.end();
+  Type type = func->type.results[0];
   CHECK_RESULT(validator_.BeginInitExpr(GetLocation(), type));
   // Push implicit init func label (equivalent to return).
   PushLabel(LabelKind::Try, Istream::kInvalidOffset, Istream::kInvalidOffset);
@@ -709,16 +710,21 @@ Result BinaryReaderInterp::BeginElemSegment(Index index,
   CHECK_RESULT(validator_.OnElemSegment(GetLocation(),
                                         Var(table_index, GetLocation()), mode));
 
+  ValueType offset_type = ValueType::I32;
+  if (table_index < table_types_.size() &&
+      table_types_[table_index].limits.is_64) {
+    offset_type = ValueType::I64;
+  }
   FuncDesc init_func{
-      FuncType{{}, {ValueType::I32}}, {}, Istream::kInvalidOffset, {}};
+      FuncType{{}, {offset_type}}, {}, Istream::kInvalidOffset, {}};
   ElemDesc desc{{}, ValueType::Void, mode, table_index, init_func};
   module_.elems.push_back(desc);
   return Result::Ok;
 }
 
 Result BinaryReaderInterp::BeginElemSegmentInitExpr(Index index) {
   ElemDesc& elem = module_.elems.back();
-  return BeginInitExpr(Type::I32, &elem.init_func);
+  return BeginInitExpr(&elem.init_func);
 }
 
 Result BinaryReaderInterp::EndElemSegmentInitExpr(Index index) {
@@ -744,7 +750,7 @@ Result BinaryReaderInterp::BeginElemExpr(Index elem_index, Index expr_index) {
   elem.elements.push_back(
       {FuncType{{}, {elem.type}}, {}, Istream::kInvalidOffset, {}});
   assert(expr_index == elem.elements.size() - 1);
-  return BeginInitExpr(elem.type, &elem.elements.back());
+  return BeginInitExpr(&elem.elements.back());
 }
 
 Result BinaryReaderInterp::EndElemExpr(Index elem_index, Index expr_index) {
@@ -758,9 +764,8 @@ Result BinaryReaderInterp::OnDataCount(Index count) {
 }
 
 Result BinaryReaderInterp::BeginDataSegmentInitExpr(Index index) {
-  MemoryType t = memory_types_[0];
   DataDesc& data = module_.datas.back();
-  return BeginInitExpr(t.limits.is_64 ? Type::I64 : Type::I32, &data.init_func);
+  return BeginInitExpr(&data.init_func);
 }
 
 Result BinaryReaderInterp::EndDataSegmentInitExpr(Index index) {
@@ -774,8 +779,13 @@ Result BinaryReaderInterp::BeginDataSegment(Index index,
   CHECK_RESULT(validator_.OnDataSegment(
       GetLocation(), Var(memory_index, GetLocation()), mode));
 
+  ValueType offset_type = ValueType::I32;
+  if (memory_index < memory_types_.size() &&
+      memory_types_[memory_index].limits.is_64) {
+    offset_type = ValueType::I64;
+  }
   FuncDesc init_func{
-      FuncType{{}, {ValueType::I32}}, {}, Istream::kInvalidOffset, {}};
+      FuncType{{}, {offset_type}}, {}, Istream::kInvalidOffset, {}};
   DataDesc desc{{}, mode, memory_index, init_func};
   module_.datas.push_back(desc);
   return Result::Ok;

src/interp/interp.cc

@@ -873,7 +873,14 @@ Instance::Ptr Instance::Instantiate(Store& store,
         if (Failed(inst->CallInitFunc(store, func_ref, &value, out_trap))) {
           return {};
         }
-        u32 offset = value.Get<u32>();
+
+        u64 offset;
+        if (table->type().limits.is_64) {
+          offset = value.Get<u64>();
+        } else {
+          offset = value.Get<u32>();
+        }
+
         if (pass == Check) {
           result = table->IsValidRange(offset, segment.size()) ? Result::Ok
                                                                : Result::Error;
@@ -888,8 +895,8 @@ Instance::Ptr Instance::Instantiate(Store& store,
           *out_trap = Trap::New(
               store, StringPrintf(
                          "out of bounds table access: elem segment is "
-                         "out of bounds: [%u, %" PRIu64 ") >= max value %u",
-                         offset, u64{offset} + segment.size(), table->size()));
+                         "out of bounds: [%" PRIu64 ", %" PRIu64 ") >= max value %u",
+                         offset, offset + segment.size(), table->size()));
           return {};
         }
       } else if (desc.mode == SegmentMode::Declared) {
@@ -1119,6 +1126,26 @@ u64 Thread::PopPtr(const Memory::Ptr& memory) {
   return memory->type().limits.is_64 ? Pop<u64>() : Pop<u32>();
 }
 
+u64 Thread::PopPtr(const Table::Ptr& table) {
+  return table->type().limits.is_64 ? Pop<u64>() : Pop<u32>();
+}
+
+void Thread::PushPtr(const Memory::Ptr& memory, u64 value) {
+  if (memory->type().limits.is_64) {
+    Push<u64>(value);
+  } else {
+    Push<u32>(value);
+  }
+}
+
+void Thread::PushPtr(const Table::Ptr& table, u64 value) {
+  if (table->type().limits.is_64) {
+    Push<u64>(value);
+  } else {
+    Push<u32>(value);
+  }
+}
+
 template <typename T>
 void WABT_VECTORCALL Thread::Push(T value) {
   Push(Value::Make(value));
@@ -1190,7 +1217,7 @@ RunResult Thread::StepInternal(Trap::Ptr* out_trap) {
     case O::ReturnCallIndirect: {
       Table::Ptr table{store_, inst_->tables()[instr.imm_u32x2.fst]};
       auto&& func_type = mod_->desc().func_types[instr.imm_u32x2.snd];
-      auto entry = Pop<u32>();
+      u64 entry = PopPtr(table);
       TRAP_IF(entry >= table->elements().size(), "undefined table index");
       auto new_func_ref = table->elements()[entry];
       TRAP_IF(new_func_ref == Ref::Null, "uninitialized table element");
@@ -1273,29 +1300,17 @@ RunResult Thread::StepInternal(Trap::Ptr* out_trap) {
 
     case O::MemorySize: {
       Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32]};
-      if (memory->type().limits.is_64) {
-        Push<u64>(memory->PageSize());
-      } else {
-        Push<u32>(static_cast<u32>(memory->PageSize()));
-      }
+      PushPtr(memory, memory->PageSize());
       break;
     }
 
     case O::MemoryGrow: {
       Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32]};
       u64 old_size = memory->PageSize();
-      if (memory->type().limits.is_64) {
-        if (Failed(memory->Grow(Pop<u64>()))) {
-          Push<s64>(-1);
-        } else {
-          Push<u64>(old_size);
-        }
+      if (Failed(memory->Grow(PopPtr(memory)))) {
+        PushPtr(memory, -1);
       } else {
-        if (Failed(memory->Grow(Pop<u32>()))) {
-          Push<s32>(-1);
-        } else {
-          Push<u32>(old_size);
-        }
+        PushPtr(memory, old_size);
       }
       break;
     }
@@ -2071,7 +2086,7 @@ RunResult Thread::DoMemoryInit(Instr instr, Trap::Ptr* out_trap) {
   auto&& data = inst_->datas()[instr.imm_u32x2.snd];
   auto size = Pop<u32>();
   auto src = Pop<u32>();
-  auto dst = PopPtr(memory);
+  u64 dst = PopPtr(memory);
   TRAP_IF(Failed(memory->Init(dst, data, src, size)),
           "out of bounds memory access: memory.init out of bounds");
   return RunResult::Ok;
@@ -2085,9 +2100,9 @@ RunResult Thread::DoDataDrop(Instr instr) {
 RunResult Thread::DoMemoryCopy(Instr instr, Trap::Ptr* out_trap) {
   Memory::Ptr mem_dst{store_, inst_->memories()[instr.imm_u32x2.fst]};
   Memory::Ptr mem_src{store_, inst_->memories()[instr.imm_u32x2.snd]};
-  auto size = PopPtr(mem_src);
-  auto src = PopPtr(mem_src);
-  auto dst = PopPtr(mem_dst);
+  u64 size = PopPtr(mem_src);
+  u64 src = PopPtr(mem_src);
+  u64 dst = PopPtr(mem_dst);
   // TODO: change to "out of bounds"
   TRAP_IF(Failed(Memory::Copy(*mem_dst, dst, *mem_src, src, size)),
           "out of bounds memory access: memory.copy out of bound");
@@ -2096,9 +2111,9 @@ RunResult Thread::DoMemoryCopy(Instr instr, Trap::Ptr* out_trap) {
 
 RunResult Thread::DoMemoryFill(Instr instr, Trap::Ptr* out_trap) {
   Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32]};
-  auto size = PopPtr(memory);
+  u64 size = PopPtr(memory);
   auto value = Pop<u32>();
-  auto dst = PopPtr(memory);
+  u64 dst = PopPtr(memory);
   TRAP_IF(Failed(memory->Fill(dst, value, size)),
           "out of bounds memory access: memory.fill out of bounds");
   return RunResult::Ok;
@@ -2109,7 +2124,7 @@ RunResult Thread::DoTableInit(Instr instr, Trap::Ptr* out_trap) {
   auto&& elem = inst_->elems()[instr.imm_u32x2.snd];
   auto size = Pop<u32>();
   auto src = Pop<u32>();
-  auto dst = Pop<u32>();
+  u64 dst = PopPtr(table);
   TRAP_IF(Failed(table->Init(store_, dst, elem, src, size)),
           "out of bounds table access: table.init out of bounds");
   return RunResult::Ok;
@@ -2123,61 +2138,61 @@ RunResult Thread::DoElemDrop(Instr instr) {
 RunResult Thread::DoTableCopy(Instr instr, Trap::Ptr* out_trap) {
   Table::Ptr table_dst{store_, inst_->tables()[instr.imm_u32x2.fst]};
   Table::Ptr table_src{store_, inst_->tables()[instr.imm_u32x2.snd]};
-  auto size = Pop<u32>();
-  auto src = Pop<u32>();
-  auto dst = Pop<u32>();
+  u64 size = PopPtr(table_src);
+  u64 src = PopPtr(table_src);
+  u64 dst = PopPtr(table_dst);
   TRAP_IF(Failed(Table::Copy(store_, *table_dst, dst, *table_src, src, size)),
           "out of bounds table access: table.copy out of bounds");
   return RunResult::Ok;
 }
 
 RunResult Thread::DoTableGet(Instr instr, Trap::Ptr* out_trap) {
   Table::Ptr table{store_, inst_->tables()[instr.imm_u32]};
-  auto index = Pop<u32>();
+  u64 index = PopPtr(table);
   Ref ref;
   TRAP_IF(Failed(table->Get(index, &ref)),
-          StringPrintf(
-              "out of bounds table access: table.get at %u >= max value %u",
-              index, table->size()));
+          StringPrintf("out of bounds table access: table.get at %" PRIu64
+                       " >= max value %u",
+                       index, table->size()));
   Push(ref);
   return RunResult::Ok;
 }
 
 RunResult Thread::DoTableSet(Instr instr, Trap::Ptr* out_trap) {
   Table::Ptr table{store_, inst_->tables()[instr.imm_u32]};
   auto ref = Pop<Ref>();
-  auto index = Pop<u32>();
+  u64 index = PopPtr(table);
   TRAP_IF(Failed(table->Set(store_, index, ref)),
-          StringPrintf(
-              "out of bounds table access: table.set at %u >= max value %u",
-              index, table->size()));
+          StringPrintf("out of bounds table access: table.set at %" PRIu64
+                       " >= max value %u",
+                       index, table->size()));
   return RunResult::Ok;
 }
 
 RunResult Thread::DoTableGrow(Instr instr, Trap::Ptr* out_trap) {
   Table::Ptr table{store_, inst_->tables()[instr.imm_u32]};
   u32 old_size = table->size();
-  auto delta = Pop<u32>();
+  auto delta = PopPtr(table);
   auto ref = Pop<Ref>();
   if (Failed(table->Grow(store_, delta, ref))) {
-    Push<s32>(-1);
+    PushPtr(table, -1);
   } else {
-    Push<u32>(old_size);
+    PushPtr(table, old_size);
   }
   return RunResult::Ok;
 }
 
 RunResult Thread::DoTableSize(Instr instr) {
   Table::Ptr table{store_, inst_->tables()[instr.imm_u32]};
-  Push<u32>(table->size());
+  PushPtr(table, table->size());
   return RunResult::Ok;
 }
 
 RunResult Thread::DoTableFill(Instr instr, Trap::Ptr* out_trap) {
   Table::Ptr table{store_, inst_->tables()[instr.imm_u32]};
-  auto size = Pop<u32>();
+  u64 size = PopPtr(table);
   auto value = Pop<Ref>();
-  auto dst = Pop<u32>();
+  u64 dst = PopPtr(table);
   TRAP_IF(Failed(table->Fill(store_, dst, value, size)),
           "out of bounds table access: table.fill out of bounds");
   return RunResult::Ok;