Intrinsic: dead.if.unused

scripts/test/fuzzing.py

@@ -109,6 +109,12 @@
     # Contains a name with "__fuzz_split", indicating it is emitted by
     # wasm-split, confusing the fuzzer because it is in the initial content.
     'fuzz_shell_second.wast',
+    # We cannot fuzz semantics-altering intrinsics, as when we optimize the
+    # behavior changes.
+    'dead-if-unused.wast',
+    'dead-if-unused-func.wast',
+    'vacuum-dead-if-unused.wast',
+    'vacuum-dead-if-unused-func.wast',
 ]
 
 

src/ir/intrinsics.h

@@ -111,6 +111,48 @@ class Intrinsics {
   std::vector<Name> getConfigureAllFunctions(Call* call);
   // As above, but looks through the module to find the configureAll.
   std::vector<Name> getConfigureAllFunctions();
+
+  // Get the code annotations for an expression in a function.
+  CodeAnnotation getAnnotations(Expression* curr, Function* func) {
+    auto& annotations = func->codeAnnotations;
+    auto iter = annotations.find(curr);
+    if (iter != annotations.end()) {
+      return iter->second;
+    }
+    return {};
+  }
+
+  // Get the code annotations for a function itself.
+  CodeAnnotation getAnnotations(Function* func) {
+    return getAnnotations(nullptr, func);
+  }
+
+  // Given a call in a function, return all the annotations for it. The call may
+  // be annotated itself (which takes precedence), or the function it calls be
+  // annotated.
+  CodeAnnotation getCallAnnotations(Call* call, Function* func) {
+    // Combine annotations from the call itself and from the called function.
+    auto ret = getAnnotations(call, func);
+
+    // Check on the called function, if it exists (it may not if the IR is still
+    // being built up).
+    if (auto* target = module.getFunctionOrNull(call->target)) {
+      auto funcAnnotations = getAnnotations(target);
+
+      // Merge them, giving precedence for the call annotation.
+      if (!ret.branchLikely) {
+        ret.branchLikely = funcAnnotations.branchLikely;
+      }
+      if (!ret.inline_) {
+        ret.inline_ = funcAnnotations.inline_;
+      }
+      if (!ret.deadIfUnused) {
+        ret.deadIfUnused = funcAnnotations.deadIfUnused;
+      }
+    }
+
+    return ret;
+  }
 };
 
 } // namespace wasm

src/parser/contexts.h

@@ -1315,6 +1315,8 @@ struct AnnotationParserCtx {
         branchHint = &a;
       } else if (a.kind == Annotations::InlineHint) {
         inlineHint = &a;
+      } else if (a.kind == Annotations::DeadIfUnusedHint) {
+        ret.deadIfUnused = true;
       }
     }
 

src/passes/Print.cpp

@@ -2789,6 +2789,12 @@ void PrintSExpression::printCodeAnnotations(Expression* curr) {
       restoreNormalColor(o);
       doIndent(o, indent);
     }
+    if (annotation.deadIfUnused) {
+      Colors::grey(o);
+      o << "(@" << Annotations::DeadIfUnusedHint << ")\n";
+      restoreNormalColor(o);
+      doIndent(o, indent);
+    }
   }
 }
 

src/passes/Vacuum.cpp

@@ -22,6 +22,7 @@
 #include <ir/branch-hints.h>
 #include <ir/drop.h>
 #include <ir/effects.h>
+#include <ir/intrinsics.h>
 #include <ir/iteration.h>
 #include <ir/literal-utils.h>
 #include <ir/utils.h>
@@ -91,10 +92,8 @@ struct Vacuum : public WalkerPass<ExpressionStackWalker<Vacuum>> {
           curr->is<Loop>() || curr->is<Try>() || curr->is<TryTable>()) {
         return curr;
       }
-      // Check if this expression itself has side effects, ignoring children.
-      EffectAnalyzer self(getPassOptions(), *getModule());
-      self.visit(curr);
-      if (self.hasUnremovableSideEffects()) {
+      // Check if this expression itself must be kept.
+      if (mustKeepUnusedParent(curr)) {
         return curr;
       }
       // The result isn't used, and this has no side effects itself, so we can
@@ -130,6 +129,26 @@ struct Vacuum : public WalkerPass<ExpressionStackWalker<Vacuum>> {
     }
   }
 
+  // Check if a parent expression must be kept around, given the knowledge that
+  // its result is unused (dropped). This is basically just a call to
+  // ShallowEffectAnalyzer to see if we can remove it, except that given the
+  // result is unused, the relevant hint may help us. (This just checks the
+  // parent itself: it may have children that the caller must check and keep
+  // around if so.)
+  bool mustKeepUnusedParent(Expression* curr) {
+    if (auto* call = curr->dynCast<Call>()) {
+      // Return true if a target in a function is annotated as dead if unused.
+      // If |curr| is marked so, then it is dead without even checking effects.
+      if (Intrinsics(*getModule())
+            .getCallAnnotations(call, getFunction())
+            .deadIfUnused) {
+        return false;
+      }
+    }
+    ShallowEffectAnalyzer self(getPassOptions(), *getModule(), curr);
+    return self.hasUnremovableSideEffects();
+  }
+
   void visitBlock(Block* curr) {
     auto& list = curr->list;
 

src/wasm-annotations.h

@@ -27,6 +27,7 @@ namespace wasm::Annotations {
 
 extern const Name BranchHint;
 extern const Name InlineHint;
+extern const Name DeadIfUnusedHint;
 
 } // namespace wasm::Annotations
 

src/wasm-binary.h

@@ -1441,6 +1441,7 @@ class WasmBinaryWriter {
 
   std::optional<BufferWithRandomAccess> getBranchHintsBuffer();
   std::optional<BufferWithRandomAccess> getInlineHintsBuffer();
+  std::optional<BufferWithRandomAccess> getDeadIfUnusedHintsBuffer();
 
   // helpers
   void writeInlineString(std::string_view name);
@@ -1733,6 +1734,7 @@ class WasmBinaryReader {
 
   void readBranchHints(size_t payloadLen);
   void readInlineHints(size_t payloadLen);
+  void readDeadIfUnusedHints(size_t payloadLen);
 
   std::tuple<Address, Address, Index, MemoryOrder>
   readMemoryAccess(bool isAtomic, bool isRMW);

src/wasm.h

@@ -2233,7 +2233,9 @@ struct BinaryLocations {
 // Forward declaration for FuncEffectsMap.
 class EffectAnalyzer;
 
-// Code annotations for VMs.
+// Annotation for a particular piece of code. This includes std::optionals for
+// all possible annotations, with the ones present being filled in (or just a
+// bool for an annotation with one possible value).
 struct CodeAnnotation {
   // Branch Hinting proposal: Whether the branch is likely, or unlikely.
   std::optional<bool> branchLikely;
@@ -2243,8 +2245,14 @@ struct CodeAnnotation {
   static const uint8_t AlwaysInline = 127;
   std::optional<uint8_t> inline_;
 
+  // Toolchain hint: If this expression's result is unused, then the entire
+  // thing can be considered dead and removable.
+  // TODO: link to spec somewhere
+  bool deadIfUnused = false;
+
   bool operator==(const CodeAnnotation& other) const {
-    return branchLikely == other.branchLikely && inline_ == other.inline_;
+    return branchLikely == other.branchLikely && inline_ == other.inline_ &&
+           deadIfUnused == other.deadIfUnused;
   }
 };
 

src/wasm/wasm-binary.cpp

@@ -1627,6 +1627,7 @@ std::optional<BufferWithRandomAccess> WasmBinaryWriter::writeCodeAnnotations() {
 
   append(getBranchHintsBuffer());
   append(getInlineHintsBuffer());
+  append(getDeadIfUnusedHintsBuffer());
   return ret;
 }
 
@@ -1769,6 +1770,17 @@ std::optional<BufferWithRandomAccess> WasmBinaryWriter::getInlineHintsBuffer() {
     });
 }
 
+std::optional<BufferWithRandomAccess>
+WasmBinaryWriter::getDeadIfUnusedHintsBuffer() {
+  return writeExpressionHints(
+    Annotations::DeadIfUnusedHint,
+    [](const CodeAnnotation& annotation) { return annotation.deadIfUnused; },
+    [](const CodeAnnotation& annotation, BufferWithRandomAccess& buffer) {
+      // Hint size, always empty.
+      buffer << U32LEB(0);
+    });
+}
+
 void WasmBinaryWriter::writeData(const char* data, size_t size) {
   for (size_t i = 0; i < size; i++) {
     o << int8_t(data[i]);
@@ -2040,7 +2052,8 @@ void WasmBinaryReader::preScan() {
       auto sectionName = getInlineString();
 
       if (sectionName == Annotations::BranchHint ||
-          sectionName == Annotations::InlineHint) {
+          sectionName == Annotations::InlineHint ||
+          sectionName == Annotations::DeadIfUnusedHint) {
         // Code annotations require code locations.
         // TODO: We could note which functions require code locations, as an
         //       optimization.
@@ -2197,6 +2210,9 @@ void WasmBinaryReader::readCustomSection(size_t payloadLen) {
   } else if (sectionName == Annotations::InlineHint) {
     deferredAnnotationSections.push_back(AnnotationSectionInfo{
       pos, [this, payloadLen]() { this->readInlineHints(payloadLen); }});
+  } else if (sectionName == Annotations::DeadIfUnusedHint) {
+    deferredAnnotationSections.push_back(AnnotationSectionInfo{
+      pos, [this, payloadLen]() { this->readDeadIfUnusedHints(payloadLen); }});
   } else {
     // an unfamiliar custom section
     if (sectionName.equals(BinaryConsts::CustomSections::Linking)) {
@@ -5507,6 +5523,18 @@ void WasmBinaryReader::readInlineHints(size_t payloadLen) {
     });
 }
 
+void WasmBinaryReader::readDeadIfUnusedHints(size_t payloadLen) {
+  readExpressionHints(
+    Annotations::DeadIfUnusedHint, payloadLen, [&](CodeAnnotation& annotation) {
+      auto size = getU32LEB();
+      if (size != 0) {
+        throwError("bad DeadIfUnusedHint size");
+      }
+
+      annotation.deadIfUnused = true;
+    });
+}
+
 std::tuple<Address, Address, Index, MemoryOrder>
 WasmBinaryReader::readMemoryAccess(bool isAtomic, bool isRMW) {
   auto rawAlignment = getU32LEB();

src/wasm/wasm-ir-builder.cpp

@@ -2661,6 +2661,12 @@ void IRBuilder::applyAnnotations(Expression* expr,
     assert(func);
     func->codeAnnotations[expr].inline_ = annotation.inline_;
   }
+
+  if (annotation.deadIfUnused) {
+    // Only possible inside functions.
+    assert(func);
+    func->codeAnnotations[expr].deadIfUnused = true;
+  }
 }
 
 } // namespace wasm

src/wasm/wasm.cpp

@@ -69,6 +69,7 @@ namespace Annotations {
 
 const Name BranchHint = "metadata.code.branch_hint";
 const Name InlineHint = "metadata.code.inline";
+const Name DeadIfUnusedHint = "binaryen.dead.if.unused";
 
 } // namespace Annotations
 

test/lit/dead-if-unused-func.wast

@@ -0,0 +1,23 @@
+;; RUN: wasm-opt -all             %s -S -o - | filecheck %s
+;; RUN: wasm-opt -all --roundtrip %s -S -o - | filecheck %s
+
+(module
+  (@binaryen.dead.if.unused)
+  (func $func-annotation
+    ;; The annotation here is on the function.
+    (drop
+      (i32.const 0)
+    )
+  )
+)
+
+;; CHECK: (module
+;; CHECK-NEXT:  (type $0 (func))
+;; CHECK-NEXT:  (@binaryen.dead.if.unused)
+;; CHECK-NEXT:  (func $func-annotation
+;; CHECK-NEXT:   (drop
+;; CHECK-NEXT:    (i32.const 0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+

test/lit/dead-if-unused.wast

@@ -0,0 +1,31 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
+
+;; RUN: wasm-opt -all             %s -S -o - | filecheck %s
+
+;; RUN: wasm-opt -all --roundtrip %s -S -o - | filecheck %s --check-prefix=RTRIP
+
+(module
+  ;; CHECK:      (type $0 (func))
+
+  ;; CHECK:      (func $func (type $0)
+  ;; CHECK-NEXT:  (call $func)
+  ;; CHECK-NEXT:  (@binaryen.dead.if.unused)
+  ;; CHECK-NEXT:  (call $func)
+  ;; CHECK-NEXT:  (call $func)
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (type $0 (func))
+
+  ;; RTRIP:      (func $func (type $0)
+  ;; RTRIP-NEXT:  (call $func)
+  ;; RTRIP-NEXT:  (@binaryen.dead.if.unused)
+  ;; RTRIP-NEXT:  (call $func)
+  ;; RTRIP-NEXT:  (call $func)
+  ;; RTRIP-NEXT: )
+  (func $func
+    ;; Three calls, one annotated in the middle.
+    (call $func)
+    (@binaryen.dead.if.unused)
+    (call $func)
+    (call $func)
+  )
+)