[mlir][Transform] NFC - Add more advanced debug spew to help hunt down potential misuses

mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp

 #include "mlir/IR/Operation.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 
 #define DEBUG_TYPE "transform-dialect"
+#define DEBUG_TYPE_FULL "transform-dialect-full"
 #define DEBUG_PRINT_AFTER_ALL "transform-dialect-print-top-level-after-all"
 #define DBGS() (llvm::dbgs() << "[" DEBUG_TYPE "] ")
+#define LDBG(X) LLVM_DEBUG(DBGS() << (X))
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // TransformState
 //===----------------------------------------------------------------------===//
 
 constexpr const Value transform::TransformState::kTopLevelValue;

 void transform::TransformState::recordOpHandleInvalidationOne(
     OpOperand &consumingHandle, ArrayRef<Operation *> potentialAncestors,
     Operation *payloadOp, Value otherHandle, Value throughValue) {
   // If the op is associated with invalidated handle, skip the check as it
   // may be reading invalid IR.
   if (invalidatedHandles.count(otherHandle))
     return;
 
+  LDBG("--recordOpHandleInvalidationOne\n");
+  LLVM_DEBUG(llvm::interleaveComma(potentialAncestors,
+                                   DBGS() << "--ancestors: ",
+                                   [](Operation *op) { llvm::dbgs() << *op; });
+             llvm::dbgs() << "\n");
   for (Operation *ancestor : potentialAncestors) {
+    LLVM_DEBUG(DBGS() << "----handle one ancestor: " << *ancestor << "\n");
+    LLVM_DEBUG(DBGS() << "----of payload with name: "
+                      << payloadOp->getName().getIdentifier() << "\n");
+    DEBUG_WITH_TYPE(DEBUG_TYPE_FULL,
+                    { (DBGS() << "----of payload: " << *payloadOp << "\n"); });
     if (!ancestor->isAncestor(payloadOp))
       continue;
 
     // Make sure the error-reporting lambda doesn't capture anything
     // by-reference because it will go out of scope. Additionally, extract
     // location from Payload IR ops because the ops themselves may be
     // deleted before the lambda gets called.
     Location ancestorLoc = ancestor->getLoc();
if (auto opResult = payloadValue.dyn_cast<OpResult>()) {
       for (Operation &payloadOp : *arg.getOwner())
         recordOpHandleInvalidation(valueHandle, &payloadOp, payloadValue);
     }
   }
 }
 
 LogicalResult transform::TransformState::checkAndRecordHandleInvalidation(
     TransformOpInterface transform) {
+  LDBG("--Start checkAndRecordHandleInvalidation\n");
   auto memoryEffectsIface =
       cast<MemoryEffectOpInterface>(transform.getOperation());
   SmallVector<MemoryEffects::EffectInstance> effects;
   memoryEffectsIface.getEffectsOnResource(
       transform::TransformMappingResource::get(), effects);
 
   for (OpOperand &target : transform->getOpOperands()) {
+    LLVM_DEBUG(DBGS() << "----iterate on handle: " << target.get() << "\n");
     // If the operand uses an invalidated handle, report it.
     auto it = invalidatedHandles.find(target.get());
     if (!transform.allowsRepeatedHandleOperands() &&
-        it != invalidatedHandles.end())
+        it != invalidatedHandles.end()) {
+      LLVM_DEBUG(
+          DBGS() << "--End checkAndRecordHandleInvalidation -> FAILURE\n");
       return it->getSecond()(transform->getLoc()), failure();
+    }
 
     // Invalidate handles pointing to the operations nested in the operation
     // associated with the handle consumed by this operation.
     auto consumesTarget = [&](const MemoryEffects::EffectInstance &effect) {
       return isa<MemoryEffects::Free>(effect.getEffect()) &&
              effect.getValue() == target.get();
     };
     if (llvm::any_of(effects, consumesTarget)) {
+      LLVM_DEBUG(DBGS() << "----found consume effect -> SKIP\n");
       if (target.get().getType().isa<TransformHandleTypeInterface>()) {
+        LDBG("----recordOpHandleInvalidation\n");
         ArrayRef<Operation *> payloadOps = getPayloadOps(target.get());
         recordOpHandleInvalidation(target, payloadOps);
       } else if (target.get()
                      .getType()
                      .isa<TransformValueHandleTypeInterface>()) {
+        LDBG("----recordValueHandleInvalidation\n");
         recordValueHandleInvalidation(target);
+      } else {
+        LDBG("----not a TransformHandle -> SKIP AND DROP ON THE FLOOR\n");
       }
+    } else {
+      LLVM_DEBUG(DBGS() << "----no consume effect -> SKIP\n");
     }
   }
 
+  LDBG("--End checkAndRecordHandleInvalidation -> SUCCESS\n");
   return success();
 }
 
 template <typename T>
 DiagnosedSilenceableFailure
 checkRepeatedConsumptionInOperand(ArrayRef<T> payload,
                                   transform::TransformOpInterface transform,
                                   unsigned operandNumber) {
if (!seen.insert(p).second) {
       return diag;
     }
   }
   return DiagnosedSilenceableFailure::success();
 }
 
 DiagnosedSilenceableFailure
 transform::TransformState::applyTransform(TransformOpInterface transform) {
-  LLVM_DEBUG(DBGS() << "applying: " << transform << "\n");
+  LLVM_DEBUG(DBGS() << "\n"; DBGS() << "applying: " << transform << "\n");
   auto printOnFailureRAII = llvm::make_scope_exit([this] {
     (void)this;
     DEBUG_WITH_TYPE(DEBUG_PRINT_AFTER_ALL, {
       DBGS() << "Top-level payload:\n";
       getTopLevel()->print(llvm::dbgs(),
                            mlir::OpPrintingFlags().printGenericOpForm());
     });
   });
   if (options.getExpensiveChecksEnabled()) {
+    LDBG("ExpensiveChecksEnabled\n");
     if (failed(checkAndRecordHandleInvalidation(transform)))
       return DiagnosedSilenceableFailure::definiteFailure();
 
     for (OpOperand &operand : transform->getOpOperands()) {
-      if (!isHandleConsumed(operand.get(), transform))
+      LLVM_DEBUG(DBGS() << "iterate on handle: " << operand.get() << "\n");
+      if (!isHandleConsumed(operand.get(), transform)) {
+        LDBG("--handle not consumed -> SKIP\n");
         continue;
+      }
+      LDBG("--handle is consumed\n");
 
       Type operandType = operand.get().getType();
       if (operandType.isa<TransformHandleTypeInterface>()) {
+        LLVM_DEBUG(
+            DBGS() << "--checkRepeatedConsumptionInOperand for Operation*\n");
         DiagnosedSilenceableFailure check =
             checkRepeatedConsumptionInOperand<Operation *>(
                 getPayloadOps(operand.get()), transform,
                 operand.getOperandNumber());
-        if (!check.succeeded())
+        if (!check.succeeded()) {
+          LDBG("----FAILED\n");
           return check;
+        }
       } else if (operandType.isa<TransformValueHandleTypeInterface>()) {
+        LDBG("--checkRepeatedConsumptionInOperand For Value\n");
         DiagnosedSilenceableFailure check =
             checkRepeatedConsumptionInOperand<Value>(
                 getPayloadValues(operand.get()), transform,
                 operand.getOperandNumber());
-        if (!check.succeeded())
+        if (!check.succeeded()) {
+          LDBG("----FAILED\n");
           return check;
         }
+      } else {
+        LDBG("--not a TransformHandle -> SKIP AND DROP ON THE FLOOR\n");
+      }
     }
   }
 
   // Find which operands are consumed.
   DenseSet<unsigned> consumedOperands;
   auto memEffectInterface =
       cast<MemoryEffectOpInterface>(transform.getOperation());
   SmallVector<MemoryEffects::EffectInstance, 2> effects;