[mlir][spirv] Use ScopedPrinter in deserialization debugging

[antiagainst]

Summary

This gives us better debugging print as it supports indent
levels and other nice features.

Depends On D115582

[antiagainst]

Update to use reference

mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp

spirv::Deserializer::sliceInstruction(spirv::Opcode &opcode,
   opcode = extractOpcode(binary[curOffset]);
   operands = binary.slice(curOffset + 1, wordCount - 1);
   curOffset = nextOffset;
   return success();
 }
 
 LogicalResult spirv::Deserializer::processInstruction(
     spirv::Opcode opcode, ArrayRef<uint32_t> operands, bool deferInstructions) {
-  LLVM_DEBUG(llvm::dbgs() << "[inst] processing instruction "
+  LLVM_DEBUG(logger.startLine() << "[inst] processing instruction "
                                 << spirv::stringifyOpcode(opcode) << "\n");
 
   // First dispatch all the instructions whose opcode does not correspond to
   // those that have a direct mirror in the SPIR-V dialect
   switch (opcode) {
   case spirv::Opcode::OpCapability:
     return processCapability(operands);
   case spirv::Opcode::OpExtension:
     return processExtension(operands);

mlir/lib/Target/SPIRV/Deserialization/Deserializer.h

 #define MLIR_TARGET_SPIRV_DESERIALIZER_H
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/IR/Builders.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include <cstdint>
 
 namespace mlir {
 namespace spirv {
 
 //===----------------------------------------------------------------------===//
 // Utility Definitions
 //===----------------------------------------------------------------------===//
 
 /// A struct for containing a header block's merge and continue targets.
 ///
 /// This struct is used to track original structured control flow info from
 /// SPIR-V blob. This info will be used to create
 /// spv.mlir.selection/spv.mlir.loop later.
 struct BlockMergeInfo {
   Block *mergeBlock;
   Block *continueBlock; // nullptr for spv.mlir.selection
   Location loc;
-  uint32_t control;
+  uint32_t control; // Selection/loop control
 
   BlockMergeInfo(Location location, uint32_t control)
       : mergeBlock(nullptr), continueBlock(nullptr), loc(location),
         control(control) {}
   BlockMergeInfo(Location location, uint32_t control, Block *m,
                  Block *c = nullptr)
       : mergeBlock(m), continueBlock(c), loc(location), control(control) {}
 };
 
 /// A struct for containing OpLine instruction information.
 struct DebugLine {
   uint32_t fileID;
   uint32_t line;
-  uint32_t col;
-
-  DebugLine(uint32_t fileIDNum, uint32_t lineNum, uint32_t colNum)
-      : fileID(fileIDNum), line(lineNum), col(colNum) {}
+  uint32_t column;
 };
 
 /// Map from a selection/loop's header block to its merge (and continue) target.
 using BlockMergeInfoMap = DenseMap<Block *, BlockMergeInfo>;
 
 /// A "deferred struct type" is a struct type with one or more member types not
 /// known when the Deserializer first encounters the struct. This happens, for
 /// example, with recursive structs where a pointer to the struct type is
SmallVector<std::pair<spirv::Opcode, ArrayRef<uint32_t>>, 4>
       deferredInstructions;
 
   /// A list of IDs for all types forward-declared through OpTypeForwardPointer
   /// instructions.
   SetVector<uint32_t> typeForwardPointerIDs;
 
   /// A list of all structs which have unresolved member types.
   SmallVector<DeferredStructTypeInfo, 0> deferredStructTypesInfos;
+
+#ifndef NDEBUG
+  /// A logger used to emit information during the deserialzation process.
+  llvm::ScopedPrinter logger;
+#endif
 };
 
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_TARGET_SPIRV_DESERIALIZER_H

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

 
 //===----------------------------------------------------------------------===//
 // Deserializer Method Definitions
 //===----------------------------------------------------------------------===//
 
 spirv::Deserializer::Deserializer(ArrayRef<uint32_t> binary,
                                   MLIRContext *context)
     : binary(binary), context(context), unknownLoc(UnknownLoc::get(context)),
-      module(createModuleOp()), opBuilder(module->getRegion()) {}
+      module(createModuleOp()), opBuilder(module->getRegion())
+#ifndef NDEBUG
+      ,
+      logger(llvm::dbgs())
+#endif
+{
+}
 
 LogicalResult spirv::Deserializer::deserialize() {
-  LLVM_DEBUG(llvm::dbgs() << "+++ starting deserialization +++\n");
+  LLVM_DEBUG({
+    logger.resetIndent();
+    logger.startLine()
+        << "//+++---------- start deserialization ----------+++//\n";
+  });
 
   if (failed(processHeader()))
     return failure();
 
   spirv::Opcode opcode = spirv::Opcode::OpNop;
   ArrayRef<uint32_t> operands;
   auto binarySize = binary.size();
   while (curOffset < binarySize) {
LogicalResult spirv::Deserializer::deserialize() {
   for (auto &deferred : deferredInstructions) {
     if (failed(processInstruction(deferred.first, deferred.second, false))) {
       return failure();
     }
   }
 
   attachVCETriple();
 
-  LLVM_DEBUG(llvm::dbgs() << "+++ completed deserialization +++\n");
+  LLVM_DEBUG(logger.startLine()
+             << "//+++-------- completed deserialization --------+++//\n");
   return success();
 }
 
 OwningOpRef<spirv::ModuleOp> spirv::Deserializer::collect() {
   return std::move(module);
 }
 
 //===----------------------------------------------------------------------===//
if (operands.size() != 4) {
     return emitError(unknownLoc, "OpFunction must have 4 parameters");
   }
   Type resultType = getType(operands[0]);
   if (!resultType) {
     return emitError(unknownLoc, "undefined result type from <id> ")
            << operands[0];
   }
 
-  if (funcMap.count(operands[1])) {
+  uint32_t fnID = operands[1];
+  if (funcMap.count(fnID)) {
     return emitError(unknownLoc, "duplicate function definition/declaration");
   }
 
   auto fnControl = spirv::symbolizeFunctionControl(operands[2]);
   if (!fnControl) {
     return emitError(unknownLoc, "unknown Function Control: ") << operands[2];
   }
 
   Type fnType = getType(operands[3]);
   if (!fnType || !fnType.isa<FunctionType>()) {
     return emitError(unknownLoc, "unknown function type from <id> ")
            << operands[3];
   }
   auto functionType = fnType.cast<FunctionType>();
 
   if ((isVoidType(resultType) && functionType.getNumResults() != 0) ||
       (functionType.getNumResults() == 1 &&
        functionType.getResult(0) != resultType)) {
     return emitError(unknownLoc, "mismatch in function type ")
            << functionType << " and return type " << resultType << " specified";
   }
 
-  std::string fnName = getFunctionSymbol(operands[1]);
+  std::string fnName = getFunctionSymbol(fnID);
   auto funcOp = opBuilder.create<spirv::FuncOp>(
       unknownLoc, fnName, functionType, fnControl.getValue());
-  curFunction = funcMap[operands[1]] = funcOp;
-  LLVM_DEBUG(llvm::dbgs() << "-- start function " << fnName << " (type = "
-                          << fnType << ", id = " << operands[1] << ") --\n");
+  curFunction = funcMap[fnID] = funcOp;
   auto *entryBlock = funcOp.addEntryBlock();
-  LLVM_DEBUG(llvm::dbgs() << "[block] created entry block " << entryBlock
-                          << "\n");
+  LLVM_DEBUG({
+    logger.startLine()
+        << "//===-------------------------------------------===//\n";
+    logger.startLine() << "[fn] name: " << fnName << "\n";
+    logger.startLine() << "[fn] type: " << fnType << "\n";
+    logger.startLine() << "[fn] ID: " << fnID << "\n";
+    logger.startLine() << "[fn] entry block: " << entryBlock << "\n";
+    logger.indent();
+  });
 
   // Parse the op argument instructions
   if (functionType.getNumInputs()) {
     for (size_t i = 0, e = functionType.getNumInputs(); i != e; ++i) {
       auto argType = functionType.getInput(i);
       spirv::Opcode opcode = spirv::Opcode::OpNop;
       ArrayRef<uint32_t> operands;
       if (failed(sliceInstruction(opcode, operands,
for (size_t i = 0, e = functionType.getNumInputs(); i != e; ++i) {
       if (!argDefinedType || argDefinedType != argType) {
         return emitError(unknownLoc,
                          "mismatch in argument type between function type "
                          "definition ")
                << functionType << " and argument type definition "
                << argDefinedType << " at argument " << i;
       }
       if (getValue(operands[1])) {
-        return emitError(unknownLoc, "duplicate definition of result <id> '")
+        return emitError(unknownLoc, "duplicate definition of result <id> ")
                << operands[1];
       }
       auto argValue = funcOp.getArgument(i);
       valueMap[operands[1]] = argValue;
     }
   }
 
   // RAII guard to reset the insertion point to the module's region after
   // deserializing the body of this function.
   OpBuilder::InsertionGuard moduleInsertionGuard(opBuilder);
 
   spirv::Opcode opcode = spirv::Opcode::OpNop;
   ArrayRef<uint32_t> instOperands;
 
   // Special handling for the entry block. We need to make sure it starts with
   // an OpLabel instruction. The entry block takes the same parameters as the
   // function. All other blocks do not take any parameter. We have already
   // created the entry block, here we need to register it to the correct label
   // <id>.
   if (failed(sliceInstruction(opcode, instOperands,
                               spirv::Opcode::OpFunctionEnd))) {
     return failure();
   }
   if (opcode == spirv::Opcode::OpFunctionEnd) {
-    LLVM_DEBUG(llvm::dbgs()
-               << "-- completed function '" << fnName << "' (type = " << fnType
-               << ", id = " << operands[1] << ") --\n");
     return processFunctionEnd(instOperands);
   }
   if (opcode != spirv::Opcode::OpLabel) {
     return emitError(unknownLoc, "a basic block must start with OpLabel");
   }
   if (instOperands.size() != 1) {
     return emitError(unknownLoc, "OpLabel should only have result <id>");
   }
while (succeeded(sliceInstruction(opcode, instOperands,
     if (failed(processInstruction(opcode, instOperands))) {
       return failure();
     }
   }
   if (opcode != spirv::Opcode::OpFunctionEnd) {
     return failure();
   }
 
-  LLVM_DEBUG(llvm::dbgs() << "-- completed function '" << fnName << "' (type = "
-                          << fnType << ", id = " << operands[1] << ") --\n");
   return processFunctionEnd(instOperands);
 }
 
 LogicalResult
 spirv::Deserializer::processFunctionEnd(ArrayRef<uint32_t> operands) {
   // Process OpFunctionEnd.
   if (!operands.empty()) {
     return emitError(unknownLoc, "unexpected operands for OpFunctionEnd");
   }
 
   // Wire up block arguments from OpPhi instructions.
   // Put all structured control flow in spv.mlir.selection/spv.mlir.loop ops.
   if (failed(wireUpBlockArgument()) || failed(structurizeControlFlow())) {
     return failure();
   }
 
   curBlock = nullptr;
   curFunction = llvm::None;
 
+  LLVM_DEBUG({
+    logger.unindent();
+    logger.startLine()
+        << "//===-------------------------------------------===//\n";
+  });
   return success();
 }
 
 Optional<std::pair<Attribute, Type>>
 spirv::Deserializer::getConstant(uint32_t id) {
   auto constIt = constantMap.find(id);
   if (constIt == constantMap.end())
     return llvm::None;

 }
 
 //===----------------------------------------------------------------------===//
 // Control flow
 //===----------------------------------------------------------------------===//
 
 Block *spirv::Deserializer::getOrCreateBlock(uint32_t id) {
   if (auto *block = getBlock(id)) {
-    LLVM_DEBUG(llvm::dbgs() << "[block] got exiting block for id = " << id
+    LLVM_DEBUG(logger.startLine() << "[block] got exiting block for id = " << id
                                   << " @ " << block << "\n");
     return block;
   }
 
   // We don't know where this block will be placed finally (in a
   // spv.mlir.selection or spv.mlir.loop or function). Create it into the
   // function for now and sort out the proper place later.
   auto *block = curFunction->addBlock();
-  LLVM_DEBUG(llvm::dbgs() << "[block] created block for id = " << id << " @ "
-                          << block << "\n");
+  LLVM_DEBUG(logger.startLine() << "[block] created block for id = " << id
+                                << " @ " << block << "\n");
   return blockMap[id] = block;
 }
 
 LogicalResult spirv::Deserializer::processBranch(ArrayRef<uint32_t> operands) {
   if (!curBlock) {
     return emitError(unknownLoc, "OpBranch must appear inside a block");
   }
 
LogicalResult spirv::Deserializer::processLabel(ArrayRef<uint32_t> operands) {
 
   if (operands.size() != 1) {
     return emitError(unknownLoc, "OpLabel should only have result <id>");
   }
 
   auto labelID = operands[0];
   // We may have forward declared this block.
   auto *block = getOrCreateBlock(labelID);
-  LLVM_DEBUG(llvm::dbgs() << "[block] populating block " << block << "\n");
+  LLVM_DEBUG(logger.startLine()
+             << "[block] populating block " << block << "\n");
   // If we have seen this block, make sure it was just a forward declaration.
   assert(block->empty() && "re-deserialize the same block!");
 
   opBuilder.setInsertionPointToStart(block);
   blockMap[labelID] = curBlock = block;
 
   return success();
 }
if (operands.size() < 4) {
     return emitError(unknownLoc, "OpPhi must specify result type, result <id>, "
                                  "and variable-parent pairs");
   }
 
   // Create a block argument for this OpPhi instruction.
   Type blockArgType = getType(operands[0]);
   BlockArgument blockArg = curBlock->addArgument(blockArgType);
   valueMap[operands[1]] = blockArg;
-  LLVM_DEBUG(llvm::dbgs() << "[phi] created block argument " << blockArg
-                          << " id = " << operands[1] << " of type "
-                          << blockArgType << '\n');
+  LLVM_DEBUG(logger.startLine()
+             << "[phi] created block argument " << blockArg
+             << " id = " << operands[1] << " of type " << blockArgType << "\n");
 
   // For each (value, predecessor) pair, insert the value to the predecessor's
   // blockPhiInfo entry so later we can fix the block argument there.
   for (unsigned i = 2, e = operands.size(); i < e; i += 2) {
     uint32_t value = operands[i];
     Block *predecessor = getOrCreateBlock(operands[i + 1]);
     std::pair<Block *, Block *> predecessorTargetPair{predecessor, curBlock};
     blockPhiInfo[predecessorTargetPair].push_back(value);
-    LLVM_DEBUG(llvm::dbgs() << "[phi] predecessor @ " << predecessor
-                            << " with arg id = " << value << '\n');
+    LLVM_DEBUG(logger.startLine() << "[phi] predecessor @ " << predecessor
+                                  << " with arg id = " << value << "\n");
   }
 
   return success();
 }
 
 namespace {
 /// A class for putting all blocks in a structured selection/loop in a
 /// spv.mlir.selection/spv.mlir.loop op.
 class ControlFlowStructurizer {
 public:
+#ifndef NDEBUG
+  ControlFlowStructurizer(Location loc, uint32_t control,
+                          spirv::BlockMergeInfoMap &mergeInfo, Block *header,
+                          Block *merge, Block *cont,
+                          llvm::ScopedPrinter &logger)
+      : location(loc), control(control), blockMergeInfo(mergeInfo),
+        headerBlock(header), mergeBlock(merge), continueBlock(cont),
+        logger(logger) {}
+#else
+  ControlFlowStructurizer(Location loc, uint32_t control,
+                          spirv::BlockMergeInfoMap &mergeInfo, Block *header,
+                          Block *merge, Block *cont)
+      : location(loc), control(control), blockMergeInfo(mergeInfo),
+        headerBlock(header), mergeBlock(merge), continueBlock(cont) {}
+#endif
+
   /// Structurizes the loop at the given `headerBlock`.
   ///
   /// This method will create an spv.mlir.loop op in the `mergeBlock` and move
   /// all blocks in the structured loop into the spv.mlir.loop's region. All
   /// branches to the `headerBlock` will be redirected to the `mergeBlock`. This
   /// method will also update `mergeInfo` by remapping all blocks inside to the
   /// newly cloned ones inside structured control flow op's regions.
-  static LogicalResult structurize(Location loc, uint32_t control,
-                                   spirv::BlockMergeInfoMap &mergeInfo,
-                                   Block *headerBlock, Block *mergeBlock,
-                                   Block *continueBlock) {
-    return ControlFlowStructurizer(loc, control, mergeInfo, headerBlock,
-                                   mergeBlock, continueBlock)
-        .structurizeImpl();
-  }
+  LogicalResult structurize();
 
 private:
-  ControlFlowStructurizer(Location loc, uint32_t control,
-                          spirv::BlockMergeInfoMap &mergeInfo, Block *header,
-                          Block *merge, Block *cont)
-      : location(loc), control(control), blockMergeInfo(mergeInfo),
-        headerBlock(header), mergeBlock(merge), continueBlock(cont) {}
-
   /// Creates a new spv.mlir.selection op at the beginning of the `mergeBlock`.
   spirv::SelectionOp createSelectionOp(uint32_t selectionControl);
 
   /// Creates a new spv.mlir.loop op at the beginning of the `mergeBlock`.
   spirv::LoopOp createLoopOp(uint32_t loopControl);
 
   /// Collects all blocks reachable from `headerBlock` except `mergeBlock`.
   void collectBlocksInConstruct();
 
-  LogicalResult structurizeImpl();
-
   Location location;
   uint32_t control;
 
   spirv::BlockMergeInfoMap &blockMergeInfo;
 
   Block *headerBlock;
   Block *mergeBlock;
   Block *continueBlock; // nullptr for spv.mlir.selection
 
   SetVector<Block *> constructBlocks;
+
+#ifndef NDEBUG
+  /// A logger used to emit information during the deserialzation process.
+  llvm::ScopedPrinter &logger;
+#endif
 };
 } // namespace
 
 spirv::SelectionOp
 ControlFlowStructurizer::createSelectionOp(uint32_t selectionControl) {
   // Create a builder and set the insertion point to the beginning of the
   // merge block so that the newly created SelectionOp will be inserted there.
   OpBuilder builder(&mergeBlock->front());
void ControlFlowStructurizer::collectBlocksInConstruct() {
   // block.
   for (unsigned i = 0; i < constructBlocks.size(); ++i) {
     for (auto *successor : constructBlocks[i]->getSuccessors())
       if (successor != mergeBlock)
         constructBlocks.insert(successor);
   }
 }
 
-LogicalResult ControlFlowStructurizer::structurizeImpl() {
+LogicalResult ControlFlowStructurizer::structurize() {
   Operation *op = nullptr;
   bool isLoop = continueBlock != nullptr;
   if (isLoop) {
     if (auto loopOp = createLoopOp(control))
       op = loopOp.getOperation();
   } else {
     if (auto selectionOp = createSelectionOp(control))
       op = selectionOp.getOperation();
LogicalResult ControlFlowStructurizer::structurize() {
   // Create a corresponding block in the SelectionOp/LoopOp's region for each
   // block in this loop construct.
   OpBuilder builder(body);
   for (auto *block : constructBlocks) {
     // Create a block and insert it before the selection/loop merge block in the
     // SelectionOp/LoopOp's region.
     auto *newBlock = builder.createBlock(&body.back());
     mapper.map(block, newBlock);
-    LLVM_DEBUG(llvm::dbgs() << "[cf] cloned block " << newBlock
+    LLVM_DEBUG(logger.startLine() << "[cf] cloned block " << newBlock
                                   << " from block " << block << "\n");
     if (!isFnEntryBlock(block)) {
       for (BlockArgument blockArg : block->getArguments()) {
         auto newArg = newBlock->addArgument(blockArg.getType());
         mapper.map(blockArg, newArg);
-        LLVM_DEBUG(llvm::dbgs() << "[cf] remapped block argument " << blockArg
-                                << " to " << newArg << '\n');
+        LLVM_DEBUG(logger.startLine() << "[cf] remapped block argument "
+                                      << blockArg << " to " << newArg << "\n");
       }
     } else {
-      LLVM_DEBUG(llvm::dbgs()
+      LLVM_DEBUG(logger.startLine()
                  << "[cf] block " << block << " is a function entry block\n");
     }
 
     for (auto &op : *block)
       newBlock->push_back(op.clone(mapper));
   }
 
   // Go through all ops and remap the operands.
LogicalResult ControlFlowStructurizer::structurize() {
   // We have created the SelectionOp/LoopOp and "moved" all blocks belonging to
   // the selection/loop construct into its region. Next we need to fix the
   // connections between this new SelectionOp/LoopOp with existing blocks.
 
   // All existing incoming branches should go to the merge block, where the
   // SelectionOp/LoopOp resides right now.
   headerBlock->replaceAllUsesWith(mergeBlock);
 
-  LLVM_DEBUG(llvm::dbgs() << "[cf] after cloning and fixing references:\n");
-  LLVM_DEBUG(llvm::dbgs() << *headerBlock->getParentOp());
-  LLVM_DEBUG(llvm::dbgs() << "\n");
+  LLVM_DEBUG({
+    logger.startLine() << "[cf] after cloning and fixing references:\n";
+    headerBlock->getParentOp()->print(logger.getOStream());
+    logger.startLine() << "\n";
+  });
 
   if (isLoop) {
     if (!mergeBlock->args_empty()) {
       return mergeBlock->getParentOp()->emitError(
           "OpPhi in loop merge block unsupported");
     }
 
     // The loop header block may have block arguments. Since now we place the
if (isLoop) {
     // loop header block.
     builder.setInsertionPointToEnd(&body.front());
     builder.create<spirv::BranchOp>(location, mapper.lookupOrNull(headerBlock),
                                     ArrayRef<Value>(blockArgs));
   }
 
   // All the blocks cloned into the SelectionOp/LoopOp's region can now be
   // cleaned up.
-  LLVM_DEBUG(llvm::dbgs() << "[cf] cleaning up blocks after clone\n");
+  LLVM_DEBUG(logger.startLine() << "[cf] cleaning up blocks after clone\n");
   // First we need to drop all operands' references inside all blocks. This is
   // needed because we can have blocks referencing SSA values from one another.
   for (auto *block : constructBlocks)
     block->dropAllReferences();
 
   // Check that whether some op in the to-be-erased blocks still has uses. Those
   // uses come from blocks that won't be sinked into the SelectionOp/LoopOp's
   // region. We cannot handle such cases given that once a value is sinked into
if (it != blockMergeInfo.end()) {
                                  newContinue);
     }
 
     // The structured selection/loop's entry block does not have arguments.
     // If the function's header block is also part of the structured control
     // flow, we cannot just simply erase it because it may contain arguments
     // matching the function signature and used by the cloned blocks.
     if (isFnEntryBlock(block)) {
-      LLVM_DEBUG(llvm::dbgs() << "[cf] changing entry block " << block
+      LLVM_DEBUG(logger.startLine() << "[cf] changing entry block " << block
                                     << " to only contain a spv.Branch op\n");
       // Still keep the function entry block for the potential block arguments,
       // but replace all ops inside with a branch to the merge block.
       block->clear();
       builder.setInsertionPointToEnd(block);
       builder.create<spirv::BranchOp>(location, mergeBlock);
     } else {
-      LLVM_DEBUG(llvm::dbgs() << "[cf] erasing block " << block << "\n");
+      LLVM_DEBUG(logger.startLine() << "[cf] erasing block " << block << "\n");
       block->erase();
     }
   }
 
-  LLVM_DEBUG(
-      llvm::dbgs() << "[cf] after structurizing construct with header block "
-                   << headerBlock << ":\n"
-                   << *op << '\n');
+  LLVM_DEBUG(logger.startLine()
+             << "[cf] after structurizing construct with header block "
+             << *op << "\n");
 
   return success();
 }
 
 LogicalResult spirv::Deserializer::wireUpBlockArgument() {
-  LLVM_DEBUG(llvm::dbgs() << "[phi] start wiring up block arguments\n");
+  LLVM_DEBUG({
+    logger.startLine()
+        << "//----- [phi] start wiring up block arguments -----//\n";
+    logger.indent();
+  });
 
   OpBuilder::InsertionGuard guard(opBuilder);
 
   for (const auto &info : blockPhiInfo) {
     Block *block = info.first.first;
     Block *target = info.first.second;
     const BlockPhiInfo &phiInfo = info.second;
-    LLVM_DEBUG(llvm::dbgs() << "[phi] block " << block << "\n");
-    LLVM_DEBUG(llvm::dbgs() << "[phi] before creating block argument:\n");
-    LLVM_DEBUG(block->getParentOp()->print(llvm::dbgs()));
-    LLVM_DEBUG(llvm::dbgs() << '\n');
+    LLVM_DEBUG({
+      logger.startLine() << "[phi] block " << block << "\n";
+      logger.startLine() << "[phi] before creating block argument:\n";
+      block->getParentOp()->print(logger.getOStream());
+      logger.startLine() << "\n";
+    });
 
     // Set insertion point to before this block's terminator early because we
     // may materialize ops via getValue() call.
     auto *op = block->getTerminator();
     opBuilder.setInsertionPoint(op);
 
     SmallVector<Value, 4> blockArgs;
     blockArgs.reserve(phiInfo.size());
     for (uint32_t valueId : phiInfo) {
       if (Value value = getValue(valueId)) {
         blockArgs.push_back(value);
-        LLVM_DEBUG(llvm::dbgs() << "[phi] block argument " << value
-                                << " id = " << valueId << '\n');
+        LLVM_DEBUG(logger.startLine() << "[phi] block argument " << value
+                                      << " id = " << valueId << "\n");
       } else {
         return emitError(unknownLoc, "OpPhi references undefined value!");
       }
     }
 
     if (auto branchOp = dyn_cast<spirv::BranchOp>(op)) {
       // Replace the previous branch op with a new one with block arguments.
       opBuilder.create<spirv::BranchOp>(branchOp.getLoc(), branchOp.getTarget(),
if (auto branchOp = dyn_cast<spirv::BranchOp>(op)) {
             branchCondOp.branch_weightsAttr(), branchCondOp.getTrueBlock(),
             branchCondOp.getFalseBlock());
 
       branchCondOp.erase();
     } else {
       return emitError(unknownLoc, "unimplemented terminator for Phi creation");
     }
 
-    LLVM_DEBUG(llvm::dbgs() << "[phi] after creating block argument:\n");
-    LLVM_DEBUG(block->getParentOp()->print(llvm::dbgs()));
-    LLVM_DEBUG(llvm::dbgs() << '\n');
+    LLVM_DEBUG({
+      logger.startLine() << "[phi] after creating block argument:\n";
+      block->getParentOp()->print(logger.getOStream());
+      logger.startLine() << "\n";
+    });
   }
   blockPhiInfo.clear();
 
-  LLVM_DEBUG(llvm::dbgs() << "[phi] completed wiring up block arguments\n");
+  LLVM_DEBUG({
+    logger.unindent();
+    logger.startLine()
+        << "//--- [phi] completed wiring up block arguments ---//\n";
+  });
   return success();
 }
 
 LogicalResult spirv::Deserializer::structurizeControlFlow() {
-  LLVM_DEBUG(llvm::dbgs() << "[cf] start structurizing control flow\n");
+  LLVM_DEBUG({
+    logger.startLine()
+        << "//----- [cf] start structurizing control flow -----//\n";
+    logger.indent();
+  });
 
   while (!blockMergeInfo.empty()) {
     Block *headerBlock = blockMergeInfo.begin()->first;
     BlockMergeInfo mergeInfo = blockMergeInfo.begin()->second;
 
-    LLVM_DEBUG(llvm::dbgs() << "[cf] header block " << headerBlock << ":\n");
-    LLVM_DEBUG(headerBlock->print(llvm::dbgs()));
+    LLVM_DEBUG({
+      logger.startLine() << "[cf] header block " << headerBlock << ":\n";
+      headerBlock->print(logger.getOStream());
+      logger.startLine() << "\n";
+    });
 
     auto *mergeBlock = mergeInfo.mergeBlock;
     assert(mergeBlock && "merge block cannot be nullptr");
     if (!mergeBlock->args_empty())
       return emitError(unknownLoc, "OpPhi in loop merge block unimplemented");
-    LLVM_DEBUG(llvm::dbgs() << "[cf] merge block " << mergeBlock << ":\n");
-    LLVM_DEBUG(mergeBlock->print(llvm::dbgs()));
+    LLVM_DEBUG({
+      logger.startLine() << "[cf] merge block " << mergeBlock << ":\n";
+      mergeBlock->print(logger.getOStream());
+      logger.startLine() << "\n";
+    });
 
     auto *continueBlock = mergeInfo.continueBlock;
-    if (continueBlock) {
-      LLVM_DEBUG(llvm::dbgs()
-                 << "[cf] continue block " << continueBlock << ":\n");
-      LLVM_DEBUG(continueBlock->print(llvm::dbgs()));
-    }
+    LLVM_DEBUG(if (continueBlock) {
+      logger.startLine() << "[cf] continue block " << continueBlock << ":\n";
+      continueBlock->print(logger.getOStream());
+      logger.startLine() << "\n";
+    });
     // Erase this case before calling into structurizer, who will update
     // blockMergeInfo.
     blockMergeInfo.erase(blockMergeInfo.begin());
-    if (failed(ControlFlowStructurizer::structurize(
-            mergeInfo.loc, mergeInfo.control, blockMergeInfo, headerBlock,
-            mergeBlock, continueBlock)))
+    ControlFlowStructurizer structurizer(mergeInfo.loc, mergeInfo.control,
+                                         blockMergeInfo, headerBlock,
+                                         mergeBlock, continueBlock
+#ifndef NDEBUG
+                                         ,
+                                         logger
+#endif
+    );
+    if (failed(structurizer.structurize()))
       return failure();
   }
 
-  LLVM_DEBUG(llvm::dbgs() << "[cf] completed structurizing control flow\n");
+  LLVM_DEBUG({
+    logger.unindent();
+    logger.startLine()
+        << "//--- [cf] completed structurizing control flow ---//\n";
+  });
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Debug
 //===----------------------------------------------------------------------===//
 
 Location spirv::Deserializer::createFileLineColLoc(OpBuilder opBuilder) {
   if (!debugLine)
     return unknownLoc;
 
   auto fileName = debugInfoMap.lookup(debugLine->fileID).str();
   if (fileName.empty())
     fileName = "<unknown>";
   return FileLineColLoc::get(opBuilder.getStringAttr(fileName), debugLine->line,
-                             debugLine->col);
+                             debugLine->column);
 }
 
 LogicalResult
 spirv::Deserializer::processDebugLine(ArrayRef<uint32_t> operands) {
   // According to SPIR-V spec:
   // "This location information applies to the instructions physically
   // following this instruction, up to the first occurrence of any of the
   // following: the next end of block, the next OpLine instruction, or the next
   // OpNoLine instruction."
   if (operands.size() != 3)
     return emitError(unknownLoc, "OpLine must have 3 operands");
-  debugLine = DebugLine(operands[0], operands[1], operands[2]);
+  debugLine = DebugLine{operands[0], operands[1], operands[2]};
   return success();
 }
 
 void spirv::Deserializer::clearDebugLine() { debugLine = llvm::None; }
 
 LogicalResult
 spirv::Deserializer::processDebugString(ArrayRef<uint32_t> operands) {
   if (operands.size() < 2)