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 {
 
+class 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

@@ -78,6 +78,11 @@ enum class TableInitExprStatus {
   TableWithoutInitExpression,
 };
 
+struct ComponentFuncParam {
+  std::string_view name;
+  ComponentType type;
+};
+
 class BinaryReaderDelegate {
  public:
   struct State {
@@ -555,11 +560,47 @@ 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;
+
+  virtual Result BeginTypeSection(uint32_t count) = 0;
+  virtual Result EndTypeSection() = 0;
+
+  virtual Result OnPrimitiveType(ComponentType type) = 0;
+  virtual Result OnOptionType(ComponentType type) = 0;
+  virtual Result OnResultType(ComponentType result, ComponentType error) = 0;
+  virtual Result OnFuncType(ComponentBinaryType type,
+                            uint32_t param_count,
+                            ComponentFuncParam* params,
+                            ComponentType result) = 0;
+  virtual Result BeginInstanceType(uint32_t count) = 0;
+  virtual Result EndInstanceType() = 0;
+  virtual Result BeginComponentType(uint32_t count) = 0;
+  virtual Result EndComponentType() = 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 {
 
+class 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,40 @@ enum class NameSectionSubsection {
 };
 const char* GetNameSectionSubsectionName(NameSectionSubsection subsec);
 
+enum class ComponentBinarySection : uint8_t {
+  // Same as ComponentDefinition::Type in ir.h.
+  CoreModule = 1,
+  CoreInstance = 2,
+  CoreType = 3,
+  Component = 4,
+  Instance = 5,
+  Type = 7,
+};
+
+enum class ComponentBinaryType : uint8_t {
+  None = 0,
+  Some = 1,
+
+  ResultSome = 0,
+  ResultNone = 1,
+
+  // Types
+  Option = 0x6b,
+  Result = 0x6a,
+  AsyncFunc = 0x43,
+  Instance = 0x42,
+  Component = 0x41,
+  Func = 0x40,
+};
+
+enum class ComponentBinaryInterface : uint8_t {
+  CoreType = 0,
+  Type = 1,
+  Alias = 2,
+  Import = 3,
+  Export = 4,
+};
+
 }  // namespace wabt
 
 #endif /* WABT_BINARY_H_ */

include/wabt/ir.h

@@ -1702,6 +1702,234 @@ struct Script {
   BindingHash module_bindings;
 };
 
+class Component;
+class ComponentTypeContainer;
+class ComponentCoreModule;
+class ComponentValueType;
+class ComponentTypeResult;
+class ComponentTypeFunc;
+
+class ComponentDefinition {
+ public:
+  enum class Section : uint8_t {
+    // Same as ComponentBinarySection in binary.h.
+    // Section types.
+    CoreModule = 1,
+    CoreInstance = 2,
+    CoreType = 3,
+    Component = 4,
+    Instance = 5,
+    Type = 7,
+  };
+
+  // Subtype for Section::Type
+  enum class Type : uint8_t {
+    Unused = 0,
+    ValueType = 1,
+
+    // Types
+    Option = 0x6b,
+    Result = 0x6a,
+    AsyncFunc = 0x43,
+    Instance = 0x42,
+    Component = 0x41,
+    Func = 0x40,
+  };
+
+  virtual ~ComponentDefinition() {}
+
+  Section section() const {
+    return section_;
+  }
+
+  Type type() const {
+    return type_;
+  }
+
+  const Component* AsComponent() const {
+    assert(section() == Section::Component);
+    return reinterpret_cast<const Component*>(this);
+  }
+
+  const ComponentTypeContainer* AsTypeContainer() const {
+    assert(section() == Section::Type &&
+           (type() == Type::Instance || type() == Type::Component));
+    return reinterpret_cast<const ComponentTypeContainer*>(this);
+  }
+
+  const ComponentCoreModule* AsCoreModule() const {
+    assert(section() == Section::CoreModule);
+    return reinterpret_cast<const ComponentCoreModule*>(this);
+  }
+
+  const ComponentValueType* AsValueType() const {
+    assert(IsValueType());
+    return reinterpret_cast<const ComponentValueType*>(this);
+  }
+
+  const ComponentTypeResult* AsTypeResult() const {
+    assert(section() == Section::Type && type() == Type::Result);
+    return reinterpret_cast<const ComponentTypeResult*>(this);
+  }
+
+  const ComponentTypeFunc* AsTypeFunc() const {
+    assert(section() == Section::Type && type() == Type::Func);
+    return reinterpret_cast<const ComponentTypeFunc*>(this);
+  }
+
+  bool IsValueType() const {
+    return type_ == Type::ValueType || type_ == Type::Option;
+  }
+
+  bool IsValueTypeOpt() const {
+    return false;
+  }
+
+ protected:
+  ComponentDefinition(Section section, Type type = Type::Unused)
+      : section_(section), type_(type) {
+    assert(section == Section::Type ? type != Type::Unused : type == Type::Unused);
+  }
+
+ private:
+  Section section_;
+  // Secondary, optional type field.
+  Type type_;
+};
+
+class ComponentContainer : public ComponentDefinition {
+ public:
+  const ComponentContainer* GetParent() const {
+    return parent_;
+  }
+  bool IsComponent() const {
+    return section() == Section::Component;
+  }
+  bool IsInstanceType() const {
+    return section() == Section::Type && type() == Type::Instance;
+  }
+  bool IsComponentType() const {
+    return section() == Section::Type && type() == Type::Component;
+  }
+
+  size_t Size() const {
+    return list_.size();
+  }
+
+  const ComponentDefinition* Get(size_t idx) const {
+    return list_[idx].get();
+  }
+
+  void Append(std::unique_ptr<ComponentDefinition> type) {
+    list_.push_back(std::move(type));
+  }
+
+  Index AppendType(std::unique_ptr<ComponentDefinition> type);
+
+ protected:
+  ComponentContainer(const ComponentContainer* parent,
+                     Section section,
+                     Type type = Type::Unused)
+      : ComponentDefinition(section, type), parent_(parent) {
+    assert(IsComponent() || IsInstanceType() || IsComponentType());
+  }
+
+ private:
+  const ComponentContainer* parent_;
+  std::vector<std::unique_ptr<ComponentDefinition>> list_;
+  std::vector<ComponentDefinition*> type_list_;
+};
+
+class ComponentTypeContainer : public ComponentContainer {
+ public:
+  ComponentTypeContainer(const ComponentContainer* parent, bool is_component)
+      : ComponentContainer(parent, Section::Type,
+                           is_component ? Type::Component : Type::Instance) {}
+};
+
+class ComponentCoreModule : public ComponentDefinition {
+ public:
+  ComponentCoreModule()
+      : ComponentDefinition(Section::CoreModule) {}
+
+  const Module* module() const {
+    return &module_;
+  }
+
+  Module* module() {
+    return &module_;
+  }
+
+ private:
+  Module module_;
+};
+
+class ComponentValueType : public ComponentDefinition {
+ public:
+  ComponentValueType(Type type, ComponentType value_type)
+      : ComponentDefinition(Section::Type, type), value_type_(value_type) {
+    assert(IsValueType() && !value_type_.IsNone());
+  }
+
+  const ComponentType& ValueType() const {
+    return value_type_;
+  }
+
+ private:
+  ComponentType value_type_;
+};
+
+class ComponentTypeResult : public ComponentDefinition {
+ public:
+  ComponentTypeResult(ComponentType result, ComponentType error)
+      : ComponentDefinition(Section::Type, Type::Result), result_(result), error_(error) {}
+
+  const ComponentType& result() const { return result_; }
+  const ComponentType& error() const { return error_; }
+
+ private:
+  ComponentType result_;
+  ComponentType error_;
+};
+
+class ComponentTypeFunc : public ComponentDefinition {
+ public:
+  struct Param {
+    std::string name;
+    ComponentType type;
+  };
+
+  ComponentTypeFunc(bool is_async, std::vector<Param>* params,
+                    ComponentType& result)
+      : ComponentDefinition(Section::Type,
+                            is_async ? Type::AsyncFunc : Type::Func),
+        result_(result) {
+    params_ = std::move(*params);
+  }
+
+  const std::vector<Param>& params() const {
+    return params_;
+  }
+
+  const ComponentType& result() const {
+    return result_;
+  }
+
+ private:
+  std::vector<Param> params_;
+  ComponentType result_;
+};
+
+class Component : public ComponentContainer {
+ public:
+  Component(const Component* parent)
+      : ComponentContainer(parent, Section::Component) {}
+
+  const Component* GetParentComponent() const {
+    return GetParent()->AsComponent();
+  }
+};
+
 void MakeTypeBindingReverseMapping(
     size_t num_types,
     const BindingHash& bindings,