Implement changes of function reference proposal

Author: Zoltan Herczeg

include/wabt/ir.h

@@ -36,7 +36,7 @@ namespace wabt {
 
 struct Module;
 
-enum class VarType {
+enum class VarType : uint16_t {
   Index,
   Name,
 };
@@ -45,6 +45,7 @@ struct Var {
   explicit Var();
   explicit Var(Index index, const Location& loc);
   explicit Var(std::string_view name, const Location& loc);
+  explicit Var(Type type, const Location& loc);
   Var(Var&&);
   Var(const Var&);
   Var& operator=(const Var&);
@@ -54,6 +55,7 @@ struct Var {
   VarType type() const { return type_; }
   bool is_index() const { return type_ == VarType::Index; }
   bool is_name() const { return type_ == VarType::Name; }
+  bool has_opt_type() const { return opt_type_ < 0; }
 
   Index index() const {
     assert(is_index());
@@ -63,17 +65,25 @@ struct Var {
     assert(is_name());
     return name_;
   }
+  Type::Enum opt_type() const {
+    assert(has_opt_type());
+    return static_cast<Type::Enum>(opt_type_);
+  }
 
   void set_index(Index);
   void set_name(std::string&&);
   void set_name(std::string_view);
+  void set_opt_type(Type::Enum);
+  Type to_type() const;
 
   Location loc;
 
  private:
   void Destroy();
 
   VarType type_;
+  // Can be set to Type::Enum types, 0 represent no optional type.
+  int16_t opt_type_;
   union {
     Index index_;
     std::string name_;
@@ -544,10 +554,10 @@ using MemoryCopyExpr = MemoryBinaryExpr<ExprType::MemoryCopy>;
 template <ExprType TypeEnum>
 class RefTypeExpr : public ExprMixin<TypeEnum> {
  public:
-  RefTypeExpr(Type type, const Location& loc = Location())
+  RefTypeExpr(Var type, const Location& loc = Location())
       : ExprMixin<TypeEnum>(loc), type(type) {}
 
-  Type type;
+  Var type;
 };
 
 using RefNullExpr = RefTypeExpr<ExprType::RefNull>;
@@ -734,9 +744,7 @@ class CallRefExpr : public ExprMixin<ExprType::CallRef> {
   explicit CallRefExpr(const Location& loc = Location())
       : ExprMixin<ExprType::CallRef>(loc) {}
 
-  // This field is setup only during Validate phase,
-  // so keep that in mind when you use it.
-  Var function_type_index;
+  Var function_type;
 };
 
 template <ExprType TypeEnum>
@@ -924,6 +932,8 @@ struct Func {
 
   std::string name;
   FuncDeclaration decl;
+  // Contains references with unknown indicies.
+  TypeVector local_type_list;
   LocalTypes local_types;
   BindingHash bindings;
   ExprList exprs;
@@ -941,7 +951,7 @@ struct Global {
   explicit Global(std::string_view name) : name(name) {}
 
   std::string name;
-  Type type = Type::Void;
+  Var type;
   bool mutable_ = false;
   ExprList init_expr;
 };

include/wabt/leb128.h

@@ -63,6 +63,7 @@ void WriteS32Leb128(Stream* stream, T value, const char* desc) {
 size_t ReadU32Leb128(const uint8_t* p, const uint8_t* end, uint32_t* out_value);
 size_t ReadU64Leb128(const uint8_t* p, const uint8_t* end, uint64_t* out_value);
 size_t ReadS32Leb128(const uint8_t* p, const uint8_t* end, uint32_t* out_value);
+size_t ReadS33Leb128(const uint8_t* p, const uint8_t* end, uint64_t* out_value);
 size_t ReadS64Leb128(const uint8_t* p, const uint8_t* end, uint64_t* out_value);
 
 }  // namespace wabt

include/wabt/shared-validator.h

@@ -43,6 +43,7 @@ struct ValidateOptions {
 class SharedValidator {
  public:
   WABT_DISALLOW_COPY_AND_ASSIGN(SharedValidator);
+  using FuncType = TypeChecker::FuncType;
   SharedValidator(Errors*, const ValidateOptions& options);
 
   // TODO: Move into SharedValidator?
@@ -140,7 +141,7 @@ class SharedValidator {
   Result EndBrTable(const Location&);
   Result OnCall(const Location&, Var func_var);
   Result OnCallIndirect(const Location&, Var sig_var, Var table_var);
-  Result OnCallRef(const Location&, Index* function_type_index);
+  Result OnCallRef(const Location&, Var function_type_var);
   Result OnCatch(const Location&, Var tag_var, bool is_catch_all);
   Result OnCompare(const Location&, Opcode);
   Result OnConst(const Location&, Type);
@@ -177,7 +178,7 @@ class SharedValidator {
   Result OnNop(const Location&);
   Result OnRefFunc(const Location&, Var func_var);
   Result OnRefIsNull(const Location&);
-  Result OnRefNull(const Location&, Type type);
+  Result OnRefNull(const Location&, Var func_type_var);
   Result OnRethrow(const Location&, Var depth);
   Result OnReturnCall(const Location&, Var func_var);
   Result OnReturnCallIndirect(const Location&, Var sig_var, Var table_var);
@@ -220,18 +221,6 @@ class SharedValidator {
   Result OnUnreachable(const Location&);
 
  private:
-  struct FuncType {
-    FuncType() = default;
-    FuncType(const TypeVector& params,
-             const TypeVector& results,
-             Index type_index)
-        : params(params), results(results), type_index(type_index) {}
-
-    TypeVector params;
-    TypeVector results;
-    Index type_index;
-  };
-
   struct StructType {
     StructType() = default;
     StructType(const TypeMutVector& fields) : fields(fields) {}

include/wabt/token.def

@@ -55,6 +55,7 @@ WABT_TOKEN(Module, "module")
 WABT_TOKEN(Mut, "mut")
 WABT_TOKEN(NanArithmetic, "nan:arithmetic")
 WABT_TOKEN(NanCanonical, "nan:canonical")
+WABT_TOKEN(Null, "null")
 WABT_TOKEN(Offset, "offset")
 WABT_TOKEN(Output, "output")
 WABT_TOKEN(PageSize, "pagesize")

include/wabt/type-checker.h

@@ -20,6 +20,7 @@
 #include <functional>
 #include <type_traits>
 #include <vector>
+#include <map>
 
 #include "wabt/common.h"
 #include "wabt/feature.h"
@@ -31,6 +32,18 @@ class TypeChecker {
  public:
   using ErrorCallback = std::function<void(const char* msg)>;
 
+  struct FuncType {
+    FuncType() = default;
+    FuncType(const TypeVector& params,
+             const TypeVector& results,
+             Index type_index)
+        : params(params), results(results), type_index(type_index) {}
+
+    TypeVector params;
+    TypeVector results;
+    Index type_index;
+  };
+
   struct Label {
     Label(LabelType,
           const TypeVector& param_types,
@@ -48,7 +61,8 @@ class TypeChecker {
     bool unreachable;
   };
 
-  explicit TypeChecker(const Features& features) : features_(features) {}
+  explicit TypeChecker(const Features& features, std::map<Index, FuncType>& func_types)
+    : features_(features), func_types_(func_types) {}
 
   void set_error_callback(const ErrorCallback& error_callback) {
     error_callback_ = error_callback;
@@ -80,7 +94,7 @@ class TypeChecker {
   Result OnCallIndirect(const TypeVector& param_types,
                         const TypeVector& result_types,
                         const Limits& table_limits);
-  Result OnIndexedFuncRef(Index* out_index);
+  Result OnCallRef(Type);
   Result OnReturnCall(const TypeVector& param_types,
                       const TypeVector& result_types);
   Result OnReturnCallIndirect(const TypeVector& param_types,
@@ -141,7 +155,7 @@ class TypeChecker {
   Result BeginInitExpr(Type type);
   Result EndInitExpr();
 
-  static Result CheckType(Type actual, Type expected);
+  Result CheckType(Type actual, Type expected);
 
  private:
   void WABT_PRINTF_FORMAT(2, 3) PrintError(const char* fmt, ...);
@@ -210,6 +224,7 @@ class TypeChecker {
   // to represent "any".
   TypeVector* br_table_sig_ = nullptr;
   Features features_;
+  std::map<Index, FuncType>& func_types_;
 };
 
 }  // namespace wabt

include/wabt/type.h

@@ -46,6 +46,8 @@ class Type {
     FuncRef = -0x10,    // 0x70
     ExternRef = -0x11,  // 0x6f
     Reference = -0x15,  // 0x6b
+    Ref = -0x1c,        // 0x64
+    RefNull = -0x1d,    // 0x63
     Func = -0x20,       // 0x60
     Struct = -0x21,     // 0x5f
     Array = -0x22,      // 0x5e
@@ -63,20 +65,24 @@ class Type {
       : enum_(static_cast<Enum>(code)), type_index_(kInvalidIndex) {}
   Type(Enum e) : enum_(e), type_index_(kInvalidIndex) {}
   Type(Enum e, Index type_index) : enum_(e), type_index_(type_index) {
-    assert(e == Enum::Reference);
+    assert(e == Enum::Reference || e == Enum::Ref ||
+           e == Enum::RefNull || type_index == kInvalidIndex);
   }
   constexpr operator Enum() const { return enum_; }
 
-  bool IsRef() const {
+  bool IsNullableRef() const {
     return enum_ == Type::ExternRef || enum_ == Type::FuncRef ||
-           enum_ == Type::Reference || enum_ == Type::ExnRef;
+           enum_ == Type::Reference || enum_ == Type::ExnRef ||
+           enum_ == Type::RefNull;
   }
 
-  bool IsReferenceWithIndex() const { return enum_ == Type::Reference; }
+  bool IsRef() const {
+    return IsNullableRef() || enum_ == Type::Ref;
+  }
 
-  bool IsNullableRef() const {
-    // Currently all reftypes are nullable
-    return IsRef();
+  bool IsReferenceWithIndex() const {
+    return enum_ == Type::Reference || enum_ == Type::Ref ||
+           enum_ == Type::RefNull;
   }
 
   std::string GetName() const {
@@ -95,7 +101,10 @@ class Type {
       case Type::Any:       return "any";
       case Type::ExternRef: return "externref";
       case Type::Reference:
+      case Type::Ref:
         return StringPrintf("(ref %d)", type_index_);
+      case Type::RefNull:
+        return StringPrintf("(ref null %d)", type_index_);
       default:
         return StringPrintf("<type_index[%d]>", enum_);
     }
@@ -132,7 +141,7 @@ class Type {
   }
 
   Index GetReferenceIndex() const {
-    assert(enum_ == Enum::Reference);
+    assert(IsReferenceWithIndex());
     return type_index_;
   }
 
@@ -151,6 +160,8 @@ class Type {
       case Type::ExnRef:
       case Type::ExternRef:
       case Type::Reference:
+      case Type::Ref:
+      case Type::RefNull:
         return TypeVector(this, this + 1);
 
       default:

include/wabt/wast-parser.h

@@ -138,7 +138,7 @@ class WastParser {
   Result ParseValueTypeList(
       TypeVector* out_type_list,
       std::unordered_map<uint32_t, std::string>* type_names);
-  Result ParseRefKind(Type* out_type);
+  Result ParseRefKind(Var* out_type);
   Result ParseRefType(Type* out_type);
   bool ParseRefTypeOpt(Type* out_type);
   Result ParseQuotedText(std::string* text, bool check_utf8 = true);

src/binary-reader-ir.cc

@@ -650,7 +650,7 @@ Result BinaryReaderIR::OnImportGlobal(Index import_index,
   auto import = std::make_unique<GlobalImport>();
   import->module_name = module_name;
   import->field_name = field_name;
-  import->global.type = type;
+  import->global.type = Var(type, GetLocation());
   import->global.mutable_ = mutable_;
   module_->AppendField(
       std::make_unique<ImportModuleField>(std::move(import), GetLocation()));
@@ -739,7 +739,7 @@ Result BinaryReaderIR::OnGlobalCount(Index count) {
 Result BinaryReaderIR::BeginGlobal(Index index, Type type, bool mutable_) {
   auto field = std::make_unique<GlobalModuleField>(GetLocation());
   Global& global = field->global;
-  global.type = type;
+  global.type = Var(type, GetLocation());
   global.mutable_ = mutable_;
   module_->AppendField(std::move(field));
   module_->features_used.simd |= (type == Type::V128);
@@ -1153,7 +1153,7 @@ Result BinaryReaderIR::OnRefFuncExpr(Index func_index) {
 
 Result BinaryReaderIR::OnRefNullExpr(Type type) {
   module_->features_used.exceptions |= (type == Type::ExnRef);
-  return AppendExpr(std::make_unique<RefNullExpr>(type));
+  return AppendExpr(std::make_unique<RefNullExpr>(Var(type, GetLocation())));
 }
 
 Result BinaryReaderIR::OnRefIsNullExpr() {

src/binary-reader-logging.cc

@@ -719,10 +719,15 @@ Result BinaryReaderLogging::OnGenericCustomSection(std::string_view name,
     return reader_->name(value);                  \
   }
 
-#define DEFINE_TYPE(name)                         \
-  Result BinaryReaderLogging::name(Type type) {   \
-    LOGF(#name "(%s)\n", type.GetName().c_str()); \
-    return reader_->name(type);                   \
+#define DEFINE_TYPE(name)                                        \
+  Result BinaryReaderLogging::name(Type type) {                  \
+    if (!type.IsReferenceWithIndex()) {                          \
+      LOGF(#name "(%s)\n", type.GetName().c_str());              \
+    } else {                                                     \
+      LOGF(#name "(%s %" PRIindex ")\n", type.GetName().c_str(), \
+           type.GetReferenceIndex());                            \
+    }                                                            \
+    return reader_->name(type);                                  \
   }
 
 #define DEFINE_INDEX_DESC(name, desc)                 \

src/binary-reader.cc

@@ -113,6 +113,7 @@ class BinaryReader {
   [[nodiscard]] Result ReadU32Leb128(uint32_t* out_value, const char* desc);
   [[nodiscard]] Result ReadU64Leb128(uint64_t* out_value, const char* desc);
   [[nodiscard]] Result ReadS32Leb128(uint32_t* out_value, const char* desc);
+  [[nodiscard]] Result ReadS33Leb128(uint64_t* out_value, const char* desc);
   [[nodiscard]] Result ReadS64Leb128(uint64_t* out_value, const char* desc);
   [[nodiscard]] Result ReadType(Type* out_value, const char* desc);
   [[nodiscard]] Result ReadRefType(Type* out_value, const char* desc);
@@ -353,6 +354,15 @@ Result BinaryReader::ReadS32Leb128(uint32_t* out_value, const char* desc) {
   return Result::Ok;
 }
 
+Result BinaryReader::ReadS33Leb128(uint64_t* out_value, const char* desc) {
+  const uint8_t* p = state_.data + state_.offset;
+  const uint8_t* end = state_.data + read_end_;
+  size_t bytes_read = wabt::ReadS33Leb128(p, end, out_value);
+  ERROR_UNLESS(bytes_read > 0, "unable to read i33 leb128: %s", desc);
+  state_.offset += bytes_read;
+  return Result::Ok;
+}
+
 Result BinaryReader::ReadS64Leb128(uint64_t* out_value, const char* desc) {
   const uint8_t* p = state_.data + state_.offset;
   const uint8_t* end = state_.data + read_end_;
@@ -573,6 +583,8 @@ bool BinaryReader::IsConcreteType(Type type) {
       return options_.features.exceptions_enabled();
 
     case Type::Reference:
+    case Type::Ref:
+    case Type::RefNull:
       return options_.features.function_references_enabled();
 
     default:
@@ -1913,8 +1925,16 @@ Result BinaryReader::ReadInstructions(Offset end_offset, const char* context) {
       }
 
       case Opcode::RefNull: {
+        uint64_t heap_type;
         Type type;
-        CHECK_RESULT(ReadRefType(&type, "ref.null type"));
+        CHECK_RESULT(ReadS33Leb128(&heap_type, "ref.null type"));
+
+        if (static_cast<int64_t>(heap_type) < 0) {
+          type = Type(static_cast<int32_t>(heap_type));
+        } else {
+          type = Type(Type::RefNull, static_cast<Index>(heap_type));
+        }
+
         CALLBACK(OnRefNullExpr, type);
         CALLBACK(OnOpcodeType, type);
         break;