Implement the basics of component model

Author: zherczeg

CMakeLists.txt

@@ -641,6 +641,13 @@ if (BUILD_TOOLS)
     INSTALL
   )
 
+  # component
+  wabt_executable(
+    NAME component
+    SOURCES src/tools/component.cc
+    INSTALL
+  )
+
   if(BUILD_FUZZ_TOOLS)
     # wasm2wat-fuzz
     wabt_executable(

include/wabt/binary-reader-ir.h

@@ -22,6 +22,7 @@
 
 namespace wabt {
 
+struct Component;
 struct Module;
 struct ReadBinaryOptions;
 
@@ -32,6 +33,13 @@ Result ReadBinaryIr(const char* filename,
                     Errors*,
                     Module* out_module);
 
+Result ReadBinaryComponentIr(const char* filename,
+                             const void* data,
+                             size_t size,
+                             const ReadBinaryOptions& options,
+                             Errors*,
+                             Component* out_component);
+
 }  // namespace wabt
 
 #endif /* WABT_BINARY_READER_IR_H_ */

include/wabt/binary-reader.h

@@ -555,11 +555,32 @@ class BinaryReaderDelegate {
   const State* state = nullptr;
 };
 
+class ComponentBinaryReaderDelegate {
+ public:
+  virtual ~ComponentBinaryReaderDelegate() {}
+
+  virtual bool OnError(const Error&) = 0;
+  virtual void OnSetState(const BinaryReaderDelegate::State* s) { state = s; }
+
+  virtual Result OnCoreModule(const void* data,
+                              size_t size,
+                              const ReadBinaryOptions& options) = 0;
+  virtual Result BeginComponent(uint32_t version, size_t depth) = 0;
+  virtual Result EndComponent() = 0;
+
+  const BinaryReaderDelegate::State* state = nullptr;
+};
+
 Result ReadBinary(const void* data,
                   size_t size,
                   BinaryReaderDelegate* reader,
                   const ReadBinaryOptions& options);
 
+Result ReadBinaryComponent(const void* data,
+                           size_t size,
+                           ComponentBinaryReaderDelegate* component_delegate,
+                           const ReadBinaryOptions& options);
+
 size_t ReadU32Leb128(const uint8_t* ptr,
                      const uint8_t* end,
                      uint32_t* out_value);

include/wabt/binary-writer.h

@@ -24,6 +24,7 @@
 
 namespace wabt {
 
+struct Component;
 struct Module;
 struct Script;
 
@@ -45,6 +46,7 @@ struct WriteBinaryOptions {
 };
 
 Result WriteBinaryModule(Stream*, const Module*, const WriteBinaryOptions&);
+Result WriteBinaryComponent(Stream*, const Component*, const WriteBinaryOptions&);
 
 void WriteType(Stream* stream, Type type, const char* desc = nullptr);
 

include/wabt/binary.h

@@ -21,6 +21,7 @@
 
 #define WABT_BINARY_MAGIC 0x6d736100
 #define WABT_BINARY_VERSION 1
+#define WABT_BINARY_COMPONENT_VERSION 0xd
 #define WABT_BINARY_LAYER_MODULE 0
 #define WABT_BINARY_LAYER_COMPONENT 1
 #define WABT_BINARY_LIMITS_HAS_MAX_FLAG 0x1
@@ -104,6 +105,15 @@ enum class NameSectionSubsection {
 };
 const char* GetNameSectionSubsectionName(NameSectionSubsection subsec);
 
+enum class ComponentBinarySection : uint8_t {
+  // Same as ComponentType in ir.h
+  CoreModule = 1,
+  CoreInstance = 2,
+  CoreType = 3,
+  Component = 4,
+  Instance = 5,
+};
+
 }  // namespace wabt
 
 #endif /* WABT_BINARY_H_ */

include/wabt/ir.h

@@ -1702,6 +1702,78 @@ struct Script {
   BindingHash module_bindings;
 };
 
+struct Component;
+class ComponentCoreModule;
+class ComponentComponent;
+
+class ComponentDefinition {
+ public:
+  enum class Type {
+    // Same as ComponentBinarySection in binary.h
+    CoreModule = 1,
+    CoreInstance = 2,
+    CoreType = 3,
+    Component = 4,
+    Instance = 5,
+  };
+
+  virtual ~ComponentDefinition() {}
+
+  Type type() const {
+    return type_;
+  }
+
+  ComponentCoreModule* AsCoreModule() {
+    assert(type() == Type::CoreModule);
+    return reinterpret_cast<ComponentCoreModule*>(this);
+  }
+
+  ComponentComponent* AsComponent() {
+    assert(type() == Type::Component);
+    return reinterpret_cast<ComponentComponent*>(this);
+  }
+
+ protected:
+  ComponentDefinition(Type type)
+      : type_(type) {}
+
+ private:
+  Type type_;
+};
+
+class ComponentCoreModule : public ComponentDefinition {
+ public:
+  ComponentCoreModule()
+      : ComponentDefinition(Type::CoreModule) {}
+
+  Module* module() {
+    return &module_;
+  }
+
+ private:
+  Module module_;
+};
+
+struct Component {
+  Component* parent = nullptr;
+  std::vector<std::unique_ptr<ComponentDefinition>> definitions;
+};
+
+class ComponentComponent : public ComponentDefinition {
+ public:
+  ComponentComponent(Component* parent)
+      : ComponentDefinition(Type::Component) {
+    component_.parent = parent;
+  }
+
+  Component* component() {
+    return &component_;
+  }
+
+ private:
+  Component component_;
+};
+
 void MakeTypeBindingReverseMapping(
     size_t num_types,
     const BindingHash& bindings,

include/wabt/token.def

@@ -31,6 +31,8 @@ WABT_TOKEN(AssertUnlinkable, "assert_unlinkable")
 WABT_TOKEN(Before, "before")
 WABT_TOKEN(Bin, "bin")
 WABT_TOKEN(Item, "item")
+WABT_TOKEN(Component, "component")
+WABT_TOKEN(Core, "core")
 WABT_TOKEN(Data, "data")
 WABT_TOKEN(Declare, "declare")
 WABT_TOKEN(Delegate, "delegate")
@@ -48,6 +50,7 @@ WABT_TOKEN(Global, "global")
 WABT_TOKEN(Import, "import")
 WABT_TOKEN(Invoke, "invoke")
 WABT_TOKEN(Input, "input")
+WABT_TOKEN(Instance, "instance")
 WABT_TOKEN(Local, "local")
 WABT_TOKEN(Lpar, "(")
 WABT_TOKEN(Memory, "memory")

include/wabt/wast-parser.h

@@ -47,6 +47,7 @@ class WastParser {
   void WABT_PRINTF_FORMAT(3, 4) Error(Location, const char* format, ...);
   Result ParseModule(std::unique_ptr<Module>* out_module);
   Result ParseScript(std::unique_ptr<Script>* out_script);
+  Result ParseComponent(std::unique_ptr<Component>* out_component);
 
   std::unique_ptr<Script> ReleaseScript();
 
@@ -281,6 +282,7 @@ class WastParser {
 
   Result ParseCommandList(Script*, CommandPtrVector*);
   Result ParseCommand(Script*, CommandPtr*);
+  Result ParseComponent(Component*);
   Result ParseAssertExceptionCommand(CommandPtr*);
   Result ParseAssertExhaustionCommand(CommandPtr*);
   Result ParseAssertInvalidCommand(CommandPtr*);
@@ -367,6 +369,11 @@ Result ParseWastScript(WastLexer* lexer,
                        Errors*,
                        WastParseOptions* options);
 
+Result ParseWatComponent(WastLexer* lexer,
+                         std::unique_ptr<Component>* out_component,
+                         Errors*,
+                         WastParseOptions* options);
+
 }  // namespace wabt
 
 #endif /* WABT_WAST_PARSER_H_ */

include/wabt/wat-writer.h

@@ -22,6 +22,7 @@
 
 namespace wabt {
 
+struct Component;
 struct Module;
 class Stream;
 
@@ -35,6 +36,7 @@ struct WriteWatOptions {
 };
 
 Result WriteWat(Stream*, const Module*, const WriteWatOptions&);
+Result WriteComponentWat(Stream*, const Component*, const WriteWatOptions&);
 
 }  // namespace wabt
 

src/binary-reader-ir.cc

@@ -2039,6 +2039,58 @@ Result BinaryReaderIR::OnGenericCustomSection(std::string_view name,
   return Result::Ok;
 }
 
+class BinaryReaderComponentIR : public ComponentBinaryReaderDelegate {
+ public:
+  BinaryReaderComponentIR(Component* out_component,
+                          const char* filename,
+                          Errors* errors);
+
+ private:
+  bool OnError(const Error&) override { return false; }
+
+  Result OnCoreModule(const void* data,
+                      size_t size,
+                      const ReadBinaryOptions& options) override;
+  Result BeginComponent(uint32_t version, size_t depth) override;
+  Result EndComponent() override;
+
+  Errors* errors_ = nullptr;
+  Component* component_ = nullptr;
+
+  const char* filename_;
+};
+
+BinaryReaderComponentIR::BinaryReaderComponentIR(Component* out_component,
+                                                 const char* filename,
+                                                 Errors* errors)
+    : errors_(errors), component_(out_component), filename_(filename) {}
+
+Result BinaryReaderComponentIR::OnCoreModule(const void* data,
+                                             size_t size,
+                                             const ReadBinaryOptions& options) {
+  auto coreModule = std::make_unique<ComponentCoreModule>();
+  BinaryReaderIR reader(coreModule->module(), filename_, errors_);
+  CHECK_RESULT(ReadBinary(data, size, &reader, options));
+  component_->definitions.push_back(std::move(coreModule));
+  return Result::Ok;
+}
+
+Result BinaryReaderComponentIR::BeginComponent(uint32_t version, size_t depth) {
+  if (depth == 0) {
+    return Result::Ok;
+  }
+  auto innerComponent = std::make_unique<ComponentComponent>(component_);
+  Component* parent = component_;
+  component_ = innerComponent->component();
+  parent->definitions.push_back(std::move(innerComponent));
+  return Result::Ok;
+}
+
+Result BinaryReaderComponentIR::EndComponent() {
+  component_ = component_->parent;
+  return Result::Ok;
+}
+
 }  // end anonymous namespace
 
 Result ReadBinaryIr(const char* filename,
@@ -2051,4 +2103,14 @@ Result ReadBinaryIr(const char* filename,
   return ReadBinary(data, size, &reader, options);
 }
 
+Result ReadBinaryComponentIr(const char* filename,
+                             const void* data,
+                             size_t size,
+                             const ReadBinaryOptions& options,
+                             Errors* errors,
+                             Component* out_component) {
+  BinaryReaderComponentIR reader(out_component, filename, errors);
+  return ReadBinaryComponent(data, size, &reader, options);
+}
+
 }  // namespace wabt