Implement the basics of component model

Author: zherczeg

CMakeLists.txt

@@ -300,6 +300,7 @@ set(WABT_LIBRARY_CC
   src/binding-hash.cc
   src/color.cc
   src/common.cc
+  src/component.cc
   src/config.cc
   src/config.h.in
   src/decompiler.cc

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

@@ -23,6 +23,7 @@
 
 #include "wabt/binary.h"
 #include "wabt/common.h"
+#include "wabt/component.h"
 #include "wabt/error.h"
 #include "wabt/feature.h"
 #include "wabt/opcode.h"
@@ -558,11 +559,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(ComponentTypeDef 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,59 @@ enum class NameSectionSubsection {
 };
 const char* GetNameSectionSubsectionName(NameSectionSubsection subsec);
 
+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,
+};
+
+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,
+};
+
 }  // namespace wabt
 
 #endif /* WABT_BINARY_H_ */

include/wabt/component.h

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2016 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WABT_COMPONENT_H_
+#define WABT_COMPONENT_H_
+
+#include "wabt/common.h"
+
+namespace wabt {
+
+// Contains data structures used by the component model.
+
+enum class ComponentSection : uint8_t {
+  Custom = 0,
+  CoreModule = 1,
+  CoreInstance = 2,
+  CoreType = 3,
+  Component = 4,
+  Instance = 5,
+  Alias = 6,
+  Type = 7,
+  Canon = 8,
+  Import = 10,
+  Export = 11,
+};
+
+class ComponentSort {
+ public:
+  enum Enum : uint8_t {
+    CoreFunc,
+    CoreTable,
+    CoreMemory,
+    CoreGlobal,
+    CoreType,
+    CoreModule,
+    CoreInstance,
+    Func,
+    Value,
+    Type,
+    Component,
+    Instance,
+    Invalid,
+  };
+
+  ComponentSort(Enum sort)
+      : sort_(sort) {}
+
+  ComponentSort()
+      : sort_(Invalid) {}
+
+  constexpr operator Enum() const { return sort_; }
+
+  const char* GetName() const;
+  const char* GetCoreName() const;
+
+ private:
+  Enum sort_;
+};
+
+// Composite type definitions.
+enum class ComponentTypeDef : uint8_t {
+  ValueType = 0,
+
+  // 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 ComponentExternalDesc : uint8_t {
+  ValueEq = 0x00,
+  ValueType = 0x01,
+  TypeEq = 0x00,
+  TypeSubRes = 0x01,
+  Unused = 0xff,
+};
+
+struct ComponentNamedType {
+  std::string_view name;
+  ComponentType type;
+};
+
+struct ComponentNamedSort {
+  std::string_view name;
+  ComponentSort sort;
+  Index index;
+};
+
+struct ComponentCanonOption {
+  enum Option : uint8_t {
+    StrEncUtf8 = 0x00,
+    StrEncUtf16 = 0x01,
+    StrEncLatin1Utf16 = 0x02,
+    Memory = 0x03,
+    Realloc = 0x04,
+    PostReturn = 0x05,
+    Async = 0x06,
+    Callback = 0x07,
+  };
+
+  Option option;
+  Index index;
+};
+
+struct ComponentExternalInfo {
+  ComponentSort sort;
+  ComponentExternalDesc 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;
+};
+
+}  // namespace wabt
+
+#endif  // WABT_DECOMPILER_AST_H_