Map ELF files as writable so we can update the relocations in them

[tberghammer]

Summary

Map ELF files as writable so we can update the relocations in them

After this change ELF files will be mapped as private writable pages so
we can cheaply update the relocations inside them without have to read
them into memory and any modification we do in the memory will not be
reflected in the on disk files.

[labath]

Adding Zachary as he was about to remove this code.

The timing of this patch is a bit unfortunate, as it would complicate the removal of the code in question. If I am not mistaken, llvm's version currently does not support copy-on-write mappings, which is what we are trying to do here. The c-o-w could certainly be added there, and we will probably need to do it in the future, but I am not sure whether this is the right time for it. I don't want to impede Zachary's cleanup effort due to a "feature" that noone has serious commitment of supporting.

include/lldb/Host/FileSpec.h

public:
   ///     as many bytes as possible.
   ///
   /// @return
   ///     A shared pointer to the memory mapped data. This shared
   ///     pointer can contain a nullptr DataBuffer pointer, so the contained
   ///     pointer must be checked prior to using it.
   //------------------------------------------------------------------
   lldb::DataBufferSP MemoryMapFileContents(off_t offset = 0,
-                                           size_t length = SIZE_MAX) const;
+                                           size_t length = SIZE_MAX,
+                                           bool writeable = false) const;
 
   //------------------------------------------------------------------
   /// Memory map part of, or the entire contents of, a file only if
   /// the file is local (not on a network mount).
   ///
   /// Returns a shared pointer to a data buffer that contains all or
   /// part of the contents of a file. The data will be memory mapped
   /// if the file is local and will lazily page in data from the file
public:
   ///     as many bytes as possible.
   ///
   /// @return
   ///     A shared pointer to the memory mapped data. This shared
   ///     pointer can contain a nullptr DataBuffer pointer, so the contained
   ///     pointer must be checked prior to using it.
   //------------------------------------------------------------------
   lldb::DataBufferSP MemoryMapFileContentsIfLocal(off_t file_offset,
-                                                  size_t file_size) const;
+                                                  size_t file_size,
+                                                  bool writeable = false) const;
 
   //------------------------------------------------------------------
   /// Read part of, or the entire contents of, a file into a heap based data
   /// buffer.
   ///
   /// Returns a shared pointer to a data buffer that contains all or
   /// part of the contents of a file. The data copies into a heap based
   /// buffer that lives in the DataBuffer shared pointer object returned.

source/Host/common/FileSpec.cpp

 // The data that is mapped will start "file_offset" bytes into the
 // file, and "file_size" bytes will be mapped. If "file_size" is
 // greater than the number of bytes available in the file starting
 // at "file_offset", the number of bytes will be appropriately
 // truncated. The final number of bytes that get mapped can be
 // verified using the DataBuffer::GetByteSize() function.
 //------------------------------------------------------------------
 DataBufferSP FileSpec::MemoryMapFileContents(off_t file_offset,
-                                             size_t file_size) const {
+                                             size_t file_size,
+                                             bool writeable) const {
   DataBufferSP data_sp;
   std::unique_ptr<DataBufferMemoryMap> mmap_data(new DataBufferMemoryMap());
   if (mmap_data.get()) {
     const size_t mapped_length =
-        mmap_data->MemoryMapFromFileSpec(this, file_offset, file_size);
+        mmap_data->MemoryMapFromFileSpec(this,
+                                         file_offset,
+                                         file_size,
+                                         writeable);
     if (((file_size == SIZE_MAX) && (mapped_length > 0)) ||
         (mapped_length >= file_size))
       data_sp.reset(mmap_data.release());
   }
   return data_sp;
 }
 
 DataBufferSP FileSpec::MemoryMapFileContentsIfLocal(off_t file_offset,
-                                                    size_t file_size) const {
+                                                    size_t file_size,
+                                                    bool writeable) const {
   if (FileSystem::IsLocal(*this))
-    return MemoryMapFileContents(file_offset, file_size);
+    return MemoryMapFileContents(file_offset, file_size, writeable);
   else
     return ReadFileContents(file_offset, file_size, NULL);
 }
 
 //------------------------------------------------------------------
 // Return the size in bytes that this object takes in memory. This
 // returns the size in bytes of this object, not any shared string
 // values it may refer to.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 
 ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp,
                                           DataBufferSP &data_sp,
                                           lldb::offset_t data_offset,
                                           const lldb_private::FileSpec *file,
                                           lldb::offset_t file_offset,
                                           lldb::offset_t length) {
   if (!data_sp) {
-    data_sp = file->MemoryMapFileContentsIfLocal(file_offset, length);
+    data_sp = file->MemoryMapFileContentsIfLocal(file_offset, length, true);
     data_offset = 0;
   }
 
   if (data_sp &&
       data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
     const uint8_t *magic = data_sp->GetBytes() + data_offset;
     if (ELFHeader::MagicBytesMatch(magic)) {
       // Update the data to contain the entire file if it doesn't already
       if (data_sp->GetByteSize() < length) {
-        data_sp = file->MemoryMapFileContentsIfLocal(file_offset, length);
+        data_sp = file->MemoryMapFileContentsIfLocal(file_offset, length, true);
         data_offset = 0;
         magic = data_sp->GetBytes();
       }
       unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
       if (address_size == 4 || address_size == 8) {
         std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(
             module_sp, data_sp, data_offset, file, file_offset, length));
         ArchSpec spec;
if (header.Parse(data, &header_offset)) {
           // In case there is header extension in the section #0, the header
           // we parsed above could have sentinel values for e_phnum, e_shnum,
           // and e_shstrndx.  In this case we need to reparse the header
           // with a bigger data source to get the actual values.
           size_t section_header_end = header.e_shoff + header.e_shentsize;
           if (header.HasHeaderExtension() &&
             section_header_end > data_sp->GetByteSize()) {
             data_sp = file.MemoryMapFileContentsIfLocal (file_offset,
-                                                         section_header_end);
+                                                         section_header_end,
+                                                         true);
             data.SetData(data_sp);
             lldb::offset_t header_offset = data_offset;
             header.Parse(data, &header_offset);
           }
 
           // Try to get the UUID from the section list. Usually that's at the
           // end, so
           // map the file in if we don't have it already.
           section_header_end =
               header.e_shoff + header.e_shnum * header.e_shentsize;
           if (section_header_end > data_sp->GetByteSize()) {
             data_sp = file.MemoryMapFileContentsIfLocal(file_offset,
-                                                        section_header_end);
+                                                        section_header_end,
+                                                        true);
             data.SetData(data_sp);
           }
 
           uint32_t gnu_debuglink_crc = 0;
           std::string gnu_debuglink_file;
           SectionHeaderColl section_headers;
           lldb_private::UUID &uuid = spec.GetUUID();
 
if (header.Parse(data, &header_offset)) {
               // and are pretty bulky - calculating whole contents crc32 would
               // be too much of luxury.
               // Thus we will need to fallback to something simpler.
               if (header.e_type == llvm::ELF::ET_CORE) {
                 size_t program_headers_end =
                     header.e_phoff + header.e_phnum * header.e_phentsize;
                 if (program_headers_end > data_sp->GetByteSize()) {
                   data_sp = file.MemoryMapFileContentsIfLocal(
-                      file_offset, program_headers_end);
+                      file_offset, program_headers_end, true);
                   data.SetData(data_sp);
                 }
                 ProgramHeaderColl program_headers;
                 GetProgramHeaderInfo(program_headers, set_data, header);
 
                 size_t segment_data_end = 0;
                 for (ProgramHeaderCollConstIter I = program_headers.begin();
                      I != program_headers.end(); ++I) {
                   segment_data_end = std::max<unsigned long long>(
                       I->p_offset + I->p_filesz, segment_data_end);
                 }
 
                 if (segment_data_end > data_sp->GetByteSize()) {
                   data_sp = file.MemoryMapFileContentsIfLocal(file_offset,
-                                                              segment_data_end);
+                                                              segment_data_end,
+                                                              true);
                   data.SetData(data_sp);
                 }
 
                 core_notes_crc =
                     CalculateELFNotesSegmentsCRC32(program_headers, data);
               } else {
                 // Need to map entire file into memory to calculate the crc.
                 data_sp =
-                    file.MemoryMapFileContentsIfLocal(file_offset, SIZE_MAX);
+                    file.MemoryMapFileContentsIfLocal(file_offset,
+                                                      SIZE_MAX,
+                                                      true);
                 data.SetData(data_sp);
                 gnu_debuglink_crc = calc_gnu_debuglink_crc32(
                     data.GetDataStart(), data.GetByteSize());
               }
             }
             if (gnu_debuglink_crc) {
               // Use 4 bytes of crc from the .gnu_debuglink section.
               uint32_t uuidt[4] = {gnu_debuglink_crc, 0, 0, 0};