diff --git a/source/fuzz/fact_manager.cpp b/source/fuzz/fact_manager.cpp
index ac3ea30..c25d171 100644
--- a/source/fuzz/fact_manager.cpp
+++ b/source/fuzz/fact_manager.cpp
@@ -800,9 +800,37 @@
 // End of data synonym facts
 //==============================
 
+//==============================
+// Dead id facts
+
+// TODO comment.
+class FactManager::DeadIdFacts {
+ public:
+  // See method in FactManager which delegates to this method.
+  void AddFact(const protobufs::FactIdIsDead& fact);
+
+  // See method in FactManager which delegates to this method.
+  bool IdIsDead(uint32_t id) const;
+
+ private:
+  std::set<uint32_t> dead_ids_;
+};
+
+void FactManager::DeadIdFacts::AddFact(const protobufs::FactIdIsDead& fact) {
+  dead_ids_.insert(fact.id());
+}
+
+bool FactManager::DeadIdFacts::IdIsDead(uint32_t id) const {
+  return dead_ids_.count(id) != 0;
+}
+
+// End of dead id facts
+//==============================
+
 FactManager::FactManager()
     : uniform_constant_facts_(MakeUnique<ConstantUniformFacts>()),
-      data_synonym_facts_(MakeUnique<DataSynonymFacts>()) {}
+      data_synonym_facts_(MakeUnique<DataSynonymFacts>()),
+      dead_id_facts_(MakeUnique<DeadIdFacts>()) {}
 
 FactManager::~FactManager() = default;
 
@@ -827,6 +855,9 @@
     case protobufs::Fact::kDataSynonymFact:
       data_synonym_facts_->AddFact(fact.data_synonym_fact(), context);
       return true;
+    case protobufs::Fact::kIdIsDeadFact:
+      dead_id_facts_->AddFact(fact.id_is_dead_fact());
+      return true;
     default:
       assert(false && "Unknown fact type.");
       return false;
@@ -898,5 +929,15 @@
                                            context);
 }
 
+bool FactManager::IdIsDead(uint32_t id) const {
+  return dead_id_facts_->IdIsDead(id);
+}
+
+void FactManager::AddFactIdIsDead(uint32_t id) {
+  protobufs::FactIdIsDead fact;
+  fact.set_id(id);
+  dead_id_facts_->AddFact(fact);
+}
+
 }  // namespace fuzz
 }  // namespace spvtools
diff --git a/source/fuzz/fact_manager.h b/source/fuzz/fact_manager.h
index 62d9dac..fb5ff71 100644
--- a/source/fuzz/fact_manager.h
+++ b/source/fuzz/fact_manager.h
@@ -58,6 +58,9 @@
                           const protobufs::DataDescriptor& data2,
                           opt::IRContext* context);
 
+  // Records the fact that |id| is dead.
+  void AddFactIdIsDead(uint32_t id);
+
   // The fact manager is responsible for managing a few distinct categories of
   // facts. In principle there could be different fact managers for each kind
   // of fact, but in practice providing one 'go to' place for facts is
@@ -130,6 +133,14 @@
   // End of id synonym facts
   //==============================
 
+  //==============================
+  // Querying facts about dead ids
+
+  bool IdIsDead(uint32_t id) const;
+
+  // End of dead id facts
+  //==============================
+
  private:
   // For each distinct kind of fact to be managed, we use a separate opaque
   // class type.
@@ -142,6 +153,10 @@
   class DataSynonymFacts;  // Opaque class for management of data synonym facts.
   std::unique_ptr<DataSynonymFacts>
       data_synonym_facts_;  // Unique pointer to internal data.
+
+  class DeadIdFacts;  // Opaque class for management of dead id facts.
+  std::unique_ptr<DeadIdFacts>
+      dead_id_facts_;  // Unique pointer to internal data.
 };
 
 }  // namespace fuzz
diff --git a/source/fuzz/fuzzer.cpp b/source/fuzz/fuzzer.cpp
index 95913d0..4695b62 100644
--- a/source/fuzz/fuzzer.cpp
+++ b/source/fuzz/fuzzer.cpp
@@ -21,6 +21,7 @@
 #include "fuzzer_pass_adjust_memory_operands_masks.h"
 #include "source/fuzz/fact_manager.h"
 #include "source/fuzz/fuzzer_context.h"
+#include "source/fuzz/fuzzer_pass_add_dead_blocks.h"
 #include "source/fuzz/fuzzer_pass_add_dead_breaks.h"
 #include "source/fuzz/fuzzer_pass_add_dead_continues.h"
 #include "source/fuzz/fuzzer_pass_add_no_contraction_decorations.h"
@@ -169,6 +170,9 @@
   // Apply some semantics-preserving passes.
   std::vector<std::unique_ptr<FuzzerPass>> passes;
   while (passes.empty()) {
+    MaybeAddPass<FuzzerPassAddDeadBlocks>(&passes, ir_context.get(),
+                                          &fact_manager, &fuzzer_context,
+                                          transformation_sequence_out);
     MaybeAddPass<FuzzerPassAddDeadBreaks>(&passes, ir_context.get(),
                                           &fact_manager, &fuzzer_context,
                                           transformation_sequence_out);
diff --git a/source/fuzz/fuzzer_context.cpp b/source/fuzz/fuzzer_context.cpp
index 98585d9..f2db42a 100644
--- a/source/fuzz/fuzzer_context.cpp
+++ b/source/fuzz/fuzzer_context.cpp
@@ -23,6 +23,7 @@
 // Default <minimum, maximum> pairs of probabilities for applying various
 // transformations. All values are percentages. Keep them in alphabetical order.
 
+const std::pair<uint32_t, uint32_t> kChanceOfAddingDeadBlock = {20, 90};
 const std::pair<uint32_t, uint32_t> kChanceOfAddingDeadBreak = {5, 80};
 const std::pair<uint32_t, uint32_t> kChanceOfAddingDeadContinue = {5, 80};
 const std::pair<uint32_t, uint32_t> kChanceOfAddingNoContractionDecoration = {
@@ -66,6 +67,8 @@
       next_fresh_id_(min_fresh_id),
       go_deeper_in_constant_obfuscation_(
           kDefaultGoDeeperInConstantObfuscation) {
+  chance_of_adding_dead_block_ =
+      ChooseBetweenMinAndMax(kChanceOfAddingDeadBlock);
   chance_of_adding_dead_break_ =
       ChooseBetweenMinAndMax(kChanceOfAddingDeadBreak);
   chance_of_adding_dead_continue_ =
diff --git a/source/fuzz/fuzzer_context.h b/source/fuzz/fuzzer_context.h
index 619c131..42ac320 100644
--- a/source/fuzz/fuzzer_context.h
+++ b/source/fuzz/fuzzer_context.h
@@ -58,6 +58,7 @@
 
   // Probabilities associated with applying various transformations.
   // Keep them in alphabetical order.
+  uint32_t GetChanceOfAddingDeadBlock() { return chance_of_adding_dead_block_; }
   uint32_t GetChanceOfAddingDeadBreak() { return chance_of_adding_dead_break_; }
   uint32_t GetChanceOfAddingDeadContinue() {
     return chance_of_adding_dead_continue_;
@@ -114,6 +115,7 @@
 
   // Probabilities associated with applying various transformations.
   // Keep them in alphabetical order.
+  uint32_t chance_of_adding_dead_block_;
   uint32_t chance_of_adding_dead_break_;
   uint32_t chance_of_adding_dead_continue_;
   uint32_t chance_of_adding_no_contraction_decoration_;
diff --git a/source/fuzz/fuzzer_pass_add_dead_blocks.cpp b/source/fuzz/fuzzer_pass_add_dead_blocks.cpp
index f964146..ac2aef3 100644
--- a/source/fuzz/fuzzer_pass_add_dead_blocks.cpp
+++ b/source/fuzz/fuzzer_pass_add_dead_blocks.cpp
@@ -14,6 +14,9 @@
 
 #include "source/fuzz/fuzzer_pass_add_dead_blocks.h"
 
+#include "source/fuzz/fuzzer_util.h"
+#include "source/fuzz/transformation_add_dead_block.h"
+
 namespace spvtools {
 namespace fuzz {
 
@@ -26,7 +29,40 @@
 FuzzerPassAddDeadBlocks::~FuzzerPassAddDeadBlocks() = default;
 
 void FuzzerPassAddDeadBlocks::Apply() {
-  assert(false && "Implement");
+  std::vector<opt::BasicBlock*> candidate_blocks;
+  for (auto& function : *GetIRContext()->module()) {
+    for (auto& block : function) {
+      if (!GetFuzzerContext()->ChoosePercentage(
+              GetFuzzerContext()->GetChanceOfAddingDeadBlock())) {
+        continue;
+      }
+      if (block.IsLoopHeader()) {
+        continue;
+      }
+      if (block.terminator()->opcode() != SpvOpBranch) {
+        continue;
+      }
+      if (fuzzerutil::IsMergeOrContinue(
+              GetIRContext(), block.terminator()->GetSingleWordInOperand(0))) {
+        continue;
+      }
+      // TODO think about OpPhi here
+      candidate_blocks.push_back(&block);
+    }
+  }
+  while (!candidate_blocks.empty()) {
+    uint32_t index = GetFuzzerContext()->RandomIndex(candidate_blocks);
+    auto block = candidate_blocks.at(index);
+    candidate_blocks.erase(candidate_blocks.begin() + index);
+    // TODO: address OpPhi situation
+    TransformationAddDeadBlock transformation(
+        GetFuzzerContext()->GetFreshId(), block->id(),
+        GetFuzzerContext()->ChooseEven(), {});
+    if (transformation.IsApplicable(GetIRContext(), *GetFactManager())) {
+      transformation.Apply(GetIRContext(), GetFactManager());
+      *GetTransformations()->add_transformation() = transformation.ToMessage();
+    }
+  }
 }
 
 }  // namespace fuzz
diff --git a/source/fuzz/fuzzer_pass_add_dead_blocks.h b/source/fuzz/fuzzer_pass_add_dead_blocks.h
index 0577151..9ebb2f3 100644
--- a/source/fuzz/fuzzer_pass_add_dead_blocks.h
+++ b/source/fuzz/fuzzer_pass_add_dead_blocks.h
@@ -24,8 +24,8 @@
 class FuzzerPassAddDeadBlocks : public FuzzerPass {
  public:
   FuzzerPassAddDeadBlocks(opt::IRContext* ir_context, FactManager* fact_manager,
-                        FuzzerContext* fuzzer_context,
-                        protobufs::TransformationSequence* transformations);
+                          FuzzerContext* fuzzer_context,
+                          protobufs::TransformationSequence* transformations);
 
   ~FuzzerPassAddDeadBlocks();
 
diff --git a/source/fuzz/fuzzer_util.cpp b/source/fuzz/fuzzer_util.cpp
index a6e3657..82d761c 100644
--- a/source/fuzz/fuzzer_util.cpp
+++ b/source/fuzz/fuzzer_util.cpp
@@ -112,14 +112,14 @@
 uint32_t MaybeGetBoolConstantId(opt::IRContext* context, bool value) {
   opt::analysis::Bool bool_type;
   auto registered_bool_type =
-          context->get_type_mgr()->GetRegisteredType(&bool_type);
+      context->get_type_mgr()->GetRegisteredType(&bool_type);
   if (!registered_bool_type) {
     return 0;
   }
   opt::analysis::BoolConstant bool_constant(registered_bool_type->AsBool(),
-          value);
+                                            value);
   return context->get_constant_mgr()->FindDeclaredConstant(
-          &bool_constant, context->get_type_mgr()->GetId(&bool_type));
+      &bool_constant, context->get_type_mgr()->GetId(&bool_type));
 }
 
 void AddUnreachableEdgeAndUpdateOpPhis(
@@ -133,7 +133,9 @@
 
   // Get the id of the boolean constant to be used as the condition.
   uint32_t bool_id = MaybeGetBoolConstantId(context, condition_value);
-  assert(bool_id && "Precondition that condition value must be available is not satisfied");
+  assert(
+      bool_id &&
+      "Precondition that condition value must be available is not satisfied");
 
   const bool from_to_edge_already_exists = bb_from->IsSuccessor(bb_to);
   auto successor = bb_from->terminator()->GetSingleWordInOperand(0);
@@ -330,19 +332,18 @@
 bool IsMergeOrContinue(opt::IRContext* ir_context, uint32_t block_id) {
   bool result = false;
   ir_context->get_def_use_mgr()->WhileEachUse(
-          block_id,
-          [&result](
-                  const opt::Instruction* use_instruction,
-                  uint32_t /*unused*/) -> bool {
-              switch (use_instruction->opcode()) {
-                case SpvOpLoopMerge:
-                case SpvOpSelectionMerge:
-                  result = true;
-                  return false;
-                default:
-                  return true;
-              }
-          });
+      block_id,
+      [&result](const opt::Instruction* use_instruction,
+                uint32_t /*unused*/) -> bool {
+        switch (use_instruction->opcode()) {
+          case SpvOpLoopMerge:
+          case SpvOpSelectionMerge:
+            result = true;
+            return false;
+          default:
+            return true;
+        }
+      });
   return result;
 }
 
diff --git a/source/fuzz/protobufs/spvtoolsfuzz.proto b/source/fuzz/protobufs/spvtoolsfuzz.proto
index ef8074e..a0efd6e 100644
--- a/source/fuzz/protobufs/spvtoolsfuzz.proto
+++ b/source/fuzz/protobufs/spvtoolsfuzz.proto
@@ -166,6 +166,7 @@
     // Order the fact options by numeric id (rather than alphabetically).
     FactConstantUniform constant_uniform_fact = 1;
     FactDataSynonym data_synonym_fact = 2;
+    FactIdIsDead id_is_dead_fact = 3;
   }
 }
 
@@ -200,6 +201,16 @@
 
 }
 
+message FactIdIsDead {
+
+  // Records the fact that a block label instruction, or an instruction inside
+  // a block, is guaranteed to be dynamically unreachable.  This is useful
+  // because it informs the fuzzer that rather arbitrary changes can be made
+  // in relation to this instruction.
+
+  uint32 id = 1;
+}
+
 message TransformationSequence {
   repeated Transformation transformation = 1;
 }
diff --git a/source/fuzz/transformation.cpp b/source/fuzz/transformation.cpp
index 3f5375e..c7aae58 100644
--- a/source/fuzz/transformation.cpp
+++ b/source/fuzz/transformation.cpp
@@ -70,8 +70,7 @@
       return MakeUnique<TransformationAddConstantScalar>(
           message.add_constant_scalar());
     case protobufs::Transformation::TransformationCase::kAddDeadBlock:
-      return MakeUnique<TransformationAddDeadBlock>(
-          message.add_dead_block());
+      return MakeUnique<TransformationAddDeadBlock>(message.add_dead_block());
     case protobufs::Transformation::TransformationCase::kAddDeadBreak:
       return MakeUnique<TransformationAddDeadBreak>(message.add_dead_break());
     case protobufs::Transformation::TransformationCase::kAddDeadContinue:
diff --git a/source/fuzz/transformation_add_dead_block.cpp b/source/fuzz/transformation_add_dead_block.cpp
index ff9cebc..0d6b2f7 100644
--- a/source/fuzz/transformation_add_dead_block.cpp
+++ b/source/fuzz/transformation_add_dead_block.cpp
@@ -24,9 +24,8 @@
     : message_(message) {}
 
 TransformationAddDeadBlock::TransformationAddDeadBlock(
-        uint32_t fresh_id, uint32_t existing_block,
-bool condition_value,
-        std::vector<uint32_t> phi_id) {
+    uint32_t fresh_id, uint32_t existing_block, bool condition_value,
+    std::vector<uint32_t> phi_id) {
   message_.set_fresh_id(fresh_id);
   message_.set_existing_block(existing_block);
   message_.set_condition_value(condition_value);
@@ -45,14 +44,16 @@
 
   // First, we check that a constant with the same value as
   // |message_.condition_value| is present.
-  if (!fuzzerutil::MaybeGetBoolConstantId(context, message_.condition_value())) {
+  if (!fuzzerutil::MaybeGetBoolConstantId(context,
+                                          message_.condition_value())) {
     // The required constant is not present, so the transformation cannot be
     // applied.
     return false;
   }
 
   // The existing block must indeed exist.
-  auto existing_block = fuzzerutil::MaybeFindBlock(context, message_.existing_block());
+  auto existing_block =
+      fuzzerutil::MaybeFindBlock(context, message_.existing_block());
   if (!existing_block) {
     return false;
   }
@@ -68,32 +69,54 @@
   }
 
   // Its successor must not be a merge block nor continue target.
-  if (fuzzerutil::IsMergeOrContinue(context, existing_block->terminator()->GetSingleWordInOperand(0))) {
+  if (fuzzerutil::IsMergeOrContinue(
+          context, existing_block->terminator()->GetSingleWordInOperand(0))) {
     return false;
   }
   return true;
 }
 
 void TransformationAddDeadBlock::Apply(
-    opt::IRContext* context, spvtools::fuzz::FactManager* /*unused*/) const {
+    opt::IRContext* context, spvtools::fuzz::FactManager* fact_manager) const {
   // TODO comment
   fuzzerutil::UpdateModuleIdBound(context, message_.fresh_id());
   auto existing_block = context->cfg()->block(message_.existing_block());
-  auto successor_block_id = existing_block->terminator()->GetSingleWordInOperand(0);
-  auto bool_id = fuzzerutil::MaybeGetBoolConstantId(context, message_.condition_value());
+  auto successor_block_id =
+      existing_block->terminator()->GetSingleWordInOperand(0);
+  auto bool_id =
+      fuzzerutil::MaybeGetBoolConstantId(context, message_.condition_value());
 
   auto enclosing_function = existing_block->GetParent();
-  std::unique_ptr<opt::BasicBlock> new_block =
-          MakeUnique<opt::BasicBlock>(MakeUnique<opt::Instruction>(
-                  context, SpvOpLabel, 0, message_.fresh_id(), opt::Instruction::OperandList()));
+  std::unique_ptr<opt::BasicBlock> new_block = MakeUnique<opt::BasicBlock>(
+      MakeUnique<opt::Instruction>(context, SpvOpLabel, 0, message_.fresh_id(),
+                                   opt::Instruction::OperandList()));
   new_block->SetParent(enclosing_function);
-  new_block->AddInstruction(MakeUnique<opt::Instruction>(context, SpvOpBranch, 0, 0, opt::Instruction::OperandList({{SPV_OPERAND_TYPE_ID, {successor_block_id}}})));
+  new_block->AddInstruction(MakeUnique<opt::Instruction>(
+      context, SpvOpBranch, 0, 0,
+      opt::Instruction::OperandList(
+          {{SPV_OPERAND_TYPE_ID, {successor_block_id}}})));
+
+  existing_block->terminator()->InsertBefore(MakeUnique<opt::Instruction>(
+      context, SpvOpSelectionMerge, 0, 0,
+      opt::Instruction::OperandList(
+          {{SPV_OPERAND_TYPE_ID, {successor_block_id}},
+           {SPV_OPERAND_TYPE_SELECTION_CONTROL,
+            {SpvSelectionControlMaskNone}}})));
+
   existing_block->terminator()->SetOpcode(SpvOpBranchConditional);
   existing_block->terminator()->SetInOperands(
-          {{SPV_OPERAND_TYPE_ID, {bool_id}},
-           {SPV_OPERAND_TYPE_ID, {message_.condition_value() ? successor_block_id : message_.fresh_id()}},
-           {SPV_OPERAND_TYPE_ID, {message_.condition_value() ? message_.fresh_id() : successor_block_id}}});
-  enclosing_function->InsertBasicBlockAfter(std::move(new_block), existing_block);
+      {{SPV_OPERAND_TYPE_ID, {bool_id}},
+       {SPV_OPERAND_TYPE_ID,
+        {message_.condition_value() ? successor_block_id
+                                    : message_.fresh_id()}},
+       {SPV_OPERAND_TYPE_ID,
+        {message_.condition_value() ? message_.fresh_id()
+                                    : successor_block_id}}});
+  enclosing_function->InsertBasicBlockAfter(std::move(new_block),
+                                            existing_block);
+
+  fact_manager->AddFactIdIsDead(message_.fresh_id());
+
   context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone);
 }
 
diff --git a/source/fuzz/transformation_add_dead_block.h b/source/fuzz/transformation_add_dead_block.h
index 203b9a9..3c85615 100644
--- a/source/fuzz/transformation_add_dead_block.h
+++ b/source/fuzz/transformation_add_dead_block.h
@@ -28,8 +28,7 @@
   explicit TransformationAddDeadBlock(
       const protobufs::TransformationAddDeadBlock& message);
 
-  TransformationAddDeadBlock(uint32_t fresh_id,
-                             uint32_t existing_block,
+  TransformationAddDeadBlock(uint32_t fresh_id, uint32_t existing_block,
                              bool condition_value,
                              std::vector<uint32_t> phi_id);
 
diff --git a/source/fuzz/transformation_add_dead_break.cpp b/source/fuzz/transformation_add_dead_break.cpp
index 9fa2df6..43847fa 100644
--- a/source/fuzz/transformation_add_dead_break.cpp
+++ b/source/fuzz/transformation_add_dead_break.cpp
@@ -111,7 +111,8 @@
     opt::IRContext* context, const FactManager& /*unused*/) const {
   // First, we check that a constant with the same value as
   // |message_.break_condition_value| is present.
-  if (!fuzzerutil::MaybeGetBoolConstantId(context, message_.break_condition_value())) {
+  if (!fuzzerutil::MaybeGetBoolConstantId(context,
+                                          message_.break_condition_value())) {
     // The required constant is not present, so the transformation cannot be
     // applied.
     return false;
diff --git a/source/fuzz/transformation_add_dead_continue.cpp b/source/fuzz/transformation_add_dead_continue.cpp
index b614a23..ffa182e 100644
--- a/source/fuzz/transformation_add_dead_continue.cpp
+++ b/source/fuzz/transformation_add_dead_continue.cpp
@@ -37,7 +37,8 @@
     opt::IRContext* context, const FactManager& /*unused*/) const {
   // First, we check that a constant with the same value as
   // |message_.continue_condition_value| is present.
-  if (!fuzzerutil::MaybeGetBoolConstantId(context, message_.continue_condition_value())) {
+  if (!fuzzerutil::MaybeGetBoolConstantId(
+          context, message_.continue_condition_value())) {
     // The required constant is not present, so the transformation cannot be
     // applied.
     return false;
diff --git a/source/fuzz/transformation_split_block.cpp b/source/fuzz/transformation_split_block.cpp
index 9f6da7c..f05e77b 100644
--- a/source/fuzz/transformation_split_block.cpp
+++ b/source/fuzz/transformation_split_block.cpp
@@ -80,7 +80,7 @@
 }
 
 void TransformationSplitBlock::Apply(opt::IRContext* context,
-                                     FactManager* /*unused*/) const {
+                                     FactManager* fact_manager) const {
   opt::Instruction* instruction_to_split_before =
       FindInstruction(message_.instruction_to_split_before(), context);
   opt::BasicBlock* block_to_split =
@@ -114,6 +114,13 @@
            "one predecessor.");
     phi_inst->SetInOperand(1, {block_to_split->id()});
   });
+
+  // If the block being split was dead, the new block arising from the split is
+  // also dead.
+  if (fact_manager->IdIsDead(block_to_split->id())) {
+    fact_manager->AddFactIdIsDead(message_.fresh_id());
+  }
+
   // Invalidate all analyses
   context->InvalidateAnalysesExceptFor(opt::IRContext::Analysis::kAnalysisNone);
 }
diff --git a/test/fuzz/transformation_add_dead_block_test.cpp b/test/fuzz/transformation_add_dead_block_test.cpp
index 1044647..fbb9c3e 100644
--- a/test/fuzz/transformation_add_dead_block_test.cpp
+++ b/test/fuzz/transformation_add_dead_block_test.cpp
@@ -48,16 +48,20 @@
   FactManager fact_manager;
 
   // Id 4 is already in use
-  ASSERT_FALSE(TransformationAddDeadBlock(4, 5, true, {}).IsApplicable(context.get(), fact_manager));
+  ASSERT_FALSE(TransformationAddDeadBlock(4, 5, true, {})
+                   .IsApplicable(context.get(), fact_manager));
 
   // Id 7 is not a block
-  ASSERT_FALSE(TransformationAddDeadBlock(100, 7, true, {}).IsApplicable(context.get(), fact_manager));
+  ASSERT_FALSE(TransformationAddDeadBlock(100, 7, true, {})
+                   .IsApplicable(context.get(), fact_manager));
 
   TransformationAddDeadBlock transformation(100, 5, true, {});
   ASSERT_TRUE(transformation.IsApplicable(context.get(), fact_manager));
   transformation.Apply(context.get(), &fact_manager);
   ASSERT_TRUE(IsValid(env, context.get()));
 
+  ASSERT_TRUE(fact_manager.IdIsDead(100));
+
   std::string after_transformation = R"(
                OpCapability Shader
           %1 = OpExtInstImport "GLSL.std.450"
@@ -72,7 +76,7 @@
           %7 = OpConstantTrue %6
           %4 = OpFunction %2 None %3
           %5 = OpLabel
-               OpSelectionMerge %8
+               OpSelectionMerge %8 None
                OpBranchConditional %7 %8 %100
         %100 = OpLabel
                OpBranch %8
@@ -83,11 +87,12 @@
   ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
 }
 
-// Target block must not be merge or continue
+// TODO Target block must not be merge or continue
 
-// Source block must not be loop head
+// TODO Source block must not be loop head
 
-// Target block can start with OpPhi; need to give suitable ids in that case
+// TODO Target block can start with OpPhi; need to give suitable ids in that
+//  case
 
 }  // namespace
 }  // namespace fuzz
diff --git a/test/fuzz/transformation_split_block_test.cpp b/test/fuzz/transformation_split_block_test.cpp
index d162e07..8c46bda 100644
--- a/test/fuzz/transformation_split_block_test.cpp
+++ b/test/fuzz/transformation_split_block_test.cpp
@@ -774,6 +774,77 @@
   ASSERT_TRUE(IsEqual(env, after_split, context.get()));
 }
 
+TEST(TransformationSplitBlockTest, DeadBlockShouldSplitToTwoDeadBlocks) {
+  // This checks that if a block B is marked as dead, it should split into a
+  // pair of dead blocks.
+  std::string shader = R"(
+               OpCapability Shader
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %4 "main"
+               OpExecutionMode %4 OriginUpperLeft
+               OpSource ESSL 310
+               OpName %4 "main"
+          %2 = OpTypeVoid
+          %3 = OpTypeFunction %2
+          %6 = OpTypeBool
+          %7 = OpConstantFalse %6
+          %4 = OpFunction %2 None %3
+          %5 = OpLabel
+               OpSelectionMerge %9 None
+               OpBranchConditional %7 %8 %9
+          %8 = OpLabel
+               OpBranch %9
+          %9 = OpLabel
+               OpReturn
+               OpFunctionEnd
+  )";
+
+  const auto env = SPV_ENV_UNIVERSAL_1_3;
+  const auto consumer = nullptr;
+  const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
+
+  FactManager fact_manager;
+
+  // Record the fact that block 8 is dead.
+  fact_manager.AddFactIdIsDead(8);
+
+  auto split = TransformationSplitBlock(
+      MakeInstructionDescriptor(8, SpvOpBranch, 0), 100);
+  ASSERT_TRUE(split.IsApplicable(context.get(), fact_manager));
+  split.Apply(context.get(), &fact_manager);
+  ASSERT_TRUE(IsValid(env, context.get()));
+
+  ASSERT_TRUE(fact_manager.IdIsDead(8));
+  ASSERT_TRUE(fact_manager.IdIsDead(100));
+
+  std::string after_split = R"(
+               OpCapability Shader
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %4 "main"
+               OpExecutionMode %4 OriginUpperLeft
+               OpSource ESSL 310
+               OpName %4 "main"
+          %2 = OpTypeVoid
+          %3 = OpTypeFunction %2
+          %6 = OpTypeBool
+          %7 = OpConstantFalse %6
+          %4 = OpFunction %2 None %3
+          %5 = OpLabel
+               OpSelectionMerge %9 None
+               OpBranchConditional %7 %8 %9
+          %8 = OpLabel
+               OpBranch %100
+        %100 = OpLabel
+               OpBranch %9
+          %9 = OpLabel
+               OpReturn
+               OpFunctionEnd
+  )";
+  ASSERT_TRUE(IsEqual(env, after_split, context.get()));
+}
+
 }  // namespace
 }  // namespace fuzz
 }  // namespace spvtools