[custom-descriptors] Initial support for ref.get_desc (#7614)

tlively · web-flow · commit bcbabd8bfb84 · 2025-05-20T00:56:20.000Z
Implement parsing and printing for binary and text as well as typing and
validation for ref.get_desc.
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
@@ -610,6 +610,7 @@
     ("i31.get_u",            "makeI31Get(false)"),
     ("ref.test",             "makeRefTest()"),
     ("ref.cast",             "makeRefCast()"),
+    ("ref.get_desc",         "makeRefGetDesc()"),
     ("br_on_null",           "makeBrOnNull()"),
     ("br_on_non_null",       "makeBrOnNull(true)"),
     ("br_on_cast",           "makeBrOnCast()"),
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
@@ -4764,6 +4764,12 @@ switch (buf[0]) {
               return Ok{};
             }
             goto parse_error;
+          case 'g':
+            if (op == "ref.get_desc"sv) {
+              CHECK_ERR(makeRefGetDesc(ctx, pos, annotations));
+              return Ok{};
+            }
+            goto parse_error;
           case 'i': {
             switch (buf[5]) {
               case '3': {
diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
@@ -245,6 +245,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   Flow visitCallRef(CallRef* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitRefTest(RefTest* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitRefCast(RefCast* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitRefGetDesc(RefGetDesc* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitBrOn(BrOn* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStructNew(StructNew* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStructGet(StructGet* curr) { WASM_UNREACHABLE("TODO"); }
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
@@ -147,6 +147,7 @@ void ReFinalize::visitI31Get(I31Get* curr) { curr->finalize(); }
 void ReFinalize::visitCallRef(CallRef* curr) { curr->finalize(); }
 void ReFinalize::visitRefTest(RefTest* curr) { curr->finalize(); }
 void ReFinalize::visitRefCast(RefCast* curr) { curr->finalize(); }
+void ReFinalize::visitRefGetDesc(RefGetDesc* curr) { curr->finalize(); }
 void ReFinalize::visitBrOn(BrOn* curr) {
   curr->finalize();
   if (curr->type == Type::unreachable) {
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
@@ -857,6 +857,14 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     note(&curr->ref, Type(top, Nullable));
   }
 
+  void visitRefGetDesc(RefGetDesc* curr,
+                       std::optional<HeapType> ht = std::nullopt) {
+    if (!ht) {
+      ht = curr->ref->type.getHeapType();
+    }
+    note(&curr->ref, Type(*ht, Nullable));
+  }
+
   void visitBrOn(BrOn* curr) {
     switch (curr->op) {
       case BrOnNull:
diff --git a/src/ir/cost.h b/src/ir/cost.h
@@ -668,6 +668,9 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
   CostType visitRefCast(RefCast* curr) {
     return CastCost + nullCheckCost(curr->ref) + visit(curr->ref);
   }
+  CostType visitRefGetDesc(RefGetDesc* curr) {
+    return 1 + nullCheckCost(curr->ref) + visit(curr->ref);
+  }
   CostType visitBrOn(BrOn* curr) {
     // BrOn of a null can be fairly fast, but anything else is a cast check.
     CostType base =
diff --git a/src/ir/effects.h b/src/ir/effects.h
@@ -849,7 +849,11 @@ class EffectAnalyzer {
     }
     void visitRefTest(RefTest* curr) {}
     void visitRefCast(RefCast* curr) {
-      // Traps if the ref is not null and the cast fails.
+      // Traps if the cast fails.
+      parent.implicitTrap = true;
+    }
+    void visitRefGetDesc(RefGetDesc* curr) {
+      // Traps if the ref is null.
       parent.implicitTrap = true;
     }
     void visitBrOn(BrOn* curr) { parent.breakTargets.insert(curr->name); }
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
@@ -703,6 +703,10 @@ struct InfoCollector
 
   void visitRefCast(RefCast* curr) { receiveChildValue(curr->ref, curr); }
   void visitRefTest(RefTest* curr) { addRoot(curr); }
+  void visitRefGetDesc(RefGetDesc* curr) {
+    // TODO: Do something more similar to struct.get here
+    addRoot(curr);
+  }
   void visitBrOn(BrOn* curr) {
     // TODO: optimize when possible
     handleBreakValue(curr);
diff --git a/src/ir/subtype-exprs.h b/src/ir/subtype-exprs.h
@@ -299,6 +299,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
     self()->noteCast(curr->ref, curr->castType);
   }
   void visitRefCast(RefCast* curr) { self()->noteCast(curr->ref, curr); }
+  void visitRefGetDesc(RefGetDesc* curr) {}
   void visitBrOn(BrOn* curr) {
     if (curr->op == BrOnCast || curr->op == BrOnCastFail) {
       self()->noteCast(curr->ref, curr->castType);
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
@@ -736,6 +736,10 @@ struct NullInstrParserCtx {
   Result<> makeRefCast(Index, const std::vector<Annotation>&, TypeT) {
     return Ok{};
   }
+  template<typename HeapTypeT>
+  Result<> makeRefGetDesc(Index, const std::vector<Annotation>&, HeapTypeT) {
+    return Ok{};
+  }
 
   Result<> makeBrOn(Index, const std::vector<Annotation>&, LabelIdxT, BrOnOp) {
     return Ok{};
@@ -2591,6 +2595,12 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
     return withLoc(pos, irBuilder.makeRefCast(type));
   }
 
+  Result<> makeRefGetDesc(Index pos,
+                          const std::vector<Annotation>& annotations,
+                          HeapType type) {
+    return withLoc(pos, irBuilder.makeRefGetDesc(type));
+  }
+
   Result<> makeBrOn(Index pos,
                     const std::vector<Annotation>& annotations,
                     Index label,
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
@@ -233,6 +233,8 @@ Result<> makeRefTest(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
 Result<> makeRefCast(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
+Result<> makeRefGetDesc(Ctx&, Index, const std::vector<Annotation>&);
+template<typename Ctx>
 Result<>
 makeBrOnNull(Ctx&, Index, const std::vector<Annotation>&, bool onFail = false);
 template<typename Ctx>
@@ -2218,6 +2220,15 @@ makeRefCast(Ctx& ctx, Index pos, const std::vector<Annotation>& annotations) {
   return ctx.makeRefCast(pos, annotations, *type);
 }
 
+template<typename Ctx>
+Result<> makeRefGetDesc(Ctx& ctx,
+                        Index pos,
+                        const std::vector<Annotation>& annotations) {
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  return ctx.makeRefGetDesc(pos, annotations, *type);
+}
+
 template<typename Ctx>
 Result<> makeBrOnNull(Ctx& ctx,
                       Index pos,
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
@@ -2211,7 +2211,10 @@ struct PrintExpressionContents
     printMedium(o, "ref.cast ");
     printType(curr->type);
   }
-
+  void visitRefGetDesc(RefGetDesc* curr) {
+    printMedium(o, "ref.get_desc ");
+    printHeapTypeName(curr->ref->type.getHeapType());
+  }
   void visitBrOn(BrOn* curr) {
     switch (curr->op) {
       case BrOnNull:
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
@@ -595,6 +595,8 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
     push(Type::none);
   }
 
+  void visitRefGetDesc(RefGetDesc* curr) { WASM_UNREACHABLE("TODO"); }
+
   void visitBrOn(BrOn* curr) {
     // Like br_if, these instructions do different things to the stack depending
     // on whether the branch is taken or not. For branches that drop the tested
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
@@ -1180,6 +1180,7 @@ enum ASTNodes {
   I31GetS = 0x1d,
   I31GetU = 0x1e,
   RefI31Shared = 0x1f,
+  RefGetDesc = 0x22,
 
   // Shared GC Opcodes
 
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
@@ -894,6 +894,12 @@ class Builder {
     ret->finalize();
     return ret;
   }
+  RefGetDesc* makeRefGetDesc(Expression* ref) {
+    auto* ret = wasm.allocator.alloc<RefGetDesc>();
+    ret->ref = ref;
+    ret->finalize();
+    return ret;
+  }
   BrOn*
   makeBrOn(BrOnOp op, Name name, Expression* ref, Type castType = Type::none) {
     auto* ret = wasm.allocator.alloc<BrOn>();
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
@@ -633,6 +633,10 @@ DELEGATE_FIELD_CASE_START(RefCast)
 DELEGATE_FIELD_CHILD(RefCast, ref)
 DELEGATE_FIELD_CASE_END(RefCast)
 
+DELEGATE_FIELD_CASE_START(RefGetDesc)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(RefGetDesc, ref)
+DELEGATE_FIELD_CASE_END(RefGetDesc)
+
 DELEGATE_FIELD_CASE_START(BrOn)
 DELEGATE_FIELD_INT(BrOn, op)
 DELEGATE_FIELD_SCOPE_NAME_USE(BrOn, name)
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
@@ -77,6 +77,7 @@ DELEGATE(I31Get);
 DELEGATE(CallRef);
 DELEGATE(RefTest);
 DELEGATE(RefCast);
+DELEGATE(RefGetDesc);
 DELEGATE(BrOn);
 DELEGATE(StructNew);
 DELEGATE(StructGet);
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -1670,6 +1670,10 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     trap("cast error");
     WASM_UNREACHABLE("unreachable");
   }
+  Flow visitRefGetDesc(RefGetDesc* curr) {
+    NOTE_ENTER("RefGetDesc");
+    WASM_UNREACHABLE("unimplemented");
+  }
   Flow visitBrOn(BrOn* curr) {
     NOTE_ENTER("BrOn");
     // BrOnCast* uses the casting infrastructure, so handle them first.
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
@@ -209,6 +209,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
                        std::optional<std::uint8_t> inline_ = std::nullopt);
   Result<> makeRefTest(Type type);
   Result<> makeRefCast(Type type);
+  Result<> makeRefGetDesc(HeapType type);
   Result<> makeBrOn(Index label,
                     BrOnOp op,
                     Type in = Type::none,
diff --git a/src/wasm.h b/src/wasm.h
@@ -718,6 +718,7 @@ class Expression {
     CallRefId,
     RefTestId,
     RefCastId,
+    RefGetDescId,
     BrOnId,
     StructNewId,
     StructGetId,
@@ -1622,6 +1623,16 @@ class RefCast : public SpecificExpression<Expression::RefCastId> {
   Type& getCastType() { return type; }
 };
 
+class RefGetDesc : public SpecificExpression<Expression::RefGetDescId> {
+public:
+  RefGetDesc() = default;
+  RefGetDesc(MixedArena& allocator) {}
+
+  Expression* ref;
+
+  void finalize();
+};
+
 class BrOn : public SpecificExpression<Expression::BrOnId> {
 public:
   BrOn() = default;
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -4498,6 +4498,10 @@ Result<> WasmBinaryReader::readInst() {
           auto [heapType, exactness] = getHeapType();
           return builder.makeRefCast(Type(heapType, Nullable, exactness));
         }
+        case BinaryConsts::RefGetDesc: {
+          auto type = getIndexedHeapType();
+          return builder.makeRefGetDesc(type);
+        }
         case BinaryConsts::BrOnCast:
         case BinaryConsts::BrOnCastFail: {
           auto flags = getInt8();
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
@@ -672,6 +672,13 @@ struct IRBuilder::ChildPopper
     return popConstrainedChildren(children);
   }
 
+  Result<> visitRefGetDesc(RefGetDesc* curr,
+                           std::optional<HeapType> ht = std::nullopt) {
+    std::vector<Child> children;
+    ConstraintCollector{builder, children}.visitRefGetDesc(curr, ht);
+    return popConstrainedChildren(children);
+  }
+
   Result<> visitBreak(Break* curr,
                       std::optional<Type> labelType = std::nullopt) {
     std::vector<Child> children;
@@ -1991,6 +1998,17 @@ Result<> IRBuilder::makeRefCast(Type type) {
   return Ok{};
 }
 
+Result<> IRBuilder::makeRefGetDesc(HeapType type) {
+  RefGetDesc curr;
+  if (!type.getDescriptorType()) {
+    return Err{"expected type with descriptor"};
+  }
+  CHECK_ERR(ChildPopper{*this}.visitRefGetDesc(&curr, type));
+  CHECK_ERR(validateTypeAnnotation(type, curr.ref));
+  push(builder.makeRefGetDesc(curr.ref));
+  return Ok{};
+}
+
 Result<> IRBuilder::makeBrOn(
   Index label, BrOnOp op, Type in, Type out, std::optional<bool> likely) {
   BrOn curr;
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
@@ -2280,6 +2280,15 @@ void BinaryInstWriter::visitRefCast(RefCast* curr) {
   parent.writeHeapType(curr->type.getHeapType(), curr->type.getExactness());
 }
 
+void BinaryInstWriter::visitRefGetDesc(RefGetDesc* curr) {
+  if (curr->ref->type.isNull()) {
+    emitUnreachable();
+    return;
+  }
+  o << int8_t(BinaryConsts::GCPrefix) << U32LEB(BinaryConsts::RefGetDesc);
+  parent.writeIndexedHeapType(curr->ref->type.getHeapType());
+}
+
 void BinaryInstWriter::visitBrOn(BrOn* curr) {
   switch (curr->op) {
     case BrOnNull:
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
@@ -495,6 +495,7 @@ struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {
   void visitI31Get(I31Get* curr);
   void visitRefTest(RefTest* curr);
   void visitRefCast(RefCast* curr);
+  void visitRefGetDesc(RefGetDesc* curr);
   void visitBrOn(BrOn* curr);
   void visitStructNew(StructNew* curr);
   void visitStructGet(StructGet* curr);
@@ -2967,6 +2968,13 @@ void FunctionValidator::visitRefCast(RefCast* curr) {
   }
 }
 
+void FunctionValidator::visitRefGetDesc(RefGetDesc* curr) {
+  shouldBeTrue(
+    getModule()->features.hasCustomDescriptors(),
+    curr,
+    "ref.get_desc requires custom descriptors [--enable-custom-descriptors]");
+}
+
 void FunctionValidator::visitBrOn(BrOn* curr) {
   shouldBeTrue(getModule()->features.hasGC(),
                curr,
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
@@ -1071,6 +1071,17 @@ void RefCast::finalize() {
   type = Type::getGreatestLowerBound(type, ref->type);
 }
 
+void RefGetDesc::finalize() {
+  if (ref->type == Type::unreachable) {
+    type = Type::unreachable;
+    return;
+  }
+
+  auto desc = ref->type.getHeapType().getDescriptorType();
+  assert(desc);
+  type = Type(*desc, NonNullable, ref->type.getExactness());
+}
+
 void BrOn::finalize() {
   if (ref->type == Type::unreachable) {
     type = Type::unreachable;
diff --git a/src/wasm2js.h b/src/wasm2js.h
@@ -2304,6 +2304,10 @@ Ref Wasm2JSBuilder::processExpression(Expression* curr,
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
     }
+    Ref visitRefGetDesc(RefGetDesc* curr) {
+      unimplemented(curr);
+      WASM_UNREACHABLE("unimp");
+    }
     Ref visitBrOn(BrOn* curr) {
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
diff --git a/test/lit/basic/custom-descriptors.wast b/test/lit/basic/custom-descriptors.wast
diff --git a/test/lit/parse-bad-get-desc.wast b/test/lit/parse-bad-get-desc.wast
diff --git a/test/lit/validation/custom-descriptors.wast b/test/lit/validation/custom-descriptors.wast

Original file line number	Diff line number	Diff line change
`@@ -849,7 +849,11 @@ class EffectAnalyzer {`
`849`	`849`	`}`
`850`	`850`	`void visitRefTest(RefTest* curr) {}`
`851`	`851`	`void visitRefCast(RefCast* curr) {`
`852`		`- // Traps if the ref is not null and the cast fails.`
	`852`	`+ // Traps if the cast fails.`
	`853`	`+ parent.implicitTrap = true;`
	`854`	`+ }`
	`855`	`+ void visitRefGetDesc(RefGetDesc* curr) {`
	`856`	`+ // Traps if the ref is null.`
`853`	`857`	`parent.implicitTrap = true;`
`854`	`858`	`}`
`855`	`859`	`void visitBrOn(BrOn* curr) { parent.breakTargets.insert(curr->name); }`
Original file line number	Diff line number	Diff line change
`@@ -299,6 +299,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {`
`299`	`299`	`self()->noteCast(curr->ref, curr->castType);`
`300`	`300`	`}`
`301`	`301`	`void visitRefCast(RefCast* curr) { self()->noteCast(curr->ref, curr); }`
	`302`	`+ void visitRefGetDesc(RefGetDesc* curr) {}`
`302`	`303`	`void visitBrOn(BrOn* curr) {`
`303`	`304`	`if (curr->op == BrOnCast \|\| curr->op == BrOnCastFail) {`
`304`	`305`	`self()->noteCast(curr->ref, curr->castType);`