[llvm][unittests] Fix protential nullptr dereferences due to unchecked return value or EXPECT_* macro

[OikawaKirie]

Summary

These problems are reported by my static analyzer on smart pointers.

In GTest, the ASSERT_* macro will stop the execution of the current test case or function, while EXPECT_* will not. Besides, If the ASSERT_* macro is used in a sub-function of a test case, it will only stop the execution of the current function and return to the caller test function. Although a test failure will be reported, the test program will still crash, which will skip some unit tests in the current test program. (See https://github.com/google/googletest/blob/master/googletest/docs/primer.md#basic-assertions)
In addition, in some test cases, the return value of a parser function is checked in a wrapper function, but both branches are allowed to reach the dereference site.

In this patch, I fixed some of the nullptr dereference with the problems above. The fix will not dismiss any check failures but can make the test program skip the current test case and continue with the next, rather than crash immediately.

[OikawaKirie]

Some of my fixes still need to be improved (see the comments in the code). If any reviewers have better ideas, I will update the patch.

Thanks.

llvm/unittests/Analysis/VectorFunctionABITest.cpp

76

Please note that. In function invokeParser, it will still crash after the call here. Since I do not know how to arrange a proper return value, I made no changes here. If any reviewers have any ideas about the problem, I will fix the problem here.

llvm/unittests/Transforms/IPO/AttributorTestBase.h

44

The same problem also appears here. It would be better if this function returns a pointer rather than a reference. But a lot of places related to it need to be changed. Therefore, I just leave it as it is.

[vsk]

Hi @OikawaKirie, thanks for the patch! Would you mind splitting up this patch? This should make each individual patch easier to review, and make it possible for changes to land incrementally (& faster). Generally we ask for patches to be split up into self-contained units: it's not an exact science, but splitting things up by directory might be a reasonable heuristic to start with.

[fhahn]

Marking as Request changes as there's an open suggestion by @vsk

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

llvm/unittests/Analysis/AssumeBundleQueriesTest.cpp

static void RunTest(
   for (auto &Elem : Tests) {
     std::string IR;
     IR.append(Head.begin(), Head.end());
     IR.append(Elem.first.begin(), Elem.first.end());
     IR.append(Tail.begin(), Tail.end());
     LLVMContext C;
     SMDiagnostic Err;
     std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
-    if (!Mod)
+    if (!Mod) {
       Err.print("AssumeQueryAPI", errs());
+      ADD_FAILURE() << "Unable to parse the assembly string";
+      continue;
+    }
     Elem.second(&*(Mod->getFunction("test")->begin()->begin()));
   }
 }
 
 bool hasMatchesExactlyAttributes(IntrinsicInst *Assume, Value *WasOn,
                                     StringRef AttrToMatch) {
   Regex Reg(AttrToMatch);
   SmallVector<StringRef, 1> Matches;
static void RunRandTest(uint64_t Seed, int Size, int MinCount, int MaxCount,
   std::random_device dev;
   std::mt19937 Rng(Seed);
   std::uniform_int_distribution<int> DistCount(MinCount, MaxCount);
   std::uniform_int_distribution<unsigned> DistValue(0, MaxValue);
   std::uniform_int_distribution<unsigned> DistAttr(0,
                                                    Attribute::EndAttrKinds - 1);
 
   std::unique_ptr<Module> Mod = std::make_unique<Module>("AssumeQueryAPI", C);
-  if (!Mod)
+  if (!Mod) {
     Err.print("AssumeQueryAPI", errs());
+    ADD_FAILURE() << "Unable to create Module";
+    return;
+  }
 
   std::vector<Type *> TypeArgs;
   for (int i = 0; i < (Size * 2); i++)
     TypeArgs.push_back(Type::getInt32PtrTy(C));
   FunctionType *FuncType =
       FunctionType::get(Type::getVoidTy(C), TypeArgs, false);
 
   Function *F =
std::unique_ptr<Module> Mod = parseAssemblyString(
       "declare void @llvm.assume(i1)\n"
       "define void @test(i32* %P, i32* %P1, i32* %P2, i32* %P3, i1 %B) {\n"
       "call void @llvm.assume(i1 true) [\"nonnull\"(i32* %P), \"align\"(i32* "
       "%P2, i32 4), \"align\"(i32* %P, i32 8)]\n"
       "call void @llvm.assume(i1 %B) [\"test\"(i32* %P1), "
       "\"dereferenceable\"(i32* %P, i32 4)]\n"
       "ret void\n}\n",
       Err, C);
-  if (!Mod)
+  if (!Mod) {
     Err.print("AssumeQueryAPI", errs());
+    FAIL() << "Unable to parse the assembly string";
+  }
   Function *F = Mod->getFunction("test");
   BasicBlock::iterator First = F->begin()->begin();
   BasicBlock::iterator Second = F->begin()->begin();
   Second++;
   AssumptionCacheTracker ACT;
   AssumptionCache &AC = ACT.getAssumptionCache(*F);
   auto AR = AC.assumptionsFor(F->getArg(3));
   ASSERT_EQ(AR.size(), 0u);
std::unique_ptr<Module> Mod = parseAssemblyString(
       "declare void @llvm.assume(i1)\n"
       "define void @test(i32* %P, i32* %P1, i32* %P2, i32 %I3, i1 %B) {\n"
       "call void @llvm.assume(i1 true) [\"align\"(i32* %P, i32 8, i32 %I3)]\n"
       "call void @llvm.assume(i1 true) [\"align\"(i32* %P1, i32 %I3, i32 "
       "%I3)]\n"
       "call void @llvm.assume(i1 true) [\"align\"(i32* %P2, i32 16, i32 8)]\n"
       "ret void\n}\n",
       Err, C);
-  if (!Mod)
+  if (!Mod) {
     Err.print("AssumeQueryAPI", errs());
+    FAIL() << "Unable to parse the assembly string";
+  }
 
   Function *F = Mod->getFunction("test");
   BasicBlock::iterator Start = F->begin()->begin();
   IntrinsicInst *II;
   RetainedKnowledge RK;
   II = cast<IntrinsicInst>(&*Start);
   RK = getKnowledgeFromBundle(*II, II->bundle_op_info_begin()[0]);
   ASSERT_EQ(RK.AttrKind, Attribute::Alignment);

llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp

last.block:
   ret i32 %ret
 }
 define internal i32 @top() {
   %1 = call i32 @branches(i32 2)
   %2 = call i32 @f1(i32 %1)
   ret i32 %2
 }
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   Function *BranchesFunction = M->getFunction("branches");
   FunctionPropertiesInfo BranchesFeatures = buildFPI(*BranchesFunction);
   EXPECT_EQ(BranchesFeatures.BasicBlockCount, 4);
   EXPECT_EQ(BranchesFeatures.BlocksReachedFromConditionalInstruction, 2);
   // 2 Users: top is one. The other is added because @branches is not internal,
   // so it may have external callers.
   EXPECT_EQ(BranchesFeatures.Uses, 2);
)IR");
   EXPECT_EQ(TopFeatures.Uses, 0);
   EXPECT_EQ(TopFeatures.DirectCallsToDefinedFunctions, 1);
   EXPECT_EQ(BranchesFeatures.LoadInstCount, 0);
   EXPECT_EQ(BranchesFeatures.StoreInstCount, 0);
   EXPECT_EQ(BranchesFeatures.MaxLoopDepth, 0);
   EXPECT_EQ(BranchesFeatures.TopLevelLoopCount, 0);
 }
 } // end anonymous namespace
 No newline at end of file

llvm/unittests/Analysis/IVDescriptorsTest.cpp

for.body:
   %cmp = icmp slt i32 %inc, %ub
   br i1 %cmp, label %for.body, label %for.exit
 for.exit:
   br label %for.end
 for.end:
   ret void
 })"
     );
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   runWithLoopInfoAndSE(
       *M, "foo", [&](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
         Function::iterator FI = F.begin();
         // First basic block is entry - skip it.
         BasicBlock *Header = &*(++FI);
         assert(Header->getName() == "for.body");
         Loop *L = LI.getLoopFor(Header);
std::unique_ptr<Module> M = parseIR(Context, R"(
         br i1 %tmp32, label %bb29, label %bb33
 
       bb33:
         br label %bb34
 
       bb34:
         ret void
       })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   runWithLoopInfoAndSE(
       *M, "barney", [&](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
         Function::iterator FI = F.begin();
         // First basic block is entry - skip it.
         BasicBlock *Header = &*(++(++(++(++FI))));
         assert(Header->getName() == "bb29");
         Loop *L = LI.getLoopFor(Header);

llvm/unittests/Analysis/LoadsTest.cpp

entry:
   %f1 = getelementptr inbounds %class, %class* %o, i32 0, i32 0
   store i32 42, i32* %f1
   %f2 = getelementptr inbounds %class, %class* %o, i32 0, i32 1
   store i32 43, i32* %f2
   %v = load i32, i32* %f1
   ret i32 %v
 }
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
   Inst = &*++F->front().rbegin();

 declare void @use(i32*)
 
 define void @f(i32* %p) {
   call void @use(i32* getelementptr inbounds ([1 x i32], [1 x i32]* @y, i64 0, i64 0))
   call void @use(i32* getelementptr inbounds (i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 0, i64 0), i64 1))
   ret void
 }
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   const auto &DL = M->getDataLayout();
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
 
   // NOTE: the implementation of canReplacePointersIfEqual is incomplete.
   // Currently the only the cases it returns false for are really sound and

llvm/unittests/Analysis/ValueTrackingTest.cpp

 }
 
 class ValueTrackingTest : public testing::Test {
 protected:
   std::unique_ptr<Module> parseModule(StringRef Assembly) {
     SMDiagnostic Error;
     std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context);
 
-    std::string errMsg;
-    raw_string_ostream os(errMsg);
-    Error.print("", os);
-    EXPECT_TRUE(M) << os.str();
+    if (!M)
+      Error.print("", errs());
 
     return M;
   }
 
   void parseAssembly(StringRef Assembly) {
     M = parseModule(Assembly);
-    ASSERT_TRUE(M);
+    if (!M)
+      return;
 
     F = M->getFunction("test");
-    ASSERT_TRUE(F) << "Test must have a function @test";
-    if (!F)
+    if (!F) {
+      errs() << "Test must have a function @test\n";
       return;
+    }
 
     A = findInstructionByNameOrNull(F, "A");
-    ASSERT_TRUE(A) << "@test must have an instruction %A";
+    if (!A) {
+      errs() << "@test must have an instruction %A\n";
+      return;
+    }
 
     CxtI = findInstructionByNameOrNull(F, "CxtI");
     CxtI2 = findInstructionByNameOrNull(F, "CxtI2");
     CxtI3 = findInstructionByNameOrNull(F, "CxtI3");
   }
 
   LLVMContext Context;
   std::unique_ptr<Module> M;

 
 TEST_F(MatchSelectPatternTest, SimpleFMin) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ult float %a, 5.0\n"
       "  %A = select i1 %1, float %a, float 5.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_NAN, false});
 }
 
 TEST_F(MatchSelectPatternTest, SimpleFMax) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float %a, 5.0\n"
       "  %A = select i1 %1, float %a, float 5.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, true});
 }
 
 TEST_F(MatchSelectPatternTest, SwappedFMax) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float 5.0, %a\n"
       "  %A = select i1 %1, float %a, float 5.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, false});
 }
 
 TEST_F(MatchSelectPatternTest, SwappedFMax2) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float %a, 5.0\n"
       "  %A = select i1 %1, float 5.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_NAN, false});
 }
 
 TEST_F(MatchSelectPatternTest, SwappedFMax3) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ult float %a, 5.0\n"
       "  %A = select i1 %1, float 5.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, true});
 }
 
 TEST_F(MatchSelectPatternTest, FastFMin) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp nnan olt float %a, 5.0\n"
       "  %A = select i1 %1, float %a, float 5.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_ANY, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMinConstantZero) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ole float %a, 0.0\n"
       "  %A = select i1 %1, float %a, float 0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // This shouldn't be matched, as %a could be -0.0.
   expectPattern({SPF_UNKNOWN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMinConstantZeroNsz) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp nsz ole float %a, 0.0\n"
       "  %A = select i1 %1, float %a, float 0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // But this should be, because we've ignored signed zeroes.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_OTHER, true});
 }
 
 TEST_F(MatchSelectPatternTest, FMinMismatchConstantZero1) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float -0.0, %a\n"
       "  %A = select i1 %1, float 0.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_NAN, true});
 }
 
 TEST_F(MatchSelectPatternTest, FMinMismatchConstantZero2) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float %a, -0.0\n"
       "  %A = select i1 %1, float 0.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_NAN, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMinMismatchConstantZero3) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float 0.0, %a\n"
       "  %A = select i1 %1, float -0.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_NAN, true});
 }
 
 TEST_F(MatchSelectPatternTest, FMinMismatchConstantZero4) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float %a, 0.0\n"
       "  %A = select i1 %1, float -0.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_NAN, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMinMismatchConstantZero5) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float -0.0, %a\n"
       "  %A = select i1 %1, float %a, float 0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_OTHER, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMinMismatchConstantZero6) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float %a, -0.0\n"
       "  %A = select i1 %1, float %a, float 0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_OTHER, true});
 }
 
 TEST_F(MatchSelectPatternTest, FMinMismatchConstantZero7) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float 0.0, %a\n"
       "  %A = select i1 %1, float %a, float -0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_OTHER, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMinMismatchConstantZero8) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float %a, 0.0\n"
       "  %A = select i1 %1, float %a, float -0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_OTHER, true});
 }
 
 TEST_F(MatchSelectPatternTest, FMaxMismatchConstantZero1) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float -0.0, %a\n"
       "  %A = select i1 %1, float 0.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_NAN, true});
 }
 
 TEST_F(MatchSelectPatternTest, FMaxMismatchConstantZero2) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float %a, -0.0\n"
       "  %A = select i1 %1, float 0.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_NAN, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMaxMismatchConstantZero3) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float 0.0, %a\n"
       "  %A = select i1 %1, float -0.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_NAN, true});
 }
 
 TEST_F(MatchSelectPatternTest, FMaxMismatchConstantZero4) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float %a, 0.0\n"
       "  %A = select i1 %1, float -0.0, float %a\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_NAN, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMaxMismatchConstantZero5) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float -0.0, %a\n"
       "  %A = select i1 %1, float %a, float 0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMaxMismatchConstantZero6) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float %a, -0.0\n"
       "  %A = select i1 %1, float %a, float 0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, true});
 }
 
 TEST_F(MatchSelectPatternTest, FMaxMismatchConstantZero7) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp olt float 0.0, %a\n"
       "  %A = select i1 %1, float %a, float -0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMaxMismatchConstantZero8) {
   parseAssembly(
       "define float @test(float %a) {\n"
       "  %1 = fcmp ogt float %a, 0.0\n"
       "  %A = select i1 %1, float %a, float -0.0\n"
       "  ret float %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The sign of zero doesn't matter in fcmp.
   expectPattern({SPF_FMAXNUM, SPNB_RETURNS_OTHER, true});
 }
 
 TEST_F(MatchSelectPatternTest, FMinMismatchConstantZeroVecUndef) {
   parseAssembly(
       "define <2 x float> @test(<2 x float> %a) {\n"
       "  %1 = fcmp ogt <2 x float> %a, <float -0.0, float -0.0>\n"
       "  %A = select <2 x i1> %1, <2 x float> <float undef, float 0.0>, <2 x float> %a\n"
       "  ret <2 x float> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // An undef in a vector constant can not be back-propagated for this analysis.
   expectPattern({SPF_UNKNOWN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, FMaxMismatchConstantZeroVecUndef) {
   parseAssembly(
       "define <2 x float> @test(<2 x float> %a) {\n"
       "  %1 = fcmp ogt <2 x float> %a, zeroinitializer\n"
       "  %A = select <2 x i1> %1, <2 x float> %a, <2 x float> <float -0.0, float undef>\n"
       "  ret <2 x float> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // An undef in a vector constant can not be back-propagated for this analysis.
   expectPattern({SPF_UNKNOWN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, VectorFMinimum) {
   parseAssembly(
       "define <4 x float> @test(<4 x float> %a) {\n"
       "  %1 = fcmp ule <4 x float> %a, \n"
       "    <float 5.0, float 5.0, float 5.0, float 5.0>\n"
       "  %A = select <4 x i1> %1, <4 x float> %a,\n"
       "     <4 x float> <float 5.0, float 5.0, float 5.0, float 5.0>\n"
       "  ret <4 x float> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // Check that pattern matching works on vectors where each lane has the same
   // unordered pattern.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_NAN, false});
 }
 
 TEST_F(MatchSelectPatternTest, VectorFMinOtherOrdered) {
   parseAssembly(
       "define <4 x float> @test(<4 x float> %a) {\n"
       "  %1 = fcmp ole <4 x float> %a, \n"
       "    <float 5.0, float 5.0, float 5.0, float 5.0>\n"
       "  %A = select <4 x i1> %1, <4 x float> %a,\n"
       "     <4 x float> <float 5.0, float 5.0, float 5.0, float 5.0>\n"
       "  ret <4 x float> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // Check that pattern matching works on vectors where each lane has the same
   // ordered pattern.
   expectPattern({SPF_FMINNUM, SPNB_RETURNS_OTHER, true});
 }
 
 TEST_F(MatchSelectPatternTest, VectorNotFMinimum) {
   parseAssembly(
       "define <4 x float> @test(<4 x float> %a) {\n"
       "  %1 = fcmp ule <4 x float> %a, \n"
       "    <float 5.0, float 0x7ff8000000000000, float 5.0, float 5.0>\n"
       "  %A = select <4 x i1> %1, <4 x float> %a,\n"
       "     <4 x float> <float 5.0, float 0x7ff8000000000000, float 5.0, float "
       "5.0>\n"
       "  ret <4 x float> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The lane that contains a NaN (0x7ff80...) behaves like a
   // non-NaN-propagating min and the other lines behave like a NaN-propagating
   // min, so check that neither is returned.
   expectPattern({SPF_UNKNOWN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, VectorNotFMinZero) {
   parseAssembly(
       "define <4 x float> @test(<4 x float> %a) {\n"
       "  %1 = fcmp ule <4 x float> %a, \n"
       "    <float 5.0, float -0.0, float 5.0, float 5.0>\n"
       "  %A = select <4 x i1> %1, <4 x float> %a,\n"
       "     <4 x float> <float 5.0, float 0.0, float 5.0, float 5.0>\n"
       "  ret <4 x float> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // Always selects the second lane of %a if it is positive or negative zero, so
   // this is stricter than a min.
   expectPattern({SPF_UNKNOWN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, DoubleCastU) {
   parseAssembly(
       "define i32 @test(i8 %a, i8 %b) {\n"
       "  %1 = icmp ult i8 %a, %b\n"
       "  %2 = zext i8 %a to i32\n"
       "  %3 = zext i8 %b to i32\n"
       "  %A = select i1 %1, i32 %2, i32 %3\n"
       "  ret i32 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // We should be able to look through the situation where we cast both operands
   // to the select.
   expectPattern({SPF_UMIN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, DoubleCastS) {
   parseAssembly(
       "define i32 @test(i8 %a, i8 %b) {\n"
       "  %1 = icmp slt i8 %a, %b\n"
       "  %2 = sext i8 %a to i32\n"
       "  %3 = sext i8 %b to i32\n"
       "  %A = select i1 %1, i32 %2, i32 %3\n"
       "  ret i32 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // We should be able to look through the situation where we cast both operands
   // to the select.
   expectPattern({SPF_SMIN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, DoubleCastBad) {
   parseAssembly(
       "define i32 @test(i8 %a, i8 %b) {\n"
       "  %1 = icmp ult i8 %a, %b\n"
       "  %2 = zext i8 %a to i32\n"
       "  %3 = sext i8 %b to i32\n"
       "  %A = select i1 %1, i32 %2, i32 %3\n"
       "  ret i32 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // The cast types here aren't the same, so we cannot match an UMIN.
   expectPattern({SPF_UNKNOWN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotSMin) {
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %cmp = icmp sgt i8 %a, %b\n"
       "  %an = xor i8 %a, -1\n"
       "  %bn = xor i8 %b, -1\n"
       "  %A = select i1 %cmp, i8 %an, i8 %bn\n"
       "  ret i8 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_SMIN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotSMinSwap) {
   parseAssembly(
       "define <2 x i8> @test(<2 x i8> %a, <2 x i8> %b) {\n"
       "  %cmp = icmp slt <2 x i8> %a, %b\n"
       "  %an = xor <2 x i8> %a, <i8 -1, i8-1>\n"
       "  %bn = xor <2 x i8> %b, <i8 -1, i8-1>\n"
       "  %A = select <2 x i1> %cmp, <2 x i8> %bn, <2 x i8> %an\n"
       "  ret <2 x i8> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_SMIN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotSMax) {
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %cmp = icmp slt i8 %a, %b\n"
       "  %an = xor i8 %a, -1\n"
       "  %bn = xor i8 %b, -1\n"
       "  %A = select i1 %cmp, i8 %an, i8 %bn\n"
       "  ret i8 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_SMAX, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotSMaxSwap) {
   parseAssembly(
       "define <2 x i8> @test(<2 x i8> %a, <2 x i8> %b) {\n"
       "  %cmp = icmp sgt <2 x i8> %a, %b\n"
       "  %an = xor <2 x i8> %a, <i8 -1, i8-1>\n"
       "  %bn = xor <2 x i8> %b, <i8 -1, i8-1>\n"
       "  %A = select <2 x i1> %cmp, <2 x i8> %bn, <2 x i8> %an\n"
       "  ret <2 x i8> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_SMAX, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotUMin) {
   parseAssembly(
       "define <2 x i8> @test(<2 x i8> %a, <2 x i8> %b) {\n"
       "  %cmp = icmp ugt <2 x i8> %a, %b\n"
       "  %an = xor <2 x i8> %a, <i8 -1, i8-1>\n"
       "  %bn = xor <2 x i8> %b, <i8 -1, i8-1>\n"
       "  %A = select <2 x i1> %cmp, <2 x i8> %an, <2 x i8> %bn\n"
       "  ret <2 x i8> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_UMIN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotUMinSwap) {
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %cmp = icmp ult i8 %a, %b\n"
       "  %an = xor i8 %a, -1\n"
       "  %bn = xor i8 %b, -1\n"
       "  %A = select i1 %cmp, i8 %bn, i8 %an\n"
       "  ret i8 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_UMIN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotUMax) {
   parseAssembly(
       "define <2 x i8> @test(<2 x i8> %a, <2 x i8> %b) {\n"
       "  %cmp = icmp ult <2 x i8> %a, %b\n"
       "  %an = xor <2 x i8> %a, <i8 -1, i8-1>\n"
       "  %bn = xor <2 x i8> %b, <i8 -1, i8-1>\n"
       "  %A = select <2 x i1> %cmp, <2 x i8> %an, <2 x i8> %bn\n"
       "  ret <2 x i8> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_UMAX, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotUMaxSwap) {
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %cmp = icmp ugt i8 %a, %b\n"
       "  %an = xor i8 %a, -1\n"
       "  %bn = xor i8 %b, -1\n"
       "  %A = select i1 %cmp, i8 %bn, i8 %an\n"
       "  ret i8 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_UMAX, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotEq) {
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %cmp = icmp eq i8 %a, %b\n"
       "  %an = xor i8 %a, -1\n"
       "  %bn = xor i8 %b, -1\n"
       "  %A = select i1 %cmp, i8 %bn, i8 %an\n"
       "  ret i8 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_UNKNOWN, SPNB_NA, false});
 }
 
 TEST_F(MatchSelectPatternTest, NotNotNe) {
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %cmp = icmp ne i8 %a, %b\n"
       "  %an = xor i8 %a, -1\n"
       "  %bn = xor i8 %b, -1\n"
       "  %A = select i1 %cmp, i8 %bn, i8 %an\n"
       "  ret i8 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectPattern({SPF_UNKNOWN, SPNB_NA, false});
 }
 
 TEST(ValueTracking, GuaranteedToTransferExecutionToSuccessor) {
   StringRef Assembly =
       "declare void @nounwind_readonly(i32*) nounwind readonly "
       "declare void @nounwind_argmemonly(i32*) nounwind argmemonly "
       "declare void @throws_but_readonly(i32*) readonly "
StringRef Assembly =
       "  call void @unknown(i32* %p) argmemonly "
       "  call void @nounwind_willreturn(i32* %p)"
       "  ret void "
       "} ";
 
   LLVMContext Context;
   SMDiagnostic Error;
   auto M = parseAssemblyString(Assembly, Error, Context);
-  assert(M && "Bad assembly?");
+  ASSERT_TRUE(M) << "Bad assembly?";
 
   auto *F = M->getFunction("f");
-  assert(F && "Bad assembly?");
+  ASSERT_TRUE(F) << "Bad assembly?";
 
   auto &BB = F->getEntryBlock();
   bool ExpectedAnswers[] = {
       true,  // call void @nounwind_readonly(i32* %p)
       true,  // call void @nounwind_argmemonly(i32* %p)
       false, // call void @throws_but_readonly(i32* %p)
       false, // call void @throws_but_argmemonly(i32* %p)
       true,  // call void @unknown(i32* %p) nounwind readonly

 }
 
 TEST_F(ValueTrackingTest, ComputeNumSignBits_PR32045) {
   parseAssembly(
       "define i32 @test(i32 %a) {\n"
       "  %A = ashr i32 %a, -1\n"
       "  ret i32 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   EXPECT_EQ(ComputeNumSignBits(A, M->getDataLayout()), 1u);
 }
 
 // No guarantees for canonical IR in this analysis, so this just bails out.
 TEST_F(ValueTrackingTest, ComputeNumSignBits_Shuffle) {
   parseAssembly(
       "define <2 x i32> @test() {\n"
       "  %A = shufflevector <2 x i32> undef, <2 x i32> undef, <2 x i32> <i32 0, i32 0>\n"
       "  ret <2 x i32> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   EXPECT_EQ(ComputeNumSignBits(A, M->getDataLayout()), 1u);
 }
 
 // No guarantees for canonical IR in this analysis, so a shuffle element that
 // references an undef value means this can't return any extra information.
 TEST_F(ValueTrackingTest, ComputeNumSignBits_Shuffle2) {
   parseAssembly(
       "define <2 x i32> @test(<2 x i1> %x) {\n"
       "  %sext = sext <2 x i1> %x to <2 x i32>\n"
       "  %A = shufflevector <2 x i32> %sext, <2 x i32> undef, <2 x i32> <i32 0, i32 2>\n"
       "  ret <2 x i32> %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   EXPECT_EQ(ComputeNumSignBits(A, M->getDataLayout()), 1u);
 }
 
 TEST(ValueTracking, propagatesPoison) {
   std::string AsmHead = "declare i32 @g(i32)\n"
                         "define void @f(i32 %x, i32 %y, float %fx, float %fy, "
                         "i1 %cond, i8* %p) {\n";
   std::string AsmTail = "  ret void\n}";
TEST(ValueTracking, propagatesPoison) {
   std::string AssemblyStr = AsmHead;
   for (auto &Itm : Data)
     AssemblyStr += Itm.second + "\n";
   AssemblyStr += AsmTail;
 
   LLVMContext Context;
   SMDiagnostic Error;
   auto M = parseAssemblyString(AssemblyStr, Error, Context);
-  assert(M && "Bad assembly?");
+  ASSERT_TRUE(M) << "Bad assembly?";
 
   auto *F = M->getFunction("f");
-  assert(F && "Bad assembly?");
+  ASSERT_TRUE(F) << "Bad assembly?";
 
   auto &BB = F->getEntryBlock();
 
   int Index = 0;
   for (auto &I : BB) {
     if (isa<ReturnInst>(&I))
       break;
     EXPECT_EQ(propagatesPoison(cast<Operator>(&I)), Data[Index].first)
         << "Incorrect answer at instruction " << Index << " = " << I;
     Index++;
   }
 }
 
 TEST_F(ValueTrackingTest, programUndefinedIfPoison) {
   parseAssembly("declare i32 @any_num()"
                 "define void @test(i32 %mask) {\n"
                 "  %A = call i32 @any_num()\n"
                 "  %B = or i32 %A, %mask\n"
                 "  udiv i32 1, %B"
                 "  ret void\n"
                 "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // If %A was poison, udiv raises UB regardless of %mask's value
   EXPECT_EQ(programUndefinedIfPoison(A), true);
 }
 
 TEST_F(ValueTrackingTest, programUndefinedIfUndefOrPoison) {
   parseAssembly("declare i32 @any_num()"
                 "define void @test(i32 %mask) {\n"
                 "  %A = call i32 @any_num()\n"
                 "  %B = or i32 %A, %mask\n"
                 "  udiv i32 1, %B"
                 "  ret void\n"
                 "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   // If %A was undef and %mask was 1, udiv does not raise UB
   EXPECT_EQ(programUndefinedIfUndefOrPoison(A), false);
 }
 
 TEST_F(ValueTrackingTest, isGuaranteedNotToBePoison_exploitBranchCond) {
   parseAssembly("declare i1 @any_bool()"
                 "define void @test(i1 %y) {\n"
                 "  %A = call i1 @any_bool()\n"
                 "  %cond = and i1 %A, %y\n"
                 "  br i1 %cond, label %BB1, label %BB2\n"
                 "BB1:\n"
                 "  ret void\n"
                 "BB2:\n"
                 "  ret void\n"
                 "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   DominatorTree DT(*F);
   for (auto &BB : *F) {
     if (&BB == &F->getEntryBlock())
       continue;
 
     EXPECT_EQ(isGuaranteedNotToBePoison(A, nullptr, BB.getTerminator(), &DT),
               true)
         << "isGuaranteedNotToBePoison does not hold at " << *BB.getTerminator();
parseAssembly("declare i32 @any_i32(i32)"
                 "  %A.next = call i32 @any_i32(i32 %A)\n"
                 "  %cond = icmp eq i32 %A.next, 0\n"
                 "  br i1 %cond, label %NEXT, label %EXIT\n"
                 "NEXT:\n"
                 "  br label %LOOP\n"
                 "EXIT:\n"
                 "  ret void\n"
                 "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   DominatorTree DT(*F);
   for (auto &BB : *F) {
     if (BB.getName() == "LOOP") {
       EXPECT_EQ(isGuaranteedNotToBePoison(A, nullptr, A, &DT), true)
           << "isGuaranteedNotToBePoison does not hold";
     }
   }
 }
 
 TEST_F(ValueTrackingTest, isGuaranteedNotToBeUndefOrPoison) {
   parseAssembly("declare void @f(i32 noundef)"
                 "define void @test(i32 %x) {\n"
                 "  %A = bitcast i32 %x to i32\n"
                 "  call void @f(i32 noundef %x)\n"
                 "  ret void\n"
                 "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   EXPECT_EQ(isGuaranteedNotToBeUndefOrPoison(A), true);
 }
 
 TEST_F(ValueTrackingTest, isGuaranteedNotToBeUndefOrPoison_assume) {
   parseAssembly("declare i1 @f_i1()\n"
                 "declare i32 @f_i32()\n"
                 "declare void @llvm.assume(i1)\n"
                 "define void @test() {\n"
                 "  %A = call i32 @f_i32()\n"
                 "  %cond = call i1 @f_i1()\n"
                 "  %CxtI = add i32 0, 0\n"
                 "  br i1 %cond, label %BB1, label %EXIT\n"
                 "BB1:\n"
                 "  %CxtI2 = add i32 0, 0\n"
                 "  %cond2 = call i1 @f_i1()\n"
                 "  call void @llvm.assume(i1 true) [ \"noundef\"(i32 %A) ]\n"
                 "  br i1 %cond2, label %BB2, label %EXIT\n"
                 "BB2:\n"
                 "  %CxtI3 = add i32 0, 0\n"
                 "  ret void\n"
                 "EXIT:\n"
                 "  ret void\n"
                 "}");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   AssumptionCache AC(*F);
   DominatorTree DT(*F);
   EXPECT_FALSE(isGuaranteedNotToBeUndefOrPoison(A, &AC, CxtI, &DT));
   EXPECT_FALSE(isGuaranteedNotToBeUndefOrPoison(A, &AC, CxtI2, &DT));
   EXPECT_TRUE(isGuaranteedNotToBeUndefOrPoison(A, &AC, CxtI3, &DT));
 }
 
 TEST(ValueTracking, canCreatePoisonOrUndef) {
TEST(ValueTracking, canCreatePoisonOrUndef) {
   std::string AssemblyStr = AsmHead;
   for (auto &Itm : Data)
     AssemblyStr += Itm.second + "\n";
   AssemblyStr += AsmTail;
 
   LLVMContext Context;
   SMDiagnostic Error;
   auto M = parseAssemblyString(AssemblyStr, Error, Context);
-  assert(M && "Bad assembly?");
+  ASSERT_TRUE(M) << "Bad assembly?";
 
   auto *F = M->getFunction("f");
-  assert(F && "Bad assembly?");
+  ASSERT_TRUE(F) << "Bad assembly?";
 
   auto &BB = F->getEntryBlock();
 
   int Index = 0;
   for (auto &I : BB) {
     if (isa<ReturnInst>(&I))
       break;
     bool Poison = Data[Index].first.first;
parseAssembly("declare i1 @f_i1()\n"
                 "  call void @llvm.assume(i1 true) [ \"align\"(i8* %A, i64 16) ]\n"
                 "  br i1 %cond2, label %BB2, label %EXIT\n"
                 "BB2:\n"
                 "  %CxtI3 = add i32 0, 0\n"
                 "  ret void\n"
                 "EXIT:\n"
                 "  ret void\n"
                 "}");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   AssumptionCache AC(*F);
   DominatorTree DT(*F);
   DataLayout DL = M->getDataLayout();
   EXPECT_EQ(getKnownAlignment(A, DL, CxtI, &AC, &DT), Align(1));
   EXPECT_EQ(getKnownAlignment(A, DL, CxtI2, &AC, &DT), Align(1));
   EXPECT_EQ(getKnownAlignment(A, DL, CxtI3, &AC, &DT), Align(16));
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownBits) {
   parseAssembly(
       "define i32 @test(i32 %a, i32 %b) {\n"
       "  %ash = mul i32 %a, 8\n"
       "  %aad = add i32 %ash, 7\n"
       "  %aan = and i32 %aad, 4095\n"
       "  %bsh = shl i32 %b, 4\n"
       "  %bad = or i32 %bsh, 6\n"
       "  %ban = and i32 %bad, 4095\n"
       "  %A = mul i32 %aan, %ban\n"
       "  ret i32 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 4278190085u, /*one*/ 10u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownMulBits) {
   parseAssembly(
       "define i32 @test(i32 %a, i32 %b) {\n"
       "  %aa = shl i32 %a, 5\n"
       "  %bb = shl i32 %b, 5\n"
       "  %aaa = or i32 %aa, 24\n"
       "  %bbb = or i32 %bb, 28\n"
       "  %A = mul i32 %aaa, %bbb\n"
       "  ret i32 %A\n"
       "}\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 95u, /*one*/ 32u);
 }
 
 TEST_F(ComputeKnownBitsTest, KnownNonZeroShift) {
   // %q is known nonzero without known bits.
   // Because %q is nonzero, %A[0] is known to be zero.
   parseAssembly(
       "define i8 @test(i8 %p, i8* %pq) {\n"
       "  %q = load i8, i8* %pq, !range !0\n"
       "  %A = shl i8 %p, %q\n"
       "  ret i8 %A\n"
       "}\n"
       "!0 = !{ i8 1, i8 5 }\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 1u, /*one*/ 0u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownFshl) {
   // fshl(....1111....0000, 00..1111........, 6)
   // = 11....000000..11
   parseAssembly(
       "define i16 @test(i16 %a, i16 %b) {\n"
       "  %aa = shl i16 %a, 4\n"
       "  %bb = lshr i16 %b, 2\n"
       "  %aaa = or i16 %aa, 3840\n"
       "  %bbb = or i16 %bb, 3840\n"
       "  %A = call i16 @llvm.fshl.i16(i16 %aaa, i16 %bbb, i16 6)\n"
       "  ret i16 %A\n"
       "}\n"
       "declare i16 @llvm.fshl.i16(i16, i16, i16)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 1008u, /*one*/ 49155u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownFshr) {
   // fshr(....1111....0000, 00..1111........, 26)
   // = 11....000000..11
   parseAssembly(
       "define i16 @test(i16 %a, i16 %b) {\n"
       "  %aa = shl i16 %a, 4\n"
       "  %bb = lshr i16 %b, 2\n"
       "  %aaa = or i16 %aa, 3840\n"
       "  %bbb = or i16 %bb, 3840\n"
       "  %A = call i16 @llvm.fshr.i16(i16 %aaa, i16 %bbb, i16 26)\n"
       "  ret i16 %A\n"
       "}\n"
       "declare i16 @llvm.fshr.i16(i16, i16, i16)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 1008u, /*one*/ 49155u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownFshlZero) {
   // fshl(....1111....0000, 00..1111........, 0)
   // = ....1111....0000
   parseAssembly(
       "define i16 @test(i16 %a, i16 %b) {\n"
       "  %aa = shl i16 %a, 4\n"
       "  %bb = lshr i16 %b, 2\n"
       "  %aaa = or i16 %aa, 3840\n"
       "  %bbb = or i16 %bb, 3840\n"
       "  %A = call i16 @llvm.fshl.i16(i16 %aaa, i16 %bbb, i16 0)\n"
       "  ret i16 %A\n"
       "}\n"
       "declare i16 @llvm.fshl.i16(i16, i16, i16)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 15u, /*one*/ 3840u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownUAddSatLeadingOnes) {
   // uadd.sat(1111...1, ........)
   // = 1111....
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %aa = or i8 %a, 241\n"
       "  %A = call i8 @llvm.uadd.sat.i8(i8 %aa, i8 %b)\n"
       "  ret i8 %A\n"
       "}\n"
       "declare i8 @llvm.uadd.sat.i8(i8, i8)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 0u, /*one*/ 240u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownUAddSatOnesPreserved) {
   // uadd.sat(00...011, .1...110)
   // = .......1
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %aa = or i8 %a, 3\n"
       "  %aaa = and i8 %aa, 59\n"
       "  %bb = or i8 %b, 70\n"
       "  %bbb = and i8 %bb, 254\n"
       "  %A = call i8 @llvm.uadd.sat.i8(i8 %aaa, i8 %bbb)\n"
       "  ret i8 %A\n"
       "}\n"
       "declare i8 @llvm.uadd.sat.i8(i8, i8)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 0u, /*one*/ 1u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownUSubSatLHSLeadingZeros) {
   // usub.sat(0000...0, ........)
   // = 0000....
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %aa = and i8 %a, 14\n"
       "  %A = call i8 @llvm.usub.sat.i8(i8 %aa, i8 %b)\n"
       "  ret i8 %A\n"
       "}\n"
       "declare i8 @llvm.usub.sat.i8(i8, i8)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 240u, /*one*/ 0u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownUSubSatRHSLeadingOnes) {
   // usub.sat(........, 1111...1)
   // = 0000....
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %bb = or i8 %a, 241\n"
       "  %A = call i8 @llvm.usub.sat.i8(i8 %a, i8 %bb)\n"
       "  ret i8 %A\n"
       "}\n"
       "declare i8 @llvm.usub.sat.i8(i8, i8)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 240u, /*one*/ 0u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownUSubSatZerosPreserved) {
   // usub.sat(11...011, .1...110)
   // = ......0.
   parseAssembly(
       "define i8 @test(i8 %a, i8 %b) {\n"
       "  %aa = or i8 %a, 195\n"
       "  %aaa = and i8 %aa, 251\n"
       "  %bb = or i8 %b, 70\n"
       "  %bbb = and i8 %bb, 254\n"
       "  %A = call i8 @llvm.usub.sat.i8(i8 %aaa, i8 %bbb)\n"
       "  ret i8 %A\n"
       "}\n"
       "declare i8 @llvm.usub.sat.i8(i8, i8)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   expectKnownBits(/*zero*/ 2u, /*one*/ 0u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownBitsPtrToIntTrunc) {
   // ptrtoint truncates the pointer type.
   parseAssembly(
       "define void @test(i8** %p) {\n"
       "  %A = load i8*, i8** %p\n"
       "  %i = ptrtoint i8* %A to i32\n"
       "  %m = and i32 %i, 31\n"
       "  %c = icmp eq i32 %m, 0\n"
       "  call void @llvm.assume(i1 %c)\n"
       "  ret void\n"
       "}\n"
       "declare void @llvm.assume(i1)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   AssumptionCache AC(*F);
   KnownBits Known = computeKnownBits(
       A, M->getDataLayout(), /* Depth */ 0, &AC, F->front().getTerminator());
   EXPECT_EQ(Known.Zero.getZExtValue(), 31u);
   EXPECT_EQ(Known.One.getZExtValue(), 0u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownBitsPtrToIntZext) {
   // ptrtoint zero extends the pointer type.
   parseAssembly(
       "define void @test(i8** %p) {\n"
       "  %A = load i8*, i8** %p\n"
       "  %i = ptrtoint i8* %A to i128\n"
       "  %m = and i128 %i, 31\n"
       "  %c = icmp eq i128 %m, 0\n"
       "  call void @llvm.assume(i1 %c)\n"
       "  ret void\n"
       "}\n"
       "declare void @llvm.assume(i1)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   AssumptionCache AC(*F);
   KnownBits Known = computeKnownBits(
       A, M->getDataLayout(), /* Depth */ 0, &AC, F->front().getTerminator());
   EXPECT_EQ(Known.Zero.getZExtValue(), 31u);
   EXPECT_EQ(Known.One.getZExtValue(), 0u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownBitsFreeze) {
   parseAssembly("define void @test() {\n"
                 "  %m = call i32 @any_num()\n"
                 "  %A = freeze i32 %m\n"
                 "  %n = and i32 %m, 31\n"
                 "  %c = icmp eq i32 %n, 0\n"
                 "  call void @llvm.assume(i1 %c)\n"
                 "  ret void\n"
                 "}\n"
                 "declare void @llvm.assume(i1)\n"
                 "declare i32 @any_num()\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   AssumptionCache AC(*F);
   KnownBits Known = computeKnownBits(A, M->getDataLayout(), /* Depth */ 0, &AC,
                                      F->front().getTerminator());
   EXPECT_EQ(Known.Zero.getZExtValue(), 31u);
   EXPECT_EQ(Known.One.getZExtValue(), 0u);
 }
 
 TEST_F(ComputeKnownBitsTest, ComputeKnownBitsAddWithRange) {
   parseAssembly("define void @test(i64* %p) {\n"
                 "  %A = load i64, i64* %p, !range !{i64 64, i64 65536}\n"
                 "  %APlus512 = add i64 %A, 512\n"
                 "  %c = icmp ugt i64 %APlus512, 523\n"
                 "  call void @llvm.assume(i1 %c)\n"
                 "  ret void\n"
                 "}\n"
                 "declare void @llvm.assume(i1)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   AssumptionCache AC(*F);
   KnownBits Known = computeKnownBits(A, M->getDataLayout(), /* Depth */ 0, &AC,
                                      F->front().getTerminator());
   EXPECT_EQ(Known.Zero.getZExtValue(), ~(65536llu - 1));
   EXPECT_EQ(Known.One.getZExtValue(), 0u);
   Instruction &APlus512 = findInstructionByName(F, "APlus512");
   Known = computeKnownBits(&APlus512, M->getDataLayout(), /* Depth */ 0, &AC,
                            F->front().getTerminator());
TEST_F(ComputeKnownBitsTest, ComputeKnownBitsAddWithRangeNoOverlap) {
   parseAssembly("define void @test(i64* %p) {\n"
                 "  %A = load i64, i64* %p, !range !{i64 32, i64 64}\n"
                 "  %APlus512 = add i64 %A, 512\n"
                 "  %c = icmp ugt i64 %APlus512, 523\n"
                 "  call void @llvm.assume(i1 %c)\n"
                 "  ret void\n"
                 "}\n"
                 "declare void @llvm.assume(i1)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   AssumptionCache AC(*F);
   KnownBits Known = computeKnownBits(A, M->getDataLayout(), /* Depth */ 0, &AC,
                                      F->front().getTerminator());
   EXPECT_EQ(Known.Zero.getZExtValue(), ~(64llu - 1));
   EXPECT_EQ(Known.One.getZExtValue(), 32u);
   Instruction &APlus512 = findInstructionByName(F, "APlus512");
   Known = computeKnownBits(&APlus512, M->getDataLayout(), /* Depth */ 0, &AC,
                            F->front().getTerminator());
parseAssembly(
       "  %A = load i64, i64* %p, !range !{i64 64, i64 65536}\n"
       "  %APtr = inttoptr i64 %A to float*"
       "  %APtrPlus512 = getelementptr float, float* %APtr, i32 128\n"
       "  %c = icmp ugt float* %APtrPlus512, inttoptr (i32 523 to float*)\n"
       "  call void @llvm.assume(i1 %c)\n"
       "  ret void\n"
       "}\n"
       "declare void @llvm.assume(i1)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   AssumptionCache AC(*F);
   KnownBits Known = computeKnownBits(A, M->getDataLayout(), /* Depth */ 0, &AC,
                                      F->front().getTerminator());
   EXPECT_EQ(Known.Zero.getZExtValue(), ~(65536llu - 1));
   EXPECT_EQ(Known.One.getZExtValue(), 0u);
   Instruction &APtrPlus512 = findInstructionByName(F, "APtrPlus512");
   Known = computeKnownBits(&APtrPlus512, M->getDataLayout(), /* Depth */ 0, &AC,
                            F->front().getTerminator());
parseAssembly(
       "  %A = load i64, i64* %p, !range !{i64 32, i64 64}\n"
       "  %APtr = inttoptr i64 %A to float*"
       "  %APtrPlus512 = getelementptr float, float* %APtr, i32 128\n"
       "  %c = icmp ugt float* %APtrPlus512, inttoptr (i32 523 to float*)\n"
       "  call void @llvm.assume(i1 %c)\n"
       "  ret void\n"
       "}\n"
       "declare void @llvm.assume(i1)\n");
+  ASSERT_TRUE(M && F && A) << "Bad assmply string?";
   AssumptionCache AC(*F);
   KnownBits Known = computeKnownBits(A, M->getDataLayout(), /* Depth */ 0, &AC,
                                      F->front().getTerminator());
   EXPECT_EQ(Known.Zero.getZExtValue(), ~(64llu - 1));
   EXPECT_EQ(Known.One.getZExtValue(), 32u);
   Instruction &APtrPlus512 = findInstructionByName(F, "APtrPlus512");
   Known = computeKnownBits(&APtrPlus512, M->getDataLayout(), /* Depth */ 0, &AC,
                            F->front().getTerminator());
const std::pair<const char *, const char *> IsBytewiseValueTests[] = {
     },
 };
 
 INSTANTIATE_TEST_CASE_P(IsBytewiseValueParamTests, IsBytewiseValueTest,
                         ::testing::ValuesIn(IsBytewiseValueTests),);
 
 TEST_P(IsBytewiseValueTest, IsBytewiseValue) {
   auto M = parseModule(std::string("@test = global ") + GetParam().second);
+  ASSERT_TRUE(M) << "Bad module assembly?";
   GlobalVariable *GV = dyn_cast<GlobalVariable>(M->getNamedValue("test"));
   Value *Actual = isBytewiseValue(GV->getInitializer(), M->getDataLayout());
   std::string Buff;
   raw_string_ostream S(Buff);
   if (Actual)
     S << *Actual;
   EXPECT_EQ(GetParam().first, S.str());
 }
TEST_F(ValueTrackingTest, ComputeConstantRange) {
   define i32 @test(i32 %stride) {
     %gt = icmp uge i32 %stride, 5
     call void @llvm.assume(i1 %gt)
     %lt = icmp ult i32 %stride, 10
     call void @llvm.assume(i1 %lt)
     %stride.plus.one = add nsw nuw i32 %stride, 1
     ret i32 %stride.plus.one
   })");
+    ASSERT_TRUE(M) << "Bad module assembly?";
     Function *F = M->getFunction("test");
 
     AssumptionCache AC(*F);
     Value *Stride = &*F->arg_begin();
     ConstantRange CR1 = computeConstantRange(Stride, true, &AC, nullptr);
     EXPECT_TRUE(CR1.isFullSet());
 
     Instruction *I = &findInstructionByName(F, "stride.plus.one");
define i32 @test(i32 %stride) {
     call void @llvm.assume(i1 %gt)
     %lt = icmp ult i32 %stride, 200
     call void @llvm.assume(i1 %lt)
     %eq = icmp eq i32 %stride, 99
     call void @llvm.assume(i1 %eq)
     %stride.plus.one = add nsw nuw i32 %stride, 1
     ret i32 %stride.plus.one
   })");
+    ASSERT_TRUE(M) << "Bad module assembly?";
     Function *F = M->getFunction("test");
 
     AssumptionCache AC(*F);
     Value *Stride = &*F->arg_begin();
     Instruction *I = &findInstructionByName(F, "stride.plus.one");
     ConstantRange CR = computeConstantRange(Stride, true, &AC, I);
     EXPECT_EQ(99, *CR.getSingleElement());
   }
bb1:
     %lt.2 = icmp ult i32 %stride, 100
     call void @llvm.assume(i1 %lt.2)
     %stride.plus.one = add nsw nuw i32 %stride, 1
     ret i32 %stride.plus.one
 
   bb2:
     ret i32 0
   })");
+    ASSERT_TRUE(M) << "Bad module assembly?";
     Function *F = M->getFunction("test");
 
     AssumptionCache AC(*F);
     Value *Stride = &*F->arg_begin();
     Instruction *GT2 = &findInstructionByName(F, "gt.2");
     ConstantRange CR = computeConstantRange(Stride, true, &AC, GT2);
     EXPECT_EQ(5, CR.getLower());
     EXPECT_EQ(0, CR.getUpper());
TEST_F(ValueTrackingTest, ComputeConstantRange) {
   define i32 @test(i32 %stride, i1 %cond) {
     %gt = icmp ugt i32 %stride, 5
     call void @llvm.assume(i1 %gt)
     %lt = icmp ult i32 %stride, 5
     call void @llvm.assume(i1 %lt)
     %stride.plus.one = add nsw nuw i32 %stride, 1
     ret i32 %stride.plus.one
   })");
+    ASSERT_TRUE(M) << "Bad module assembly?";
     Function *F = M->getFunction("test");
 
     AssumptionCache AC(*F);
     Value *Stride = &*F->arg_begin();
 
     Instruction *I = &findInstructionByName(F, "stride.plus.one");
     ConstantRange CR = computeConstantRange(Stride, true, &AC, I);
     EXPECT_TRUE(CR.isEmptySet());
TEST_F(ValueTrackingTest, ComputeConstantRange) {
   define i32 @test(i32 %x.1, i32 %x.2) {
     %gt = icmp uge i32 %x.1, 5
     call void @llvm.assume(i1 %gt)
     %lt = icmp ult i32 %x.2, %x.1
     call void @llvm.assume(i1 %lt)
     %stride.plus.one = add nsw nuw i32 %x.1, 1
     ret i32 %stride.plus.one
   })");
+    ASSERT_TRUE(M) << "Bad module assembly?";
     Function *F = M->getFunction("test");
 
     AssumptionCache AC(*F);
     Value *X2 = &*std::next(F->arg_begin());
 
     Instruction *I = &findInstructionByName(F, "stride.plus.one");
     ConstantRange CR1 = computeConstantRange(X2, true, &AC, I);
     EXPECT_EQ(0, CR1.getLower());
false, false},
       exit:
         ret void
       })",
      false, false},
 };
 
 TEST_P(FindAllocaForValueTest, findAllocaForValue) {
   auto M = parseModule(GetParam().IR);
+  ASSERT_TRUE(M) << "Bad module assembly?";
   Function *F = M->getFunction("test");
   Instruction *I = &findInstructionByName(F, "r");
   const AllocaInst *AI = findAllocaForValue(I);
   EXPECT_EQ(!!AI, GetParam().AnyOffsetResult);
 }
 
 TEST_P(FindAllocaForValueTest, findAllocaForValueZeroOffset) {
   auto M = parseModule(GetParam().IR);
+  ASSERT_TRUE(M) << "Bad module assembly?";
   Function *F = M->getFunction("test");
   Instruction *I = &findInstructionByName(F, "r");
   const AllocaInst *AI = findAllocaForValue(I, true);
   EXPECT_EQ(!!AI, GetParam().ZeroOffsetResult);
 }
 
 INSTANTIATE_TEST_CASE_P(FindAllocaForValueTest, FindAllocaForValueTest,
                         ::testing::ValuesIn(FindAllocaForValueTests), );

llvm/unittests/Analysis/VectorFunctionABITest.cpp

 // Test fixture needed that holds the veariables needed by the parser.
 class VFABIParserTest : public ::testing::Test {
 private:
   // Parser output.
   VFInfo Info;
   // Reset the data needed for the test.
   void reset(const StringRef Name, const StringRef IRType) {
     M = parseAssemblyString("declare void @dummy()", Err, Ctx);
-    EXPECT_NE(M.get(), nullptr) << "Loading an invalid module.\n "
+    ASSERT_NE(M.get(), nullptr) << "Loading an invalid module.\n "
                                 << Err.getMessage() << "\n";
     Type *Ty = parseType(IRType, Err, *(M.get()));
     FunctionType *FTy = dyn_cast<FunctionType>(Ty);
-    EXPECT_NE(FTy, nullptr) << "Invalid function type string: " << IRType
+    ASSERT_NE(FTy, nullptr) << "Invalid function type string: " << IRType
                             << "\n"
                             << Err.getMessage() << "\n";
     FunctionCallee F = M->getOrInsertFunction(Name, FTy);
-    EXPECT_NE(F.getCallee(), nullptr)
+    ASSERT_NE(F.getCallee(), nullptr)
         << "The function must be present in the module\n";
     // Reset the VFInfo
     Info = VFInfo();
   }
 
   // Data needed to load the optional IR passed to invokeParser
   LLVMContext Ctx;
   SMDiagnostic Err;
protected:
   bool invokeParser(const StringRef MangledName,
                     const StringRef VectorName = "",
                     const StringRef IRType = "void()") {
     StringRef Name = MangledName;
     if (!VectorName.empty())
       Name = VectorName;
     // Reset the VFInfo and the Module to be able to invoke
     // `invokeParser` multiple times in the same test.
     reset(Name, IRType);
 
     const auto OptInfo = VFABI::tryDemangleForVFABI(MangledName, *(M.get()));
     if (OptInfo.hasValue()) {
       Info = OptInfo.getValue();
       return true;
     }
 
     return false;

 }
 
 class VFABIAttrTest : public testing::Test {
 protected:
   void SetUp() override {
     M = parseAssemblyString(IR, Err, Ctx);
     // Get the only call instruction in the block, which is the first
     // instruction.
+    ASSERT_TRUE(M) << "Unable to parse the assembly string";
     CI = dyn_cast<CallInst>(&*(instructions(M->getFunction("f")).begin()));
   }
   const char *IR = "define i32 @f(i32 %a) {\n"
                    " %1 = call i32 @g(i32 %a) #0\n"
                    "  ret i32 %1\n"
                    "}\n"
                    "declare i32 @g(i32)\n"
                    "declare <2 x i32> @custom_vg(<2 x i32>)"
TEST(VFABIGetMappingsTest, IndirectCallInst) {
   LLVMContext C;
   std::unique_ptr<Module> M = parseIR(C, R"IR(
 define void @call(void () * %f) {
 entry:
   call void %f()
   ret void
 }
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   auto F = dyn_cast_or_null<Function>(M->getNamedValue("call"));
   ASSERT_TRUE(F);
   auto CI = dyn_cast<CallInst>(&F->front().front());
   ASSERT_TRUE(CI);
   ASSERT_TRUE(CI->isIndirectCall());
   auto Mappings = VFDatabase::getMappings(*CI);
   EXPECT_EQ(Mappings.size(), (unsigned)0);
 }

llvm/unittests/IR/DebugInfoTest.cpp

std::unique_ptr<Module> M = parseIR(C, R"(
     !5 = distinct !DISubprogram(name: "f", linkageName: "f", scope: null, file: !1, line: 1, type: !6, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !7)
     !6 = !DISubroutineType(types: !2)
     !7 = !{!8}
     !8 = !DILocalVariable(name: "1", scope: !5, file: !1, line: 1, type: !9)
     !9 = !DIBasicType(name: "ty32", size: 32, encoding: DW_ATE_unsigned)
     !10 = !DILocation(line: 1, column: 1, scope: !5)
     !11 = distinct !{!11, !10, !10}
 )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   // Look up the debug info emission kind for the CU via the loop metadata
   // attached to the terminator. If, when stripping non-line table debug info,
   // we update the terminator's metadata correctly, we should be able to
   // observe the change in emission kind for the CU.
   auto getEmissionKind = [&]() {
     Instruction &I = *M->getFunction("f")->getEntryBlock().getFirstNonPHI();
     MDNode *LoopMD = I.getMetadata(LLVMContext::MD_loop);
std::unique_ptr<Module> M = parseIR(C, R"(
     !5 = !{i32 2, !"Debug Info Version", i32 3}
     !6 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
     !7 = !DISubroutineType(types: !2)
     !8 = !{!9}
     !9 = !DILocalVariable(name: "1", scope: !6, file: !1, line: 1, type: !10)
     !10 = !DIBasicType(name: "ty16", size: 16, encoding: DW_ATE_unsigned)
     !11 = !DILocation(line: 1, column: 1, scope: !6)
 )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   // Find %b = add ...
   Instruction &I = *M->getFunction("f")->getEntryBlock().getFirstNonPHI();
 
   // Find the dbg.value using %b.
   SmallVector<DbgValueInst *, 1> DVIs;
   findDbgValues(DVIs, &I);
 
TEST(DIBuilder, CreateFortranArrayTypeWithAttributes) {
   DIExpression *Associated = getDIExpression(1);
   DIExpression *Allocated = getDIExpression(2);
   DIExpression *Rank = DIB.createConstantValueExpression(3);
 
   DICompositeType *ArrayType = DIB.createArrayType(0, 0, nullptr, Subscripts,
                                                    DataLocation, Associated,
                                                    Allocated, Rank);
 
-  EXPECT_TRUE(isa_and_nonnull<DICompositeType>(ArrayType));
+  ASSERT_TRUE(ArrayType);
+  EXPECT_TRUE(isa<DICompositeType>(ArrayType));
   EXPECT_EQ(ArrayType->getRawDataLocation(), DataLocation);
   EXPECT_EQ(ArrayType->getRawAssociated(), Associated);
   EXPECT_EQ(ArrayType->getRawAllocated(), Allocated);
   EXPECT_EQ(ArrayType->getRawRank(), Rank);
 
   // Avoid memory leak.
   DIVariable::deleteTemporary(DataLocation);
 }
 
 } // end namespace

llvm/unittests/IR/InstructionsTest.cpp

 
 if.then:
   ret void
 
 if.end:
   ret void
 }
 )");
+  ASSERT_TRUE(M);
   Function *Foo = M->getFunction("foo");
   auto BBs = Foo->getBasicBlockList().begin();
   CallBrInst &CBI = cast<CallBrInst>(BBs->front());
   ++BBs;
   ++BBs;
   BasicBlock &BranchTestExit = *BBs;
   ++BBs;
   BasicBlock &IfThen = *BBs;

llvm/unittests/IR/LegacyPassManagerTest.cpp

TEST(PassManager, CallbackCallsModifier0) {
                        "  ret void\n"
                        "}\n"
                        "\n"
                        "!0 = !{!1}\n"
                        "!1 = !{i64 0, i64 1, i1 false}";
 
       SMDiagnostic Err;
       std::unique_ptr<Module> M = parseAssemblyString(IR, Err, Context);
-      if (!M)
+      if (!M) {
         Err.print("LegacyPassManagerTest", errs());
+        FAIL() << "Unable to parse the assembly string";
+      }
 
       CallbackCallsModifierPass *P = new CallbackCallsModifierPass();
       legacy::PassManager Passes;
       Passes.add(P);
       Passes.run(*M);
     }
   }
 }

llvm/unittests/InterfaceStub/ELFYAMLTest.cpp

const char Data[] = "--- !tapi-tbe\n"
                       "Arch: x86_64\n"
                       "NeededLibs: [libc.so, libfoo.so, libbar.so]\n"
                       "Symbols:\n"
                       "  foo: { Type: Func, Undefined: true }\n"
                       "...\n";
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
   std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
-  EXPECT_NE(Stub.get(), nullptr);
+  ASSERT_NE(Stub.get(), nullptr);
   EXPECT_FALSE(Stub->SoName.hasValue());
   EXPECT_EQ(Stub->Arch, (uint16_t)llvm::ELF::EM_X86_64);
   EXPECT_EQ(Stub->NeededLibs.size(), 3u);
   EXPECT_STREQ(Stub->NeededLibs[0].c_str(), "libc.so");
   EXPECT_STREQ(Stub->NeededLibs[1].c_str(), "libfoo.so");
   EXPECT_STREQ(Stub->NeededLibs[2].c_str(), "libbar.so");
 }
 
 TEST(ElfYamlTextAPI, YAMLReadsTBESymbols) {
   const char Data[] = "--- !tapi-tbe\n"
                       "TbeVersion: 1.0\n"
                       "SoName: test.so\n"
                       "Arch: x86_64\n"
                       "Symbols:\n"
                       "  bar: { Type: Object, Size: 42 }\n"
                       "  baz: { Type: TLS, Size: 3 }\n"
                       "  foo: { Type: Func, Warning: \"Deprecated!\" }\n"
                       "  nor: { Type: NoType, Undefined: true }\n"
                       "  not: { Type: File, Undefined: true, Size: 111, "
                       "Weak: true, Warning: \'All fields populated!\' }\n"
                       "...\n";
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
   std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
-  EXPECT_NE(Stub.get(), nullptr);
+  ASSERT_NE(Stub.get(), nullptr);
   EXPECT_TRUE(Stub->SoName.hasValue());
   EXPECT_STREQ(Stub->SoName->c_str(), "test.so");
   EXPECT_EQ(Stub->Symbols.size(), 5u);
 
   auto Iterator = Stub->Symbols.begin();
   ELFSymbol const &SymBar = *Iterator++;
   EXPECT_STREQ(SymBar.Name.c_str(), "bar");
   EXPECT_EQ(SymBar.Size, 42u);
const char Data[] = "--- !tapi-tbe\n"
                       "TbeVersion: 1.0\n"
                       "SoName: test.so\n"
                       "Arch: x86_64\n"
                       "Symbols: {}\n"
                       "...\n";
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
   std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
-  EXPECT_NE(Stub.get(), nullptr);
+  ASSERT_NE(Stub.get(), nullptr);
   EXPECT_EQ(0u, Stub->Symbols.size());
 }
 
 TEST(ElfYamlTextAPI, YAMLUnreadableTBE) {
   // Can't read: wrong format/version.
   const char Data[] = "--- !tapi-tbz\n"
                       "TbeVersion: z.3\n"
                       "SoName: test.so\n"

llvm/unittests/MC/DwarfLineTables.cpp

Context() {
     llvm::InitializeAllDisassemblers();
 
     // If we didn't build x86, do not run the test.
     std::string Error;
     const Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
     if (!TheTarget)
       return;
 
+    setContext(TheTarget);
+  }
+
+  void setContext(const Target *TheTarget) {
     MRI.reset(TheTarget->createMCRegInfo(Triple));
+    ASSERT_TRUE(MRI) << "Unable to create reg info";
     MCTargetOptions MCOptions;
     MAI.reset(TheTarget->createMCAsmInfo(*MRI, Triple, MCOptions));
+    ASSERT_TRUE(MAI) << "Unable to create asm info";
     Ctx = std::make_unique<MCContext>(MAI.get(), MRI.get(), nullptr);
   }
 
   operator bool() { return Ctx.get(); }
   operator MCContext &() { return *Ctx; };
 };
 
 Context &getContext() {

llvm/unittests/MC/MCInstPrinter.cpp

MCInstPrinterTest() {
 
     const Target *TheTarget =
         TargetRegistry::lookupTarget(TripleName, ErrorStr);
 
     // If we didn't build x86, do not run the test.
     if (!TheTarget)
       return;
 
+    [&]() {
       MRI.reset(TheTarget->createMCRegInfo(TripleName));
+      ASSERT_TRUE(MRI) << "Unable to create reg info";
       MCTargetOptions MCOptions;
       MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+      ASSERT_TRUE(MAI) << "Unable to create asm info";
       MII.reset(TheTarget->createMCInstrInfo());
+      ASSERT_TRUE(MII) << "Unable to create instruction info";
       Printer.reset(TheTarget->createMCInstPrinter(
             Triple(TripleName), MAI->getAssemblerDialect(), *MAI, *MII, *MRI));
+      ASSERT_TRUE(Printer) << "Unable to create instruction printer";
+    }();
   }
 
   template <typename T> std::string formatHex(T i) {
     std::string Buffer;
     raw_string_ostream OS(Buffer);
     OS << Printer->formatHex(i);
     OS.flush();
     return Buffer;

llvm/unittests/Remarks/BitstreamRemarksParsingTest.cpp

template <size_t N> void parseGood(const char (&Buf)[N]) {
   // This testing methodology has the drawback of relying on both the YAML
   // remark parser and the bitstream remark serializer. It does simplify
   // testing a lot, since working directly with bitstream is not that easy.
 
   // 1.
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
       remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1});
   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
-  EXPECT_TRUE(*MaybeParser != nullptr);
+  ASSERT_TRUE(*MaybeParser != nullptr);
 
   std::unique_ptr<remarks::Remark> FromYAMLRemark = nullptr;
   remarks::RemarkParser &Parser = **MaybeParser;
   Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
   EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
-  EXPECT_TRUE(*Remark != nullptr);               // At least one remark.
+  ASSERT_TRUE(*Remark != nullptr);               // At least one remark.
   // Keep the previous remark around.
   FromYAMLRemark = std::move(*Remark);
   Remark = Parser.next();
   Error E = Remark.takeError();
   EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
   EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
 
   // 2.
   remarks::StringTable BSStrTab;
   BSStrTab.internalize(*FromYAMLRemark);
   std::string BSBuf;
   raw_string_ostream BSStream(BSBuf);
   Expected<std::unique_ptr<remarks::RemarkSerializer>> BSSerializer =
       remarks::createRemarkSerializer(remarks::Format::Bitstream,
                                       remarks::SerializerMode::Standalone,
                                       BSStream, std::move(BSStrTab));
   EXPECT_FALSE(errorToBool(BSSerializer.takeError()));
   (*BSSerializer)->emit(*FromYAMLRemark);
 
   // 3.
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeBSParser =
       remarks::createRemarkParser(remarks::Format::Bitstream, BSStream.str());
   EXPECT_FALSE(errorToBool(MaybeBSParser.takeError()));
-  EXPECT_TRUE(*MaybeBSParser != nullptr);
+  ASSERT_TRUE(*MaybeBSParser != nullptr);
 
   std::unique_ptr<remarks::Remark> FromBSRemark = nullptr;
   remarks::RemarkParser &BSParser = **MaybeBSParser;
   Expected<std::unique_ptr<remarks::Remark>> BSRemark = BSParser.next();
   EXPECT_FALSE(errorToBool(BSRemark.takeError())); // Check for parsing errors.
-  EXPECT_TRUE(*BSRemark != nullptr);               // At least one remark.
+  ASSERT_TRUE(*BSRemark != nullptr);               // At least one remark.
   // Keep the previous remark around.
   FromBSRemark = std::move(*BSRemark);
   BSRemark = BSParser.next();
   Error BSE = BSRemark.takeError();
   EXPECT_TRUE(BSE.isA<remarks::EndOfFileError>());
   EXPECT_TRUE(errorToBool(std::move(BSE))); // Check for parsing errors.
 
   EXPECT_EQ(*FromYAMLRemark, *FromBSRemark);
StringRef Buf = "\n"
                   "  - Caller: foo\n"
                   "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
                   "  - String: ' because its definition is unavailable'\n"
                   "\n";
 
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
       remarks::createRemarkParser(remarks::Format::YAML, Buf);
   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
-  EXPECT_TRUE(*MaybeParser != nullptr);
+  ASSERT_TRUE(*MaybeParser != nullptr);
 
   remarks::RemarkParser &Parser = **MaybeParser;
   Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
   EXPECT_FALSE(
       errorToBool(MaybeRemark.takeError())); // Check for parsing errors.
-  EXPECT_TRUE(*MaybeRemark != nullptr);      // At least one remark.
+  ASSERT_TRUE(*MaybeRemark != nullptr);      // At least one remark.
 
   const remarks::Remark &Remark = **MaybeRemark;
   EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
   EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
   EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
   EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
-  EXPECT_TRUE(Remark.Loc);
+  ASSERT_TRUE(Remark.Loc);
   const remarks::RemarkLocation &RL = *Remark.Loc;
   EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
   EXPECT_EQ(RL.SourceLine, 3U);
   EXPECT_EQ(RL.SourceColumn, 12U);
-  EXPECT_TRUE(Remark.Hotness);
+  ASSERT_TRUE(Remark.Hotness);
   EXPECT_EQ(*Remark.Hotness, 4U);
   EXPECT_EQ(Remark.Args.size(), 4U);
 
   unsigned ArgID = 0;
   for (const remarks::Argument &Arg : Remark.Args) {
     switch (ArgID) {
     case 0:
       EXPECT_EQ(checkStr(Arg.Key, 6), "Callee");
       EXPECT_EQ(checkStr(Arg.Val, 3), "bar");
       EXPECT_FALSE(Arg.Loc);
       break;
     case 1:
       EXPECT_EQ(checkStr(Arg.Key, 6), "String");
       EXPECT_EQ(checkStr(Arg.Val, 26), " will not be inlined into ");
       EXPECT_FALSE(Arg.Loc);
       break;
     case 2: {
       EXPECT_EQ(checkStr(Arg.Key, 6), "Caller");
       EXPECT_EQ(checkStr(Arg.Val, 3), "foo");
-      EXPECT_TRUE(Arg.Loc);
+      ASSERT_TRUE(Arg.Loc);
       const remarks::RemarkLocation &RL = *Arg.Loc;
       EXPECT_EQ(checkStr(RL.SourceFilePath, 6), "file.c");
       EXPECT_EQ(RL.SourceLine, 2U);
       EXPECT_EQ(RL.SourceColumn, 0U);
       break;
     }
     case 3:
       EXPECT_EQ(checkStr(Arg.Key, 6), "String");
TEST(BitstreamRemarks, ContentsCAPI) {
   EXPECT_FALSE(LLVMRemarkParserHasError(Parser));
   LLVMRemarkParserDispose(Parser);
 }
 
 static void parseBad(StringRef Input, const char *ErrorMsg) {
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeBSParser =
       remarks::createRemarkParser(remarks::Format::Bitstream, Input);
   EXPECT_FALSE(errorToBool(MaybeBSParser.takeError()));
-  EXPECT_TRUE(*MaybeBSParser != nullptr);
+  ASSERT_TRUE(*MaybeBSParser != nullptr);
 
   remarks::RemarkParser &BSParser = **MaybeBSParser;
   Expected<std::unique_ptr<remarks::Remark>> BSRemark = BSParser.next();
   EXPECT_EQ(ErrorMsg, toString(BSRemark.takeError())); // Expect an error.
 }
 
 TEST(BitstreamRemarks, ParsingEmpty) {
   parseBad(StringRef(), "End of file reached.");

llvm/unittests/Remarks/YAMLRemarksParsingTest.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 template <size_t N> void parseGood(const char (&Buf)[N]) {
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
       remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1});
   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
-  EXPECT_TRUE(*MaybeParser != nullptr);
+  ASSERT_TRUE(*MaybeParser != nullptr);
 
   remarks::RemarkParser &Parser = **MaybeParser;
   Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
   EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
   EXPECT_TRUE(*Remark != nullptr);               // At least one remark.
   Remark = Parser.next();
   Error E = Remark.takeError();
   EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
   EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
 }
 
 void parseGoodMeta(StringRef Buf) {
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
       remarks::createRemarkParserFromMeta(remarks::Format::YAML, Buf);
   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
-  EXPECT_TRUE(*MaybeParser != nullptr);
+  ASSERT_TRUE(*MaybeParser != nullptr);
 
   remarks::RemarkParser &Parser = **MaybeParser;
   Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
   EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
   EXPECT_TRUE(*Remark != nullptr);               // At least one remark.
   Remark = Parser.next();
   Error E = Remark.takeError();
   EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
   EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
 }
 
 template <size_t N>
 bool parseExpectError(const char (&Buf)[N], const char *Error) {
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
       remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1});
   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
   EXPECT_TRUE(*MaybeParser != nullptr);
+  if (!*MaybeParser)
+    return false;
 
   remarks::RemarkParser &Parser = **MaybeParser;
   Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
   EXPECT_FALSE(Remark); // Check for parsing errors.
 
   std::string ErrorStr;
   raw_string_ostream Stream(ErrorStr);
   handleAllErrors(Remark.takeError(),
StringRef Buf = "\n"
                   "  - Caller: foo\n"
                   "    DebugLoc: { File: file.c, Line: 2, Column: 0 }\n"
                   "  - String: ' because its definition is unavailable'\n"
                   "\n";
 
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
       remarks::createRemarkParser(remarks::Format::YAML, Buf);
   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
-  EXPECT_TRUE(*MaybeParser != nullptr);
+  ASSERT_TRUE(*MaybeParser != nullptr);
 
   remarks::RemarkParser &Parser = **MaybeParser;
   Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
   EXPECT_FALSE(
       errorToBool(MaybeRemark.takeError())); // Check for parsing errors.
-  EXPECT_TRUE(*MaybeRemark != nullptr);      // At least one remark.
+  ASSERT_TRUE(*MaybeRemark != nullptr);      // At least one remark.
 
   const remarks::Remark &Remark = **MaybeRemark;
   EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
   EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
   EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
   EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
   EXPECT_TRUE(Remark.Loc);
   const remarks::RemarkLocation &RL = *Remark.Loc;
StringRef StrTabBuf =
                 "unavailable",
                 115);
 
   remarks::ParsedStringTable StrTab(StrTabBuf);
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
       remarks::createRemarkParser(remarks::Format::YAMLStrTab, Buf,
                                   std::move(StrTab));
   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
-  EXPECT_TRUE(*MaybeParser != nullptr);
+  ASSERT_TRUE(*MaybeParser != nullptr);
 
   remarks::RemarkParser &Parser = **MaybeParser;
   Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
   EXPECT_FALSE(
       errorToBool(MaybeRemark.takeError())); // Check for parsing errors.
-  EXPECT_TRUE(*MaybeRemark != nullptr);      // At least one remark.
+  ASSERT_TRUE(*MaybeRemark != nullptr);      // At least one remark.
 
   const remarks::Remark &Remark = **MaybeRemark;
   EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
   EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
   EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
   EXPECT_EQ(checkStr(Remark.FunctionName, 3), "foo");
   EXPECT_TRUE(Remark.Loc);
   const remarks::RemarkLocation &RL = *Remark.Loc;
TEST(YAMLRemarks, ParsingBadStringTableIndex) {
 
   StringRef StrTabBuf = StringRef("inline");
 
   remarks::ParsedStringTable StrTab(StrTabBuf);
   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
       remarks::createRemarkParser(remarks::Format::YAMLStrTab, Buf,
                                   std::move(StrTab));
   EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
-  EXPECT_TRUE(*MaybeParser != nullptr);
+  ASSERT_TRUE(*MaybeParser != nullptr);
 
   remarks::RemarkParser &Parser = **MaybeParser;
   Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
   EXPECT_FALSE(MaybeRemark); // Expect an error here.
 
   std::string ErrorStr;
   raw_string_ostream Stream(ErrorStr);
   handleAllErrors(MaybeRemark.takeError(),

llvm/unittests/Support/MemoryBufferTest.cpp

protected:
   typedef std::unique_ptr<MemoryBuffer> OwningBuffer;
 
   std::string data;
 };
 
 TEST_F(MemoryBufferTest, get) {
   // Default name and null-terminator flag
   OwningBuffer MB1(MemoryBuffer::getMemBuffer(data));
-  EXPECT_TRUE(nullptr != MB1.get());
+  ASSERT_TRUE(nullptr != MB1.get());
 
   // RequiresNullTerminator = false
   OwningBuffer MB2(MemoryBuffer::getMemBuffer(data, "one", false));
-  EXPECT_TRUE(nullptr != MB2.get());
+  ASSERT_TRUE(nullptr != MB2.get());
 
   // RequiresNullTerminator = true
   OwningBuffer MB3(MemoryBuffer::getMemBuffer(data, "two", true));
-  EXPECT_TRUE(nullptr != MB3.get());
+  ASSERT_TRUE(nullptr != MB3.get());
 
   // verify all 3 buffers point to the same address
   EXPECT_EQ(MB1->getBufferStart(), MB2->getBufferStart());
   EXPECT_EQ(MB2->getBufferStart(), MB3->getBufferStart());
 
   // verify the original data is unmodified after deleting the buffers
   MB1.reset();
   MB2.reset();
TEST_F(MemoryBufferTest, NullTerminator4K) {
   const char *BufData = MB.get()->getBufferStart();
   EXPECT_EQ('f', BufData[4095]);
   EXPECT_EQ('\0', BufData[4096]);
 }
 
 TEST_F(MemoryBufferTest, copy) {
   // copy with no name
   OwningBuffer MBC1(MemoryBuffer::getMemBufferCopy(data));
-  EXPECT_TRUE(nullptr != MBC1.get());
+  ASSERT_TRUE(nullptr != MBC1.get());
 
   // copy with a name
   OwningBuffer MBC2(MemoryBuffer::getMemBufferCopy(data, "copy"));
-  EXPECT_TRUE(nullptr != MBC2.get());
+  ASSERT_TRUE(nullptr != MBC2.get());
 
   // verify the two copies do not point to the same place
   EXPECT_NE(MBC1->getBufferStart(), MBC2->getBufferStart());
 }
 
 #if LLVM_ENABLE_THREADS
 TEST_F(MemoryBufferTest, createFromPipe) {
   sys::fs::file_t pipes[2];
TEST_F(MemoryBufferTest, make_new) {
   EXPECT_TRUE(nullptr != One.get());
 
   // uninitialized buffer with name
   OwningBuffer Two(WritableMemoryBuffer::getNewUninitMemBuffer(123, "bla"));
   EXPECT_TRUE(nullptr != Two.get());
 
   // 0-initialized buffer with no name
   OwningBuffer Three(WritableMemoryBuffer::getNewMemBuffer(321, data));
-  EXPECT_TRUE(nullptr != Three.get());
+  ASSERT_TRUE(nullptr != Three.get());
   for (size_t i = 0; i < 321; ++i)
     EXPECT_EQ(0, Three->getBufferStart()[0]);
 
   // 0-initialized buffer with name
   OwningBuffer Four(WritableMemoryBuffer::getNewMemBuffer(123, "zeros"));
-  EXPECT_TRUE(nullptr != Four.get());
+  ASSERT_TRUE(nullptr != Four.get());
   for (size_t i = 0; i < 123; ++i)
     EXPECT_EQ(0, Four->getBufferStart()[0]);
 }
 
 void MemoryBufferTest::testGetOpenFileSlice(bool Reopen) {
   // Test that MemoryBuffer::getOpenFile works properly when no null
   // terminator is requested and the size is large enough to trigger
   // the usage of memory mapping.

llvm/unittests/Target/ARM/MachineInstrTest.cpp

if (!T) {
     return;
   }
 
   TargetOptions Options;
   auto TM = std::unique_ptr<LLVMTargetMachine>(
     static_cast<LLVMTargetMachine*>(
       T->createTargetMachine(TT, "generic", "", Options, None, None,
                              CodeGenOpt::Default)));
+  ASSERT_TRUE(TM) << "Unable to create target machine";
   ARMSubtarget ST(TM->getTargetTriple(), std::string(TM->getTargetCPU()),
                   std::string(TM->getTargetFeatureString()),
                   *static_cast<const ARMBaseTargetMachine *>(TM.get()), false);
   const ARMBaseInstrInfo *TII = ST.getInstrInfo();
   auto MII = TM->getMCInstrInfo();
 
   for (unsigned i = 0; i < ARM::INSTRUCTION_LIST_END; ++i) {
     const MCInstrDesc &Desc = TII->get(i);
if (!T) {
     return;
   }
 
   TargetOptions Options;
   auto TM = std::unique_ptr<LLVMTargetMachine>(
     static_cast<LLVMTargetMachine*>(
       T->createTargetMachine(TT, "generic", "", Options, None, None,
                              CodeGenOpt::Default)));
+  ASSERT_TRUE(TM) << "Unable to create target machine";
   ARMSubtarget ST(TM->getTargetTriple(), std::string(TM->getTargetCPU()),
                   std::string(TM->getTargetFeatureString()),
                   *static_cast<const ARMBaseTargetMachine *>(TM.get()), false);
   const ARMBaseInstrInfo *TII = ST.getInstrInfo();
   auto MII = TM->getMCInstrInfo();
 
   for (unsigned i = 0; i < ARM::INSTRUCTION_LIST_END; ++i) {
     const MCInstrDesc &Desc = TII->get(i);
if (!T) {
     return;
   }
 
   TargetOptions Options;
   auto TM = std::unique_ptr<LLVMTargetMachine>(
     static_cast<LLVMTargetMachine*>(
       T->createTargetMachine(TT, "generic", "", Options, None, None,
                              CodeGenOpt::Default)));
+  ASSERT_TRUE(TM) << "Unable to create target machine";
   ARMSubtarget ST(TM->getTargetTriple(), std::string(TM->getTargetCPU()),
                   std::string(TM->getTargetFeatureString()),
                   *static_cast<const ARMBaseTargetMachine *>(TM.get()), false);
   const ARMBaseInstrInfo *TII = ST.getInstrInfo();
   auto MII = TM->getMCInstrInfo();
 
   for (unsigned i = 0; i < ARM::INSTRUCTION_LIST_END; ++i) {
     const MCInstrDesc &Desc = TII->get(i);
if (!T) {
     return;
   }
 
   TargetOptions Options;
   auto TM = std::unique_ptr<LLVMTargetMachine>(
     static_cast<LLVMTargetMachine*>(
       T->createTargetMachine(TT, "generic", "", Options, None, None,
                              CodeGenOpt::Default)));
+  ASSERT_TRUE(TM) << "Unable to create target machine";
   ARMSubtarget ST(TM->getTargetTriple(), std::string(TM->getTargetCPU()),
                   std::string(TM->getTargetFeatureString()),
                   *static_cast<const ARMBaseTargetMachine *>(TM.get()), false);
 
   auto MII = TM->getMCInstrInfo();
   for (unsigned i = 0; i < ARM::INSTRUCTION_LIST_END; ++i) {
     uint64_t Flags = MII->get(i).TSFlags;
     if ((Flags & ARMII::DomainMask) != ARMII::DomainMVE)
if (!T) {
     dbgs() << Error;
     return;
   }
 
   TargetOptions Options;
   auto TM = std::unique_ptr<LLVMTargetMachine>(
       static_cast<LLVMTargetMachine *>(T->createTargetMachine(
           TT, "generic", "", Options, None, None, CodeGenOpt::Default)));
+  ASSERT_TRUE(TM) << "Unable to create target machine";
   ARMSubtarget ST(TM->getTargetTriple(), std::string(TM->getTargetCPU()),
                   std::string(TM->getTargetFeatureString()),
                   *static_cast<const ARMBaseTargetMachine *>(TM.get()), false);
   const ARMBaseInstrInfo *TII = ST.getInstrInfo();
   auto MII = TM->getMCInstrInfo();
 
   for (unsigned Op = 0; Op < ARM::INSTRUCTION_LIST_END; ++Op) {
     const MCInstrDesc &Desc = TII->get(Op);

llvm/unittests/Transforms/IPO/AttributorTestBase.h

 class AttributorTestBase : public testing::Test {
 protected:
   std::unique_ptr<LLVMContext> Ctx;
   std::unique_ptr<Module> M;
 
   AttributorTestBase() : Ctx(new LLVMContext) {}
 
   Module &parseModule(const char *ModuleString) {
+    [&]() {
       SMDiagnostic Err;
       M = parseAssemblyString(ModuleString, Err, *Ctx);
-    EXPECT_TRUE(M);
+      ASSERT_TRUE(M);
+    }();
     return *M;
   }
 };
 
 } // namespace llvm
 
 #endif
 No newline at end of file

llvm/unittests/Transforms/Utils/BasicBlockUtilsTest.cpp

std::unique_ptr<Module> M = parseIR(
     "bb1:\n"
     "  %phi = phi i32 [ 0, %entry ], [ 1, %bb0 ]"
     "  ret i32 %phi\n"
     "bb2:\n"
     "  ret i32 42\n"
     "}\n"
     "\n"
     );
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *F = M->getFunction("has_unreachable");
   DominatorTree DT(*F);
   DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
 
   EXPECT_EQ(F->size(), (size_t)4);
   bool Result = EliminateUnreachableBlocks(*F, &DTU);
   EXPECT_TRUE(Result);
std::unique_ptr<Module> M = parseIR(
     "bb0:\n"
     "  br label %bb1\n"
     "bb1:\n"
     "  %phi = phi i32 [ 0, %entry ], [ 1, %bb0 ]"
     "  ret i32 %phi\n"
     "}\n"
     "\n"
     );
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *F = M->getFunction("no_unreachable");
   DominatorTree DT(*F);
   DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
 
   EXPECT_EQ(F->size(), (size_t)3);
   bool Result = EliminateUnreachableBlocks(*F, &DTU);
   EXPECT_FALSE(Result);
std::unique_ptr<Module> M = parseIR(
     "bb0:\n"
     "  br label %bb1\n"
     "bb1:\n"
     "  %phi = phi i32 [ 0, %entry ], [ 1, %bb0 ]"
     "  ret i32 %phi\n"
     "}\n"
     "\n"
     );
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *F = M->getFunction("basic_func");
   DominatorTree DT(*F);
 
   // Make sure the dominator tree is properly updated if calling this on the
   // entry block.
   SplitBlockPredecessors(&F->getEntryBlock(), {}, "split.entry", &DT);
   EXPECT_TRUE(DT.verify());
std::unique_ptr<Module> M = parseIR(
     "  br label %bb1\n"
     "bb1:\n"
     "  br label %bb2\n"
     "bb2:\n"
     "  ret void\n"
     "}\n"
     "\n"
     );
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *F = M->getFunction("crit_edge");
   DominatorTree DT(*F);
   PostDominatorTree PDT(*F);
 
   CriticalEdgeSplittingOptions CESO(&DT, nullptr, nullptr, &PDT);
   EXPECT_EQ(1u, SplitAllCriticalEdges(*F, CESO));
   EXPECT_TRUE(DT.verify());
std::unique_ptr<Module> M =
                  "bb1:\n"
                  "  %p = phi i32 [0, %bb0], [0, %entry]\n"
                  "  br i1 %cond1, label %bb2, label %bb3\n"
                  "bb2:\n"
                  "  ret void\n"
                  "bb3:\n"
                  "  ret void\n"
                  "}\n");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *F = M->getFunction("crit_edge");
   DominatorTree DT(*F);
   LoopInfo LI(DT);
   BranchProbabilityInfo BPI(*F, LI);
   BlockFrequencyInfo BFI(*F, BPI, LI);
 
   auto Block = [&F](StringRef BBName) -> const BasicBlock & {
std::unique_ptr<Module> M = parseIR(
          "  ret void\n"
          "L17:\n"
          "  ret void\n"
          "L18:\n"
          "  ret void\n"
          "L19:\n"
          "  ret void\n"
          "}\n");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *F = M->getFunction("edge_probability");
   DominatorTree DT(*F);
   LoopInfo LI(DT);
   BranchProbabilityInfo BPI(*F, LI);
 
   auto Block = [&F](StringRef BBName) -> const BasicBlock & {
     for (auto &BB : *F)

llvm/unittests/Transforms/Utils/CallPromotionUtilsTest.cpp

entry:
   %vtable.i = load void (%class.Interface*)**, void (%class.Interface*)*** %c
   %fp = load void (%class.Interface*)*, void (%class.Interface*)** %vtable.i
   call void %fp(%class.Interface* nonnull %base.i)
   ret void
 }
 
 declare void @_ZN4Impl3RunEv(%class.Impl* %this)
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);

 %class.Interface = type { i32 (...)** }
 
 define void @f(void (%class.Interface*)* %fp, %class.Interface* nonnull %base.i) {
 entry:
   call void %fp(%class.Interface* nonnull %base.i)
   ret void
 }
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);

 
 define void @f(void (%class.Interface*)** %vtable.i, %class.Interface* nonnull %base.i) {
 entry:
   %fp = load void (%class.Interface*)*, void (%class.Interface*)** %vtable.i
   call void %fp(%class.Interface* nonnull %base.i)
   ret void
 }
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
entry:
   %vtable.i = load void (%class.Interface*)**, void (%class.Interface*)*** %c
   %fp = load void (%class.Interface*)*, void (%class.Interface*)** %vtable.i
   call void %fp(%class.Interface* nonnull %base.i)
   ret void
 }
 
 declare void @_ZN4Impl3RunEv(%class.Impl* %this)
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
entry:
   %vtable.i = load void (%class.Interface*)**, void (%class.Interface*)*** %c
   %fp = load void (%class.Interface*)*, void (%class.Interface*)** %vtable.i
   call void %fp(%class.Interface* nonnull %base.i)
   ret void
 }
 
 declare void @_ZN4Impl3RunEv(%class.Impl* %this)
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
entry:
   %vtable.i = load void (%class.Interface*)**, void (%class.Interface*)*** %c
   %fp = load void (%class.Interface*)*, void (%class.Interface*)** %vtable.i
   call void %fp(%class.Interface* nonnull %base.i)
   ret void
 }
 
 declare void @_ZN4Impl3RunEv(%class.Impl* %this)
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
entry:
   %memptr.virtualfn.i = load i32 (%struct.A*)*, i32 (%struct.A*)** %5, align 8
   %call.i = call i32 %memptr.virtualfn.i(%struct.A* %a)
   ret i32 %call.i
 }
 
 declare i32 @_ZN1A3vf1Ev(%struct.A* %this)
 declare i32 @_ZN1A3vf2Ev(%struct.A* %this)
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *GV = M->getNamedValue("_Z2g1v");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
entry:
   %vtable.i = load %struct1 (%class.Interface*)**, %struct1 (%class.Interface*)*** %c
   %fp = load %struct1 (%class.Interface*)*, %struct1 (%class.Interface*)** %vtable.i
   %rv = call %struct1 %fp(%class.Interface* nonnull %base.i)
   ret %struct1 %rv
 }
 
 declare %struct2 @_ZN4Impl3RunEv(%class.Impl* %this)
 )IR");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
   Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
   ASSERT_FALSE(CI->getCalledFunction());
   bool IsPromoted = tryPromoteCall(*CI);
   EXPECT_FALSE(IsPromoted);
 }

llvm/unittests/Transforms/Utils/CloningTest.cpp

for.outer.latch:
   %cmp.outer = icmp slt i32 %inc.outer, %ub
   br i1 %cmp.outer, label %for.outer, label %for.outer.exit
 for.outer.exit:
   br label %for.end
 for.end:
   ret void
 })"
     );
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   runWithLoopInfoAndDominatorTree(
       *M, "foo", [&](Function &F, LoopInfo &LI, DominatorTree &DT) {
         Function::iterator FI = F.begin();
         // First basic block is entry - skip it.
         BasicBlock *Preheader = &*(++FI);
         BasicBlock *Header = &*(++FI);
         assert(Header->getName() == "for.outer");
StringRef ImplAssembly = R"(
     }
     declare void @bar()
   )";
 
   LLVMContext Context;
   SMDiagnostic Error;
 
   auto ImplModule = parseAssemblyString(ImplAssembly, Error, Context);
-  EXPECT_TRUE(ImplModule != nullptr);
+  ASSERT_TRUE(ImplModule != nullptr);
   auto *ImplFunction = ImplModule->getFunction("foo");
-  EXPECT_TRUE(ImplFunction != nullptr);
+  ASSERT_TRUE(ImplFunction != nullptr);
   auto *DeclFunction = ImplModule->getFunction("bar");
-  EXPECT_TRUE(DeclFunction != nullptr);
+  ASSERT_TRUE(DeclFunction != nullptr);
 
   ValueToValueMapTy VMap;
   SmallVector<ReturnInst *, 8> Returns;
   ClonedCodeInfo CCI;
   CloneFunctionInto(ImplFunction, DeclFunction, VMap, true, Returns, "", &CCI);
 
   EXPECT_FALSE(verifyModule(*ImplModule, &errs()));
   EXPECT_FALSE(CCI.ContainsCalls);
StringRef ImplAssembly = R"(
     }
     declare void @bar()
   )";
 
   LLVMContext Context;
   SMDiagnostic Error;
 
   auto ImplModule = parseAssemblyString(ImplAssembly, Error, Context);
-  EXPECT_TRUE(ImplModule != nullptr);
+  ASSERT_TRUE(ImplModule != nullptr);
   auto *ImplFunction = ImplModule->getFunction("foo");
-  EXPECT_TRUE(ImplFunction != nullptr);
+  ASSERT_TRUE(ImplFunction != nullptr);
   auto *DeclFunction = ImplModule->getFunction("bar");
-  EXPECT_TRUE(DeclFunction != nullptr);
+  ASSERT_TRUE(DeclFunction != nullptr);
 
   ValueToValueMapTy VMap;
   SmallVector<ReturnInst *, 8> Returns;
   ClonedCodeInfo CCI;
   CloneFunctionInto(DeclFunction, ImplFunction, VMap, true, Returns, "", &CCI);
 
   EXPECT_FALSE(verifyModule(*ImplModule, &errs()));
   EXPECT_TRUE(CCI.ContainsCalls);
StringRef ImplAssembly = R"(
     !6 = !DILocation(line: 55, column: 15, scope: !3, inlinedAt: !7)
     !7 = distinct !DILocation(line: 73, column: 14, scope: !5)
   )";
 
   LLVMContext Context;
   SMDiagnostic Error;
 
   auto ImplModule = parseAssemblyString(ImplAssembly, Error, Context);
-  EXPECT_TRUE(ImplModule != nullptr);
+  ASSERT_TRUE(ImplModule != nullptr);
   auto *OldFunc = ImplModule->getFunction("test");
-  EXPECT_TRUE(OldFunc != nullptr);
+  ASSERT_TRUE(OldFunc != nullptr);
   auto *NewFunc = ImplModule->getFunction("cloned");
-  EXPECT_TRUE(NewFunc != nullptr);
+  ASSERT_TRUE(NewFunc != nullptr);
 
   ValueToValueMapTy VMap;
   SmallVector<ReturnInst *, 8> Returns;
   ClonedCodeInfo CCI;
   CloneFunctionInto(NewFunc, OldFunc, VMap, true, Returns, "", &CCI);
 
   // This fails if the scopes in the llvm.dbg.declare variable and location
   // aren't the same.
TEST(CloneFunction, CloneFunctionToDifferentModule) {
   StringRef DeclAssembly = R"(
     declare void @foo()
   )";
 
   LLVMContext Context;
   SMDiagnostic Error;
 
   auto ImplModule = parseAssemblyString(ImplAssembly, Error, Context);
-  EXPECT_TRUE(ImplModule != nullptr);
+  ASSERT_TRUE(ImplModule != nullptr);
   // DICompileUnits: !2, !6. Only !2 is reachable from @foo().
   EXPECT_TRUE(GetDICompileUnitCount(*ImplModule) == 2);
   auto* ImplFunction = ImplModule->getFunction("foo");
-  EXPECT_TRUE(ImplFunction != nullptr);
+  ASSERT_TRUE(ImplFunction != nullptr);
 
   auto DeclModule = parseAssemblyString(DeclAssembly, Error, Context);
-  EXPECT_TRUE(DeclModule != nullptr);
+  ASSERT_TRUE(DeclModule != nullptr);
   // No DICompileUnits defined here.
   EXPECT_TRUE(GetDICompileUnitCount(*DeclModule) == 0);
   auto* DeclFunction = DeclModule->getFunction("foo");
-  EXPECT_TRUE(DeclFunction != nullptr);
+  ASSERT_TRUE(DeclFunction != nullptr);
 
   ValueToValueMapTy VMap;
   VMap[ImplFunction] = DeclFunction;
   // No args to map
   SmallVector<ReturnInst*, 8> Returns;
   CloneFunctionInto(DeclFunction, ImplFunction, VMap, true, Returns);
 
   EXPECT_FALSE(verifyModule(*ImplModule, &errs()));

llvm/unittests/Transforms/Utils/CodeMoverUtilsTest.cpp

std::unique_ptr<Module> M =
                  if.second.end:
                    br i1 %cond2, label %if.third, label %if.third.end
                  if.third:
                    store i32 3, i32* %i, align 4
                    br label %if.third.end
                  if.third.end:
                    ret void
                  })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.first");
         EXPECT_TRUE(
             isControlFlowEquivalent(*FirstIfBody, *FirstIfBody, DT, PDT));
         BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.second");
         EXPECT_TRUE(
std::unique_ptr<Module> M =
                    store i32 8, i32* %i, align 4
                    br label %if.sixth.end
                  if.sixth.else:
                    store i32 9, i32* %i, align 4
                    br label %if.sixth.end
                  if.sixth.end:
                    ret void
                  })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.first");
         BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.second");
         BasicBlock *ThirdIfBody = getBasicBlockByName(F, "if.third");
         BasicBlock *ThirdElseBody = getBasicBlockByName(F, "if.third.else");
         EXPECT_TRUE(
std::unique_ptr<Module> M =
          if.outer.second:
            br i1 %cond1, label %if.inner.second, label %if.second.end
          if.inner.second:
            store i32 2, i32* %i, align 4
            br label %if.second.end
          if.second.end:
            ret void
          })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         BasicBlock *FirstOuterIfBody = getBasicBlockByName(F, "if.outer.first");
         BasicBlock *FirstInnerIfBody = getBasicBlockByName(F, "if.inner.first");
         BasicBlock *SecondOuterIfBody =
             getBasicBlockByName(F, "if.outer.second");
         BasicBlock *SecondInnerIfBody =
std::unique_ptr<Module> M = parseIR(
          if.third.end:
            br i1 %cond1, label %if.fourth, label %if.fourth.end
          if.fourth:
            store i32 4, i32* %i, align 4
            br label %if.fourth.end
          if.fourth.end:
            ret void
          })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.inner.first");
         BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.inner.second");
         EXPECT_FALSE(
             isControlFlowEquivalent(*FirstIfBody, *SecondIfBody, DT, PDT));
 
std::unique_ptr<Module> M =
                    %tobool3 = icmp ne i32 %2, 0
                    br i1 %tobool3, label %if.third, label %if.third.end
                  if.third:
                    store i32 3, i32* %i, align 4
                    br label %if.third.end
                  if.third.end:
                    ret void
                  })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         BasicBlock *FirstIfBody = getBasicBlockByName(F, "if.first");
         BasicBlock *SecondIfBody = getBasicBlockByName(F, "if.second");
         // Limitation: if we can prove cond haven't been modify between %0 and
         // %1, then we can prove FirstIfBody and SecondIfBody are control flow
         // equivalent.
std::unique_ptr<Module> M =
                    br i1 %cond2, label %succ1ret, label %succ1succ1
                  succ1ret:
                    ret void
                  succ1succ1:
                    br label %bb
                  bb:
                    ret void
                  })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         BasicBlock &Idom = F.front();
         assert(Idom.getName() == "idom" && "Expecting BasicBlock idom");
         BasicBlock &BB = F.back();
         assert(BB.getName() == "bb" && "Expecting BasicBlock bb");
         EXPECT_FALSE(isControlFlowEquivalent(Idom, BB, DT, PDT));
std::unique_ptr<Module> M = parseIR(
            %cmp = icmp slt i64 %inc, %N
            br i1 %cmp, label %for.body, label %for.end
          for.end:
            ret void
          }
          declare void @safecall() nounwind nosync willreturn
          declare void @unsafecall1()
          declare void @unsafecall2())");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         BasicBlock *Entry = getBasicBlockByName(F, "entry");
         Instruction *CI_safecall = Entry->front().getNextNode();
         assert(isa<CallInst>(CI_safecall) &&
                "Expecting CI_safecall to be a CallInst");
std::unique_ptr<Module> M =
                    br i1 %cond, label %if.then.second, label %if.end.second
                  if.then.second:
                    %sub_op0 = add i32 %op0, 1
                    %sub = sub i32 %sub_op0, %op1
                    br label %if.end.second
                  if.end.second:
                    ret void
                  })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         Instruction *AddInst = getInstructionByName(F, "add");
         Instruction *SubInst = getInstructionByName(F, "sub");
 
         // Cannot move as %user uses %add and %sub doesn't dominates %user.
std::unique_ptr<Module> M = parseIR(C, R"(define void @foo(i64 %N) {
                    %inc = add nsw i64 %i, 1
                    br label %for.latch
                  for.latch:
                    %cmp = icmp slt i64 %inc, %N
                    br i1 %cmp, label %for.body, label %for.end
                  for.end:
                    ret void
                  })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         Instruction *IncInst = getInstructionByName(F, "inc");
         Instruction *CmpInst = getInstructionByName(F, "cmp");
 
         // Can move as the incoming block of %inc for %i (%for.latch) dominated
std::unique_ptr<Module> M =
                    br i1 %cond, label %if.end.second, label %if.then.second
                  if.then.second:
                    %sub_op0 = add i32 %op0, 1
                    %sub = sub i32 %sub_op0, %op1
                    br label %if.end.second
                  if.end.second:
                    ret void
                  })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         Instruction *AddInst = getInstructionByName(F, "add");
         Instruction *SubInst = getInstructionByName(F, "sub");
 
         // Cannot move as %user uses %add and %sub doesn't dominates %user.
entry:
     store i32 2, i32* %A, align 4 ; storeA2 
     store i32 4, i32* %B, align 4 ; StoreB1 
     %tmp2 = load i32, i32* %A, align 4 ; loadA2 
     %tmp3 = load i32, i32* %A, align 4 ; loadA3 
     %tmp4 = load i32, i32* %B, align 4 ; loadB2
     %tmp5 = load i32, i32* %B, align 4 ; loadB3
     ret void
 })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   run(*M, "dependence",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         Instruction *LoadA0 = getInstructionByName(F, "tmp0");
         Instruction *LoadA1 = getInstructionByName(F, "tmp1");
         Instruction *LoadA2 = getInstructionByName(F, "tmp2");
         Instruction *LoadA3 = getInstructionByName(F, "tmp3");
bb19:
         %tmp4 = load i32, i32* %B, align 4 ; loadB2
         br i1 %cond, label %bb20, label %bb21
     bb20:
        br label %bb21
     bb21:
        %tmp5 = load i32, i32* %B, align 4 ; loadB3
        ret void
    })");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   run(*M, "dependence",
       [&](Function &F, DominatorTree &DT, PostDominatorTree &PDT,
           DependenceInfo &DI) {
         BasicBlock *BB1 = getBasicBlockByName(F, "bb1");
         BasicBlock *BB3 = getBasicBlockByName(F, "bb3");
         BasicBlock *BB7 = getBasicBlockByName(F, "bb7");
         BasicBlock *BB11 = getBasicBlockByName(F, "bb11");
         BasicBlock *BB13 = getBasicBlockByName(F, "bb13");

llvm/unittests/Transforms/Utils/LocalTest.cpp

std::unique_ptr<Module> M = parseIR(C,
       !8 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 1, type: !9, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: false, unit: !0, retainedNodes: !2)
       !9 = !DISubroutineType(types: !10)
       !10 = !{null}
       !11 = !DILocalVariable(name: "x", scope: !8, file: !1, line: 2, type: !12)
       !12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
       !13 = !DILocation(line: 2, column: 7, scope: !8)
       !14 = !DILocation(line: 3, column: 1, scope: !8)
       )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
   Inst = Inst->getNextNode()->getNextNode();
auto Test = [&](Function &F, DomTreeUpdater &DTU) {
     if (DTU.hasPostDomTree()) {
       EXPECT_TRUE(DTU.getPostDomTree().verify());
     }
   };
 
   // Test MergeBasicBlockIntoOnlyPred working under Eager UpdateStrategy with
   // both DT and PDT.
   resetIR();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(*DT, PDT, DomTreeUpdater::UpdateStrategy::Eager);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Eager UpdateStrategy with
   // DT.
   resetIR();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     DomTreeUpdater DTU(*DT, DomTreeUpdater::UpdateStrategy::Eager);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Eager UpdateStrategy with
   // PDT.
   resetIR();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(PDT, DomTreeUpdater::UpdateStrategy::Eager);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Lazy UpdateStrategy with
   // both DT and PDT.
   resetIR();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(*DT, PDT, DomTreeUpdater::UpdateStrategy::Lazy);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Lazy UpdateStrategy with
   // PDT.
   resetIR();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(PDT, DomTreeUpdater::UpdateStrategy::Lazy);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Lazy UpdateStrategy with DT.
   resetIR();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     DomTreeUpdater DTU(*DT, DomTreeUpdater::UpdateStrategy::Lazy);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Eager UpdateStrategy with
   // both DT and PDT.
   resetIRReplaceEntry();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(*DT, PDT, DomTreeUpdater::UpdateStrategy::Eager);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Eager UpdateStrategy with
   // DT.
   resetIRReplaceEntry();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     DomTreeUpdater DTU(*DT, DomTreeUpdater::UpdateStrategy::Eager);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Eager UpdateStrategy with
   // PDT.
   resetIRReplaceEntry();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(PDT, DomTreeUpdater::UpdateStrategy::Eager);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Lazy UpdateStrategy with
   // both DT and PDT.
   resetIRReplaceEntry();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(*DT, PDT, DomTreeUpdater::UpdateStrategy::Lazy);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Lazy UpdateStrategy with
   // PDT.
   resetIRReplaceEntry();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(PDT, DomTreeUpdater::UpdateStrategy::Lazy);
     Test(F, DTU);
   });
 
   // Test MergeBasicBlockIntoOnlyPred working under Lazy UpdateStrategy with DT.
   resetIRReplaceEntry();
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
   runWithDomTree(*M, "f", [&](Function &F, DominatorTree *DT) {
     DomTreeUpdater DTU(*DT, DomTreeUpdater::UpdateStrategy::Lazy);
     Test(F, DTU);
   });
 }
 
 TEST(Local, ConstantFoldTerminator) {
   LLVMContext C;
std::unique_ptr<Module> M = parseIR(C,
       entry:
         indirectbr i8* blockaddress(@indirectbr_unreachable, %bb0), [label %bb1]
       bb0:
         ret void
       bb1:
         ret void
       }
         )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto CFAllTerminatorsEager = [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(*DT, PDT, DomTreeUpdater::UpdateStrategy::Eager);
     for (Function::iterator I = F.begin(), E = F.end(); I != E;) {
       BasicBlock *BB = &*I++;
       ConstantFoldTerminator(BB, true, nullptr, &DTU);
     }
M = parseIR(C,
       !8 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 1, type: !9, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: false, unit: !0, retainedNodes: !2)
       !9 = !DISubroutineType(types: !10)
       !10 = !{null}
       !11 = !DILocalVariable(name: "x", scope: !8, file: !1, line: 2, type: !12)
       !12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
       !13 = !DILocation(line: 2, column: 7, scope: !8)
       !14 = !DILocation(line: 3, column: 1, scope: !8)
       )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
     auto *GV = M->getNamedValue("f");
     ASSERT_TRUE(GV);
     F = dyn_cast<Function>(GV);
     ASSERT_TRUE(F);
   }
 
   bool doesDebugValueDescribeX(const DbgValueInst &DI) {
std::unique_ptr<Module> M = parseIR(Ctx,
     !2 = !{}
     !3 = !{i32 1}
     !4 = !{i32 0}
     !5 = !{i32 2, !"Debug Info Version", i32 3}
     !6 = distinct !DISubprogram(name: "foo", linkageName: "foo", scope: null, file: !1, line: 1, type: !7, isLocal: true, isDefinition: true, scopeLine: 1, isOptimized: true, unit: !0, retainedNodes: !2)
     !7 = !DISubroutineType(types: !2)
     !8 = !DILocation(line: 1, column: 1, scope: !6)
   )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   bool BrokenDebugInfo = true;
   verifyModule(*M, &errs(), &BrokenDebugInfo);
   ASSERT_FALSE(BrokenDebugInfo);
 
   Function &F = *cast<Function>(M->getNamedValue("foo"));
 
   BasicBlock &BB = F.front();
std::unique_ptr<Module> M = parseIR(Ctx,
     !14 = !DILocalVariable(name: "4", scope: !6, file: !1, line: 4, type: !10)
     !15 = !DILocation(line: 1, column: 1, scope: !6)
     !16 = !DILocation(line: 2, column: 1, scope: !6)
     !17 = !DILocation(line: 3, column: 1, scope: !6)
     !18 = !DILocation(line: 4, column: 1, scope: !6)
     !19 = !DILocation(line: 5, column: 1, scope: !6)
     !20 = !DILocalVariable(name: "5", scope: !6, file: !1, line: 5, type: !10)
   )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   bool BrokenDebugInfo = true;
   verifyModule(*M, &errs(), &BrokenDebugInfo);
   ASSERT_FALSE(BrokenDebugInfo);
 
   Function &F = *cast<Function>(M->getNamedValue("f"));
   DominatorTree DT{F};
 
std::unique_ptr<Module> M = parseIR(C,
         br label %exit
 
       exit:
         ret void
       }
 
       declare i1 @invokable()
       )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto runEager = [&](Function &F, DominatorTree *DT) {
     PostDominatorTree PDT = PostDominatorTree(F);
     DomTreeUpdater DTU(*DT, PDT, DomTreeUpdater::UpdateStrategy::Eager);
     removeUnreachableBlocks(F, &DTU);
     EXPECT_TRUE(DTU.getDomTree().verify());
     EXPECT_TRUE(DTU.getPostDomTree().verify());
   };
M = parseIR(C,
               R"(
       define void @f() {
       entry:
         ret void
       bb0:
         ret void
       }
         )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto checkRUBlocksRetVal = [&](Function &F, DominatorTree *DT) {
     DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy);
     EXPECT_TRUE(removeUnreachableBlocks(F, &DTU));
     EXPECT_FALSE(removeUnreachableBlocks(F, &DTU));
     EXPECT_TRUE(DTU.getDomTree().verify());
   };
 
test.bb:
       call void @llvm.assume(i1 %0)
       br i1 %phi, label %if.bb2, label %then.bb2
     if.bb2:
       ret i32 %1
     then.bb2:
       ret i32 0
     }
   )");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   Function &F = *cast<Function>(M->getNamedValue("foo"));
   TargetTransformInfo TTI(M->getDataLayout());
 
   SimplifyCFGOptions Options{};
   Options.setAssumptionCache(nullptr);
 
   // Obtain BasicBlock of interest to this test, %test.bb.

llvm/unittests/Transforms/Utils/LoopRotationUtilsTest.cpp

 return:
   ret i32 %sum
 
 deopt.exit:
   %deopt.val = call i32(...) @llvm.experimental.deoptimize.i32() [ "deopt"(i32 %val.a.idx) ]
   ret i32 %deopt.val
 })"
     );
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *F = M->getFunction("test");
   DominatorTree DT(*F);
   LoopInfo LI(DT);
   AssumptionCache AC(*F);
   TargetTransformInfo TTI(M->getDataLayout());
   TargetLibraryInfoImpl TLII;
   TargetLibraryInfo TLI(TLII);

 return:
   ret i32 %sum
 
 deopt.exit:
   %deopt.val = call i32(...) @llvm.experimental.deoptimize.i32() [ "deopt"(i32 %val.a.idx) ]
   ret i32 %deopt.val
 })"
     );
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *F = M->getFunction("test_nondup");
   DominatorTree DT(*F);
   LoopInfo LI(DT);
   AssumptionCache AC(*F);
   TargetTransformInfo TTI(M->getDataLayout());
   TargetLibraryInfoImpl TLII;
   TargetLibraryInfo TLI(TLII);

llvm/unittests/Transforms/Utils/LoopUtilsTest.cpp

std::unique_ptr<Module> M =
                  "  br i1 %cmp.k, label %for.k, label %for.i.latch\n"
                  "for.i.latch:\n"
                  "  %inc.i = add nsw i64 %i, 1\n"
                  "  %cmp.i = icmp slt i64 %inc.i, 100\n"
                  "  br i1 %cmp.i, label %for.i, label %for.end\n"
                  "for.end:\n"
                  "  ret void\n"
                  "}\n");
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   run(*M, "foo",
       [&](Function &F, DominatorTree &DT, ScalarEvolution &SE, LoopInfo &LI) {
         assert(LI.begin() != LI.end() && "Expecting loops in function F");
         Loop *L = *LI.begin();
         assert(L && L->getName() == "for.i" && "Expecting loop for.i");
 
         deleteDeadLoop(L, &DT, &SE, &LI);

llvm/unittests/Transforms/Utils/UnrollLoopTest.cpp

while.body:                                       ; preds = %while.cond
   store i32 %mul, i32* %arrayidx2
   %inc = add nsw i64 %i.0, 1
   br label %while.cond
 
 while.end:                                        ; preds = %while.cond
   ret i32 0
 })"
     );
+  ASSERT_TRUE(M) << "Unable to parse the assembly string";
 
   auto *F = M->getFunction("test");
   DominatorTree DT(*F);
   LoopInfo LI(DT);
   AssumptionCache AC(*F);
   TargetLibraryInfoImpl TLII;
   TargetLibraryInfo TLI(TLII);
   ScalarEvolution SE(*F, TLI, AC, DT, LI);

llvm/unittests/tools/llvm-exegesis/PowerPC/AnalysisTest.cpp

protected:
   AnalysisTest() {
     const std::string TT = "powerpc64le-unknown-linux";
     std::string error;
     const Target *const TheTarget = TargetRegistry::lookupTarget(TT, error);
     if (!TheTarget) {
       errs() << error << "\n";
       return;
     }
+    [&]() {
       STI.reset(TheTarget->createMCSubtargetInfo(TT, "pwr9", ""));
+      ASSERT_TRUE(STI) << "Unable to create subtarget info";
+    }();
+    if (!STI)
+      return;
 
     // Compute the ProxResIdx of ports uses in tests.
     const auto &SM = STI->getSchedModel();
     for (unsigned I = 0, E = SM.getNumProcResourceKinds(); I < E; ++I) {
       const std::string Name = SM.getProcResource(I)->Name;
       if (Name == "ALU") {
         ALUIdx = I;
       } else if (Name == "ALUE") {

llvm/unittests/tools/llvm-exegesis/PowerPC/TargetTest.cpp

 using testing::Not;
 
 constexpr const char kTriple[] = "powerpc64le-unknown-linux";
 
 class PowerPCTargetTest : public ::testing::Test {
 protected:
   PowerPCTargetTest()
       : ExegesisTarget_(ExegesisTarget::lookup(Triple(kTriple))) {
-    EXPECT_THAT(ExegesisTarget_, NotNull());
+    [&]() {
+      ASSERT_THAT(ExegesisTarget_, NotNull());
       std::string error;
       Target_ = TargetRegistry::lookupTarget(kTriple, error);
-    EXPECT_THAT(Target_, NotNull());
+      ASSERT_THAT(Target_, NotNull());
+    }();
   }
   static void SetUpTestCase() {
     LLVMInitializePowerPCTargetInfo();
     LLVMInitializePowerPCTarget();
     LLVMInitializePowerPCTargetMC();
     InitializePowerPCExegesisTarget();
   }
 
   const Target *Target_;
   const ExegesisTarget *const ExegesisTarget_;
 };
 
 TEST_F(PowerPCTargetTest, SetRegToConstant) {
   const std::unique_ptr<MCSubtargetInfo> STI(
       Target_->createMCSubtargetInfo(kTriple, "generic", ""));
+  ASSERT_TRUE(STI) << "Unable to create subtarget info";
   const auto Insts = ExegesisTarget_->setRegTo(*STI, PPC::X0, APInt());
   EXPECT_THAT(Insts, Not(IsEmpty()));
 }
 
 TEST_F(PowerPCTargetTest, DefaultPfmCounters) {
   const std::string Expected = "CYCLES";
   EXPECT_EQ(ExegesisTarget_->getPfmCounters("").CycleCounter, Expected);
   EXPECT_EQ(ExegesisTarget_->getPfmCounters("unknown_cpu").CycleCounter,
             Expected);
 }
 
 } // namespace
 } // namespace exegesis
 } // namespace llvm