[NFC] Reordering parameters in getFile and getFileOrSTDIN

[abhina.sreeskantharajan]

Summary

In future patches I will be setting the IsText parameter frequently so I will refactor the args to be in the following order. I have removed the FileSize parameter because it is never used.

 static ErrorOr<std::unique_ptr<MemoryBuffer>>
 getFile(const Twine &Filename, bool IsText = false,
         bool RequiresNullTerminator = true, bool IsVolatile = false);

 static ErrorOr<std::unique_ptr<MemoryBuffer>>
 getFileOrSTDIN(const Twine &Filename, bool IsText = false,
                bool RequiresNullTerminator = true);

static ErrorOr<std::unique_ptr<MB>>
getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
           bool IsText, bool RequiresNullTerminator, bool IsVolatile);

 static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
 getFile(const Twine &Filename, bool IsVolatile = false);

[abhina.sreeskantharajan]

Move FileSize to the end because it is never used.

[abhina.sreeskantharajan]

After going through all the function usages, I realized FileSize is not used anywhere. I can remove this parameter.

[jhenderson]

Overall, this seems reasonable to me. I have a slight concern that it might cause surprising failures for downstream users, that aren't picked up at build time (due to implicit conversions), but I don't think you need to worry too much about that.

llvm/include/llvm/Support/MemoryBuffer.h

78–80

You need to remove the reference to FileSize from the description here.

llvm/lib/Support/MemoryBuffer.cpp

108–109

Are there users of the FileSize here? If not, can you repeat the change for this function?

[abhina.sreeskantharajan]

I've removed FileSize from getFileAux and WritableMemoryBuffer::getFile as well.

[abhina.sreeskantharajan]

llvm/include/llvm/Support/MemoryBuffer.h

78–80

Thanks for catching that, I updated the comment.

llvm/lib/Support/MemoryBuffer.cpp

108–109

No, I was able to remove FileSize from here as well as WritableMemoryBuffer::getFile too. Thanks

[jhenderson]

LGTM, with nit.

llvm/lib/Support/MemoryBuffer.cpp

281

Whilst you're modifying, add the named parameter comment for the 0, so that it's not just a magic number.

[abhina.sreeskantharajan]

Rebase and fix formatting.

[abhina.sreeskantharajan]

llvm/lib/Support/MemoryBuffer.cpp

281

Thanks for catching, this is fixed now.

clang/lib/Tooling/JSONCompilationDatabase.cpp

 } // namespace clang
 
 std::unique_ptr<JSONCompilationDatabase>
 JSONCompilationDatabase::loadFromFile(StringRef FilePath,
                                       std::string &ErrorMessage,
                                       JSONCommandLineSyntax Syntax) {
   // Don't mmap: if we're a long-lived process, the build system may overwrite.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> DatabaseBuffer =
-      llvm::MemoryBuffer::getFile(FilePath, /*FileSize=*/-1,
+      llvm::MemoryBuffer::getFile(FilePath, /*IsText=*/false,
                                   /*RequiresNullTerminator=*/true,
                                   /*IsVolatile=*/true);
   if (std::error_code Result = DatabaseBuffer.getError()) {
     ErrorMessage = "Error while opening JSON database: " + Result.message();
     return nullptr;
   }
   std::unique_ptr<JSONCompilationDatabase> Database(
       new JSONCompilationDatabase(std::move(*DatabaseBuffer), Syntax));

clang/tools/arcmt-test/arcmt-test.cpp

static bool performTransformations(StringRef resourcesPath,
   // FIXME: TestResultForARC
 
   return false;
 }
 
 static bool filesCompareEqual(StringRef fname1, StringRef fname2) {
   using namespace llvm;
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> file1 = MemoryBuffer::getFile(
-      fname1, /*FileSize=*/-1, /*RequiresNullTerminator=*/true,
-      /*IsVolatile=*/false, /*IsText=*/true);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> file1 =
+      MemoryBuffer::getFile(fname1, /*IsText=*/true);
   if (!file1)
     return false;
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> file2 = MemoryBuffer::getFile(
-      fname2, /*FileSize=*/-1, /*RequiresNullTerminator=*/true,
-      /*IsVolatile=*/false, /*IsText=*/true);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> file2 =
+      MemoryBuffer::getFile(fname2, /*IsText=*/true);
   if (!file2)
     return false;
 
   return file1.get()->getBuffer() == file2.get()->getBuffer();
 }
 
 static bool verifyTransformedFiles(ArrayRef<std::string> resultFiles) {
   using namespace llvm;
for (ArrayRef<std::string>::iterator
     }
     resultMap[sys::path::stem(fname)] = fname;
   }
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> inputBuf = std::error_code();
   if (RemappingsFile.empty())
     inputBuf = MemoryBuffer::getSTDIN();
   else
-    inputBuf = MemoryBuffer::getFile(RemappingsFile, /*FileSize=*/-1,
-                                     /*RequiresNullTerminator=*/true,
-                                     /*IsVolatile=*/false, /*IsText=*/true);
+    inputBuf = MemoryBuffer::getFile(RemappingsFile, /*IsText=*/true);
   if (!inputBuf) {
     errs() << "error: could not read remappings input\n";
     return true;
   }
 
   SmallVector<StringRef, 8> strs;
   inputBuf.get()->getBuffer().split(strs, "\n", /*MaxSplit=*/-1,
                                     /*KeepEmpty=*/false);

lld/COFF/Driver.cpp

 #if _WIN32
   // On Windows, file I/O is relatively slow so it is best to do this
   // asynchronously.
   auto strategy = std::launch::async;
 #else
   auto strategy = std::launch::deferred;
 #endif
   return std::async(strategy, [=]() {
-    auto mbOrErr = MemoryBuffer::getFile(path,
-                                         /*FileSize*/ -1,
-                                         /*RequiresNullTerminator*/ false);
+    auto mbOrErr = MemoryBuffer::getFile(path, /*IsText=*/false,
+                                         /*RequiresNullTerminator=*/false);
     if (!mbOrErr)
       return MBErrPair{nullptr, mbOrErr.getError()};
     return MBErrPair{std::move(*mbOrErr), std::error_code()};
   });
 }
 
 // Symbol names are mangled by prepending "_" on x86.
 static StringRef mangle(StringRef sym) {
if (!config->incremental) {
     handleError(writeImportLibrary(libName, path, exports, config->machine,
                                    config->mingw));
     return;
   }
 
   // If the import library already exists, replace it only if the contents
   // have changed.
   ErrorOr<std::unique_ptr<MemoryBuffer>> oldBuf = MemoryBuffer::getFile(
-      path, /*FileSize*/ -1, /*RequiresNullTerminator*/ false);
+      path, /*IsText=*/false, /*RequiresNullTerminator=*/false);
   if (!oldBuf) {
     handleError(writeImportLibrary(libName, path, exports, config->machine,
                                    config->mingw));
     return;
   }
 
   SmallString<128> tmpName;
   if (std::error_code ec =
           sys::fs::createUniqueFile(path + ".tmp-%%%%%%%%.lib", tmpName))
     fatal("cannot create temporary file for import library " + path + ": " +
           ec.message());
 
   if (Error e = writeImportLibrary(libName, tmpName, exports, config->machine,
                                    config->mingw)) {
     handleError(std::move(e));
     return;
   }
 
   std::unique_ptr<MemoryBuffer> newBuf = check(MemoryBuffer::getFile(
-      tmpName, /*FileSize*/ -1, /*RequiresNullTerminator*/ false));
+      tmpName, /*IsText=*/false, /*RequiresNullTerminator=*/false));
   if ((*oldBuf)->getBuffer() != newBuf->getBuffer()) {
     oldBuf->reset();
     handleError(errorCodeToError(sys::fs::rename(tmpName, path)));
   } else {
     sys::fs::remove(tmpName);
   }
 }
 
 static void parseModuleDefs(StringRef path) {
-  std::unique_ptr<MemoryBuffer> mb = CHECK(
-      MemoryBuffer::getFile(path, -1, false, true), "could not open " + path);
+  std::unique_ptr<MemoryBuffer> mb =
+      CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
+                                  /*RequiresNullTerminator=*/false,
+                                  /*IsVolatile=*/true),
+            "could not open " + path);
   COFFModuleDefinition m = check(parseCOFFModuleDefinition(
       mb->getMemBufferRef(), config->machine, config->mingw));
 
   // Include in /reproduce: output if applicable.
   driver->takeBuffer(std::move(mb));
 
   if (config->outputFile.empty())
     config->outputFile = std::string(saver.save(m.OutputFile));
static void parseOrderFile(StringRef arg) {
   DenseSet<StringRef> set;
   for (Chunk *c : symtab->getChunks())
     if (auto *sec = dyn_cast<SectionChunk>(c))
       if (sec->sym)
         set.insert(sec->sym->getName());
 
   // Open a file.
   StringRef path = arg.substr(1);
-  std::unique_ptr<MemoryBuffer> mb = CHECK(
-      MemoryBuffer::getFile(path, -1, false, true), "could not open " + path);
+  std::unique_ptr<MemoryBuffer> mb =
+      CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
+                                  /*RequiresNullTerminator=*/false,
+                                  /*IsVolatile=*/true),
+            "could not open " + path);
 
   // Parse a file. An order file contains one symbol per line.
   // All symbols that were not present in a given order file are
   // considered to have the lowest priority 0 and are placed at
   // end of an output section.
   for (StringRef arg : args::getLines(mb->getMemBufferRef())) {
     std::string s(arg);
     if (config->machine == I386 && !isDecorated(s))
       s = "_" + s;
 
     if (set.count(s) == 0) {
       if (config->warnMissingOrderSymbol)
         warn("/order:" + arg + ": missing symbol: " + s + " [LNK4037]");
     }
     else
       config->order[s] = INT_MIN + config->order.size();
   }
 
   // Include in /reproduce: output if applicable.
   driver->takeBuffer(std::move(mb));
 }
 
 static void parseCallGraphFile(StringRef path) {
-  std::unique_ptr<MemoryBuffer> mb = CHECK(
-      MemoryBuffer::getFile(path, -1, false, true), "could not open " + path);
+  std::unique_ptr<MemoryBuffer> mb =
+      CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
+                                  /*RequiresNullTerminator=*/false,
+                                  /*IsVolatile=*/true),
+            "could not open " + path);
 
   // Build a map from symbol name to section.
   DenseMap<StringRef, Symbol *> map;
   for (ObjFile *file : ObjFile::instances)
     for (Symbol *sym : file->getSymbols())
       if (sym)
         map[sym->getName()] = sym;
 

lld/COFF/DriverUtils.cpp

public:
   }
 
   // Returns a memory buffer of this temporary file.
   // Note that this function does not leave the file open,
   // so it is safe to remove the file immediately after this function
   // is called (you cannot remove an opened file on Windows.)
   std::unique_ptr<MemoryBuffer> getMemoryBuffer() {
     // IsVolatile=true forces MemoryBuffer to not use mmap().
-    return CHECK(MemoryBuffer::getFile(path, /*FileSize=*/-1,
+    return CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
                                        /*RequiresNullTerminator=*/false,
                                        /*IsVolatile=*/true),
                  "could not open " + path);
   }
 
   std::string path;
 };
 }

lld/ELF/InputFiles.cpp

Optional<MemoryBufferRef> elf::readFile(StringRef path) {
   // The --chroot option changes our virtual root directory.
   // This is useful when you are dealing with files created by --reproduce.
   if (!config->chroot.empty() && path.startswith("/"))
     path = saver.save(config->chroot + path);
 
   log(path);
   config->dependencyFiles.insert(llvm::CachedHashString(path));
 
-  auto mbOrErr = MemoryBuffer::getFile(path, -1, false);
+  auto mbOrErr = MemoryBuffer::getFile(path, /*IsText=*/false,
+                                       /*RequiresNullTerminator=*/false);
   if (auto ec = mbOrErr.getError()) {
     error("cannot open " + path + ": " + ec.message());
     return None;
   }
 
   std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

 std::unique_ptr<PDBFile>
 ObjectFilePDB::loadPDBFile(std::string PdbPath,
                            llvm::BumpPtrAllocator &Allocator) {
   llvm::file_magic magic;
   auto ec = llvm::identify_magic(PdbPath, magic);
   if (ec || magic != llvm::file_magic::pdb)
     return nullptr;
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ErrorOrBuffer =
-      llvm::MemoryBuffer::getFile(PdbPath, /*FileSize=*/-1,
+      llvm::MemoryBuffer::getFile(PdbPath, /*IsText=*/false,
                                   /*RequiresNullTerminator=*/false);
   if (!ErrorOrBuffer)
     return nullptr;
   std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
 
   llvm::StringRef Path = Buffer->getBufferIdentifier();
   auto Stream = std::make_unique<llvm::MemoryBufferByteStream>(
       std::move(Buffer), llvm::support::little);

lldb/unittests/TestingSupport/TestUtilities.cpp

llvm::Expected<TestFile> TestFile::fromYaml(llvm::StringRef Yaml) {
   if (!llvm::yaml::convertYAML(YIn, OS, [](const llvm::Twine &Msg) {}))
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "convertYAML() failed");
   return TestFile(std::move(Buffer));
 }
 
 llvm::Expected<TestFile> TestFile::fromYamlFile(const llvm::Twine &Name) {
   auto BufferOrError =
-      llvm::MemoryBuffer::getFile(GetInputFilePath(Name), /*FileSize*/ -1,
-                                  /*RequiresNullTerminator*/ false);
+      llvm::MemoryBuffer::getFile(GetInputFilePath(Name), /*IsText=*/false,
+                                  /*RequiresNullTerminator=*/false);
   if (!BufferOrError)
     return llvm::errorCodeToError(BufferOrError.getError());
   return fromYaml(BufferOrError.get()->getBuffer());
 }

llvm/include/llvm/Support/MemoryBuffer.h

StringRef getBuffer() const {
     return StringRef(BufferStart, getBufferSize());
   }
 
   /// Return an identifier for this buffer, typically the filename it was read
   /// from.
   virtual StringRef getBufferIdentifier() const { return "Unknown buffer"; }
 
   /// Open the specified file as a MemoryBuffer, returning a new MemoryBuffer
   /// if successful, otherwise returning null. If FileSize is specified, this
   /// means that the client knows that the file exists and that it has the
   /// specified size.
   ///
+  /// \param IsText Set to true to indicate that the file should be read in
+  /// text mode.
+  ///
   /// \param IsVolatile Set to true to indicate that the contents of the file
   /// can change outside the user's control, e.g. when libclang tries to parse
   /// while the user is editing/updating the file or if the file is on an NFS.
-  ///
-  /// \param IsText Set to true to indicate that the file should be read in
-  /// text mode.
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
-  getFile(const Twine &Filename, int64_t FileSize = -1,
+  getFile(const Twine &Filename, bool IsText = false,
           bool RequiresNullTerminator = true, bool IsVolatile = false,
-          bool IsText = false);
+          int64_t FileSize = -1);
 
   /// Read all of the specified file into a MemoryBuffer as a stream
   /// (i.e. until EOF reached). This is useful for special files that
   /// look like a regular file but have 0 size (e.g. /proc/cpuinfo on Linux).
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getFileAsStream(const Twine &Filename);
 
   /// Given an already-open file descriptor, map some slice of it into a
public:
   getMemBufferCopy(StringRef InputData, const Twine &BufferName = "");
 
   /// Read all of stdin into a file buffer, and return it.
   static ErrorOr<std::unique_ptr<MemoryBuffer>> getSTDIN();
 
   /// Open the specified file as a MemoryBuffer, or open stdin if the Filename
   /// is "-".
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
-  getFileOrSTDIN(const Twine &Filename, int64_t FileSize = -1,
-                 bool RequiresNullTerminator = true, bool IsText = false);
+  getFileOrSTDIN(const Twine &Filename, bool IsText = false,
+                 bool RequiresNullTerminator = true, int64_t FileSize = -1);
 
   /// Map a subrange of the specified file as a MemoryBuffer.
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
                bool IsVolatile = false);
 
   //===--------------------------------------------------------------------===//
   // Provided for performance analysis.

llvm/lib/BinaryFormat/Magic.cpp

file_magic llvm::identify_magic(StringRef Magic) {
 
   default:
     break;
   }
   return file_magic::unknown;
 }
 
 std::error_code llvm::identify_magic(const Twine &Path, file_magic &Result) {
-  auto FileOrError = MemoryBuffer::getFile(Path, -1LL, false);
+  auto FileOrError = MemoryBuffer::getFile(Path, /*IsText=*/false,
+                                           /*RequiresNullTerminator=*/false);
   if (!FileOrError)
     return FileOrError.getError();
 
   std::unique_ptr<MemoryBuffer> FileBuffer = std::move(*FileOrError);
   Result = identify_magic(FileBuffer->getBuffer());
 
   return std::error_code();
 }

llvm/lib/DebugInfo/PDB/Native/NativeSession.cpp

Session =
       std::make_unique<NativeSession>(std::move(File), std::move(Allocator));
 
   return Error::success();
 }
 
 static Expected<std::unique_ptr<PDBFile>>
 loadPdbFile(StringRef PdbPath, std::unique_ptr<BumpPtrAllocator> &Allocator) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
-      MemoryBuffer::getFile(PdbPath, /*FileSize=*/-1,
+      MemoryBuffer::getFile(PdbPath, /*IsText=*/false,
                             /*RequiresNullTerminator=*/false);
   if (!ErrorOrBuffer)
     return make_error<RawError>(ErrorOrBuffer.getError());
   std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
 
   PdbPath = Buffer->getBufferIdentifier();
   file_magic Magic;
   auto EC = identify_magic(PdbPath, Magic);

llvm/lib/FuzzMutate/FuzzerCLI.cpp

int llvm::runFuzzerOnInputs(int ArgC, char *ArgV[], FuzzerTestFun TestOne,
   for (int I = 1; I < ArgC; ++I) {
     StringRef Arg(ArgV[I]);
     if (Arg.startswith("-")) {
       if (Arg.equals("-ignore_remaining_args=1"))
         break;
       continue;
     }
 
-    auto BufOrErr = MemoryBuffer::getFile(Arg, /*FileSize-*/ -1,
+    auto BufOrErr = MemoryBuffer::getFile(Arg, /*IsText=*/false,
                                           /*RequiresNullTerminator=*/false);
     if (std::error_code EC = BufOrErr.getError()) {
       errs() << "Error reading file: " << Arg << ": " << EC.message() << "\n";
       return 1;
     }
     std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
     errs() << "Running: " << Arg << " (" << Buf->getBufferSize() << " bytes)\n";
     TestOne(reinterpret_cast<const uint8_t *>(Buf->getBufferStart()),

llvm/lib/IRReader/IRReader.cpp

std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
 
   return parseAssembly(Buffer, Err, Context, nullptr, DataLayoutCallback);
 }
 
 std::unique_ptr<Module>
 llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
                   DataLayoutCallbackTy DataLayoutCallback) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(Filename, /*FileSize=*/-1,
-                                   /*RequiresNullTerminator=*/true,
-                                   /*IsText=*/true);
+      MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/true);
   if (std::error_code EC = FileOrErr.getError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
                        "Could not open input file: " + EC.message());
     return nullptr;
   }
 
   return parseIR(FileOrErr.get()->getMemBufferRef(), Err, Context,
                  DataLayoutCallback);

llvm/lib/LTO/LTOCodeGenerator.cpp

 
 std::unique_ptr<MemoryBuffer>
 LTOCodeGenerator::compileOptimized() {
   const char *name;
   if (!compileOptimizedToFile(&name))
     return nullptr;
 
   // read .o file into memory buffer
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
-      MemoryBuffer::getFile(name, -1, false);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = MemoryBuffer::getFile(
+      name, /*IsText=*/false, /*RequiresNullTerminator=*/false);
   if (std::error_code EC = BufferOrErr.getError()) {
     emitError(EC.message());
     sys::fs::remove(NativeObjectPath);
     return nullptr;
   }
 
   // remove temp files
   sys::fs::remove(NativeObjectPath);

llvm/lib/Object/Binary.cpp

case file_magic::tapi_file:
     return TapiUniversal::create(Buffer);
   }
   llvm_unreachable("Unexpected Binary File Type");
 }
 
 Expected<OwningBinary<Binary>>
 object::createBinary(StringRef Path, LLVMContext *Context, bool InitContent) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
+      MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
   if (std::error_code EC = FileOrErr.getError())
     return errorCodeToError(EC);
   std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
 
   Expected<std::unique_ptr<Binary>> BinOrErr =
       createBinary(Buffer->getMemBufferRef(), Context, InitContent);
   if (!BinOrErr)
     return BinOrErr.takeError();
   std::unique_ptr<Binary> &Bin = BinOrErr.get();
 
   return OwningBinary<Binary>(std::move(Bin), std::move(Buffer));
 }

llvm/lib/ProfileData/GCOV.cpp

class LineConsumer {
   StringRef Remaining;
 
 public:
   LineConsumer() = default;
   LineConsumer(StringRef Filename) {
     // Open source files without requiring a NUL terminator. The concurrent
     // modification may nullify the NUL terminator condition.
     ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
-        MemoryBuffer::getFileOrSTDIN(Filename, -1,
+        MemoryBuffer::getFileOrSTDIN(Filename, /*IsText=*/false,
                                      /*RequiresNullTerminator=*/false);
     if (std::error_code EC = BufferOrErr.getError()) {
       errs() << Filename << ": " << EC.message() << "\n";
       Remaining = "";
     } else {
       Buffer = std::move(BufferOrErr.get());
       Remaining = Buffer->getBuffer();
     }

llvm/lib/Support/MemoryBuffer.cpp

public:
   MemoryBuffer::BufferKind getBufferKind() const override {
     return MemoryBuffer::MemoryBuffer_Malloc;
   }
 };
 } // namespace
 
 template <typename MB>
 static ErrorOr<std::unique_ptr<MB>>
 getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
-           uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile,
-           bool IsText);
+           uint64_t Offset, bool IsText, bool RequiresNullTerminator,
+           bool IsVolatile);
 
 std::unique_ptr<MemoryBuffer>
 MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName,
                            bool RequiresNullTerminator) {
   auto *Ret = new (NamedBufferAlloc(BufferName))
       MemoryBufferMem<MemoryBuffer>(InputData, RequiresNullTerminator);
   return std::unique_ptr<MemoryBuffer>(Ret);
 }

 MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) {
   auto Buf = getMemBufferCopyImpl(InputData, BufferName);
   if (Buf)
     return std::move(*Buf);
   return nullptr;
 }
 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
-MemoryBuffer::getFileOrSTDIN(const Twine &Filename, int64_t FileSize,
-                             bool RequiresNullTerminator, bool IsText) {
+MemoryBuffer::getFileOrSTDIN(const Twine &Filename, bool IsText,
+                             bool RequiresNullTerminator, int64_t FileSize) {
   SmallString<256> NameBuf;
   StringRef NameRef = Filename.toStringRef(NameBuf);
 
   if (NameRef == "-")
     return getSTDIN();
-  return getFile(Filename, FileSize, RequiresNullTerminator, false, IsText);
+  return getFile(Filename, IsText, RequiresNullTerminator, /*IsVolatile=*/false,
+                 FileSize);
 }
 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
 MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize,
                            uint64_t Offset, bool IsVolatile) {
-  return getFileAux<MemoryBuffer>(FilePath, -1, MapSize, Offset, false,
-                                  IsVolatile, false);
+  return getFileAux<MemoryBuffer>(FilePath, -1, MapSize, Offset,
+                                  /*IsText=*/false,
+                                  /*RequiresNullTerminator=*/false, IsVolatile);
 }
 
 //===----------------------------------------------------------------------===//
 // MemoryBuffer::getFile implementation.
 //===----------------------------------------------------------------------===//
 
 namespace {
 
if (*ReadBytes == 0)
       break;
     Buffer.set_size(Buffer.size() + *ReadBytes);
   }
 
   return getMemBufferCopyImpl(Buffer, BufferName);
 }
 
 ErrorOr<std::unique_ptr<MemoryBuffer>>
-MemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
+MemoryBuffer::getFile(const Twine &Filename, bool IsText,
                       bool RequiresNullTerminator, bool IsVolatile,
-                      bool IsText) {
-  return getFileAux<MemoryBuffer>(Filename, FileSize, FileSize, 0,
-                                  RequiresNullTerminator, IsVolatile, IsText);
+                      int64_t FileSize) {
+  return getFileAux<MemoryBuffer>(Filename, FileSize, FileSize, 0, IsText,
+                                  RequiresNullTerminator, IsVolatile);
 }
 
 template <typename MB>
 static ErrorOr<std::unique_ptr<MB>>
 getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
                 uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
                 bool IsVolatile);
 
 template <typename MB>
 static ErrorOr<std::unique_ptr<MB>>
 getFileAux(const Twine &Filename, int64_t FileSize, uint64_t MapSize,
-           uint64_t Offset, bool RequiresNullTerminator, bool IsVolatile,
-           bool IsText) {
+           uint64_t Offset, bool IsText, bool RequiresNullTerminator,
+           bool IsVolatile) {
   Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead(
       Filename, IsText ? sys::fs::OF_Text : sys::fs::OF_None);
   if (!FDOrErr)
     return errorToErrorCode(FDOrErr.takeError());
   sys::fs::file_t FD = *FDOrErr;
   auto Ret = getOpenFileImpl<MB>(FD, Filename, FileSize, MapSize, Offset,
                                  RequiresNullTerminator, IsVolatile);
   sys::fs::closeFile(FD);
   return Ret;
 }
 
 ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
 WritableMemoryBuffer::getFile(const Twine &Filename, int64_t FileSize,
                               bool IsVolatile) {
-  return getFileAux<WritableMemoryBuffer>(Filename, FileSize, FileSize, 0,
-                                          /*RequiresNullTerminator*/ false,
-                                          IsVolatile, false);
+  return getFileAux<WritableMemoryBuffer>(
+      Filename, FileSize, FileSize, 0,
+      /*IsText=*/false, /*RequiresNullTerminator=*/false, IsVolatile);
 }
 
 ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
 WritableMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize,
                                    uint64_t Offset, bool IsVolatile) {
-  return getFileAux<WritableMemoryBuffer>(Filename, -1, MapSize, Offset, false,
-                                          IsVolatile, false);
+  return getFileAux<WritableMemoryBuffer>(
+      Filename, -1, MapSize, Offset, /*IsText=*/false,
+      /*RequiresNullTerminator=*/false, IsVolatile);
 }
 
 std::unique_ptr<WritableMemoryBuffer>
 WritableMemoryBuffer::getNewUninitMemBuffer(size_t Size, const Twine &BufferName) {
   using MemBuffer = MemoryBufferMem<WritableMemoryBuffer>;
   // Allocate space for the MemoryBuffer, the data and the name. It is important
   // that MemoryBuffer and data are aligned so PointerIntPair works with them.
   // TODO: Is 16-byte alignment enough?  We copy small object files with large

llvm/lib/TableGen/Main.cpp

int llvm::TableGenMain(const char *argv0, TableGenMainFn *MainFn) {
 
   if (TimePhases)
     Records.startPhaseTiming();
 
   // Parse the input file.
 
   Records.startTimer("Parse, build records");
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(InputFilename, /*FileSize=*/-1,
-                                   /*RequiresNullTerminator=*/true,
-                                   /*IsText=*/true);
+      MemoryBuffer::getFileOrSTDIN(InputFilename, /*IsText=*/true);
   if (std::error_code EC = FileOrErr.getError())
     return reportError(argv0, "Could not open input file '" + InputFilename +
                                   "': " + EC.message() + "\n");
 
   Records.saveInputFilename(InputFilename);
 
   // Tell SrcMgr about this buffer, which is what TGParser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());
int llvm::TableGenMain(const char *argv0, TableGenMainFn *MainFn) {
   }
 
   Records.startTimer("Write output");
   bool WriteFile = true;
   if (WriteIfChanged) {
     // Only updates the real output file if there are any differences.
     // This prevents recompilation of all the files depending on it if there
     // aren't any.
-    if (auto ExistingOrErr = MemoryBuffer::getFile(
-            OutputFilename, /*FileSize=*/-1, /*RequiresNullTerminator=*/true,
-            /*IsVolatile=*/false, /*IsText=*/true))
+    if (auto ExistingOrErr =
+            MemoryBuffer::getFile(OutputFilename, /*IsText=*/true))
       if (std::move(ExistingOrErr.get())->getBuffer() == Out.str())
         WriteFile = false;
   }
   if (WriteFile) {
     std::error_code EC;
     ToolOutputFile OutFile(OutputFilename, EC, sys::fs::OF_Text);
     if (EC)
       return reportError(argv0, "error opening " + OutputFilename + ": " +

llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp

static void fatalOpenError(llvm::Error E, Twine File) {
   });
 }
 
 static void doList(opt::InputArgList& Args) {
   // lib.exe prints the contents of the first archive file.
   std::unique_ptr<MemoryBuffer> B;
   for (auto *Arg : Args.filtered(OPT_INPUT)) {
     // Create or open the archive object.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> MaybeBuf =
-        MemoryBuffer::getFile(Arg->getValue(), -1, false);
+    ErrorOr<std::unique_ptr<MemoryBuffer>> MaybeBuf = MemoryBuffer::getFile(
+        Arg->getValue(), /*IsText=*/false, /*RequiresNullTerminator=*/false);
     fatalOpenError(errorCodeToError(MaybeBuf.getError()), Arg->getValue());
 
     if (identify_magic(MaybeBuf.get()->getBuffer()) == file_magic::archive) {
       B = std::move(MaybeBuf.get());
       break;
     }
   }
 
for (auto *Arg : Args.filtered(OPT_INPUT)) {
     // Note that there's a loophole in the rule; you can prepend `.\` or
     // something like that to a path to make it look different, and they are
     // handled as if they were different files. This behavior is compatible with
     // Microsoft lib.exe.
     if (!Seen.insert(Path).second)
       continue;
 
     // Open a file.
-    ErrorOr<std::unique_ptr<MemoryBuffer>> MOrErr =
-        MemoryBuffer::getFile(Path, -1, false);
+    ErrorOr<std::unique_ptr<MemoryBuffer>> MOrErr = MemoryBuffer::getFile(
+        Path, /*IsText=*/false, /*RequiresNullTerminator=*/false);
     fatalOpenError(errorCodeToError(MOrErr.getError()), Path);
     MemoryBufferRef MBRef = (*MOrErr)->getMemBufferRef();
 
     // Append a file.
     appendFile(Members, LibMachine, LibMachineSource, MBRef);
 
     // Take the ownership of the file buffer to keep the file open.
     MBs.push_back(std::move(*MOrErr));

llvm/tools/lli/lli.cpp

public:
 
   std::unique_ptr<MemoryBuffer> getObject(const Module* M) override {
     const std::string &ModuleID = M->getModuleIdentifier();
     std::string CacheName;
     if (!getCacheFilename(ModuleID, CacheName))
       return nullptr;
     // Load the object from the cache filename
     ErrorOr<std::unique_ptr<MemoryBuffer>> IRObjectBuffer =
-        MemoryBuffer::getFile(CacheName, -1, false);
+        MemoryBuffer::getFile(CacheName, /*IsText=*/false,
+                              /*RequiresNullTerminator=*/false);
     // If the file isn't there, that's OK.
     if (!IRObjectBuffer)
       return nullptr;
     // MCJIT will want to write into this buffer, and we don't want that
     // because the file has probably just been mmapped.  Instead we make
     // a copy.  The filed-based buffer will be released when it goes
     // out of scope.
     return MemoryBuffer::getMemBufferCopy(IRObjectBuffer.get()->getBuffer());

llvm/tools/llvm-ar/llvm-ar.cpp

 static void getArchive() {
   if (PositionalArgs.empty())
     badUsage("an archive name must be specified");
   ArchiveName = PositionalArgs[0];
   PositionalArgs.erase(PositionalArgs.begin());
 }
 
 static object::Archive &readLibrary(const Twine &Library) {
-  auto BufOrErr = MemoryBuffer::getFile(Library, -1, false);
+  auto BufOrErr = MemoryBuffer::getFile(Library, /*IsText=*/false,
+                                        /*RequiresNullTerminator=*/false);
   failIfError(BufOrErr.getError(), "could not open library " + Library);
   ArchiveBuffers.push_back(std::move(*BufOrErr));
   auto LibOrErr =
       object::Archive::create(ArchiveBuffers.back()->getMemBufferRef());
   failIfError(errorToErrorCode(LibOrErr.takeError()),
               "could not parse library");
   Archives.push_back(std::move(*LibOrErr));
   return *Archives.back();
case CreateSymTab:
     return;
   }
   llvm_unreachable("Unknown operation.");
 }
 
 static int performOperation(ArchiveOperation Operation,
                             std::vector<NewArchiveMember> *NewMembers) {
   // Create or open the archive object.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
-      MemoryBuffer::getFile(ArchiveName, -1, false);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(
+      ArchiveName, /*IsText=*/false, /*RequiresNullTerminator=*/false);
   std::error_code EC = Buf.getError();
   if (EC && EC != errc::no_such_file_or_directory)
     fail("unable to open '" + ArchiveName + "': " + EC.message());
 
   if (!EC) {
     Error Err = Error::success();
     object::Archive Archive(Buf.get()->getMemBufferRef(), Err);
     failIfError(std::move(Err), "unable to load '" + ArchiveName + "'");

llvm/tools/llvm-cov/gcov.cpp

static void reportCoverage(StringRef SourceFile, StringRef ObjectDir,
   std::string GCDA = InputGCDA.empty()
                          ? std::string(CoverageFileStem.str()) + ".gcda"
                          : InputGCDA;
   GCOVFile GF;
 
   // Open .gcda and .gcda without requiring a NUL terminator. The concurrent
   // modification may nullify the NUL terminator condition.
   ErrorOr<std::unique_ptr<MemoryBuffer>> GCNO_Buff =
-      MemoryBuffer::getFileOrSTDIN(GCNO, -1, /*RequiresNullTerminator=*/false);
+      MemoryBuffer::getFileOrSTDIN(GCNO, /*IsText=*/false,
+                                   /*RequiresNullTerminator=*/false);
   if (std::error_code EC = GCNO_Buff.getError()) {
     errs() << GCNO << ": " << EC.message() << "\n";
     return;
   }
   GCOVBuffer GCNO_GB(GCNO_Buff.get().get());
   if (!GF.readGCNO(GCNO_GB)) {
     errs() << "Invalid .gcno File!\n";
     return;
   }
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> GCDA_Buff =
-      MemoryBuffer::getFileOrSTDIN(GCDA, -1, /*RequiresNullTerminator=*/false);
+      MemoryBuffer::getFileOrSTDIN(GCDA, /*IsText=*/false,
+                                   /*RequiresNullTerminator=*/false);
   if (std::error_code EC = GCDA_Buff.getError()) {
     if (EC != errc::no_such_file_or_directory) {
       errs() << GCDA << ": " << EC.message() << "\n";
       return;
     }
     // Clear the filename to make it clear we didn't read anything.
     GCDA = "-";
   } else {

llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

static Error processCommandLineLibraries() {
   return Error::success();
 }
 
 static Error processFileList() {
   StringRef FileName, DirName;
   std::tie(FileName, DirName) = StringRef(FileList).rsplit(",");
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(FileName, /*FileSize=*/-1,
+      MemoryBuffer::getFileOrSTDIN(FileName, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
   if (std::error_code EC = FileOrErr.getError())
     return createFileError(FileName, errorCodeToError(EC));
   const MemoryBuffer &Ref = *FileOrErr.get();
 
   line_iterator I(Ref, /*SkipBlanks=*/false);
   if (I.is_at_eof())
     return createStringError(std::errc::invalid_argument,

llvm/tools/llvm-pdbutil/InputFile.cpp

if (Magic == file_magic::pdb) {
     return std::move(IF);
   }
 
   if (!AllowUnknownFile)
     return make_error<StringError>(
         formatv("File {0} is not a supported file type", Path),
         inconvertibleErrorCode());
 
-  auto Result = MemoryBuffer::getFile(Path, -1LL, false);
+  auto Result = MemoryBuffer::getFile(Path, /*IsText=*/false,
+                                      /*RequiresNullTerminator=*/false);
   if (!Result)
     return make_error<StringError>(
         formatv("File {0} could not be opened", Path), Result.getError());
 
   IF.UnknownFile = std::move(*Result);
   IF.PdbOrObj = IF.UnknownFile.get();
   return std::move(IF);
 }

llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp

 } // namespace exportstream
 }
 
 static ExitOnError ExitOnErr;
 
 static void yamlToPdb(StringRef Path) {
   BumpPtrAllocator Allocator;
   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
-      MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
+      MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
 
   if (ErrorOrBuffer.getError()) {
     ExitOnErr(createFileError(Path, errorCodeToError(ErrorOrBuffer.getError())));
   }
 
   std::unique_ptr<MemoryBuffer> &Buffer = ErrorOrBuffer.get();
 

llvm/tools/llvm-rc/ResourceFileWriter.cpp

ResourceFileWriter::loadFile(StringRef File) const {
   // must have a root directory, but e.g. the path "\dir\file" on windows
   // isn't considered absolute, but it does have a root directory. As long as
   // sys::path::append doesn't handle appending an absolute path or a path
   // starting with a root directory on top of a base, we must handle this
   // case separately at the top. C++17's path::append handles that case
   // properly though, so if using that to append paths below, this early
   // exception case could be removed.)
   if (sys::path::has_root_directory(File))
-    return errorOrToExpected(MemoryBuffer::getFile(File, -1, false));
+    return errorOrToExpected(MemoryBuffer::getFile(
+        File, /*IsText=*/false, /*RequiresNullTerminator=*/false));
 
   // 1. The current working directory.
   sys::fs::current_path(Cwd);
   Path.assign(Cwd.begin(), Cwd.end());
   sys::path::append(Path, File);
   if (sys::fs::exists(Path))
-    return errorOrToExpected(MemoryBuffer::getFile(Path, -1, false));
+    return errorOrToExpected(MemoryBuffer::getFile(
+        Path, /*IsText=*/false, /*RequiresNullTerminator=*/false));
 
   // 2. The directory of the input resource file, if it is different from the
   // current working directory.
   StringRef InputFileDir = sys::path::parent_path(Params.InputFilePath);
   Path.assign(InputFileDir.begin(), InputFileDir.end());
   sys::path::append(Path, File);
   if (sys::fs::exists(Path))
-    return errorOrToExpected(MemoryBuffer::getFile(Path, -1, false));
+    return errorOrToExpected(MemoryBuffer::getFile(
+        Path, /*IsText=*/false, /*RequiresNullTerminator=*/false));
 
   // 3. All of the include directories specified on the command line.
   for (StringRef ForceInclude : Params.Include) {
     Path.assign(ForceInclude.begin(), ForceInclude.end());
     sys::path::append(Path, File);
     if (sys::fs::exists(Path))
-      return errorOrToExpected(MemoryBuffer::getFile(Path, -1, false));
+      return errorOrToExpected(MemoryBuffer::getFile(
+          Path, /*IsText=*/false, /*RequiresNullTerminator=*/false));
   }
 
   if (auto Result =
           llvm::sys::Process::FindInEnvPath("INCLUDE", File, Params.NoInclude))
-    return errorOrToExpected(MemoryBuffer::getFile(*Result, -1, false));
+    return errorOrToExpected(MemoryBuffer::getFile(
+        *Result, /*IsText=*/false, /*RequiresNullTerminator=*/false));
 
   return make_error<StringError>("error : file not found : " + Twine(File),
                                  inconvertibleErrorCode());
 }
 
 } // namespace rc
 } // namespace llvm

llvm/tools/llvm-readobj/llvm-readobj.cpp

static void dumpWindowsResourceFile(WindowsResource *WinRes,
   if (auto Err = Dumper.printData())
     reportError(std::move(Err), WinRes->getFileName());
 }
 
 
 /// Opens \a File and dumps it.
 static void dumpInput(StringRef File, ScopedPrinter &Writer) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(File, /*FileSize=*/-1,
+      MemoryBuffer::getFileOrSTDIN(File, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
   if (std::error_code EC = FileOrErr.getError())
     return reportError(errorCodeToError(EC), File);
 
   std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
   file_magic Type = identify_magic(Buffer->getBuffer());
   if (Type == file_magic::bitcode) {
     reportWarning(createStringError(errc::invalid_argument,

llvm/tools/obj2yaml/obj2yaml.cpp

static Error dumpObject(const ObjectFile &Obj) {
   if (Obj.isWasm())
     return errorCodeToError(wasm2yaml(outs(), cast<WasmObjectFile>(Obj)));
 
   llvm_unreachable("unexpected object file format");
 }
 
 static Error dumpInput(StringRef File) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(File, /*FileSize=*/-1,
+      MemoryBuffer::getFileOrSTDIN(File, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
   if (std::error_code EC = FileOrErr.getError())
     return errorCodeToError(EC);
   std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
   MemoryBufferRef MemBuf = Buffer->getMemBufferRef();
   if (file_magic::archive == identify_magic(MemBuf.getBuffer()))
     return archive2yaml(outs(), MemBuf);
 

llvm/tools/sanstats/sanstats.cpp

while (1) {
     llvm::outs() << " " << CountFromData(Data, SizeofPtr) << '\n';
   }
 }
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv,
                               "Sanitizer Statistics Processing Tool");
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
-      MemoryBuffer::getFile(ClInputFile, -1, false);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
+      ClInputFile, /*IsText=*/false, /*RequiresNullTerminator=*/false);
   if (!MBOrErr) {
     errs() << argv[0] << ": " << ClInputFile << ": "
            << MBOrErr.getError().message() << '\n';
     return 1;
   }
   std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
   const char *Begin = MB->getBufferStart(), *End = MB->getBufferEnd();
   if (Begin == End) {

llvm/utils/FileCheck/FileCheck.cpp

errs() << "Unable to combine check-prefix strings into a prefix regular "
            << REError << "\n";
     return 2;
   }
 
   SourceMgr SM;
 
   // Read the expected strings from the check file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> CheckFileOrErr =
-      MemoryBuffer::getFileOrSTDIN(CheckFilename, /*FileSize=*/-1,
-                                   /*RequiresNullTerminator=*/true,
-                                   /*IsText=*/true);
+      MemoryBuffer::getFileOrSTDIN(CheckFilename, /*IsText=*/true);
   if (std::error_code EC = CheckFileOrErr.getError()) {
     errs() << "Could not open check file '" << CheckFilename
            << "': " << EC.message() << '\n';
     return 2;
   }
   MemoryBuffer &CheckFile = *CheckFileOrErr.get();
 
   SmallString<4096> CheckFileBuffer;
   StringRef CheckFileText = FC.CanonicalizeFile(CheckFile, CheckFileBuffer);
 
   unsigned CheckFileBufferID =
       SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(
                                 CheckFileText, CheckFile.getBufferIdentifier()),
                             SMLoc());
 
   std::pair<unsigned, unsigned> ImpPatBufferIDRange;
   if (FC.readCheckFile(SM, CheckFileText, PrefixRE, &ImpPatBufferIDRange))
     return 2;
 
   // Open the file to check and add it to SourceMgr.
   ErrorOr<std::unique_ptr<MemoryBuffer>> InputFileOrErr =
-      MemoryBuffer::getFileOrSTDIN(InputFilename, /*FileSize=*/-1,
-                                   /*RequiresNullTerminator=*/true,
-                                   /*IsText=*/true);
+      MemoryBuffer::getFileOrSTDIN(InputFilename, /*IsText=*/true);
   if (InputFilename == "-")
     InputFilename = "<stdin>"; // Overwrite for improved diagnostic messages
   if (std::error_code EC = InputFileOrErr.getError()) {
     errs() << "Could not open input file '" << InputFilename
            << "': " << EC.message() << '\n';
     return 2;
   }
   MemoryBuffer &InputFile = *InputFileOrErr.get();