Add support for the custom-page-sizes proposal

README.md

@@ -62,6 +62,7 @@ Wabt has been compiled to JavaScript via emscripten. Some of the functionality i
 | [multi-memory][]      | `--enable-multi-memory`     |   | ✓ | ✓ | ✓ | ✓ | ✓ |
 | [extended-const][]    | `--enable-extended-const`   |   | ✓ | ✓ | ✓ | ✓ | ✓ |
 | [relaxed-simd][]      | `--enable-relaxed-simd`     |   | ✓ | ✓ | ✓ | ✓ |   |
+| [custom-page-sizes][] | `--enable-custom-page-sizes`|   | ✓ | ✓ | ✓ | ✓ |   |
 
 [exception handling]: https://github.com/WebAssembly/exception-handling
 [mutable globals]: https://github.com/WebAssembly/mutable-global
@@ -78,6 +79,7 @@ Wabt has been compiled to JavaScript via emscripten. Some of the functionality i
 [multi-memory]: https://github.com/WebAssembly/multi-memory
 [extended-const]: https://github.com/WebAssembly/extended-const
 [relaxed-simd]: https://github.com/WebAssembly/relaxed-simd
+[custom-page-sizes]: https://github.com/WebAssembly/custom-page-sizes
 
 ## Cloning
 

include/wabt/binary-reader-logging.h

@@ -74,7 +74,8 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
                         std::string_view module_name,
                         std::string_view field_name,
                         Index memory_index,
-                        const Limits* page_limits) override;
+                        const Limits* page_limits,
+                        uint32_t page_size) override;
   Result OnImportGlobal(Index import_index,
                         std::string_view module_name,
                         std::string_view field_name,
@@ -102,7 +103,9 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
 
   Result BeginMemorySection(Offset size) override;
   Result OnMemoryCount(Index count) override;
-  Result OnMemory(Index index, const Limits* limits) override;
+  Result OnMemory(Index index,
+                  const Limits* limits,
+                  uint32_t page_size) override;
   Result EndMemorySection() override;
 
   Result BeginGlobalSection(Offset size) override;

include/wabt/binary-reader-nop.h

@@ -89,7 +89,8 @@ class BinaryReaderNop : public BinaryReaderDelegate {
                         std::string_view module_name,
                         std::string_view field_name,
                         Index memory_index,
-                        const Limits* page_limits) override {
+                        const Limits* page_limits,
+                        uint32_t page_size) override {
     return Result::Ok;
   }
   Result OnImportGlobal(Index import_index,
@@ -130,7 +131,9 @@ class BinaryReaderNop : public BinaryReaderDelegate {
   /* Memory section */
   Result BeginMemorySection(Offset size) override { return Result::Ok; }
   Result OnMemoryCount(Index count) override { return Result::Ok; }
-  Result OnMemory(Index index, const Limits* limits) override {
+  Result OnMemory(Index index,
+                  const Limits* limits,
+                  uint32_t page_size) override {
     return Result::Ok;
   }
   Result EndMemorySection() override { return Result::Ok; }

include/wabt/binary-reader.h

@@ -125,7 +125,8 @@ class BinaryReaderDelegate {
                                 std::string_view module_name,
                                 std::string_view field_name,
                                 Index memory_index,
-                                const Limits* page_limits) = 0;
+                                const Limits* page_limits,
+                                uint32_t page_size) = 0;
   virtual Result OnImportGlobal(Index import_index,
                                 std::string_view module_name,
                                 std::string_view field_name,
@@ -156,7 +157,9 @@ class BinaryReaderDelegate {
   /* Memory section */
   virtual Result BeginMemorySection(Offset size) = 0;
   virtual Result OnMemoryCount(Index count) = 0;
-  virtual Result OnMemory(Index index, const Limits* limits) = 0;
+  virtual Result OnMemory(Index index,
+                          const Limits* limits,
+                          uint32_t page_size) = 0;
   virtual Result EndMemorySection() = 0;
 
   /* Global section */

include/wabt/binary.h

@@ -24,7 +24,12 @@
 #define WABT_BINARY_LIMITS_HAS_MAX_FLAG 0x1
 #define WABT_BINARY_LIMITS_IS_SHARED_FLAG 0x2
 #define WABT_BINARY_LIMITS_IS_64_FLAG 0x4
-#define WABT_BINARY_LIMITS_ALL_FLAGS                                     \
+#define WABT_BINARY_LIMITS_HAS_CUSTOM_PAGE_SIZE_FLAG 0x8
+#define WABT_BINARY_LIMITS_ALL_MEMORY_FLAGS                              \
+  (WABT_BINARY_LIMITS_HAS_MAX_FLAG | WABT_BINARY_LIMITS_IS_SHARED_FLAG | \
+   WABT_BINARY_LIMITS_IS_64_FLAG |                                       \
+   WABT_BINARY_LIMITS_HAS_CUSTOM_PAGE_SIZE_FLAG)
+#define WABT_BINARY_LIMITS_ALL_TABLE_FLAGS                               \
   (WABT_BINARY_LIMITS_HAS_MAX_FLAG | WABT_BINARY_LIMITS_IS_SHARED_FLAG | \
    WABT_BINARY_LIMITS_IS_64_FLAG)
 

include/wabt/common.h

@@ -44,14 +44,18 @@
 #define WABT_USE(x) static_cast<void>(x)
 
 // 64k
-#define WABT_PAGE_SIZE 0x10000
-// # of pages that fit in 32-bit address space
-#define WABT_MAX_PAGES32 0x10000
-// # of pages that fit in 64-bit address space
-#define WABT_MAX_PAGES64 0x1000000000000
-#define WABT_BYTES_TO_PAGES(x) ((x) >> 16)
-#define WABT_ALIGN_UP_TO_PAGE(x) \
-  (((x) + WABT_PAGE_SIZE - 1) & ~(WABT_PAGE_SIZE - 1))
+#define WABT_DEFAULT_PAGE_SIZE 0x10000
+
+inline uint64_t WABT_BYTES_TO_MIN_PAGES(uint64_t num_bytes,
+                                        uint32_t page_size) {
+  if ((page_size == 0) ||
+      (page_size & (page_size - 1))) {  // malformed page sizes
+    WABT_UNREACHABLE;
+    return 0;
+  }
+  uint64_t num_pages = num_bytes / page_size;
+  return (page_size * num_pages == num_bytes) ? num_pages : num_pages + 1;
+}
 
 #define WABT_ENUM_COUNT(name) \
   (static_cast<int>(name::Last) - static_cast<int>(name::First) + 1)

include/wabt/feature.def

@@ -40,3 +40,4 @@ WABT_FEATURE(memory64,            "memory64",                false,   "64-bit me
 WABT_FEATURE(multi_memory,        "multi-memory",            false,   "Multi-memory")
 WABT_FEATURE(extended_const,      "extended-const",          false,   "Extended constant expressions")
 WABT_FEATURE(relaxed_simd,        "relaxed-simd",            false,   "Relaxed SIMD")
+WABT_FEATURE(custom_page_sizes,   "custom-page-sizes",       false,   "Custom page sizes")

include/wabt/interp/interp-inl.h

@@ -64,11 +64,12 @@ inline bool MemoryType::classof(const ExternType* type) {
   return type->kind == skind;
 }
 
-inline MemoryType::MemoryType(Limits limits)
-    : ExternType(ExternKind::Memory), limits(limits) {
+inline MemoryType::MemoryType(Limits limits, uint32_t page_size)
+    : ExternType(ExternKind::Memory), limits(limits), page_size(page_size) {
   // Always set max.
   if (!limits.has_max) {
-    this->limits.max = limits.is_64 ? WABT_MAX_PAGES64 : WABT_MAX_PAGES32;
+    this->limits.max = WABT_BYTES_TO_MIN_PAGES(
+        (limits.is_64 ? UINT64_MAX : UINT32_MAX), page_size);
   }
 }
 

include/wabt/interp/interp.h

@@ -206,7 +206,7 @@ struct MemoryType : ExternType {
   static const ExternKind skind = ExternKind::Memory;
   static bool classof(const ExternType* type);
 
-  explicit MemoryType(Limits);
+  explicit MemoryType(Limits, uint32_t);
 
   std::unique_ptr<ExternType> Clone() const override;
 
@@ -215,6 +215,7 @@ struct MemoryType : ExternType {
                       std::string* out_msg);
 
   Limits limits;
+  uint32_t page_size;
 };
 
 struct GlobalType : ExternType {

include/wabt/ir.h

@@ -947,6 +947,7 @@ struct Memory {
 
   std::string name;
   Limits page_limits;
+  uint32_t page_size;
 };
 
 struct DataSegment {

include/wabt/shared-validator.h

@@ -75,7 +75,7 @@ class SharedValidator {
 
   Result OnFunction(const Location&, Var sig_var);
   Result OnTable(const Location&, Type elem_type, const Limits&);
-  Result OnMemory(const Location&, const Limits&);
+  Result OnMemory(const Location&, const Limits&, uint32_t page_size);
   Result OnGlobalImport(const Location&, Type type, bool mutable_);
   Result OnGlobal(const Location&, Type type, bool mutable_);
   Result OnTag(const Location&, Var sig_var);

include/wabt/token.def

@@ -57,6 +57,7 @@ WABT_TOKEN(NanArithmetic, "nan:arithmetic")
 WABT_TOKEN(NanCanonical, "nan:canonical")
 WABT_TOKEN(Offset, "offset")
 WABT_TOKEN(Output, "output")
+WABT_TOKEN(PageSize, "pagesize")
 WABT_TOKEN(Param, "param")
 WABT_TOKEN(Ref, "ref")
 WABT_TOKEN(Quote, "quote")

include/wabt/wast-parser.h

@@ -147,6 +147,7 @@ class WastParser {
   Result ParseMemidx(Location loc, Var* memidx);
   Result ParseLimitsIndex(Limits*);
   Result ParseLimits(Limits*);
+  Result ParsePageSize(uint32_t*);
   Result ParseNat(uint64_t*, bool is_64);
 
   Result ParseModuleFieldList(Module*);

src/binary-reader-ir.cc

@@ -126,7 +126,8 @@ class BinaryReaderIR : public BinaryReaderNop {
                         std::string_view module_name,
                         std::string_view field_name,
                         Index memory_index,
-                        const Limits* page_limits) override;
+                        const Limits* page_limits,
+                        uint32_t page_size) override;
   Result OnImportGlobal(Index import_index,
                         std::string_view module_name,
                         std::string_view field_name,
@@ -148,7 +149,9 @@ class BinaryReaderIR : public BinaryReaderNop {
                  const Limits* elem_limits) override;
 
   Result OnMemoryCount(Index count) override;
-  Result OnMemory(Index index, const Limits* limits) override;
+  Result OnMemory(Index index,
+                  const Limits* limits,
+                  uint32_t page_size) override;
 
   Result OnGlobalCount(Index count) override;
   Result BeginGlobal(Index index, Type type, bool mutable_) override;
@@ -620,11 +623,13 @@ Result BinaryReaderIR::OnImportMemory(Index import_index,
                                       std::string_view module_name,
                                       std::string_view field_name,
                                       Index memory_index,
-                                      const Limits* page_limits) {
+                                      const Limits* page_limits,
+                                      uint32_t page_size) {
   auto import = std::make_unique<MemoryImport>();
   import->module_name = module_name;
   import->field_name = field_name;
   import->memory.page_limits = *page_limits;
+  import->memory.page_size = page_size;
   if (import->memory.page_limits.is_shared) {
     module_->features_used.threads = true;
   }
@@ -707,10 +712,13 @@ Result BinaryReaderIR::OnMemoryCount(Index count) {
   return Result::Ok;
 }
 
-Result BinaryReaderIR::OnMemory(Index index, const Limits* page_limits) {
+Result BinaryReaderIR::OnMemory(Index index,
+                                const Limits* page_limits,
+                                uint32_t page_size) {
   auto field = std::make_unique<MemoryModuleField>(GetLocation());
   Memory& memory = field->memory;
   memory.page_limits = *page_limits;
+  memory.page_size = page_size;
   if (memory.page_limits.is_shared) {
     module_->features_used.threads = true;
   }

src/binary-reader-logging.cc

@@ -217,14 +217,15 @@ Result BinaryReaderLogging::OnImportMemory(Index import_index,
                                            std::string_view module_name,
                                            std::string_view field_name,
                                            Index memory_index,
-                                           const Limits* page_limits) {
+                                           const Limits* page_limits,
+                                           uint32_t page_size) {
   char buf[100];
   SPrintLimits(buf, sizeof(buf), page_limits);
   LOGF("OnImportMemory(import_index: %" PRIindex ", memory_index: %" PRIindex
        ", %s)\n",
        import_index, memory_index, buf);
   return reader_->OnImportMemory(import_index, module_name, field_name,
-                                 memory_index, page_limits);
+                                 memory_index, page_limits, page_size);
 }
 
 Result BinaryReaderLogging::OnImportGlobal(Index import_index,
@@ -264,11 +265,13 @@ Result BinaryReaderLogging::OnTable(Index index,
   return reader_->OnTable(index, elem_type, elem_limits);
 }
 
-Result BinaryReaderLogging::OnMemory(Index index, const Limits* page_limits) {
+Result BinaryReaderLogging::OnMemory(Index index,
+                                     const Limits* page_limits,
+                                     uint32_t page_size) {
   char buf[100];
   SPrintLimits(buf, sizeof(buf), page_limits);
   LOGF("OnMemory(index: %" PRIindex ", %s)\n", index, buf);
-  return reader_->OnMemory(index, page_limits);
+  return reader_->OnMemory(index, page_limits, page_size);
 }
 
 Result BinaryReaderLogging::BeginGlobal(Index index, Type type, bool mutable_) {

src/binary-reader-objdump.cc

@@ -1059,7 +1059,8 @@ class BinaryReaderObjdump : public BinaryReaderObjdumpBase {
                         std::string_view module_name,
                         std::string_view field_name,
                         Index memory_index,
-                        const Limits* page_limits) override;
+                        const Limits* page_limits,
+                        uint32_t page_size) override;
   Result OnImportGlobal(Index import_index,
                         std::string_view module_name,
                         std::string_view field_name,
@@ -1081,7 +1082,9 @@ class BinaryReaderObjdump : public BinaryReaderObjdumpBase {
                  const Limits* elem_limits) override;
 
   Result OnMemoryCount(Index count) override;
-  Result OnMemory(Index index, const Limits* limits) override;
+  Result OnMemory(Index index,
+                  const Limits* limits,
+                  uint32_t page_size) override;
 
   Result OnGlobalCount(Index count) override;
   Result BeginGlobal(Index index, Type type, bool mutable_) override;
@@ -1563,7 +1566,8 @@ Result BinaryReaderObjdump::OnImportMemory(Index import_index,
                                            std::string_view module_name,
                                            std::string_view field_name,
                                            Index memory_index,
-                                           const Limits* page_limits) {
+                                           const Limits* page_limits,
+                                           uint32_t page_size) {
   PrintDetails(" - memory[%" PRIindex "] pages: initial=%" PRId64, memory_index,
                page_limits->initial);
   if (page_limits->has_max) {
@@ -1575,6 +1579,9 @@ Result BinaryReaderObjdump::OnImportMemory(Index import_index,
   if (page_limits->is_64) {
     PrintDetails(" i64");
   }
+  if (page_size != WABT_DEFAULT_PAGE_SIZE) {
+    PrintDetails(" (pagesize %u)", page_size);
+  }
   PrintDetails(" <- " PRIstringview "." PRIstringview "\n",
                WABT_PRINTF_STRING_VIEW_ARG(module_name),
                WABT_PRINTF_STRING_VIEW_ARG(field_name));
@@ -1615,7 +1622,9 @@ Result BinaryReaderObjdump::OnMemoryCount(Index count) {
   return OnCount(count);
 }
 
-Result BinaryReaderObjdump::OnMemory(Index index, const Limits* page_limits) {
+Result BinaryReaderObjdump::OnMemory(Index index,
+                                     const Limits* page_limits,
+                                     uint32_t page_size) {
   PrintDetails(" - memory[%" PRIindex "] pages: initial=%" PRId64, index,
                page_limits->initial);
   if (page_limits->has_max) {
@@ -1627,6 +1636,9 @@ Result BinaryReaderObjdump::OnMemory(Index index, const Limits* page_limits) {
   if (page_limits->is_64) {
     PrintDetails(" i64");
   }
+  if (page_size != WABT_DEFAULT_PAGE_SIZE) {
+    PrintDetails(" (pagesize %u)", page_size);
+  }
   PrintDetails("\n");
   return Result::Ok;
 }