Made llvm-cfi-verify not execute unit tests on non-x86 builds.

[hctim]

Summary

Patched out from D38427.

[vlad.tsyrklevich]

unittests/tools/llvm-cfi-verify/GraphBuilder.cpp

132 ↗

(On Diff #119895)

nit: Put this in the error handler instead of having it here.

[hctim]

Put unsuccessful initialisation and message in error event handler.

llvm/trunk/tools/llvm-cfi-verify/lib/FileAnalysis.h

private:
 
   // A list of addresses of indirect control flow instructions.
   std::set<uint64_t> IndirectInstructions;
 };
 
 class UnsupportedDisassembly : public ErrorInfo<UnsupportedDisassembly> {
 public:
   static char ID;
+  std::string Text;
+
+  UnsupportedDisassembly(StringRef Text);
 
   void log(raw_ostream &OS) const override;
   std::error_code convertToErrorCode() const override;
 };
 
 } // namespace cfi_verify
 } // namespace llvm
 
 #endif // LLVM_CFI_VERIFY_FILE_ANALYSIS_H

llvm/trunk/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

if (!BinaryOrErr)
     return BinaryOrErr.takeError();
 
   // Construct the object and allow it to take ownership of the binary.
   object::OwningBinary<object::Binary> Binary = std::move(BinaryOrErr.get());
   FileAnalysis Analysis(std::move(Binary));
 
   Analysis.Object = dyn_cast<object::ObjectFile>(Analysis.Binary.getBinary());
   if (!Analysis.Object)
-    return make_error<UnsupportedDisassembly>();
+    return make_error<UnsupportedDisassembly>("Failed to cast object");
 
   Analysis.ObjectTriple = Analysis.Object->makeTriple();
   Analysis.Features = Analysis.Object->getFeatures();
 
   // Init the rest of the object.
   if (auto InitResponse = Analysis.initialiseDisassemblyMembers())
     return std::move(InitResponse);
 
Error FileAnalysis::initialiseDisassemblyMembers() {
   std::string TripleName = ObjectTriple.getTriple();
   ArchName = "";
   MCPU = "";
   std::string ErrorString;
 
   ObjectTarget =
       TargetRegistry::lookupTarget(ArchName, ObjectTriple, ErrorString);
   if (!ObjectTarget)
-    return make_error<StringError>(Twine("Couldn't find target \"") +
-                                       ObjectTriple.getTriple() +
-                                       "\", failed with error: " + ErrorString,
-                                   inconvertibleErrorCode());
+    return make_error<UnsupportedDisassembly>(
+        (Twine("Couldn't find target \"") + ObjectTriple.getTriple() +
+        "\", failed with error: " + ErrorString).str());
 
   RegisterInfo.reset(ObjectTarget->createMCRegInfo(TripleName));
   if (!RegisterInfo)
-    return make_error<StringError>("Failed to initialise RegisterInfo.",
-                                   inconvertibleErrorCode());
+    return make_error<UnsupportedDisassembly>(
+        "Failed to initialise RegisterInfo.");
 
   AsmInfo.reset(ObjectTarget->createMCAsmInfo(*RegisterInfo, TripleName));
   if (!AsmInfo)
-    return make_error<StringError>("Failed to initialise AsmInfo.",
-                                   inconvertibleErrorCode());
+    return make_error<UnsupportedDisassembly>("Failed to initialise AsmInfo.");
 
   SubtargetInfo.reset(ObjectTarget->createMCSubtargetInfo(
       TripleName, MCPU, Features.getString()));
   if (!SubtargetInfo)
-    return make_error<StringError>("Failed to initialise SubtargetInfo.",
-                                   inconvertibleErrorCode());
+    return make_error<UnsupportedDisassembly>(
+        "Failed to initialise SubtargetInfo.");
 
   MII.reset(ObjectTarget->createMCInstrInfo());
   if (!MII)
-    return make_error<StringError>("Failed to initialise MII.",
-                                   inconvertibleErrorCode());
+    return make_error<UnsupportedDisassembly>("Failed to initialise MII.");
 
   Context.reset(new MCContext(AsmInfo.get(), RegisterInfo.get(), &MOFI));
 
   Disassembler.reset(
       ObjectTarget->createMCDisassembler(*SubtargetInfo, *Context));
 
   if (!Disassembler)
-    return make_error<StringError>("No disassembler available for target",
-                                   inconvertibleErrorCode());
+    return make_error<UnsupportedDisassembly>(
+        "No disassembler available for target");
 
   MIA.reset(ObjectTarget->createMCInstrAnalysis(MII.get()));
 
   Printer.reset(ObjectTarget->createMCInstPrinter(
       ObjectTriple, AsmInfo->getAssemblerDialect(), *AsmInfo, *MII,
       *RegisterInfo));
 
   return Error::success();
void FileAnalysis::addInstruction(const Instr &Instruction) {
   if (!KV.second) {
     errs() << "Failed to add instruction at address "
            << format_hex(Instruction.VMAddress, 2)
            << ": Instruction at this address already exists.\n";
     exit(EXIT_FAILURE);
   }
 }
 
+UnsupportedDisassembly::UnsupportedDisassembly(StringRef Text) : Text(Text) {}
+
 char UnsupportedDisassembly::ID;
 void UnsupportedDisassembly::log(raw_ostream &OS) const {
-  OS << "Dissassembling of non-objects not currently supported.\n";
+  OS << "Could not initialise disassembler: " << Text;
 }
 
 std::error_code UnsupportedDisassembly::convertToErrorCode() const {
   return std::error_code();
 }
 
 } // namespace cfi_verify
 } // namespace llvm

llvm/trunk/unittests/tools/llvm-cfi-verify/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmPrinters
   AllTargetsAsmParsers
   AllTargetsDescs
   AllTargetsDisassemblers
   AllTargetsInfos
   CFIVerify
   MC
   MCParser
   Object
   Support
   )
 
-list(FIND LLVM_TARGETS_TO_BUILD "X86" x86_idx)
-if (NOT x86_idx LESS 0)
-  add_llvm_unittest(CFIVerifyTests
-    FileAnalysis.cpp
-    GraphBuilder.cpp)
-endif()

llvm/trunk/unittests/tools/llvm-cfi-verify/FileAnalysis.cpp

public:
   Error initialiseDisassemblyMembers() {
     return FileAnalysis::initialiseDisassemblyMembers();
   }
 };
 
 class BasicFileAnalysisTest : public ::testing::Test {
 protected:
   virtual void SetUp() {
-    if (Analysis.initialiseDisassemblyMembers()) {
-      FAIL() << "Failed to initialise FileAnalysis.";
+    SuccessfullyInitialised = true;
+    if (auto Err = Analysis.initialiseDisassemblyMembers()) {
+      handleAllErrors(std::move(Err), [&](const UnsupportedDisassembly &E) {
+        SuccessfullyInitialised = false;
+        outs()
+            << "Note: CFIVerifyTests are disabled due to lack of x86 support "
+               "on this build.\n";
+      });
     }
   }
 
+  bool SuccessfullyInitialised;
   ELFx86TestFileAnalysis Analysis;
 };
 
 TEST_F(BasicFileAnalysisTest, BasicDisassemblyTraversalTest) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x90,                   // 0: nop
           0xb0, 0x00,             // 1: mov $0x0, %al
           0x48, 0x89, 0xe5,       // 3: mov %rsp, %rbp
           0x48, 0x83, 0xec, 0x18, // 6: sub $0x18, %rsp
           0x48, 0xbe, 0xc4, 0x07, 0x40,
           0x00, 0x00, 0x00, 0x00, 0x00, // 10: movabs $0x4007c4, %rsi
TEST_F(BasicFileAnalysisTest, BasicDisassemblyTraversalTest) {
   EXPECT_EQ(5u, InstrMeta->InstructionSize);
   EXPECT_FALSE(InstrMeta->Valid);
 
   EXPECT_EQ(nullptr, Analysis.getNextInstructionSequential(*InstrMeta));
   EXPECT_EQ(nullptr, Analysis.getPrevInstructionSequential(*InstrMeta));
 }
 
 TEST_F(BasicFileAnalysisTest, PrevAndNextFromBadInst) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x90, // 0: nop
           0x2f, // 1: (bad)
           0x90  // 2: nop
       },
       0xDEADBEEF);
   const auto &BadInstrMeta = Analysis.getInstructionOrDie(0xDEADBEEF + 1);
   const auto *GoodInstrMeta =
       Analysis.getPrevInstructionSequential(BadInstrMeta);
   EXPECT_NE(nullptr, GoodInstrMeta);
   EXPECT_EQ(0xDEADBEEF, GoodInstrMeta->VMAddress);
   EXPECT_EQ(1u, GoodInstrMeta->InstructionSize);
 
   GoodInstrMeta = Analysis.getNextInstructionSequential(BadInstrMeta);
   EXPECT_NE(nullptr, GoodInstrMeta);
   EXPECT_EQ(0xDEADBEEF + 2, GoodInstrMeta->VMAddress);
   EXPECT_EQ(1u, GoodInstrMeta->InstructionSize);
 }
 
 TEST_F(BasicFileAnalysisTest, CFITrapTest) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x90,                   // 0: nop
           0xb0, 0x00,             // 1: mov $0x0, %al
           0x48, 0x89, 0xe5,       // 3: mov %rsp, %rbp
           0x48, 0x83, 0xec, 0x18, // 6: sub $0x18, %rsp
           0x48, 0xbe, 0xc4, 0x07, 0x40,
           0x00, 0x00, 0x00, 0x00, 0x00, // 10: movabs $0x4007c4, %rsi
EXPECT_FALSE(
       Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 21)));
   EXPECT_FALSE(
       Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 23)));
   EXPECT_TRUE(
       Analysis.isCFITrap(Analysis.getInstructionOrDie(0xDEADBEEF + 28)));
 }
 
 TEST_F(BasicFileAnalysisTest, FallThroughTest) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x90,                         // 0: nop
           0xb0, 0x00,                   // 1: mov $0x0, %al
           0x2f,                         // 3: (bad)
           0x0f, 0x0b,                   // 4: ud2
           0xff, 0x20,                   // 6: jmpq *(%rax)
           0xeb, 0x00,                   // 8: jmp +0
EXPECT_FALSE(
       Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 15)));
   EXPECT_TRUE(
       Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 17)));
   EXPECT_FALSE(
       Analysis.canFallThrough(Analysis.getInstructionOrDie(0xDEADBEEF + 19)));
 }
 
 TEST_F(BasicFileAnalysisTest, DefiniteNextInstructionTest) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x90,                         // 0: nop
           0xb0, 0x00,                   // 1: mov $0x0, %al
           0x2f,                         // 3: (bad)
           0x0f, 0x0b,                   // 4: ud2
           0xff, 0x20,                   // 6: jmpq *(%rax)
           0xeb, 0x00,                   // 8: jmp 10 [+0]
TEST_F(BasicFileAnalysisTest, DefiniteNextInstructionTest) {
 
   Current = Analysis.getInstruction(0xDEADBEEF + 38);
   Next = Analysis.getDefiniteNextInstruction(*Current);
   EXPECT_NE(nullptr, Next);
   EXPECT_EQ(0xDEADBEEF + 4, Next->VMAddress);
 }
 
 TEST_F(BasicFileAnalysisTest, ControlFlowXRefsTest) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x90,                         // 0: nop
           0xb0, 0x00,                   // 1: mov $0x0, %al
           0x2f,                         // 3: (bad)
           0x0f, 0x0b,                   // 4: ud2
           0xff, 0x20,                   // 6: jmpq *(%rax)
           0xeb, 0x00,                   // 8: jmp 10 [+0]

llvm/trunk/unittests/tools/llvm-cfi-verify/GraphBuilder.cpp

public:
   Error initialiseDisassemblyMembers() {
     return FileAnalysis::initialiseDisassemblyMembers();
   }
 };
 
 class BasicGraphBuilderTest : public ::testing::Test {
 protected:
   virtual void SetUp() {
-    if (Analysis.initialiseDisassemblyMembers()) {
-      FAIL() << "Failed to initialise FileAnalysis.";
+    SuccessfullyInitialised = true;
+    if (auto Err = Analysis.initialiseDisassemblyMembers()) {
+      handleAllErrors(std::move(Err), [&](const UnsupportedDisassembly &E) {
+        SuccessfullyInitialised = false;
+        outs()
+            << "Note: CFIVerifyTests are disabled due to lack of x86 support "
+               "on this build.\n";
+      });
     }
   }
 
+  bool SuccessfullyInitialised;
   ELFx86TestFileAnalysis Analysis;
 };
 
 MATCHER_P2(HasPath, Result, Matcher, "has path " + PrintToString(Matcher)) {
   const auto &Path = Result.flattenAddress(arg);
   *result_listener << "the path is " << PrintToString(Path);
   return Matches(Matcher)(Path);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphTestSinglePathFallthroughUd2) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0x0f, 0x0b, // 2: ud2
           0xff, 0x10, // 4: callq *(%rax)
       },
       0xDEADBEEF);
   const auto Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
 
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(1));
   EXPECT_THAT(Result.ConditionalBranchNodes,
               Each(Field(&ConditionalBranchNode::CFIProtection, Eq(true))));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Contains(AllOf(Field(&ConditionalBranchNode::Address, Eq(0xDEADBEEF)),
                      Field(&ConditionalBranchNode::Target,
                            HasPath(Result, ElementsAre(0xDEADBEEF + 4))),
                      Field(&ConditionalBranchNode::Fallthrough,
                            HasPath(Result, ElementsAre(0xDEADBEEF + 2))))))
       << PrintToString(Result);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphTestSinglePathJumpUd2) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0xff, 0x10, // 2: callq *(%rax)
           0x0f, 0x0b, // 4: ud2
       },
       0xDEADBEEF);
   const auto Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
 
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(1));
   EXPECT_THAT(Result.ConditionalBranchNodes,
               Each(Field(&ConditionalBranchNode::CFIProtection, Eq(true))));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Contains(AllOf(Field(&ConditionalBranchNode::Address, Eq(0xDEADBEEF)),
                      Field(&ConditionalBranchNode::Target,
                            HasPath(Result, ElementsAre(0xDEADBEEF + 4))),
                      Field(&ConditionalBranchNode::Fallthrough,
                            HasPath(Result, ElementsAre(0xDEADBEEF + 2))))))
       << PrintToString(Result);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphTestDualPathDualUd2) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0x03, // 0: jne 5 [+3]
           0x90,       // 2: nop
           0xff, 0x10, // 3: callq *(%rax)
           0x0f, 0x0b, // 5: ud2
           0x75, 0xf9, // 7: jne 2 [-7]
           0x0f, 0x0b, // 9: ud2
EXPECT_THAT(
           Field(&ConditionalBranchNode::Fallthrough,
                 HasPath(Result, ElementsAre(0xDEADBEEF + 9))),
           Field(&ConditionalBranchNode::Target,
                 HasPath(Result, ElementsAre(0xDEADBEEF + 2, 0xDEADBEEF + 3))))))
       << PrintToString(Result);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphTestDualPathSingleUd2) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0x05, // 0: jne 7 [+5]
           0x90,       // 2: nop
           0xff, 0x10, // 3: callq *(%rax)
           0x75, 0xfb, // 5: jne 2 [-5]
           0x0f, 0x0b, // 7: ud2
       },
EXPECT_THAT(
           Field(&ConditionalBranchNode::Fallthrough,
                 HasPath(Result, ElementsAre(0xDEADBEEF + 7))),
           Field(&ConditionalBranchNode::Target,
                 HasPath(Result, ElementsAre(0xDEADBEEF + 2, 0xDEADBEEF + 3))))))
       << PrintToString(Result);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphFailures) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x90,       // 0: nop
           0x75, 0xfe, // 1: jne 1 [-2]
       },
       0xDEADBEEF);
   GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF);
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 
   Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 1);
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 
   Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADC0DE);
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphNoXrefs) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0xeb, 0xfe, // 0: jmp 0 [-2]
           0xff, 0x10, // 2: callq *(%rax)
       },
       0xDEADBEEF);
   GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
   EXPECT_THAT(Result.OrphanedNodes, ElementsAre(0xDEADBEEF + 2));
   EXPECT_THAT(Result.IntermediateNodes, IsEmpty());
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphConditionalInfiniteLoop) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0xfe, // 0: jne 0 [-2]
           0xff, 0x10, // 2: callq *(%rax)
       },
       0xDEADBEEF);
   GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 2);
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(1));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Each(AllOf(Field(&ConditionalBranchNode::CFIProtection, Eq(false)),
                  Field(&ConditionalBranchNode::Target,
                        HasPath(Result, ElementsAre(0xDEADBEEF))),
                  Field(&ConditionalBranchNode::Fallthrough,
                        HasPath(Result, ElementsAre(0xDEADBEEF + 2))))))
       << PrintToString(Result);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphUnconditionalInfiniteLoop) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0xeb, 0xfc, // 2: jmp 0 [-4]
           0xff, 0x10, // 4: callq *(%rax)
       },
       0xDEADBEEF);
   GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
   EXPECT_THAT(Result.OrphanedNodes, IsEmpty());
   EXPECT_THAT(Result.ConditionalBranchNodes, SizeIs(1));
   EXPECT_THAT(
       Result.ConditionalBranchNodes,
       Contains(
           AllOf(Field(&ConditionalBranchNode::Address, Eq(0xDEADBEEF)),
                 Field(&ConditionalBranchNode::Fallthrough,
                       HasPath(Result, ElementsAre(0xDEADBEEF + 2, 0xDEADBEEF))),
                 Field(&ConditionalBranchNode::Target,
                       HasPath(Result, ElementsAre(0xDEADBEEF + 4))))))
       << PrintToString(Result);
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphNoFlowsToIndirection) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0x00, // 0: jne 2 [+0]
           0xeb, 0xfc, // 2: jmp 0 [-4]
           0xff, 0x10, // 4: callq *(%rax)
       },
       0xDEADBEEF);
   GraphResult Result = GraphBuilder::buildFlowGraph(Analysis, 0xDEADBEEF + 4);
   EXPECT_THAT(Result.OrphanedNodes, ElementsAre(0xDEADBEEF + 4));
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphLengthExceededUpwards) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0x06, // 0: jne 8 [+6]
           0x90,       // 2: nop
           0x90,       // 3: nop
           0x90,       // 4: nop
           0x90,       // 5: nop
           0xff, 0x10, // 6: callq *(%rax)
EXPECT_THAT(Result.OrphanedNodes,
                                                0xDEADBEEF + 6))))
       << PrintToString(Result);
   EXPECT_THAT(Result.ConditionalBranchNodes, IsEmpty());
 
   SearchLengthForConditionalBranch = PrevSearchLengthForConditionalBranch;
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphLengthExceededDownwards) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0x02, // 0: jne 4 [+2]
           0xff, 0x10, // 2: callq *(%rax)
           0x90,       // 4: nop
           0x90,       // 5: nop
           0x90,       // 6: nop
           0x90,       // 7: nop
TEST_F(BasicGraphBuilderTest, BuildFlowGraphLengthExceededDownwards) {
 
   SearchLengthForUndef = PrevSearchLengthForUndef;
 }
 
 // This test ensures when avoiding doing repeated work we still generate the
 // paths correctly. We don't need to recalculate the flow from 0x2 -> 0x3 as it
 // should only need to be generated once.
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphWithRepeatedWork) {
+  if (!SuccessfullyInitialised)
+    return;
   Analysis.parseSectionContents(
       {
           0x75, 0x05, // 0: jne 7 [+5]
           0x90,       // 2: nop
           0xff, 0x10, // 3: callq *(%rax)
           0x75, 0xfb, // 5: jne 2 [-5]
           0x0f, 0x0b, // 7: ud2
       },
EXPECT_THAT(
                 HasPath(Result, ElementsAre(0xDEADBEEF + 7))))))
       << PrintToString(Result);
   EXPECT_THAT(Result.IntermediateNodes, SizeIs(1));
   EXPECT_THAT(Result.IntermediateNodes,
               UnorderedElementsAre(Pair(0xDEADBEEF + 2, 0xDEADBEEF + 3)));
 }
 
 TEST_F(BasicGraphBuilderTest, BuildFlowGraphComplexExample) {
+  if (!SuccessfullyInitialised)
+    return;
   // The following code has this graph:
   //  +----------+      +--------------+
   //  |    20    | <--- |      0       |
   //  +----------+      +--------------+
   //    |                 |
   //    v                 v
   //  +----------+      +--------------+
   //  |    21    |      |      2       |