[LLVM][llvm-cfi] Inclusive language: replace uses of blacklist with ignorelist

[ZarkoCA]

Summary

Replace the description and file names for this argument. As far as I understand
this is a positional argument and I don't believe this changes breaks any existing
interfaces.

[hctim]

LGTM, thanks!

[MaskRay]

LGTM.

llvm/test/tools/llvm-cfi-verify/X86/ignorelist-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
+# RUN: echo "src:*tiny*" > %t.ignorelist.txt
+# RUN: llvm-cfi-verify %t.o %t.ignorelist.txt | FileCheck %s
 
 # CHECK-LABEL: {{^Instruction: .* \(FAIL_BAD_CONDITIONAL_BRANCH\)}}
 # CHECK-NEXT: tiny.cc:11
-# CHECK-NEXT: {{^Blacklist Match:.*blacklist\.txt:1$}}
+# CHECK-NEXT: {{^Ignorelist Match:.*ignorelist\.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):
+# Source: (ignorelist.txt):
 #   src:*tiny*

llvm/test/tools/llvm-cfi-verify/X86/ignorelist-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
+# RUN: echo "fun:*main*" > %t.ignorelist.txt
+# RUN: llvm-cfi-verify %t.o %t.ignorelist.txt | FileCheck %s
 
 # CHECK-LABEL: {{^Instruction: .* \(FAIL_BAD_CONDITIONAL_BRANCH\)}}
 # CHECK-NEXT: tiny.cc:11
-# CHECK-NEXT: {{^Blacklist Match:.*blacklist\.txt:1$}}
+# CHECK-NEXT: {{^Ignorelist Match:.*ignorelist\.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):
+# Source: (ignorelist.txt):
 #   fun:*main*

llvm/test/tools/llvm-cfi-verify/X86/ignorelist-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
+# RUN: echo "src:*tiny*" > %t.ignorelist.txt
+# RUN: llvm-cfi-verify %t.o %t.ignorelist.txt | FileCheck %s
 
 # CHECK-LABEL: {{^Instruction: .* \(PROTECTED\)}}
 # CHECK-NEXT: tiny.cc:11
-# CHECK-NEXT: {{^Blacklist Match:.*blacklist\.txt:1$}}
+# CHECK-NEXT: {{^Ignorelist Match:.*ignorelist\.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):
+# Source: (ignorelist.txt):
 #   src:*tiny*

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

 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::cfi_verify;
 
 static cl::OptionCategory CFIVerifyCategory("CFI Verify Options");
 
 cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input file>"),
                                    cl::Required, cl::cat(CFIVerifyCategory));
-cl::opt<std::string> BlacklistFilename(cl::Positional,
-                                       cl::desc("[blacklist file]"),
+cl::opt<std::string> IgnorelistFilename(cl::Positional,
+                                        cl::desc("[ignorelist file]"),
                                         cl::init("-"),
                                         cl::cat(CFIVerifyCategory));
 cl::opt<bool> PrintGraphs(
     "print-graphs",
     cl::desc("Print graphs around indirect CF instructions in DOT format."),
     cl::init(false), cl::cat(CFIVerifyCategory));
 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 "
static void printInstructionInformation(const FileAnalysis &Analysis,
 
   if (PrintGraphs)
     Graph.printToDOT(Analysis, outs());
 }
 
 static void printInstructionStatus(unsigned BlameLine, bool CFIProtected,
                                    const DILineInfo &LineInfo) {
   if (BlameLine) {
-    outs() << "Blacklist Match: " << BlacklistFilename << ":" << BlameLine
+    outs() << "Ignorelist Match: " << IgnorelistFilename << ":" << BlameLine
            << "\n";
     if (CFIProtected)
       outs() << "====> Unexpected Protected\n";
     else
       outs() << "====> Expected Unprotected\n";
 
     if (PrintBlameContextAll)
       printBlameContext(LineInfo, PrintBlameContextAll);
outs() << formatv("\nTotal Indirect CF Instructions: {0}\n"
                     ExpectedUnprotected,
                     ((double)ExpectedUnprotected) / IndirectCFInstructions,
                     UnexpectedUnprotected,
                     ((double)UnexpectedUnprotected) / IndirectCFInstructions);
 
   if (!SpecialCaseList)
     return;
 
-  outs() << "\nBlacklist Results:\n";
+  outs() << "\nIgnorelist Results:\n";
   for (const auto &KV : BlameCounter) {
-    outs() << "  " << BlacklistFilename << ":" << KV.first << " affects "
+    outs() << "  " << IgnorelistFilename << ":" << KV.first << " affects "
            << KV.second << " indirect CF instructions.\n";
   }
 }
 
 int main(int argc, char **argv) {
   cl::HideUnrelatedOptions({&CFIVerifyCategory, &getColorCategory()});
   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 != "-") {
+  if (IgnorelistFilename != "-") {
     std::string Error;
-    SpecialCaseList = SpecialCaseList::create({BlacklistFilename},
+    SpecialCaseList = SpecialCaseList::create({IgnorelistFilename},
                                               *vfs::getRealFileSystem(), Error);
     if (!SpecialCaseList) {
-      errs() << "Failed to get blacklist: " << Error << "\n";
+      errs() << "Failed to get ignorelist: " << Error << "\n";
       exit(EXIT_FAILURE);
     }
   }
 
   FileAnalysis Analysis = ExitOnErr(FileAnalysis::Create(InputFilename));
   printIndirectCFInstructions(Analysis, SpecialCaseList.get());
 
   return EXIT_SUCCESS;
 }