Split getOpenFile into getOpenFile and getOpenFileSlice.

The main observation is that we never need both the filesize and the map size.
When mapping a slice of a file, it doesn't make sense to request a null
terminator and that would be the only case where the filesize would be used.

There are other cleanups that should be done in this area:

* A client should not have to pass the size (even an explicit -1) to say if
  it wants a null terminator or not, so we should probably swap the argument
  order.
* The default should be to not require a null terminator. Very few clients
  require this, but many end up asking for it just because it is the default.

llvm-svn: 186984

llvm/include/llvm/Support/MemoryBuffer.h

@@ -74,13 +74,17 @@ public:
                             int64_t FileSize = -1,
                             bool RequiresNullTerminator = true);
 
-  /// getOpenFile - Given an already-open file descriptor, read the file and
+  // Get a MemoryBuffer of part of a file. Since this is in the middle of a
-  /// return a MemoryBuffer.
+  // file, the buffer is not null terminated.
+  static error_code getOpenFileSlice(int FD, const char *Filename,
+                                     OwningPtr<MemoryBuffer> &Result,
+                                     uint64_t MapSize, int64_t Offset);
+
+  /// Given an already-open file descriptor, read the file and return a
+  /// MemoryBuffer.
   static error_code getOpenFile(int FD, const char *Filename,
-                                OwningPtr<MemoryBuffer> &result,
+                                OwningPtr<MemoryBuffer> &Result,
-                                uint64_t FileSize = -1,
+                                uint64_t FileSize,
-                                uint64_t MapSize = -1,
-                                int64_t Offset = 0,
                                 bool RequiresNullTerminator = true);
 
   /// getMemBuffer - Open the specified memory range as a MemoryBuffer.  Note

llvm/lib/Support/MemoryBuffer.cpp

@@ -248,6 +248,11 @@ error_code MemoryBuffer::getFile(StringRef Filename,
                                RequiresNullTerminator);
 }
 
+static error_code getOpenFileImpl(int FD, const char *Filename,
+                                  OwningPtr<MemoryBuffer> &Result,
+                                  uint64_t FileSize, uint64_t MapSize,
+                                  int64_t Offset, bool RequiresNullTerminator);
+
 error_code MemoryBuffer::getFile(const char *Filename,
                                  OwningPtr<MemoryBuffer> &result,
                                  int64_t FileSize,
@@ -257,8 +262,8 @@ error_code MemoryBuffer::getFile(const char *Filename,
   if (EC)
     return EC;
 
-  error_code ret = getOpenFile(FD, Filename, result, FileSize, FileSize,
+  error_code ret = getOpenFileImpl(FD, Filename, result, FileSize, FileSize, 0,
-                               0, RequiresNullTerminator);
+                                   RequiresNullTerminator);
   close(FD);
   return ret;
 }
@@ -305,11 +310,10 @@ static bool shouldUseMmap(int FD,
   return true;
 }
 
-error_code MemoryBuffer::getOpenFile(int FD, const char *Filename,
+static error_code getOpenFileImpl(int FD, const char *Filename,
-                                     OwningPtr<MemoryBuffer> &result,
+                                  OwningPtr<MemoryBuffer> &result,
-                                     uint64_t FileSize, uint64_t MapSize,
+                                  uint64_t FileSize, uint64_t MapSize,
-                                     int64_t Offset,
+                                  int64_t Offset, bool RequiresNullTerminator) {
-                                     bool RequiresNullTerminator) {
   static int PageSize = sys::process::get_self()->page_size();
 
   // Default is to map the full file.
@@ -386,6 +390,20 @@ error_code MemoryBuffer::getOpenFile(int FD, const char *Filename,
   return error_code::success();
 }
 
+error_code MemoryBuffer::getOpenFile(int FD, const char *Filename,
+                                     OwningPtr<MemoryBuffer> &Result,
+                                     uint64_t FileSize,
+                                     bool RequiresNullTerminator) {
+  return getOpenFileImpl(FD, Filename, Result, FileSize, FileSize, 0,
+                         RequiresNullTerminator);
+}
+
+error_code MemoryBuffer::getOpenFileSlice(int FD, const char *Filename,
+                                          OwningPtr<MemoryBuffer> &Result,
+                                          uint64_t MapSize, int64_t Offset) {
+  return getOpenFileImpl(FD, Filename, Result, -1, MapSize, Offset, false);
+}
+
 //===----------------------------------------------------------------------===//
 // MemoryBuffer::getSTDIN implementation.
 //===----------------------------------------------------------------------===//

llvm/tools/gold/gold-plugin.cpp

@@ -252,9 +252,8 @@ static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file,
     if (file->offset) {
       offset = file->offset;
     }
-    if (error_code ec =
+    if (error_code ec = MemoryBuffer::getOpenFileSlice(
-        MemoryBuffer::getOpenFile(file->fd, file->name, buffer, -1,
+            file->fd, file->name, buffer, file->filesize, offset)) {
-                                  file->filesize, offset, false)) {
       (*message)(LDPL_ERROR, ec.message().c_str());
       return LDPS_ERR;
     }

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

@@ -770,9 +770,9 @@ static void performWriteOperation(ArchiveOperation Operation,
       failIfError(sys::fs::status(FD, Status), FileName);
 
       OwningPtr<MemoryBuffer> File;
-      failIfError(
+      failIfError(MemoryBuffer::getOpenFile(FD, FileName, File,
-          MemoryBuffer::getOpenFile(FD, FileName, File, Status.getSize()),
+                                            Status.getSize(), false),
-          FileName);
+                  FileName);
 
       StringRef Name = sys::path::filename(FileName);
       if (Name.size() < 16)

llvm/tools/lto/LTOModule.cpp

@@ -209,17 +209,16 @@ LTOModule *LTOModule::makeLTOModule(const char *path, std::string &errMsg) {
 
 LTOModule *LTOModule::makeLTOModule(int fd, const char *path,
                                     size_t size, std::string &errMsg) {
-  return makeLTOModule(fd, path, size, size, 0, errMsg);
+  return makeLTOModule(fd, path, size, 0, errMsg);
 }
 
 LTOModule *LTOModule::makeLTOModule(int fd, const char *path,
-                                    size_t file_size,
                                     size_t map_size,
                                     off_t offset,
                                     std::string &errMsg) {
   OwningPtr<MemoryBuffer> buffer;
-  if (error_code ec = MemoryBuffer::getOpenFile(fd, path, buffer, file_size,
+  if (error_code ec =
-                                                map_size, offset, false)) {
+          MemoryBuffer::getOpenFileSlice(fd, path, buffer, map_size, offset)) {
     errMsg = ec.message();
     return NULL;
   }

llvm/tools/lto/LTOModule.h

@@ -82,7 +82,6 @@ public:
   static LTOModule *makeLTOModule(int fd, const char *path,
                                   size_t size, std::string &errMsg);
   static LTOModule *makeLTOModule(int fd, const char *path,
-                                  size_t file_size,
                                   size_t map_size,
                                   off_t offset,
                                   std::string& errMsg);

llvm/tools/lto/lto.cpp

@@ -78,8 +78,7 @@ lto_module_t lto_module_create_from_fd_at_offset(int fd, const char *path,
                                                  size_t file_size,
                                                  size_t map_size,
                                                  off_t offset) {
-  return LTOModule::makeLTOModule(fd, path, file_size, map_size,
+  return LTOModule::makeLTOModule(fd, path, map_size, offset, sLastErrorString);
-                                  offset, sLastErrorString);
 }
 
 /// lto_module_create_from_memory - Loads an object file from memory. Returns

llvm/unittests/Support/MemoryBufferTest.cpp

@@ -113,13 +113,10 @@ TEST_F(MemoryBufferTest, getOpenFileNoNullTerminator) {
   }
 
   OwningBuffer Buf;
-  error_code EC = MemoryBuffer::getOpenFile(TestFD,
+  error_code EC = MemoryBuffer::getOpenFileSlice(TestFD, TestPath.c_str(), Buf,
-                                            TestPath.c_str(),
+                                                 40000, // Size
-                                            Buf,
+                                                 8000   // Offset
-                                            40000,    // Size
+                                                 );
-                                            -1,
-                                            8000,     // Offset
-                                            false);
   EXPECT_FALSE(EC);
 
   StringRef BufData = Buf->getBuffer();