diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 91bee00..1646c85 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -487,6 +487,8 @@
     "transform/transform.h",
     "transform/unshadow.cc",
     "transform/unshadow.h",
+    "transform/unwind_discard_functions.cc",
+    "transform/unwind_discard_functions.h",
     "transform/utils/hoist_to_decl_before.cc",
     "transform/utils/hoist_to_decl_before.h",
     "transform/var_for_dynamic_index.cc",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 5e077e6..1f5e90c 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -365,6 +365,8 @@
   transform/transform.h
   transform/unshadow.cc
   transform/unshadow.h
+  transform/unwind_discard_functions.cc
+  transform/unwind_discard_functions.h
   transform/vectorize_scalar_matrix_constructors.cc
   transform/vectorize_scalar_matrix_constructors.h
   transform/var_for_dynamic_index.cc
@@ -1031,6 +1033,7 @@
       transform/single_entry_point_test.cc
       transform/test_helper.h
       transform/unshadow_test.cc
+      transform/unwind_discard_functions_test.cc
       transform/var_for_dynamic_index_test.cc
       transform/vectorize_scalar_matrix_constructors_test.cc
       transform/vertex_pulling_test.cc
diff --git a/src/tint/sem/if_statement.cc b/src/tint/sem/if_statement.cc
index d5f8fb3..38a7395 100644
--- a/src/tint/sem/if_statement.cc
+++ b/src/tint/sem/if_statement.cc
@@ -40,5 +40,9 @@
 
 ElseStatement::~ElseStatement() = default;
 
+const ast::ElseStatement* ElseStatement::Declaration() const {
+  return static_cast<const ast::ElseStatement*>(Base::Declaration());
+}
+
 }  // namespace sem
 }  // namespace tint
diff --git a/src/tint/sem/if_statement.h b/src/tint/sem/if_statement.h
index 7dc2a11..c38a32a 100644
--- a/src/tint/sem/if_statement.h
+++ b/src/tint/sem/if_statement.h
@@ -73,6 +73,9 @@
   /// Destructor
   ~ElseStatement() override;
 
+  /// @returns the AST node
+  const ast::ElseStatement* Declaration() const;
+
   /// @returns the else-statement condition expression
   const Expression* Condition() const { return condition_; }
 
diff --git a/src/tint/transform/glsl.cc b/src/tint/transform/glsl.cc
index c7352c4..a1cb69c 100644
--- a/src/tint/transform/glsl.cc
+++ b/src/tint/transform/glsl.cc
@@ -34,6 +34,7 @@
 #include "src/tint/transform/simplify_pointers.h"
 #include "src/tint/transform/single_entry_point.h"
 #include "src/tint/transform/unshadow.h"
+#include "src/tint/transform/unwind_discard_functions.h"
 #include "src/tint/transform/zero_init_workgroup_memory.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::transform::Glsl);
@@ -84,6 +85,7 @@
   }
   manager.Add<CanonicalizeEntryPointIO>();
   manager.Add<PromoteSideEffectsToDecl>();
+  manager.Add<UnwindDiscardFunctions>();
   manager.Add<SimplifyPointers>();
 
   manager.Add<RemovePhonies>();
diff --git a/src/tint/transform/test_helper.h b/src/tint/transform/test_helper.h
index 974cba0..8a36df1 100644
--- a/src/tint/transform/test_helper.h
+++ b/src/tint/transform/test_helper.h
@@ -118,7 +118,8 @@
   template <typename TRANSFORM>
   bool ShouldRun(Program&& program, const DataMap& data = {}) {
     EXPECT_TRUE(program.IsValid()) << program.Diagnostics().str();
-    return TRANSFORM().ShouldRun(&program, data);
+    const Transform& t = TRANSFORM();
+    return t.ShouldRun(&program, data);
   }
 
   /// @param in the input WGSL source
diff --git a/src/tint/transform/unwind_discard_functions.cc b/src/tint/transform/unwind_discard_functions.cc
new file mode 100644
index 0000000..80a47b1
--- /dev/null
+++ b/src/tint/transform/unwind_discard_functions.cc
@@ -0,0 +1,432 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/transform/unwind_discard_functions.h"
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "src/tint/ast/discard_statement.h"
+#include "src/tint/ast/return_statement.h"
+#include "src/tint/ast/traverse_expressions.h"
+#include "src/tint/sem/block_statement.h"
+#include "src/tint/sem/call.h"
+#include "src/tint/sem/for_loop_statement.h"
+#include "src/tint/sem/function.h"
+#include "src/tint/sem/if_statement.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::transform::UnwindDiscardFunctions);
+
+namespace tint::transform {
+namespace {
+
+class State {
+ private:
+  CloneContext& ctx;
+  ProgramBuilder& b;
+  const sem::Info& sem;
+  Symbol module_discard_var_name;   // Use ModuleDiscardVarName() to read
+  Symbol module_discard_func_name;  // Use ModuleDiscardFuncName() to read
+
+  // For the input statement, returns the block and statement within that
+  // block to insert before/after.
+  std::pair<const sem::BlockStatement*, const ast::Statement*>
+  GetInsertionPoint(const ast::Statement* stmt) {
+    using RetType =
+        std::pair<const sem::BlockStatement*, const ast::Statement*>;
+
+    if (auto* sem_stmt = sem.Get(stmt)) {
+      auto* parent = sem_stmt->Parent();
+      return Switch(
+          parent,
+          [&](const sem::BlockStatement* block) -> RetType {
+            // Common case, just insert in the current block above the input
+            // statement.
+            return {block, stmt};
+          },
+          [&](const sem::ForLoopStatement* fl) -> RetType {
+            // `stmt` is either the for loop initializer or the continuing
+            // statement of a for-loop.
+            if (fl->Declaration()->initializer == stmt) {
+              // For loop init, insert above the for loop itself.
+              return {fl->Block(), fl->Declaration()};
+            }
+
+            TINT_ICE(Transform, b.Diagnostics())
+                << "cannot insert before or after continuing statement of a "
+                   "for-loop";
+            return {};
+          },
+          [&](Default) -> RetType {
+            TINT_ICE(Transform, b.Diagnostics())
+                << "expected parent of statement to be either a block or for "
+                   "loop";
+            return {};
+          });
+    }
+
+    return {};
+  }
+
+  // If `block`'s parent is of type TO, returns pointer to it.
+  template <typename TO>
+  const TO* ParentAs(const ast::BlockStatement* block) {
+    if (auto* sem_block = sem.Get(block)) {
+      return As<TO>(sem_block->Parent());
+    }
+    return nullptr;
+  }
+
+  // Returns true if `sem_expr` contains a call expression that may
+  // (transitively) execute a discard statement.
+  bool MayDiscard(const sem::Expression* sem_expr) {
+    return sem_expr && sem_expr->Behaviors().Contains(sem::Behavior::kDiscard);
+  }
+
+  // Lazily creates and returns the name of the module bool variable for whether
+  // to discard: "tint_discard".
+  Symbol ModuleDiscardVarName() {
+    if (!module_discard_var_name.IsValid()) {
+      module_discard_var_name = b.Symbols().New("tint_discard");
+      ctx.dst->Global(module_discard_var_name, b.ty.bool_(), b.Expr(false),
+                      ast::StorageClass::kPrivate);
+    }
+    return module_discard_var_name;
+  }
+
+  // Lazily creates and returns the name of the function that contains a single
+  // discard statement: "tint_discard_func".
+  // We do this to avoid having multiple discard statements in a single program,
+  // which causes problems in certain backends (see crbug.com/1118).
+  Symbol ModuleDiscardFuncName() {
+    if (!module_discard_func_name.IsValid()) {
+      module_discard_func_name = b.Symbols().New("tint_discard_func");
+      b.Func(module_discard_func_name, {}, b.ty.void_(), {b.Discard()});
+    }
+    return module_discard_func_name;
+  }
+
+  // Creates "return <default return value>;" based on the return type of
+  // `stmt`'s owning function.
+  const ast::ReturnStatement* Return(const ast::Statement* stmt) {
+    const ast::Expression* ret_val = nullptr;
+    auto* ret_type = sem.Get(stmt)->Function()->Declaration()->return_type;
+    if (!ret_type->Is<ast::Void>()) {
+      ret_val = b.Construct(ctx.Clone(ret_type));
+    }
+    return b.Return(ret_val);
+  }
+
+  // Returns true if the function `stmt` is in is an entry point
+  bool IsInEntryPointFunc(const ast::Statement* stmt) {
+    return sem.Get(stmt)->Function()->Declaration()->IsEntryPoint();
+  }
+
+  // Creates "tint_discard_func();"
+  const ast::CallStatement* CallDiscardFunc() {
+    auto func_name = ModuleDiscardFuncName();
+    return b.CallStmt(b.Call(func_name));
+  }
+
+  // Creates and returns a new if-statement of the form:
+  //
+  //    if (tint_discard) {
+  //      return <default value>;
+  //    }
+  //
+  // or if `stmt` is in a entry point function:
+  //
+  //    if (tint_discard) {
+  //      tint_discard_func();
+  //      return <default value>;
+  //    }
+  //
+  const ast::IfStatement* IfDiscardReturn(const ast::Statement* stmt) {
+    ast::StatementList stmts;
+
+    // For entry point functions, also emit the discard statement
+    if (IsInEntryPointFunc(stmt)) {
+      stmts.emplace_back(CallDiscardFunc());
+    }
+
+    stmts.emplace_back(Return(stmt));
+
+    auto var_name = ModuleDiscardVarName();
+    return b.If(var_name, b.Block(stmts));
+  }
+
+  // Hoists `sem_expr` to a let followed by an `IfDiscardReturn` before `stmt`.
+  // For example, if `stmt` is:
+  //
+  //    return f();
+  //
+  // This function will transform this to:
+  //
+  //    let t1 = f();
+  //    if (tint_discard) {
+  //      return;
+  //    }
+  //    return t1;
+  //
+  const ast::Statement* HoistAndInsertBefore(const ast::Statement* stmt,
+                                             const sem::Expression* sem_expr) {
+    auto* expr = sem_expr->Declaration();
+
+    auto ip = GetInsertionPoint(stmt);
+    auto var_name = b.Sym();
+    auto* decl = b.Decl(b.Var(var_name, nullptr, ctx.Clone(expr)));
+    ctx.InsertBefore(ip.first->Declaration()->statements, ip.second, decl);
+
+    ctx.InsertBefore(ip.first->Declaration()->statements, ip.second,
+                     IfDiscardReturn(stmt));
+
+    auto* var_expr = b.Expr(var_name);
+
+    // Special handling for CallStatement as we can only replace its expression
+    // with a CallExpression.
+    if (stmt->Is<ast::CallStatement>()) {
+      // We could replace the call statement with no statement, but we can't do
+      // that with transforms (yet), so just return a phony assignment.
+      return b.Assign(b.Phony(), var_expr);
+    }
+
+    ctx.Replace(expr, var_expr);
+    return ctx.CloneWithoutTransform(stmt);
+  }
+
+  // Returns true if `stmt` is a for-loop initializer statement.
+  bool IsForLoopInitStatement(const ast::Statement* stmt) {
+    if (auto* sem_stmt = sem.Get(stmt)) {
+      if (auto* sem_fl = As<sem::ForLoopStatement>(sem_stmt->Parent())) {
+        return sem_fl->Declaration()->initializer == stmt;
+      }
+    }
+    return false;
+  }
+
+  // Inserts an `IfDiscardReturn` after `stmt` if possible (i.e. `stmt` is not
+  // in a for-loop init), otherwise falls back to HoistAndInsertBefore, hoisting
+  // `sem_expr` to a let followed by an `IfDiscardReturn` before `stmt`.
+  //
+  // For example, if `stmt` is:
+  //
+  //    let r = f();
+  //
+  // This function will transform this to:
+  //
+  //    let r = f();
+  //    if (tint_discard) {
+  //      return;
+  //    }
+  const ast::Statement* TryInsertAfter(const ast::Statement* stmt,
+                                       const sem::Expression* sem_expr) {
+    // If `stmt` is the init of a for-loop, hoist and insert before instead.
+    if (IsForLoopInitStatement(stmt)) {
+      return HoistAndInsertBefore(stmt, sem_expr);
+    }
+
+    auto ip = GetInsertionPoint(stmt);
+    ctx.InsertAfter(ip.first->Declaration()->statements, ip.second,
+                    IfDiscardReturn(stmt));
+    return nullptr;  // Don't replace current statement
+  }
+
+  // Replaces the input discard statement with either setting the module level
+  // discard bool ("tint_discard = true"), or calling the discard function
+  // ("tint_discard_func()"), followed by a default return statement.
+  //
+  // Replaces "discard;" with:
+  //
+  //    tint_discard = true;
+  //    return;
+  //
+  // Or if `stmt` is a entry point function, replaces with:
+  //
+  //    tint_discard_func();
+  //    return;
+  //
+  const ast::Statement* ReplaceDiscardStatement(
+      const ast::DiscardStatement* stmt) {
+    const ast::Statement* to_insert = nullptr;
+    if (IsInEntryPointFunc(stmt)) {
+      to_insert = CallDiscardFunc();
+    } else {
+      auto var_name = ModuleDiscardVarName();
+      to_insert = b.Assign(var_name, true);
+    }
+
+    auto ip = GetInsertionPoint(stmt);
+    ctx.InsertBefore(ip.first->Declaration()->statements, ip.second, to_insert);
+    return Return(stmt);
+  }
+
+  // Handle statement
+  const ast::Statement* Statement(const ast::Statement* stmt) {
+    return Switch(
+        stmt,
+        [&](const ast::DiscardStatement* s) -> const ast::Statement* {
+          return ReplaceDiscardStatement(s);
+        },
+        [&](const ast::AssignmentStatement* s) -> const ast::Statement* {
+          auto* sem_lhs = sem.Get(s->lhs);
+          auto* sem_rhs = sem.Get(s->rhs);
+          if (MayDiscard(sem_lhs)) {
+            if (MayDiscard(sem_rhs)) {
+              TINT_ICE(Transform, b.Diagnostics())
+                  << "Unexpected: both sides of assignment statement may "
+                     "discard. Make sure transform::PromoteSideEffectsToDecl "
+                     "was run first.";
+            }
+            return TryInsertAfter(s, sem_lhs);
+          } else if (MayDiscard(sem_rhs)) {
+            return TryInsertAfter(s, sem_rhs);
+          }
+          return nullptr;
+        },
+        [&](const ast::CallStatement* s) -> const ast::Statement* {
+          auto* sem_expr = sem.Get(s->expr);
+          if (!MayDiscard(sem_expr)) {
+            return nullptr;
+          }
+          return TryInsertAfter(s, sem_expr);
+        },
+        [&](const ast::ElseStatement* s) -> const ast::Statement* {
+          if (MayDiscard(sem.Get(s->condition))) {
+            TINT_ICE(Transform, b.Diagnostics())
+                << "Unexpected ElseIf condition that may discard. Make sure "
+                   "transform::PromoteSideEffectsToDecl was run first.";
+          }
+          return nullptr;
+        },
+        [&](const ast::ForLoopStatement* s) -> const ast::Statement* {
+          if (MayDiscard(sem.Get(s->condition))) {
+            TINT_ICE(Transform, b.Diagnostics())
+                << "Unexpected ForLoopStatement condition that may discard. "
+                   "Make sure transform::PromoteSideEffectsToDecl was run "
+                   "first.";
+          }
+          return nullptr;
+        },
+        [&](const ast::IfStatement* s) -> const ast::Statement* {
+          auto* sem_expr = sem.Get(s->condition);
+          if (!MayDiscard(sem_expr)) {
+            return nullptr;
+          }
+          return HoistAndInsertBefore(s, sem_expr);
+        },
+        [&](const ast::ReturnStatement* s) -> const ast::Statement* {
+          auto* sem_expr = sem.Get(s->value);
+          if (!MayDiscard(sem_expr)) {
+            return nullptr;
+          }
+          return HoistAndInsertBefore(s, sem_expr);
+        },
+        [&](const ast::SwitchStatement* s) -> const ast::Statement* {
+          auto* sem_expr = sem.Get(s->condition);
+          if (!MayDiscard(sem_expr)) {
+            return nullptr;
+          }
+          return HoistAndInsertBefore(s, sem_expr);
+        },
+        [&](const ast::VariableDeclStatement* s) -> const ast::Statement* {
+          auto* var = s->variable;
+          if (!var->constructor) {
+            return nullptr;
+          }
+          auto* sem_expr = sem.Get(var->constructor);
+          if (!MayDiscard(sem_expr)) {
+            return nullptr;
+          }
+          return TryInsertAfter(s, sem_expr);
+        });
+  }
+
+ public:
+  /// Constructor
+  /// @param ctx_in the context
+  explicit State(CloneContext& ctx_in)
+      : ctx(ctx_in), b(*ctx_in.dst), sem(ctx_in.src->Sem()) {}
+
+  /// Runs the transform
+  void Run() {
+    ctx.ReplaceAll(
+        [&](const ast::BlockStatement* block) -> const ast::Statement* {
+          // If this block is for an else-if statement, process the else-if now
+          // before processing its block statements.
+          // NOTE: we can't replace else statements at this point - this would
+          // need to be done when replacing the parent if-statement. However, in
+          // this transform, we don't ever expect to need to do this as else-ifs
+          // are converted to else { if } by PromoteSideEffectsToDecl, so this
+          // is only for validation.
+          if (auto* sem_else = ParentAs<sem::ElseStatement>(block)) {
+            if (auto* new_stmt = Statement(sem_else->Declaration())) {
+              TINT_ASSERT(Transform, new_stmt == nullptr);
+              return nullptr;
+            }
+          }
+
+          // Iterate block statements and replace them as needed.
+          for (auto* stmt : block->statements) {
+            if (auto* new_stmt = Statement(stmt)) {
+              ctx.Replace(stmt, new_stmt);
+            }
+
+            // Handle for loops, as they are the only other AST node that
+            // contains statements outside of BlockStatements.
+            if (auto* fl = stmt->As<ast::ForLoopStatement>()) {
+              if (auto* new_stmt = Statement(fl->initializer)) {
+                ctx.Replace(fl->initializer, new_stmt);
+              }
+              if (auto* new_stmt = Statement(fl->continuing)) {
+                // NOTE: Should never reach here as we cannot discard in a
+                // continuing block.
+                ctx.Replace(fl->continuing, new_stmt);
+              }
+            }
+          }
+
+          return nullptr;
+        });
+
+    ctx.Clone();
+  }
+};
+
+}  // namespace
+
+UnwindDiscardFunctions::UnwindDiscardFunctions() = default;
+UnwindDiscardFunctions::~UnwindDiscardFunctions() = default;
+
+void UnwindDiscardFunctions::Run(CloneContext& ctx,
+                                 const DataMap&,
+                                 DataMap&) const {
+  State state(ctx);
+  state.Run();
+}
+
+bool UnwindDiscardFunctions::ShouldRun(const Program* program,
+                                       const DataMap& /*data*/) const {
+  auto& sem = program->Sem();
+  for (auto* f : program->AST().Functions()) {
+    if (sem.Get(f)->Behaviors().Contains(sem::Behavior::kDiscard)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace tint::transform
diff --git a/src/tint/transform/unwind_discard_functions.h b/src/tint/transform/unwind_discard_functions.h
new file mode 100644
index 0000000..42bbecb
--- /dev/null
+++ b/src/tint/transform/unwind_discard_functions.h
@@ -0,0 +1,68 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_TRANSFORM_UNWIND_DISCARD_FUNCTIONS_H_
+#define SRC_TINT_TRANSFORM_UNWIND_DISCARD_FUNCTIONS_H_
+
+#include "src/tint/transform/transform.h"
+
+namespace tint::transform {
+
+/// This transform is responsible for implementing discard semantics as per the
+/// WGSL specification: https://gpuweb.github.io/gpuweb/wgsl/#discard-statement
+///
+/// Not all backend languages implement discard this way (e.g. HLSL), so this
+/// transform does the following:
+///
+/// * Replaces discard statements with setting a module-level boolean
+/// "tint_discard" to true and returning immediately.
+/// * Wherever calls are made to discarding functions (directly or
+/// transitively), it inserts a check afterwards for if "tint_discard" is true,
+/// to return immediately.
+/// * Finally, entry point functions that call discarding functions
+/// emit a call to "tint_discard_func()" that contains the sole discard
+/// statement.
+///
+/// @note Depends on the following transforms to have been run first:
+/// * PromoteSideEffectsToDecl
+class UnwindDiscardFunctions
+    : public Castable<UnwindDiscardFunctions, Transform> {
+ public:
+  /// Constructor
+  UnwindDiscardFunctions();
+
+  /// Destructor
+  ~UnwindDiscardFunctions() override;
+
+ protected:
+  /// Runs the transform using the CloneContext built for transforming a
+  /// program. Run() is responsible for calling Clone() on the CloneContext.
+  /// @param ctx the CloneContext primed with the input program and
+  /// ProgramBuilder
+  /// @param inputs optional extra transform-specific input data
+  /// @param outputs optional extra transform-specific output data
+  void Run(CloneContext& ctx,
+           const DataMap& inputs,
+           DataMap& outputs) const override;
+
+  /// @param program the program to inspect
+  /// @param data optional extra transform-specific input data
+  /// @returns true if this transform should be run for the given program
+  bool ShouldRun(const Program* program,
+                 const DataMap& data = {}) const override;
+};
+
+}  // namespace tint::transform
+
+#endif  // SRC_TINT_TRANSFORM_UNWIND_DISCARD_FUNCTIONS_H_
diff --git a/src/tint/transform/unwind_discard_functions_test.cc b/src/tint/transform/unwind_discard_functions_test.cc
new file mode 100644
index 0000000..ae0a1f1
--- /dev/null
+++ b/src/tint/transform/unwind_discard_functions_test.cc
@@ -0,0 +1,1421 @@
+// Copyright 2022 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/transform/unwind_discard_functions.h"
+#include "src/tint/transform/promote_side_effects_to_decl.h"
+#include "src/tint/transform/test_helper.h"
+
+namespace tint {
+namespace transform {
+namespace {
+
+using UnwindDiscardFunctionsTest = TransformTest;
+
+TEST_F(UnwindDiscardFunctionsTest, EmptyModule) {
+  auto* src = "";
+  auto* expect = src;
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, ShouldRun_NoDiscardFunc) {
+  auto* src = R"(
+fn f() {
+}
+)";
+
+  EXPECT_FALSE(ShouldRun<UnwindDiscardFunctions>(src));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, SingleDiscardFunc_NoCall) {
+  auto* src = R"(
+fn f() {
+  discard;
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() {
+  tint_discard = true;
+  return;
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, MultipleDiscardFuncs_NoCall) {
+  auto* src = R"(
+fn f() {
+  discard;
+  let marker1 = 0;
+}
+
+fn g() {
+  discard;
+  let marker1 = 0;
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() {
+  tint_discard = true;
+  return;
+  let marker1 = 0;
+}
+
+fn g() {
+  tint_discard = true;
+  return;
+  let marker1 = 0;
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Call_VoidReturn) {
+  auto* src = R"(
+fn f() {
+  discard;
+  let marker1 = 0;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  f();
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() {
+  tint_discard = true;
+  return;
+  let marker1 = 0;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Call_NonVoidReturn) {
+  auto* src = R"(
+struct S {
+  x : i32,
+  y : i32,
+};
+
+fn f() -> S {
+  if (true) {
+    discard;
+  }
+  let marker1 = 0;
+  var s : S;
+  return s;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  f();
+  let marker2 = 0;
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+struct S {
+  x : i32,
+  y : i32,
+}
+
+var<private> tint_discard : bool = false;
+
+fn f() -> S {
+  if (true) {
+    tint_discard = true;
+    return S();
+  }
+  let marker1 = 0;
+  var s : S;
+  return s;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let marker2 = 0;
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Call_Nested) {
+  auto* src = R"(
+fn f() -> i32 {
+  let marker1 = 0;
+  if (true) {
+    discard;
+  }
+  let marker2 = 0;
+  return 0;
+}
+
+fn g() -> i32 {
+  let marker1 = 0;
+  f();
+  let marker2 = 0;
+  return 0;
+}
+
+fn h() -> i32{
+  let marker1 = 0;
+  g();
+  let marker2 = 0;
+  return 0;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  h();
+  let marker2 = 0;
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  let marker1 = 0;
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  let marker2 = 0;
+  return 0;
+}
+
+fn g() -> i32 {
+  let marker1 = 0;
+  f();
+  if (tint_discard) {
+    return i32();
+  }
+  let marker2 = 0;
+  return 0;
+}
+
+fn h() -> i32 {
+  let marker1 = 0;
+  g();
+  if (tint_discard) {
+    return i32();
+  }
+  let marker2 = 0;
+  return 0;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  h();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let marker2 = 0;
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Call_Multiple) {
+  auto* src = R"(
+fn f() {
+  discard;
+  let marker1 = 0;
+}
+
+fn g() {
+  discard;
+  let marker1 = 0;
+}
+
+fn h() {
+  discard;
+  let marker1 = 0;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  f();
+  let marker2 = 0;
+  g();
+  let marker3 = 0;
+  h();
+  let marker4 = 0;
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() {
+  tint_discard = true;
+  return;
+  let marker1 = 0;
+}
+
+fn g() {
+  tint_discard = true;
+  return;
+  let marker1 = 0;
+}
+
+fn h() {
+  tint_discard = true;
+  return;
+  let marker1 = 0;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let marker2 = 0;
+  g();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let marker3 = 0;
+  h();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let marker4 = 0;
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Call_DiscardFuncDeclaredBelow) {
+  auto* src = R"(
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  f();
+  let marker1 = 0;
+  return vec4<f32>();
+}
+
+fn f() {
+  discard;
+  let marker1 = 0;
+}
+)";
+  auto* expect = R"(
+fn tint_discard_func() {
+  discard;
+}
+
+var<private> tint_discard : bool = false;
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let marker1 = 0;
+  return vec4<f32>();
+}
+
+fn f() {
+  tint_discard = true;
+  return;
+  let marker1 = 0;
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, If) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  if (f() == 42) {
+    let marker1 = 0;
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 42;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let tint_symbol = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  if ((tint_symbol == 42)) {
+    let marker1 = 0;
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, ElseIf) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  if (true) {
+    let marker1 = 0;
+  } else if (f() == 42) {
+    let marker2 = 0;
+  } else if (true) {
+    let marker3 = 0;
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 42;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  if (true) {
+    let marker1 = 0;
+  } else {
+    let tint_symbol = f();
+    if (tint_discard) {
+      tint_discard_func();
+      return vec4<f32>();
+    }
+    if ((tint_symbol == 42)) {
+      let marker2 = 0;
+    } else if (true) {
+      let marker3 = 0;
+    }
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, ForLoop_Init_Assignment) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  var a = 0;
+  for (a = f(); ; ) {
+    let marker2 = 0;
+    break;
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 42;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  var a = 0;
+  var tint_symbol = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  for(a = tint_symbol; ; ) {
+    let marker2 = 0;
+    break;
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, ForLoop_Init_Call) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  for (f(); ; ) {
+    let marker2 = 0;
+    break;
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 42;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  var tint_symbol = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  for(_ = tint_symbol; ; ) {
+    let marker2 = 0;
+    break;
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, ForLoop_Init_VariableDecl) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  for (let i = f(); ; ) {
+    let marker2 = 0;
+    break;
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 42;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  var tint_symbol = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  for(let i = tint_symbol; ; ) {
+    let marker2 = 0;
+    break;
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, ForLoop_Cond) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  for (; f() == 42; ) {
+    let marker2 = 0;
+    break;
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 42;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  loop {
+    let tint_symbol = f();
+    if (tint_discard) {
+      tint_discard_func();
+      return vec4<f32>();
+    }
+    if (!((tint_symbol == 42))) {
+      break;
+    }
+    {
+      let marker2 = 0;
+      break;
+    }
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, ForLoop_Cont) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  for (; ; f()) {
+    let marker2 = 0;
+    break;
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect =
+      R"(test:12:12 error: cannot call a function that may discard inside a continuing block
+  for (; ; f()) {
+           ^
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Switch) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  switch (f()) {
+    case 0: {
+      let marker1 = 0;
+    }
+    case 1: {
+      let marker2 = 0;
+    }
+    case 42: {
+      let marker3 = 0;
+    }
+    default: {
+      let marker4 = 0;
+    }
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 42;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  var tint_symbol = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  switch(tint_symbol) {
+    case 0: {
+      let marker1 = 0;
+    }
+    case 1: {
+      let marker2 = 0;
+    }
+    case 42: {
+      let marker3 = 0;
+    }
+    default: {
+      let marker4 = 0;
+    }
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Return) {
+  auto* src = R"(
+struct S {
+  x : i32,
+  y : i32,
+};
+
+fn f() -> S {
+  if (true) {
+    discard;
+  }
+  var s : S;
+  return s;
+}
+
+fn g() -> S {
+  return f();
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  g();
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+struct S {
+  x : i32,
+  y : i32,
+}
+
+var<private> tint_discard : bool = false;
+
+fn f() -> S {
+  if (true) {
+    tint_discard = true;
+    return S();
+  }
+  var s : S;
+  return s;
+}
+
+fn g() -> S {
+  var tint_symbol = f();
+  if (tint_discard) {
+    return S();
+  }
+  return tint_symbol;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let marker1 = 0;
+  g();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, VariableDecl) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  var a = f();
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 42;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  var a = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Assignment_RightDiscard) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 42;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  var a : i32;
+  a = f();
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 42;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  var a : i32;
+  a = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Assignment_LeftDiscard) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 0;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  var b = array<i32, 10>();
+  b[f()] = 10;
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 0;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  var b = array<i32, 10>();
+  let tint_symbol = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  b[tint_symbol] = 10;
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Assignment_BothDiscard) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 0;
+}
+
+fn g() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 0;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  var b = array<i32, 10>();
+  b[f()] = g();
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 0;
+}
+
+fn g() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 0;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  var b = array<i32, 10>();
+  let tint_symbol = g();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let tint_symbol_1 = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  b[tint_symbol_1] = tint_symbol;
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Binary_Arith_MultipleDiscardFuncs) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 0;
+}
+
+fn g() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 0;
+}
+
+fn h() -> i32{
+  if (true) {
+    discard;
+  }
+  return 0;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  if ((f() + g() + h()) == 0) {
+    let marker1 = 0;
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 0;
+}
+
+fn g() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 0;
+}
+
+fn h() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 0;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let tint_symbol = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let tint_symbol_1 = g();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  let tint_symbol_2 = h();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  if ((((tint_symbol + tint_symbol_1) + tint_symbol_2) == 0)) {
+    let marker1 = 0;
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, Binary_Logical_MultipleDiscardFuncs) {
+  auto* src = R"(
+fn f() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 0;
+}
+
+fn g() -> i32 {
+  if (true) {
+    discard;
+  }
+  return 0;
+}
+
+fn h() -> i32{
+  if (true) {
+    discard;
+  }
+  return 0;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  if (f() == 1 && g() == 2 && h() == 3) {
+    let marker1 = 0;
+  }
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard : bool = false;
+
+fn f() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 0;
+}
+
+fn g() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 0;
+}
+
+fn h() -> i32 {
+  if (true) {
+    tint_discard = true;
+    return i32();
+  }
+  return 0;
+}
+
+fn tint_discard_func() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  let tint_symbol_2 = f();
+  if (tint_discard) {
+    tint_discard_func();
+    return vec4<f32>();
+  }
+  var tint_symbol_1 = (tint_symbol_2 == 1);
+  if (tint_symbol_1) {
+    let tint_symbol_3 = g();
+    if (tint_discard) {
+      tint_discard_func();
+      return vec4<f32>();
+    }
+    tint_symbol_1 = (tint_symbol_3 == 2);
+  }
+  var tint_symbol = tint_symbol_1;
+  if (tint_symbol) {
+    let tint_symbol_4 = h();
+    if (tint_discard) {
+      tint_discard_func();
+      return vec4<f32>();
+    }
+    tint_symbol = (tint_symbol_4 == 3);
+  }
+  if (tint_symbol) {
+    let marker1 = 0;
+  }
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(UnwindDiscardFunctionsTest, EnsureNoSymbolCollision) {
+  auto* src = R"(
+var<private> tint_discard_func : i32;
+var<private> tint_discard : i32;
+
+fn f() {
+  discard;
+  let marker1 = 0;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in: vec4<f32>) -> @location(0) vec4<f32> {
+  f();
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+  auto* expect = R"(
+var<private> tint_discard_func : i32;
+
+var<private> tint_discard : i32;
+
+var<private> tint_discard_1 : bool = false;
+
+fn f() {
+  tint_discard_1 = true;
+  return;
+  let marker1 = 0;
+}
+
+fn tint_discard_func_1() {
+  discard;
+}
+
+@stage(fragment)
+fn main(@builtin(position) coord_in : vec4<f32>) -> @location(0) vec4<f32> {
+  f();
+  if (tint_discard_1) {
+    tint_discard_func_1();
+    return vec4<f32>();
+  }
+  let marker1 = 0;
+  return vec4<f32>();
+}
+)";
+
+  DataMap data;
+  auto got = Run<PromoteSideEffectsToDecl, UnwindDiscardFunctions>(src, data);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+}  // namespace
+}  // namespace transform
+}  // namespace tint
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index 909fcff..bf35449 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -62,6 +62,7 @@
 #include "src/tint/transform/remove_phonies.h"
 #include "src/tint/transform/simplify_pointers.h"
 #include "src/tint/transform/unshadow.h"
+#include "src/tint/transform/unwind_discard_functions.h"
 #include "src/tint/transform/zero_init_workgroup_memory.h"
 #include "src/tint/utils/defer.h"
 #include "src/tint/utils/map.h"
@@ -187,6 +188,7 @@
   // only accessed directly via member accessors.
   manager.Add<transform::NumWorkgroupsFromUniform>();
   manager.Add<transform::PromoteSideEffectsToDecl>();
+  manager.Add<transform::UnwindDiscardFunctions>();
   manager.Add<transform::SimplifyPointers>();
   manager.Add<transform::RemovePhonies>();
   // ArrayLengthFromUniform must come after InlinePointerLets and Simplify, as
diff --git a/src/tint/writer/msl/generator_impl.cc b/src/tint/writer/msl/generator_impl.cc
index 78388dd..3e8d38b 100644
--- a/src/tint/writer/msl/generator_impl.cc
+++ b/src/tint/writer/msl/generator_impl.cc
@@ -68,6 +68,7 @@
 #include "src/tint/transform/remove_phonies.h"
 #include "src/tint/transform/simplify_pointers.h"
 #include "src/tint/transform/unshadow.h"
+#include "src/tint/transform/unwind_discard_functions.h"
 #include "src/tint/transform/vectorize_scalar_matrix_constructors.h"
 #include "src/tint/transform/wrap_arrays_in_structs.h"
 #include "src/tint/transform/zero_init_workgroup_memory.h"
@@ -174,6 +175,7 @@
   }
   manager.Add<transform::CanonicalizeEntryPointIO>();
   manager.Add<transform::PromoteSideEffectsToDecl>();
+  manager.Add<transform::UnwindDiscardFunctions>();
   manager.Add<transform::PromoteInitializersToConstVar>();
 
   manager.Add<transform::VectorizeScalarMatrixConstructors>();
diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc
index 3b3bdb7..1bf650f 100644
--- a/src/tint/writer/spirv/builder.cc
+++ b/src/tint/writer/spirv/builder.cc
@@ -52,6 +52,7 @@
 #include "src/tint/transform/remove_unreachable_statements.h"
 #include "src/tint/transform/simplify_pointers.h"
 #include "src/tint/transform/unshadow.h"
+#include "src/tint/transform/unwind_discard_functions.h"
 #include "src/tint/transform/var_for_dynamic_index.h"
 #include "src/tint/transform/vectorize_scalar_matrix_constructors.h"
 #include "src/tint/transform/zero_init_workgroup_memory.h"
@@ -278,6 +279,7 @@
   }
   manager.Add<transform::RemoveUnreachableStatements>();
   manager.Add<transform::PromoteSideEffectsToDecl>();
+  manager.Add<transform::UnwindDiscardFunctions>();
   manager.Add<transform::SimplifyPointers>();  // Required for arrayLength()
   manager.Add<transform::FoldConstants>();
   manager.Add<transform::VectorizeScalarMatrixConstructors>();
diff --git a/test/tint/BUILD.gn b/test/tint/BUILD.gn
index 834d948..7f6ec7e 100644
--- a/test/tint/BUILD.gn
+++ b/test/tint/BUILD.gn
@@ -338,6 +338,7 @@
     "../../src/tint/transform/test_helper.h",
     "../../src/tint/transform/transform_test.cc",
     "../../src/tint/transform/unshadow_test.cc",
+    "../../src/tint/transform/unwind_discard_functions_test.cc",
     "../../src/tint/transform/utils/hoist_to_decl_before_test.cc",
     "../../src/tint/transform/var_for_dynamic_index_test.cc",
     "../../src/tint/transform/vectorize_scalar_matrix_constructors_test.cc",
diff --git a/test/tint/bug/dawn/947.wgsl.expected.glsl b/test/tint/bug/dawn/947.wgsl.expected.glsl
index f3e2440..71b989e 100644
--- a/test/tint/bug/dawn/947.wgsl.expected.glsl
+++ b/test/tint/bug/dawn/947.wgsl.expected.glsl
@@ -52,19 +52,29 @@
   vec4 position;
 };
 
+bool tint_discard = false;
 uniform highp sampler2D myTexture_mySampler;
 
 vec4 fs_main(vec2 texcoord) {
   vec2 clampedTexcoord = clamp(texcoord, vec2(0.0f, 0.0f), vec2(1.0f, 1.0f));
   if (!(all(equal(clampedTexcoord, texcoord)))) {
-    discard;
+    tint_discard = true;
+    return vec4(0.0f, 0.0f, 0.0f, 0.0f);
   }
   vec4 srcColor = texture(myTexture_mySampler, texcoord);
   return srcColor;
 }
 
+void tint_discard_func() {
+  discard;
+}
+
 void main() {
   vec4 inner_result = fs_main(texcoord_1);
+  if (tint_discard) {
+    tint_discard_func();
+    return;
+  }
   value = inner_result;
   return;
 }
diff --git a/test/tint/bug/dawn/947.wgsl.expected.hlsl b/test/tint/bug/dawn/947.wgsl.expected.hlsl
index da0ff6a..7bcadcb 100644
--- a/test/tint/bug/dawn/947.wgsl.expected.hlsl
+++ b/test/tint/bug/dawn/947.wgsl.expected.hlsl
@@ -45,21 +45,29 @@
   float4 value : SV_Target0;
 };
 
+static bool tint_discard = false;
+
 float4 fs_main_inner(float2 texcoord) {
-  if (true) {
-    float2 clampedTexcoord = clamp(texcoord, float2(0.0f, 0.0f), float2(1.0f, 1.0f));
-    if (!(all((clampedTexcoord == texcoord)))) {
-      discard;
-    }
-    float4 srcColor = myTexture.Sample(mySampler, texcoord);
-    return srcColor;
+  float2 clampedTexcoord = clamp(texcoord, float2(0.0f, 0.0f), float2(1.0f, 1.0f));
+  if (!(all((clampedTexcoord == texcoord)))) {
+    tint_discard = true;
+    return float4(0.0f, 0.0f, 0.0f, 0.0f);
   }
-  float4 unused;
-  return unused;
+  float4 srcColor = myTexture.Sample(mySampler, texcoord);
+  return srcColor;
+}
+
+void tint_discard_func() {
+  discard;
 }
 
 tint_symbol_5 fs_main(tint_symbol_4 tint_symbol_3) {
   const float4 inner_result_1 = fs_main_inner(tint_symbol_3.texcoord);
+  if (tint_discard) {
+    tint_discard_func();
+    const tint_symbol_5 tint_symbol_8 = (tint_symbol_5)0;
+    return tint_symbol_8;
+  }
   tint_symbol_5 wrapper_result_1 = (tint_symbol_5)0;
   wrapper_result_1.value = inner_result_1;
   return wrapper_result_1;
diff --git a/test/tint/bug/dawn/947.wgsl.expected.msl b/test/tint/bug/dawn/947.wgsl.expected.msl
index 22bfdd3..15efcd0 100644
--- a/test/tint/bug/dawn/947.wgsl.expected.msl
+++ b/test/tint/bug/dawn/947.wgsl.expected.msl
@@ -20,21 +20,21 @@
   float2 arr[3];
 };
 
-VertexOutputs vs_main_inner(uint VertexIndex, const constant Uniforms* const tint_symbol_4) {
+VertexOutputs vs_main_inner(uint VertexIndex, const constant Uniforms* const tint_symbol_5) {
   tint_array_wrapper texcoord = {.arr={float2(-0.5f, 0.0f), float2(1.5f, 0.0f), float2(0.5f, 2.0f)}};
   VertexOutputs output = {};
   output.position = float4(((texcoord.arr[VertexIndex] * 2.0f) - float2(1.0f, 1.0f)), 0.0f, 1.0f);
-  bool flipY = ((*(tint_symbol_4)).u_scale[1] < 0.0f);
+  bool flipY = ((*(tint_symbol_5)).u_scale[1] < 0.0f);
   if (flipY) {
-    output.texcoords = ((((texcoord.arr[VertexIndex] * (*(tint_symbol_4)).u_scale) + (*(tint_symbol_4)).u_offset) * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f));
+    output.texcoords = ((((texcoord.arr[VertexIndex] * (*(tint_symbol_5)).u_scale) + (*(tint_symbol_5)).u_offset) * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f));
   } else {
-    output.texcoords = ((((texcoord.arr[VertexIndex] * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f)) * (*(tint_symbol_4)).u_scale) + (*(tint_symbol_4)).u_offset);
+    output.texcoords = ((((texcoord.arr[VertexIndex] * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f)) * (*(tint_symbol_5)).u_scale) + (*(tint_symbol_5)).u_offset);
   }
   return output;
 }
 
-vertex tint_symbol vs_main(const constant Uniforms* tint_symbol_5 [[buffer(0)]], uint VertexIndex [[vertex_id]]) {
-  VertexOutputs const inner_result = vs_main_inner(VertexIndex, tint_symbol_5);
+vertex tint_symbol vs_main(const constant Uniforms* tint_symbol_6 [[buffer(0)]], uint VertexIndex [[vertex_id]]) {
+  VertexOutputs const inner_result = vs_main_inner(VertexIndex, tint_symbol_6);
   tint_symbol wrapper_result = {};
   wrapper_result.texcoords = inner_result.texcoords;
   wrapper_result.position = inner_result.position;
@@ -49,17 +49,28 @@
   float4 value [[color(0)]];
 };
 
-float4 fs_main_inner(float2 texcoord, texture2d<float, access::sample> tint_symbol_6, sampler tint_symbol_7) {
+float4 fs_main_inner(float2 texcoord, thread bool* const tint_symbol_7, texture2d<float, access::sample> tint_symbol_8, sampler tint_symbol_9) {
   float2 clampedTexcoord = clamp(texcoord, float2(0.0f, 0.0f), float2(1.0f, 1.0f));
   if (!(all((clampedTexcoord == texcoord)))) {
-    discard_fragment();
+    *(tint_symbol_7) = true;
+    return float4();
   }
-  float4 srcColor = tint_symbol_6.sample(tint_symbol_7, texcoord);
+  float4 srcColor = tint_symbol_8.sample(tint_symbol_9, texcoord);
   return srcColor;
 }
 
-fragment tint_symbol_3 fs_main(texture2d<float, access::sample> tint_symbol_8 [[texture(0)]], sampler tint_symbol_9 [[sampler(0)]], tint_symbol_2 tint_symbol_1 [[stage_in]]) {
-  float4 const inner_result_1 = fs_main_inner(tint_symbol_1.texcoord, tint_symbol_8, tint_symbol_9);
+void tint_discard_func() {
+  discard_fragment();
+}
+
+fragment tint_symbol_3 fs_main(texture2d<float, access::sample> tint_symbol_11 [[texture(0)]], sampler tint_symbol_12 [[sampler(0)]], tint_symbol_2 tint_symbol_1 [[stage_in]]) {
+  thread bool tint_symbol_10 = false;
+  float4 const inner_result_1 = fs_main_inner(tint_symbol_1.texcoord, &(tint_symbol_10), tint_symbol_11, tint_symbol_12);
+  if (tint_symbol_10) {
+    tint_discard_func();
+    tint_symbol_3 const tint_symbol_4 = {};
+    return tint_symbol_4;
+  }
   tint_symbol_3 wrapper_result_1 = {};
   wrapper_result_1.value = inner_result_1;
   return wrapper_result_1;
diff --git a/test/tint/bug/dawn/947.wgsl.expected.spvasm b/test/tint/bug/dawn/947.wgsl.expected.spvasm
index cfe88b2..df48a9a 100644
--- a/test/tint/bug/dawn/947.wgsl.expected.spvasm
+++ b/test/tint/bug/dawn/947.wgsl.expected.spvasm
@@ -1,10 +1,10 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 137
+; Bound: 140
 ; Schema: 0
                OpCapability Shader
-        %116 = OpExtInstImport "GLSL.std.450"
+        %118 = OpExtInstImport "GLSL.std.450"
                OpMemoryModel Logical GLSL450
                OpEntryPoint Vertex %vs_main "vs_main" %VertexIndex_1 %texcoords_1 %position_1 %vertex_point_size
                OpEntryPoint Fragment %fs_main "fs_main" %texcoord_1 %value
@@ -30,6 +30,7 @@
                OpName %output "output"
                OpName %flipY "flipY"
                OpName %vs_main "vs_main"
+               OpName %tint_discard_func "tint_discard_func"
                OpName %fs_main_inner "fs_main_inner"
                OpName %texcoord_0 "texcoord"
                OpName %clampedTexcoord "clampedTexcoord"
@@ -114,10 +115,10 @@
          %89 = OpConstantComposite %v2float %float_0 %float_1
        %void = OpTypeVoid
         %103 = OpTypeFunction %void
-        %111 = OpTypeFunction %v4float %v2float
-        %117 = OpConstantComposite %v2float %float_0 %float_0
+        %113 = OpTypeFunction %v4float %v2float
+        %119 = OpConstantComposite %v2float %float_0 %float_0
      %v2bool = OpTypeVector %bool 2
-        %129 = OpTypeSampledImage %27
+        %132 = OpTypeSampledImage %27
 %vs_main_inner = OpFunction %VertexOutputs None %28
 %VertexIndex = OpFunctionParameter %uint
          %32 = OpLabel
@@ -184,34 +185,39 @@
                OpStore %vertex_point_size %float_1
                OpReturn
                OpFunctionEnd
-%fs_main_inner = OpFunction %v4float None %111
+%tint_discard_func = OpFunction %void None %103
+        %112 = OpLabel
+               OpKill
+               OpFunctionEnd
+%fs_main_inner = OpFunction %v4float None %113
  %texcoord_0 = OpFunctionParameter %v2float
-        %114 = OpLabel
+        %116 = OpLabel
 %clampedTexcoord = OpVariable %_ptr_Function_v2float Function %8
    %srcColor = OpVariable %_ptr_Function_v4float Function %12
-        %115 = OpExtInst %v2float %116 NClamp %texcoord_0 %117 %58
-               OpStore %clampedTexcoord %115
-        %121 = OpLoad %v2float %clampedTexcoord
-        %122 = OpFOrdEqual %v2bool %121 %texcoord_0
-        %120 = OpAll %bool %122
-        %119 = OpLogicalNot %bool %120
-               OpSelectionMerge %124 None
-               OpBranchConditional %119 %125 %124
-        %125 = OpLabel
-               OpKill
-        %124 = OpLabel
-        %127 = OpLoad %24 %mySampler
-        %128 = OpLoad %27 %myTexture
-        %130 = OpSampledImage %129 %128 %127
-        %126 = OpImageSampleImplicitLod %v4float %130 %texcoord_0
-               OpStore %srcColor %126
-        %132 = OpLoad %v4float %srcColor
-               OpReturnValue %132
+        %117 = OpExtInst %v2float %118 NClamp %texcoord_0 %119 %58
+               OpStore %clampedTexcoord %117
+        %123 = OpLoad %v2float %clampedTexcoord
+        %124 = OpFOrdEqual %v2bool %123 %texcoord_0
+        %122 = OpAll %bool %124
+        %121 = OpLogicalNot %bool %122
+               OpSelectionMerge %126 None
+               OpBranchConditional %121 %127 %126
+        %127 = OpLabel
+        %128 = OpFunctionCall %void %tint_discard_func
+               OpReturnValue %12
+        %126 = OpLabel
+        %130 = OpLoad %24 %mySampler
+        %131 = OpLoad %27 %myTexture
+        %133 = OpSampledImage %132 %131 %130
+        %129 = OpImageSampleImplicitLod %v4float %133 %texcoord_0
+               OpStore %srcColor %129
+        %135 = OpLoad %v4float %srcColor
+               OpReturnValue %135
                OpFunctionEnd
     %fs_main = OpFunction %void None %103
-        %134 = OpLabel
-        %136 = OpLoad %v2float %texcoord_1
-        %135 = OpFunctionCall %v4float %fs_main_inner %136
-               OpStore %value %135
+        %137 = OpLabel
+        %139 = OpLoad %v2float %texcoord_1
+        %138 = OpFunctionCall %v4float %fs_main_inner %139
+               OpStore %value %138
                OpReturn
                OpFunctionEnd
diff --git a/test/tint/bug/tint/1081.wgsl.expected.glsl b/test/tint/bug/tint/1081.wgsl.expected.glsl
index 3b4deae..5bef660 100644
--- a/test/tint/bug/tint/1081.wgsl.expected.glsl
+++ b/test/tint/bug/tint/1081.wgsl.expected.glsl
@@ -3,9 +3,11 @@
 
 layout(location = 1) flat in ivec3 x_1;
 layout(location = 2) out int value;
+bool tint_discard = false;
 int f(int x) {
   if ((x == 10)) {
-    discard;
+    tint_discard = true;
+    return 0;
   }
   return x;
 }
@@ -14,6 +16,9 @@
   int y = x.x;
   while (true) {
     int r = f(y);
+    if (tint_discard) {
+      return 0;
+    }
     if ((r == 0)) {
       break;
     }
@@ -21,8 +26,16 @@
   return y;
 }
 
+void tint_discard_func() {
+  discard;
+}
+
 void main() {
   int inner_result = tint_symbol(x_1);
+  if (tint_discard) {
+    tint_discard_func();
+    return;
+  }
   value = inner_result;
   return;
 }
diff --git a/test/tint/bug/tint/1081.wgsl.expected.hlsl b/test/tint/bug/tint/1081.wgsl.expected.hlsl
index ad9174c..60ace97 100644
--- a/test/tint/bug/tint/1081.wgsl.expected.hlsl
+++ b/test/tint/bug/tint/1081.wgsl.expected.hlsl
@@ -1,12 +1,11 @@
+static bool tint_discard = false;
+
 int f(int x) {
-  if (true) {
-    if ((x == 10)) {
-      discard;
-    }
-    return x;
+  if ((x == 10)) {
+    tint_discard = true;
+    return 0;
   }
-  int unused;
-  return unused;
+  return x;
 }
 
 struct tint_symbol_1 {
@@ -20,6 +19,9 @@
   int y = x.x;
   [loop] while (true) {
     const int r = f(y);
+    if (tint_discard) {
+      return 0;
+    }
     if ((r == 0)) {
       break;
     }
@@ -27,8 +29,17 @@
   return y;
 }
 
+void tint_discard_func() {
+  discard;
+}
+
 tint_symbol_2 main(tint_symbol_1 tint_symbol) {
   const int inner_result = main_inner(tint_symbol.x);
+  if (tint_discard) {
+    tint_discard_func();
+    const tint_symbol_2 tint_symbol_3 = (tint_symbol_2)0;
+    return tint_symbol_3;
+  }
   tint_symbol_2 wrapper_result = (tint_symbol_2)0;
   wrapper_result.value = inner_result;
   return wrapper_result;
diff --git a/test/tint/bug/tint/1081.wgsl.expected.msl b/test/tint/bug/tint/1081.wgsl.expected.msl
index 34ebe0c..8304df1 100644
--- a/test/tint/bug/tint/1081.wgsl.expected.msl
+++ b/test/tint/bug/tint/1081.wgsl.expected.msl
@@ -1,9 +1,10 @@
 #include <metal_stdlib>
 
 using namespace metal;
-int f(int x) {
+int f(int x, thread bool* const tint_symbol_5) {
   if ((x == 10)) {
-    discard_fragment();
+    *(tint_symbol_5) = true;
+    return int();
   }
   return x;
 }
@@ -16,10 +17,13 @@
   int value [[color(2)]];
 };
 
-int tint_symbol_inner(int3 x) {
+int tint_symbol_inner(int3 x, thread bool* const tint_symbol_6) {
   int y = x[0];
   while (true) {
-    int const r = f(y);
+    int const r = f(y, tint_symbol_6);
+    if (*(tint_symbol_6)) {
+      return int();
+    }
     if ((r == 0)) {
       break;
     }
@@ -27,8 +31,18 @@
   return y;
 }
 
+void tint_discard_func() {
+  discard_fragment();
+}
+
 fragment tint_symbol_3 tint_symbol(tint_symbol_2 tint_symbol_1 [[stage_in]]) {
-  int const inner_result = tint_symbol_inner(tint_symbol_1.x);
+  thread bool tint_symbol_7 = false;
+  int const inner_result = tint_symbol_inner(tint_symbol_1.x, &(tint_symbol_7));
+  if (tint_symbol_7) {
+    tint_discard_func();
+    tint_symbol_3 const tint_symbol_4 = {};
+    return tint_symbol_4;
+  }
   tint_symbol_3 wrapper_result = {};
   wrapper_result.value = inner_result;
   return wrapper_result;
diff --git a/test/tint/bug/tint/1081.wgsl.expected.spvasm b/test/tint/bug/tint/1081.wgsl.expected.spvasm
index 2f5ee3f..53e025c 100644
--- a/test/tint/bug/tint/1081.wgsl.expected.spvasm
+++ b/test/tint/bug/tint/1081.wgsl.expected.spvasm
@@ -1,7 +1,7 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 41
+; Bound: 51
 ; Schema: 0
                OpCapability Shader
                OpMemoryModel Logical GLSL450
@@ -9,8 +9,10 @@
                OpExecutionMode %main OriginUpperLeft
                OpName %x_1 "x_1"
                OpName %value "value"
+               OpName %tint_discard "tint_discard"
                OpName %f "f"
                OpName %x "x"
+               OpName %tint_discard_func "tint_discard_func"
                OpName %main_inner "main_inner"
                OpName %x_0 "x"
                OpName %y "y"
@@ -25,55 +27,71 @@
 %_ptr_Output_int = OpTypePointer Output %int
           %7 = OpConstantNull %int
       %value = OpVariable %_ptr_Output_int Output %7
-          %8 = OpTypeFunction %int %int
-     %int_10 = OpConstant %int 10
        %bool = OpTypeBool
-         %17 = OpTypeFunction %int %v3int
+      %false = OpConstantFalse %bool
+%_ptr_Private_bool = OpTypePointer Private %bool
+%tint_discard = OpVariable %_ptr_Private_bool Private %false
+         %12 = OpTypeFunction %int %int
+     %int_10 = OpConstant %int 10
+       %true = OpConstantTrue %bool
+       %void = OpTypeVoid
+         %21 = OpTypeFunction %void
+         %25 = OpTypeFunction %int %v3int
 %_ptr_Function_int = OpTypePointer Function %int
       %int_0 = OpConstant %int 0
-       %void = OpTypeVoid
-         %35 = OpTypeFunction %void
-          %f = OpFunction %int None %8
+          %f = OpFunction %int None %12
           %x = OpFunctionParameter %int
-         %11 = OpLabel
-         %13 = OpIEqual %bool %x %int_10
-               OpSelectionMerge %15 None
-               OpBranchConditional %13 %16 %15
-         %16 = OpLabel
-               OpKill
          %15 = OpLabel
+         %17 = OpIEqual %bool %x %int_10
+               OpSelectionMerge %18 None
+               OpBranchConditional %17 %19 %18
+         %19 = OpLabel
+               OpStore %tint_discard %true
+               OpReturnValue %7
+         %18 = OpLabel
                OpReturnValue %x
                OpFunctionEnd
- %main_inner = OpFunction %int None %17
-        %x_0 = OpFunctionParameter %v3int
-         %20 = OpLabel
-          %y = OpVariable %_ptr_Function_int Function %7
-         %21 = OpCompositeExtract %int %x_0 0
-               OpStore %y %21
-               OpBranch %24
+%tint_discard_func = OpFunction %void None %21
          %24 = OpLabel
-               OpLoopMerge %25 %26 None
-               OpBranch %27
-         %27 = OpLabel
-         %29 = OpLoad %int %y
-         %28 = OpFunctionCall %int %f %29
-         %31 = OpIEqual %bool %28 %int_0
-               OpSelectionMerge %32 None
-               OpBranchConditional %31 %33 %32
-         %33 = OpLabel
-               OpBranch %25
-         %32 = OpLabel
-               OpBranch %26
-         %26 = OpLabel
-               OpBranch %24
-         %25 = OpLabel
-         %34 = OpLoad %int %y
-               OpReturnValue %34
+               OpKill
                OpFunctionEnd
-       %main = OpFunction %void None %35
-         %38 = OpLabel
-         %40 = OpLoad %v3int %x_1
-         %39 = OpFunctionCall %int %main_inner %40
-               OpStore %value %39
+ %main_inner = OpFunction %int None %25
+        %x_0 = OpFunctionParameter %v3int
+         %28 = OpLabel
+          %y = OpVariable %_ptr_Function_int Function %7
+         %29 = OpCompositeExtract %int %x_0 0
+               OpStore %y %29
+               OpBranch %32
+         %32 = OpLabel
+               OpLoopMerge %33 %34 None
+               OpBranch %35
+         %35 = OpLabel
+         %37 = OpLoad %int %y
+         %36 = OpFunctionCall %int %f %37
+         %38 = OpLoad %bool %tint_discard
+               OpSelectionMerge %39 None
+               OpBranchConditional %38 %40 %39
+         %40 = OpLabel
+         %41 = OpFunctionCall %void %tint_discard_func
+               OpReturnValue %7
+         %39 = OpLabel
+         %43 = OpIEqual %bool %36 %int_0
+               OpSelectionMerge %44 None
+               OpBranchConditional %43 %45 %44
+         %45 = OpLabel
+               OpBranch %33
+         %44 = OpLabel
+               OpBranch %34
+         %34 = OpLabel
+               OpBranch %32
+         %33 = OpLabel
+         %46 = OpLoad %int %y
+               OpReturnValue %46
+               OpFunctionEnd
+       %main = OpFunction %void None %21
+         %48 = OpLabel
+         %50 = OpLoad %v3int %x_1
+         %49 = OpFunctionCall %int %main_inner %50
+               OpStore %value %49
                OpReturn
                OpFunctionEnd
diff --git a/test/tint/bug/tint/1118.wgsl.expected.glsl b/test/tint/bug/tint/1118.wgsl.expected.glsl
index 7f61d30..a9bb098 100644
--- a/test/tint/bug/tint/1118.wgsl.expected.glsl
+++ b/test/tint/bug/tint/1118.wgsl.expected.glsl
@@ -39,6 +39,7 @@
 } x_137;
 
 vec4 glFragColor = vec4(0.0f, 0.0f, 0.0f, 0.0f);
+bool tint_discard = false;
 void main_1() {
   vec3 viewDirectionW = vec3(0.0f, 0.0f, 0.0f);
   vec4 baseColor = vec4(0.0f, 0.0f, 0.0f, 0.0f);
@@ -57,10 +58,12 @@
   vec3 finalSpecular = vec3(0.0f, 0.0f, 0.0f);
   vec4 color = vec4(0.0f, 0.0f, 0.0f, 0.0f);
   if ((fClipDistance3 > 0.0f)) {
-    discard;
+    tint_discard = true;
+    return;
   }
   if ((fClipDistance4 > 0.0f)) {
-    discard;
+    tint_discard = true;
+    return;
   }
   vec4 x_34 = x_29.vEyePosition;
   vec3 x_38 = vec3(0.0f, 0.0f, 0.0f);
@@ -115,12 +118,24 @@
   fClipDistance3 = fClipDistance3_param;
   fClipDistance4 = fClipDistance4_param;
   main_1();
-  main_out tint_symbol_1 = main_out(glFragColor);
-  return tint_symbol_1;
+  if (tint_discard) {
+    main_out tint_symbol_1 = main_out(vec4(0.0f, 0.0f, 0.0f, 0.0f));
+    return tint_symbol_1;
+  }
+  main_out tint_symbol_2 = main_out(glFragColor);
+  return tint_symbol_2;
+}
+
+void tint_discard_func() {
+  discard;
 }
 
 void main() {
   main_out inner_result = tint_symbol(fClipDistance3_param_1, fClipDistance4_param_1);
+  if (tint_discard) {
+    tint_discard_func();
+    return;
+  }
   glFragColor_1_1 = inner_result.glFragColor_1;
   return;
 }
diff --git a/test/tint/bug/tint/1118.wgsl.expected.hlsl b/test/tint/bug/tint/1118.wgsl.expected.hlsl
index 9d86c0e..117a578 100644
--- a/test/tint/bug/tint/1118.wgsl.expected.hlsl
+++ b/test/tint/bug/tint/1118.wgsl.expected.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
 static float fClipDistance3 = 0.0f;
 static float fClipDistance4 = 0.0f;
 cbuffer cbuffer_x_29 : register(b0, space0) {
@@ -12,6 +10,7 @@
   uint4 x_137[1];
 };
 static float4 glFragColor = float4(0.0f, 0.0f, 0.0f, 0.0f);
+static bool tint_discard = false;
 
 void main_1() {
   float3 viewDirectionW = float3(0.0f, 0.0f, 0.0f);
@@ -31,10 +30,12 @@
   float3 finalSpecular = float3(0.0f, 0.0f, 0.0f);
   float4 color = float4(0.0f, 0.0f, 0.0f, 0.0f);
   if ((fClipDistance3 > 0.0f)) {
-    discard;
+    tint_discard = true;
+    return;
   }
   if ((fClipDistance4 > 0.0f)) {
-    discard;
+    tint_discard = true;
+    return;
   }
   const float4 x_34 = asfloat(x_29[0]);
   const float3 x_38 = float3(0.0f, 0.0f, 0.0f);
@@ -96,15 +97,26 @@
   fClipDistance3 = fClipDistance3_param;
   fClipDistance4 = fClipDistance4_param;
   main_1();
-  const main_out tint_symbol_8 = {glFragColor};
-  return tint_symbol_8;
+  if (tint_discard) {
+    const main_out tint_symbol_8 = (main_out)0;
+    return tint_symbol_8;
+  }
+  const main_out tint_symbol_9 = {glFragColor};
+  return tint_symbol_9;
+}
+
+void tint_discard_func() {
+  discard;
 }
 
 tint_symbol_2 main(tint_symbol_1 tint_symbol) {
   const main_out inner_result = main_inner(tint_symbol.fClipDistance3_param, tint_symbol.fClipDistance4_param);
+  if (tint_discard) {
+    tint_discard_func();
+    const tint_symbol_2 tint_symbol_10 = (tint_symbol_2)0;
+    return tint_symbol_10;
+  }
   tint_symbol_2 wrapper_result = (tint_symbol_2)0;
   wrapper_result.glFragColor_1 = inner_result.glFragColor_1;
   return wrapper_result;
 }
-Internal error: unread predicate
-
diff --git a/test/tint/bug/tint/1118.wgsl.expected.msl b/test/tint/bug/tint/1118.wgsl.expected.msl
index 6f56a9c..e1bcabf 100644
--- a/test/tint/bug/tint/1118.wgsl.expected.msl
+++ b/test/tint/bug/tint/1118.wgsl.expected.msl
@@ -28,7 +28,7 @@
   /* 0x0000 */ float visibility;
 };
 
-void main_1(thread float* const tint_symbol_5, thread float* const tint_symbol_6, const constant Scene* const tint_symbol_7, const constant Material* const tint_symbol_8, const constant Mesh* const tint_symbol_9, thread float4* const tint_symbol_10) {
+void main_1(thread float* const tint_symbol_7, thread bool* const tint_symbol_8, thread float* const tint_symbol_9, const constant Scene* const tint_symbol_10, const constant Material* const tint_symbol_11, const constant Mesh* const tint_symbol_12, thread float4* const tint_symbol_13) {
   float3 viewDirectionW = 0.0f;
   float4 baseColor = 0.0f;
   float3 diffuseColor = 0.0f;
@@ -45,21 +45,23 @@
   float3 finalDiffuse = 0.0f;
   float3 finalSpecular = 0.0f;
   float4 color = 0.0f;
-  float const x_9 = *(tint_symbol_5);
+  float const x_9 = *(tint_symbol_7);
   if ((x_9 > 0.0f)) {
-    discard_fragment();
+    *(tint_symbol_8) = true;
+    return;
   }
-  float const x_17 = *(tint_symbol_6);
+  float const x_17 = *(tint_symbol_9);
   if ((x_17 > 0.0f)) {
-    discard_fragment();
+    *(tint_symbol_8) = true;
+    return;
   }
-  float4 const x_34 = (*(tint_symbol_7)).vEyePosition;
+  float4 const x_34 = (*(tint_symbol_10)).vEyePosition;
   float3 const x_38 = float3(0.0f, 0.0f, 0.0f);
   viewDirectionW = normalize((float3(x_34[0], x_34[1], x_34[2]) - x_38));
   baseColor = float4(1.0f, 1.0f, 1.0f, 1.0f);
-  float4 const x_52 = (*(tint_symbol_8)).vDiffuseColor;
+  float4 const x_52 = (*(tint_symbol_11)).vDiffuseColor;
   diffuseColor = float3(x_52[0], x_52[1], x_52[2]);
-  float const x_60 = (*(tint_symbol_8)).vDiffuseColor[3];
+  float const x_60 = (*(tint_symbol_11)).vDiffuseColor[3];
   alpha = x_60;
   float3 const x_62 = float3(0.0f, 0.0f, 0.0f);
   float3 const x_64 = float3(0.0f, 0.0f, 0.0f);
@@ -76,12 +78,12 @@
   shadow = 1.0f;
   refractionColor = float4(0.0f, 0.0f, 0.0f, 1.0f);
   reflectionColor = float4(0.0f, 0.0f, 0.0f, 1.0f);
-  float3 const x_94 = (*(tint_symbol_8)).vEmissiveColor;
+  float3 const x_94 = (*(tint_symbol_11)).vEmissiveColor;
   emissiveColor = x_94;
   float3 const x_96 = diffuseBase;
   float3 const x_97 = diffuseColor;
   float3 const x_99 = emissiveColor;
-  float3 const x_103 = (*(tint_symbol_8)).vAmbientColor;
+  float3 const x_103 = (*(tint_symbol_11)).vAmbientColor;
   float4 const x_108 = baseColor;
   finalDiffuse = (clamp((((x_96 * x_97) + x_99) + x_103), float3(0.0f, 0.0f, 0.0f), float3(1.0f, 1.0f, 1.0f)) * float3(x_108[0], x_108[1], x_108[2]));
   finalSpecular = float3(0.0f, 0.0f, 0.0f);
@@ -97,11 +99,11 @@
   float3 const x_132 = fmax(float3(x_129[0], x_129[1], x_129[2]), float3(0.0f, 0.0f, 0.0f));
   float4 const x_133 = color;
   color = float4(x_132[0], x_132[1], x_132[2], x_133[3]);
-  float const x_140 = (*(tint_symbol_9)).visibility;
+  float const x_140 = (*(tint_symbol_12)).visibility;
   float const x_142 = color[3];
   color[3] = (x_142 * x_140);
   float4 const x_147 = color;
-  *(tint_symbol_10) = x_147;
+  *(tint_symbol_13) = x_147;
   return;
 }
 
@@ -118,19 +120,33 @@
   float4 glFragColor_1 [[color(0)]];
 };
 
-main_out tint_symbol_inner(float fClipDistance3_param, float fClipDistance4_param, thread float* const tint_symbol_11, thread float* const tint_symbol_12, const constant Scene* const tint_symbol_13, const constant Material* const tint_symbol_14, const constant Mesh* const tint_symbol_15, thread float4* const tint_symbol_16) {
-  *(tint_symbol_11) = fClipDistance3_param;
-  *(tint_symbol_12) = fClipDistance4_param;
-  main_1(tint_symbol_11, tint_symbol_12, tint_symbol_13, tint_symbol_14, tint_symbol_15, tint_symbol_16);
-  main_out const tint_symbol_4 = {.glFragColor_1=*(tint_symbol_16)};
-  return tint_symbol_4;
+main_out tint_symbol_inner(float fClipDistance3_param, float fClipDistance4_param, thread float* const tint_symbol_14, thread float* const tint_symbol_15, thread bool* const tint_symbol_16, const constant Scene* const tint_symbol_17, const constant Material* const tint_symbol_18, const constant Mesh* const tint_symbol_19, thread float4* const tint_symbol_20) {
+  *(tint_symbol_14) = fClipDistance3_param;
+  *(tint_symbol_15) = fClipDistance4_param;
+  main_1(tint_symbol_14, tint_symbol_16, tint_symbol_15, tint_symbol_17, tint_symbol_18, tint_symbol_19, tint_symbol_20);
+  if (*(tint_symbol_16)) {
+    main_out const tint_symbol_4 = {};
+    return tint_symbol_4;
+  }
+  main_out const tint_symbol_5 = {.glFragColor_1=*(tint_symbol_20)};
+  return tint_symbol_5;
 }
 
-fragment tint_symbol_3 tint_symbol(const constant Scene* tint_symbol_19 [[buffer(0)]], const constant Material* tint_symbol_20 [[buffer(1)]], const constant Mesh* tint_symbol_21 [[buffer(2)]], tint_symbol_2 tint_symbol_1 [[stage_in]]) {
-  thread float tint_symbol_17 = 0.0f;
-  thread float tint_symbol_18 = 0.0f;
-  thread float4 tint_symbol_22 = 0.0f;
-  main_out const inner_result = tint_symbol_inner(tint_symbol_1.fClipDistance3_param, tint_symbol_1.fClipDistance4_param, &(tint_symbol_17), &(tint_symbol_18), tint_symbol_19, tint_symbol_20, tint_symbol_21, &(tint_symbol_22));
+void tint_discard_func() {
+  discard_fragment();
+}
+
+fragment tint_symbol_3 tint_symbol(const constant Scene* tint_symbol_24 [[buffer(0)]], const constant Material* tint_symbol_25 [[buffer(1)]], const constant Mesh* tint_symbol_26 [[buffer(2)]], tint_symbol_2 tint_symbol_1 [[stage_in]]) {
+  thread float tint_symbol_21 = 0.0f;
+  thread float tint_symbol_22 = 0.0f;
+  thread bool tint_symbol_23 = false;
+  thread float4 tint_symbol_27 = 0.0f;
+  main_out const inner_result = tint_symbol_inner(tint_symbol_1.fClipDistance3_param, tint_symbol_1.fClipDistance4_param, &(tint_symbol_21), &(tint_symbol_22), &(tint_symbol_23), tint_symbol_24, tint_symbol_25, tint_symbol_26, &(tint_symbol_27));
+  if (tint_symbol_23) {
+    tint_discard_func();
+    tint_symbol_3 const tint_symbol_6 = {};
+    return tint_symbol_6;
+  }
   tint_symbol_3 wrapper_result = {};
   wrapper_result.glFragColor_1 = inner_result.glFragColor_1;
   return wrapper_result;
diff --git a/test/tint/bug/tint/1118.wgsl.expected.spvasm b/test/tint/bug/tint/1118.wgsl.expected.spvasm
index 390f103..3023204 100644
--- a/test/tint/bug/tint/1118.wgsl.expected.spvasm
+++ b/test/tint/bug/tint/1118.wgsl.expected.spvasm
@@ -1,10 +1,10 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 187
+; Bound: 198
 ; Schema: 0
                OpCapability Shader
-         %69 = OpExtInstImport "GLSL.std.450"
+         %73 = OpExtInstImport "GLSL.std.450"
                OpMemoryModel Logical GLSL450
                OpEntryPoint Fragment %main "main" %fClipDistance3_param_1 %fClipDistance4_param_1 %glFragColor_1_1
                OpExecutionMode %main OriginUpperLeft
@@ -27,6 +27,7 @@
                OpMemberName %Mesh 0 "visibility"
                OpName %x_137 "x_137"
                OpName %glFragColor "glFragColor"
+               OpName %tint_discard "tint_discard"
                OpName %main_1 "main_1"
                OpName %viewDirectionW "viewDirectionW"
                OpName %baseColor "baseColor"
@@ -44,6 +45,7 @@
                OpName %finalDiffuse "finalDiffuse"
                OpName %finalSpecular "finalSpecular"
                OpName %color "color"
+               OpName %tint_discard_func "tint_discard_func"
                OpName %main_out "main_out"
                OpMemberName %main_out 0 "glFragColor_1"
                OpName %main_inner "main_inner"
@@ -97,199 +99,217 @@
       %x_137 = OpVariable %_ptr_Uniform_Mesh Uniform
 %_ptr_Private_v4float = OpTypePointer Private %v4float
 %glFragColor = OpVariable %_ptr_Private_v4float Private %8
+       %bool = OpTypeBool
+      %false = OpConstantFalse %bool
+%_ptr_Private_bool = OpTypePointer Private %bool
+%tint_discard = OpVariable %_ptr_Private_bool Private %false
        %void = OpTypeVoid
-         %25 = OpTypeFunction %void
+         %29 = OpTypeFunction %void
 %_ptr_Function_v3float = OpTypePointer Function %v3float
-         %31 = OpConstantNull %v3float
+         %35 = OpConstantNull %v3float
 %_ptr_Function_v4float = OpTypePointer Function %v4float
 %_ptr_Function_float = OpTypePointer Function %float
     %v2float = OpTypeVector %float 2
 %_ptr_Function_v2float = OpTypePointer Function %v2float
-         %41 = OpConstantNull %v2float
+         %45 = OpConstantNull %v2float
     %float_0 = OpConstant %float 0
-       %bool = OpTypeBool
+       %true = OpConstantTrue %bool
        %uint = OpTypeInt 32 0
      %uint_0 = OpConstant %uint 0
 %_ptr_Uniform_v4float = OpTypePointer Uniform %v4float
-         %67 = OpConstantComposite %v3float %float_0 %float_0 %float_0
+         %71 = OpConstantComposite %v3float %float_0 %float_0 %float_0
     %float_1 = OpConstant %float 1
-         %76 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1
+         %80 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1
      %uint_3 = OpConstant %uint 3
 %_ptr_Uniform_float = OpTypePointer Uniform %float
-         %92 = OpConstantComposite %v2float %float_0 %float_0
-         %93 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0
-        %110 = OpConstantComposite %v3float %float_1 %float_1 %float_1
-        %111 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1
+         %96 = OpConstantComposite %v2float %float_0 %float_0
+         %97 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_0
+        %114 = OpConstantComposite %v3float %float_1 %float_1 %float_1
+        %115 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1
 %_ptr_Uniform_v3float = OpTypePointer Uniform %v3float
      %uint_1 = OpConstant %uint 1
    %main_out = OpTypeStruct %v4float
-        %172 = OpTypeFunction %main_out %float %float
-     %main_1 = OpFunction %void None %25
-         %28 = OpLabel
-%viewDirectionW = OpVariable %_ptr_Function_v3float Function %31
+        %178 = OpTypeFunction %main_out %float %float
+        %189 = OpConstantNull %main_out
+     %main_1 = OpFunction %void None %29
+         %32 = OpLabel
+%viewDirectionW = OpVariable %_ptr_Function_v3float Function %35
   %baseColor = OpVariable %_ptr_Function_v4float Function %8
-%diffuseColor = OpVariable %_ptr_Function_v3float Function %31
+%diffuseColor = OpVariable %_ptr_Function_v3float Function %35
       %alpha = OpVariable %_ptr_Function_float Function %11
-    %normalW = OpVariable %_ptr_Function_v3float Function %31
-   %uvOffset = OpVariable %_ptr_Function_v2float Function %41
-%baseAmbientColor = OpVariable %_ptr_Function_v3float Function %31
+    %normalW = OpVariable %_ptr_Function_v3float Function %35
+   %uvOffset = OpVariable %_ptr_Function_v2float Function %45
+%baseAmbientColor = OpVariable %_ptr_Function_v3float Function %35
  %glossiness = OpVariable %_ptr_Function_float Function %11
-%diffuseBase = OpVariable %_ptr_Function_v3float Function %31
+%diffuseBase = OpVariable %_ptr_Function_v3float Function %35
      %shadow = OpVariable %_ptr_Function_float Function %11
 %refractionColor = OpVariable %_ptr_Function_v4float Function %8
 %reflectionColor = OpVariable %_ptr_Function_v4float Function %8
-%emissiveColor = OpVariable %_ptr_Function_v3float Function %31
-%finalDiffuse = OpVariable %_ptr_Function_v3float Function %31
-%finalSpecular = OpVariable %_ptr_Function_v3float Function %31
+%emissiveColor = OpVariable %_ptr_Function_v3float Function %35
+%finalDiffuse = OpVariable %_ptr_Function_v3float Function %35
+%finalSpecular = OpVariable %_ptr_Function_v3float Function %35
       %color = OpVariable %_ptr_Function_v4float Function %8
-         %52 = OpLoad %float %fClipDistance3
-         %54 = OpFOrdGreaterThan %bool %52 %float_0
-               OpSelectionMerge %56 None
-               OpBranchConditional %54 %57 %56
-         %57 = OpLabel
-               OpKill
-         %56 = OpLabel
-         %58 = OpLoad %float %fClipDistance4
-         %59 = OpFOrdGreaterThan %bool %58 %float_0
-               OpSelectionMerge %60 None
-               OpBranchConditional %59 %61 %60
-         %61 = OpLabel
-               OpKill
+         %56 = OpLoad %float %fClipDistance3
+         %58 = OpFOrdGreaterThan %bool %56 %float_0
+               OpSelectionMerge %59 None
+               OpBranchConditional %58 %60 %59
          %60 = OpLabel
-         %65 = OpAccessChain %_ptr_Uniform_v4float %x_29 %uint_0
-         %66 = OpLoad %v4float %65
-         %70 = OpCompositeExtract %float %66 0
-         %71 = OpCompositeExtract %float %66 1
-         %72 = OpCompositeExtract %float %66 2
-         %73 = OpCompositeConstruct %v3float %70 %71 %72
-         %74 = OpFSub %v3float %73 %67
-         %68 = OpExtInst %v3float %69 Normalize %74
-               OpStore %viewDirectionW %68
-               OpStore %baseColor %76
-         %77 = OpAccessChain %_ptr_Uniform_v4float %x_49 %uint_0
-         %78 = OpLoad %v4float %77
-         %79 = OpCompositeExtract %float %78 0
-         %80 = OpCompositeExtract %float %78 1
-         %81 = OpCompositeExtract %float %78 2
-         %82 = OpCompositeConstruct %v3float %79 %80 %81
-               OpStore %diffuseColor %82
-         %85 = OpAccessChain %_ptr_Uniform_float %x_49 %uint_0 %uint_3
-         %86 = OpLoad %float %85
-               OpStore %alpha %86
-         %90 = OpDPdx %v3float %67
-         %91 = OpDPdy %v3float %67
-         %89 = OpExtInst %v3float %69 Cross %90 %91
-         %88 = OpFNegate %v3float %89
-         %87 = OpExtInst %v3float %69 Normalize %88
-               OpStore %normalW %87
-               OpStore %uvOffset %92
-         %94 = OpLoad %v4float %baseColor
-         %95 = OpCompositeExtract %float %94 0
-         %96 = OpCompositeExtract %float %94 1
-         %97 = OpCompositeExtract %float %94 2
-         %98 = OpCompositeConstruct %v3float %95 %96 %97
-         %99 = OpCompositeExtract %float %93 0
-        %100 = OpCompositeExtract %float %93 1
-        %101 = OpCompositeExtract %float %93 2
+               OpStore %tint_discard %true
+               OpReturn
+         %59 = OpLabel
+         %62 = OpLoad %float %fClipDistance4
+         %63 = OpFOrdGreaterThan %bool %62 %float_0
+               OpSelectionMerge %64 None
+               OpBranchConditional %63 %65 %64
+         %65 = OpLabel
+               OpStore %tint_discard %true
+               OpReturn
+         %64 = OpLabel
+         %69 = OpAccessChain %_ptr_Uniform_v4float %x_29 %uint_0
+         %70 = OpLoad %v4float %69
+         %74 = OpCompositeExtract %float %70 0
+         %75 = OpCompositeExtract %float %70 1
+         %76 = OpCompositeExtract %float %70 2
+         %77 = OpCompositeConstruct %v3float %74 %75 %76
+         %78 = OpFSub %v3float %77 %71
+         %72 = OpExtInst %v3float %73 Normalize %78
+               OpStore %viewDirectionW %72
+               OpStore %baseColor %80
+         %81 = OpAccessChain %_ptr_Uniform_v4float %x_49 %uint_0
+         %82 = OpLoad %v4float %81
+         %83 = OpCompositeExtract %float %82 0
+         %84 = OpCompositeExtract %float %82 1
+         %85 = OpCompositeExtract %float %82 2
+         %86 = OpCompositeConstruct %v3float %83 %84 %85
+               OpStore %diffuseColor %86
+         %89 = OpAccessChain %_ptr_Uniform_float %x_49 %uint_0 %uint_3
+         %90 = OpLoad %float %89
+               OpStore %alpha %90
+         %94 = OpDPdx %v3float %71
+         %95 = OpDPdy %v3float %71
+         %93 = OpExtInst %v3float %73 Cross %94 %95
+         %92 = OpFNegate %v3float %93
+         %91 = OpExtInst %v3float %73 Normalize %92
+               OpStore %normalW %91
+               OpStore %uvOffset %96
+         %98 = OpLoad %v4float %baseColor
+         %99 = OpCompositeExtract %float %98 0
+        %100 = OpCompositeExtract %float %98 1
+        %101 = OpCompositeExtract %float %98 2
         %102 = OpCompositeConstruct %v3float %99 %100 %101
-        %103 = OpFMul %v3float %98 %102
-        %104 = OpLoad %v4float %baseColor
-        %105 = OpCompositeExtract %float %103 0
-        %106 = OpCompositeExtract %float %103 1
-        %107 = OpCompositeExtract %float %103 2
-        %108 = OpCompositeExtract %float %104 3
-        %109 = OpCompositeConstruct %v4float %105 %106 %107 %108
-               OpStore %baseColor %109
-               OpStore %baseAmbientColor %110
+        %103 = OpCompositeExtract %float %97 0
+        %104 = OpCompositeExtract %float %97 1
+        %105 = OpCompositeExtract %float %97 2
+        %106 = OpCompositeConstruct %v3float %103 %104 %105
+        %107 = OpFMul %v3float %102 %106
+        %108 = OpLoad %v4float %baseColor
+        %109 = OpCompositeExtract %float %107 0
+        %110 = OpCompositeExtract %float %107 1
+        %111 = OpCompositeExtract %float %107 2
+        %112 = OpCompositeExtract %float %108 3
+        %113 = OpCompositeConstruct %v4float %109 %110 %111 %112
+               OpStore %baseColor %113
+               OpStore %baseAmbientColor %114
                OpStore %glossiness %float_0
-               OpStore %diffuseBase %67
+               OpStore %diffuseBase %71
                OpStore %shadow %float_1
-               OpStore %refractionColor %111
-               OpStore %reflectionColor %111
-        %113 = OpAccessChain %_ptr_Uniform_v3float %x_49 %uint_3
-        %114 = OpLoad %v3float %113
-               OpStore %emissiveColor %114
-        %115 = OpLoad %v3float %diffuseBase
-        %116 = OpLoad %v3float %diffuseColor
-        %117 = OpLoad %v3float %emissiveColor
-        %119 = OpAccessChain %_ptr_Uniform_v3float %x_49 %uint_1
-        %120 = OpLoad %v3float %119
-        %121 = OpLoad %v4float %baseColor
-        %123 = OpFMul %v3float %115 %116
-        %124 = OpFAdd %v3float %123 %117
-        %125 = OpFAdd %v3float %124 %120
-        %122 = OpExtInst %v3float %69 NClamp %125 %67 %110
-        %126 = OpCompositeExtract %float %121 0
-        %127 = OpCompositeExtract %float %121 1
-        %128 = OpCompositeExtract %float %121 2
-        %129 = OpCompositeConstruct %v3float %126 %127 %128
-        %130 = OpFMul %v3float %122 %129
-               OpStore %finalDiffuse %130
-               OpStore %finalSpecular %67
-        %131 = OpLoad %v3float %finalDiffuse
-        %132 = OpLoad %v3float %baseAmbientColor
-        %133 = OpLoad %v3float %finalSpecular
-        %134 = OpLoad %v4float %reflectionColor
-        %135 = OpLoad %v4float %refractionColor
-        %136 = OpFMul %v3float %131 %132
-        %137 = OpFAdd %v3float %136 %133
-        %138 = OpCompositeExtract %float %134 0
-        %139 = OpCompositeExtract %float %134 1
-        %140 = OpCompositeExtract %float %134 2
-        %141 = OpCompositeConstruct %v3float %138 %139 %140
-        %142 = OpFAdd %v3float %137 %141
-        %143 = OpCompositeExtract %float %135 0
-        %144 = OpCompositeExtract %float %135 1
-        %145 = OpCompositeExtract %float %135 2
-        %146 = OpCompositeConstruct %v3float %143 %144 %145
-        %147 = OpFAdd %v3float %142 %146
-        %148 = OpLoad %float %alpha
-        %149 = OpCompositeExtract %float %147 0
-        %150 = OpCompositeExtract %float %147 1
-        %151 = OpCompositeExtract %float %147 2
-        %152 = OpCompositeConstruct %v4float %149 %150 %151 %148
-               OpStore %color %152
-        %153 = OpLoad %v4float %color
-        %155 = OpCompositeExtract %float %153 0
-        %156 = OpCompositeExtract %float %153 1
-        %157 = OpCompositeExtract %float %153 2
-        %158 = OpCompositeConstruct %v3float %155 %156 %157
-        %154 = OpExtInst %v3float %69 NMax %158 %67
-        %159 = OpLoad %v4float %color
-        %160 = OpCompositeExtract %float %154 0
-        %161 = OpCompositeExtract %float %154 1
-        %162 = OpCompositeExtract %float %154 2
-        %163 = OpCompositeExtract %float %159 3
-        %164 = OpCompositeConstruct %v4float %160 %161 %162 %163
-               OpStore %color %164
-        %165 = OpAccessChain %_ptr_Uniform_float %x_137 %uint_0
-        %166 = OpLoad %float %165
-        %167 = OpAccessChain %_ptr_Function_float %color %uint_3
-        %168 = OpLoad %float %167
-        %169 = OpAccessChain %_ptr_Function_float %color %uint_3
-        %170 = OpFMul %float %168 %166
-               OpStore %169 %170
-        %171 = OpLoad %v4float %color
-               OpStore %glFragColor %171
+               OpStore %refractionColor %115
+               OpStore %reflectionColor %115
+        %117 = OpAccessChain %_ptr_Uniform_v3float %x_49 %uint_3
+        %118 = OpLoad %v3float %117
+               OpStore %emissiveColor %118
+        %119 = OpLoad %v3float %diffuseBase
+        %120 = OpLoad %v3float %diffuseColor
+        %121 = OpLoad %v3float %emissiveColor
+        %123 = OpAccessChain %_ptr_Uniform_v3float %x_49 %uint_1
+        %124 = OpLoad %v3float %123
+        %125 = OpLoad %v4float %baseColor
+        %127 = OpFMul %v3float %119 %120
+        %128 = OpFAdd %v3float %127 %121
+        %129 = OpFAdd %v3float %128 %124
+        %126 = OpExtInst %v3float %73 NClamp %129 %71 %114
+        %130 = OpCompositeExtract %float %125 0
+        %131 = OpCompositeExtract %float %125 1
+        %132 = OpCompositeExtract %float %125 2
+        %133 = OpCompositeConstruct %v3float %130 %131 %132
+        %134 = OpFMul %v3float %126 %133
+               OpStore %finalDiffuse %134
+               OpStore %finalSpecular %71
+        %135 = OpLoad %v3float %finalDiffuse
+        %136 = OpLoad %v3float %baseAmbientColor
+        %137 = OpLoad %v3float %finalSpecular
+        %138 = OpLoad %v4float %reflectionColor
+        %139 = OpLoad %v4float %refractionColor
+        %140 = OpFMul %v3float %135 %136
+        %141 = OpFAdd %v3float %140 %137
+        %142 = OpCompositeExtract %float %138 0
+        %143 = OpCompositeExtract %float %138 1
+        %144 = OpCompositeExtract %float %138 2
+        %145 = OpCompositeConstruct %v3float %142 %143 %144
+        %146 = OpFAdd %v3float %141 %145
+        %147 = OpCompositeExtract %float %139 0
+        %148 = OpCompositeExtract %float %139 1
+        %149 = OpCompositeExtract %float %139 2
+        %150 = OpCompositeConstruct %v3float %147 %148 %149
+        %151 = OpFAdd %v3float %146 %150
+        %152 = OpLoad %float %alpha
+        %153 = OpCompositeExtract %float %151 0
+        %154 = OpCompositeExtract %float %151 1
+        %155 = OpCompositeExtract %float %151 2
+        %156 = OpCompositeConstruct %v4float %153 %154 %155 %152
+               OpStore %color %156
+        %157 = OpLoad %v4float %color
+        %159 = OpCompositeExtract %float %157 0
+        %160 = OpCompositeExtract %float %157 1
+        %161 = OpCompositeExtract %float %157 2
+        %162 = OpCompositeConstruct %v3float %159 %160 %161
+        %158 = OpExtInst %v3float %73 NMax %162 %71
+        %163 = OpLoad %v4float %color
+        %164 = OpCompositeExtract %float %158 0
+        %165 = OpCompositeExtract %float %158 1
+        %166 = OpCompositeExtract %float %158 2
+        %167 = OpCompositeExtract %float %163 3
+        %168 = OpCompositeConstruct %v4float %164 %165 %166 %167
+               OpStore %color %168
+        %169 = OpAccessChain %_ptr_Uniform_float %x_137 %uint_0
+        %170 = OpLoad %float %169
+        %171 = OpAccessChain %_ptr_Function_float %color %uint_3
+        %172 = OpLoad %float %171
+        %173 = OpAccessChain %_ptr_Function_float %color %uint_3
+        %174 = OpFMul %float %172 %170
+               OpStore %173 %174
+        %175 = OpLoad %v4float %color
+               OpStore %glFragColor %175
                OpReturn
                OpFunctionEnd
- %main_inner = OpFunction %main_out None %172
+%tint_discard_func = OpFunction %void None %29
+        %177 = OpLabel
+               OpKill
+               OpFunctionEnd
+ %main_inner = OpFunction %main_out None %178
 %fClipDistance3_param = OpFunctionParameter %float
 %fClipDistance4_param = OpFunctionParameter %float
-        %177 = OpLabel
+        %183 = OpLabel
                OpStore %fClipDistance3 %fClipDistance3_param
                OpStore %fClipDistance4 %fClipDistance4_param
-        %178 = OpFunctionCall %void %main_1
-        %179 = OpLoad %v4float %glFragColor
-        %180 = OpCompositeConstruct %main_out %179
-               OpReturnValue %180
+        %184 = OpFunctionCall %void %main_1
+        %185 = OpLoad %bool %tint_discard
+               OpSelectionMerge %186 None
+               OpBranchConditional %185 %187 %186
+        %187 = OpLabel
+        %188 = OpFunctionCall %void %tint_discard_func
+               OpReturnValue %189
+        %186 = OpLabel
+        %190 = OpLoad %v4float %glFragColor
+        %191 = OpCompositeConstruct %main_out %190
+               OpReturnValue %191
                OpFunctionEnd
-       %main = OpFunction %void None %25
-        %182 = OpLabel
-        %184 = OpLoad %float %fClipDistance3_param_1
-        %185 = OpLoad %float %fClipDistance4_param_1
-        %183 = OpFunctionCall %main_out %main_inner %184 %185
-        %186 = OpCompositeExtract %v4float %183 0
-               OpStore %glFragColor_1_1 %186
+       %main = OpFunction %void None %29
+        %193 = OpLabel
+        %195 = OpLoad %float %fClipDistance3_param_1
+        %196 = OpLoad %float %fClipDistance4_param_1
+        %194 = OpFunctionCall %main_out %main_inner %195 %196
+        %197 = OpCompositeExtract %v4float %194 0
+               OpStore %glFragColor_1_1 %197
                OpReturn
                OpFunctionEnd
diff --git a/test/tint/bug/tint/1369.wgsl.expected.glsl b/test/tint/bug/tint/1369.wgsl.expected.glsl
index 4d0b9b7..dbecc85 100644
--- a/test/tint/bug/tint/1369.wgsl.expected.glsl
+++ b/test/tint/bug/tint/1369.wgsl.expected.glsl
@@ -9,17 +9,30 @@
 #version 310 es
 precision mediump float;
 
+bool tint_discard = false;
 bool call_discard() {
-  discard;
+  tint_discard = true;
+  return false;
   return true;
 }
 
 void f() {
   bool v = call_discard();
+  if (tint_discard) {
+    return;
+  }
   bool also_unreachable = false;
 }
 
+void tint_discard_func() {
+  discard;
+}
+
 void main() {
   f();
+  if (tint_discard) {
+    tint_discard_func();
+    return;
+  }
   return;
 }
diff --git a/test/tint/bug/tint/1369.wgsl.expected.hlsl b/test/tint/bug/tint/1369.wgsl.expected.hlsl
index dff55b3..d0fffc5 100644
--- a/test/tint/bug/tint/1369.wgsl.expected.hlsl
+++ b/test/tint/bug/tint/1369.wgsl.expected.hlsl
@@ -6,17 +6,24 @@
     var also_unreachable : bool;
         ^^^^^^^^^^^^^^^^
 
+static bool tint_discard = false;
+
 bool call_discard() {
-  if (true) {
-    discard;
-    return true;
-  }
-  bool unused;
-  return unused;
+  tint_discard = true;
+  return false;
+  return true;
+}
+
+void tint_discard_func() {
+  discard;
 }
 
 void f() {
   bool v = call_discard();
+  if (tint_discard) {
+    tint_discard_func();
+    return;
+  }
   bool also_unreachable = false;
   return;
 }
diff --git a/test/tint/bug/tint/1369.wgsl.expected.msl b/test/tint/bug/tint/1369.wgsl.expected.msl
index 8d1a7d7..e5ce396 100644
--- a/test/tint/bug/tint/1369.wgsl.expected.msl
+++ b/test/tint/bug/tint/1369.wgsl.expected.msl
@@ -9,13 +9,23 @@
 #include <metal_stdlib>
 
 using namespace metal;
-bool call_discard() {
-  discard_fragment();
+bool call_discard(thread bool* const tint_symbol) {
+  *(tint_symbol) = true;
+  return bool();
   return true;
 }
 
+void tint_discard_func() {
+  discard_fragment();
+}
+
 fragment void f() {
-  bool v = call_discard();
+  thread bool tint_symbol_1 = false;
+  bool v = call_discard(&(tint_symbol_1));
+  if (tint_symbol_1) {
+    tint_discard_func();
+    return;
+  }
   bool also_unreachable = false;
   return;
 }
diff --git a/test/tint/bug/tint/1369.wgsl.expected.spvasm b/test/tint/bug/tint/1369.wgsl.expected.spvasm
index a78ae04..e3ece9c 100644
--- a/test/tint/bug/tint/1369.wgsl.expected.spvasm
+++ b/test/tint/bug/tint/1369.wgsl.expected.spvasm
@@ -9,29 +9,47 @@
 ; SPIR-V
 ; Version: 1.3
 ; Generator: Google Tint Compiler; 0
-; Bound: 13
+; Bound: 23
 ; Schema: 0
                OpCapability Shader
                OpMemoryModel Logical GLSL450
                OpEntryPoint Fragment %f "f"
                OpExecutionMode %f OriginUpperLeft
+               OpName %tint_discard "tint_discard"
                OpName %call_discard "call_discard"
+               OpName %tint_discard_func "tint_discard_func"
                OpName %f "f"
                OpName %v "v"
        %bool = OpTypeBool
-          %1 = OpTypeFunction %bool
+      %false = OpConstantFalse %bool
+%_ptr_Private_bool = OpTypePointer Private %bool
+%tint_discard = OpVariable %_ptr_Private_bool Private %false
+          %5 = OpTypeFunction %bool
+       %true = OpConstantTrue %bool
+          %9 = OpConstantNull %bool
        %void = OpTypeVoid
-          %5 = OpTypeFunction %void
+         %10 = OpTypeFunction %void
 %_ptr_Function_bool = OpTypePointer Function %bool
-         %12 = OpConstantNull %bool
-%call_discard = OpFunction %bool None %1
-          %4 = OpLabel
+%call_discard = OpFunction %bool None %5
+          %7 = OpLabel
+               OpStore %tint_discard %true
+               OpReturnValue %9
+               OpFunctionEnd
+%tint_discard_func = OpFunction %void None %10
+         %13 = OpLabel
                OpKill
                OpFunctionEnd
-          %f = OpFunction %void None %5
-          %8 = OpLabel
-          %v = OpVariable %_ptr_Function_bool Function %12
-          %9 = OpFunctionCall %bool %call_discard
-               OpStore %v %9
+          %f = OpFunction %void None %10
+         %15 = OpLabel
+          %v = OpVariable %_ptr_Function_bool Function %9
+         %16 = OpFunctionCall %bool %call_discard
+               OpStore %v %16
+         %19 = OpLoad %bool %tint_discard
+               OpSelectionMerge %20 None
+               OpBranchConditional %19 %21 %20
+         %21 = OpLabel
+         %22 = OpFunctionCall %void %tint_discard_func
+               OpReturn
+         %20 = OpLabel
                OpReturn
                OpFunctionEnd
diff --git a/test/tint/unittest/reader/spirv/SpvParserCFGTest_EmitBody_Kill_InsideLoop.spvasm.expected.hlsl b/test/tint/unittest/reader/spirv/SpvParserCFGTest_EmitBody_Kill_InsideLoop.spvasm.expected.hlsl
deleted file mode 100644
index cc96aff..0000000
--- a/test/tint/unittest/reader/spirv/SpvParserCFGTest_EmitBody_Kill_InsideLoop.spvasm.expected.hlsl
+++ /dev/null
@@ -1,17 +0,0 @@
-SKIP: FAILED
-
-warning: code is unreachable
-static uint var_1 = 0u;
-
-void main_1() {
-  [loop] while (true) {
-    discard;
-  }
-  discard;
-}
-
-void main() {
-  main_1();
-  return;
-}
-
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/call-function-with-discard/0-opt.spvasm.expected.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/call-function-with-discard/0-opt.spvasm.expected.hlsl
deleted file mode 100644
index 1db4c8c..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/call-function-with-discard/0-opt.spvasm.expected.hlsl
+++ /dev/null
@@ -1,50 +0,0 @@
-SKIP: FAILED
-
-cbuffer cbuffer_x_6 : register(b0, space0) {
-  uint4 x_6[1];
-};
-static float4 x_GLF_color = float4(0.0f, 0.0f, 0.0f, 0.0f);
-
-void func_() {
-  const float x_28 = asfloat(x_6[0].x);
-  if ((1.0f > x_28)) {
-    discard;
-  }
-  return;
-}
-
-void main_1() {
-  x_GLF_color = float4(0.0f, 0.0f, 0.0f, 0.0f);
-  [loop] while (true) {
-    func_();
-    if (false) {
-    } else {
-      break;
-    }
-  }
-  x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
-  return;
-}
-
-struct main_out {
-  float4 x_GLF_color_1;
-};
-struct tint_symbol {
-  float4 x_GLF_color_1 : SV_Target0;
-};
-
-main_out main_inner() {
-  main_1();
-  const main_out tint_symbol_2 = {x_GLF_color};
-  return tint_symbol_2;
-}
-
-tint_symbol main() {
-  const main_out inner_result = main_inner();
-  tint_symbol wrapper_result = (tint_symbol)0;
-  wrapper_result.x_GLF_color_1 = inner_result.x_GLF_color_1;
-  return wrapper_result;
-}
-C:\src\tint\test\Shader@0x0000016102DC2B30(16,10-21): warning X3557: loop only executes for 0 iteration(s), consider removing [loop]
-C:\src\tint\test\Shader@0x0000016102DC2B30(8,15-18): internal error: invalid access of unbound variable
-
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/call-function-with-discard/0-opt.wgsl.expected.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/call-function-with-discard/0-opt.wgsl.expected.hlsl
deleted file mode 100644
index a528cf5..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/call-function-with-discard/0-opt.wgsl.expected.hlsl
+++ /dev/null
@@ -1,50 +0,0 @@
-SKIP: FAILED
-
-cbuffer cbuffer_x_6 : register(b0, space0) {
-  uint4 x_6[1];
-};
-static float4 x_GLF_color = float4(0.0f, 0.0f, 0.0f, 0.0f);
-
-void func_() {
-  const float x_28 = asfloat(x_6[0].x);
-  if ((1.0f > x_28)) {
-    discard;
-  }
-  return;
-}
-
-void main_1() {
-  x_GLF_color = float4(0.0f, 0.0f, 0.0f, 0.0f);
-  [loop] while (true) {
-    func_();
-    if (false) {
-    } else {
-      break;
-    }
-  }
-  x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
-  return;
-}
-
-struct main_out {
-  float4 x_GLF_color_1;
-};
-struct tint_symbol {
-  float4 x_GLF_color_1 : SV_Target0;
-};
-
-main_out main_inner() {
-  main_1();
-  const main_out tint_symbol_2 = {x_GLF_color};
-  return tint_symbol_2;
-}
-
-tint_symbol main() {
-  const main_out inner_result = main_inner();
-  tint_symbol wrapper_result = (tint_symbol)0;
-  wrapper_result.x_GLF_color_1 = inner_result.x_GLF_color_1;
-  return wrapper_result;
-}
-C:\src\tint\test\Shader@0x0000026A3937ED10(16,10-21): warning X3557: loop only executes for 0 iteration(s), consider removing [loop]
-C:\src\tint\test\Shader@0x0000026A3937ED10(8,15-18): internal error: invalid access of unbound variable
-
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/stable-binarysearch-tree-false-if-discard-loop/1.spvasm.expected.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/stable-binarysearch-tree-false-if-discard-loop/1.spvasm.expected.hlsl
deleted file mode 100755
index 1626926..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/stable-binarysearch-tree-false-if-discard-loop/1.spvasm.expected.hlsl
+++ /dev/null
Binary files differ
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/stable-binarysearch-tree-false-if-discard-loop/1.wgsl.expected.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/stable-binarysearch-tree-false-if-discard-loop/1.wgsl.expected.hlsl
deleted file mode 100755
index 711e15f..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/stable-binarysearch-tree-false-if-discard-loop/1.wgsl.expected.hlsl
+++ /dev/null
Binary files differ
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/unreachable-discard-statement-in-if/0-opt.spvasm.expected.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/unreachable-discard-statement-in-if/0-opt.spvasm.expected.hlsl
deleted file mode 100644
index 1f1e152..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/unreachable-discard-statement-in-if/0-opt.spvasm.expected.hlsl
+++ /dev/null
@@ -1,64 +0,0 @@
-SKIP: FAILED
-
-cbuffer cbuffer_x_7 : register(b0, space0) {
-  uint4 x_7[1];
-};
-static float4 gl_FragCoord = float4(0.0f, 0.0f, 0.0f, 0.0f);
-static float4 x_GLF_color = float4(0.0f, 0.0f, 0.0f, 0.0f);
-
-float3 computePoint_() {
-  if (true) {
-    const float x_48 = asfloat(x_7[0].x);
-    const float x_50 = asfloat(x_7[0].y);
-    if ((x_48 > x_50)) {
-      discard;
-    }
-    return float3(0.0f, 0.0f, 0.0f);
-  }
-  float3 unused;
-  return unused;
-}
-
-void main_1() {
-  bool x_34 = false;
-  [loop] while (true) {
-    const float3 x_36 = computePoint_();
-    const float x_41 = gl_FragCoord.x;
-    if ((x_41 < 0.0f)) {
-      x_34 = true;
-      break;
-    }
-    const float3 x_45 = computePoint_();
-    x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
-    x_34 = true;
-    break;
-  }
-  return;
-}
-
-struct main_out {
-  float4 x_GLF_color_1;
-};
-struct tint_symbol_1 {
-  float4 gl_FragCoord_param : SV_Position;
-};
-struct tint_symbol_2 {
-  float4 x_GLF_color_1 : SV_Target0;
-};
-
-main_out main_inner(float4 gl_FragCoord_param) {
-  gl_FragCoord = gl_FragCoord_param;
-  main_1();
-  const main_out tint_symbol_4 = {x_GLF_color};
-  return tint_symbol_4;
-}
-
-tint_symbol_2 main(tint_symbol_1 tint_symbol) {
-  const main_out inner_result = main_inner(tint_symbol.gl_FragCoord_param);
-  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
-  wrapper_result.x_GLF_color_1 = inner_result.x_GLF_color_1;
-  return wrapper_result;
-}
-C:\src\tint\test\Shader@0x0000014F8C58FE70(22,10-21): warning X3557: loop only executes for 0 iteration(s), consider removing [loop]
-C:\src\tint\test\Shader@0x0000014F8C58FE70(11,10-13): internal error: invalid access of unbound variable
-
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/unreachable-discard-statement-in-if/0-opt.wgsl.expected.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/unreachable-discard-statement-in-if/0-opt.wgsl.expected.hlsl
deleted file mode 100644
index 1bbf048..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/unreachable-discard-statement-in-if/0-opt.wgsl.expected.hlsl
+++ /dev/null
@@ -1,64 +0,0 @@
-SKIP: FAILED
-
-cbuffer cbuffer_x_7 : register(b0, space0) {
-  uint4 x_7[1];
-};
-static float4 gl_FragCoord = float4(0.0f, 0.0f, 0.0f, 0.0f);
-static float4 x_GLF_color = float4(0.0f, 0.0f, 0.0f, 0.0f);
-
-float3 computePoint_() {
-  if (true) {
-    const float x_48 = asfloat(x_7[0].x);
-    const float x_50 = asfloat(x_7[0].y);
-    if ((x_48 > x_50)) {
-      discard;
-    }
-    return float3(0.0f, 0.0f, 0.0f);
-  }
-  float3 unused;
-  return unused;
-}
-
-void main_1() {
-  bool x_34 = false;
-  [loop] while (true) {
-    const float3 x_36 = computePoint_();
-    const float x_41 = gl_FragCoord.x;
-    if ((x_41 < 0.0f)) {
-      x_34 = true;
-      break;
-    }
-    const float3 x_45 = computePoint_();
-    x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
-    x_34 = true;
-    break;
-  }
-  return;
-}
-
-struct main_out {
-  float4 x_GLF_color_1;
-};
-struct tint_symbol_1 {
-  float4 gl_FragCoord_param : SV_Position;
-};
-struct tint_symbol_2 {
-  float4 x_GLF_color_1 : SV_Target0;
-};
-
-main_out main_inner(float4 gl_FragCoord_param) {
-  gl_FragCoord = gl_FragCoord_param;
-  main_1();
-  const main_out tint_symbol_4 = {x_GLF_color};
-  return tint_symbol_4;
-}
-
-tint_symbol_2 main(tint_symbol_1 tint_symbol) {
-  const main_out inner_result = main_inner(tint_symbol.gl_FragCoord_param);
-  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
-  wrapper_result.x_GLF_color_1 = inner_result.x_GLF_color_1;
-  return wrapper_result;
-}
-C:\src\tint\test\Shader@0x0000017E3AA920C0(22,10-21): warning X3557: loop only executes for 0 iteration(s), consider removing [loop]
-C:\src\tint\test\Shader@0x0000017E3AA920C0(11,10-13): internal error: invalid access of unbound variable
-