Fixes a bug in finding the upcoming store/conditional branch instruction

[oota-llvm.git] / lib / IR / Verifier.cpp

diff --git a/lib/IR/Verifier.cpp b/lib/IR/Verifier.cpp
index 1557ca0dbb78821bfecf64e093cf521ce7da1e35..ba6bbb1f637ff586fda4ae93a149000b0909d1c3 100644 (file)
--- a/lib/IR/Verifier.cpp
+++ b/lib/IR/Verifier.cpp
@@ -446,7 +446,8 @@ private:
   // Module-level debug info verification...
   void verifyTypeRefs();
   template <class MapTy>
-  void verifyDIExpression(const DbgInfoIntrinsic &I, const MapTy &TypeRefs);
+  void verifyBitPieceExpression(const DbgInfoIntrinsic &I,
+                                const MapTy &TypeRefs);
   void visitUnresolvedTypeRef(const MDString *S, const MDNode *N);
 };
 } // End anonymous namespace
@@ -3353,6 +3354,9 @@ void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
   }
 
   const Use &U = I.getOperandUse(i);
+  if (!(InstsInThisBlock.count(Op) || DT.dominates(Op, U))) {
+    i = *((unsigned*) nullptr);
+  }
   Assert(InstsInThisBlock.count(Op) || DT.dominates(Op, U),
          "Instruction does not dominate all uses!", Op, &I);
 }
@@ -4087,34 +4091,15 @@ static uint64_t getVariableSize(const DILocalVariable &V, const MapTy &Map) {
 }
 
 template <class MapTy>
-void Verifier::verifyDIExpression(const DbgInfoIntrinsic &I,
-                                  const MapTy &TypeRefs) {
+void Verifier::verifyBitPieceExpression(const DbgInfoIntrinsic &I,
+                                        const MapTy &TypeRefs) {
   DILocalVariable *V;
   DIExpression *E;
-  const Value *Arg;
-  uint64_t ArgumentTypeSizeInBits = 0;
   if (auto *DVI = dyn_cast<DbgValueInst>(&I)) {
-    Arg = DVI->getValue();
-    if (Arg)
-      ArgumentTypeSizeInBits =
-          M->getDataLayout().getTypeAllocSizeInBits(Arg->getType());
     V = dyn_cast_or_null<DILocalVariable>(DVI->getRawVariable());
     E = dyn_cast_or_null<DIExpression>(DVI->getRawExpression());
   } else {
     auto *DDI = cast<DbgDeclareInst>(&I);
-    // For declare intrinsics, get the total size of the alloca, to allow
-    // case where the variable may span more than one element.
-    Arg = DDI->getAddress();
-    if (Arg)
-      Arg = Arg->stripPointerCasts();
-    const AllocaInst *AI = dyn_cast_or_null<AllocaInst>(Arg);
-    if (AI) {
-      // We can only say something about constant size allocations
-      if (const ConstantInt *CI = dyn_cast<ConstantInt>(AI->getArraySize()))
-        ArgumentTypeSizeInBits =
-            CI->getLimitedValue() *
-            M->getDataLayout().getTypeAllocSizeInBits(AI->getAllocatedType());
-    }
     V = dyn_cast_or_null<DILocalVariable>(DDI->getRawVariable());
     E = dyn_cast_or_null<DIExpression>(DDI->getRawExpression());
   }
@@ -4123,6 +4108,10 @@ void Verifier::verifyDIExpression(const DbgInfoIntrinsic &I,
   if (!V || !E || !E->isValid())
     return;
 
+  // Nothing to do if this isn't a bit piece expression.
+  if (!E->isBitPiece())
+    return;
+
   // The frontend helps out GDB by emitting the members of local anonymous
   // unions as artificial local variables with shared storage. When SROA splits
   // the storage for artificial local variables that are smaller than the entire
@@ -4138,33 +4127,11 @@ void Verifier::verifyDIExpression(const DbgInfoIntrinsic &I,
   if (!VarSize)
     return;
 
-  if (E->isBitPiece()) {
-    unsigned PieceSize = E->getBitPieceSize();
-    unsigned PieceOffset = E->getBitPieceOffset();
-    Assert(PieceSize + PieceOffset <= VarSize,
-           "piece is larger than or outside of variable", &I, V, E);
-    Assert(PieceSize != VarSize, "piece covers entire variable", &I, V, E);
-    return;
-  }
-
-  if (!ArgumentTypeSizeInBits)
-    return; // We were unable to determine the size of the argument
-
-  if (E->getNumElements() == 0) {
-    // In the case where the expression is empty, verify the size of the
-    // argument. Doing this in the general case would require looking through
-    // any dereferences that may be in the expression.
-    Assert(ArgumentTypeSizeInBits == VarSize,
-           "size of passed value (" + utostr(ArgumentTypeSizeInBits) +
-               ") does not match size of declared variable (" +
-               utostr(VarSize) + ")",
-           &I, Arg, V, V->getType(), E);
-  } else if (E->getElement(0) == dwarf::DW_OP_deref) {
-    Assert(ArgumentTypeSizeInBits == M->getDataLayout().getPointerSizeInBits(),
-           "the operation of the expression is a deref, but the passed value "
-           "is not pointer sized",
-           &I, Arg, V, V->getType(), E);
-  }
+  unsigned PieceSize = E->getBitPieceSize();
+  unsigned PieceOffset = E->getBitPieceOffset();
+  Assert(PieceSize + PieceOffset <= VarSize,
+         "piece is larger than or outside of variable", &I, V, E);
+  Assert(PieceSize != VarSize, "piece covers entire variable", &I, V, E);
 }
 
 void Verifier::visitUnresolvedTypeRef(const MDString *S, const MDNode *N) {
@@ -4197,7 +4164,7 @@ void Verifier::verifyTypeRefs() {
     for (const BasicBlock &BB : F)
       for (const Instruction &I : BB)
         if (auto *DII = dyn_cast<DbgInfoIntrinsic>(&I))
-          verifyDIExpression(*DII, TypeRefs);
+          verifyBitPieceExpression(*DII, TypeRefs);
 
   // Return early if all typerefs were resolved.
   if (UnresolvedTypeRefs.empty())