[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 ↗

(On Diff #123106)

errs()

72 ↗

(On Diff #123106)

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 ↗

(On Diff #123106)

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 ↗

(On Diff #123106)

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

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

108 ↗

(On Diff #123106)

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

127 ↗

(On Diff #123106)

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

llvm/trunk/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: {{^Instruction: .* \(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*

llvm/trunk/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: {{^Instruction: .* \(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*

llvm/trunk/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: {{^Instruction: .* \(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*

llvm/trunk/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: {{^Instruction: .* \(PROTECTED\):.*callq +\*%rax}}
 # CHECK-NEXT: digraph
 # CHECK-NEXT: {{^.*jbe.*->.*callq \*%rax}}
 # CHECK-NEXT: {{^.*jbe.*->.*ud2}}
 # CHECK-NEXT: }
 # CHECK-NEXT: tiny.cc:11

llvm/trunk/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

llvm/trunk/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: {{^Instruction: .* \(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%)

llvm/trunk/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: {{^Instruction: .* \(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%)

llvm/trunk/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) {
+  auto FileOrErr = MemoryBuffer::getFile(LineInfo.FileName);
+  if (!FileOrErr) {
+    errs() << "Could not open file: " << LineInfo.FileName << "\n";
+    return;
+  }
+
+  std::unique_ptr<MemoryBuffer> File = std::move(FileOrErr.get());
+  SmallVector<StringRef, 100> 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() << ">";
+    else
+      outs() << " ";
+
+    outs() << i << ": " << Lines[i - 1] << "\n";
+  }
+}
+
+void printInstructionInformation(const FileAnalysis &Analysis,
+                                 const Instr &InstrMeta,
+                                 const GraphResult &Graph,
+                                 CFIProtectionStatus ProtectionStatus) {
+  outs() << "Instruction: " << format_hex(InstrMeta.VMAddress, 2) << " ("
+         << stringCFIProtectionStatus(ProtectionStatus) << "): ";
+  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";
+    else
+      outs() << "====> Expected Unprotected\n";
+
+    if (PrintBlameContextAll)
+      printBlameContext(LineInfo, PrintBlameContextAll);
+  } else {
+    if (CFIProtected) {
+      outs() << "====> Expected Protected\n";
+      if (PrintBlameContextAll)
+        printBlameContext(LineInfo, PrintBlameContextAll);
+    } else {
+      outs() << "====> Unexpected Unprotected (BAD)\n";
+      if (PrintBlameContext)
+        printBlameContext(LineInfo, PrintBlameContext);
+    }
+  }
+}
+
 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) {
+      outs() << "-----------------------------------------------------\n";
+      printInstructionInformation(Analysis, InstrMeta, Graph, ProtectionStatus);
+    }
 
     if (IgnoreDWARFFlag) {
       if (CFIProtected)
         ExpectedProtected++;
       else
         UnexpectedUnprotected++;
       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);
         ExpectedProtected++;
-      else
+      } else {
+        if (PrintBlameContext && !Summarize)
+          printBlameContext(LineInfo, PrintBlameContext);
         UnexpectedUnprotected++;
+      }
       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("\nTotal 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);
 
   if (!SpecialCaseList)
     return;
 
-  outs() << "Blacklist Results:\n";
+  outs() << "\nBlacklist Results:\n";
   for (const auto &KV : BlameCounter) {
     outs() << "  " << BlacklistFilename << ":" << KV.first << " affects "
            << KV.second << " indirect CF instructions.\n";
   }
 }
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(
       argc, argv,
       "Identifies whether Control Flow Integrity protects all indirect control "
       "flow instructions in the provided object file, DSO or binary.\nNote: "
       "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;
 }