[SPIR-V] Use a helper class for most if/else branching

Simplifies emission of the blocks themselves (including inserting blocks
into the function's block list in the correct order), as well as phi after
the branching.

Also fixes 64bpp storing with blending in the fragment shader interlock
render backend implementation (had a typo that caused the high 32 bits to
overwrite the low ones).

Author: Triang3l

src/xenia/gpu/spirv_builder.cc

@@ -13,6 +13,8 @@
 #include <utility>
 #include <vector>
 
+#include "xenia/base/assert.h"
+
 namespace xe {
 namespace gpu {
 
@@ -101,5 +103,105 @@ spv::Id SpirvBuilder::createTriBuiltinCall(spv::Id result_type,
   return result;
 }
 
+SpirvBuilder::IfBuilder::IfBuilder(spv::Id condition, unsigned int control,
+                                   SpirvBuilder& builder,
+                                   unsigned int thenWeight,
+                                   unsigned int elseWeight)
+    : builder(builder),
+      condition(condition),
+      control(control),
+      thenWeight(thenWeight),
+      elseWeight(elseWeight),
+      function(builder.getBuildPoint()->getParent()) {
+  // Make the blocks, but only put the then-block into the function, the
+  // else-block and merge-block will be added later, in order, after earlier
+  // code is emitted.
+  thenBlock = new spv::Block(builder.getUniqueId(), function);
+  elseBlock = nullptr;
+  mergeBlock = new spv::Block(builder.getUniqueId(), function);
+
+  // Save the current block, so that we can add in the flow control split when
+  // makeEndIf is called.
+  headerBlock = builder.getBuildPoint();
+
+  spv::Id headerBlockId = headerBlock->getId();
+  thenPhiParent = headerBlockId;
+  elsePhiParent = headerBlockId;
+
+  function.addBlock(thenBlock);
+  builder.setBuildPoint(thenBlock);
+}
+
+void SpirvBuilder::IfBuilder::makeBeginElse(bool branchToMerge) {
+#ifndef NDEBUG
+  assert_true(currentBranch == Branch::kThen);
+#endif
+
+  if (branchToMerge) {
+    // Close out the "then" by having it jump to the mergeBlock.
+    thenPhiParent = builder.getBuildPoint()->getId();
+    builder.createBranch(mergeBlock);
+  }
+
+  // Make the first else block and add it to the function.
+  elseBlock = new spv::Block(builder.getUniqueId(), function);
+  function.addBlock(elseBlock);
+
+  // Start building the else block.
+  builder.setBuildPoint(elseBlock);
+
+#ifndef NDEBUG
+  currentBranch = Branch::kElse;
+#endif
+}
+
+void SpirvBuilder::IfBuilder::makeEndIf(bool branchToMerge) {
+#ifndef NDEBUG
+  assert_true(currentBranch == Branch::kThen || currentBranch == Branch::kElse);
+#endif
+
+  if (branchToMerge) {
+    // Jump to the merge block.
+    (elseBlock ? elsePhiParent : thenPhiParent) =
+        builder.getBuildPoint()->getId();
+    builder.createBranch(mergeBlock);
+  }
+
+  // Go back to the headerBlock and make the flow control split.
+  builder.setBuildPoint(headerBlock);
+  builder.createSelectionMerge(mergeBlock, control);
+  {
+    spv::Block* falseBlock = elseBlock ? elseBlock : mergeBlock;
+    std::unique_ptr<spv::Instruction> branch =
+        std::make_unique<spv::Instruction>(spv::OpBranchConditional);
+    branch->addIdOperand(condition);
+    branch->addIdOperand(thenBlock->getId());
+    branch->addIdOperand(falseBlock->getId());
+    if (thenWeight || elseWeight) {
+      branch->addImmediateOperand(thenWeight);
+      branch->addImmediateOperand(elseWeight);
+    }
+    builder.getBuildPoint()->addInstruction(std::move(branch));
+    thenBlock->addPredecessor(builder.getBuildPoint());
+    falseBlock->addPredecessor(builder.getBuildPoint());
+  }
+
+  // Add the merge block to the function.
+  function.addBlock(mergeBlock);
+  builder.setBuildPoint(mergeBlock);
+
+#ifndef NDEBUG
+  currentBranch = Branch::kMerge;
+#endif
+}
+
+spv::Id SpirvBuilder::IfBuilder::createMergePhi(spv::Id then_variable,
+                                                spv::Id else_variable) const {
+  assert_true(builder.getBuildPoint() == mergeBlock);
+  return builder.createQuadOp(spv::OpPhi, builder.getTypeId(then_variable),
+                              then_variable, getThenPhiParent(), else_variable,
+                              getElsePhiParent());
+}
+
 }  // namespace gpu
 }  // namespace xe

src/xenia/gpu/spirv_builder.h

@@ -10,7 +10,10 @@
 #ifndef XENIA_GPU_SPIRV_BUILDER_H_
 #define XENIA_GPU_SPIRV_BUILDER_H_
 
+#include <optional>
+
 #include "third_party/glslang/SPIRV/SpvBuilder.h"
+#include "xenia/base/assert.h"
 
 namespace xe {
 namespace gpu {
@@ -42,6 +45,60 @@ class SpirvBuilder : public spv::Builder {
   spv::Id createTriBuiltinCall(spv::Id result_type, spv::Id builtins,
                                int entry_point, spv::Id operand1,
                                spv::Id operand2, spv::Id operand3);
+
+  // Helper to use for building nested control flow with if-then-else with
+  // additions over SpvBuilder::If.
+  class IfBuilder {
+   public:
+    IfBuilder(spv::Id condition, unsigned int control, SpirvBuilder& builder,
+              unsigned int thenWeight = 0, unsigned int elseWeight = 0);
+
+    ~IfBuilder() {
+#ifndef NDEBUG
+      assert_true(currentBranch == Branch::kMerge);
+#endif
+    }
+
+    void makeBeginElse(bool branchToMerge = true);
+    void makeEndIf(bool branchToMerge = true);
+
+    // If there's no then/else block that branches to the merge block, the phi
+    // parent is the header block - this simplifies then-only usage.
+    spv::Id getThenPhiParent() const { return thenPhiParent; }
+    spv::Id getElsePhiParent() const { return elsePhiParent; }
+
+    spv::Id createMergePhi(spv::Id then_variable, spv::Id else_variable) const;
+
+   private:
+    enum class Branch {
+      kThen,
+      kElse,
+      kMerge,
+    };
+
+    IfBuilder(const IfBuilder& ifBuilder) = delete;
+    IfBuilder& operator=(const IfBuilder& ifBuilder) = delete;
+
+    SpirvBuilder& builder;
+    spv::Id condition;
+    unsigned int control;
+    unsigned int thenWeight;
+    unsigned int elseWeight;
+
+    spv::Function& function;
+
+    spv::Block* headerBlock;
+    spv::Block* thenBlock;
+    spv::Block* elseBlock;
+    spv::Block* mergeBlock;
+
+    spv::Id thenPhiParent;
+    spv::Id elsePhiParent;
+
+#ifndef NDEBUG
+    Branch currentBranch = Branch::kThen;
+#endif
+  };
 };
 
 }  // namespace gpu