diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/SpvConverter.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/SpvConverter.hpp
index 0010f2344..6d42a7356 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/SpvConverter.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/SpvConverter.hpp
@@ -28,6 +28,7 @@ struct Context : ir::Context {
 
   Context();
 
+  ir::Region createRegion(ir::Location loc);
   ir::Value createRegionWithLabel(ir::Location loc);
 
   void setName(ir::spv::IdRef inst, std::string name);
@@ -35,6 +36,7 @@ struct Context : ir::Context {
 
   ir::Value getOrCreateConstant(ir::Value typeValue, const ir::Operand &value);
   ir::Value getNull(ir::Value typeValue);
+  ir::Value getUndef(ir::Value typeValue);
 
   ir::Value getType(ir::spv::Op baseType, int width, bool isSigned);
   ir::Value getType(const TypeInfo &info);
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/analyze.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/analyze.hpp
index f7d8af271..3b1f00b57 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/analyze.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/analyze.hpp
@@ -15,8 +15,6 @@
 #include <vector>
 
 namespace shader {
-struct DomTree;
-struct PostDomTree;
 class CFG {
 public:
   class Node {
@@ -42,7 +40,6 @@ public:
       mSuccessors.insert(to);
     }
 
-    bool hasPredecessor(Node *node) { return mPredecessors.contains(node); }
     bool hasSuccessor(Node *node) { return mSuccessors.contains(node); }
     auto &getPredecessors() { return mPredecessors; }
     auto &getSuccessors() { return mSuccessors; }
@@ -118,16 +115,6 @@ public:
   void print(std::ostream &os, ir::NameStorage &ns, bool subgraph = false,
              std::string_view nameSuffix = "");
   std::string genTest();
-
-  CFG buildView(CFG::Node *from, PostDomTree *domTree = nullptr,
-                const std::unordered_set<ir::Value> &stopLabels = {},
-                ir::Value continueLabel = nullptr);
-
-  CFG buildView(ir::Value from, PostDomTree *domTree = nullptr,
-                const std::unordered_set<ir::Value> &stopLabels = {},
-                ir::Value continueLabel = nullptr) {
-    return buildView(getNode(from), domTree, stopLabels, continueLabel);
-  }
 };
 
 class MemorySSA {
@@ -182,11 +169,27 @@ bool isWithoutSideEffects(ir::InstructionId id);
 bool isTerminator(ir::Instruction inst);
 bool isBranch(ir::Instruction inst);
 ir::Value unwrapPointer(ir::Value pointer);
+
+ir::Instruction getTerminator(ir::RegionLike region);
+std::vector<std::pair<ir::Block, int>> getAllSuccessors(ir::Block region);
+std::vector<std::pair<ir::Block, int>> getAllPredecessors(ir::Block region);
+
+std::unordered_set<ir::Block> getSuccessors(ir::Block region);
+std::unordered_set<ir::Block> getPredecessors(ir::Block region);
+std::size_t getSuccessorCount(ir::Block region);
+std::size_t getPredecessorCount(ir::Block region);
+bool hasSuccessor(ir::Block region, ir::Block successor);
+bool hasAtLeastSuccessors(ir::Block region, std::size_t count);
+ir::Block getUniqSuccessor(ir::Block region);
+
+graph::DomTree<ir::Block> buildDomTree(ir::Block block);
+graph::DomTree<ir::Block> buildPostDomTree(ir::Block block);
+graph::DomTree<ir::Block> buildDomTree(ir::RegionLike region);
+graph::DomTree<ir::Block> buildPostDomTree(ir::RegionLike region);
 graph::DomTree<ir::Value> buildDomTree(CFG &cfg, ir::Value root = nullptr);
 graph::DomTree<ir::Value> buildPostDomTree(CFG &cfg, ir::Value root);
 
-CFG buildCFG(ir::Instruction firstInstruction,
-             const std::unordered_set<ir::Value> &exitLabels = {},
+CFG buildCFG(ir::Instruction firstInstruction, ir::Value exitLabel = nullptr,
              ir::Value continueLabel = nullptr);
 MemorySSA buildMemorySSA(CFG &cfg, ModuleInfo *moduleInfo = nullptr);
 
@@ -200,23 +203,6 @@ bool dominates(ir::Instruction a, ir::Instruction b, bool isPostDom,
 ir::Value findNearestCommonDominator(ir::Instruction a, ir::Instruction b,
                                      graph::DomTree<ir::Value> &domTree);
 
-class BackEdgeStorage {
-  std::unordered_map<ir::Value, std::unordered_set<ir::Value>> backEdges;
-
-public:
-  BackEdgeStorage() = default;
-  BackEdgeStorage(CFG &cfg);
-
-  const std::unordered_set<ir::Value> *get(ir::Value value) {
-    if (auto it = backEdges.find(value); it != backEdges.end()) {
-      return &it->second;
-    }
-    return nullptr;
-  }
-
-  auto &all() { return backEdges; }
-};
-
 struct AnalysisStorage {
   template <typename... T>
     requires(sizeof...(T) > 0)
@@ -245,9 +231,7 @@ struct AnalysisStorage {
   {
     void *result = getImpl(
         rx::TypeId::get<T>(), getDeleter<T>(),
-        [&] {
-          return std::make_unique<T>(std::forward<ArgsT>(args)...).release();
-        },
+        [&] { return new T(std::forward<ArgsT>(args)...); },
         [&](void *object) {
           *reinterpret_cast<T *>(object) = T(std::forward<ArgsT>(args)...);
         });
@@ -261,10 +245,7 @@ struct AnalysisStorage {
   {
     void *result = getImpl(
         rx::TypeId::get<T>(), getDeleter<T>(),
-        [&] {
-          return std::make_unique<T>(std::forward<BuilderFn>(builder)())
-              .release();
-        },
+        [&] { return new T(std::forward<BuilderFn>(builder)()); },
         [&](void *object) {
           *reinterpret_cast<T *>(object) = std::forward<BuilderFn>(builder)();
         });
@@ -304,20 +285,20 @@ private:
   std::map<rx::TypeId, Entry> mStorage;
 };
 
-struct PostDomTree : graph::DomTree<ir::Value> {
+struct PostDomTree : graph::DomTree<ir::Block> {
   PostDomTree() = default;
-  PostDomTree(graph::DomTree<ir::Value> &&other)
-      : graph::DomTree<ir::Value>::DomTree(std::move(other)) {}
-  PostDomTree(CFG &cfg, ir::Value root)
-      : PostDomTree(buildPostDomTree(cfg, root)) {}
+  PostDomTree(graph::DomTree<ir::Block> &&other)
+      : graph::DomTree<ir::Block>::DomTree(std::move(other)) {}
+  PostDomTree(ir::Block block) : PostDomTree(buildPostDomTree(block)) {}
+  PostDomTree(ir::RegionLike region) : DomTree(buildPostDomTree(region)) {}
 };
 
-struct DomTree : graph::DomTree<ir::Value> {
+struct DomTree : graph::DomTree<ir::Block> {
   DomTree() = default;
-  DomTree(graph::DomTree<ir::Value> &&other)
-      : graph::DomTree<ir::Value>::DomTree(std::move(other)) {}
-  DomTree(CFG &cfg, ir::Value root = nullptr)
-      : DomTree(buildDomTree(cfg, root)) {}
+  DomTree(graph::DomTree<ir::Block> &&other)
+      : graph::DomTree<ir::Block>::DomTree(std::move(other)) {}
+  DomTree(ir::Block block) : DomTree(buildDomTree(block)) {}
+  DomTree(ir::RegionLike region) : DomTree(buildDomTree(region)) {}
 };
 
 template <typename T, std::size_t> struct Tag : T {
@@ -337,107 +318,4 @@ template <typename T, std::size_t> struct Tag : T {
   }
 };
 
-struct Construct {
-  Construct *parent;
-  std::forward_list<Construct> children;
-  ir::Value header;
-  ir::Value merge;
-  ir::Value loopBody;
-  ir::Value loopContinue;
-  AnalysisStorage analysis;
-
-  static std::unique_ptr<Construct> createRoot(ir::RegionLike region,
-                                               ir::Value merge) {
-    auto result = std::make_unique<Construct>();
-    auto &cfg =
-        result->analysis.get<CFG>([&] { return buildCFG(region.getFirst()); });
-    result->header = cfg.getEntryLabel();
-    result->merge = merge;
-    return result;
-  }
-
-  Construct *createChild(ir::Value header, ir::Value merge) {
-    auto &result = children.emplace_front();
-    result.parent = this;
-    result.header = header;
-    result.merge = merge;
-    return &result;
-  }
-
-  Construct *createChild(ir::Value header, ir::Value merge,
-                         ir::Value loopContinue, ir::Value loopBody) {
-    auto &result = children.emplace_front();
-    result.parent = this;
-    result.header = header;
-    result.merge = merge;
-    result.loopContinue = loopContinue;
-    result.loopBody = loopBody;
-    return &result;
-  }
-
-  Construct createTemporaryChild(ir::Value header, ir::Value merge) {
-    Construct result;
-    result.parent = this;
-    result.header = header;
-    result.merge = merge;
-    return result;
-  }
-
-  CFG &getCfg() {
-    return analysis.get<CFG>([this] {
-      if (parent != nullptr) {
-        return parent->getCfg().buildView(header, &parent->getPostDomTree(),
-                                          {header, merge});
-      }
-
-      return buildCFG(header);
-    });
-  }
-
-  CFG &getCfgWithoutContinue() {
-    if (loopContinue == nullptr) {
-      return getCfg();
-    }
-
-    return analysis.get<Tag<CFG, kWithoutContinue>>([this] {
-      if (parent != nullptr) {
-        return parent->getCfg().buildView(header, &parent->getPostDomTree(),
-                                          {header, merge}, loopContinue);
-      }
-
-      return buildCFG(header, {}, loopContinue);
-    });
-  }
-
-  DomTree &getDomTree() { return analysis.get<DomTree>(getCfg(), header); }
-  PostDomTree &getPostDomTree() {
-    return analysis.get<PostDomTree>(getCfg(), merge);
-  }
-  BackEdgeStorage &getBackEdgeStorage() {
-    return analysis.get<BackEdgeStorage>(getCfg());
-  }
-  BackEdgeStorage &getBackEdgeWithoutContinueStorage() {
-    if (loopContinue == nullptr) {
-      return getBackEdgeStorage();
-    }
-    return analysis.get<Tag<BackEdgeStorage, kWithoutContinue>>(
-        getCfgWithoutContinue());
-  }
-  auto getBackEdges(ir::Value node) { return getBackEdgeStorage().get(node); }
-  auto getBackEdgesWithoutContinue(ir::Value node) {
-    return getBackEdgeWithoutContinueStorage().get(node);
-  }
-  auto getBackEdges() { return getBackEdges(header); }
-  void invalidate();
-  void invalidateAll();
-
-  bool isNull() const { return header == nullptr; }
-
-  void removeLastChild() { children.pop_front(); }
-
-private:
-  enum {
-    kWithoutContinue,
-  };
-};
 } // namespace shader
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/dialect/builtin.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/dialect/builtin.hpp
index ac965896d..c30b100e6 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/dialect/builtin.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/dialect/builtin.hpp
@@ -1,6 +1,8 @@
 #pragma once
 #include "../ir/Block.hpp"
 #include "../ir/Builder.hpp"
+#include "../ir/LoopConstruct.hpp"
+#include "../ir/SelectionConstruct.hpp"
 #include "../ir/Value.hpp"
 
 namespace shader::ir {
@@ -11,8 +13,9 @@ namespace shader::ir::builtin {
 enum Op {
   INVALID_INSTRUCTION,
   BLOCK,
-  IF_ELSE,
-  LOOP,
+  LOOP_CONSTRUCT,
+  CONTINUE_CONSTRUCT,
+  SELECTION_CONSTRUCT,
 };
 
 inline const char *getInstructionName(unsigned id) {
@@ -23,11 +26,14 @@ inline const char *getInstructionName(unsigned id) {
   case BLOCK:
     return "block";
 
-  case IF_ELSE:
-    return "ifElse";
+  case LOOP_CONSTRUCT:
+    return "loop_construct";
 
-  case LOOP:
-    return "loop";
+  case CONTINUE_CONSTRUCT:
+    return "continue_construct";
+
+  case SELECTION_CONSTRUCT:
+    return "selection_construct";
   }
   return nullptr;
 }
@@ -46,23 +52,30 @@ struct Builder : BuilderFacade<Builder<ImplT>, ImplT> {
                                               INVALID_INSTRUCTION);
   }
 
-  Instruction createIfElse(Location location, Value cond, Block ifTrue,
-                           Block ifFalse = {}) {
-    std::vector<Operand> operands = {{cond, ifTrue}};
-    if (ifFalse) {
-      operands.push_back(ifFalse);
-    }
-    return this->template create<Instruction>(location, Kind::Builtin, IF_ELSE,
-                                              operands);
+  SelectionConstruct createSelectionConstruct(Location location, ir::Block body,
+                                              ir::Block merge) {
+    return this->template create<SelectionConstruct>(
+        location, Kind::Builtin, SELECTION_CONSTRUCT,
+        std::span<const Operand>{{body, merge}});
   }
 
-  Instruction createLoop(Location location, Block body) {
-    return this->template create<Instruction>(location, Kind::Builtin, IF_ELSE,
-                                              {{body}});
+  ContinueConstruct createContinueConstruct(Location location, ir::Block body,
+                                            ir::Block merge) {
+    return this->template create<ContinueConstruct>(
+        location, Kind::Builtin, CONTINUE_CONSTRUCT,
+        std::span<const Operand>{{body, merge}});
+  }
+
+  LoopConstruct createLoopConstruct(Location location, ir::Block body,
+                                    ir::Block merge,
+                                    ContinueConstruct continueConstruct) {
+    return this->template create<LoopConstruct>(
+        location, Kind::Builtin, LOOP_CONSTRUCT,
+        std::span<const Operand>{{body, merge, continueConstruct}});
   }
 
   auto createBlock(Location location) {
-    return this->template create<Block>(location);
+    return this->template create<Block>(location, Kind::Builtin, BLOCK);
   }
 
   auto createRegion(Location location) {
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/dialect/memssa.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/dialect/memssa.hpp
index 293d9c0a1..c95f00093 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/dialect/memssa.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/dialect/memssa.hpp
@@ -14,6 +14,7 @@ enum Op {
   OpBarrier,
   OpJump,
   OpExit,
+  OpScope,
 
   OpCount,
 };
@@ -24,8 +25,9 @@ template <typename BaseT> struct BaseImpl : BaseT {
   using BaseT::BaseT;
   using BaseT::operator=;
 
-  void print(std::ostream &os, NameStorage &ns) const override {
-    BaseT::print(os, ns);
+  void print(std::ostream &os, NameStorage &ns,
+             const PrintOptions &opts) const override {
+    BaseT::print(os, ns, opts);
 
     if (link) {
       os << " : ";
@@ -220,7 +222,7 @@ struct ScopeWrapper : BaseWrapper<ImplT, ir::BlockWrapper> {
       std::set<Var> result;
       std::vector<Var> workList;
 
-      for (auto comp : var.getOperands()) {
+      for (auto &comp : var.getOperands()) {
         auto compVar = comp.getAsValue().staticCast<Var>();
         result.insert(compVar);
 
@@ -235,7 +237,7 @@ struct ScopeWrapper : BaseWrapper<ImplT, ir::BlockWrapper> {
         auto var = workList.back();
         workList.pop_back();
 
-        for (auto comp : var.getOperands()) {
+        for (auto &comp : var.getOperands()) {
           auto compVar = comp.getAsValue().staticCast<Var>();
           result.insert(compVar);
 
@@ -353,7 +355,8 @@ struct Builder : BuilderFacade<Builder<ImplT>, ImplT> {
   }
 
   Scope createScope(ir::Instruction labelInst) {
-    Scope result = this->template create<Scope>(labelInst.getLocation());
+    Scope result = this->template create<Scope>(labelInst.getLocation(),
+                                                ir::Kind::MemSSA, OpScope);
     result.impl->link = labelInst;
     return result;
   }
@@ -417,6 +420,8 @@ inline const char *getInstructionName(unsigned op) {
     return "jump";
   case OpExit:
     return "exit";
+  case OpScope:
+    return "scope";
   }
   return nullptr;
 }
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Block.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Block.hpp
index e5134d323..64de2b3aa 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Block.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Block.hpp
@@ -19,10 +19,12 @@ struct Block : BlockWrapper<BlockImpl> {
 };
 
 struct BlockImpl : ValueImpl, RegionLikeImpl {
-  BlockImpl(Location loc);
+  using ValueImpl::ValueImpl;
+
   Node clone(Context &context, CloneMap &map) const override;
 
-  void print(std::ostream &os, NameStorage &ns) const override {
+  void print(std::ostream &os, NameStorage &ns,
+             const PrintOptions &opts) const override {
     os << '%' << ns.getNameOf(const_cast<BlockImpl *>(this));
     os << " = ";
 
@@ -41,11 +43,13 @@ struct BlockImpl : ValueImpl, RegionLikeImpl {
     }
 
     os << "{\n";
+    auto childOpts = opts.nextLevel();
     for (auto child : children()) {
-      os << "  ";
-      child.print(os, ns);
+      childOpts.printIdent(os);
+      child.print(os, ns, childOpts);
       os << "\n";
     }
+    opts.printIdent(os);
     os << "}";
   }
 };
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Builder.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Builder.hpp
index 9fcdeafc6..01a85128f 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Builder.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Builder.hpp
@@ -22,6 +22,46 @@ template <typename BuilderT, typename ImplT> struct BuilderFacade {
   }
 };
 
+class InsertionPoint {
+  RegionLike mInsertionStorage;
+  Instruction mInsertionPoint;
+
+public:
+  InsertionPoint() = default;
+
+  InsertionPoint(RegionLike storage, Instruction point)
+      : mInsertionStorage(storage), mInsertionPoint(point) {}
+
+  static InsertionPoint createInsertAfter(Instruction point) {
+    return {point.getParent(), point};
+  }
+
+  static InsertionPoint createInsertBefore(Instruction point) {
+    return {point.getParent(), point.getPrev()};
+  }
+
+  static InsertionPoint createAppend(RegionLike storage) {
+    return {storage, storage.getLast()};
+  }
+
+  static InsertionPoint createPrepend(RegionLike storage) {
+    return {storage, nullptr};
+  }
+
+  RegionLike getInsertionStorage() { return mInsertionStorage; }
+  Instruction getInsertionPoint() { return mInsertionPoint; }
+
+  void insert(ir::Instruction inst) {
+    getInsertionStorage().insertAfter(getInsertionPoint(), inst);
+    mInsertionPoint = inst;
+  }
+
+  void eraseAndInsert(ir::Instruction inst) {
+    inst.erase();
+    insert(inst);
+  }
+};
+
 template <template <typename> typename... InterfaceTs>
 class Builder : public InterfaceTs<Builder<InterfaceTs...>>... {
   Context *mContext{};
@@ -32,6 +72,13 @@ public:
   Builder() = default;
   Builder(Context &context) : mContext(&context) {}
 
+  static Builder create(Context &context, InsertionPoint point) {
+    auto result = Builder(context);
+    result.mInsertionStorage = point.getInsertionStorage();
+    result.mInsertionPoint = point.getInsertionPoint();
+    return result;
+  }
+
   static Builder createInsertAfter(Context &context, Instruction point) {
     auto result = Builder(context);
     result.mInsertionStorage = point.getParent();
@@ -42,14 +89,14 @@ public:
   static Builder createInsertBefore(Context &context, Instruction point) {
     auto result = Builder(context);
     result.mInsertionStorage = point.getParent();
-    result.mInsertionPoint = point.getPrev().cast<Instruction>();
+    result.mInsertionPoint = point.getPrev();
     return result;
   }
 
   static Builder createAppend(Context &context, RegionLike storage) {
     auto result = Builder(context);
     result.mInsertionStorage = storage;
-    result.mInsertionPoint = storage.getLast().cast<Instruction>();
+    result.mInsertionPoint = storage.getLast();
     return result;
   }
 
@@ -65,6 +112,10 @@ public:
   Instruction getInsertionPoint() { return mInsertionPoint; }
   void setInsertionPoint(Instruction inst) { mInsertionPoint = inst; }
 
+  InsertionPoint saveInsertionPoint() {
+    return { mInsertionStorage, mInsertionPoint };
+  }
+
   template <typename T, typename... ArgsT>
     requires requires {
       typename T::underlying_type;
@@ -73,12 +124,21 @@ public:
     }
   T create(ArgsT &&...args) {
     auto result = getContext().template create<T>(std::forward<ArgsT>(args)...);
-    using InstanceType = typename T::underlying_type;
     getInsertionStorage().insertAfter(getInsertionPoint(), result);
     if constexpr (requires { mInsertionPoint = Instruction(result); }) {
       mInsertionPoint = Instruction(result);
     }
     return result;
   }
+
+  void insert(ir::Instruction inst) {
+    getInsertionStorage().insertAfter(getInsertionPoint(), inst);
+    mInsertionPoint = inst;
+  }
+
+  void eraseAndInsert(ir::Instruction inst) {
+    inst.erase();
+    insert(inst);
+  }
 };
 } // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Construct.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Construct.hpp
new file mode 100644
index 000000000..25464cbce
--- /dev/null
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Construct.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "Block.hpp"
+
+namespace shader::ir {
+template <typename ImplT>
+struct ConstructWrapper : BlockWrapper<ImplT> {
+  using BlockWrapper<ImplT>::BlockWrapper;
+  using BlockWrapper<ImplT>::operator=;
+
+  ir::Block getHeader() {
+    return this->impl->getOperand(0)
+        .getAsValue()
+        .template staticCast<ir::Block>();
+  }
+
+  void setHeader(ir::Block block) {
+    this->impl->replaceOperand(0, block);
+  }
+
+  ir::Block getMerge() {
+    return this->impl->getOperand(1)
+        .getAsValue()
+        .template staticCast<ir::Block>();
+  }
+
+  void setMerge(ir::Block block) {
+    this->impl->replaceOperand(1, block);
+  }
+};
+
+struct ConstructImpl;
+
+struct Construct : ConstructWrapper<ConstructImpl> {
+  using ConstructWrapper<ConstructImpl>::ConstructWrapper;
+  using ConstructWrapper<ConstructImpl>::operator=;
+};
+
+struct ConstructImpl : BlockImpl {
+  using BlockImpl::BlockImpl;
+};
+} // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Impl.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Impl.hpp
index 7bc459d88..5a0508350 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Impl.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Impl.hpp
@@ -4,8 +4,10 @@
 #include "Block.hpp"
 #include "Context.hpp"
 #include "InstructionImpl.hpp"
+#include "LoopConstruct.hpp"
 #include "NodeImpl.hpp"
 #include "RegionImpl.hpp"
+#include "SelectionConstruct.hpp"
 #include "ValueImpl.hpp"
 
 namespace shader::ir {
@@ -41,8 +43,8 @@ inline Operand InstructionImpl::eraseOperand(int index, int count) {
   if (index + count == operands.size()) {
     auto result = replaceOperand(index, nullptr);
 
-    for (int i = 1; i < count; ++i) {
-      replaceOperand(i + index, nullptr);
+    for (std::size_t i = index + 1; i < operands.size(); ++i) {
+      replaceOperand(i, nullptr);
     }
 
     operands.resize(operands.size() - count);
@@ -51,11 +53,7 @@ inline Operand InstructionImpl::eraseOperand(int index, int count) {
 
   auto result = replaceOperand(index, replaceOperand(index + 1, nullptr));
 
-  for (int i = 1; i < count; ++i) {
-    replaceOperand(index + i, nullptr);
-  }
-
-  for (int i = index + 1; i < operands.size() - count; ++i) {
+  for (std::size_t i = index + 1; i < operands.size() - count; ++i) {
     replaceOperand(i, replaceOperand(i + count, nullptr));
   }
 
@@ -146,6 +144,12 @@ inline void RegionLikeImpl::prependChild(Instruction node) {
   assert(node.getPrev() == nullptr);
   assert(node.getNext() == nullptr);
 
+#ifndef NDEBUG
+  if (auto thisInst = dynamic_cast<InstructionImpl *>(this)) {
+    assert(node != thisInst);
+  }
+#endif
+
   node.get()->parent = this;
   if (last == nullptr) {
     last = node;
@@ -161,6 +165,12 @@ inline void RegionLikeImpl::addChild(Instruction node) {
   assert(node.getPrev() == nullptr);
   assert(node.getNext() == nullptr);
 
+#ifndef NDEBUG
+  if (auto thisInst = dynamic_cast<InstructionImpl *>(this)) {
+    assert(node != thisInst);
+  }
+#endif
+  
   node.get()->parent = this;
   if (first == nullptr) {
     first = node;
@@ -171,13 +181,33 @@ inline void RegionLikeImpl::addChild(Instruction node) {
   last = node;
 }
 
-inline void RegionImpl::print(std::ostream &os, NameStorage &ns) const {
+inline void RegionLikeImpl::printRegion(std::ostream &os, NameStorage &ns,
+                                        const PrintOptions &opts) const {
+  if (auto node = dynamic_cast<const NodeImpl *>(this)) {
+    node->print(os, ns, opts);
+  } else {
+    os << "<detached region>";
+  }
+}
+
+inline auto RegionLikeImpl::getParent() const {
+  if (auto inst = dynamic_cast<const InstructionImpl *>(this)) {
+    return inst->parent;
+  }
+
+  return RegionLike();
+}
+
+inline void RegionImpl::print(std::ostream &os, NameStorage &ns,
+                              const PrintOptions &opts) const {
+  opts.printIdent(os);
   os << "{\n";
-  for (auto child : children()) {
-    os << "  ";
-    child.print(os, ns);
+  for (auto childIdent = opts.nextLevel(); auto child : children()) {
+    childIdent.printIdent(os);
+    child.print(os, ns, childIdent);
     os << "\n";
   }
+  opts.printIdent(os);
   os << "}";
 }
 
@@ -230,6 +260,24 @@ T cloneInstructionImpl(const U *object, Context &context, CloneMap &map,
 
   return result;
 }
+
+template <typename T, typename U, typename... ArgsT>
+  requires(std::is_same_v<typename T::underlying_type, U>)
+T cloneBlockImpl(const U *object, Context &context, CloneMap &map,
+                 ArgsT &&...args) {
+  auto result = context.create<T>(clone(object->getLocation(), context),
+                                  std::forward<ArgsT>(args)...);
+
+  for (auto &&operand : object->getOperands()) {
+    result.addOperand(operand.clone(context, map));
+  }
+
+  for (auto &&child : object->children()) {
+    result.addChild(ir::clone(child, context, map));
+  }
+
+  return result;
+}
 } // namespace detail
 
 inline Node InstructionImpl::clone(Context &context, CloneMap &map) const {
@@ -250,20 +298,24 @@ inline Node RegionImpl::clone(Context &context, CloneMap &map) const {
   return result;
 }
 
-inline BlockImpl::BlockImpl(Location loc)
-    : ValueImpl(loc, ir::Kind::Builtin, builtin::BLOCK) {}
-
 inline Node BlockImpl::clone(Context &context, CloneMap &map) const {
-  auto result = context.create<Block>(ir::clone(getLocation(), context));
-  for (auto &&operand : getOperands()) {
-    result.addOperand(operand.clone(context, map));
-  }
+  return detail::cloneBlockImpl<Block>(this, context, map, kind, op);
+}
 
-  for (auto &&child : children()) {
-    result.addChild(ir::clone(child, context, map));
-  }
+inline Node ContinueConstructImpl::clone(Context &context,
+                                         CloneMap &map) const {
+  return detail::cloneBlockImpl<ContinueConstruct>(this, context, map, kind,
+                                                   op);
+}
 
-  return result;
+inline Node LoopConstructImpl::clone(Context &context, CloneMap &map) const {
+  return detail::cloneBlockImpl<LoopConstruct>(this, context, map, kind, op);
+}
+
+inline Node SelectionConstructImpl::clone(Context &context,
+                                          CloneMap &map) const {
+  return detail::cloneBlockImpl<SelectionConstruct>(this, context, map, kind,
+                                                    op);
 }
 
 inline Operand Operand::clone(Context &context, CloneMap &map) const {
@@ -324,7 +376,8 @@ inline Node memssa::DefImpl::clone(Context &context, CloneMap &map) const {
 
 inline Node memssa::ScopeImpl::clone(Context &context, CloneMap &map) const {
   auto self = Scope(const_cast<ScopeImpl *>(this));
-  auto result = context.create<Scope>(ir::clone(self.getLocation(), context));
+  auto result =
+      context.create<Scope>(ir::clone(self.getLocation(), context), kind, op);
 
   for (auto &&operand : self.getOperands()) {
     result.addOperand(operand.clone(context, map));
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/InstructionImpl.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/InstructionImpl.hpp
index b958e66f7..0d42c7c74 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/InstructionImpl.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/InstructionImpl.hpp
@@ -47,12 +47,13 @@ struct InstructionImpl : NodeImpl {
 
   decltype(auto) getOperands() const { return std::span(operands); }
 
-  void print(std::ostream &os, NameStorage &ns) const override {
+  void print(std::ostream &os, NameStorage &ns,
+             const PrintOptions &) const override {
     os << getInstructionName(kind, op);
 
     if (!operands.empty()) {
       os << "(";
-      for (bool first = true; auto operand : operands) {
+      for (bool first = true; auto &operand : operands) {
         if (first) {
           first = false;
         } else {
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/LoopConstruct.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/LoopConstruct.hpp
new file mode 100644
index 000000000..58d250555
--- /dev/null
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/LoopConstruct.hpp
@@ -0,0 +1,105 @@
+#pragma once
+
+#include "Construct.hpp"
+
+namespace shader::ir {
+template <typename ImplT>
+struct ContinueConstructWrapper : ConstructWrapper<ImplT> {
+  using ConstructWrapper<ImplT>::ConstructWrapper;
+  using ConstructWrapper<ImplT>::operator=;
+};
+
+struct ContinueConstructImpl;
+struct ContinueConstruct : ContinueConstructWrapper<ContinueConstructImpl> {
+  using ContinueConstructWrapper<
+      ContinueConstructImpl>::ContinueConstructWrapper;
+  using ContinueConstructWrapper<ContinueConstructImpl>::operator=;
+};
+
+template <typename ImplT>
+struct LoopConstructWrapper : ConstructWrapper<ImplT> {
+  using ConstructWrapper<ImplT>::ConstructWrapper;
+  using ConstructWrapper<ImplT>::operator=;
+
+  Block getLatch() { return this->impl->last.template staticCast<Block>(); }
+
+  ContinueConstruct getContinue() {
+    return this->impl->getOperand(2)
+        .getAsValue()
+        .template staticCast<ContinueConstruct>();
+  }
+};
+
+struct LoopConstructImpl;
+struct LoopConstruct : LoopConstructWrapper<LoopConstructImpl> {
+  using LoopConstructWrapper<LoopConstructImpl>::LoopConstructWrapper;
+  using LoopConstructWrapper<LoopConstructImpl>::operator=;
+};
+
+struct LoopConstructImpl : ConstructImpl {
+  using ConstructImpl::ConstructImpl;
+
+  Node clone(Context &context, CloneMap &map) const override;
+
+  void print(std::ostream &os, NameStorage &ns,
+             const PrintOptions &opts) const override {
+    os << '%' << ns.getNameOf(const_cast<LoopConstructImpl *>(this));
+    os << " = ";
+
+    if (getOperands().size() > 3) {
+      os << '[';
+      for (bool first = true; auto &operand : getOperands().subspan(3)) {
+        if (first) {
+          first = false;
+        } else {
+          os << ", ";
+        }
+
+        operand.print(os, ns);
+      }
+      os << "] ";
+    }
+
+    auto bodyOpts = opts.nextLevel();
+    os << "loop (header = ";
+    getOperand(0).print(os, ns);
+    os << ", merge = ";
+    getOperand(1).print(os, ns);
+    os << ", latch = ";
+    os << "%" << ns.getNameOf(last);
+    os << ") {\n";
+
+    {
+      bodyOpts.printIdent(os);
+      os << "body {\n";
+      for (auto childOpts = bodyOpts.nextLevel(); auto child : children()) {
+        childOpts.printIdent(os);
+        child.print(os, ns, childOpts);
+        os << "\n";
+      }
+
+      bodyOpts.printIdent(os);
+      os << "}\n";
+    }
+
+    {
+      bodyOpts.printIdent(os);
+      os << "continue {\n";
+      bodyOpts.printIdent(os, 1);
+      getOperand(2).getAsValue().print(os, ns, bodyOpts.nextLevel());
+      os << "\n";
+      bodyOpts.printIdent(os);
+      os << "}\n";
+    }
+
+    opts.printIdent(os);
+    os << "}";
+  }
+};
+
+struct ContinueConstructImpl : ConstructImpl {
+  using ConstructImpl::ConstructImpl;
+  Node clone(Context &context, CloneMap &map) const override;
+};
+
+} // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/NodeImpl.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/NodeImpl.hpp
index 7fb8046ba..2b3287981 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/NodeImpl.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/NodeImpl.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "PrintOptions.hpp"
 #include "Location.hpp"
 #include "Node.hpp"
 #include "Operand.hpp"
@@ -59,7 +60,7 @@ struct NodeImpl {
   void setLocation(Location newLocation) { location = newLocation; }
   Location getLocation() const { return location; }
 
-  virtual void print(std::ostream &os, NameStorage &ns) const = 0;
+  virtual void print(std::ostream &os, NameStorage &ns, const PrintOptions &opts) const = 0;
   virtual Node clone(Context &context, CloneMap &map) const = 0;
 };
 } // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PreincNodeIterable.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PreincNodeIterable.hpp
index 1b00c4208..2d83bde35 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PreincNodeIterable.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PreincNodeIterable.hpp
@@ -1,9 +1,10 @@
 #pragma once
 
 #include "InstructionImpl.hpp" // IWYU pragma: keep
+#include <type_traits>
 
 namespace shader::ir {
-template <typename T> struct PreincNodeIterable {
+template <typename T = Instruction> struct Range {
   struct EndIterator {};
 
   struct Iterator {
@@ -52,18 +53,24 @@ template <typename T> struct PreincNodeIterable {
     }
   };
 
-  PreincNodeIterable(Instruction beginIt, Instruction endIt)
+  Range(Instruction beginIt, Instruction endIt)
       : mBeginIt(beginIt), mEndIt(endIt) {}
 
+  template <typename OtherT>
+    requires(!std::is_same_v<OtherT, Range>)
+  Range(OtherT other) : Range(other.mBeginIt, other.mEndIt) {}
+
   Iterator begin() const { return Iterator(mBeginIt, mEndIt); }
   EndIterator end() const { return EndIterator{}; }
 
 private:
   Instruction mBeginIt;
   Instruction mEndIt;
+
+  template <typename> friend struct Range;
 };
 
-template <typename T> struct RevPreincNodeIterable {
+template <typename T = Instruction> struct RevRange {
   struct EndIterator {};
 
   struct Iterator {
@@ -112,25 +119,37 @@ template <typename T> struct RevPreincNodeIterable {
     }
   };
 
-  RevPreincNodeIterable(Instruction beginIt, Instruction endIt)
+  RevRange(Instruction beginIt, Instruction endIt)
       : mBeginIt(beginIt), mEndIt(endIt) {}
 
+  template <typename OtherT>
+    requires(!std::is_same_v<OtherT, RevRange>)
+  RevRange(OtherT other) : RevRange(other.mBeginIt, other.mEndIt) {}
+
   Iterator begin() const { return Iterator(mBeginIt, mEndIt); }
   EndIterator end() const { return EndIterator{}; }
 
 private:
   Instruction mBeginIt;
   Instruction mEndIt;
+
+  template <typename> friend struct RevRange;
 };
 
 template <typename T = Instruction>
-inline PreincNodeIterable<T> range(Instruction begin,
-                                   Instruction end = nullptr) {
+inline Range<T> range(Instruction begin, Instruction end = nullptr) {
+  if (end) {
+    assert(begin.getParent() == end.getParent());
+  }
+
   return {begin, end};
 }
 template <typename T = Instruction>
-inline RevPreincNodeIterable<T> revRange(Instruction begin,
-                                         Instruction end = nullptr) {
+inline RevRange<T> revRange(Instruction begin, Instruction end = nullptr) {
+  if (end) {
+    assert(begin.getParent() == end.getParent());
+  }
+
   return {begin, end};
 }
 } // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PrintOptions.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PrintOptions.hpp
new file mode 100644
index 000000000..53983c0da
--- /dev/null
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PrintOptions.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <ostream>
+#include <string>
+
+namespace shader {
+struct PrintOptions {
+  int identLevel = 0;
+  int identCount = 2;
+  char identChar = ' ';
+
+  [[nodiscard]] PrintOptions nextLevel() const {
+    auto result = *this;
+    result.identLevel++;
+    return result;
+  }
+
+  void printIdent(std::ostream &os, int offset = 0) const {
+    os << std::string((identLevel + offset) * identCount, identChar);
+  }
+};
+} // namespace shader
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PrintableWrapper.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PrintableWrapper.hpp
index c44e86ed4..911743745 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PrintableWrapper.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/PrintableWrapper.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "PointerWrapper.hpp"
+#include "PrintOptions.hpp"
 #include <ostream>
 
 namespace shader::ir {
@@ -9,18 +10,28 @@ template <typename T> struct PrintableWrapper : PointerWrapper<T> {
   using PointerWrapper<T>::PointerWrapper;
   using PointerWrapper<T>::operator=;
 
-  void print(std::ostream &os, NameStorage &ns) const {
-    if constexpr (requires { this->impl->print(os, ns); }) {
+  void print(std::ostream &os, NameStorage &ns, const PrintOptions &opts = {}) const {
+    if constexpr (requires { this->impl->print(os, ns, opts); }) {
+      this->impl->print(os, ns, opts);
+    } else if constexpr (requires { this->impl->print(os, ns); }) {
       this->impl->print(os, ns);
+    } else if constexpr (requires { this->impl->print(os, opts); }) {
+      this->impl->print(os, opts);
     } else {
       this->impl->print(os);
     }
   }
 
-  void print(std::ostream &os) const
-    requires requires { this->impl->print(os); }
+  void print(std::ostream &os, const PrintOptions &opts = {}) const
+    requires(
+        requires { this->impl->print(os, opts); } ||
+        requires { this->impl->print(os); })
   {
-    this->impl->print(os);
+    if constexpr (requires { this->impl->print(os, opts); }) {
+      this->impl->print(os, opts);
+    } else {
+      this->impl->print(os);
+    }
   }
 };
 } // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionImpl.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionImpl.hpp
index c5d81ce30..bd85df18f 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionImpl.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionImpl.hpp
@@ -9,7 +9,8 @@ namespace shader::ir {
 struct RegionImpl : NodeImpl, RegionLikeImpl {
   RegionImpl(Location loc) { setLocation(loc); }
 
-  void print(std::ostream &os, NameStorage &ns) const override;
+  void print(std::ostream &os, NameStorage &ns,
+             const PrintOptions &opts) const override;
   Node clone(Context &context, CloneMap &map) const override;
 };
 } // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionLike.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionLike.hpp
index 87c12c9c5..03488f73a 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionLike.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionLike.hpp
@@ -28,9 +28,19 @@ struct RegionLikeWrapper : BaseWrapper<ImplT> {
   template <typename T = Instruction> auto revChildren() {
     return this->impl->template revChildren<T>();
   }
+
+  void print(std::ostream &os, NameStorage &ns,
+             const PrintOptions &opts = {}) const {
+    this->impl->printRegion(os, ns, opts);
+  }
+
+  auto getParent() const {
+    return this->impl->getParent();
+  }
 };
 
 struct RegionLikeImpl;
+
 struct RegionLike : RegionLikeWrapper<RegionLikeImpl, PointerWrapper> {
   using RegionLikeWrapper::RegionLikeWrapper;
   using RegionLikeWrapper::operator=;
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionLikeImpl.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionLikeImpl.hpp
index 65c524944..0ff57ff6f 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionLikeImpl.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/RegionLikeImpl.hpp
@@ -11,15 +11,20 @@ struct RegionLikeImpl {
   virtual ~RegionLikeImpl() = default;
 
   template <typename T = Instruction> auto children() const {
-    return PreincNodeIterable<T>{first, nullptr};
+    return Range<T>{first, nullptr};
   }
 
   template <typename T = Instruction> auto revChildren() const {
-    return RevPreincNodeIterable<T>{last, nullptr};
+    return RevRange<T>{last, nullptr};
   }
 
-  virtual void insertAfter(Instruction point, Instruction node);
-  virtual void prependChild(Instruction node);
-  virtual void addChild(Instruction node);
+  void insertAfter(Instruction point, Instruction node);
+  void prependChild(Instruction node);
+  void addChild(Instruction node);
+
+  void printRegion(std::ostream &os, NameStorage &ns,
+                           const PrintOptions &opts) const;
+
+  auto getParent() const;
 };
 } // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/SelectionConstruct.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/SelectionConstruct.hpp
new file mode 100644
index 000000000..a148df076
--- /dev/null
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/SelectionConstruct.hpp
@@ -0,0 +1,62 @@
+#pragma once
+
+#include "Construct.hpp"
+
+namespace shader::ir {
+template <typename ImplT>
+struct SelectionConstructWrapper : ConstructWrapper<ImplT> {
+  using ConstructWrapper<ImplT>::ConstructWrapper;
+  using ConstructWrapper<ImplT>::operator=;
+};
+
+struct SelectionConstructImpl;
+
+struct SelectionConstruct : SelectionConstructWrapper<SelectionConstructImpl> {
+  using SelectionConstructWrapper<
+      SelectionConstructImpl>::SelectionConstructWrapper;
+  using SelectionConstructWrapper<SelectionConstructImpl>::operator=;
+};
+
+struct SelectionConstructImpl : ConstructImpl {
+  using ConstructImpl::ConstructImpl;
+
+  Node clone(Context &context, CloneMap &map) const override;
+
+  void print(std::ostream &os, NameStorage &ns,
+             const PrintOptions &opts) const override {
+    os << '%' << ns.getNameOf(const_cast<SelectionConstructImpl *>(this));
+    os << " = ";
+
+    if (getOperands().size() > 2) {
+      os << '[';
+      for (bool first = true; auto &operand : getOperands().subspan(2)) {
+        if (first) {
+          first = false;
+        } else {
+          os << ", ";
+        }
+
+        operand.print(os, ns);
+      }
+      os << "] ";
+    }
+
+    auto bodyOpts = opts.nextLevel();
+    os << "selection (header = ";
+    getOperand(0).print(os, ns);
+    os << ", merge = ";
+    getOperand(1).print(os, ns);
+    os << ") {\n";
+
+    for (auto child : children()) {
+      bodyOpts.printIdent(os);
+
+      child.print(os, ns, bodyOpts);
+      os << "\n";
+    }
+
+    opts.printIdent(os);
+    os << "}";
+  }
+};
+} // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Value.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Value.hpp
index bbdefaec0..c4a4f1482 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Value.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/Value.hpp
@@ -2,9 +2,12 @@
 
 #include "Instruction.hpp"
 #include "Operand.hpp"
+#include "rx/FunctionRef.hpp"
 
 namespace shader::ir {
 struct Value;
+struct ValueUse;
+
 template <typename T> struct ValueWrapper : InstructionWrapper<T> {
   using InstructionWrapper<T>::InstructionWrapper;
   using InstructionWrapper<T>::operator=;
@@ -12,6 +15,7 @@ template <typename T> struct ValueWrapper : InstructionWrapper<T> {
   decltype(auto) getUserList() const { return this->impl->getUserList(); }
   auto &getUseList() const { return this->impl->uses; }
   void replaceAllUsesWith(Value other) const;
+  void replaceUsesIf(Value other, rx::FunctionRef<bool(ValueUse)> cb);
 
   bool isUnused() const { return this->impl->uses.empty(); }
 };
@@ -22,15 +26,21 @@ struct Value : ValueWrapper<ValueImpl> {
   using ValueWrapper::operator=;
 };
 
-template <typename T>
-void ValueWrapper<T>::replaceAllUsesWith(Value other) const {
-  this->impl->replaceAllUsesWith(other);
-}
-
 struct ValueUse {
   Instruction user;
   Value node;
   int operandIndex;
   auto operator<=>(const ValueUse &) const = default;
 };
+
+template <typename T>
+void ValueWrapper<T>::replaceAllUsesWith(Value other) const {
+  this->impl->replaceAllUsesWith(other);
+}
+
+template <typename T>
+void ValueWrapper<T>::replaceUsesIf(Value other,
+                                    rx::FunctionRef<bool(ValueUse)> cb) {
+  this->impl->replaceUsesIf(other, cb);
+}
 } // namespace shader::ir
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/ValueImpl.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/ValueImpl.hpp
index a30bddeca..af785cb10 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/ir/ValueImpl.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/ir/ValueImpl.hpp
@@ -4,25 +4,24 @@
 #include "NameStorage.hpp"
 #include "Node.hpp"
 #include "Value.hpp"
+#include "rx/FunctionRef.hpp"
 
 namespace shader::ir {
 struct ValueImpl : InstructionImpl {
   std::set<ValueUse> uses;
 
-  ValueImpl(Location location, Kind kind, unsigned op,
-            std::span<const Operand> operands = {})
-      : InstructionImpl(location, kind, op, operands) {}
+  using InstructionImpl::InstructionImpl;
 
   void addUse(Instruction user, int operandIndex) {
-    uses.insert({user, this, operandIndex});
+    uses.insert({.user=user, .node=this, .operandIndex=operandIndex});
   }
 
   void removeUse(Instruction user, int operandIndex) {
-    uses.erase({user, this, operandIndex});
+    uses.erase({.user=user, .node=this, .operandIndex=operandIndex});
   }
 
-  std::set<Node> getUserList() const {
-    std::set<Node> list;
+  std::set<Instruction> getUserList() const {
+    std::set<Instruction> list;
     for (auto use : uses) {
       list.insert(use.user);
     }
@@ -44,10 +43,29 @@ struct ValueImpl : InstructionImpl {
     }
   }
 
-  void print(std::ostream &os, NameStorage &ns) const override {
+  void replaceUsesIf(Value other, rx::FunctionRef<bool(ValueUse)> cond) {
+    if (other == this) {
+      std::abort();
+    }
+
+    auto savedUses = uses;
+
+    for (auto &use : savedUses) {
+      if (cond(use)) {
+        if (other == nullptr) {
+          use.user.replaceOperand(use.operandIndex, nullptr);
+        } else {
+          use.user.replaceOperand(use.operandIndex, other);
+        }
+      }
+    }
+  }
+
+  void print(std::ostream &os, NameStorage &ns,
+             const PrintOptions &opts) const override {
     os << '%' << ns.getNameOf(const_cast<ValueImpl *>(this));
     os << " = ";
-    InstructionImpl::print(os, ns);
+    InstructionImpl::print(os, ns, opts);
   }
 
   Node clone(Context &context, CloneMap &map) const override;
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/spv.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/spv.hpp
index ba2030459..8c1a6b4a0 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/spv.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/spv.hpp
@@ -113,7 +113,7 @@ std::optional<BinaryLayout> deserialize(ir::Context &context,
 ///
 /// \returns A vector of u32 values representing the SPIR-V binary.
 ///
-std::vector<std::uint32_t> serialize(ir::Region body);
+std::vector<std::uint32_t> serialize(ir::RegionLike body);
 
 inline std::vector<std::uint32_t> serialize(ir::Context &context,
                                             BinaryLayout &&layout) {
diff --git a/rpcsx/gpu/lib/gcn-shader/include/shader/transform.hpp b/rpcsx/gpu/lib/gcn-shader/include/shader/transform.hpp
index 92fbb99ce..43c0e6da7 100644
--- a/rpcsx/gpu/lib/gcn-shader/include/shader/transform.hpp
+++ b/rpcsx/gpu/lib/gcn-shader/include/shader/transform.hpp
@@ -3,6 +3,5 @@
 #include "ir.hpp"
 
 namespace shader {
-void structurizeCfg(spv::Context &context, ir::RegionLike region,
-                    ir::Value exitLabel);
+void structurizeCfg(spv::Context &context, ir::RegionLike region);
 }
diff --git a/rpcsx/gpu/lib/gcn-shader/src/GcnConverter.cpp b/rpcsx/gpu/lib/gcn-shader/src/GcnConverter.cpp
index 48d662cdd..498a566ba 100644
--- a/rpcsx/gpu/lib/gcn-shader/src/GcnConverter.cpp
+++ b/rpcsx/gpu/lib/gcn-shader/src/GcnConverter.cpp
@@ -374,7 +374,7 @@ struct ResourcesBuilder {
         } else if (auto value = inst.cast<ir::Value>()) {
           resourcePhi.addOperand(value);
         } else {
-          auto block = resources.context.create<ir::Block>(inst.getLocation());
+          auto block = resources.context.create<ir::Block>(inst.getLocation(), ir::Kind::Builtin, ir::builtin::BLOCK);
           inst.erase();
           block.addChild(inst);
           resourcePhi.addOperand(block);
@@ -396,7 +396,8 @@ struct ResourcesBuilder {
       return value;
     }
 
-    auto block = resources.context.create<ir::Block>(inst.getLocation());
+    auto block = resources.context.create<ir::Block>(
+        inst.getLocation(), ir::Kind::Builtin, ir::builtin::BLOCK);
     block.addChild(inst);
     return block;
   }
diff --git a/rpcsx/gpu/lib/gcn-shader/src/SpvConverter.cpp b/rpcsx/gpu/lib/gcn-shader/src/SpvConverter.cpp
index f812a2741..158330b21 100644
--- a/rpcsx/gpu/lib/gcn-shader/src/SpvConverter.cpp
+++ b/rpcsx/gpu/lib/gcn-shader/src/SpvConverter.cpp
@@ -12,7 +12,7 @@ static std::string getTypeName(ir::Value type);
 static std::string getConstantName(ir::Value constant) {
   if (constant == ir::spv::OpConstant) {
     auto typeValue = constant.getOperand(0).getAsValue();
-    auto value = constant.getOperand(1);
+    auto &value = constant.getOperand(1);
 
     if (typeValue == ir::spv::OpTypeInt) {
       auto width = *typeValue.getOperand(0).getAsInt32();
@@ -310,6 +310,10 @@ ir::Node spv::Import::getOrCloneImpl(ir::Context &context, ir::Node node,
   return CloneMap::getOrCloneImpl(context, node, isOperand);
 }
 
+ir::Region spv::Context::createRegion(ir::Location loc) {
+  return create<ir::Region>(loc);
+}
+
 ir::Value spv::Context::createRegionWithLabel(ir::Location loc) {
   return Builder::createAppend(*this, create<ir::Region>(loc))
       .createSpvLabel(loc);
@@ -340,6 +344,10 @@ ir::Value spv::Context::getNull(ir::Value typeValue) {
   return getOrCreateGlobal(ir::spv::OpConstantNull, {{typeValue}});
 }
 
+ir::Value spv::Context::getUndef(ir::Value typeValue) {
+  return getOrCreateGlobal(ir::spv::OpUndef, {{typeValue}});
+}
+
 ir::Value spv::Context::getType(ir::spv::Op baseType, int width,
                                 bool isSigned) {
   switch (baseType) {
diff --git a/rpcsx/gpu/lib/gcn-shader/src/analyze.cpp b/rpcsx/gpu/lib/gcn-shader/src/analyze.cpp
index d7e996d7c..3b342ab5a 100644
--- a/rpcsx/gpu/lib/gcn-shader/src/analyze.cpp
+++ b/rpcsx/gpu/lib/gcn-shader/src/analyze.cpp
@@ -3,8 +3,8 @@
 #include "ir.hpp"
 #include "rx/die.hpp"
 #include "spv.hpp"
+#include <algorithm>
 #include <iostream>
-#include <print>
 
 using namespace shader;
 
@@ -174,6 +174,274 @@ ir::Value shader::unwrapPointer(ir::Value pointer) {
   }
 }
 
+ir::Instruction shader::getTerminator(ir::RegionLike region) {
+  if (auto block = region.cast<ir::Block>()) {
+    if (block == ir::builtin::LOOP_CONSTRUCT ||
+        block == ir::builtin::SELECTION_CONSTRUCT) {
+      return block;
+    }
+  }
+
+  auto terminator = region.getLast();
+  if (!terminator || !isTerminator(terminator)) {
+    return {};
+  }
+  return terminator;
+}
+
+static int getTotalSuccessorCount(ir::Instruction terminator) {
+  if (terminator == ir::spv::OpBranch) {
+    return 1;
+  }
+
+  if (terminator == ir::spv::OpBranchConditional) {
+    return 2;
+  }
+
+  if (terminator == ir::spv::OpSwitch) {
+    return terminator.getOperandCount() / 2;
+  }
+
+  if (terminator == ir::builtin::LOOP_CONSTRUCT ||
+      terminator == ir::builtin::SELECTION_CONSTRUCT) {
+    return 1;
+  }
+
+  return 0;
+}
+
+static void walkSuccessors(ir::Instruction terminator, auto &&cb) {
+  if (terminator == ir::spv::OpBranch) {
+    cb(terminator.getOperand(0).getAsValue(), 0);
+    return;
+  }
+
+  if (terminator == ir::spv::OpBranchConditional) {
+    cb(terminator.getOperand(1).getAsValue(), 1);
+    cb(terminator.getOperand(2).getAsValue(), 2);
+    return;
+  }
+
+  if (terminator == ir::spv::OpSwitch) {
+    for (std::size_t i = 1, end = terminator.getOperandCount(); i < end;
+         i += 2) {
+      cb(terminator.getOperand(i).getAsValue(), i);
+    }
+    return;
+  }
+
+  if (terminator == ir::builtin::LOOP_CONSTRUCT ||
+      terminator == ir::builtin::SELECTION_CONSTRUCT) {
+    cb(terminator.getOperand(0).getAsValue(), 0);
+  }
+}
+
+std::vector<std::pair<ir::Block, int>>
+shader::getAllSuccessors(ir::Block region) {
+  auto terminator = getTerminator(region);
+
+  if (!terminator) {
+    return {};
+  }
+
+  std::vector<std::pair<ir::Block, int>> result;
+  result.reserve(getTotalSuccessorCount(terminator));
+
+  walkSuccessors(terminator, [&](ir::Value successor, int operandIndex) {
+    if (auto block = successor.cast<ir::Block>()) {
+      result.emplace_back(block, operandIndex);
+    }
+  });
+
+  return result;
+}
+
+std::vector<std::pair<ir::Block, int>>
+shader::getAllPredecessors(ir::Block region) {
+  std::vector<std::pair<ir::Block, int>> result;
+  result.reserve(region.getUseList().size());
+
+  for (auto &use : region.getUseList()) {
+    if (isBranch(use.user)) {
+      if (auto block = use.user.getParent().cast<ir::Block>()) {
+        result.emplace_back(block, use.operandIndex);
+      }
+
+      continue;
+    }
+
+    if (use.operandIndex == 0 &&
+        (use.user == ir::builtin::LOOP_CONSTRUCT ||
+         use.user == ir::builtin::SELECTION_CONSTRUCT)) {
+      result.emplace_back(use.user.staticCast<ir::Block>(), use.operandIndex);
+      continue;
+    }
+  }
+
+  return result;
+}
+
+std::unordered_set<ir::Block> shader::getSuccessors(ir::Block block) {
+  auto terminator = getTerminator(block);
+
+  if (!terminator) {
+    return {};
+  }
+
+  std::unordered_set<ir::Block> result;
+
+  result.reserve(getTotalSuccessorCount(terminator));
+
+  walkSuccessors(terminator, [&](ir::Value successor, int) {
+    if (auto block = successor.cast<ir::Block>()) {
+      result.insert(block);
+    }
+  });
+
+  return result;
+}
+
+std::unordered_set<ir::Block> shader::getPredecessors(ir::Block block) {
+  std::unordered_set<ir::Block> result;
+  result.reserve(block.getUseList().size());
+
+  for (auto &use : block.getUseList()) {
+    if (use.operandIndex == 0 &&
+        (use.user == ir::builtin::LOOP_CONSTRUCT ||
+         use.user == ir::builtin::SELECTION_CONSTRUCT)) {
+      result.insert(use.user.staticCast<ir::Block>());
+      continue;
+    }
+
+    if (isBranch(use.user)) {
+      if (auto block = use.user.getParent().cast<ir::Block>()) {
+        result.insert(block);
+      }
+    }
+  }
+
+  return result;
+}
+
+std::size_t shader::getSuccessorCount(ir::Block region) {
+  return getSuccessors(region).size();
+}
+
+std::size_t shader::getPredecessorCount(ir::Block region) {
+  return getPredecessors(region).size();
+}
+
+bool shader::hasSuccessor(ir::Block region, ir::Block successor) {
+  auto terminator = getTerminator(region);
+
+  if (!terminator) {
+    return false;
+  }
+
+  bool result = false;
+
+  walkSuccessors(terminator, [&](ir::Value currentSuccessor, int) {
+    if (result) {
+      return;
+    }
+
+    if (currentSuccessor == successor) {
+      result = true;
+      return;
+    }
+  });
+
+  return result;
+}
+
+bool shader::hasAtLeastSuccessors(ir::Block region, std::size_t count) {
+  auto terminator = getTerminator(region);
+  if (!terminator) {
+    return false;
+  }
+
+  if (getTotalSuccessorCount(terminator) < count) {
+    return false;
+  }
+
+  std::vector<ir::Block> successors;
+  successors.reserve(count - 1);
+
+  bool result = false;
+  walkSuccessors(terminator, [&](ir::Value successor, int) {
+    if (result) {
+      return;
+    }
+
+    if (auto block = successor.cast<ir::Block>()) {
+      if (!std::ranges::contains(successors, block)) {
+        if (successors.size() + 1 >= count) {
+          result = true;
+          return;
+        }
+
+        successors.push_back(block);
+      }
+    }
+  });
+
+  return result;
+}
+
+ir::Block shader::getUniqSuccessor(ir::Block region) {
+  auto terminator = getTerminator(region);
+  if (!terminator) {
+    return {};
+  }
+
+  ir::Block result;
+  bool noUniqSuccessor = false;
+
+  walkSuccessors(terminator, [&](ir::Value successor, int) {
+    if (noUniqSuccessor) {
+      return;
+    }
+
+    if (auto block = successor.cast<ir::Block>()) {
+      if (!result) {
+        result = block;
+      } else if (result != block) {
+        noUniqSuccessor = true;
+      }
+    }
+  });
+
+  if (noUniqSuccessor) {
+    return {};
+  }
+
+  return result;
+}
+
+graph::DomTree<ir::Block> shader::buildDomTree(ir::Block block) {
+  return graph::buildDomTree(block, [&](ir::Block region, const auto &cb) {
+    for (auto succ : getSuccessors(region)) {
+      cb(succ);
+    }
+  });
+}
+
+graph::DomTree<ir::Block> shader::buildPostDomTree(ir::Block block) {
+  return graph::buildDomTree(block, [&](ir::Block region, const auto &cb) {
+    for (auto pred : getPredecessors(region)) {
+      cb(pred);
+    }
+  });
+}
+
+graph::DomTree<ir::Block> shader::buildDomTree(ir::RegionLike region) {
+  return buildDomTree(region.getFirst().staticCast<ir::Block>());
+}
+
+graph::DomTree<ir::Block> shader::buildPostDomTree(ir::RegionLike region) {
+  return buildPostDomTree(region.getLast().staticCast<ir::Block>());
+}
+
 graph::DomTree<ir::Value> shader::buildDomTree(CFG &cfg, ir::Value root) {
   if (root == nullptr) {
     root = cfg.getEntryLabel();
@@ -223,195 +491,38 @@ void CFG::print(std::ostream &os, ir::NameStorage &ns, bool subgraph,
 
 std::string CFG::genTest() {
   std::string result;
-  result += "ir::Value genCfg(spv::Context &context) {\n";
-  result += "  auto loc = context.getUnknownLocation();\n";
-  result += "  auto boolT = context.getTypeBool();\n";
-  result += "  auto trueV = context.getTrue();\n";
-  result += "  auto builder = Builder::createAppend(context, "
-            "context.layout.getOrCreateFunctions(context));\n";
-  result += "  auto debugs = Builder::createAppend(context, "
-            "context.layout.getOrCreateDebugs(context));\n";
-
+  result += "void cfgTest() {\n";
   ir::NameStorage ns;
 
   for (auto node : getPreorderNodes()) {
     auto name = ns.getNameOf(node->getLabel());
-    result += "  auto _" + name + " =  builder.createSpvLabel(loc);\n";
-    result += "  context.ns.setNameOf(_" + name + ", \"" + name + "\");\n";
-    result += "  debugs.createSpvName(loc, _" + name + ", \"" + name + "\");\n";
+    result += "  auto _" + name + " =  createLabel(\"" + name + "\");\n";
   }
 
   for (auto node : getPreorderNodes()) {
     auto name = ns.getNameOf(node->getLabel());
-    result +=
-        "  builder = Builder::createInsertAfter(context, _" + name + ");\n";
     if (node->getSuccessorCount() == 1) {
-      result += "  builder.createSpvBranch(loc, _" +
+      result += "  createBranch(_" +
                 ns.getNameOf((*node->getSuccessors().begin())->getLabel()) +
                 ");\n";
     } else if (node->getSuccessorCount() == 2) {
       auto firstIt = node->getSuccessors().begin();
       auto secondIt = std::next(firstIt);
-      result += "  builder.createSpvBranchConditional(loc, trueV, _" +
+      result += "  createConditionalBranch(_" +
                 ns.getNameOf((*firstIt)->getLabel()) + ", _" +
                 ns.getNameOf((*secondIt)->getLabel()) + ");\n";
 
     } else if (node->getSuccessorCount() == 0) {
-      result += "  builder.createSpvReturn(loc);\n";
-      result += "  auto returnBlock = _" + name + ";\n";
+      result += "  createReturn(_" + name + ");\n";
     }
   }
 
-  result += "  return returnBlock;\n";
   result += "}\n";
 
   return result;
 }
 
-static void walkSuccessors(ir::Instruction terminator, auto &&cb) {
-  if (terminator == ir::spv::OpBranch) {
-    cb(terminator.getOperand(0).getAsValue());
-    return;
-  }
-
-  if (terminator == ir::spv::OpBranchConditional) {
-    cb(terminator.getOperand(1).getAsValue());
-    cb(terminator.getOperand(2).getAsValue());
-    return;
-  }
-
-  if (terminator == ir::spv::OpSwitch) {
-    for (std::size_t i = 1, end = terminator.getOperandCount(); i < end;
-         i += 2) {
-      cb(terminator.getOperand(i).getAsValue());
-    }
-    return;
-  }
-}
-
-CFG CFG::buildView(CFG::Node *from, PostDomTree *domTree,
-                   const std::unordered_set<ir::Value> &stopLabels,
-                   ir::Value continueLabel) {
-  struct Item {
-    CFG::Node *node;
-    std::vector<CFG::Node *> successors;
-  };
-
-  std::vector<CFG::Node *> workList;
-  std::unordered_set<ir::Value> visited;
-
-  workList.push_back(from);
-  CFG result;
-  result.mEntryNode = result.getOrCreateNode(from->getLabel());
-  visited.insert(from->getLabel());
-
-  // for (auto pred : from->getPredecessors()) {
-  //   result.getOrCreateNode(pred->getLabel());
-  // }
-
-  auto createResultNode = [&](CFG::Node *node) {
-    auto newNode = result.getOrCreateNode(node->getLabel());
-    newNode->setTerminator(node->getTerminator());
-    return newNode;
-  };
-
-  while (!workList.empty()) {
-    auto item = workList.back();
-    workList.pop_back();
-
-    auto resultItem = createResultNode(item);
-    result.addPreorderNode(resultItem);
-
-    if (item != from) {
-      if (item->getLabel() == continueLabel) {
-        continue;
-      }
-      if (stopLabels.contains(item->getLabel())) {
-        if (domTree == nullptr) {
-          continue;
-        }
-
-        for (auto succ : item->getSuccessors()) {
-          if (!domTree->dominates(item->getLabel(), succ->getLabel())) {
-            continue;
-          }
-
-          auto resultSucc = createResultNode(succ);
-          resultItem->addEdge(resultSucc);
-
-          if (visited.insert(succ->getLabel()).second) {
-            workList.push_back(succ);
-          }
-        }
-
-        continue;
-      }
-    }
-
-    for (auto succ : item->getSuccessors()) {
-      auto resultSucc = createResultNode(succ);
-      resultItem->addEdge(resultSucc);
-
-      if (visited.insert(succ->getLabel()).second) {
-        workList.push_back(succ);
-      }
-    }
-  }
-
-  if (domTree != nullptr) {
-    return result;
-  }
-
-  for (auto exitLabel : stopLabels) {
-    if (exitLabel == nullptr) {
-      continue;
-    }
-
-    // collect internal branches from exitLabel. Need to collect all blocks
-    // first to be able discard edges to not exists in this CFG target blocks
-    if (auto from = result.getNode(exitLabel)) {
-      for (auto succ : getNode(exitLabel)->getSuccessors()) {
-        if (auto to = result.getNode(succ->getLabel())) {
-          from->addEdge(to);
-        }
-      }
-    }
-  }
-
-  return result;
-}
-
-void Construct::invalidateAll() {
-  Construct *root = this;
-  while (root->parent != nullptr) {
-    root = root->parent;
-  }
-
-  std::vector<Construct *> workList;
-  workList.push_back(root);
-
-  while (!workList.empty()) {
-    auto item = workList.back();
-    workList.pop_back();
-    item->analysis.invalidateAll();
-
-    for (auto &child : item->children) {
-      workList.push_back(&child);
-    }
-  }
-}
-
-void Construct::invalidate() {
-  invalidateAll();
-  // Construct *item = this;
-  // while (item != nullptr) {
-  //   item->analysis.invalidateAll();
-  //   item = item->parent;
-  // }
-}
-
-CFG shader::buildCFG(ir::Instruction firstInstruction,
-                     const std::unordered_set<ir::Value> &exitLabels,
+CFG shader::buildCFG(ir::Instruction firstInstruction, ir::Value exitLabel,
                      ir::Value continueLabel) {
   struct Item {
     CFG::Node *node;
@@ -426,14 +537,16 @@ CFG shader::buildCFG(ir::Instruction firstInstruction,
 
   std::unordered_set<CFG::Node *> visited;
 
-  bool force = true;
-
   auto addSuccessor = [&](Item &from, ir::Value toLabel) {
+    if (toLabel == continueLabel) {
+      return;
+    }
+
     auto to = result.getOrCreateNode(toLabel);
     from.node->addEdge(to);
 
-    if (!force && (exitLabels.contains(from.node->getLabel()) ||
-                   from.node->getLabel() == continueLabel)) {
+    if (from.node->getLabel() == exitLabel ||
+        from.node->getLabel() == continueLabel) {
       return;
     }
 
@@ -471,7 +584,6 @@ CFG shader::buildCFG(ir::Instruction firstInstruction,
         visited.insert(item.node);
       } else {
         item.iterator = nullptr;
-        force = false;
       }
 
       continue;
@@ -481,7 +593,8 @@ CFG shader::buildCFG(ir::Instruction firstInstruction,
       item.node->setTerminator(inst);
       item.iterator = nullptr;
 
-      walkSuccessors(inst, [&](ir::Value label) { addSuccessor(item, label); });
+      walkSuccessors(inst,
+                     [&](ir::Value label, int) { addSuccessor(item, label); });
       continue;
     }
 
@@ -492,22 +605,6 @@ CFG shader::buildCFG(ir::Instruction firstInstruction,
     }
   }
 
-  for (auto exitLabel : exitLabels) {
-    if (exitLabel == nullptr) {
-      continue;
-    }
-
-    // collect internal branches from exitLabel. Need to collect all blocks
-    // first to be able discard edges to not exists in this CFG target blocks
-    if (auto from = result.getNode(exitLabel)) {
-      walkSuccessors(from->getTerminator(), [&](ir::Value toLabel) {
-        if (auto to = result.getNode(toLabel)) {
-          from->addEdge(to);
-        }
-      });
-    }
-  }
-
   return result;
 }
 
@@ -930,13 +1027,6 @@ MemorySSA MemorySSABuilder::build(CFG &cfg, auto &&handleInst) {
     }
   }
 
-  // auto domTree = graph::DomTreeBuilder<ir::memssa::Scope>{}.build(
-  //     entryScope, [&](ir::memssa::Scope scope, const auto &cb) {
-  //       for (auto succ : scope.getSuccessors()) {
-  //         cb(succ);
-  //       }
-  //     });
-
   for (auto scope : ir::range<ir::memssa::Scope>(entryScope)) {
     for (auto use : scope.children<ir::memssa::Use>()) {
       auto &user = memSSA.userDefs[use.getLinkedInst()];
@@ -1220,56 +1310,3 @@ shader::findNearestCommonDominator(ir::Instruction a, ir::Instruction b,
   return domTree.findNearestCommonDominator(a.staticCast<ir::Value>(),
                                             b.staticCast<ir::Value>());
 }
-
-BackEdgeStorage::BackEdgeStorage(CFG &cfg) {
-  struct Entry {
-    ir::Value bb;
-    CFG::Node::Iterator successorsIt;
-    CFG::Node::Iterator successorsEnd;
-  };
-
-  std::vector<Entry> workList;
-  std::unordered_set<ir::Value> inWorkList;
-  // std::unordered_set<ir::Value> viewed;
-  workList.reserve(cfg.getPostorderNodes().size());
-  inWorkList.reserve(cfg.getPostorderNodes().size());
-
-  auto addToWorkList = [&](CFG::Node *node) {
-    if (inWorkList.insert(node->getLabel()).second) {
-      workList.push_back({
-          .bb = node->getLabel(),
-          .successorsIt = node->getSuccessors().begin(),
-          .successorsEnd = node->getSuccessors().end(),
-      });
-      return true;
-    }
-
-    return false;
-  };
-
-  addToWorkList(cfg.getEntryNode());
-
-  while (!workList.empty()) {
-    auto &entry = workList.back();
-
-    if (entry.successorsIt == entry.successorsEnd) {
-      // viewed.insert(inWorkList.extract(entry.bb));
-      workList.pop_back();
-      continue;
-    }
-
-    auto label = entry.bb;
-    auto it = entry.successorsIt;
-    ++entry.successorsIt;
-
-    auto successor = *it;
-
-    // if (viewed.contains(successor->getLabel())) {
-    //   continue;
-    // }
-
-    if (!addToWorkList(successor)) {
-      backEdges[successor->getLabel()].insert(label);
-    }
-  }
-}
\ No newline at end of file
diff --git a/rpcsx/gpu/lib/gcn-shader/src/gcn.cpp b/rpcsx/gpu/lib/gcn-shader/src/gcn.cpp
index c07bd5f79..67b939723 100644
--- a/rpcsx/gpu/lib/gcn-shader/src/gcn.cpp
+++ b/rpcsx/gpu/lib/gcn-shader/src/gcn.cpp
@@ -1902,7 +1902,6 @@ gcn::deserialize(gcn::Context &context, const gcn::Environment &environment,
 
   std::print("\n\n{}\n\n", buildCFG(context.entryPoint).genTest());
 
-  structurizeCfg(context, context.body,
-                 context.epilogue.getFirst().cast<ir::Value>());
+  structurizeCfg(context, context.body);
   return context.body;
 }
diff --git a/rpcsx/gpu/lib/gcn-shader/src/spv.cpp b/rpcsx/gpu/lib/gcn-shader/src/spv.cpp
index 0ecbdac6a..9b64b9e93 100644
--- a/rpcsx/gpu/lib/gcn-shader/src/spv.cpp
+++ b/rpcsx/gpu/lib/gcn-shader/src/spv.cpp
@@ -7,7 +7,7 @@
 using namespace shader;
 
 static std::uint32_t generateSpv(std::vector<std::uint32_t> &result,
-                                 shader::ir::Region body) {
+                                 shader::ir::RegionLike body) {
   std::map<shader::ir::Value, std::uint32_t> valueToId;
   std::uint32_t bounds = 1;
 
@@ -63,7 +63,7 @@ static std::uint32_t generateSpv(std::vector<std::uint32_t> &result,
       addWord(getValueId(value));
     }
 
-    for (auto operand : operands) {
+    for (auto &operand : operands) {
       if (auto value = operand.getAsValue()) {
         addWord(getValueId(value));
         continue;
@@ -126,7 +126,7 @@ shader::spv::deserialize(ir::Context &context,
   return {};
 }
 
-std::vector<std::uint32_t> shader::spv::serialize(ir::Region body) {
+std::vector<std::uint32_t> shader::spv::serialize(ir::RegionLike body) {
   std::vector<std::uint32_t> result;
   result.resize(5);
   result[0] = 0x07230203;
@@ -170,6 +170,7 @@ std::string shader::spv::disassembly(std::span<const std::uint32_t> spv,
   std::string result;
   if (text != nullptr) {
     result = std::string(text->str, text->length);
+    spvTextDestroy(text);
   }
 
   spvDiagnosticDestroy(diagnostic);
diff --git a/rpcsx/gpu/lib/gcn-shader/src/transform.cpp b/rpcsx/gpu/lib/gcn-shader/src/transform.cpp
index 4d0908f61..7b8035ee9 100644
--- a/rpcsx/gpu/lib/gcn-shader/src/transform.cpp
+++ b/rpcsx/gpu/lib/gcn-shader/src/transform.cpp
@@ -2,335 +2,291 @@
 #include "SpvConverter.hpp"
 #include "analyze.hpp"
 #include "dialect.hpp"
+#include <algorithm>
+#include <functional>
+#include <iostream>
 #include <rx/die.hpp>
+#include <unordered_map>
 #include <unordered_set>
+#include <vector>
 
 using namespace shader;
 
 using Builder = ir::Builder<ir::builtin::Builder, ir::spv::Builder>;
 
-struct InstCloner : ir::CloneMap {
-  ir::Node getOrClone(ir::Context &context, ir::Node node,
-                      bool isOperand) override {
-    if (isOperand) {
-      return node;
-    }
+static bool isConstruct(ir::Instruction block) {
+  return block == ir::builtin::LOOP_CONSTRUCT ||
+         block == ir::builtin::SELECTION_CONSTRUCT ||
+         block == ir::builtin::CONTINUE_CONSTRUCT;
+}
 
-    return ir::CloneMap::getOrClone(context, node, isOperand);
+static ir::Block getConstructOf(ir::Instruction inst) {
+  auto block = inst.cast<ir::Block>();
+  if (block && isConstruct(block)) {
+    block = block.getParent().cast<ir::Block>();
   }
 
-  template <typename T> T get(T object) {
-    if (auto result = getOverride(object)) {
-      return result.template staticCast<T>();
+  while (block) {
+    if (isConstruct(block)) {
+      return block;
     }
 
-    return object;
+    block = block.getParent().cast<ir::Block>();
   }
-};
+
+  return {};
+}
+
+static ir::Instruction skipPhis(ir::Instruction inst) {
+  while (inst && inst == ir::spv::OpPhi) {
+    inst = inst.getNext();
+  }
+
+  return inst;
+}
+
+static ir::Block getConstructMergeBlock(ir::Block block) {
+  if (auto construct = block.cast<ir::Construct>()) {
+    return construct.getMerge();
+  }
+
+  return {};
+}
+
+/**
+ * Tarjan's algorithm for finding strongly connected components (SCCs).
+ * This finds all cycles in the CFG
+ */
+static std::vector<std::unordered_set<ir::Block>>
+findSCCs(ir::Range<ir::Block> nodes) {
+  std::unordered_map<ir::Block, std::size_t> indices;
+  std::unordered_map<ir::Block, std::size_t> lowlinks;
+  std::unordered_set<ir::Block> onStack;
+  std::vector<ir::Block> stack;
+  std::vector<std::unordered_set<ir::Block>> sccs;
+  std::size_t index = 0;
+
+  auto rootParent = (*nodes.begin()).getParent();
+
+  std::function<void(ir::Block)> strongConnect = [&](ir::Block node) {
+    indices[node] = index;
+    lowlinks[node] = index;
+    index++;
+    stack.push_back(node);
+    onStack.insert(node);
+
+    // Consider successors of node
+    for (auto successor : getSuccessors(node)) {
+      if (successor.getParent() != rootParent) {
+        continue;
+      }
+
+      if (!indices.contains(successor)) {
+        // Successor has not yet been visited; recurse on it
+        strongConnect(successor);
+        lowlinks[node] = std::min(lowlinks[node], lowlinks[successor]);
+      } else if (onStack.contains(successor)) {
+        // Successor is in stack and hence in the current SCC
+        lowlinks[node] = std::min(lowlinks[node], indices[successor]);
+      }
+    }
+
+    // If node is a root node, pop the stack and create an SCC
+    if (lowlinks[node] == indices[node]) {
+      std::unordered_set<ir::Block> scc;
+      scc.reserve(stack.size());
+      ir::Block w;
+      do {
+        w = stack.back();
+        stack.pop_back();
+        onStack.erase(w);
+        scc.insert(w);
+      } while (w != node);
+
+      // keep cycles only
+      if (!scc.empty()) {
+        auto isLoop = scc.size() > 1;
+
+        if (!isLoop) {
+          // single node can contain branch to self
+          isLoop = hasSuccessor(w, w);
+        }
+
+        if (isLoop) {
+          sccs.push_back(std::move(scc));
+        }
+      }
+    }
+  };
+
+  for (auto node : nodes) {
+    if (node.getParent() != rootParent) {
+      continue;
+    }
+
+    if (!indices.contains(node)) {
+      strongConnect(node);
+    }
+  }
+  return sccs;
+}
+
+static void replaceTerminatorTarget(ir::Instruction terminator,
+                                    int operandIndex, ir::Value newTarget) {
+  auto prevTarget = terminator.getOperand(operandIndex).getAsValue();
+  terminator.replaceOperand(operandIndex, newTarget);
+  auto selection = terminator.getPrev();
+
+  if (selection == ir::spv::OpSelectionMerge ||
+      selection == ir::spv::OpLoopMerge) {
+    for (std::size_t i = 0, end = selection.getOperandCount(); i < end; ++i) {
+      if (selection.getOperand(i) == prevTarget) {
+        selection.replaceOperand(i, newTarget);
+        break;
+      }
+    }
+  }
+}
 
 static bool replaceTerminatorTarget(ir::Instruction terminator,
                                     ir::Value oldTarget, ir::Value newTarget) {
   bool changes = false;
   for (std::size_t i = 0, end = terminator.getOperandCount(); i < end; ++i) {
     if (terminator.getOperand(i) == oldTarget) {
-      terminator.replaceOperand(i, newTarget);
+      replaceTerminatorTarget(terminator, i, newTarget);
       changes = true;
     }
   }
 
-  if (!changes) {
-    return false;
-  }
-
-  auto selection = terminator.getPrev();
-
-  if (selection == ir::spv::OpSelectionMerge ||
-      selection == ir::spv::OpLoopMerge) {
-    for (std::size_t i = 0, end = selection.getOperandCount(); i < end; ++i) {
-      if (selection.getOperand(i) == oldTarget) {
-        selection.replaceOperand(i, newTarget);
-      }
-    }
-  }
-
-  return true;
+  return changes;
 }
 
-static void
-cloneBlockRange(spv::Context &context, Construct &construct,
-                CFG::Node *startNode, std::unordered_set<ir::Value> stopLabels,
-                const std::unordered_set<CFG::Node *> &keepPredecessors) {
-  std::unordered_set<CFG::Node *> visited;
-  std::vector<CFG::Node *> workList;
-  workList.push_back(startNode);
-  visited.insert(startNode);
+class Edge {
+  ir::Block mFromBlock;
+  int mToOperandIndex;
 
-  InstCloner cloner;
-  std::vector<ir::Value> clonedLabels;
+public:
+  Edge(ir::Block fromBlock, int toOperandIndex)
+      : mFromBlock(fromBlock), mToOperandIndex(toOperandIndex) {}
 
-  while (!workList.empty()) {
-    auto bb = workList.back();
-    workList.pop_back();
+  [[nodiscard]] ir::Block from() const { return mFromBlock; }
+  [[nodiscard]] ir::Block to() const {
+    return getTerminator(mFromBlock)
+        .getOperand(mToOperandIndex)
+        .getAsValue()
+        .staticCast<ir::Block>();
+  }
 
-    if (!bb->hasTerminator()) {
-      continue;
+  [[nodiscard]] int operandIndex() const { return mToOperandIndex; }
+
+  void replaceSuccessor(ir::Value newSuccessor) {
+    replaceTerminatorTarget(getTerminator(mFromBlock), mToOperandIndex,
+                            newSuccessor);
+  }
+
+  bool operator==(const Edge &) const = default;
+};
+
+inline Edge createEdge(ir::Block from, ir::Block to) {
+  for (int index = 0; auto &op : from.getLast().getOperands()) {
+
+    if (op.getAsValue() == to) {
+      return {from, index};
     }
+    index++;
+  }
 
-    auto region = bb->getLabel().getParent();
+  rx::die("attempt to create invalid edge");
+}
 
-    for (auto inst : bb->rangeWithoutTerminator()) {
-      auto clonedInst = ir::clone(inst, context, cloner);
-      region.addChild(clonedInst);
+struct CycleEdges {
+  std::vector<Edge> entryEdges;
+  std::vector<Edge> backEdges;
+  std::vector<Edge> exitEdges;
+};
 
-      if (inst == ir::spv::OpLabel) {
-        clonedLabels.push_back(inst.staticCast<ir::Value>());
-        context.ns.setNameOf(clonedInst, "clone_" + context.ns.getNameOf(inst));
-      }
-    }
+static CycleEdges
+calculateCycleEdges(const std::unordered_set<ir::Block> &cycles) {
+  CycleEdges result;
+  std::unordered_set<ir::Block> entryBlocks;
 
-    auto terminator = ir::clone(bb->getTerminator(), context, cloner);
-
-    if (terminator != nullptr) {
-      region.addChild(terminator);
-
-      for (std::size_t i = 0, end = terminator.getOperandCount(); i < end;
-           ++i) {
-        auto target = terminator.getOperand(i).getAsValue();
-        if (target != ir::spv::OpLabel || stopLabels.contains(target)) {
-          continue;
-        }
-
-        terminator.replaceOperand(i, ir::clone(target, context, cloner));
-      }
-
-      auto selection = terminator.getPrev();
-
-      if (selection == ir::spv::OpSelectionMerge ||
-          selection == ir::spv::OpLoopMerge) {
-        for (std::size_t i = 0, end = selection.getOperandCount(); i < end;
-             ++i) {
-          auto target = selection.getOperand(i).getAsValue();
-          if (target != ir::spv::OpLabel || stopLabels.contains(target)) {
-            continue;
-          }
-
-          selection.replaceOperand(i, ir::clone(target, context, cloner));
-        }
-      }
-    }
-
-    for (auto succ : bb->getSuccessors()) {
-      if (stopLabels.contains(succ->getLabel())) {
+  for (auto block : cycles) {
+    for (auto [pred, operandIndex] : getAllPredecessors(block)) {
+      if (cycles.contains(pred)) {
         continue;
       }
 
-      if (visited.insert(succ).second) {
-        workList.push_back(succ);
-      }
+      result.entryEdges.emplace_back(pred, operandIndex);
+    }
+
+    for (auto [succ, operandIndex] : getAllSuccessors(block)) {
+      if (cycles.contains(succ))
+        continue;
+
+      entryBlocks.insert(succ);
+      result.exitEdges.emplace_back(block, operandIndex);
     }
   }
 
-  for (auto label : clonedLabels) {
-    for (auto inst : ir::range(label.getNext())) {
-      if (inst != ir::spv::OpPhi) {
-        break;
-      }
+  for (auto block : cycles) {
+    for (auto [succ, operandIndex] : getAllSuccessors(block)) {
+      if (entryBlocks.contains(succ))
+        continue;
 
-      if (label == startNode->getLabel()) {
-        auto clonedInst = ir::clone(inst, context, cloner);
-        auto newClonedPhi = Builder::createInsertBefore(context, clonedInst)
-                                .createSpvPhi(inst.getLocation(),
-                                              inst.getOperand(0).getAsValue());
-        clonedInst.staticCast<ir::Value>().replaceAllUsesWith(newClonedPhi);
-        clonedInst.remove();
-
-        for (std::size_t i = 1, end = inst.getOperandCount(); i < end; i += 2) {
-          auto target = inst.getOperand(i).getAsValue();
-          if (target != ir::spv::OpLabel) {
-            continue;
-          }
-
-          if (cloner.getOverride(target) == nullptr) {
-            continue;
-          }
-
-          bool hasPred = false;
-
-          for (auto pred : keepPredecessors) {
-            if (pred->getLabel() == target) {
-              hasPred = true;
-              break;
-            }
-          }
-
-          if (hasPred) {
-            newClonedPhi.addOperand(inst.eraseOperand(i));
-            newClonedPhi.addOperand(inst.eraseOperand(i));
-          } else {
-            inst.replaceOperand(i, ir::clone(target, context, cloner));
-          }
-        }
-      } else {
-        for (std::size_t i = 2, end = inst.getOperandCount(); i < end; i += 2) {
-          auto target = inst.getOperand(i).getAsValue();
-          if (target != ir::spv::OpLabel || stopLabels.contains(target)) {
-            continue;
-          }
-
-          inst.replaceOperand(i, ir::clone(target, context, cloner));
-        }
-      }
-
-      break;
+      result.backEdges.emplace_back(block, operandIndex);
     }
   }
 
-  auto clonedStartLabel = cloner.get(startNode->getLabel());
-  auto backEdges = construct.getBackEdges(startNode->getLabel());
-  for (auto pred : keepPredecessors) {
-    if (backEdges && backEdges->contains(pred->getLabel())) {
-      continue;
-    }
-
-    replaceTerminatorTarget(pred->getTerminator(), startNode->getLabel(),
-                            clonedStartLabel);
-  }
+  return result;
 }
 
-static ir::Instruction findTerminator(ir::Instruction label) {
-  while (!isTerminator(label)) {
-    label = label.getNext();
-  }
+static ir::Block createMergeBlock(spv::Context &context,
+                                  ir::InsertionPoint insertPoint,
+                                  const std::unordered_set<ir::Block> &preds,
+                                  ir::Block to) {
+  rx::dieIf(preds.empty(), "createMergeBlock: unexpected edges count");
 
-  return label;
-}
+  auto loc = to.getLocation();
 
-static ir::Value createMergeBlock(
-    spv::Context &context, CFG::Node *originalNode,
-    const std::unordered_multimap<CFG::Node *, CFG::Node *> &edges) {
-  auto loc = originalNode->getLabel().getLocation();
-  auto mergeBlockBuilder =
-      Builder::createInsertAfter(context, originalNode->getTerminator());
-  auto mergeLabel = mergeBlockBuilder.createSpvLabel(loc);
-  auto region = mergeLabel.getParent();
+  auto mergeBlock = Builder::create(context, insertPoint).createBlock(loc);
+  Builder::createAppend(context, mergeBlock).createSpvBranch(loc, to);
 
-  rx::dieIf(edges.empty(), "createMergeBlock: unexpected edges count");
-  if (edges.size() == 1) {
-    auto [from, to] = *edges.begin();
-    mergeBlockBuilder.createSpvBranch(loc, to->getLabel());
-
-    replaceTerminatorTarget(from->getTerminator(), to->getLabel(), mergeLabel);
-  } else if (edges.size() == 2) {
-    auto blockMergePhi =
-        mergeBlockBuilder.createSpvPhi(loc, context.getTypeBool());
-
-    auto firstEdgeIt = edges.begin();
-    auto secondEdgeIt = std::next(firstEdgeIt);
-
-    mergeBlockBuilder.createSpvBranchConditional(
-        loc, blockMergePhi, secondEdgeIt->second->getLabel(),
-        firstEdgeIt->second->getLabel());
-
-    for (std::uint32_t index = 0; auto [from, to] : edges) {
-      auto terminator = from->getTerminator();
-
-      auto terminateBlockBuilder = Builder::createAppend(context, region);
-      auto terminateBlock = terminateBlockBuilder.createSpvLabel(loc);
-      terminateBlockBuilder.createSpvBranch(loc, mergeLabel);
-      blockMergePhi.addOperand(context.getBool(index++ > 0));
-      blockMergePhi.addOperand(terminateBlock);
-
-      replaceTerminatorTarget(terminator, to->getLabel(), terminateBlock);
-    }
-  } else {
-    auto blockMergePhi =
-        mergeBlockBuilder.createSpvPhi(loc, context.getTypeUInt32());
-
-    auto blockMergeSwitch = mergeBlockBuilder.createSpvSwitch(
-        loc, blockMergePhi, edges.begin()->second->getLabel());
-
-    for (std::uint32_t index = 0; auto [from, to] : edges) {
-      auto terminator = from->getTerminator();
-
-      auto terminateBlockBuilder = Builder::createAppend(context, region);
-      auto terminateBlock = terminateBlockBuilder.createSpvLabel(loc);
-      terminateBlockBuilder.createSpvBranch(loc, mergeLabel);
-
-      auto blockId = context.imm32(index);
-      if (index != 0) {
-        blockMergeSwitch.addOperand(blockId);
-        blockMergeSwitch.addOperand(to->getLabel());
-      }
-
-      ++index;
-
-      blockMergePhi.addOperand(blockId);
-      blockMergePhi.addOperand(terminateBlock);
-
-      replaceTerminatorTarget(terminator, to->getLabel(), terminateBlock);
-    }
-  }
-
-  return mergeLabel;
-}
-
-static std::pair<ir::Value, ir::Instruction>
-createTrampolineBlock(spv::Context &context,
-                      const std::unordered_set<CFG::Node *> &preds,
-                      CFG::Node *to) {
-
-  rx::dieIf(preds.empty(), "createTrampolineBlock: unexpected edges count");
-
-  auto loc = to->getLabel().getLocation();
-
-  auto trampolineBuilder = Builder::createInsertBefore(context, to->getLabel());
-  auto trampolineLabel = trampolineBuilder.createSpvLabel(loc);
-  auto terminator = trampolineBuilder.createSpvBranch(loc, to->getLabel());
-
-  if (preds.size() == to->getPredecessorCount()) {
-    for (auto phi : ir::range(to->getLabel().getNext())) {
+  if (preds.size() == getPredecessorCount(to)) {
+    for (auto phi : ir::range(to.getFirst())) {
       if (phi != ir::spv::OpPhi) {
         break;
       }
 
       phi.erase();
-      trampolineLabel.getParent().insertAfter(trampolineLabel, phi);
+      mergeBlock.prependChild(phi);
     }
   } else if (preds.size() == 1) {
-    for (auto phi : ir::range(to->getLabel().getNext())) {
+    auto pred = *preds.begin();
+    for (auto phi : ir::range(to.getFirst())) {
       if (phi != ir::spv::OpPhi) {
         break;
       }
 
       for (std::size_t i = 2; i < phi.getOperandCount(); i += 2) {
-        if (phi.getOperand(i) == to->getLabel()) {
-          phi.replaceOperand(i, trampolineLabel);
+        if (phi.getOperand(i) == pred) {
+          phi.replaceOperand(i, mergeBlock);
         }
       }
     }
   } else {
-    for (auto phi : ir::range(to->getLabel().getNext())) {
+    for (auto phi : ir::range(to.getFirst())) {
       if (phi != ir::spv::OpPhi) {
         break;
       }
 
       auto newPhi =
-          Builder::createInsertAfter(context, trampolineLabel)
+          Builder::createPrepend(context, mergeBlock)
               .createSpvPhi(phi.getLocation(), phi.getOperand(0).getAsValue());
 
       for (std::size_t i = 1; i < phi.getOperandCount();) {
-        auto value = phi.getOperand(i).getAsValue();
-        auto label = phi.getOperand(i + 1).getAsValue();
-
-        bool hasPred = false;
-        for (auto pred : preds) {
-          if (pred->getLabel() == label) {
-            hasPred = true;
-            break;
-          }
-        }
-
-        if (hasPred) {
+        // auto value = phi.getOperand(i).getAsValue();
+        auto label = phi.getOperand(i + 1).getAsValue().staticCast<ir::Block>();
+        if (preds.contains(label)) {
           newPhi.addOperand(phi.eraseOperand(i));
           newPhi.addOperand(phi.eraseOperand(i));
         } else {
@@ -339,520 +295,1157 @@ createTrampolineBlock(spv::Context &context,
       }
 
       phi.addOperand(newPhi);
-      phi.addOperand(trampolineLabel);
+      phi.addOperand(mergeBlock);
     }
   }
 
   for (auto pred : preds) {
-    replaceTerminatorTarget(pred->getTerminator(), to->getLabel(),
-                            trampolineLabel);
+    replaceTerminatorTarget(getTerminator(pred), to, mergeBlock);
   }
 
-  return {trampolineLabel, terminator};
+  return mergeBlock;
 }
 
-static ir::Value createEntryBlock(
-    spv::Context &context, CFG::Node *originalHeadNode,
-    const std::unordered_map<CFG::Node *, std::unordered_set<CFG::Node *>>
-        &edges) {
+static ir::Block createRouteBlock(spv::Context &context,
+                                  ir::InsertionPoint insertPoint,
+                                  const std::vector<Edge> &edges) {
+  auto loc = context.getUnknownLocation();
 
-  auto loc = originalHeadNode->getLabel().getLocation();
-  auto entryBuilder =
-      Builder::createInsertBefore(context, originalHeadNode->getLabel());
-  auto entryLabel = entryBuilder.createSpvLabel(loc);
-  context.ns.setUniqueNameOf(entryLabel, "head");
-  auto region = originalHeadNode->getLabel().getParent();
+  rx::dieIf(edges.empty(), "createRouteBlock: unexpected edges count");
 
-  rx::dieIf(edges.empty(), "createEntryBlock: unexpected edges count");
+  std::unordered_map<ir::Block, std::unordered_set<unsigned>> fromSucc;
+  std::unordered_map<ir::Block, std::unordered_set<ir::Block>> toPreds;
+  std::unordered_map<ir::Block, std::unordered_set<ir::Block>> toAllPreds;
+  std::unordered_set<ir::Block> patchPredecessors;
 
-  ir::Value selectorPhi;
-  ir::Value defaultPhiValue;
-
-  if (edges.size() == 1) {
-    selectorPhi = entryBuilder.createSpvPhi(loc, context.getTypeBool());
-    defaultPhiValue = context.getFalse();
-    auto &[to, fromList] = *edges.begin();
-
-    auto [trampoline, terminator] =
-        createTrampolineBlock(context, fromList, to);
-
-    entryBuilder.createSpvBranchConditional(loc, selectorPhi, to->getLabel(),
-                                            originalHeadNode->getLabel());
-    replaceTerminatorTarget(terminator, to->getLabel(), entryLabel);
-    selectorPhi.addOperand(context.getTrue());
-    selectorPhi.addOperand(trampoline);
-  } else {
-    selectorPhi = entryBuilder.createSpvPhi(loc, context.getTypeUInt32());
-    defaultPhiValue = context.imm32(0);
-    auto selectorSwitch = entryBuilder.createSpvSwitch(
-        loc, selectorPhi, originalHeadNode->getLabel());
-
-    for (std::uint32_t index = 1; auto [to, fromList] : edges) {
-      selectorSwitch.addOperand(index);
-      selectorSwitch.addOperand(to->getLabel());
-      auto [trampoline, terminator] =
-          createTrampolineBlock(context, fromList, to);
-      replaceTerminatorTarget(terminator, to->getLabel(), entryLabel);
-      selectorPhi.addOperand(context.imm32(index));
-      selectorPhi.addOperand(trampoline);
-
-      ++index;
-    }
-  }
-
-  for (auto originalPred : originalHeadNode->getPredecessors()) {
-    if (replaceTerminatorTarget(originalPred->getTerminator(),
-                                originalHeadNode->getLabel(), entryLabel)) {
-      selectorPhi.addOperand(defaultPhiValue);
-      selectorPhi.addOperand(originalPred->getLabel());
-    }
-  }
-
-  return entryLabel;
-}
-
-static std::pair<Construct *, bool>
-structurizeConstruct(spv::Context &context, Construct &parentConstruct,
-                     ir::Value entry) {
-  ir::Value mergeLabel;
-  auto &parentCfg = parentConstruct.getCfg();
-
-  bool isLoop = false;
-  ir::Instruction entryTerminator;
   {
+    std::unordered_set<ir::Block> routePredecessors;
 
-    auto entryNode = parentCfg.getNode(entry);
-    entryTerminator = entryNode->getTerminator();
-
-    auto queryConstruct =
-        parentConstruct.createTemporaryChild(entry, parentConstruct.merge);
-    queryConstruct.loopContinue = parentConstruct.loopContinue;
-    auto &postDomTree = queryConstruct.getPostDomTree();
-
-    for (auto succ : entryNode->getSuccessors()) {
-      if (mergeLabel == nullptr) {
-        mergeLabel = succ->getLabel();
-      } else {
-        if (mergeLabel == succ->getLabel()) {
-          continue;
-        }
-        mergeLabel = postDomTree.findNearestCommonDominator(mergeLabel,
-                                                            succ->getLabel());
+    for (auto edge : edges) {
+      if (!routePredecessors.insert(edge.from()).second) {
+        patchPredecessors.insert(edge.from());
       }
+
+      toPreds[edge.to()].emplace(edge.from());
+      fromSucc[edge.from()].emplace(edge.operandIndex());
     }
 
-    if (auto backEdges = queryConstruct.getBackEdgesWithoutContinue(entry)) {
-      isLoop = entry != parentConstruct.loopContinue;
-
-      auto &domTree = queryConstruct.getDomTree();
-
-      for (auto backEdge : *backEdges) {
-        mergeLabel =
-            postDomTree.findNearestCommonDominator(mergeLabel, backEdge);
-
-        if (mergeLabel == parentConstruct.merge) {
-          break;
-        }
-
-        for (auto pred :
-             queryConstruct.getCfg().getNode(backEdge)->getPredecessors()) {
-          mergeLabel = postDomTree.findNearestCommonDominator(mergeLabel,
-                                                              pred->getLabel());
-        }
-
-        if (mergeLabel == parentConstruct.merge) {
-          break;
-        }
-      }
-    }
-
-    if (queryConstruct.merge != mergeLabel) {
-      queryConstruct.merge = mergeLabel;
-      queryConstruct.analysis.invalidateAll();
-    }
-
-    if (isLoop) {
-      isLoop = queryConstruct.getCfg().getNode(entry)->hasPredecessors();
-    }
-
-    while (mergeLabel != parentConstruct.merge) {
-      // if selected merge block has branches to construct nodes, it is invalid
-      // merge block, need to find another one
-      auto &cfg = queryConstruct.getCfg();
-      if (!cfg.getNode(mergeLabel)->hasSuccessors()) {
-        break;
-      }
-
-      auto &postDomTree = parentConstruct.getPostDomTree();
-      for (auto succ : parentCfg.getNode(mergeLabel)->getSuccessors()) {
-        mergeLabel = postDomTree.findNearestCommonDominator(succ->getLabel(),
-                                                            mergeLabel);
-        if (queryConstruct.merge != mergeLabel) {
-          queryConstruct.merge = mergeLabel;
-          queryConstruct.analysis.invalidateAll();
-        }
-
-        if (mergeLabel == parentConstruct.merge) {
-          break;
-        }
-      }
-    }
-
-    // pick latest available merge block
-    while (mergeLabel != parentConstruct.merge) {
-      auto mergeNode = parentConstruct.getCfg().getNode(mergeLabel);
-      if (mergeNode->getSuccessorCount() != 1) {
-        break;
-      }
-
-      auto nextMergeNode = *mergeNode->getSuccessors().begin();
-
-      if (nextMergeNode->getPredecessorCount() != 1) {
-        break;
-      }
-
-      auto nextLabel = nextMergeNode->getLabel();
-
-      if (nextLabel == mergeLabel || nextLabel == parentConstruct.merge) {
-        break;
-      }
-
-      mergeLabel = nextLabel;
+    for (auto &[to, preds] : toPreds) {
+      toAllPreds[to] = getPredecessors(to);
     }
   }
 
-  auto result = parentConstruct.createChild(entry, mergeLabel);
-  result->loopContinue = parentConstruct.loopContinue;
-
-  std::unordered_multimap<CFG::Node *, CFG::Node *> invalidExitEdges;
-  std::unordered_map<CFG::Node *, std::unordered_set<CFG::Node *>>
-      invalidEnterEdges;
-  std::unordered_map<ir::Value, std::unordered_set<ir::Value>> invalidEdges;
-  bool invalidMerge = result->merge == parentConstruct.merge;
-
-  auto &cfg = result->getCfg();
-  bool changes = false;
-
-  for (auto block : cfg.getPreorderNodes()) {
-    if (block == cfg.getEntryNode()) {
-      continue;
-    }
-
-    auto parentBlock = parentCfg.getNode(block->getLabel());
-
-    for (auto blockPred : parentBlock->getPredecessors()) {
-      if (cfg.getNode(blockPred->getLabel()) != nullptr) {
-        continue;
-      }
-
-      // it is branch to construct node from external block, need to fix it
-
-      if (block->getLabel() == mergeLabel) {
-        // only this construct can have branches to merge block
-        invalidMerge = true;
-        continue;
-      }
-
-      invalidEdges[block->getLabel()].emplace(blockPred->getLabel());
-      invalidEnterEdges[block].emplace(blockPred);
-      continue;
-    }
-
-    if (block->getLabel() == mergeLabel) {
-      continue;
-    }
-
-    for (auto succ : parentBlock->getSuccessors()) {
-      if (cfg.getNode(succ->getLabel()) == nullptr) {
-        // branch to block outside this construct, it should be done from
-        // merge block
-        invalidExitEdges.emplace(block, succ);
-      }
-    }
+  if (toPreds.size() == 1) {
+    auto &[to, preds] = *toPreds.begin();
+    return createMergeBlock(context, insertPoint, preds, to);
   }
 
-  for (auto &[edge, fromList] : invalidEnterEdges) {
-    for (auto pred : edge->getPredecessors()) {
-      fromList.insert(pred);
-    }
+  auto route = Builder::create(context, insertPoint).createBlock(loc);
+  ir::Value routePhi;
+
+  if (toPreds.size() > 1) {
+    routePhi =
+        Builder::createPrepend(context, route)
+            .createSpvPhi(loc, toPreds.size() == 2 ? context.getTypeBool()
+                                                   : context.getTypeUInt32());
   }
 
-  bool isInvalidLoopHeader =
-      isLoop && cfg.getEntryNode()->getTerminator() != ir::spv::OpBranch;
-  bool isInvalidLoopContinue = false;
+  std::unordered_map<ir::Value, std::uint32_t> successorToId;
 
-  if (isLoop) {
-    auto entryNode = cfg.getEntryNode();
-    if (entryNode->getPredecessorCount() > 1) {
-      isInvalidLoopContinue = true;
-    }
-    if (!isInvalidLoopContinue) {
-      auto predLabel = (*entryNode->getPredecessors().begin())->getLabel();
-      auto continueNode = parentCfg.getNode(predLabel);
+  if (toPreds.size() == 1) {
+    // single successor, create unconditional branch
+    Builder::createAppend(context, route)
+        .createSpvBranch(loc, toPreds.begin()->first);
+  } else if (toPreds.size() == 2) {
+    // 2 successors, create conditional branch
+    auto it = toPreds.begin();
+    auto firstSuccessor = it->first;
+    auto secondSuccessor = (++it)->first;
 
-      // continue block is not part of construct, it should contain only
-      // branch to header
-      isInvalidLoopContinue = continueNode->getSuccessorCount() > 1;
-    }
+    Builder::createAppend(context, route)
+        .createSpvBranchConditional(loc, routePhi, firstSuccessor,
+                                    secondSuccessor);
   } else {
-    if (entryTerminator == ir::spv::OpBranch) {
-      return {};
-    }
-  }
+    // > 2 successors, create switch
+    auto routeSwitch =
+        Builder::createAppend(context, route)
+            .createSpvSwitch(loc, routePhi, toPreds.begin()->first);
 
-  if (isLoop) {
-    if (!isInvalidLoopContinue) {
-      result->loopContinue =
-          (*cfg.getEntryNode()->getPredecessors().begin())->getLabel();
-    }
-    if (!isInvalidLoopHeader) {
-      result->loopBody =
-          (*cfg.getEntryNode()->getSuccessors().begin())->getLabel();
-    }
-  }
+    successorToId.reserve(toPreds.size());
 
-  if (isLoop) {
-    if (isInvalidLoopContinue) {
-      result->loopContinue =
-          createTrampolineBlock(context, cfg.getEntryNode()->getPredecessors(),
-                                parentCfg.getNode(result->header))
-              .first;
-      context.ns.setUniqueNameOf(result->loopContinue, "continue");
-      return {nullptr, true};
-    }
-
-    if (isInvalidLoopHeader) {
-      auto prevHeader = parentCfg.getNode(result->header);
-      result->header = createTrampolineBlock(
-                           context, prevHeader->getPredecessors(), prevHeader)
-                           .first;
-      return {nullptr, true};
-    }
-  }
-
-  if (!invalidEdges.empty()) {
-    auto &domTree = parentConstruct.getDomTree();
-    for (auto &[to, fromList] : invalidEdges) {
-      cloneBlockRange(context, *result, parentCfg.getNode(to),
-                      {result->merge, isLoop ? result->header : nullptr},
-                      cfg.getNode(to)->getPredecessors());
-    }
-
-    return {nullptr, true};
-  }
-
-  if (!invalidExitEdges.empty()) {
-    auto mergeNode = parentCfg.getNode(result->merge);
-    result->merge = createMergeBlock(context, mergeNode, invalidExitEdges);
-    return {nullptr, true};
-  }
-
-  if (invalidMerge) {
-    auto mergeNode = parentCfg.getNode(result->merge);
-    result->merge =
-        createTrampolineBlock(
-            context, cfg.getNode(result->merge)->getPredecessors(), mergeNode)
-            .first;
-    return {nullptr, true};
-  }
-
-  if (!isInvalidLoopHeader && !invalidEnterEdges.empty()) {
-    result->header = createEntryBlock(
-        context, parentCfg.getNode(result->header), invalidEnterEdges);
-    return {nullptr, true};
-  }
-
-  return {result, changes};
-}
-
-static bool structurizeCfgImpl(spv::Context &context, ir::RegionLike region,
-                               ir::Value exitLabel) {
-  bool changes = false;
-  std::unordered_map<ir::Value, Construct *> resultConstructs;
-  auto rootConstruct = Construct::createRoot(region, exitLabel);
-
-  struct Entry {
-    ir::Value header;
-    std::vector<ir::Value> successors;
-  };
-  std::vector<Entry> workList;
-
-  auto pushWorkList = [&](CFG::Node *node, ir::Value continueLabel = nullptr) {
-    auto &entry = workList.emplace_back(Entry{node->getLabel()});
-
-    for (auto succ : node->getSuccessors()) {
-      if (continueLabel != succ->getLabel()) {
-        entry.successors.push_back(succ->getLabel());
+    for (std::uint32_t id = 0; auto &[succ, pred] : toPreds) {
+      if (id) {
+        routeSwitch.addOperand(id);
+        routeSwitch.addOperand(succ);
       }
+
+      successorToId[succ] = id++;
     }
+  }
+
+  auto getSuccessorId = [&](ir::Block successor) {
+    if (toPreds.size() == 2) {
+      return context.getBool(successor == toPreds.begin()->first);
+    }
+
+    return context.imm32(successorToId.at(successor));
   };
 
-  std::unordered_set<ir::Value> visited;
-  std::unordered_set<ir::Value> seen;
-  auto entryNode = rootConstruct->getCfg().getEntryNode();
+  for (auto patchBlock : patchPredecessors) {
+    auto predSuccessors = getAllSuccessors(patchBlock);
+    auto terminator = getTerminator(patchBlock);
+    auto &routeSuccessors = fromSucc.at(patchBlock);
 
-  pushWorkList(entryNode);
-  resultConstructs[entryNode->getLabel()] = rootConstruct.get();
-  auto currentConstruct = rootConstruct.get();
+    int keepSuccessors = predSuccessors.size() - routeSuccessors.size();
 
-  while (!workList.empty()) {
-    auto &entry = workList.back();
-    if (entry.successors.empty()) {
-      if (currentConstruct->header == entry.header) {
-        currentConstruct = currentConstruct->parent;
-      }
+    assert(keepSuccessors >= 0);
+    assert(terminator == ir::spv::OpSwitch ||
+           terminator == ir::spv::OpBranchConditional);
 
-      workList.pop_back();
-      continue;
-    }
+    auto cond = terminator.getOperand(0).getAsValue();
+    auto condType = cond.getOperand(0).getAsValue();
+    std::map<ir::Operand, ir::Block> condValueToSucc;
+    ir::Block defaultSucc;
 
-    auto label = entry.successors.back();
-    entry.successors.pop_back();
-
-    if (label == currentConstruct->merge) {
-      continue;
-    }
-
-    if (!visited.insert(label).second) {
-      continue;
-    }
-
-    CFG::Node *bb = currentConstruct->getCfg().getNode(label);
-    ir::Value currentHeader = currentConstruct->header;
-
-    if (bb == nullptr) {
-      continue;
-    }
-
-    auto terminator = bb->getTerminator();
-    if (terminator == nullptr) {
-      continue;
-    }
-
-    auto selection = terminator.getPrev();
-
-    if (selection == ir::spv::OpLoopMerge ||
-        selection == ir::spv::OpSelectionMerge) {
-      auto parentContinue = currentConstruct->loopContinue;
-      currentConstruct = currentConstruct->createChild(
-          bb->getLabel(), selection.getOperand(0).getAsValue());
-      currentConstruct->loopContinue = parentContinue;
-
-      seen.insert(bb->getLabel());
-      seen.insert(selection.getOperand(0).getAsValue());
-
-      if (selection == ir::spv::OpLoopMerge) {
-        currentConstruct->loopContinue = selection.getOperand(1).getAsValue();
-
-        seen.insert(selection.getOperand(1).getAsValue());
-      }
-    } else {
-      selection = nullptr;
-    }
-
-    bool requiresSelection = false;
-
-    if (selection == nullptr && isBranch(terminator)) {
-      requiresSelection = true;
+    if (keepSuccessors == 0) {
+      // we are going to replace all successors of this block, create direct
+      // jump to route block
+      Builder::createInsertAfter(context, terminator)
+          .createSpvBranch(terminator.getLocation(), route);
 
       if (terminator == ir::spv::OpBranchConditional) {
-        if (seen.contains(terminator.getOperand(1).getAsValue()) &&
-            seen.contains(terminator.getOperand(2).getAsValue())) {
-          requiresSelection = false;
+        condValueToSucc[context.getTrue()] =
+            terminator.getOperand(1).getAsValue().staticCast<ir::Block>();
+        condValueToSucc[context.getFalse()] =
+            terminator.getOperand(2).getAsValue().staticCast<ir::Block>();
+      } else if (terminator == ir::spv::OpSwitch) {
+        defaultSucc =
+            terminator.getOperand(1).getAsValue().staticCast<ir::Block>();
+
+        for (int i = 2, end = terminator.getOperandCount(); i < end; i += 2) {
+          condValueToSucc[terminator.getOperand(i)] =
+              terminator.getOperand(i + 1).getAsValue().staticCast<ir::Block>();
         }
       }
-    }
-
-    if (requiresSelection) {
-      auto [newConstruct, cfgChanges] =
-          structurizeConstruct(context, *currentConstruct, label);
-      if (cfgChanges) {
-        return true;
+    } else if (terminator == ir::spv::OpSwitch) {
+      if (routeSuccessors.contains(1)) {
+        defaultSucc =
+            terminator.getOperand(1).getAsValue().staticCast<ir::Block>();
       }
 
-      if (newConstruct != nullptr) {
-        seen.insert(newConstruct->header);
-        seen.insert(newConstruct->merge);
+      bool shouldReplaceDefault = defaultSucc != nullptr;
 
-        if (newConstruct->loopContinue) {
-          seen.insert(newConstruct->loopContinue);
-        }
+      for (int i = 2, id = 2, end = terminator.getOperandCount(); i < end;
+           id += 2) {
+        if (routeSuccessors.contains(id + 1)) {
+          if (shouldReplaceDefault) {
+            auto value = terminator.eraseOperand(i);
+            auto successor = terminator.eraseOperand(i);
 
-        auto structuralBlock =
-            newConstruct->getCfg().getNode(newConstruct->header);
-        auto mergeNode =
-            currentConstruct->getCfg().getNode(newConstruct->merge);
+            condValueToSucc[value] =
+                successor.getAsValue().staticCast<ir::Block>();
 
-        if (newConstruct->loopContinue == nullptr) {
-          for (auto pred : mergeNode->getPredecessors()) {
-            pushWorkList(pred, newConstruct->loopContinue);
+            continue;
           }
-        } else {
-          pushWorkList(mergeNode, newConstruct->loopContinue);
+
+          condValueToSucc[terminator.getOperand(i)] =
+              terminator.getOperand(i + 1).getAsValue().staticCast<ir::Block>();
+
+          terminator.replaceOperand(i + 1, route);
         }
 
-        pushWorkList(structuralBlock);
-
-        if (auto [it, inserted] =
-                resultConstructs.emplace(newConstruct->header, nullptr);
-            inserted) {
-          it->second = newConstruct;
-        }
-
-        currentConstruct = newConstruct;
-        continue;
+        i += 2;
       }
-    }
 
-    pushWorkList(bb);
-  }
-
-  auto &cfg = rootConstruct->getCfg();
-  auto &domTree = rootConstruct->getDomTree();
-
-  if (currentConstruct != nullptr) {
-    rx::die("currentConstruct: %s-%s\n",
-            context.ns.getNameOf(currentConstruct->header).c_str(),
-            context.ns.getNameOf(currentConstruct->merge).c_str());
-  }
-
-  std::unordered_set<ir::Value> insertedLoops;
-  std::unordered_set<ir::Value> insertedMerges;
-
-  for (auto &[header, construct] : resultConstructs) {
-    if (construct->loopBody != nullptr) {
-      auto headerNode = cfg.getNode(construct->header);
-      auto terminator = headerNode->getTerminator();
-
-      Builder::createInsertBefore(context, terminator)
-          .createSpvLoopMerge(terminator.getLocation(), construct->merge,
-                              construct->loopContinue,
-                              ir::spv::LoopControl::None());
-      changes = true;
+      if (shouldReplaceDefault) {
+        terminator.replaceOperand(1, route);
+      }
     } else {
-      auto headerNode = cfg.getNode(construct->header);
-      auto terminator = headerNode->getTerminator();
+      if (routeSuccessors.contains(1)) {
+        condValueToSucc[context.getTrue()] =
+            terminator.getOperand(1).getAsValue().staticCast<ir::Block>();
+        terminator.replaceOperand(1, route);
+      } else {
+        assert(routeSuccessors.contains(2));
+        condValueToSucc[context.getFalse()] =
+            terminator.getOperand(2).getAsValue().staticCast<ir::Block>();
+        terminator.replaceOperand(2, route);
+      }
+    }
 
-      if (terminator == ir::spv::OpBranch ||
-          terminator.getPrev() == ir::spv::OpSelectionMerge) {
-        continue;
+    if (routePhi) {
+      auto boolType = context.getTypeBool();
+      auto builder = Builder::createInsertBefore(context, terminator);
+
+      ir::Value selector;
+
+      if (defaultSucc) {
+        selector = getSuccessorId(defaultSucc);
       }
 
-      if (!domTree.dominates(construct->header, construct->merge)) {
-        continue;
+      auto selectorType =
+          toPreds.size() == 2 ? boolType : context.getTypeUInt32();
+      for (auto &[value, to] : condValueToSucc) {
+        if (!selector) {
+          selector = getSuccessorId(to);
+        } else {
+          auto valueId = value.getAsValue();
+          if (!valueId) {
+            valueId = context.imm32(*value.getAsInt32());
+          }
+
+          ir::Value selectionCond;
+
+          if (condType == boolType) {
+            selectionCond = builder.createSpvLogicalEqual(
+                terminator.getLocation(), boolType, cond, valueId);
+          } else {
+            selectionCond = builder.createSpvIEqual(terminator.getLocation(),
+                                                    boolType, cond, valueId);
+          }
+          selector = builder.createSpvSelect(terminator.getLocation(),
+                                             selectorType, selectionCond,
+                                             getSuccessorId(to), selector);
+        }
       }
 
-      Builder::createInsertBefore(context, terminator)
-          .createSpvSelectionMerge(terminator.getLocation(), construct->merge,
-                                   ir::spv::SelectionControl::None);
-      changes = true;
+      routePhi.addOperand(selector);
+      routePhi.addOperand(patchBlock);
+    }
+
+    if (keepSuccessors == 0) {
+      terminator.remove();
     }
   }
-  return changes;
+
+  for (auto &[to, preds] : toPreds) {
+    if (toPreds.size() > 1) {
+      auto successorId = getSuccessorId(to);
+
+      for (auto from : preds) {
+        // branches already resolved
+        if (patchPredecessors.contains(from)) {
+          continue;
+        }
+
+        routePhi.addOperand(successorId);
+        routePhi.addOperand(from);
+      }
+    }
+
+    for (auto from : preds) {
+      if (patchPredecessors.contains(from)) {
+        continue;
+      }
+
+      replaceTerminatorTarget(getTerminator(from), to, route);
+    }
+
+    if (toAllPreds.at(to).size() == preds.size()) {
+      // all predecessors will be replaced, move phi nodes
+
+      for (auto phi : ir::range(ir::Block(to).getFirst())) {
+        if (phi != ir::spv::OpPhi) {
+          break;
+        }
+
+        phi.erase();
+        route.prependChild(phi);
+
+        if (preds.size() != edges.size()) {
+          // route block has additional edges. add dummy nodes to phi, this
+          // block not reachable from new predecessors anyway
+
+          auto undef = context.getUndef(phi.getOperand(0).getAsValue());
+
+          for (auto edge : edges) {
+            if (!preds.contains(edge.from())) {
+              phi.addOperand(undef);
+              phi.addOperand(edge.from());
+            }
+          }
+        }
+      }
+
+      continue;
+    }
+
+    if (preds.size() == 1) {
+      auto pred = *preds.begin();
+      for (auto phi : ir::range(ir::Block(to).getFirst())) {
+        if (phi != ir::spv::OpPhi) {
+          break;
+        }
+
+        for (std::size_t i = 2; i < phi.getOperandCount(); i += 2) {
+          auto label = phi.getOperand(i).getAsValue();
+
+          if (label == pred) {
+            phi.replaceOperand(i, route);
+          }
+        }
+      }
+
+      continue;
+    }
+
+    // partial predecessors replacement, update PHIs
+
+    for (auto phi : ir::range(ir::Block(to).getFirst())) {
+      if (phi != ir::spv::OpPhi) {
+        break;
+      }
+
+      auto newPhi =
+          Builder::createPrepend(context, route)
+              .createSpvPhi(phi.getLocation(), phi.getOperand(0).getAsValue());
+
+      for (std::size_t i = 1; i < phi.getOperandCount();) {
+        // auto value = phi.getOperand(i).getAsValue();
+        auto label = phi.getOperand(i + 1).getAsValue().cast<ir::Block>();
+
+        if (preds.contains(label)) {
+          newPhi.addOperand(phi.eraseOperand(i));
+          newPhi.addOperand(phi.eraseOperand(i));
+        } else {
+          i += 2;
+        }
+      }
+
+      phi.addOperand(newPhi);
+      phi.addOperand(route);
+
+      if (preds.size() != edges.size()) {
+        // merge block has additional edges. add dummy nodes to phi, this
+        // block not reachable from new blocks
+
+        auto dummyValue = phi.getOperand(1).getAsValue();
+
+        for (auto edge : edges) {
+          if (!preds.contains(edge.from())) {
+            phi.addOperand(dummyValue);
+            phi.addOperand(edge.from());
+          }
+        }
+      }
+    }
+  }
+
+  return route;
 }
 
-void shader::structurizeCfg(spv::Context &context, ir::RegionLike region,
-                            ir::Value exitLabel) {
-  while (structurizeCfgImpl(context, region, exitLabel)) {
+static ir::Value transformToCanonicalRegion(spv::Context &context,
+                                            ir::RegionLike region) {
+  auto cfg = buildCFG(region.getFirst());
+  std::vector<CFG::Node *> exitNodes;
+  for (auto node : cfg.getPreorderNodes()) {
+    if (!node->hasSuccessors()) {
+      exitNodes.push_back(node);
+    }
+  }
+
+  if (cfg.getEntryNode()->hasPredecessors()) {
+    auto builder = Builder::createPrepend(context, region);
+    auto prevEntry = cfg.getEntryLabel();
+    auto newEntry = builder.createSpvLabel(prevEntry.getLocation());
+    builder.createSpvBranch(prevEntry.getLocation(), prevEntry);
+
+    for (auto it = prevEntry.getNext(); it && it == ir::spv::OpVariable;) {
+      auto moveInst = it;
+      it = it.getNext();
+
+      moveInst.erase();
+      region.insertAfter(newEntry, moveInst);
+    }
+  }
+
+  if (exitNodes.empty()) {
+    region.print(std::cerr, context.ns);
+    rx::die("scfg: cfg without termination block");
+  }
+
+  if (exitNodes.size() == 1) {
+    return exitNodes.back()->getLabel();
+  }
+
+  ir::Value returnType;
+  ir::Instruction returnInst;
+
+  for (auto exitNode : exitNodes) {
+    auto terminator = exitNode->getTerminator();
+
+    if (terminator && terminator == ir::spv::OpReturnValue) {
+      auto terminatorReturnValue = terminator.getOperand(0).getAsValue();
+      auto terminatorReturnType =
+          terminatorReturnValue.getOperand(0).getAsValue();
+      if (returnType && terminatorReturnType == returnType) {
+        rx::die("scfg: unexpected terminator return type");
+      } else {
+        returnType = terminatorReturnType;
+      }
+    }
+
+    if (terminator) {
+      if (returnInst && returnInst.getInstId() != terminator.getInstId()) {
+        returnInst.print(std::cerr, context.ns);
+        std::cerr << '\n';
+        terminator.print(std::cerr, context.ns);
+        std::cerr << '\n';
+        rx::die("scfg: unexpected return instruction kind change");
+      } else {
+        returnInst = terminator;
+      }
+    }
+  }
+
+  if (returnType) {
+    auto variablePointerType =
+        context.getTypePointer(ir::spv::StorageClass::Function, returnType);
+
+    auto returnValueVariable =
+        Builder::createInsertAfter(context, region.getFirst())
+            .createSpvVariable(context.getUnknownLocation(),
+                               variablePointerType,
+                               ir::spv::StorageClass::Function);
+
+    auto newExitBlock = [&] {
+      auto loc = context.getUnknownLocation();
+      auto builder = Builder::createAppend(context, region);
+      auto newExitBlock = builder.createSpvLabel(loc);
+
+      auto mergedReturnValue =
+          builder.createSpvLoad(loc, returnType, returnValueVariable);
+      builder.createSpvReturnValue(loc, mergedReturnValue);
+      return newExitBlock;
+    }();
+
+    for (auto exitNode : exitNodes) {
+      auto terminator = exitNode->getTerminator();
+
+      if (terminator) {
+        auto newTerminator = Builder::createInsertAfter(context, terminator);
+
+        newTerminator.createSpvStore(terminator.getLocation(),
+                                     returnValueVariable,
+                                     terminator.getOperand(0).getAsValue());
+        newTerminator.createSpvBranch(terminator.getLocation(), newExitBlock);
+        terminator.erase();
+      }
+    }
+
+    return newExitBlock;
+  }
+
+  if (!returnInst) {
+    rx::die("scfg: unexpected cfg terminator");
+  }
+
+  auto newExitBlock = Builder::createAppend(context, region)
+                          .createSpvLabel(context.getUnknownLocation());
+
+  for (auto exitNode : exitNodes) {
+    auto terminator = exitNode->getTerminator();
+
+    if (terminator) {
+      auto newTerminator = Builder::createInsertAfter(context, terminator);
+      newTerminator.createSpvBranch(terminator.getLocation(), newExitBlock);
+      terminator.erase();
+    }
+  }
+
+  region.insertAfter(newExitBlock, returnInst);
+  return newExitBlock;
+}
+
+static void transformToCf(spv::Context &context, ir::RegionLike region) {
+  ir::Block currentBlock;
+
+  for (auto inst : region.children()) {
+    if (inst == ir::builtin::BLOCK) {
+      continue;
+    }
+
+    if (inst == ir::spv::OpLabel) {
+      currentBlock = Builder::createInsertBefore(context, inst)
+                         .createBlock(inst.getLocation());
+
+      if (auto name = context.ns.tryGetNameOf(inst); !name.empty()) {
+        context.ns.setNameOf(currentBlock, std::string(name));
+      }
+
+      inst.staticCast<ir::Value>().replaceAllUsesWith(currentBlock);
+      inst.remove();
+      continue;
+    }
+
+    if (!currentBlock) {
+      inst.print(std::cerr, context.ns);
+      std::cerr << "\n";
+      region.print(std::cerr, context.ns);
+      std::cerr << "\n";
+      rx::die("cfg: node without label");
+    }
+
+    inst.erase();
+    currentBlock.addChild(inst);
+
+    if (isTerminator(inst)) {
+      currentBlock = nullptr;
+    }
   }
 }
+
+static void transformToFlat(spv::Context &context, ir::RegionLike region) {
+  std::vector<ir::Instruction> workList;
+
+  workList.push_back(region.getFirst());
+
+  auto insertPoint = Builder::createPrepend(context, region);
+
+  while (!workList.empty()) {
+    auto inst = workList.back();
+
+    workList.pop_back();
+
+    if (inst == nullptr) {
+      continue;
+    }
+
+    auto unwrapBlock = [&](ir::Block block) {
+      if (auto construct = block.cast<ir::LoopConstruct>()) {
+        auto merge = construct.getMerge();
+        auto cont = construct.getContinue().getHeader();
+        auto body = construct.getHeader();
+
+        auto blockLabel = insertPoint.createSpvLabel(block.getLocation());
+        construct.replaceAllUsesWith(blockLabel);
+
+        if (auto name = context.ns.tryGetNameOf(block); !name.empty()) {
+          context.ns.setNameOf(blockLabel, std::string(name));
+        }
+
+        for (auto phi : ir::range(construct.getFirst())) {
+          if (phi != ir::spv::OpPhi) {
+            break;
+          }
+
+          insertPoint.eraseAndInsert(phi);
+        }
+
+        insertPoint.createSpvLoopMerge(construct.getLocation(), merge, cont,
+                                       ir::spv::LoopControl::None());
+        insertPoint.createSpvBranch(construct.getLocation(), body);
+
+        workList.emplace_back(cont);
+        workList.emplace_back(construct.getFirst());
+        return;
+      }
+
+      if (auto construct = block.cast<ir::SelectionConstruct>()) {
+        auto constructBody = construct.getHeader();
+
+        auto header = ir::InsertionPoint::createPrepend(constructBody);
+        auto merge = construct.getMerge();
+
+        for (auto phi : ir::range(construct.getFirst())) {
+          if (phi != ir::spv::OpPhi) {
+            break;
+          }
+
+          for (std::size_t i = 1; i < phi.getOperandCount();) {
+            if (phi.getOperand(i + 1) == construct) {
+              phi.eraseOperand(i);
+              phi.eraseOperand(i);
+            } else {
+              i += 2;
+            }
+          }
+
+          header.eraseAndInsert(phi);
+        }
+
+        Builder::createInsertBefore(context, constructBody.getLast())
+            .createSpvSelectionMerge(construct.getLocation(), merge,
+                                     ir::spv::SelectionControl::None);
+
+        construct.replaceAllUsesWith(constructBody);
+        workList.emplace_back(constructBody);
+        return;
+      }
+
+      auto blockLabel = insertPoint.createSpvLabel(block.getLocation());
+
+      block.replaceAllUsesWith(blockLabel);
+
+      workList.emplace_back(block.getFirst());
+
+      if (auto name = context.ns.tryGetNameOf(block); !name.empty()) {
+        context.ns.setNameOf(blockLabel, std::string(name));
+      }
+    };
+
+    if (auto next = inst.getNext()) {
+      workList.push_back(next);
+    }
+
+    if (auto block = inst.cast<ir::Block>()) {
+      std::cout << "processing " << context.ns.getNameOf(block) << "\n";
+      unwrapBlock(block);
+      block.erase();
+      continue;
+    }
+
+    insertPoint.eraseAndInsert(inst);
+  }
+}
+
+bool isParentConstruct(ir::RegionLike parent, ir::RegionLike construct) {
+  while (parent != construct && construct) {
+    construct = construct.getParent();
+  }
+
+  return parent == construct;
+}
+
+static ir::LoopConstruct
+createLoopConstruct(spv::Context &context, ir::RegionLike parentConstruct,
+                    ir::Block header, ir::Block latch, ir::Block cont,
+                    ir::Block merge,
+                    const std::unordered_set<shader::ir::Block> &scc) {
+  auto continueConstruct =
+      Builder::createInsertAfter(context, header)
+          .createContinueConstruct(header.getLocation(), cont, header);
+
+  auto loopConstruct = Builder::createInsertBefore(context, header)
+                           .createLoopConstruct(header.getLocation(), header,
+                                                merge, continueConstruct);
+
+  continueConstruct.erase();
+
+  header.erase();
+  loopConstruct.addChild(header);
+
+  std::vector<ir::Block> workList;
+  workList.emplace_back(header);
+
+  while (!workList.empty()) {
+    ir::Block block = workList.back();
+    workList.pop_back();
+
+    block.erase();
+    loopConstruct.addChild(block);
+
+    std::unordered_set<ir::Block> successors;
+    if (isConstruct(block)) {
+      successors = {getConstructMergeBlock(block)};
+    } else {
+      successors = getSuccessors(block);
+    }
+
+    for (auto succ : successors) {
+      if (succ == merge || succ.getParent() != parentConstruct ||
+          !scc.contains(succ)) {
+        continue;
+      }
+
+      workList.push_back(succ);
+    }
+  }
+
+  latch.erase();
+  loopConstruct.addChild(latch);
+
+  cont.erase();
+  continueConstruct.addChild(cont);
+
+  merge.erase();
+  loopConstruct.getParent().insertAfter(loopConstruct, merge);
+
+  return loopConstruct;
+}
+
+static ir::SelectionConstruct
+createSelectionConstruct(spv::Context &context, ir::RegionLike parentConstruct,
+                         const std::unordered_set<ir::Block> &components,
+                         ir::Block header, ir::Block merge) {
+  auto selectionConstruct =
+      Builder::createInsertBefore(context, header)
+          .createSelectionConstruct(header.getLocation(), header, merge);
+
+  std::vector<ir::Block> workList;
+  workList.emplace_back(header);
+
+  while (!workList.empty()) {
+    ir::Block block = workList.back();
+    workList.pop_back();
+
+    block.erase();
+    selectionConstruct.addChild(block);
+
+    std::unordered_set<ir::Block> successors;
+    if (auto construct = block.cast<ir::Construct>()) {
+      successors = {construct.getMerge()};
+    } else {
+      successors = getSuccessors(block);
+    }
+
+    for (auto succ : successors) {
+      if (succ == merge || succ.getParent() != parentConstruct ||
+          !components.contains(succ)) {
+        continue;
+      }
+
+      workList.push_back(succ);
+    }
+  }
+
+  merge.erase();
+  selectionConstruct.getParent().insertAfter(selectionConstruct, merge);
+
+  return selectionConstruct;
+}
+
+static void wrapLoopConstructs(spv::Context &context, ir::RegionLike root) {
+  auto region = root.children<ir::Block>();
+  auto sccs = findSCCs(region);
+
+  for (auto scc : sccs) {
+    auto edges = calculateCycleEdges(scc);
+
+    ir::Block bodyLabel;
+    ir::Block continueLabel;
+    ir::Block mergeLabel;
+    ir::Block latchLabel;
+
+    if (!edges.entryEdges.empty()) {
+      if (edges.entryEdges.size() == 1 && edges.backEdges.size() == 1 &&
+          edges.entryEdges[0].to() == edges.backEdges[0].to()) {
+        bodyLabel = edges.entryEdges[0].to();
+        continueLabel = edges.backEdges[0].from();
+      }
+
+      if (!bodyLabel) {
+        std::vector<Edge> entryEdges = edges.entryEdges;
+        // back edges should jump to entry block
+        entryEdges.insert(entryEdges.end(), edges.backEdges.begin(),
+                          edges.backEdges.end());
+
+        // for loop no need to split blocks, we can just rotate loop
+        bodyLabel = createRouteBlock(
+            context, ir::InsertionPoint::createInsertBefore(*scc.begin()),
+            entryEdges);
+        scc.insert(bodyLabel);
+        edges = calculateCycleEdges(scc);
+      }
+
+      if (!continueLabel || bodyLabel == continueLabel ||
+          getSuccessorCount(continueLabel) != 1) {
+
+        std::unordered_set<ir::Block> preds;
+        for (auto edge : edges.backEdges) {
+          preds.insert(edge.from());
+        }
+        continueLabel = createMergeBlock(
+            context, ir::InsertionPoint::createInsertAfter(bodyLabel), preds,
+            bodyLabel);
+        scc.insert(continueLabel);
+        edges = calculateCycleEdges(scc);
+      }
+    }
+
+    if (!edges.exitEdges.empty()) {
+      mergeLabel = [&] -> ir::Block {
+        auto exitEdges = std::span(edges.exitEdges);
+        auto header = exitEdges[0].to();
+        exitEdges = exitEdges.subspan(1);
+
+        while (!exitEdges.empty()) {
+          if (header != exitEdges[0].to()) {
+            return {};
+          }
+
+          exitEdges = exitEdges.subspan(1);
+        }
+
+        return header;
+      }();
+
+      if (mergeLabel) {
+        auto predecessors = getPredecessors(mergeLabel);
+
+        for (auto pred : predecessors) {
+          if (!scc.contains(pred)) {
+            mergeLabel = {};
+            break;
+          }
+        }
+
+        if (mergeLabel && predecessors.size() == 1) {
+          latchLabel = *predecessors.begin();
+
+          auto latchSuccessors = getSuccessors(latchLabel);
+
+          auto it = latchSuccessors.begin();
+          auto firstSuccessor = *it;
+          auto secondSuccessor = *++it;
+
+          if ((firstSuccessor != continueLabel &&
+               secondSuccessor != continueLabel)) {
+            latchLabel = {};
+            mergeLabel = {};
+          }
+
+          if (latchLabel && getPredecessorCount(continueLabel) != 1) {
+            latchLabel = {};
+          }
+        }
+      }
+
+      if (!mergeLabel) {
+        mergeLabel = createRouteBlock(
+            context,
+            ir::InsertionPoint::createInsertAfter(edges.exitEdges[0].from()),
+            edges.exitEdges);
+
+        edges = calculateCycleEdges(scc);
+      }
+
+      if (!latchLabel) {
+        std::vector<Edge> exitEdges = edges.exitEdges;
+
+        for (auto [pred, operandIndex] : getAllPredecessors(continueLabel)) {
+          exitEdges.emplace_back(pred, operandIndex);
+        }
+
+        latchLabel = createRouteBlock(
+            context,
+            ir::InsertionPoint::createInsertAfter(edges.exitEdges[0].from()),
+            exitEdges);
+        scc.insert(latchLabel);
+      }
+    }
+
+    if (bodyLabel && continueLabel && mergeLabel) {
+      auto loopConstruct = createLoopConstruct(
+          context, root, bodyLabel, latchLabel, continueLabel, mergeLabel, scc);
+
+      // replace references to body outside this construct with header (i.e.
+      // loop construct node)
+      bodyLabel.replaceUsesIf(loopConstruct, [=](ir::ValueUse use) {
+        return (isTerminator(use.user) ||
+                (use.user != loopConstruct && isConstruct(use.user))) &&
+               getConstructOf(use.user) != loopConstruct;
+      });
+
+      // move PHIs to construct
+      for (auto phi : ir::range(bodyLabel.getFirst())) {
+        if (phi != ir::spv::OpPhi) {
+          break;
+        }
+
+        phi.erase();
+        loopConstruct.prependChild(phi);
+      }
+    }
+  }
+}
+
+static void wrapSelectionConstructs(spv::Context &context,
+                                    ir::RegionLike root) {
+  std::vector<ir::Range<ir::Block>> workList;
+  workList.push_back(root.children<ir::Block>());
+  std::unordered_set<ir::Block> usedMergeBlocks;
+
+  while (!workList.empty()) {
+    auto region = workList.back();
+    workList.pop_back();
+
+    for (auto entryBlock : region) {
+      if (isConstruct(entryBlock)) {
+        if (entryBlock == ir::builtin::SELECTION_CONSTRUCT) {
+          if (auto body =
+                  skipPhis(entryBlock.getFirst()).getNext().cast<ir::Block>()) {
+            workList.emplace_back(ir::range(body));
+          }
+        } else if (auto body =
+                       skipPhis(entryBlock.getFirst()).cast<ir::Block>()) {
+          workList.emplace_back(ir::range(body));
+        }
+        continue;
+      }
+
+      auto terminator = entryBlock.getLast();
+      if (!terminator || !isTerminator(terminator) ||
+          (terminator != ir::spv::OpBranchConditional &&
+           terminator != ir::spv::OpSwitch)) {
+        continue;
+      }
+
+      ir::RegionLike parentConstruct = getConstructOf(entryBlock);
+
+      if (auto parentSelection =
+              parentConstruct.cast<ir::SelectionConstruct>()) {
+        if (parentSelection.getHeader() == entryBlock) {
+          continue;
+        }
+      }
+
+      auto successors = getSuccessors(entryBlock);
+
+      if (parentConstruct) {
+        if (parentConstruct.getLast() == entryBlock) {
+          // do not look at latch/continuation blocks
+          continue;
+        }
+      }
+
+      if (!parentConstruct) {
+        parentConstruct = root;
+      }
+
+      std::unordered_set<ir::Block> components;
+      components.insert(entryBlock);
+
+      auto addConstructComponent = [&](ir::Construct construct) {
+        components.insert(construct);
+
+        // add whole body of construct
+        for (auto child : construct.children<ir::Block>()) {
+          components.insert(child);
+        }
+
+        if (auto loop = construct.cast<ir::LoopConstruct>()) {
+          // it if is loop, add continue construct also
+          for (auto child : loop.getContinue().children<ir::Block>()) {
+            components.insert(child);
+          }
+        }
+
+        auto constructMerge = construct.getMerge();
+        if (parentConstruct != root &&
+            getSuccessorCount(construct.getMerge()) == 0) {
+          // we cannot take this merge block, it is exit from function block
+          // create trampoline node and replace merge block of this node
+
+          auto newMerge = createMergeBlock(
+              context, ir::InsertionPoint::createInsertBefore(constructMerge),
+              getPredecessors(constructMerge), constructMerge);
+
+          construct.setMerge(newMerge);
+          constructMerge = newMerge;
+        }
+
+        components.insert(constructMerge);
+
+        return getSuccessors(constructMerge);
+      };
+
+      auto addComponent = [&](ir::Block block) {
+        if (auto construct = block.cast<ir::Construct>()) {
+          return addConstructComponent(construct);
+        }
+
+        if (hasAtLeastSuccessors(block, 1)) {
+          components.insert(block);
+          return getSuccessors(block);
+        }
+
+        auto trampoline = createMergeBlock(
+            context, ir::InsertionPoint::createInsertBefore(block),
+            getPredecessors(block), block);
+
+        components.insert(trampoline);
+        return getSuccessors(block);
+      };
+
+      {
+        // try to find blocks that has no other predecessors
+
+        auto parentEntry =
+            skipPhis(parentConstruct.getFirst()).staticCast<ir::Block>();
+
+        auto headerSuccessors = getSuccessors(entryBlock);
+
+        std::vector<ir::Block> workList(headerSuccessors.begin(),
+                                        headerSuccessors.end());
+        while (!workList.empty()) {
+          auto block = workList.back();
+          workList.pop_back();
+
+          if (components.contains(block)) {
+            continue;
+          }
+
+          if (block.getParent() != parentConstruct) {
+            continue;
+          }
+
+          if (block == parentEntry || block == parentConstruct.getLast()) {
+            // do not take entry/latch/continuation of parent construct
+            continue;
+          }
+
+          bool hasAllPreds = true;
+          auto loop = block.cast<ir::LoopConstruct>();
+          for (auto pred : getPredecessors(block)) {
+            if (components.contains(pred)) {
+              continue;
+            }
+
+            if (loop && pred == loop.getContinue().getLast()) {
+              // ignore continue predecessor of loop
+              continue;
+            }
+
+            hasAllPreds = false;
+            break;
+          }
+
+          if (hasAllPreds) {
+            addComponent(block);
+          }
+        }
+      }
+
+      if (components.size() == 1) {
+        // all successors are used by nodes outside this header, it means it is
+        // not structured loop node or case block of OpSwitch with fallthrough
+        continue;
+      }
+
+      ir::Block entryLabel = entryBlock;
+      ir::Block mergeLabel;
+      bool mergeInserted = false;
+
+      std::unordered_set<ir::Block> exitBlocks;
+      std::vector<Edge> exitEdges;
+      for (auto block : components) {
+        for (auto [succ, operandIndex] : getAllSuccessors(block)) {
+          if (!components.contains(succ)) {
+            exitEdges.emplace_back(block, operandIndex);
+            exitBlocks.insert(block);
+          }
+        }
+      }
+
+      if (!exitBlocks.empty()) {
+        if (exitBlocks.size() == 1) {
+          mergeLabel = *exitBlocks.begin();
+        }
+
+        if (!mergeLabel ||
+            getAllPredecessors(mergeLabel).size() != exitEdges.size() ||
+            isConstruct(mergeLabel)) {
+          mergeLabel = createRouteBlock(
+              context, ir::InsertionPoint::createInsertAfter(entryBlock),
+              exitEdges);
+
+          workList.emplace_back(ir::range(mergeLabel));
+          mergeInserted = true;
+        }
+      } else {
+        mergeLabel = parentConstruct.getLast().staticCast<ir::Block>();
+      }
+
+      if (!mergeInserted) {
+        for (auto user : mergeLabel.getUserList()) {
+          if (auto construct = user.cast<ir::Construct>()) {
+            if (construct.getMerge() != mergeLabel) {
+              continue;
+            }
+          }
+          mergeLabel = createMergeBlock(
+              context, ir::InsertionPoint::createInsertBefore(mergeLabel),
+              getPredecessors(mergeLabel), mergeLabel);
+          mergeInserted = true;
+          break;
+        }
+      }
+
+      if (!mergeInserted) {
+        auto mergePreds = getPredecessors(mergeLabel);
+        std::unordered_set<ir::Block> branchesInsideConstruct;
+
+        for (auto pred : mergePreds) {
+          if (components.contains(pred)) {
+            branchesInsideConstruct.insert(pred);
+          }
+        }
+
+        if (branchesInsideConstruct.size() != mergePreds.size()) {
+          mergeLabel = createMergeBlock(
+              context, ir::InsertionPoint::createInsertBefore(mergeLabel),
+              branchesInsideConstruct, mergeLabel);
+        }
+      }
+
+      auto construct = createSelectionConstruct(
+          context, parentConstruct, components, entryLabel, mergeLabel);
+
+      // update merge label
+      construct.setMerge(mergeLabel);
+
+      construct.getHeader().replaceUsesIf(construct, [=](ir::ValueUse use) {
+        if (getConstructOf(use.user) != construct) {
+          if (isTerminator(use.user)) {
+            return true;
+          }
+
+          // allow update block merges
+          if (isConstruct(use.user) && use.operandIndex == 1) {
+            return true;
+          }
+        }
+
+        if (use.user != construct && isConstruct(use.user)) {
+          return true;
+        }
+
+        return false;
+      });
+
+      // move PHIs to construct
+      for (auto phi : ir::range(construct.getHeader().getFirst())) {
+        if (phi != ir::spv::OpPhi) {
+          break;
+        }
+
+        phi.erase();
+        construct.prependChild(phi);
+      }
+
+      // view child constructs
+      if (auto child = construct.getHeader().getNext().cast<ir::Block>()) {
+        workList.emplace_back(ir::range(child));
+      }
+
+      // view next constructs
+      if (auto next = construct.getNext()) {
+        workList.emplace_back(ir::range(next));
+      }
+
+      break;
+    }
+  }
+}
+
+void shader::structurizeCfg(spv::Context &context, ir::RegionLike region) {
+  // std::cerr << "before transforms: ";
+  // region.print(std::cerr, context.ns);
+  // std::cerr << "\n";
+
+  transformToCanonicalRegion(context, region);
+  transformToCf(context, region);
+
+  wrapLoopConstructs(context, region);
+  wrapSelectionConstructs(context, region);
+
+  // std::cerr << "structured: ";
+  // region.print(std::cerr, context.ns);
+  // std::cerr << "\n";
+  transformToFlat(context, region);
+
+  // std::cerr << "flat: ";
+  // region.print(std::cerr, context.ns);
+  // std::cerr << "\n";
+}
diff --git a/rx/include/rx/FunctionRef.hpp b/rx/include/rx/FunctionRef.hpp
index c6c41ce81..3c5eb66bf 100644
--- a/rx/include/rx/FunctionRef.hpp
+++ b/rx/include/rx/FunctionRef.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <compare>
+#include <type_traits>
 #include <utility>
 
 namespace rx {
@@ -12,7 +13,7 @@ template <typename RT, typename... ArgsT> class FunctionRef<RT(ArgsT...)> {
 public:
   constexpr FunctionRef() = default;
 
-  template <typename T>
+  template <typename T> requires (!std::is_same_v<std::remove_cvref_t<T>, FunctionRef>)
   constexpr FunctionRef(T &&object)
     requires requires(ArgsT... args) { RT(object(args...)); }
       : context(