Implement the basics of component model

Author: zherczeg

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,41 @@ enum class TableInitExprStatus {
   TableWithoutInitExpression,
 };
 
+struct ComponentNamedType {
+  std::string_view name;
+  ComponentType type;
+};
+
+struct ComponentNamedSort {
+  std::string_view name;
+  ComponentSort sort;
+  Index index;
+};
+
+struct ComponentCanonOption {
+  ComponentBinaryCanonOption option;
+  Index index;
+};
+
+struct ComponentExternalInfo {
+  ComponentSort sort;
+  ComponentBinaryExternal external;
+  Index index;
+};
+
+struct ComponentExportInfo {
+  ComponentSort sort;
+  Index index;
+};
+
+struct ComponentNamedExportInfo {
+  std::string_view name;
+  std::string_view version_suffix;
+  ComponentSort sort;
+  bool has_version_suffix;
+  Index index;
+};
+
 class BinaryReaderDelegate {
  public:
   struct State {
@@ -558,11 +593,112 @@ 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 BeginCoreInstanceSection(uint32_t count) = 0;
+  virtual Result EndCoreInstanceSection() = 0;
+  virtual Result OnCoreInstance(uint32_t module_index,
+                                uint32_t argument_count,
+                                ComponentNamedSort* arguments) = 0;
+  virtual Result OnInlineCoreInstance(uint32_t argument_count,
+                                      ComponentNamedSort* arguments) = 0;
+
+  virtual Result BeginInstanceSection(uint32_t count) = 0;
+  virtual Result EndInstanceSection() = 0;
+  virtual Result OnInstance(uint32_t module_index,
+                            uint32_t argument_count,
+                            ComponentNamedSort* arguments) = 0;
+  virtual Result OnInlineInstance(uint32_t argument_count,
+                                  ComponentNamedExportInfo* arguments) = 0;
+
+  virtual Result BeginAliasSection(uint32_t count) = 0;
+  virtual Result EndAliasSection() = 0;
+  virtual Result OnAliasExport(ComponentSort sort,
+                               uint32_t instance_index,
+                               std::string_view name) = 0;
+  virtual Result OnAliasCoreExport(ComponentSort sort,
+                                   uint32_t core_instance_index,
+                                   std::string_view name) = 0;
+  virtual Result OnAliasOuter(ComponentSort sort,
+                              uint32_t counter,
+                              uint32_t index) = 0;
+
+  virtual Result BeginTypeSection(uint32_t count) = 0;
+  virtual Result EndTypeSection() = 0;
+  virtual Result OnPrimitiveType(ComponentType type) = 0;
+  virtual Result OnRecordType(uint32_t field_count,
+                              ComponentNamedType* fields) = 0;
+  virtual Result OnVariantType(uint32_t case_count,
+                               ComponentNamedType* cases) = 0;
+  virtual Result OnListType(ComponentType type) = 0;
+  virtual Result OnListFixedType(ComponentType type, uint32_t size) = 0;
+  virtual Result OnTupleType(uint32_t type_count, ComponentType* types) = 0;
+  virtual Result OnFlagsType(uint32_t flag_count, std::string_view* flags) = 0;
+  virtual Result OnEnumType(uint32_t enum_count, std::string_view* enums) = 0;
+  virtual Result OnOptionType(ComponentType type) = 0;
+  virtual Result OnResultType(ComponentType result, ComponentType error) = 0;
+  virtual Result OnOwnType(Index index) = 0;
+  virtual Result OnBorrowType(Index index) = 0;
+  virtual Result OnStreamType(ComponentType type) = 0;
+  virtual Result OnFutureType(ComponentType type) = 0;
+  virtual Result OnFuncType(ComponentBinaryType type,
+                            uint32_t param_count,
+                            ComponentNamedType* 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;
+
+  virtual Result BeginCanonSection(uint32_t count) = 0;
+  virtual Result EndCanonSection() = 0;
+  virtual Result OnCanonLift(Index core_func_index,
+                             uint32_t option_count,
+                             ComponentCanonOption* options,
+                             Index type_index) = 0;
+  virtual Result OnCanonLower(Index func_index,
+                              uint32_t option_count,
+                              ComponentCanonOption* options) = 0;
+  virtual Result OnCanonType(ComponentBinaryCanon canon, Index type_index) = 0;
+
+  virtual Result BeginImportSection(uint32_t count) = 0;
+  virtual Result EndImportSection() = 0;
+  virtual Result OnImport(std::string_view external_name,
+                          std::string_view* version_suffix,
+                          ComponentExternalInfo* external_info) = 0;
+
+  virtual Result BeginExportSection(uint32_t count) = 0;
+  virtual Result EndExportSection() = 0;
+  virtual Result OnExport(std::string_view external_name,
+                          std::string_view* version_suffix,
+                          ComponentExternalInfo* external_info,
+                          ComponentExportInfo* export_info) = 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);
+
+bool ReadBinaryIsComponent(const void* data, size_t size);
+
 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,112 @@ enum class NameSectionSubsection {
 };
 const char* GetNameSectionSubsectionName(NameSectionSubsection subsec);
 
+enum class ComponentBinarySection : uint8_t {
+  // Same as ComponentDef::Type in ir.h.
+  Custom = 0,
+  CoreModule = 1,
+  CoreInstance = 2,
+  CoreType = 3,
+  Component = 4,
+  Instance = 5,
+  Alias = 6,
+  Type = 7,
+  Canon = 8,
+  Import = 10,
+  Export = 11,
+};
+
+enum class ComponentBinarySort : uint8_t {
+  Core = 0x00,
+  Func = 0x01,
+  Value = 0x02,
+  Type = 0x03,
+  Component = 0x04,
+  Instance = 0x05,
+};
+
+enum class ComponentBinaryCoreSort : uint8_t {
+  Func = 0x00,
+  Table = 0x01,
+  Memory = 0x02,
+  Global = 0x03,
+  Type = 0x10,
+  Module = 0x11,
+  Instance = 0x12,
+  NonCore = 0xff,
+};
+
+enum class ComponentBinaryInstance : uint8_t {
+  Reference = 0x00,
+  Inline = 0x01,
+};
+
+enum class ComponentBinaryAlias : uint8_t {
+  Export = 0x00,
+  CoreExport = 0x01,
+  Outer = 0x02,
+};
+
+enum class ComponentBinaryType : uint8_t {
+  None = 0,
+  Some = 1,
+
+  ResultSome = 0,
+  ResultNone = 1,
+
+  // Types
+  Record = 0x72,
+  Variant = 0x71,
+  List = 0x70,
+  Tuple = 0x6f,
+  Flags = 0x6e,
+  Enum = 0x6d,
+  Option = 0x6b,
+  Result = 0x6a,
+  Own = 0x69,
+  Borrow = 0x68,
+  Stream = 0x66,
+  Future = 0x65,
+  ListFixed = 0x67,
+  AsyncFunc = 0x43,
+  Instance = 0x42,
+  Component = 0x41,
+  Func = 0x40,
+};
+
+enum class ComponentBinaryInterface : uint8_t {
+  CoreType = 0,
+  Type = 1,
+  Alias = 2,
+  Import = 3,
+  Export = 4,
+};
+
+enum class ComponentBinaryCanon : uint8_t {
+  Lift = 0x00,
+  Lower = 0x01,
+  ResourceDrop = 0x03,
+};
+
+enum class ComponentBinaryCanonOption : uint8_t {
+  StrEncUtf8 = 0x00,
+  StrEncUtf16 = 0x01,
+  StrEncLatin1Utf16 = 0x02,
+  Memory = 0x03,
+  Realloc = 0x04,
+  PostReturn = 0x05,
+  Async = 0x06,
+  Callback = 0x07,
+};
+
+enum class ComponentBinaryExternal : uint8_t {
+  ValueEq = 0x00,
+  ValueType = 0x01,
+  TypeEq = 0x00,
+  TypeSubRes = 0x01,
+  Unused = 0xff,
+};
+
 }  // namespace wabt
 
 #endif /* WABT_BINARY_H_ */