Revert "[DebugInfo] Recover debug intrinsics when killing duplicated/empty basic blocks"

This reverts commit 72ce759928e6dfee6a9efa310b966c19722352ba.

Reverted due to build failure.

2 files changed, 22 insertions, 64 deletions

diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp
index 94edf8ccab8..eaccaa1c4ac 100644
--- a/llvm/lib/Transforms/Utils/Local.cpp
+++ b/llvm/lib/Transforms/Utils/Local.cpp
@@ -485,19 +485,15 @@ void llvm::RecursivelyDeleteTriviallyDeadInstructions(
     I.eraseFromParent();
   }
 }
-void llvm::setDbgVariableUndef(DbgVariableIntrinsic *DVI) {
-  Value *DbgValue = DVI->getVariableLocation(false);
-  Value *Undef = UndefValue::get(DbgValue ? DbgValue->getType()
-                                          : Type::getInt1Ty(DVI->getContext()));
-  DVI->setOperand(
-      0, MetadataAsValue::get(DVI->getContext(), ValueAsMetadata::get(Undef)));
-}
 
 bool llvm::replaceDbgUsesWithUndef(Instruction *I) {
   SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
   findDbgUsers(DbgUsers, I);
-  for (auto *DII : DbgUsers)
-    setDbgVariableUndef(DII);
+  for (auto *DII : DbgUsers) {
+    Value *Undef = UndefValue::get(I->getType());
+    DII->setOperand(0, MetadataAsValue::get(DII->getContext(),
+                                            ValueAsMetadata::get(Undef)));
+  }
   return !DbgUsers.empty();
 }
 
@@ -1044,19 +1040,6 @@ bool llvm::TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB,
       assert(PN->use_empty() && "There shouldn't be any uses here!");
       PN->eraseFromParent();
     }
-    // If Succ has multiple predecessors, each debug intrinsic in BB may or may
-    // not be valid when we reach Succ, so the debug variable should be set
-    // undef since its value is unknown.
-    Instruction *DbgInsertPoint = Succ->getFirstNonPHI();
-    while (DbgInfoIntrinsic *DI = dyn_cast<DbgInfoIntrinsic>(&BB->front())) {
-      if (auto DVI = cast<DbgVariableIntrinsic>(DI)) {
-        if (!isa<DbgDeclareInst>(DVI))
-          setDbgVariableUndef(DVI);
-        DVI->moveBefore(DbgInsertPoint);
-      } else {
-        break;
-      }
-    }
   }
 
   // If the unconditional branch we replaced contains llvm.loop metadata, we
diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
index fe47f6bde21..79d4857c2c8 100644
--- a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -13,7 +13,6 @@
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
@@ -39,7 +38,6 @@
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
-#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
@@ -1252,38 +1250,14 @@ static bool HoistThenElseCodeToIf(BranchInst *BI,
 
   Instruction *I1 = &*BB1_Itr++, *I2 = &*BB2_Itr++;
   // Skip debug info if it is not identical.
-
-  // If the terminator instruction is hoisted, and any variable locations have
-  // non-identical debug intrinsics, then those variable locations must be set
-  // as undef.
-  // FIXME: If each block contains identical debug variable intrinsics in a
-  // different order, they will be considered non-identical and be dropped.
-  MapVector<DebugVariable, DbgVariableIntrinsic *> UndefDVIs;
-
-  auto SkipDbgInfo = [&UndefDVIs](Instruction *&I,
-                                  BasicBlock::iterator &BB_Itr) {
-    while (isa<DbgInfoIntrinsic>(I)) {
-      if (DbgVariableIntrinsic *DVI = dyn_cast<DbgVariableIntrinsic>(I))
-        UndefDVIs.insert(
-            {DebugVariable(DVI->getVariable(), DVI->getExpression(),
-                           DVI->getDebugLoc()->getInlinedAt()),
-             DVI});
-      I = &*BB_Itr++;
-    }
-  };
-
-  auto SkipNonIdenticalDbgInfo =
-      [&BB1_Itr, &BB2_Itr, &SkipDbgInfo](Instruction *&I1, Instruction *&I2) {
-        DbgInfoIntrinsic *DBI1 = dyn_cast<DbgInfoIntrinsic>(I1);
-        DbgInfoIntrinsic *DBI2 = dyn_cast<DbgInfoIntrinsic>(I2);
-        if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) {
-          SkipDbgInfo(I1, BB1_Itr);
-          SkipDbgInfo(I2, BB2_Itr);
-        }
-      };
-
-  SkipNonIdenticalDbgInfo(I1, I2);
-
+  DbgInfoIntrinsic *DBI1 = dyn_cast<DbgInfoIntrinsic>(I1);
+  DbgInfoIntrinsic *DBI2 = dyn_cast<DbgInfoIntrinsic>(I2);
+  if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) {
+    while (isa<DbgInfoIntrinsic>(I1))
+      I1 = &*BB1_Itr++;
+    while (isa<DbgInfoIntrinsic>(I2))
+      I2 = &*BB2_Itr++;
+  }
   // FIXME: Can we define a safety predicate for CallBr?
   if (isa<PHINode>(I1) || !I1->isIdenticalToWhenDefined(I2) ||
       (isa<InvokeInst>(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2)) ||
@@ -1356,7 +1330,15 @@ static bool HoistThenElseCodeToIf(BranchInst *BI,
 
     I1 = &*BB1_Itr++;
     I2 = &*BB2_Itr++;
-    SkipNonIdenticalDbgInfo(I1, I2);
+    // Skip debug info if it is not identical.
+    DbgInfoIntrinsic *DBI1 = dyn_cast<DbgInfoIntrinsic>(I1);
+    DbgInfoIntrinsic *DBI2 = dyn_cast<DbgInfoIntrinsic>(I2);
+    if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) {
+      while (isa<DbgInfoIntrinsic>(I1))
+        I1 = &*BB1_Itr++;
+      while (isa<DbgInfoIntrinsic>(I2))
+        I2 = &*BB2_Itr++;
+    }
   } while (I1->isIdenticalToWhenDefined(I2));
 
   return true;
@@ -1392,13 +1374,6 @@ HoistTerminator:
   }
 
   // Okay, it is safe to hoist the terminator.
-  for (auto DIVariableInst : UndefDVIs) {
-    DbgVariableIntrinsic *DVI = DIVariableInst.second;
-    DVI->moveBefore(BI);
-    if (DVI->getVariableLocation())
-      setDbgVariableUndef(DVI);
-  }
-
   Instruction *NT = I1->clone();
   BIParent->getInstList().insert(BI->getIterator(), NT);
   if (!NT->getType()->isVoidTy()) {