[cfi-verify] Add blame context printing, and improved print format.

[hctim]

Summary

This update now allows users to specify --blame-context and --blame-context-all to print source file blame information for the source of the blame.

Also updates the inline printing to correctly identify the top of the inlining stack for blame information.

[vlad.tsyrklevich]

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

67

errs()

72

I'd just make this a SmallVectorImpl<> or a std::vector<>, the small-size optimization here is not likely to help much since many files are >200 lines.

80

Why print this here at all? It would seem reasonable to me to just print the full protection status with the instruction, e.g. Expected Protected Instruction: ... and just have this print

 1: ...
>2: ...
 3: ...

92

Can we condense this to a single line and remove the text formatting? Like

outs() << "Instruction: " << stringCfiProtectionStatus() << ": " << format_hex() << ": ";

108

Prefer to put these with instruction printing (e.g. so it gets printed even if no SCL is given.)

127

We have lots of these delimiters, could we just place them at the start or end of an instruction and eliminate the rest?

test/tools/llvm-cfi-verify/X86/blacklist-expected-unprotected.s

 # RUN: llvm-mc %S/Inputs/unprotected-lineinfo.s -filetype obj \
 # RUN:         -triple x86_64-linux-elf -o %t.o
 # RUN: echo "src:*tiny*" > %t.blacklist.txt
 # RUN: llvm-cfi-verify %t.o %t.blacklist.txt | FileCheck %s
 
-# CHECK-LABEL: U
+# CHECK-LABEL: Begin Instruction
+# CHECK-NEXT: FAIL_BAD_CONDITIONAL_BRANCH
 # CHECK-NEXT: tiny.cc:11
 # CHECK-NEXT: {{^Blacklist Match:.*blacklist\.txt:1$}}
 # CHECK-NEXT: ====> Expected Unprotected
 
 # CHECK: Expected Protected: 0 (0.00%)
 # CHECK: Unexpected Protected: 0 (0.00%)
 # CHECK: Expected Unprotected: 1 (100.00%)
 # CHECK: Unexpected Unprotected (BAD): 0 (0.00%)
 
 # Source: (blacklist.txt):
 #   src:*tiny*

test/tools/llvm-cfi-verify/X86/blacklist-match-fun.s

 # RUN: llvm-mc %S/Inputs/unprotected-fullinfo.s -filetype obj \
 # RUN:         -triple x86_64-linux-elf -o %t.o
 # RUN: echo "fun:*main*" > %t.blacklist.txt
 # RUN: llvm-cfi-verify %t.o %t.blacklist.txt | FileCheck %s
 
-# CHECK-LABEL: U
+# CHECK-LABEL: Begin Instruction
+# CHECK-NEXT: FAIL_BAD_CONDITIONAL_BRANCH
 # CHECK-NEXT: tiny.cc:11
 # CHECK-NEXT: {{^Blacklist Match:.*blacklist\.txt:1$}}
 # CHECK-NEXT: ====> Expected Unprotected
 
 # CHECK: Expected Protected: 0 (0.00%)
 # CHECK: Unexpected Protected: 0 (0.00%)
 # CHECK: Expected Unprotected: 1 (100.00%)
 # CHECK: Unexpected Unprotected (BAD): 0 (0.00%)
 
 # Source: (blacklist.txt):
 #   fun:*main*

test/tools/llvm-cfi-verify/X86/blacklist-unexpected-protected.s

 # RUN: llvm-mc %S/Inputs/protected-lineinfo.s -filetype obj \
 # RUN:         -triple x86_64-linux-elf -o %t.o
 # RUN: echo "src:*tiny*" > %t.blacklist.txt
 # RUN: llvm-cfi-verify %t.o %t.blacklist.txt | FileCheck %s
 
-# CHECK-LABEL: P
+# CHECK-LABEL: Begin Instruction
+# CHECK-NEXT: PROTECTED
 # CHECK-NEXT: tiny.cc:11
 # CHECK-NEXT: {{^Blacklist Match:.*blacklist\.txt:1$}}
 # CHECK-NEXT: ====> Unexpected Protected
 
 # CHECK: Expected Protected: 0 (0.00%)
 # CHECK: Unexpected Protected: 1 (100.00%)
 # CHECK: Expected Unprotected: 0 (0.00%)
 # CHECK: Unexpected Unprotected (BAD): 0 (0.00%)
 
 # Source: (blacklist.txt):
 #   src:*tiny*

test/tools/llvm-cfi-verify/X86/dot-printing.s

 # RUN: llvm-mc %S/Inputs/protected-lineinfo.s -filetype obj \
 # RUN:         -triple x86_64-linux-elf -o %t.o
 # RUN: llvm-cfi-verify -print-graphs %t.o | FileCheck %s
 
 # The expected output is as follows:
-#   P 0x7b |  callq *%rax
+#   ----------------- Begin Instruction -----------------
+#   PROTECTED 0x7b:  callq *%rax
 #   digraph graph_0x7b {
 #     "0x77:  jbe 2" -> "0x7b:  callq *%rax"
 #     "0x77:  jbe 2" -> "0x79:  ud2"
 #   }
 #   0x7b = tiny.cc:11:3 (main)
 
-# CHECK: {{^P.*callq +\*%rax.*$}}
+# CHECK-LABEL: Begin Instruction
+# CHECK-NEXT: {{^PROTECTED.*callq +\*%rax.*$}}
 # CHECK-NEXT: digraph
 # CHECK-NEXT: {{^.*jbe.*->.*callq \*%rax}}
 # CHECK-NEXT: {{^.*jbe.*->.*ud2}}
 # CHECK-NEXT: }
 # CHECK-NEXT: tiny.cc:11

test/tools/llvm-cfi-verify/X86/indirect-cf-elimination.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-linux-elf -o %t.o
-# RUN: llvm-cfi-verify %t.o 2>&1 | FileCheck %s
+# RUN: llvm-cfi-verify %t.o 2>&1 --summarize | FileCheck %s
 
 # This is the same file as protected-lineinfo.s, however contains a hand-
 # assembled function (fake_function) that has no line table information
 # associated with it. Because there is no LT info, the indirect call made in the
 # function should not be reported at all by llvm-cfi-verify.
 
 # We can test that this indirect call is ignored from the final statistics
 # reporting of the cfi-verify program. It should only find a single indirect CF
 # instruction at `tiny.cc:11` (see protected-lineinfo.s for the source).
 
+# CHECK-NOT: Begin Instruction
+
 # CHECK: Expected Protected: 1 (100.00%)
 # CHECK: Unexpected Protected: 0 (0.00%)
 # CHECK: Expected Unprotected: 0 (0.00%)
 # CHECK: Unexpected Unprotected (BAD): 0 (0.00%)
 
   .text
   .file "ld-temp.o"
   .p2align  4, 0x90

test/tools/llvm-cfi-verify/X86/protected-lineinfo.s

 # RUN: llvm-mc %S/Inputs/protected-lineinfo.s -filetype obj \
 # RUN:         -triple x86_64-linux-elf -o %t.o
 # RUN: llvm-cfi-verify %t.o | FileCheck %s
 
-# CHECK-LABEL: P
+# CHECK-LABEL: Begin Instruction
+# CHECK-NEXT: PROTECTED
 # CHECK-NEXT: tiny.cc:11
 
 # CHECK: Expected Protected: 1 (100.00%)
 # CHECK: Unexpected Protected: 0 (0.00%)
 # CHECK: Expected Unprotected: 0 (0.00%)
 # CHECK: Unexpected Unprotected (BAD): 0 (0.00%)

test/tools/llvm-cfi-verify/X86/unprotected-lineinfo.s

 # RUN: llvm-mc %S/Inputs/unprotected-lineinfo.s -filetype obj \
 # RUN:         -triple x86_64-linux-elf -o %t.o
 # RUN: llvm-cfi-verify %t.o | FileCheck %s
 
-# CHECK-LABEL: U
+# CHECK-LABEL: Begin Instruction
+# CHECK-NEXT: FAIL_BAD_CONDITIONAL_BRANCH
 # CHECK-NEXT: tiny.cc:11
 
 # CHECK: Expected Protected: 0 (0.00%)
 # CHECK: Unexpected Protected: 0 (0.00%)
 # CHECK: Expected Unprotected: 0 (0.00%)
 # CHECK: Unexpected Unprotected (BAD): 1 (100.00%)

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

cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input file>"),
                                    cl::Required);
 cl::opt<std::string> BlacklistFilename(cl::Positional,
                                        cl::desc("[blacklist file]"),
                                        cl::init("-"));
 cl::opt<bool> PrintGraphs(
     "print-graphs",
     cl::desc("Print graphs around indirect CF instructions in DOT format."),
     cl::init(false));
+cl::opt<unsigned> PrintBlameContext(
+    "blame-context",
+    cl::desc("Print the blame context (if possible) for BAD instructions. This "
+             "specifies the number of lines of context to include, where zero "
+             "disables this feature."),
+    cl::init(0));
+cl::opt<unsigned> PrintBlameContextAll(
+    "blame-context-all",
+    cl::desc("Prints the blame context (if possible) for ALL instructions. "
+             "This specifies the number of lines of context for non-BAD "
+             "instructions (see --blame-context). If --blame-context is "
+             "unspecified, it prints this number of contextual lines for BAD "
+             "instructions as well."),
+    cl::init(0));
+cl::opt<bool> Summarize("summarize", cl::desc("Print the summary only."),
+                        cl::init(false));
 
 ExitOnError ExitOnErr;
 
+void printBlameContext(const DILineInfo &LineInfo, unsigned Context,
+                       StringRef ProtectionStatusShort) {
+  auto FileOrErr = MemoryBuffer::getFile(LineInfo.FileName);
+  if (!FileOrErr) {
+    outs() << "******* Could not open file.\n";
+    return;
+  }
+
+  std::unique_ptr<MemoryBuffer> File = std::move(FileOrErr.get());
+  SmallVector<StringRef, 200> Lines;
+  File->getBuffer().split(Lines, '\n');
+
+  for (unsigned i = std::max(1l, (long)LineInfo.Line - Context);
+       i <
+       std::min(Lines.size() + 1, (unsigned long)LineInfo.Line + Context + 1);
+       ++i) {
+    if (i == LineInfo.Line)
+      outs() << "[" << ProtectionStatusShort << "]>";
+    else
+      outs() << "****>";
+
+    outs() << " " << i << ": " << Lines[i - 1] << "\n";
+  }
+}
+
+void printInstructionInformation(const FileAnalysis &Analysis,
+                                 const Instr &InstrMeta,
+                                 const GraphResult &Graph,
+                                 CFIProtectionStatus ProtectionStatus) {
+  outs() << "----------------- Begin Instruction -----------------\n";
+  outs() << stringCFIProtectionStatus(ProtectionStatus) << " "
+         << format_hex(InstrMeta.VMAddress, 2) << ": ";
+  Analysis.printInstruction(InstrMeta, outs());
+  outs() << " \n";
+
+  if (PrintGraphs)
+    Graph.printToDOT(Analysis, outs());
+}
+
+void printInstructionStatus(unsigned BlameLine, bool CFIProtected,
+                            const DILineInfo &LineInfo) {
+  if (BlameLine) {
+    outs() << "Blacklist Match: " << BlacklistFilename << ":" << BlameLine
+           << "\n";
+    if (CFIProtected) {
+      outs() << "====> Unexpected Protected\n";
+      if (PrintBlameContextAll)
+        printBlameContext(LineInfo, PrintBlameContextAll, "UP");
+    } else {
+      outs() << "====> Expected Unprotected\n";
+      if (PrintBlameContextAll)
+        printBlameContext(LineInfo, PrintBlameContextAll, "EU");
+    }
+  } else {
+    if (CFIProtected) {
+      outs() << "====> Expected Protected\n";
+      if (PrintBlameContextAll)
+        printBlameContext(LineInfo, PrintBlameContextAll, "EP");
+    } else {
+      outs() << "====> Unexpected Unprotected (BAD)\n";
+      if (PrintBlameContext)
+        printBlameContext(LineInfo, PrintBlameContext, "UU");
+    }
+  }
+  outs() << "-----------------------------------------------------\n";
+}
+
 void printIndirectCFInstructions(FileAnalysis &Analysis,
                                  const SpecialCaseList *SpecialCaseList) {
   uint64_t ExpectedProtected = 0;
   uint64_t UnexpectedProtected = 0;
   uint64_t ExpectedUnprotected = 0;
   uint64_t UnexpectedUnprotected = 0;
 
   std::map<unsigned, uint64_t> BlameCounter;
 
   for (uint64_t Address : Analysis.getIndirectInstructions()) {
     const auto &InstrMeta = Analysis.getInstructionOrDie(Address);
     GraphResult Graph = GraphBuilder::buildFlowGraph(Analysis, Address);
 
     CFIProtectionStatus ProtectionStatus =
         Analysis.validateCFIProtection(Graph);
     bool CFIProtected = (ProtectionStatus == CFIProtectionStatus::PROTECTED);
 
-    if (CFIProtected)
-      outs() << "P ";
-    else
-      outs() << "U ";
-
-    outs() << format_hex(Address, 2) << " | ";
-    Analysis.printInstruction(InstrMeta, outs());
-    outs() << " \n";
-
-    if (PrintGraphs)
-      Graph.printToDOT(Analysis, outs());
+    if (!Summarize)
+      printInstructionInformation(Analysis, InstrMeta, Graph, ProtectionStatus);
 
     if (IgnoreDWARFFlag) {
       if (CFIProtected)
         ExpectedProtected++;
       else
         UnexpectedUnprotected++;
+      if (!Summarize)
+        outs() << "-----------------------------------------------------\n";
       continue;
     }
 
     auto InliningInfo = Analysis.symbolizeInlinedCode(Address);
     if (!InliningInfo || InliningInfo->getNumberOfFrames() == 0) {
       errs() << "Failed to symbolise " << format_hex(Address, 2)
              << " with line tables from " << InputFilename << "\n";
       exit(EXIT_FAILURE);
     }
 
-    const auto &LineInfo =
-        InliningInfo->getFrame(InliningInfo->getNumberOfFrames() - 1);
+    const auto &LineInfo = InliningInfo->getFrame(0);
 
     // Print the inlining symbolisation of this instruction.
+    if (!Summarize) {
       for (uint32_t i = 0; i < InliningInfo->getNumberOfFrames(); ++i) {
         const auto &Line = InliningInfo->getFrame(i);
-      outs() << "  " << format_hex(Address, 2) << " = " << Line.FileName << ":"
-             << Line.Line << ":" << Line.Column << " (" << Line.FunctionName
-             << ")\n";
+        outs() << "  " << format_hex(Address, 2) << " = " << Line.FileName
+               << ":" << Line.Line << ":" << Line.Column << " ("
+               << Line.FunctionName << ")\n";
+      }
     }
 
     if (!SpecialCaseList) {
-      if (CFIProtected)
+      if (CFIProtected) {
+        if (PrintBlameContextAll && !Summarize)
+          printBlameContext(LineInfo, PrintBlameContextAll, "EP");
         ExpectedProtected++;
-      else
+      } else {
+        if (PrintBlameContext && !Summarize)
+          printBlameContext(LineInfo, PrintBlameContext, "UU");
         UnexpectedUnprotected++;
+      }
+      if (!Summarize)
+        outs() << "-----------------------------------------------------\n";
       continue;
     }
 
     unsigned BlameLine = 0;
     for (auto &K : {"cfi-icall", "cfi-vcall"}) {
       if (!BlameLine)
         BlameLine =
             SpecialCaseList->inSectionBlame(K, "src", LineInfo.FileName);
       if (!BlameLine)
         BlameLine =
             SpecialCaseList->inSectionBlame(K, "fun", LineInfo.FunctionName);
     }
 
     if (BlameLine) {
-      outs() << "Blacklist Match: " << BlacklistFilename << ":" << BlameLine
-             << "\n";
       BlameCounter[BlameLine]++;
-      if (CFIProtected) {
+      if (CFIProtected)
         UnexpectedProtected++;
-        outs() << "====> Unexpected Protected\n";
-      } else {
+      else
         ExpectedUnprotected++;
-        outs() << "====> Expected Unprotected\n";
-      }
     } else {
-      if (CFIProtected) {
+      if (CFIProtected)
         ExpectedProtected++;
-        outs() << "====> Expected Protected\n";
-      } else {
+      else
         UnexpectedUnprotected++;
-        outs() << "====> Unexpected Unprotected\n";
-      }
     }
+
+    if (!Summarize)
+      printInstructionStatus(BlameLine, CFIProtected, LineInfo);
   }
 
   uint64_t IndirectCFInstructions = ExpectedProtected + UnexpectedProtected +
                                     ExpectedUnprotected + UnexpectedUnprotected;
 
   if (IndirectCFInstructions == 0) {
     outs() << "No indirect CF instructions found.\n";
     return;
   }
 
-  outs() << formatv("Expected Protected: {0} ({1:P})\n"
-                    "Unexpected Protected: {2} ({3:P})\n"
-                    "Expected Unprotected: {4} ({5:P})\n"
-                    "Unexpected Unprotected (BAD): {6} ({7:P})\n",
-                    ExpectedProtected,
+  outs() << formatv("Total Indirect CF Instructions: {0}\n"
+                    "Expected Protected: {1} ({2:P})\n"
+                    "Unexpected Protected: {3} ({4:P})\n"
+                    "Expected Unprotected: {5} ({6:P})\n"
+                    "Unexpected Unprotected (BAD): {7} ({8:P})\n",
+                    IndirectCFInstructions, ExpectedProtected,
                     ((double)ExpectedProtected) / IndirectCFInstructions,
                     UnexpectedProtected,
                     ((double)UnexpectedProtected) / IndirectCFInstructions,
                     ExpectedUnprotected,
                     ((double)ExpectedUnprotected) / IndirectCFInstructions,
                     UnexpectedUnprotected,
                     ((double)UnexpectedUnprotected) / IndirectCFInstructions);
 
cl::ParseCommandLineOptions(
       "Anything statically linked into the provided file *must* be compiled "
       "with '-g'. This can be relaxed through the '--ignore-dwarf' flag.");
 
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
   InitializeAllDisassemblers();
 
+  if (PrintBlameContextAll && !PrintBlameContext)
+    PrintBlameContext.setValue(PrintBlameContextAll);
+
   std::unique_ptr<SpecialCaseList> SpecialCaseList;
   if (BlacklistFilename != "-") {
     std::string Error;
     SpecialCaseList = SpecialCaseList::create({BlacklistFilename}, Error);
     if (!SpecialCaseList) {
       errs() << "Failed to get blacklist: " << Error << "\n";
       exit(EXIT_FAILURE);
     }
   }
 
   FileAnalysis Analysis = ExitOnErr(FileAnalysis::Create(InputFilename));
   printIndirectCFInstructions(Analysis, SpecialCaseList.get());
 
   return EXIT_SUCCESS;
 }