Add an IsLiteral parameter to SpecialCaseList (Clang side).

[samsonov]

See my comment in review thread for D4547. I'm not happy with code structure you propose. In particular, I don't see why Clang (?) should know whether DFSan expects to see special case lists in "literal" mode. It's really a DFSan implementation detail, which probably shouldn't be exposed.

[pcc]

See my comment in review thread for D4547. I'm not happy with code structure you propose. In particular, I don't see why Clang (?) should know whether DFSan expects to see special case lists in "literal" mode. It's really a DFSan implementation detail, which probably shouldn't be exposed.

Okay, I guess we can hide that behind DFSanABIList.

include/clang/CodeGen/BackendUtil.h

enum BackendAction {
     Backend_EmitBC,        ///< Emit LLVM bitcode files
     Backend_EmitLL,        ///< Emit human-readable LLVM assembly
     Backend_EmitNothing,   ///< Don't emit anything (benchmarking mode)
     Backend_EmitMCNull,    ///< Run CodeGen, but don't emit anything
     Backend_EmitObj        ///< Emit native object files
   };
 
   std::unique_ptr<llvm::SpecialCaseList>
-  CreateSpecialCaseList(const CodeGenOptions &CGOpts);
+  CreateSpecialCaseList(const LangOptions &LOpts, const CodeGenOptions &CGOpts);
 
   void EmitBackendOutput(DiagnosticsEngine &Diags, const CodeGenOptions &CGOpts,
                          const TargetOptions &TOpts, const LangOptions &LOpts,
                          StringRef TDesc, llvm::Module *M, BackendAction Action,
                          raw_ostream *OS);
 }
 
 #endif

lib/CodeGen/BackendUtil.cpp

static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
                                    PassManagerBase &PM) {
   PM.add(createThreadSanitizerPass());
 }
 
 static void addDataFlowSanitizerPass(const PassManagerBuilder &Builder,
                                      PassManagerBase &PM) {
   const PassManagerBuilderWrapper &BuilderWrapper =
       static_cast<const PassManagerBuilderWrapper&>(Builder);
+  const LangOptions &LOpts = BuilderWrapper.getLangOpts();
   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
-  PM.add(createDataFlowSanitizerPass(CreateSpecialCaseList(CGOpts)));
+  PM.add(createDataFlowSanitizerPass(CreateSpecialCaseList(LOpts, CGOpts)));
 }
 
 void EmitAssemblyHelper::CreatePasses() {
   unsigned OptLevel = CodeGenOpts.OptimizationLevel;
   CodeGenOptions::InliningMethod Inlining = CodeGenOpts.getInlining();
 
   // Handle disabling of LLVM optimization, where we want to preserve the
   // internal module before any optimization.
void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
   }
 
   if (CodeGenPasses) {
     PrettyStackTraceString CrashInfo("Code generation");
     CodeGenPasses->run(*TheModule);
   }
 }
 
-std::unique_ptr<SpecialCaseList> clang::CreateSpecialCaseList(const CodeGenOptions &CGOpts) {
+std::unique_ptr<SpecialCaseList>
+clang::CreateSpecialCaseList(const LangOptions &LOpts,
+                             const CodeGenOptions &CGOpts) {
   auto SCL = llvm::make_unique<SpecialCaseList>();
   for (const auto &Path : CGOpts.SanitizerBlacklistFiles) {
     std::string Error;
-    if (!SCL->loadFromFile(Path, Error)) {
+    if (!SCL->loadFromFile(Path, /*IsLiteral=*/LOpts.Sanitize.DataFlow,
+                           Error)) {
       report_fatal_error(Error);
     }
   }
 
   return SCL;
 }
 
 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,

lib/CodeGen/CodeGenModule.cpp

: Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M),
       ObjCRuntime(nullptr), OpenCLRuntime(nullptr), OpenMPRuntime(nullptr),
       CUDARuntime(nullptr), DebugInfo(nullptr), ARCData(nullptr),
       NoObjCARCExceptionsMetadata(nullptr), RRData(nullptr), PGOReader(nullptr),
       CFConstantStringClassRef(nullptr), ConstantStringClassRef(nullptr),
       NSConstantStringType(nullptr), NSConcreteGlobalBlock(nullptr),
       NSConcreteStackBlock(nullptr), BlockObjectAssign(nullptr),
       BlockObjectDispose(nullptr), BlockDescriptorType(nullptr),
       GenericBlockLiteralType(nullptr), LifetimeStartFn(nullptr),
-      LifetimeEndFn(nullptr), SanitizerBL(CreateSpecialCaseList(CGO)),
+      LifetimeEndFn(nullptr), SanitizerBL(CreateSpecialCaseList(LangOpts, CGO)),
       SanitizerMD(new SanitizerMetadata(*this)) {
 
   // Initialize the type cache.
   llvm::LLVMContext &LLVMContext = M.getContext();
   VoidTy = llvm::Type::getVoidTy(LLVMContext);
   Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
   Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
   Int32Ty = llvm::Type::getInt32Ty(LLVMContext);

lib/Driver/SanitizerArgs.cpp

AsanZeroBaseShadow =
         (TC.getTriple().getEnvironment() == llvm::Triple::Android);
   }
 }
 
 void SanitizerArgs::addBlacklistFile(const Driver &D, StringRef BLPath) {
   // Validate the blacklist format.
   std::string BLError;
   llvm::SpecialCaseList SCL;
-  if (!SCL.loadFromFile(BLPath, BLError))
+  if (!SCL.loadFromFile(BLPath, /*IsLiteral=*/false, BLError))
     D.Diag(diag::err_drv_malformed_sanitizer_blacklist) << BLError;
   else
     BlacklistFiles.push_back(BLPath);
 }
 
 void SanitizerArgs::addArgs(const llvm::opt::ArgList &Args,
                             llvm::opt::ArgStringList &CmdArgs) const {
   if (!Kind)