[NFC] SIL: Typed debug_value.poisonRefs.

nate-chandler · nate-chandler · commit 91fe12aab437 · 2024-07-03T14:53:30.000-07:00
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -1072,7 +1072,7 @@ class SILBuilder {
 
   DebugValueInst *createDebugValue(
       SILLocation Loc, SILValue src, SILDebugVariable Var,
-      bool poisonRefs = false,
+      PoisonRefs_t poisonRefs = DontPoisonRefs,
       UsesMoveableValueDebugInfo_t wasMoved = DoesNotUseMoveableValueDebugInfo,
       bool trace = false);
   DebugValueInst *createDebugValueAddr(
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -5402,11 +5402,11 @@ class DebugValueInst final
   USE_SHARED_UINT8;
 
   DebugValueInst(SILDebugLocation DebugLoc, SILValue Operand,
-                 SILDebugVariable Var, bool poisonRefs,
+                 SILDebugVariable Var, PoisonRefs_t poisonRefs,
                  UsesMoveableValueDebugInfo_t operandWasMoved, bool trace);
   static DebugValueInst *create(SILDebugLocation DebugLoc, SILValue Operand,
                                 SILModule &M, SILDebugVariable Var,
-                                bool poisonRefs,
+                                PoisonRefs_t poisonRefs,
                                 UsesMoveableValueDebugInfo_t operandWasMoved,
                                 bool trace);
   static DebugValueInst *createAddr(SILDebugLocation DebugLoc, SILValue Operand,
@@ -5516,9 +5516,11 @@ class DebugValueInst final
   /// OSSA lowering. It should not be necessary to model the poison operation as
   /// a side effect, which would violate the rule that debug_values cannot
   /// affect optimization.
-  bool poisonRefs() const { return sharedUInt8().DebugValueInst.poisonRefs; }
+  PoisonRefs_t poisonRefs() const {
+    return PoisonRefs_t(sharedUInt8().DebugValueInst.poisonRefs);
+  }
 
-  void setPoisonRefs(bool poisonRefs = true) {
+  void setPoisonRefs(PoisonRefs_t poisonRefs = PoisonRefs) {
     sharedUInt8().DebugValueInst.poisonRefs = poisonRefs;
   }
 
diff --git a/lib/SIL/IR/SILBuilder.cpp b/lib/SIL/IR/SILBuilder.cpp
@@ -635,7 +635,7 @@ void SILBuilder::emitDestructureValueOperation(
 
 DebugValueInst *SILBuilder::createDebugValue(SILLocation Loc, SILValue src,
                                              SILDebugVariable Var,
-                                             bool poisonRefs,
+                                             PoisonRefs_t poisonRefs,
                                              UsesMoveableValueDebugInfo_t moved,
                                              bool trace) {
   if (shouldDropVariable(Var, Loc))
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -436,8 +436,8 @@ SILType AllocBoxInst::getAddressType() const {
 
 DebugValueInst::DebugValueInst(
     SILDebugLocation DebugLoc, SILValue Operand, SILDebugVariable Var,
-    bool poisonRefs, UsesMoveableValueDebugInfo_t usesMoveableValueDebugInfo,
-    bool trace)
+    PoisonRefs_t poisonRefs,
+    UsesMoveableValueDebugInfo_t usesMoveableValueDebugInfo, bool trace)
     : UnaryInstructionBase(DebugLoc, Operand),
       SILDebugVariableSupplement(Var.DIExpr.getNumElements(),
                                  Var.Type.has_value(), Var.Loc.has_value(),
@@ -454,7 +454,8 @@ DebugValueInst::DebugValueInst(
 
 DebugValueInst *DebugValueInst::create(SILDebugLocation DebugLoc,
                                        SILValue Operand, SILModule &M,
-                                       SILDebugVariable Var, bool poisonRefs,
+                                       SILDebugVariable Var,
+                                       PoisonRefs_t poisonRefs,
                                        UsesMoveableValueDebugInfo_t wasMoved,
                                        bool trace) {
   // Don't store the same information twice.
@@ -478,8 +479,8 @@ DebugValueInst::createAddr(SILDebugLocation DebugLoc, SILValue Operand,
   if (!isa<AllocStackInst>(Operand))
     Var.DIExpr.prependElements(
       {SILDIExprElement::createOperator(SILDIExprOperator::Dereference)});
-  return DebugValueInst::create(DebugLoc, Operand, M, Var,
-                                /*poisonRefs=*/false, wasMoved, trace);
+  return DebugValueInst::create(DebugLoc, Operand, M, Var, DontPoisonRefs,
+                                wasMoved, trace);
 }
 
 bool DebugValueInst::exprStartsWithDeref() const {
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -3391,7 +3391,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
   }
 
   case SILInstructionKind::DebugValueInst: {
-    bool poisonRefs = false;
+    PoisonRefs_t poisonRefs = DontPoisonRefs;
     bool hasTrace = false;
     UsesMoveableValueDebugInfo_t usesMoveableValueDebugInfo =
         DoesNotUseMoveableValueDebugInfo;
@@ -3402,7 +3402,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     SourceLoc attributeLoc;
     while (parseSILOptional(attributeName, attributeLoc, *this)) {
       if (attributeName == "poison")
-        poisonRefs = true;
+        poisonRefs = PoisonRefs;
       else if (attributeName == "trace")
         hasTrace = true;
       else if (attributeName == "moveable_value_debuginfo")
diff --git a/lib/SILOptimizer/Mandatory/ConsumeOperatorCopyableAddressesChecker.cpp b/lib/SILOptimizer/Mandatory/ConsumeOperatorCopyableAddressesChecker.cpp
@@ -1529,7 +1529,7 @@ bool DataflowState::cleanupAllDestroyAddr(
               addressDebugInst->getDebugScope());
           dbgValueInsertBuilder.createDebugValue(
               (*addressDebugInst)->getLoc(), SILUndef::get(address), *varInfo,
-              false, UsesMoveableValueDebugInfo);
+              DontPoisonRefs, UsesMoveableValueDebugInfo);
         }
       }
       useState.destroys.insert(dvi);
@@ -1569,7 +1569,7 @@ bool DataflowState::cleanupAllDestroyAddr(
         SILBuilderWithScope reinitBuilder((*reinit)->getNextInstruction());
         reinitBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());
         reinitBuilder.createDebugValue((*addressDebugInst)->getLoc(), address,
-                                       *varInfo, false,
+                                       *varInfo, DontPoisonRefs,
                                        UsesMoveableValueDebugInfo);
       }
     }
@@ -1821,7 +1821,7 @@ bool DataflowState::process(
           undefBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());
           undefBuilder.createDebugValue(
               addressDebugInst->getLoc(), SILUndef::get(address), *varInfo,
-              false /*poison*/, UsesMoveableValueDebugInfo);
+              DontPoisonRefs, UsesMoveableValueDebugInfo);
         }
       }
 
@@ -2202,9 +2202,9 @@ bool ConsumeOperatorCopyableAddressesChecker::performSingleBasicBlockAnalysis(
       if (auto varInfo = addressDebugInst.getVarInfo()) {
         SILBuilderWithScope undefBuilder(builder);
         undefBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());
-        undefBuilder.createDebugValue(addressDebugInst->getLoc(),
-                                      SILUndef::get(address), *varInfo, false,
-                                      UsesMoveableValueDebugInfo);
+        undefBuilder.createDebugValue(
+            addressDebugInst->getLoc(), SILUndef::get(address), *varInfo,
+            DontPoisonRefs, UsesMoveableValueDebugInfo);
       }
       addressDebugInst.markAsMoved();
     }
@@ -2319,9 +2319,9 @@ bool ConsumeOperatorCopyableAddressesChecker::performSingleBasicBlockAnalysis(
         {
           SILBuilderWithScope undefBuilder(builder);
           undefBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());
-          undefBuilder.createDebugValue(addressDebugInst->getLoc(),
-                                        SILUndef::get(address), *varInfo, false,
-                                        UsesMoveableValueDebugInfo);
+          undefBuilder.createDebugValue(
+              addressDebugInst->getLoc(), SILUndef::get(address), *varInfo,
+              DontPoisonRefs, UsesMoveableValueDebugInfo);
         }
         {
           // Make sure at the reinit point to create a new debug value after the
@@ -2330,7 +2330,7 @@ bool ConsumeOperatorCopyableAddressesChecker::performSingleBasicBlockAnalysis(
           SILBuilderWithScope reinitBuilder(next);
           reinitBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());
           reinitBuilder.createDebugValue(addressDebugInst->getLoc(), address,
-                                         *varInfo, false,
+                                         *varInfo, DontPoisonRefs,
                                          UsesMoveableValueDebugInfo);
         }
       }
@@ -2369,9 +2369,9 @@ bool ConsumeOperatorCopyableAddressesChecker::performSingleBasicBlockAnalysis(
       if (auto varInfo = addressDebugInst.getVarInfo()) {
         SILBuilderWithScope undefBuilder(builder);
         undefBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());
-        undefBuilder.createDebugValue(addressDebugInst->getLoc(),
-                                      SILUndef::get(address), *varInfo, false,
-                                      UsesMoveableValueDebugInfo);
+        undefBuilder.createDebugValue(
+            addressDebugInst->getLoc(), SILUndef::get(address), *varInfo,
+            DontPoisonRefs, UsesMoveableValueDebugInfo);
       }
       addressDebugInst.markAsMoved();
     }
diff --git a/lib/SILOptimizer/Mandatory/ConsumeOperatorCopyableValuesChecker.cpp b/lib/SILOptimizer/Mandatory/ConsumeOperatorCopyableValuesChecker.cpp
@@ -512,7 +512,7 @@ bool ConsumeOperatorCopyableValuesChecker::check() {
             builder.setCurrentDebugScope(dbgVarInst->getDebugScope());
             builder.createDebugValue(
                 dbgVarInst->getLoc(), SILUndef::get(mvi->getOperand()),
-                *varInfo, false /*poison*/, UsesMoveableValueDebugInfo);
+                *varInfo, DontPoisonRefs, UsesMoveableValueDebugInfo);
           }
           validMoves.push_back(mvi);
         }
diff --git a/lib/SILOptimizer/Mandatory/DebugInfoCanonicalizer.cpp b/lib/SILOptimizer/Mandatory/DebugInfoCanonicalizer.cpp
@@ -75,7 +75,7 @@ static SILInstruction *cloneDebugValue(DebugVarCarryingInst original,
   builder.setCurrentDebugScope(original->getDebugScope());
   return builder.createDebugValue(
       original->getLoc(), original.getOperandForDebugValueClone(),
-      *original.getVarInfo(), false, UsesMoveableValueDebugInfo);
+      *original.getVarInfo(), DontPoisonRefs, UsesMoveableValueDebugInfo);
 }
 
 static SILInstruction *cloneDebugValue(DebugVarCarryingInst original,
@@ -84,7 +84,7 @@ static SILInstruction *cloneDebugValue(DebugVarCarryingInst original,
   builder.setCurrentDebugScope(original->getDebugScope());
   return builder.createDebugValue(
       original->getLoc(), original.getOperandForDebugValueClone(),
-      *original.getVarInfo(), false, UsesMoveableValueDebugInfo);
+      *original.getVarInfo(), DontPoisonRefs, UsesMoveableValueDebugInfo);
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp b/lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp
@@ -323,7 +323,7 @@ static void insertDebugValueBefore(SILInstruction *insertPt,
   SILBuilderWithScope debugInfoBuilder(insertPt);
   debugInfoBuilder.setCurrentDebugScope(debugVar->getDebugScope());
   debugInfoBuilder.createDebugValue(debugVar->getLoc(), operand(), *varInfo,
-                                    false, UsesMoveableValueDebugInfo);
+                                    DontPoisonRefs, UsesMoveableValueDebugInfo);
 }
 
 static void convertMemoryReinitToInitForm(SILInstruction *memInst,
diff --git a/lib/SILOptimizer/Mandatory/MovedAsyncVarDebugInfoPropagator.cpp b/lib/SILOptimizer/Mandatory/MovedAsyncVarDebugInfoPropagator.cpp
@@ -96,7 +96,7 @@ cloneDebugValueMakeUndef(DebugVarCarryingInst original, SILBasicBlock *block) {
   builder.setCurrentDebugScope(original->getDebugScope());
   auto *undef = SILUndef::get(original.getOperandForDebugValueClone());
   return builder.createDebugValue(original->getLoc(), undef,
-                                  *original.getVarInfo(), false,
+                                  *original.getVarInfo(), DontPoisonRefs,
                                   UsesMoveableValueDebugInfo);
 }
 
@@ -107,7 +107,7 @@ cloneDebugValueMakeUndef(DebugVarCarryingInst original,
   builder.setCurrentDebugScope(original->getDebugScope());
   auto *undef = SILUndef::get(original.getOperandForDebugValueClone());
   return builder.createDebugValue(original->getLoc(), undef,
-                                  *original.getVarInfo(), false,
+                                  *original.getVarInfo(), DontPoisonRefs,
                                   UsesMoveableValueDebugInfo);
 }
 
@@ -120,7 +120,7 @@ static SILInstruction *cloneDebugValue(DebugVarCarryingInst original,
   builder.setCurrentDebugScope(original->getDebugScope());
   return builder.createDebugValue(
       original->getLoc(), original.getOperandForDebugValueClone(),
-      *original.getVarInfo(), false, UsesMoveableValueDebugInfo);
+      *original.getVarInfo(), DontPoisonRefs, UsesMoveableValueDebugInfo);
 }
 
 static SILInstruction *cloneDebugValue(DebugVarCarryingInst original,
@@ -132,7 +132,7 @@ static SILInstruction *cloneDebugValue(DebugVarCarryingInst original,
   builder.setCurrentDebugScope(original->getDebugScope());
   return builder.createDebugValue(
       original->getLoc(), original.getOperandForDebugValueClone(),
-      *original.getVarInfo(), false, UsesMoveableValueDebugInfo);
+      *original.getVarInfo(), DontPoisonRefs, UsesMoveableValueDebugInfo);
 }
 
 namespace {
diff --git a/lib/SILOptimizer/Mandatory/OwnershipModelEliminator.cpp b/lib/SILOptimizer/Mandatory/OwnershipModelEliminator.cpp
@@ -455,8 +455,8 @@ static void injectDebugPoison(DestroyValueInst *destroy) {
     // This debug location is obviously inconsistent with surrounding code, but
     // IRGen is responsible for fixing this.
     builder.setCurrentDebugScope(scope);
-    auto *newDebugVal = builder.createDebugValue(loc, destroyedValue, *varInfo,
-                                                 /*poisonRefs*/ true);
+    auto *newDebugVal =
+        builder.createDebugValue(loc, destroyedValue, *varInfo, PoisonRefs);
     assert(*(newDebugVal->getVarInfo()) == *varInfo && "lost in translation");
     (void)newDebugVal;
   }

Original file line number	Diff line number	Diff line change
`@@ -1529,7 +1529,7 @@ bool DataflowState::cleanupAllDestroyAddr(`
`1529`	`1529`	`addressDebugInst->getDebugScope());`
`1530`	`1530`	`dbgValueInsertBuilder.createDebugValue(`
`1531`	`1531`	`(addressDebugInst)->getLoc(), SILUndef::get(address), varInfo,`
`1532`		`- false, UsesMoveableValueDebugInfo);`
	`1532`	`+ DontPoisonRefs, UsesMoveableValueDebugInfo);`
`1533`	`1533`	`}`
`1534`	`1534`	`}`
`1535`	`1535`	`useState.destroys.insert(dvi);`
`@@ -1569,7 +1569,7 @@ bool DataflowState::cleanupAllDestroyAddr(`
`1569`	`1569`	`SILBuilderWithScope reinitBuilder((*reinit)->getNextInstruction());`
`1570`	`1570`	`reinitBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());`
`1571`	`1571`	`reinitBuilder.createDebugValue((*addressDebugInst)->getLoc(), address,`
`1572`		`- *varInfo, false,`
	`1572`	`+ *varInfo, DontPoisonRefs,`
`1573`	`1573`	`UsesMoveableValueDebugInfo);`
`1574`	`1574`	`}`
`1575`	`1575`	`}`
`@@ -1821,7 +1821,7 @@ bool DataflowState::process(`
`1821`	`1821`	`undefBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());`
`1822`	`1822`	`undefBuilder.createDebugValue(`
`1823`	`1823`	`addressDebugInst->getLoc(), SILUndef::get(address), *varInfo,`
`1824`		`- false /poison/, UsesMoveableValueDebugInfo);`
	`1824`	`+ DontPoisonRefs, UsesMoveableValueDebugInfo);`
`1825`	`1825`	`}`
`1826`	`1826`	`}`
`1827`	`1827`
`@@ -2202,9 +2202,9 @@ bool ConsumeOperatorCopyableAddressesChecker::performSingleBasicBlockAnalysis(`
`2202`	`2202`	`if (auto varInfo = addressDebugInst.getVarInfo()) {`
`2203`	`2203`	`SILBuilderWithScope undefBuilder(builder);`
`2204`	`2204`	`undefBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());`
`2205`		`- undefBuilder.createDebugValue(addressDebugInst->getLoc(),`
`2206`		`- SILUndef::get(address), *varInfo, false,`
`2207`		`- UsesMoveableValueDebugInfo);`
	`2205`	`+ undefBuilder.createDebugValue(`
	`2206`	`+ addressDebugInst->getLoc(), SILUndef::get(address), *varInfo,`
	`2207`	`+ DontPoisonRefs, UsesMoveableValueDebugInfo);`
`2208`	`2208`	`}`
`2209`	`2209`	`addressDebugInst.markAsMoved();`
`2210`	`2210`	`}`
`@@ -2319,9 +2319,9 @@ bool ConsumeOperatorCopyableAddressesChecker::performSingleBasicBlockAnalysis(`
`2319`	`2319`	`{`
`2320`	`2320`	`SILBuilderWithScope undefBuilder(builder);`
`2321`	`2321`	`undefBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());`
`2322`		`- undefBuilder.createDebugValue(addressDebugInst->getLoc(),`
`2323`		`- SILUndef::get(address), *varInfo, false,`
`2324`		`- UsesMoveableValueDebugInfo);`
	`2322`	`+ undefBuilder.createDebugValue(`
	`2323`	`+ addressDebugInst->getLoc(), SILUndef::get(address), *varInfo,`
	`2324`	`+ DontPoisonRefs, UsesMoveableValueDebugInfo);`
`2325`	`2325`	`}`
`2326`	`2326`	`{`
`2327`	`2327`	`// Make sure at the reinit point to create a new debug value after the`
`@@ -2330,7 +2330,7 @@ bool ConsumeOperatorCopyableAddressesChecker::performSingleBasicBlockAnalysis(`
`2330`	`2330`	`SILBuilderWithScope reinitBuilder(next);`
`2331`	`2331`	`reinitBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());`
`2332`	`2332`	`reinitBuilder.createDebugValue(addressDebugInst->getLoc(), address,`
`2333`		`- *varInfo, false,`
	`2333`	`+ *varInfo, DontPoisonRefs,`
`2334`	`2334`	`UsesMoveableValueDebugInfo);`
`2335`	`2335`	`}`
`2336`	`2336`	`}`
`@@ -2369,9 +2369,9 @@ bool ConsumeOperatorCopyableAddressesChecker::performSingleBasicBlockAnalysis(`
`2369`	`2369`	`if (auto varInfo = addressDebugInst.getVarInfo()) {`
`2370`	`2370`	`SILBuilderWithScope undefBuilder(builder);`
`2371`	`2371`	`undefBuilder.setCurrentDebugScope(addressDebugInst->getDebugScope());`
`2372`		`- undefBuilder.createDebugValue(addressDebugInst->getLoc(),`
`2373`		`- SILUndef::get(address), *varInfo, false,`
`2374`		`- UsesMoveableValueDebugInfo);`
	`2372`	`+ undefBuilder.createDebugValue(`
	`2373`	`+ addressDebugInst->getLoc(), SILUndef::get(address), *varInfo,`
	`2374`	`+ DontPoisonRefs, UsesMoveableValueDebugInfo);`
`2375`	`2375`	`}`
`2376`	`2376`	`addressDebugInst.markAsMoved();`
`2377`	`2377`	`}`
Original file line number	Diff line number	Diff line change
`@@ -512,7 +512,7 @@ bool ConsumeOperatorCopyableValuesChecker::check() {`
`512`	`512`	`builder.setCurrentDebugScope(dbgVarInst->getDebugScope());`
`513`	`513`	`builder.createDebugValue(`
`514`	`514`	`dbgVarInst->getLoc(), SILUndef::get(mvi->getOperand()),`
`515`		`- varInfo, false /poison*/, UsesMoveableValueDebugInfo);`
	`515`	`+ *varInfo, DontPoisonRefs, UsesMoveableValueDebugInfo);`
`516`	`516`	`}`
`517`	`517`	`validMoves.push_back(mvi);`
`518`	`518`	`}`
Original file line number	Diff line number	Diff line change
`@@ -323,7 +323,7 @@ static void insertDebugValueBefore(SILInstruction *insertPt,`
`323`	`323`	`SILBuilderWithScope debugInfoBuilder(insertPt);`
`324`	`324`	`debugInfoBuilder.setCurrentDebugScope(debugVar->getDebugScope());`
`325`	`325`	`debugInfoBuilder.createDebugValue(debugVar->getLoc(), operand(), *varInfo,`
`326`		`- false, UsesMoveableValueDebugInfo);`
	`326`	`+ DontPoisonRefs, UsesMoveableValueDebugInfo);`
`327`	`327`	`}`
`328`	`328`
`329`	`329`	`static void convertMemoryReinitToInitForm(SILInstruction *memInst,`