[Driver] Use VFS to check if sanitizer blacklists exist

[ilya-biryukov]

Summary

This is a follow-up to 590f279c456bbde632eca8ef89a85c478f15a249, which
moved some of the callers to use VFS.

It turned out more code in Driver calls into real filesystem APIs and
also needs an update.

[ilya-biryukov]

clang/unittests/Driver/SanitizerArgsTest.cpp

101

I'm pretty sure this is going to fail on Windows, looking for ideas on how to unify this with minimal code...
Let me know if there's some cool trick for this that I should know...

[ilya-biryukov]

clang/unittests/Driver/SanitizerArgsTest.cpp

72

NIT to self: remove this newline and the one before return

[jkorous]

clang/unittests/Driver/SanitizerArgsTest.cpp

101

Would llvm::sys::path::convert_to_slash() help?

142

Nit

[kadircet]

clang/unittests/Driver/SanitizerArgsTest.cpp

38

can't this be just clang ? as we are passing the resource-dir explicitly anyway

would be nice to not depend on any relative path deduction in the test.

45

nit s/emulateCompilation/emulateSingleCompilation/

54

nit: maybe put InputFile as the last entry in Args ?

101

maybe make this explicit with smthng like concat(ResourceDir, "share", "asan_blacklist.txt") instead of ASanBlackList?

101

Would llvm::sys::path::convert_to_slash() help?

+1 to this, maybe go over Command.getArguments and create a normalized version first, and then check over that one.

[ilya-biryukov]

• Address comments

[kadircet]

thanks!

clang/unittests/Driver/SanitizerArgsTest.cpp

90

nit: semicolon

[ilya-biryukov]

• Remove redundant semicolon

[teemperor]

FYI, this doesn't compile, see: http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/10890 (and probably all other build bots that are starting to break).

FAILED: tools/sancov/CMakeFiles/sancov.dir/sancov.cpp.o                                                                                                                                                             
/usr/lib/ccache/bin/clang++  -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/sancov -I/home/teemperor/work/ci/llvm/llvm/tools/sancov -I/usr/
include/libxml2 -Iinclude -I/home/teemperor/work/ci/llvm/llvm/include -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wc
ast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-col
or -ffunction-sections -fdata-sections -O3    -UNDEBUG  -fno-exceptions -fno-rtti -std=c++14 -MD -MT tools/sancov/CMakeFiles/sancov.dir/sancov.cpp.o -MF tools/sancov/CMakeFiles/sancov.dir/sancov.cpp.o.d -o tools/
sancov/CMakeFiles/sancov.dir/sancov.cpp.o -c /home/teemperor/work/ci/llvm/llvm/tools/sancov/sancov.cpp                                                                                                              
/home/teemperor/work/ci/llvm/llvm/tools/sancov/sancov.cpp:513:56: error: too few arguments to function call, expected 2, have 1                                                                                     
    return SpecialCaseList::createOrDie({{ClBlacklist}});                                                                                                                                                           
           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~                ^                                                                                                                                                            
/home/teemperor/work/ci/llvm/llvm/include/llvm/Support/SpecialCaseList.h:80:3: note: 'createOrDie' declared here                                                                                                    
  static std::unique_ptr<SpecialCaseList>                                                                                                                                                                           
  ^                                                                                                                                                                                                                 
1 error generated.

[ilya-biryukov]

@teemperor Sorry for the trouble. I did not run LLVM tests, so had to revert the change.

Was reverted in 9f3fdb0d7fab73083e354768eb5808597474e1b8 and relanded as aa981c1802d7353c777e399f2568e5a0e12dea21

[teemperor]

Thanks for the quick fix!

[merge_guards_bot]

Build result: FAILURE - Log files: console-log.txt, CMakeCache.txt

[thakis]

Do we need to add a dep on Frontend to DriverTests here? That's a heavy dependency (it pulls in Sema etc). If it is needed, maybe the test is in the wrong binary?

[ilya-biryukov]

In D70440#1756262, @thakis wrote:

Do we need to add a dep on Frontend to DriverTests here? That's a heavy dependency (it pulls in Sema etc). If it is needed, maybe the test is in the wrong binary?

We need it solely for TextDiagnosticPrinter. Very handy to see the errors in case of failures.
There are probably no reasons it cannot live outside frontend, should be a manageable refactoring. (I haven't checked though, might be wrong)

Logically, the tests seem to be in the right place.

I agree it's not perfect, but there are probably more useful things one can spend their time on.

clang/lib/Basic/SanitizerSpecialCaseList.cpp

 using namespace clang;
 
 std::unique_ptr<SanitizerSpecialCaseList>
 SanitizerSpecialCaseList::create(const std::vector<std::string> &Paths,
                                  llvm::vfs::FileSystem &VFS,
                                  std::string &Error) {
   std::unique_ptr<clang::SanitizerSpecialCaseList> SSCL(
       new SanitizerSpecialCaseList());
-  if (SSCL->createInternal(Paths, Error, VFS)) {
+  if (SSCL->createInternal(Paths, VFS, Error)) {
     SSCL->createSanitizerSections();
     return SSCL;
   }
   return nullptr;
 }
 
 std::unique_ptr<SanitizerSpecialCaseList>
 SanitizerSpecialCaseList::createOrDie(const std::vector<std::string> &Paths,

clang/lib/Basic/XRayLists.cpp

 #include "clang/Basic/XRayLists.h"
 
 using namespace clang;
 
 XRayFunctionFilter::XRayFunctionFilter(
     ArrayRef<std::string> AlwaysInstrumentPaths,
     ArrayRef<std::string> NeverInstrumentPaths,
     ArrayRef<std::string> AttrListPaths, SourceManager &SM)
-    : AlwaysInstrument(
-          llvm::SpecialCaseList::createOrDie(AlwaysInstrumentPaths)),
-      NeverInstrument(llvm::SpecialCaseList::createOrDie(NeverInstrumentPaths)),
-      AttrList(llvm::SpecialCaseList::createOrDie(AttrListPaths)), SM(SM) {}
+    : AlwaysInstrument(llvm::SpecialCaseList::createOrDie(
+          AlwaysInstrumentPaths, SM.getFileManager().getVirtualFileSystem())),
+      NeverInstrument(llvm::SpecialCaseList::createOrDie(
+          NeverInstrumentPaths, SM.getFileManager().getVirtualFileSystem())),
+      AttrList(llvm::SpecialCaseList::createOrDie(
+          AttrListPaths, SM.getFileManager().getVirtualFileSystem())),
+      SM(SM) {}
 
 XRayFunctionFilter::ImbueAttribute
 XRayFunctionFilter::shouldImbueFunction(StringRef FunctionName) const {
   // First apply the always instrument list, than if it isn't an "always" see
   // whether it's treated as a "never" instrument function.
   // TODO: Remove these as they're deprecated; use the AttrList exclusively.
   if (AlwaysInstrument->inSection("xray_always_instrument", "fun", FunctionName,
                                   "arg1") ||

clang/lib/Driver/SanitizerArgs.cpp

SanitizerMask Mask;
                          SanitizerKind::FloatDivideByZero}};
 
   for (auto BL : Blacklists) {
     if (!(Kinds & BL.Mask))
       continue;
 
     clang::SmallString<64> Path(D.ResourceDir);
     llvm::sys::path::append(Path, "share", BL.File);
-    if (llvm::sys::fs::exists(Path))
+    if (D.getVFS().exists(Path))
       BlacklistFiles.push_back(Path.str());
     else if (BL.Mask == SanitizerKind::CFI)
       // If cfi_blacklist.txt cannot be found in the resource dir, driver
       // should fail.
       D.Diag(clang::diag::err_drv_no_such_file) << Path;
   }
 }
 
SanitizerArgs::SanitizerArgs(const ToolChain &TC,
   // Setup blacklist files.
   // Add default blacklist from resource directory.
   addDefaultBlacklists(D, Kinds, SystemBlacklistFiles);
   // Parse -f(no-)sanitize-blacklist options.
   for (const auto *Arg : Args) {
     if (Arg->getOption().matches(options::OPT_fsanitize_blacklist)) {
       Arg->claim();
       std::string BLPath = Arg->getValue();
-      if (llvm::sys::fs::exists(BLPath)) {
+      if (D.getVFS().exists(BLPath)) {
         UserBlacklistFiles.push_back(BLPath);
       } else {
         D.Diag(clang::diag::err_drv_no_such_file) << BLPath;
       }
     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_blacklist)) {
       Arg->claim();
       UserBlacklistFiles.clear();
       SystemBlacklistFiles.clear();
     }
   }
   // Validate blacklists format.
   {
     std::string BLError;
     std::unique_ptr<llvm::SpecialCaseList> SCL(
-        llvm::SpecialCaseList::create(UserBlacklistFiles, BLError));
+        llvm::SpecialCaseList::create(UserBlacklistFiles, D.getVFS(), BLError));
     if (!SCL.get())
       D.Diag(clang::diag::err_drv_malformed_sanitizer_blacklist) << BLError;
   }
   {
     std::string BLError;
-    std::unique_ptr<llvm::SpecialCaseList> SCL(
-        llvm::SpecialCaseList::create(SystemBlacklistFiles, BLError));
+    std::unique_ptr<llvm::SpecialCaseList> SCL(llvm::SpecialCaseList::create(
+        SystemBlacklistFiles, D.getVFS(), BLError));
     if (!SCL.get())
       D.Diag(clang::diag::err_drv_malformed_sanitizer_blacklist) << BLError;
   }
 
   // Parse -f[no-]sanitize-memory-track-origins[=level] options.
   if (AllAddedKinds & SanitizerKind::Memory) {
     if (Arg *A =
             Args.getLastArg(options::OPT_fsanitize_memory_track_origins_EQ,

clang/lib/Driver/XRayArgs.cpp

else
           InstrumentationBundle.Mask |= Mask;
         }
       }
 
     // Validate the always/never attribute files. We also make sure that they
     // are treated as actual dependencies.
     for (const auto &Filename :
          Args.getAllArgValues(options::OPT_fxray_always_instrument)) {
-      if (llvm::sys::fs::exists(Filename)) {
+      if (D.getVFS().exists(Filename)) {
         AlwaysInstrumentFiles.push_back(Filename);
         ExtraDeps.push_back(Filename);
       } else
         D.Diag(clang::diag::err_drv_no_such_file) << Filename;
     }
 
     for (const auto &Filename :
          Args.getAllArgValues(options::OPT_fxray_never_instrument)) {
-      if (llvm::sys::fs::exists(Filename)) {
+      if (D.getVFS().exists(Filename)) {
         NeverInstrumentFiles.push_back(Filename);
         ExtraDeps.push_back(Filename);
       } else
         D.Diag(clang::diag::err_drv_no_such_file) << Filename;
     }
 
     for (const auto &Filename :
          Args.getAllArgValues(options::OPT_fxray_attr_list)) {
-      if (llvm::sys::fs::exists(Filename)) {
+      if (D.getVFS().exists(Filename)) {
         AttrListFiles.push_back(Filename);
         ExtraDeps.push_back(Filename);
       } else
         D.Diag(clang::diag::err_drv_no_such_file) << Filename;
     }
 
     // Get the list of modes we want to support.
     auto SpecifiedModes = Args.getAllArgValues(options::OPT_fxray_modes);

clang/unittests/Driver/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Support
   Option
   )
 
 add_clang_unittest(ClangDriverTests
   DistroTest.cpp
   ToolChainTest.cpp
   ModuleCacheTest.cpp
   MultilibTest.cpp
+  SanitizerArgsTest.cpp
   )
 
 clang_target_link_libraries(ClangDriverTests
   PRIVATE
   clangDriver
   clangBasic
+  clangFrontend # For TextDiagnosticPrinter.
   )

clang/unittests/Driver/SanitizerArgsTest.cpp

+//===- unittests/Driver/SanitizerArgsTest.cpp -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticIDs.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/Job.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include <cstdlib>
+#include <memory>
+#include <string>
+using namespace clang;
+using namespace clang::driver;
+
+using ::testing::Contains;
+using ::testing::StrEq;
+
+namespace {
+
+static constexpr const char *ClangBinary = "clang";
+static constexpr const char *InputFile = "/sources/foo.c";
+
+std::string concatPaths(llvm::ArrayRef<StringRef> Components) {
+  llvm::SmallString<128> P;
+  for (StringRef C : Components)
+    llvm::sys::path::append(P, C);
+  return P.str().str();
+}
+
+class SanitizerArgsTest : public ::testing::Test {
+protected:
+  const Command &emulateSingleCompilation(std::vector<std::string> ExtraArgs,
+                                          std::vector<std::string> ExtraFiles) {
+    assert(!Driver && "Running twice is not allowed");
+
+    llvm::IntrusiveRefCntPtr<DiagnosticOptions> Opts = new DiagnosticOptions;
+    DiagnosticsEngine Diags(
+        new DiagnosticIDs, Opts,
+        new TextDiagnosticPrinter(llvm::errs(), Opts.get()));
+    Driver.emplace(ClangBinary, "x86_64-unknown-linux-gnu", Diags,
+                   prepareFS(ExtraFiles));
+
+    std::vector<const char *> Args = {ClangBinary};
+    for (const auto &A : ExtraArgs)
+      Args.push_back(A.c_str());
+    Args.push_back("-c");
+    Args.push_back(InputFile);
+
+    Compilation.reset(Driver->BuildCompilation(Args));
+
+    if (Diags.hasErrorOccurred())
+      ADD_FAILURE() << "Error occurred while parsing compilation arguments. "
+                       "See stderr for details.";
+
+    const auto &Commands = Compilation->getJobs().getJobs();
+    assert(Commands.size() == 1);
+    return *Commands.front();
+  }
+
+private:
+  llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>
+  prepareFS(llvm::ArrayRef<std::string> ExtraFiles) {
+    llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS =
+        new llvm::vfs::InMemoryFileSystem;
+    FS->addFile(ClangBinary, time_t(), llvm::MemoryBuffer::getMemBuffer(""));
+    FS->addFile(InputFile, time_t(), llvm::MemoryBuffer::getMemBuffer(""));
+    for (llvm::StringRef F : ExtraFiles)
+      FS->addFile(F, time_t(), llvm::MemoryBuffer::getMemBuffer(""));
+    return FS;
+  }
+
+  llvm::Optional<Driver> Driver;
+  std::unique_ptr<driver::Compilation> Compilation;
+};
+
+TEST_F(SanitizerArgsTest, Blacklists) {
+  const std::string ResourceDir = "/opt/llvm/lib/resources";
+  const std::string UserBlacklist = "/source/my_blacklist.txt";
+  const std::string ASanBlacklist =
+      concatPaths({ResourceDir, "share", "asan_blacklist.txt"});
+
+  auto &Command = emulateSingleCompilation(
+      /*ExtraArgs=*/{"-fsanitize=address", "-resource-dir", ResourceDir,
+                     std::string("-fsanitize-blacklist=") + UserBlacklist},
+      /*ExtraFiles=*/{ASanBlacklist, UserBlacklist});
+
+  // System blacklists are added based on resource-dir.
+  EXPECT_THAT(Command.getArguments(),
+              Contains(StrEq(std::string("-fsanitize-system-blacklist=") +
+                             ASanBlacklist)));
+  // User blacklists should also be added.
+  EXPECT_THAT(
+      Command.getArguments(),
+      Contains(StrEq(std::string("-fsanitize-blacklist=") + UserBlacklist)));
+}
+
+TEST_F(SanitizerArgsTest, XRayLists) {
+  const std::string XRayWhitelist = "/source/xray_whitelist.txt";
+  const std::string XRayBlacklist = "/source/xray_blacklist.txt";
+  const std::string XRayAttrList = "/source/xray_attr_list.txt";
+
+  auto &Command = emulateSingleCompilation(
+      /*ExtraArgs=*/
+      {
+          "-fxray-instrument",
+          "-fxray-always-instrument=" + XRayWhitelist,
+          "-fxray-never-instrument=" + XRayBlacklist,
+          "-fxray-attr-list=" + XRayAttrList,
+      },
+      /*ExtraFiles=*/{XRayWhitelist, XRayBlacklist, XRayAttrList});
+
+  // Blacklists exist in the filesystem, so they should be added to the
+  // compilation command, produced by the driver.
+  EXPECT_THAT(Command.getArguments(),
+              Contains(StrEq("-fxray-always-instrument=" + XRayWhitelist)));
+  EXPECT_THAT(Command.getArguments(),
+              Contains(StrEq("-fxray-never-instrument=" + XRayBlacklist)));
+  EXPECT_THAT(Command.getArguments(),
+              Contains(StrEq("-fxray-attr-list=" + XRayAttrList)));
+}
+
+} // namespace

llvm/include/llvm/Support/SpecialCaseList.h

 class Regex;
 class StringRef;
 
 class SpecialCaseList {
 public:
   /// Parses the special case list entries from files. On failure, returns
   /// 0 and writes an error message to string.
   static std::unique_ptr<SpecialCaseList>
-  create(const std::vector<std::string> &Paths, std::string &Error);
+  create(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &FS,
+         std::string &Error);
   /// Parses the special case list from a memory buffer. On failure, returns
   /// 0 and writes an error message to string.
   static std::unique_ptr<SpecialCaseList> create(const MemoryBuffer *MB,
                                                  std::string &Error);
   /// Parses the special case list entries from files. On failure, reports a
   /// fatal error.
   static std::unique_ptr<SpecialCaseList>
-  createOrDie(const std::vector<std::string> &Paths);
+  createOrDie(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &FS);
 
   ~SpecialCaseList();
 
   /// Returns true, if special case list contains a line
   /// \code
   ///   @Prefix:<E>=@Category
   /// \endcode
   /// where @Query satisfies wildcard expression <E> in a given @Section.
public:
   /// Returns zero if there is no blacklist entry corresponding to this
   /// expression.
   unsigned inSectionBlame(StringRef Section, StringRef Prefix, StringRef Query,
                           StringRef Category = StringRef()) const;
 
 protected:
   // Implementations of the create*() functions that can also be used by derived
   // classes.
-  bool createInternal(const std::vector<std::string> &Paths, std::string &Error,
-                      vfs::FileSystem &VFS = *vfs::getRealFileSystem());
+  bool createInternal(const std::vector<std::string> &Paths,
+                      vfs::FileSystem &VFS, std::string &Error);
   bool createInternal(const MemoryBuffer *MB, std::string &Error);
 
   SpecialCaseList() = default;
   SpecialCaseList(SpecialCaseList const &) = delete;
   SpecialCaseList &operator=(SpecialCaseList const &) = delete;
 
   /// Represents a set of regular expressions.  Regular expressions which are
   /// "literal" (i.e. no regex metacharacters) are stored in Strings.  The

llvm/lib/Support/SpecialCaseList.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/SpecialCaseList.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Regex.h"
+#include "llvm/Support/VirtualFileSystem.h"
 #include <string>
 #include <system_error>
 #include <utility>
 
 #include <stdio.h>
 namespace llvm {
 
 bool SpecialCaseList::Matcher::insert(std::string Regexp,
unsigned SpecialCaseList::Matcher::match(StringRef Query) const {
   for (auto& RegExKV : RegExes)
     if (RegExKV.first->match(Query))
       return RegExKV.second;
   return 0;
 }
 
 std::unique_ptr<SpecialCaseList>
 SpecialCaseList::create(const std::vector<std::string> &Paths,
-                        std::string &Error) {
+                        llvm::vfs::FileSystem &FS, std::string &Error) {
   std::unique_ptr<SpecialCaseList> SCL(new SpecialCaseList());
-  if (SCL->createInternal(Paths, Error))
+  if (SCL->createInternal(Paths, FS, Error))
     return SCL;
   return nullptr;
 }
 
 std::unique_ptr<SpecialCaseList> SpecialCaseList::create(const MemoryBuffer *MB,
                                                          std::string &Error) {
   std::unique_ptr<SpecialCaseList> SCL(new SpecialCaseList());
   if (SCL->createInternal(MB, Error))
     return SCL;
   return nullptr;
 }
 
 std::unique_ptr<SpecialCaseList>
-SpecialCaseList::createOrDie(const std::vector<std::string> &Paths) {
+SpecialCaseList::createOrDie(const std::vector<std::string> &Paths,
+                             llvm::vfs::FileSystem &FS) {
   std::string Error;
-  if (auto SCL = create(Paths, Error))
+  if (auto SCL = create(Paths, FS, Error))
     return SCL;
   report_fatal_error(Error);
 }
 
 bool SpecialCaseList::createInternal(const std::vector<std::string> &Paths,
-                                     std::string &Error, vfs::FileSystem &VFS) {
+                                     vfs::FileSystem &VFS, std::string &Error) {
   StringMap<size_t> Sections;
   for (const auto &Path : Paths) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
         VFS.getBufferForFile(Path);
     if (std::error_code EC = FileOrErr.getError()) {
       Error = (Twine("can't open file '") + Path + "': " + EC.message()).str();
       return false;
     }

llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SpecialCaseList.h"
+#include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Transforms/Instrumentation.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>

 
 DataFlowSanitizer::DataFlowSanitizer(
     const std::vector<std::string> &ABIListFiles, void *(*getArgTLS)(),
     void *(*getRetValTLS)())
     : ModulePass(ID), GetArgTLSPtr(getArgTLS), GetRetvalTLSPtr(getRetValTLS) {
   std::vector<std::string> AllABIListFiles(std::move(ABIListFiles));
   AllABIListFiles.insert(AllABIListFiles.end(), ClABIListFiles.begin(),
                          ClABIListFiles.end());
-  ABIList.set(SpecialCaseList::createOrDie(AllABIListFiles));
+  // FIXME: should we propagate vfs::FileSystem to this constructor?
+  ABIList.set(
+      SpecialCaseList::createOrDie(AllABIListFiles, *vfs::getRealFileSystem()));
 }
 
 FunctionType *DataFlowSanitizer::getArgsFunctionType(FunctionType *T) {
   SmallVector<Type *, 4> ArgTypes(T->param_begin(), T->param_end());
   ArgTypes.append(T->getNumParams(), ShadowTy);
   if (T->isVarArg())
     ArgTypes.push_back(ShadowPtrTy);
   Type *RetType = T->getReturnType();