Implement full reference support for call_ref, ref_null and variables

Support named references for globals, locals, tables, elems
Support named references for call_ref, ref_null

Author: Zoltan Herczeg

include/wabt/binary-reader-logging.h

@@ -181,7 +181,7 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
   Result OnCatchExpr(Index tag_index) override;
   Result OnCatchAllExpr() override;
   Result OnCallIndirectExpr(Index sig_index, Index table_index) override;
-  Result OnCallRefExpr() override;
+  Result OnCallRefExpr(Type sig_type) override;
   Result OnCompareExpr(Opcode opcode) override;
   Result OnConvertExpr(Opcode opcode) override;
   Result OnDelegateExpr(Index depth) override;

include/wabt/binary-reader-nop.h

@@ -250,7 +250,7 @@ class BinaryReaderNop : public BinaryReaderDelegate {
   Result OnCallIndirectExpr(Index sig_index, Index table_index) override {
     return Result::Ok;
   }
-  Result OnCallRefExpr() override { return Result::Ok; }
+  Result OnCallRefExpr(Type sig_type) override { return Result::Ok; }
   Result OnCatchExpr(Index tag_index) override { return Result::Ok; }
   Result OnCatchAllExpr() override { return Result::Ok; }
   Result OnCompareExpr(Opcode opcode) override { return Result::Ok; }

include/wabt/binary-reader.h

@@ -255,7 +255,7 @@ class BinaryReaderDelegate {
                                Index default_target_depth) = 0;
   virtual Result OnCallExpr(Index func_index) = 0;
   virtual Result OnCallIndirectExpr(Index sig_index, Index table_index) = 0;
-  virtual Result OnCallRefExpr() = 0;
+  virtual Result OnCallRefExpr(Type sig_type) = 0;
   virtual Result OnCatchExpr(Index tag_index) = 0;
   virtual Result OnCatchAllExpr() = 0;
   virtual Result OnCompareExpr(Opcode opcode) = 0;

include/wabt/ir.h

@@ -36,24 +36,41 @@ namespace wabt {
 
 struct Module;
 
-enum class VarType {
+enum class VarType : uint16_t {
   Index,
   Name,
 };
 
 struct Var {
+  // Var can represent variables or types.
+
+  // Represent a variable:
+  //   has_opt_type() is false
+  //   Only used by wast-parser
+
+  // Represent a type:
+  //   has_opt_type() is true, is_index() is true
+  //   type can be get by to_type()
+  //   Binary reader only constructs this variant
+
+  // Represent both a variable and a type:
+  //   has_opt_type() is true, is_name() is true
+  //   A reference, which index is unknown
+  //   Only used by wast-parser
+
   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&);
   Var& operator=(Var&&);
   ~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 +80,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, Type::Any represent no optional type.
+  int16_t opt_type_;
   union {
     Index index_;
     std::string name_;
@@ -537,10 +562,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>;
@@ -727,9 +752,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 sig_type;
 };
 
 template <ExprType TypeEnum>

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?
@@ -141,7 +142,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);
@@ -178,7 +179,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);
@@ -221,18 +222,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
@@ -58,6 +60,12 @@ class Type {
     I32U = 7,  // Not actually specified, but used internally with load/store
   };
 
+  // Used by FuncRef / ExternRef
+  enum GenericReferenceType : uint32_t {
+    ReferenceOrNull = 0,
+    ReferenceNonNull = 1,
+  };
+
   Type() = default;  // Provided so Type can be member of a union.
   Type(int32_t code)
       : enum_(static_cast<Enum>(code)), type_index_(0) {
@@ -67,7 +75,7 @@ class Type {
     assert(!EnumIsReferenceWithIndex(enum_));
   }
   Type(Enum e, Index type_index) : enum_(e), type_index_(type_index) {
-    assert(EnumIsReferenceWithIndex(e));
+    assert(EnumIsReferenceWithIndex(e) || (IsNonTypedRef() && (type_index_ == ReferenceOrNull || type_index_ == ReferenceNonNull)));
   }
   constexpr operator Enum() const { return enum_; }
 
@@ -90,14 +98,25 @@ class Type {
 
   bool IsRef() const {
     return enum_ == Type::ExternRef || enum_ == Type::FuncRef ||
-           enum_ == Type::Reference || enum_ == Type::ExnRef;
+           enum_ == Type::Reference || enum_ == Type::ExnRef ||
+           enum_ == Type::RefNull || enum_ == Type::Ref;
+  }
+
+  bool IsNullableRef() const {
+    return enum_ == Type::Reference || enum_ == Type::ExnRef ||
+           enum_ == Type::RefNull ||
+           ((enum_ == Type::ExternRef || enum_ == Type::FuncRef) && type_index_ == ReferenceOrNull);
   }
 
   bool IsReferenceWithIndex() const { return EnumIsReferenceWithIndex(enum_); }
 
-  bool IsNullableRef() const {
-    // Currently all reftypes are nullable
-    return IsRef();
+  bool IsNonTypedRef() const {
+    return EnumIsNonTypedRef(enum_);
+  }
+
+  bool IsNullableNonTypedRef() const {
+    assert(EnumIsNonTypedRef(enum_));
+    return type_index_ == ReferenceOrNull;
   }
 
   std::string GetName() const {
@@ -110,13 +129,18 @@ class Type {
       case Type::I8:        return "i8";
       case Type::I16:       return "i16";
       case Type::ExnRef:    return "exnref";
-      case Type::FuncRef:   return "funcref";
       case Type::Func:      return "func";
       case Type::Void:      return "void";
       case Type::Any:       return "any";
-      case Type::ExternRef: return "externref";
+      case Type::FuncRef:
+        return type_index_ == ReferenceOrNull ? "funcref" : "(ref func)";
+      case Type::ExternRef:
+        return type_index_ == ReferenceOrNull ? "externref" : "(ref extern)";
       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_);
     }
@@ -153,7 +177,7 @@ class Type {
   }
 
   Index GetReferenceIndex() const {
-    assert(enum_ == Enum::Reference);
+    assert(IsReferenceWithIndex());
     return type_index_;
   }
 
@@ -172,18 +196,25 @@ class Type {
       case Type::ExnRef:
       case Type::ExternRef:
       case Type::Reference:
+      case Type::Ref:
+      case Type::RefNull:
         return TypeVector(this, this + 1);
 
       default:
         WABT_UNREACHABLE;
     }
   }
 
- private:
   static bool EnumIsReferenceWithIndex(Enum value) {
-    return value == Type::Reference;
+    return value == Type::Reference || value == Type::Ref ||
+           value == Type::RefNull;
   }
 
+  static bool EnumIsNonTypedRef(Enum value) {
+    return value == Type::ExternRef || value == Type::FuncRef;
+  }
+
+ private:
   Enum enum_;
   // This index is 0 for non-references, so a zeroed
   // memory area represents a valid Type::Any type.