[NFC] Properties::hasUnwritableTypeImmediate (#7576)

Many WasmGC instructions have type index immediates that determine the
static types of certain operands. When we emit the IR, we need to look
at these operands to determine the type index immediate to emit. In
cases where the operand is unreachable or has bottom type, there is no
possible type index to emit, so we have to emit a replacement.

Previously Print.cpp had a visitor for each instruction that has such a
type immediate to individually check whether the replacement was
necessary. Refactor this to use a new
`Properties::hasUnwritableTypeImmediate` function implemented on top of
a new DELEGATE_FIELD_REF_CHILD macro in wasm-delegations-fields.def.
This function will be used elsewhere in a following PR.

Author: tlively

src/ir/properties.h

@@ -514,6 +514,41 @@ inline MemoryOrder getMemoryOrder(Expression* curr) {
   return MemoryOrder::Unordered;
 }
 
+// Whether this instruction will be unwritable in the text and binary formats
+// because it requires a type index immediate giving the type of a child that
+// has unreachable or null type, and therefore does not have a type index.
+inline bool hasUnwritableTypeImmediate(Expression* curr) {
+#define DELEGATE_ID curr->_id
+
+#define DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(id, field)                        \
+  {                                                                            \
+    auto type = curr->cast<id>()->field->type;                                 \
+    if (type == Type::unreachable || type.isNull()) {                          \
+      return true;                                                             \
+    }                                                                          \
+  }
+
+#define DELEGATE_FIELD_CHILD(id, field)
+#define DELEGATE_FIELD_CHILD_VECTOR(id, field)
+#define DELEGATE_FIELD_INT(id, field)
+#define DELEGATE_FIELD_INT_ARRAY(id, field)
+#define DELEGATE_FIELD_INT_VECTOR(id, field)
+#define DELEGATE_FIELD_LITERAL(id, field)
+#define DELEGATE_FIELD_NAME(id, field)
+#define DELEGATE_FIELD_NAME_VECTOR(id, field)
+#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field)
+#define DELEGATE_FIELD_SCOPE_NAME_USE(id, field)
+#define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field)
+#define DELEGATE_FIELD_TYPE(id, field)
+#define DELEGATE_FIELD_TYPE_VECTOR(id, field)
+#define DELEGATE_FIELD_HEAPTYPE(id, field)
+#define DELEGATE_FIELD_ADDRESS(id, field)
+
+#include "wasm-delegations-fields.def"
+
+  return false;
+}
+
 // A "generative" expression is one that can generate different results for the
 // same inputs, and that difference is *not* explained by other expressions that
 // interact with this one. This is an intrinsic/internal property of the

src/passes/Print.cpp

@@ -313,13 +313,8 @@ struct PrintSExpression : public UnifiedExpressionVisitor<PrintSExpression> {
   void visitTry(Try* curr);
   void visitTryTable(TryTable* curr);
 
+  void printUnreachableReplacement(Expression* curr);
   bool maybePrintUnreachableReplacement(Expression* curr, Type type);
-  bool maybePrintUnreachableOrNullReplacement(Expression* curr, Type type);
-  void visitCallRef(CallRef* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->target->type)) {
-      visitExpression(curr);
-    }
-  }
   void visitRefCast(RefCast* curr) {
     if (!maybePrintUnreachableReplacement(curr, curr->type)) {
       visitExpression(curr);
@@ -330,26 +325,6 @@ struct PrintSExpression : public UnifiedExpressionVisitor<PrintSExpression> {
       visitExpression(curr);
     }
   }
-  void visitStructGet(StructGet* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->ref->type)) {
-      visitExpression(curr);
-    }
-  }
-  void visitStructSet(StructSet* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->ref->type)) {
-      visitExpression(curr);
-    }
-  }
-  void visitStructRMW(StructRMW* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->ref->type)) {
-      visitExpression(curr);
-    }
-  }
-  void visitStructCmpxchg(StructCmpxchg* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->ref->type)) {
-      visitExpression(curr);
-    }
-  }
   void visitArrayNew(ArrayNew* curr) {
     if (!maybePrintUnreachableReplacement(curr, curr->type)) {
       visitExpression(curr);
@@ -370,63 +345,28 @@ struct PrintSExpression : public UnifiedExpressionVisitor<PrintSExpression> {
       visitExpression(curr);
     }
   }
-  void visitArraySet(ArraySet* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->ref->type)) {
-      visitExpression(curr);
-    }
-  }
-  void visitArrayGet(ArrayGet* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->ref->type)) {
-      visitExpression(curr);
-    }
-  }
-  void visitArrayCopy(ArrayCopy* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->srcRef->type) &&
-        !maybePrintUnreachableOrNullReplacement(curr, curr->destRef->type)) {
-      visitExpression(curr);
-    }
-  }
-  void visitArrayFill(ArrayFill* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->ref->type)) {
-      visitExpression(curr);
-    }
-  }
-  void visitArrayInitData(ArrayInitData* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->ref->type)) {
-      visitExpression(curr);
-    }
-  }
-  void visitArrayInitElem(ArrayInitElem* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->ref->type)) {
-      visitExpression(curr);
-    }
-  }
   void visitContNew(ContNew* curr) {
     if (!maybePrintUnreachableReplacement(curr, curr->type)) {
       visitExpression(curr);
     }
   }
   void visitContBind(ContBind* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->cont->type) &&
-        !maybePrintUnreachableOrNullReplacement(curr, curr->type)) {
+    if (!maybePrintUnreachableReplacement(curr, curr->type)) {
       visitExpression(curr);
     }
   }
   void visitResume(Resume* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->cont->type) &&
-        !maybePrintUnreachableOrNullReplacement(curr, curr->type)) {
+    if (!maybePrintUnreachableReplacement(curr, curr->type)) {
       visitExpression(curr);
     }
   }
   void visitResumeThrow(ResumeThrow* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->cont->type) &&
-        !maybePrintUnreachableOrNullReplacement(curr, curr->type)) {
+    if (!maybePrintUnreachableReplacement(curr, curr->type)) {
       visitExpression(curr);
     }
   }
   void visitStackSwitch(StackSwitch* curr) {
-    if (!maybePrintUnreachableOrNullReplacement(curr, curr->cont->type) &&
-        !maybePrintUnreachableOrNullReplacement(curr, curr->type)) {
+    if (!maybePrintUnreachableReplacement(curr, curr->type)) {
       visitExpression(curr);
     }
   }
@@ -2776,6 +2716,11 @@ void PrintSExpression::maybePrintImplicitBlock(Expression* curr) {
 }
 
 void PrintSExpression::visitExpression(Expression* curr) {
+  if (Properties::hasUnwritableTypeImmediate(curr)) {
+    printUnreachableReplacement(curr);
+    return;
+  }
+
   o << '(';
   printExpressionContents(curr);
   auto it = ChildIterator(curr);
@@ -2987,16 +2932,7 @@ void PrintSExpression::visitTryTable(TryTable* curr) {
   controlFlowDepth--;
 }
 
-bool PrintSExpression::maybePrintUnreachableReplacement(Expression* curr,
-                                                        Type type) {
-  // When we cannot print an instruction because the child from which it's
-  // supposed to get a type immediate is unreachable, then we print a
-  // semantically-equivalent block that drops each of the children and ends in
-  // an unreachable.
-  if (type != Type::unreachable) {
-    return false;
-  }
-
+void PrintSExpression::printUnreachableReplacement(Expression* curr) {
   // Emit a block with drops of the children.
   o << "(block";
   if (!minify) {
@@ -3012,15 +2948,19 @@ bool PrintSExpression::maybePrintUnreachableReplacement(Expression* curr,
   Unreachable unreachable;
   printFullLine(&unreachable);
   decIndent();
-  return true;
 }
 
-bool PrintSExpression::maybePrintUnreachableOrNullReplacement(Expression* curr,
-                                                              Type type) {
-  if (type.isNull()) {
-    type = Type::unreachable;
+bool PrintSExpression::maybePrintUnreachableReplacement(Expression* curr,
+                                                        Type type) {
+  // When we cannot print an instruction because the child from which it's
+  // supposed to get a type immediate is unreachable, then we print a
+  // semantically-equivalent block that drops each of the children and ends in
+  // an unreachable.
+  if (type == Type::unreachable) {
+    printUnreachableReplacement(curr);
+    return true;
   }
-  return maybePrintUnreachableReplacement(curr, type);
+  return false;
 }
 
 static bool requiresExplicitFuncType(HeapType type) {

src/wasm-delegations-fields.def

@@ -38,6 +38,10 @@
 //    are visited in reverse order, which is convenient for walking by pushing
 //    them to a stack first).
 //
+// DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(id, field) - called for each child field
+// whose type is given by an immediate in the binary format. If you do not
+// define this, then DELEGATE_FIELD_CHILD is called.
+//
 // DELEGATE_FIELD_OPTIONAL_CHILD(id, field) - called for a child that may not be
 //    present (like a Return's value). If you do not define this then
 //    DELEGATE_FIELD_CHILD is called.
@@ -109,6 +113,10 @@
 #error please define DELEGATE_FIELD_CHILD(id, field)
 #endif
 
+#ifndef DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD
+#define DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(id, field) DELEGATE_FIELD_CHILD(id, field)
+#endif
+
 #ifndef DELEGATE_FIELD_OPTIONAL_CHILD
 #define DELEGATE_FIELD_OPTIONAL_CHILD(id, field) DELEGATE_FIELD_CHILD(id, field)
 #endif
@@ -230,6 +238,7 @@
 // By default we emit a switch and cases, but that can be customized using the
 // following:
 
+
 #ifndef DELEGATE_FIELD_MAIN_START
 #define DELEGATE_FIELD_MAIN_START                                              \
   switch (DELEGATE_ID) {                                                       \
@@ -610,7 +619,7 @@ DELEGATE_FIELD_INT(I31Get, signed_)
 DELEGATE_FIELD_CASE_END(I31Get)
 
 DELEGATE_FIELD_CASE_START(CallRef)
-DELEGATE_FIELD_CHILD(CallRef, target)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(CallRef, target)
 DELEGATE_FIELD_CHILD_VECTOR(CallRef, operands)
 DELEGATE_FIELD_INT(CallRef, isReturn)
 DELEGATE_FIELD_CASE_END(CallRef)
@@ -637,31 +646,31 @@ DELEGATE_FIELD_CASE_END(StructNew)
 
 DELEGATE_FIELD_CASE_START(StructGet)
 DELEGATE_FIELD_INT(StructGet, index)
-DELEGATE_FIELD_CHILD(StructGet, ref)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructGet, ref)
 DELEGATE_FIELD_INT(StructGet, signed_)
 DELEGATE_FIELD_INT(StructGet, order)
 DELEGATE_FIELD_CASE_END(StructGet)
 
 DELEGATE_FIELD_CASE_START(StructSet)
 DELEGATE_FIELD_INT(StructSet, index)
 DELEGATE_FIELD_CHILD(StructSet, value)
-DELEGATE_FIELD_CHILD(StructSet, ref)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructSet, ref)
 DELEGATE_FIELD_INT(StructSet, order)
 DELEGATE_FIELD_CASE_END(StructSet)
 
 DELEGATE_FIELD_CASE_START(StructRMW)
 DELEGATE_FIELD_INT(StructRMW, op)
 DELEGATE_FIELD_INT(StructRMW, index)
 DELEGATE_FIELD_CHILD(StructRMW, value)
-DELEGATE_FIELD_CHILD(StructRMW, ref)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructRMW, ref)
 DELEGATE_FIELD_INT(StructRMW, order)
 DELEGATE_FIELD_CASE_END(StructRMW)
 
 DELEGATE_FIELD_CASE_START(StructCmpxchg)
 DELEGATE_FIELD_INT(StructCmpxchg, index)
 DELEGATE_FIELD_CHILD(StructCmpxchg, replacement)
 DELEGATE_FIELD_CHILD(StructCmpxchg, expected)
-DELEGATE_FIELD_CHILD(StructCmpxchg, ref)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructCmpxchg, ref)
 DELEGATE_FIELD_INT(StructCmpxchg, order)
 DELEGATE_FIELD_CASE_END(StructCmpxchg)
 
@@ -688,14 +697,14 @@ DELEGATE_FIELD_CASE_END(ArrayNewFixed)
 
 DELEGATE_FIELD_CASE_START(ArrayGet)
 DELEGATE_FIELD_CHILD(ArrayGet, index)
-DELEGATE_FIELD_CHILD(ArrayGet, ref)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayGet, ref)
 DELEGATE_FIELD_INT(ArrayGet, signed_)
 DELEGATE_FIELD_CASE_END(ArrayGet)
 
 DELEGATE_FIELD_CASE_START(ArraySet)
 DELEGATE_FIELD_CHILD(ArraySet, value)
 DELEGATE_FIELD_CHILD(ArraySet, index)
-DELEGATE_FIELD_CHILD(ArraySet, ref)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArraySet, ref)
 DELEGATE_FIELD_CASE_END(ArraySet)
 
 DELEGATE_FIELD_CASE_START(ArrayLen)
@@ -705,32 +714,32 @@ DELEGATE_FIELD_CASE_END(ArrayLen)
 DELEGATE_FIELD_CASE_START(ArrayCopy)
 DELEGATE_FIELD_CHILD(ArrayCopy, length)
 DELEGATE_FIELD_CHILD(ArrayCopy, srcIndex)
-DELEGATE_FIELD_CHILD(ArrayCopy, srcRef)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayCopy, srcRef)
 DELEGATE_FIELD_CHILD(ArrayCopy, destIndex)
-DELEGATE_FIELD_CHILD(ArrayCopy, destRef)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayCopy, destRef)
 DELEGATE_FIELD_CASE_END(ArrayCopy)
 
 DELEGATE_FIELD_CASE_START(ArrayFill)
 DELEGATE_FIELD_CHILD(ArrayFill, size)
 DELEGATE_FIELD_CHILD(ArrayFill, value)
 DELEGATE_FIELD_CHILD(ArrayFill, index)
-DELEGATE_FIELD_CHILD(ArrayFill, ref)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayFill, ref)
 DELEGATE_FIELD_CASE_END(ArrayFill)
 
 DELEGATE_FIELD_CASE_START(ArrayInitData)
 DELEGATE_FIELD_NAME_KIND(ArrayInitData, segment, ModuleItemKind::DataSegment)
 DELEGATE_FIELD_CHILD(ArrayInitData, size)
 DELEGATE_FIELD_CHILD(ArrayInitData, offset)
 DELEGATE_FIELD_CHILD(ArrayInitData, index)
-DELEGATE_FIELD_CHILD(ArrayInitData, ref)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayInitData, ref)
 DELEGATE_FIELD_CASE_END(ArrayInitData)
 
 DELEGATE_FIELD_CASE_START(ArrayInitElem)
 DELEGATE_FIELD_NAME_KIND(ArrayInitElem, segment, ModuleItemKind::ElementSegment)
 DELEGATE_FIELD_CHILD(ArrayInitElem, size)
 DELEGATE_FIELD_CHILD(ArrayInitElem, offset)
 DELEGATE_FIELD_CHILD(ArrayInitElem, index)
-DELEGATE_FIELD_CHILD(ArrayInitElem, ref)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayInitElem, ref)
 DELEGATE_FIELD_CASE_END(ArrayInitElem)
 
 DELEGATE_FIELD_CASE_START(RefAs)
@@ -788,7 +797,7 @@ DELEGATE_FIELD_CHILD(ContNew, func)
 DELEGATE_FIELD_CASE_END(ContNew)
 
 DELEGATE_FIELD_CASE_START(ContBind)
-DELEGATE_FIELD_CHILD(ContBind, cont)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ContBind, cont)
 DELEGATE_FIELD_CHILD_VECTOR(ContBind, operands)
 DELEGATE_FIELD_CASE_END(ContBind)
 
@@ -799,23 +808,23 @@ DELEGATE_FIELD_CASE_END(Suspend)
 
 DELEGATE_FIELD_CASE_START(Resume)
 DELEGATE_FIELD_TYPE_VECTOR(Resume, sentTypes)
-DELEGATE_FIELD_CHILD(Resume, cont)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(Resume, cont)
 DELEGATE_FIELD_CHILD_VECTOR(Resume, operands)
 DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(Resume, handlerBlocks)
 DELEGATE_FIELD_NAME_KIND_VECTOR(Resume, handlerTags, ModuleItemKind::Tag)
 DELEGATE_FIELD_CASE_END(Resume)
 
 DELEGATE_FIELD_CASE_START(ResumeThrow)
 DELEGATE_FIELD_TYPE_VECTOR(ResumeThrow, sentTypes)
-DELEGATE_FIELD_CHILD(ResumeThrow, cont)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ResumeThrow, cont)
 DELEGATE_FIELD_CHILD_VECTOR(ResumeThrow, operands)
 DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(ResumeThrow, handlerBlocks)
 DELEGATE_FIELD_NAME_KIND_VECTOR(ResumeThrow, handlerTags, ModuleItemKind::Tag)
 DELEGATE_FIELD_NAME_KIND(ResumeThrow, tag, ModuleItemKind::Tag)
 DELEGATE_FIELD_CASE_END(ResumeThrow)
 
 DELEGATE_FIELD_CASE_START(StackSwitch)
-DELEGATE_FIELD_CHILD(StackSwitch, cont)
+DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StackSwitch, cont)
 DELEGATE_FIELD_CHILD_VECTOR(StackSwitch, operands)
 DELEGATE_FIELD_NAME_KIND(StackSwitch, tag, ModuleItemKind::Tag)
 DELEGATE_FIELD_CASE_END(StackSwitch)
@@ -827,6 +836,7 @@ DELEGATE_FIELD_MAIN_END
 #undef DELEGATE_START
 #undef DELEGATE_END
 #undef DELEGATE_FIELD_CHILD
+#undef DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD
 #undef DELEGATE_FIELD_OPTIONAL_CHILD
 #undef DELEGATE_FIELD_CHILD_VECTOR
 #undef DELEGATE_FIELD_INT