Set MemoryBuffer's RequiresNullTerminator to false by default.

[ruiu]

Summary

MemoryBuffer::getFile()-family functions take RequiresNullTerminator
boolean argument. If it is true, MemoryBuffer ensures that the buffer
ends with '\0'. By default, it is true.

But that default was not reasonable. If you are reading binary files,
or even if you are reading text files, you usually don't need a nul
terminator character. However, because it's default, we do that in many
places.

This patch flips the default so that we don't append '\0' by default.

I tested this patch by adding code to add a dummy non-'\0' byte at end
of a buffer if RequiresNullTerminator is false and run all tests.

[• espindola]

I really like the idea of changing the default, but maybe instead of an argument we should just have two functions:

getFile(...)
getNullTerminatedFile(...)

clang/tools/clang-refactor/TestSupport.cpp

297

Maybe we should have a getNullTerminatedFile?

llvm/unittests/AsmParser/AsmParserTest.cpp

36

Why delete this test?

[ruiu]

clang/tools/clang-refactor/TestSupport.cpp

297

I tried that but it seems it is better to do it incrementally. MemoryBuffer functions are used at a lot of places in LLVM and doing multiple changes in the same patch isn't easy. So let me submit this patch first.

llvm/unittests/AsmParser/AsmParserTest.cpp

36

Because this test doesn't pass with this patch and what this test is testing doesn't make sense. It verifies that the asm parser dies with an assertion failure if an input is not \0-terminated, but the asm parser doesn't actually requires the terminator. It works fine without it.

[inglorion]

Thanks for doing this! I did some of the ground work for this in the COFF linker, but never got around to flipping the default. I too like the idea of having a separate function for the NUL-terminated case. It seems we all want that, so how do we get there? Are you planning to follow this up with a patch that removes the RequiresNullTerminator flag and rewrites calls that use it to use the new function instead?

[ruiu]

I believe this patch is ready for submit, though I didn't get any LGTM for this. Could you review it for me?

[inglorion]

I haven't accepted the patch yet because I want to make sure we do end up removing the RequiresNullTerminator flag. You indicated that you don't want to do that in this patch. That's ok with me as long as you do plan to do it in a soon-to-come follow-up patch. If you don't plan to write that follow-up patch, I would like you to include the new function and rewrite the calls in this patch.

[ruiu]

Yes, I'll create a follow-up patch to remove RequiresNullTerminator from this function and create a new function for those that needs that functionality.

[inglorion]

Alright then, LGTM.

clang/lib/Tooling/CompilationDatabase.cpp

if (!stripPositionalArgs(CommandLine, StrippedArgs, ErrorMsg))
     return nullptr;
   return llvm::make_unique<FixedCompilationDatabase>(Directory, StrippedArgs);
 }
 
 std::unique_ptr<FixedCompilationDatabase>
 FixedCompilationDatabase::loadFromFile(StringRef Path, std::string &ErrorMsg) {
   ErrorMsg.clear();
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
-      llvm::MemoryBuffer::getFile(Path);
+      llvm::MemoryBuffer::getFile(Path, -1, true);
   if (std::error_code Result = File.getError()) {
     ErrorMsg = "Error while opening fixed database: " + Result.message();
     return nullptr;
   }
   std::vector<std::string> Args{llvm::line_iterator(**File),
                                 llvm::line_iterator()};
   return llvm::make_unique<FixedCompilationDatabase>(
       llvm::sys::path::parent_path(Path), std::move(Args));

clang/tools/clang-refactor/ClangRefactor.cpp

bool applySourceChanges() {
     for (const auto &Change : Changes)
       Files.insert(Change.getFilePath());
     // FIXME: Add automatic formatting support as well.
     tooling::ApplyChangesSpec Spec;
     // FIXME: We should probably cleanup the result by default as well.
     Spec.Cleanup = false;
     for (const auto &File : Files) {
       llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> BufferErr =
-          llvm::MemoryBuffer::getFile(File);
+          llvm::MemoryBuffer::getFile(File, -1, true);
       if (!BufferErr) {
         llvm::errs() << "error: failed to open " << File << " for rewriting\n";
         return true;
       }
       auto Result = tooling::applyAtomicChanges(File, (*BufferErr)->getBuffer(),
                                                 Changes, Spec);
       if (!Result) {
         llvm::errs() << toString(Result.takeError());

clang/tools/clang-refactor/TestSupport.cpp

bool printRewrittenSources(const tooling::AtomicChanges &Changes,
                            raw_ostream &OS) {
   std::set<std::string> Files;
   for (const auto &Change : Changes)
     Files.insert(Change.getFilePath());
   tooling::ApplyChangesSpec Spec;
   Spec.Cleanup = false;
   for (const auto &File : Files) {
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> BufferErr =
-        llvm::MemoryBuffer::getFile(File);
+        llvm::MemoryBuffer::getFile(File, -1, true);
     if (!BufferErr) {
       llvm::errs() << "failed to open" << File << "\n";
       return true;
     }
     auto Result = tooling::applyAtomicChanges(File, (*BufferErr)->getBuffer(),
                                               Changes, Spec);
     if (!Result) {
       llvm::errs() << toString(Result.takeError());
private:
 
   const TestSelectionRangesInFile &TestRanges;
   std::vector<std::vector<Expected<tooling::AtomicChanges>>> Results;
 };
 
 std::pair<unsigned, unsigned> getLineColumn(StringRef Filename,
                                             unsigned Offset) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrOrFile =
-      MemoryBuffer::getFile(Filename);
+      MemoryBuffer::getFile(Filename, -1, true);
   if (!ErrOrFile)
     return {0, 0};
   StringRef Source = ErrOrFile.get()->getBuffer();
   Source = Source.take_front(Offset);
   size_t LastLine = Source.find_last_of("\r\n");
   return {Source.count('\n') + 1,
           (LastLine == StringRef::npos ? Offset : Offset - LastLine) + 1};
 }
static unsigned addEndLineOffsetAndEndColumn(StringRef Source, unsigned Offset,
   size_t LineStart = Source.find_last_of("\r\n", /*From=*/Offset + LineOffset);
   return addColumnOffset(
       Source, LineStart == StringRef::npos ? 0 : LineStart + 1, Column - 1);
 }
 
 Optional<TestSelectionRangesInFile>
 findTestSelectionRanges(StringRef Filename) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrOrFile =
-      MemoryBuffer::getFile(Filename);
+      MemoryBuffer::getFile(Filename, -1, true);
   if (!ErrOrFile) {
     llvm::errs() << "error: -selection=test:" << Filename
                  << " : could not open the given file";
     return None;
   }
   StringRef Source = ErrOrFile.get()->getBuffer();
 
   // See the doc comment for this function for the explanation of this

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);
     if (!MBOrErr)
       return MBErrPair{nullptr, MBOrErr.getError()};
     return MBErrPair{std::move(*MBOrErr), std::error_code()};
   });
 }
 
 MemoryBufferRef LinkerDriver::takeBuffer(std::unique_ptr<MemoryBuffer> MB) {
   MemoryBufferRef MBRef = *MB;
static void createImportLibrary(bool AsLib) {
   if (!Config->Incremental) {
     HandleError(writeImportLibrary(LibName, Path, Exports, Config->Machine,
                                    false, 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);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> OldBuf = MemoryBuffer::getFile(Path);
   if (!OldBuf) {
     HandleError(writeImportLibrary(LibName, Path, Exports, Config->Machine,
                                    false, 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,
                                    false, Config->MinGW)) {
     HandleError(std::move(E));
     return;
   }
 
-  std::unique_ptr<MemoryBuffer> NewBuf = check(MemoryBuffer::getFile(
-      TmpName, /*FileSize*/ -1, /*RequiresNullTerminator*/ false));
+  std::unique_ptr<MemoryBuffer> NewBuf = check(MemoryBuffer::getFile(TmpName));
   if ((*OldBuf)->getBuffer() != NewBuf->getBuffer()) {
     OldBuf->reset();
     HandleError(errorCodeToError(sys::fs::rename(TmpName, Path)));
   } else {
     sys::fs::remove(TmpName);
   }
 }
 

llvm/include/llvm/Support/MemoryBuffer.h

public:
   /// means that the client knows that the file exists and that it has the
   /// specified size.
   ///
   /// \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.
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getFile(const Twine &Filename, int64_t FileSize = -1,
-          bool RequiresNullTerminator = true, bool IsVolatile = false);
+          bool RequiresNullTerminator = false, bool IsVolatile = false);
 
   /// 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
   /// MemoryBuffer. The slice is specified by an \p Offset and \p MapSize.
   /// Since this is in the middle of a file, the buffer is not null terminated.
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize,
                    int64_t Offset, bool IsVolatile = false);
 
   /// Given an already-open file descriptor, read the file and return a
   /// MemoryBuffer.
   ///
   /// \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.
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getOpenFile(int FD, const Twine &Filename, uint64_t FileSize,
-              bool RequiresNullTerminator = true, bool IsVolatile = false);
+              bool RequiresNullTerminator = false, bool IsVolatile = false);
 
   /// Open the specified memory range as a MemoryBuffer. Note that InputData
   /// must be null terminated if RequiresNullTerminator is true.
   static std::unique_ptr<MemoryBuffer>
   getMemBuffer(StringRef InputData, StringRef BufferName = "",
-               bool RequiresNullTerminator = true);
+               bool RequiresNullTerminator = false);
 
   static std::unique_ptr<MemoryBuffer>
-  getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator = true);
+  getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator = false);
 
   /// Open the specified memory range as a MemoryBuffer, copying the contents
   /// and taking ownership of it. InputData does not have to be null terminated.
   static std::unique_ptr<MemoryBuffer>
   getMemBufferCopy(StringRef InputData, const Twine &BufferName = "");
 
   /// Read all of stdin into a file buffer, and return it.
   static ErrorOr<std::unique_ptr<MemoryBuffer>> getSTDIN();

llvm/lib/AsmParser/Parser.cpp

llvm::parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context,
   return M;
 }
 
 std::unique_ptr<Module>
 llvm::parseAssemblyFile(StringRef Filename, SMDiagnostic &Err,
                         LLVMContext &Context, SlotMapping *Slots,
                         bool UpgradeDebugInfo, StringRef DataLayoutString) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(Filename);
+      MemoryBuffer::getFileOrSTDIN(Filename, -1, true);
   if (std::error_code EC = FileOrErr.getError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
                        "Could not open input file: " + EC.message());
     return nullptr;
   }
 
   return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots,
                        UpgradeDebugInfo, DataLayoutString);

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

 static const char kBadString[] = "??";
 
 // Prints source code around in the FileName the Line.
 void DIPrinter::printContext(const std::string &FileName, int64_t Line) {
   if (PrintSourceContext <= 0)
     return;
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
-      MemoryBuffer::getFile(FileName);
+      MemoryBuffer::getFile(FileName, -1, true);
   if (!BufOrErr)
     return;
 
   std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
   int64_t FirstLine =
       std::max(static_cast<int64_t>(1), Line - PrintSourceContext / 2);
   int64_t LastLine = FirstLine + PrintSourceContext;
   size_t MaxLineNumberWidth = std::ceil(std::log10(LastLine));

llvm/lib/Support/SourceMgr.cpp

 
 static const size_t TabStop = 8;
 
 unsigned SourceMgr::AddIncludeFile(const std::string &Filename,
                                    SMLoc IncludeLoc,
                                    std::string &IncludedFile) {
   IncludedFile = Filename;
   ErrorOr<std::unique_ptr<MemoryBuffer>> NewBufOrErr =
-    MemoryBuffer::getFile(IncludedFile);
+      MemoryBuffer::getFile(IncludedFile, -1, /*RequiresNullTerminator=*/true);
 
   // If the file didn't exist directly, see if it's in an include path.
   for (unsigned i = 0, e = IncludeDirectories.size(); i != e && !NewBufOrErr;
        ++i) {
     IncludedFile =
         IncludeDirectories[i] + sys::path::get_separator().data() + Filename;
-    NewBufOrErr = MemoryBuffer::getFile(IncludedFile);
+    NewBufOrErr = MemoryBuffer::getFile(IncludedFile, -1, true);
   }
 
   if (!NewBufOrErr)
     return 0;
 
   return AddNewSourceBuffer(std::move(*NewBufOrErr), IncludeLoc);
 }
 

llvm/lib/TableGen/Main.cpp

static int createDependencyFile(const TGParser &Parser, const char *argv0) {
   return 0;
 }
 
 int llvm::TableGenMain(char *argv0, TableGenMainFn *MainFn) {
   RecordKeeper Records;
 
   // Parse the input file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
-      MemoryBuffer::getFileOrSTDIN(InputFilename);
+      MemoryBuffer::getFileOrSTDIN(InputFilename, -1, true);
   if (std::error_code EC = FileOrErr.getError())
     return reportError(argv0, "Could not open input file '" + InputFilename +
                                   "': " + EC.message() + "\n");
 
   // Tell SrcMgr about this buffer, which is what TGParser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*FileOrErr), SMLoc());
 
   // Record the location of the include directory so that the lexer can find

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);
     // 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 performOperation(ArchiveOperation Operation,
   }
   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);
+      MemoryBuffer::getFile(ArchiveName);
   std::error_code EC = Buf.getError();
   if (EC && EC != errc::no_such_file_or_directory)
     fail("error opening '" + ArchiveName + "': " + EC.message() + "!");
 
   if (!EC) {
     Error Err = Error::success();
     object::Archive Archive(Buf.get()->getMemBufferRef(), Err);
     EC = errorToErrorCode(std::move(Err));
auto Command = StringSwitch<MRICommand>(CommandStr.lower())
                        .Case("create", MRICommand::Create)
                        .Case("delete", MRICommand::Delete)
                        .Case("save", MRICommand::Save)
                        .Case("end", MRICommand::End)
                        .Default(MRICommand::Invalid);
 
     switch (Command) {
     case MRICommand::AddLib: {
-      auto BufOrErr = MemoryBuffer::getFile(Rest, -1, false);
+      auto BufOrErr = MemoryBuffer::getFile(Rest);
       failIfError(BufOrErr.getError(), "Could not open 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));
       object::Archive &Lib = *Archives.back();

llvm/tools/llvm-cov/CodeCoverage.cpp

CodeCoverageTool::getSourceFile(StringRef SourceFile) {
   if (!RemappedFilenames.empty()) {
     auto Loc = RemappedFilenames.find(SourceFile);
     if (Loc != RemappedFilenames.end())
       SourceFile = Loc->second;
   }
   for (const auto &Files : LoadedSourceFiles)
     if (sys::fs::equivalent(SourceFile, Files.first))
       return *Files.second;
-  auto Buffer = MemoryBuffer::getFile(SourceFile);
+  auto Buffer = MemoryBuffer::getFile(SourceFile, -1, true);
   if (auto EC = Buffer.getError()) {
     error(EC.message(), SourceFile);
     return EC;
   }
   LoadedSourceFiles.emplace_back(SourceFile, std::move(Buffer.get()));
   return *LoadedSourceFiles.back().second;
 }
 

llvm/tools/llvm-cov/gcov.cpp

std::string GCNO = InputGCNO.empty()
                          ? std::string(CoverageFileStem.str()) + ".gcno"
                          : InputGCNO;
   std::string GCDA = InputGCDA.empty()
                          ? std::string(CoverageFileStem.str()) + ".gcda"
                          : InputGCDA;
   GCOVFile GF;
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> GCNO_Buff =
-      MemoryBuffer::getFileOrSTDIN(GCNO);
+      MemoryBuffer::getFileOrSTDIN(GCNO, -1, true);
   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);
+      MemoryBuffer::getFileOrSTDIN(GCDA, -1, true);
   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-opt-report/OptReport.cpp

if (!InputRelDir.empty()) {
                            << EC.message() << "\n";
         return false;
       }
     }
 
     const auto &FileInfo = FI.second;
 
     ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
-        MemoryBuffer::getFile(FileName);
+        MemoryBuffer::getFile(FileName, -1, true);
     if (std::error_code EC = Buf.getError()) {
       WithColor::error() << "Can't open file " << FileName << ": "
                          << EC.message() << "\n";
       return false;
     }
 
     if (FirstFile)
       FirstFile = false;

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);
   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-rc/ResourceFileWriter.cpp

ResourceFileWriter::loadFile(StringRef File) const {
   SmallString<128> Cwd;
   std::unique_ptr<MemoryBuffer> Result;
 
   // 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));
 
   // 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));
 
   // 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));
   }
 
   if (auto Result =
           llvm::sys::Process::FindInEnvPath("INCLUDE", File, Params.NoInclude))
-    return errorOrToExpected(MemoryBuffer::getFile(*Result, -1, false));
+    return errorOrToExpected(MemoryBuffer::getFile(*Result));
 
   return make_error<StringError>("error : file not found : " + Twine(File),
                                  inconvertibleErrorCode());
 }
 
 } // namespace rc
 } // namespace llvm

llvm/tools/sanstats/sanstats.cpp

const char *ReadModule(char SizeofPtr, const char *Begin, const char *End) {
   }
 }
 
 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);
+      MemoryBuffer::getFile(ClInputFile);
   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/unittests/AsmParser/AsmParserTest.cpp

TEST(AsmParserTest, NullTerminatedInput) {
   StringRef Source = "; Empty module \n";
   SMDiagnostic Error;
   auto Mod = parseAssemblyString(Source, Error, Ctx);
 
   EXPECT_TRUE(Mod != nullptr);
   EXPECT_TRUE(Error.getMessage().empty());
 }
 
-#ifdef GTEST_HAS_DEATH_TEST
-#ifndef NDEBUG
-
-TEST(AsmParserTest, NonNullTerminatedInput) {
-  LLVMContext Ctx;
-  StringRef Source = "; Empty module \n\1\2";
-  SMDiagnostic Error;
-  std::unique_ptr<Module> Mod;
-  EXPECT_DEATH(Mod = parseAssemblyString(Source.substr(0, Source.size() - 2),
-                                         Error, Ctx),
-               "Buffer is not null terminated!");
-}
-
-#endif
-#endif
-
 TEST(AsmParserTest, SlotMappingTest) {
   LLVMContext Ctx;
   StringRef Source = "@0 = global i32 0\n !0 = !{}\n !42 = !{i32 42}";
   SMDiagnostic Error;
   SlotMapping Mapping;
   auto Mod = parseAssemblyString(Source, Error, Ctx, &Mapping);
 
   EXPECT_TRUE(Mod != nullptr);