Update testsuite and implement table64 (#2418)

See WebAssembly/memory64#51

Includes workaround for #2422

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-objdump.cc

@@ -1644,6 +1644,9 @@ Result BinaryReaderObjdump::OnTable(Index index,
   if (!name.empty()) {
     PrintDetails(" <" PRIstringview ">", WABT_PRINTF_STRING_VIEW_ARG(name));
   }
+  if (elem_limits->is_64) {
+    PrintDetails(" i64");
+  }
   PrintDetails("\n");
   return Result::Ok;
 }

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/c-writer.cc

@@ -1292,7 +1292,15 @@ void CWriter::Write(const Const& const_) {
         // Negative zero. Special-cased so it isn't written as -0 below.
         Writef("-0.0");
       } else {
-        Writef("%.17g", Bitcast<double>(f64_bits));
+        char buf[128];
+        snprintf(buf, sizeof(buf), "%.17g", Bitcast<double>(f64_bits));
+        // Append .0 if sprint didn't include a decimal point or use the
+        // exponent ('e') form.  This is a workaround for an MSVC parsing
+        // issue: https://github.com/WebAssembly/wabt/issues/2422
+        if (!strchr(buf, '.') && !strchr(buf, 'e')) {
+          strcat(buf, ".0");
+        }
+        Writef("%s", buf);
       }
       break;
     }
@@ -3636,18 +3644,18 @@ void CWriter::Write(const ExprList& exprs) {
 
       case ExprType::TableGrow: {
         const Table* table = module_->GetTable(cast<TableGrowExpr>(&expr)->var);
-        Write(StackVar(1, Type::I32), " = wasm_rt_grow_",
+        Write(StackVar(1, table->elem_limits.IndexType()), " = wasm_rt_grow_",
               GetReferenceTypeName(table->elem_type), "_table(",
               ExternalInstancePtr(ModuleFieldType::Table, table->name), ", ",
               StackVar(0), ", ", StackVar(1), ");", Newline());
         DropTypes(2);
-        PushType(Type::I32);
+        PushType(table->elem_limits.IndexType());
       } break;
 
       case ExprType::TableSize: {
         const Table* table = module_->GetTable(cast<TableSizeExpr>(&expr)->var);
 
-        PushType(Type::I32);
+        PushType(table->elem_limits.IndexType());
         Write(StackVar(0), " = ",
               ExternalInstanceRef(ModuleFieldType::Table, table->name),
               ".size;", Newline());

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;