ELF: create "container" sections from PT_LOAD segments

[labath]

Summary

This is the result of the discussion in D55356, where it was suggested
as a solution to representing the addresses that logically belong to a
module in memory, but are not a part of any of its sections.

The ELF PT_LOAD segments are similar to the MachO "load commands",
except that the relationship between them and the object file sections
is a bit weaker. While in the MachO case, the sections belonging to a
specific segment are placed directly inside it in the object file
logical structur, in the ELF case, the sections and segments form two
separate hierarchies. This means that it is in theory possible to create
an elf file where only a part of a section would belong to some segment
(and another part to a different one). However, I am not aware of any
tool which would produce such a file (and most tools will have problems
ingesting them), so this means it is still possible to follow the MachO
model and make sections children of the PT_LOAD segments.

In case we run into (corrupt?) files with overlapping sections, I have
added code (and tests) which adjusts the sizes and/or drops the offending
sections in order to present a reasonable image to the upper layers of
LLDB. This is mostly done for completeness, as I don't anticipate
running into this situation in the real world. However, if we do run
into it, and the current behavior is not suitable for some reason, we
can implement this logic differently.

[clayborg]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1841–1844 ↗

(On Diff #179278)

Use existing range code from Range.h?

#include "lldb/Utility/Range.h"
typedef Range<lldb::addr_t, lldb::addr_t> SegmentAddressInfo;

1846–1850 ↗

(On Diff #179278)

Use SegmentAddressInfo using either of:

struct SectionAddressInfo : public SegmentAddressInfo {
  SectionSP Segment;
};

or

struct SectionAddressInfo {
  SegmentAddressInfo Range;
  SectionSP Segment;
};

1954 ↗

(On Diff #179278)

Maybe add square brackets around section name? "PT_LOAD[0]" "PT_LOAD[1]"? I am fine either way, just throwing this out there

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

229 ↗

(On Diff #179278)

Make this static and move to ObjectFileElf.cpp? It doesn't need to be a method.

[jankratochvil]

it is in theory possible to create an elf file where only a part of a section would belong to some segment (and another part to a different one).

ELF standard: "An object file segment contains one or more sections.", "An object file segment comprises one or more sections"

[joerg]

In D55998#1340448, @jankratochvil wrote:

it is in theory possible to create an elf file where only a part of a section would belong to some segment (and another part to a different one).

ELF standard: "An object file segment contains one or more sections.", "An object file segment comprises one or more sections"

I wouldn't rule out smart tools splitting a section into a read-only and read-write part on linking. So no, I certainly wouldn't assume any direct correspondance between segments and sections.

[labath]

In D55998#1340711, @joerg wrote:

In D55998#1340448, @jankratochvil wrote:

ELF standard: "An object file segment contains one or more sections.", "An object file segment comprises one or more sections"

I wouldn't rule out smart tools splitting a section into a read-only and read-write part on linking. So no, I certainly wouldn't assume any direct correspondance between segments and sections.

That's interesting. Do you know of any such tool doing that? I am asking because that might give us a clue on how to handle that situation. In your example, it might be cleanest to split the offending section in two, and place the parts in appropriate segments (with the right permissions). However, I don't want to add code doing that if there is no known tool producing such files. If there aren't any (and I hope that there aren't, since it does appear to violate the spec), then I think we should just do the minimal amount of work necessary to process these (corrupt?) files without doing something completely bogus (like crashing). I think the current implementation would fit that bill.

[labath]

Address review comments:

• move SegmentID() to the cpp file
• use lldb_private::Range (not lldb_utility::Range) for segment and sections ranges
• use brackets in segment names (PT_LOAD[0])

[joerg]

I foundamentally don't understand what you are trying to do. You can either look at the executable from a segment perspective or from a section perspective. But trying to mix the views is bound to give bogus results.

[labath]

In D55998#1341263, @joerg wrote:

I foundamentally don't understand what you are trying to do.

This is stemming from a discussion on a different patch. If you're interested in the full background you can look it up here https://reviews.llvm.org/D55356#1327099 (note that some of it happened on the mailing list, so it may not have made it into phabricator), but the short story is this: I needed a way to represent the base address of a module in lldb. Although that seems trivial, it is made complicated by the fact that lldb assumes that this address will belong to one of the module's sections. In the ELF case that typically won't be the case, as the load address will typically point to the first byte of the elf header (although it can point to anything really). Now, after learning this, my first reaction was also, "well, duh, we need to change that assumption", but then I realized that this will actually be correct if you consider treat segments to be "sections" as well (as then the load address is just the first byte of the first section). The nice part about this is that (to my surprise) perfectly matches what lldb is doing for MachO files. And if we assume that the elf spec that Jan quoted is true, then this is also a perfectly valid thing to do.

Also, even though this wasn't my motivation, I believe an even bigger impact of this will be greater accuracy in the way lldb attributes addresses. Right now, if you ask lldb about an a module's address which doesn't belong to any of the module's sections (e.g. the inter-section padding, or the padding commonly present at the beginning of the first segment), then lldb will say it doesn't have a clue. With this patch, it will correctly report that this address belongs to the module and was loaded by the given PT_LOAD segment.

You can either look at the executable from a segment perspective or from a section perspective. But trying to mix the views is bound to give bogus results.

But will it really? I mean, it's technically possible to create an elf file with inconsistent section/segment views, but the only way I know of doing that involves using a hex editor (and, then, I could create bogus MachO files the same way). As far as I know, gnu linker scripts https://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_node/ld_23.html#SEC23 only allow you to put the whole section into a segment or none of it. yaml2obj (I know that's not a very convincing data point) has the same restriction. With a hex-editor, I can create many inconsistencies using the section headers alone, but I'm not worried about those either, if there isn't a legitimate use case for e.g. sections with overlapping VM addresses. Obviously, throwing program headers into the mix adds a whole new level of possible inconsistencies, but I am not sure if these ever occur in practice.

[labath]

Greg, what do you think about the current version of this patch.

Joerg, I propose to check the patch in in the current form, as this solves existing issues in the lldb's ELF representation and improves the overall consistency of lldb's representation of object files. I'm not opposed to changing things again if we find a use case that this breaks, but I can do that only once I know what that use case is (and that might involve making changes to the generic representation of modules in lldb).

[clayborg]

LGTM

lldb/trunk/lit/Modules/ELF/PT_LOAD-empty.yaml

+# Test behavior on unusual (and probably corrupt) files. Test that we drop an
+# empty PT_LOAD segment.
+
+# RUN: yaml2obj %s > %t
+# RUN: lldb-test object-file %t | FileCheck %s
+#
+# CHECK-NOT: container
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_ARM
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x1000
+    Align: 0x4

lldb/trunk/lit/Modules/ELF/PT_LOAD-overlap-PT_INTERP.yaml

+# Test that an overlapping PT_INTERP segment does not cause us to drop the
+# subsequent PT_LOAD segment.
+
+# RUN: yaml2obj %s > %t
+# RUN: lldb-test object-file %t | FileCheck %s
+
+# CHECK:        Index: 0
+# CHECK-NEXT:   ID: 0xfffffffffffffffe
+# CHECK-NEXT:   Name: PT_LOAD[0]
+# CHECK-NEXT:   Type: container
+# CHECK-NEXT:   Permissions: rwx
+# CHECK-NEXT:   Thread specific: no
+# CHECK-NEXT:   VM address: 0x1000
+# CHECK-NEXT:   VM size: 12
+# CHECK-NEXT:   File size: 12
+# CHECK-NEXT:   Showing 2 subsections
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_ARM
+Sections:
+  - Name:            .interp
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1000
+    AddressAlign:    0x4
+    Content:         3232
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1004
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+ProgramHeaders:
+  - Type: PT_INTERP
+    Flags: [ PF_R ]
+    VAddr: 0x1000
+    Align: 0x4
+    Sections:
+      - Section: .interp
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_W, PF_R ]
+    VAddr: 0x1000
+    Align: 0x4
+    Sections:
+      - Section: .interp
+      - Section: .text

lldb/trunk/lit/Modules/ELF/PT_LOAD-overlap-section.yaml

+# Test behavior on strange (invalid?) elf files where the sections cross segment
+# boundary. The test input was generated from this yaml file, but the program
+# header was modified by hand, so this input is here for reference only.
+#
+# Right now lldb shortens sections to make sure every section is fully contained
+# within a segment, but other behaviors are possible too (including outright
+# rejecting such files).
+
+# RUN: lldb-test object-file %S/Inputs/PT_LOAD-overlap-section.elf | FileCheck %s
+
+# CHECK:      Index: 0
+# CHECK-NEXT: ID: 0xffffffffffffffff
+# CHECK-NEXT: Name: PT_LOAD[0]
+# CHECK-NEXT: Type: container
+# CHECK-NEXT: Permissions: rwx
+# CHECK-NEXT: Thread specific: no
+# CHECK-NEXT: VM address: 0x1006
+# CHECK-NEXT: VM size: 8
+# CHECK-NEXT: File size: 8
+# CHECK-NEXT: Showing 1 subsections
+# CHECK-NEXT:   Index: 0
+# CHECK-NEXT:   ID: 0x2
+# CHECK-NEXT:   Name: .text
+# CHECK-NEXT:   Type: code
+# CHECK-NEXT:   Permissions: r-x
+# CHECK-NEXT:   Thread specific: no
+# CHECK-NEXT:   VM address: 0x1008
+# CHECK-NEXT:   VM size: 6
+# CHECK-NEXT:   File size: 8
+
+# CHECK:      Index: 1
+# CHECK-NEXT: ID: 0x1
+# CHECK-NEXT: Name: .interp
+# CHECK-NEXT: Type: regular
+# CHECK-NEXT: Permissions: r--
+# CHECK-NEXT: Thread specific: no
+# CHECK-NEXT: VM address: 0x1000
+# CHECK-NEXT: VM size: 6
+# CHECK-NEXT: File size: 8
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_ARM
+Sections:
+  - Name:            .interp
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1000
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1008
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_W, PF_R ]
+    VAddr: 0x1008 # Modified by hand to start at 0x1006
+    Align: 0x4
+    Sections:
+      - Section: .text

lldb/trunk/lit/Modules/ELF/PT_LOAD-overlap.yaml

+# Test behavior on unusual (and probably corrupt) object files. Check that we
+# drop the second PT_LOAD segment which overlaps with the first one.
+
+# RUN: yaml2obj %s > %t
+# RUN: lldb-test object-file %t | FileCheck %s
+
+# CHECK: Type: container
+# CHECK-NOT: Type: container
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_ARM
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1008
+    AddressAlign:    0x4
+    Content:         3232
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_W, PF_R ]
+    VAddr: 0x1000
+    Align: 0x4
+    Sections:
+      - Section: .text
+      - Section: .data
+  - Type: PT_LOAD
+    Flags: [ PF_R, PF_W ]
+    VAddr: 0x1008
+    Align: 0x4
+    Sections:
+      - Section: .data

lldb/trunk/lit/Modules/ELF/PT_LOAD.yaml

+# Test that sections are made child-sections of the PT_LOAD segments/sections.
+
+# RUN: yaml2obj %s > %t
+# RUN: lldb-test object-file %t | FileCheck %s
+
+# CHECK:      Index: 0
+# CHECK-NEXT: ID: 0xffffffffffffffff
+# CHECK-NEXT: Name: PT_LOAD[0]
+# CHECK-NEXT: Type: container
+# CHECK-NEXT: Permissions: rwx
+# CHECK-NEXT: Thread specific: no
+# CHECK-NEXT: VM address: 0x1000
+# CHECK-NEXT: VM size: 10
+# CHECK-NEXT: File size: 10
+# CHECK-NEXT: Showing 2 subsections
+# CHECK-NEXT:   Index: 0
+# CHECK-NEXT:   ID: 0x1
+# CHECK-NEXT:   Name: .text
+# CHECK-NEXT:   Type: code
+# CHECK-NEXT:   Permissions: r-x
+# CHECK-NEXT:   Thread specific: no
+# CHECK-NEXT:   VM address: 0x1000
+# CHECK-NEXT:   VM size: 8
+# CHECK-NEXT:   File size: 8
+# CHECK-EMPTY:
+# CHECK-NEXT:   Index: 1
+# CHECK-NEXT:   ID: 0x2
+# CHECK-NEXT:   Name: .data
+# CHECK-NEXT:   Type: data
+# CHECK-NEXT:   Permissions: r--
+# CHECK-NEXT:   Thread specific: no
+# CHECK-NEXT:   VM address: 0x1008
+# CHECK-NEXT:   VM size: 2
+# CHECK-NEXT:   File size: 2
+# CHECK-EMPTY:
+# CHECK-EMPTY:
+# CHECK-NEXT: Index: 1
+# CHECK-NEXT: ID: 0x3
+# CHECK-NEXT: Name: .data_outside
+# CHECK-NEXT: Type: regular
+# CHECK-NEXT: Permissions: r--
+# CHECK-NEXT: Thread specific: no
+# CHECK-NEXT: VM address: 0x2000
+# CHECK-NEXT: VM size: 2
+# CHECK-NEXT: File size: 2
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_ARM
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1008
+    AddressAlign:    0x4
+    Content:         3232
+  - Name:            .data_outside
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x2000
+    AddressAlign:    0x4
+    Content:         3232
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_W, PF_R ]
+    VAddr: 0x1000
+    Align: 0x4
+    Sections:
+      - Section: .text
+      - Section: .data

lldb/trunk/lit/Modules/ELF/section-overlap.yaml

+# Test handling of (corrupt?) object files, which have sections with overlapping
+# virtual addresses.
+#
+# Right now the overlapping sections get dropped, but other behaviors
+# (including outright rejecting such files) are possible too.
+
+# RUN: yaml2obj %s > %t
+# RUN: lldb-test object-file %t | FileCheck %s
+
+# CHECK-NOT: .overlap1
+# CHECK-NOT: .overlap2
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_ARM
+Sections:
+  - Name:            .sect1
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1000
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+  - Name:            .overlap1
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1004
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+  - Name:            .sect2
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x2000
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+  - Name:            .overlap2
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x2004
+    AddressAlign:    0x4
+    Content:         DEADBEEFBAADF00D
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_W, PF_R ]
+    VAddr: 0x1000
+    Align: 0x4
+    Sections:
+      - Section: .sect1
+      - Section: .overlap1

lldb/trunk/lit/Modules/ELF/section-permissions.yaml

 # RUN: yaml2obj %s > %t
 # RUN: lldb-test object-file %t | FileCheck %s
 
 # CHECK-LABEL: Name: .r-x
 # CHECK: Permissions: r-x
 #
 # CHECK-LABEL: Name: .rw-
 # CHECK: Permissions: rw-
 
 # CHECK-LABEL: Name: .---
 # CHECK: Permissions: ---
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
-  Type:            ET_DYN
+  Type:            ET_REL
   Machine:         EM_X86_64
   Entry:           0x00000000000007A0
 Sections:
   - Name:            .r-x
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Content:         DEADBEEFBAADF00D
   - Name:            .rw-

lldb/trunk/lit/Modules/ELF/section-types.yaml

 # CHECK-LABEL: Name: .tbss
 # CHECK-NEXT: Type: zero-fill
 # CHECK: Thread specific: yes
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
-  Type:            ET_DYN
+  Type:            ET_REL
   Machine:         EM_X86_64
   Entry:           0x00000000000007A0
 Sections:
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Content:         DEADBEEFBAADF00D
   - Name:            .debug_info

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 #include <algorithm>
 #include <cassert>
 #include <unordered_map>
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/RangeMap.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
+#include "llvm/ADT/IntervalMap.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/Decompressor.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/MipsABIFlags.h"
 
unsigned ELFRelocation::RelocAddend64(const ELFRelocation &rel) {
   if (rel.reloc.is<ELFRel *>())
     return 0;
   else
     return rel.reloc.get<ELFRela *>()->r_addend;
 }
 
 } // end anonymous namespace
 
+static user_id_t SegmentID(size_t PHdrIndex) { return ~PHdrIndex; }
+
 bool ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset) {
   // Read all fields.
   if (data.GetU32(offset, &n_namesz, 3) == NULL)
     return false;
 
   // The name field is required to be nul-terminated, and n_namesz includes the
   // terminating nul in observed implementations (contrary to the ELF-64 spec).
   // A special case is needed for cores generated by some older Linux versions,
if (section_list) {
 
       const size_t num_sections = section_list->GetSize();
       size_t sect_idx = 0;
 
       for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
         // Iterate through the object file sections to find all of the sections
         // that have SHF_ALLOC in their flag bits.
         SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
-        if (section_sp && section_sp->Test(SHF_ALLOC)) {
+        if (section_sp->Test(SHF_ALLOC) ||
+            section_sp->GetType() == eSectionTypeContainer) {
           lldb::addr_t load_addr = section_sp->GetFileAddress();
           // We don't want to update the load address of a section with type
           // eSectionTypeAbsoluteAddress as they already have the absolute load
           // address already specified
           if (section_sp->GetType() != eSectionTypeAbsoluteAddress)
             load_addr += value;
 
           // On 32-bit systems the load address have to fit into 4 bytes. The
if (H.sh_flags & SHF_ALLOC)
     Perm |= ePermissionsReadable;
   if (H.sh_flags & SHF_WRITE)
     Perm |= ePermissionsWritable;
   if (H.sh_flags & SHF_EXECINSTR)
     Perm |= ePermissionsExecutable;
   return Perm;
 }
 
+static Permissions GetPermissions(const ELFProgramHeader &H) {
+  Permissions Perm = Permissions(0);
+  if (H.p_flags & PF_R)
+    Perm |= ePermissionsReadable;
+  if (H.p_flags & PF_W)
+    Perm |= ePermissionsWritable;
+  if (H.p_flags & PF_X)
+    Perm |= ePermissionsExecutable;
+  return Perm;
+}
+
 namespace {
+
+using VMRange = lldb_private::Range<addr_t, addr_t>;
+
+struct SectionAddressInfo {
+  SectionSP Segment;
+  VMRange Range;
+};
+
 // (Unlinked) ELF object files usually have 0 for every section address, meaning
 // we need to compute synthetic addresses in order for "file addresses" from
 // different sections to not overlap. This class handles that logic.
 class VMAddressProvider {
-  bool m_synthesizing;
-  addr_t m_next;
+  using VMMap = llvm::IntervalMap<addr_t, SectionSP, 4,
+                                       llvm::IntervalMapHalfOpenInfo<addr_t>>;
+
+  ObjectFile::Type ObjectType;
+  addr_t NextVMAddress = 0;
+  VMMap::Allocator Alloc;
+  VMMap Segments = VMMap(Alloc);
+  VMMap Sections = VMMap(Alloc);
+  lldb_private::Log *Log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES);
+
+  VMRange GetVMRange(const ELFSectionHeader &H) {
+    addr_t Address = H.sh_addr;
+    addr_t Size = H.sh_flags & SHF_ALLOC ? H.sh_size : 0;
+    if (ObjectType == ObjectFile::Type::eTypeObjectFile && Segments.empty() && (H.sh_flags & SHF_ALLOC)) {
+      NextVMAddress =
+          llvm::alignTo(NextVMAddress, std::max<addr_t>(H.sh_addralign, 1));
+      Address = NextVMAddress;
+      NextVMAddress += Size;
+    }
+    return VMRange(Address, Size);
+  }
 
 public:
-  VMAddressProvider(ObjectFile::Type Type)
-      : m_synthesizing(Type == ObjectFile::Type::eTypeObjectFile), m_next(0) {}
+  VMAddressProvider(ObjectFile::Type Type) : ObjectType(Type) {}
+
+  llvm::Optional<VMRange> GetAddressInfo(const ELFProgramHeader &H) {
+    if (H.p_memsz == 0) {
+      LLDB_LOG(Log,
+               "Ignoring zero-sized PT_LOAD segment. Corrupt object file?");
+      return llvm::None;
+    }
 
-  std::pair<addr_t, addr_t> GetAddressAndSize(const ELFSectionHeader &H) {
-    addr_t address = H.sh_addr;
-    addr_t size = H.sh_flags & SHF_ALLOC ? H.sh_size : 0;
-    if (m_synthesizing && (H.sh_flags & SHF_ALLOC)) {
-      m_next = llvm::alignTo(m_next, std::max<addr_t>(H.sh_addralign, 1));
-      address = m_next;
-      m_next += size;
+    if (Segments.overlaps(H.p_vaddr, H.p_vaddr + H.p_memsz)) {
+      LLDB_LOG(Log,
+               "Ignoring overlapping PT_LOAD segment. Corrupt object file?");
+      return llvm::None;
+    }
+    return VMRange(H.p_vaddr, H.p_memsz);
+  }
+
+  llvm::Optional<SectionAddressInfo> GetAddressInfo(const ELFSectionHeader &H) {
+    VMRange Range = GetVMRange(H);
+    SectionSP Segment;
+    auto It = Segments.find(Range.GetRangeBase());
+    if ((H.sh_flags & SHF_ALLOC) && It.valid()) {
+      addr_t MaxSize;
+      if (It.start() <= Range.GetRangeBase()) {
+        MaxSize = It.stop() - Range.GetRangeBase();
+        Segment = *It;
+      } else
+        MaxSize = It.start() - Range.GetRangeBase();
+      if (Range.GetByteSize() > MaxSize) {
+        LLDB_LOG(Log, "Shortening section crossing segment boundaries. "
+                      "Corrupt object file?");
+        Range.SetByteSize(MaxSize);
+      }
     }
-    return {address, size};
+    if (Range.GetByteSize() > 0 &&
+        Sections.overlaps(Range.GetRangeBase(), Range.GetRangeEnd())) {
+      LLDB_LOG(Log, "Ignoring overlapping section. Corrupt object file?");
+      return llvm::None;
+    }
+    if (Segment)
+      Range.Slide(-Segment->GetFileAddress());
+    return SectionAddressInfo{Segment, Range};
+  }
+
+  void AddSegment(const VMRange &Range, SectionSP Seg) {
+    Segments.insert(Range.GetRangeBase(), Range.GetRangeEnd(), std::move(Seg));
+  }
+
+  void AddSection(SectionAddressInfo Info, SectionSP Sect) {
+    if (Info.Range.GetByteSize() == 0)
+      return;
+    if (Info.Segment)
+      Info.Range.Slide(Info.Segment->GetFileAddress());
+    Sections.insert(Info.Range.GetRangeBase(), Info.Range.GetRangeEnd(),
+                    std::move(Sect));
   }
 };
 }
 
 void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
-  if (!m_sections_ap.get() && ParseSectionHeaders()) {
-    m_sections_ap.reset(new SectionList());
+  if (m_sections_ap)
+    return;
 
-    VMAddressProvider address_provider(CalculateType());
-    for (SectionHeaderCollIter I = std::next(m_section_headers.begin());
-         I != m_section_headers.end(); ++I) {
-      const ELFSectionHeaderInfo &header = *I;
+  m_sections_ap = llvm::make_unique<SectionList>();
+
+  size_t LoadID = 0;
+  for (const auto &EnumPHdr : llvm::enumerate(ProgramHeaders())) {
+    const ELFProgramHeader &PHdr = EnumPHdr.value();
+    if (PHdr.p_type != PT_LOAD)
+      continue;
+
+    auto InfoOr = address_provider.GetAddressInfo(PHdr);
+    if (!InfoOr)
+      continue;
+
+    ConstString Name(("PT_LOAD[" + llvm::Twine(LoadID++) + "]").str());
+    uint32_t Log2Align = llvm::Log2_64(std::max<elf_xword>(PHdr.p_align, 1));
+    SectionSP Segment = std::make_shared<Section>(
+        GetModule(), this, SegmentID(EnumPHdr.index()), Name,
+        eSectionTypeContainer, InfoOr->GetRangeBase(), InfoOr->GetByteSize(),
+        PHdr.p_offset, PHdr.p_filesz, Log2Align, /*flags*/ 0);
+    Segment->SetPermissions(GetPermissions(PHdr));
+    m_sections_ap->AddSection(Segment);
+
+    address_provider.AddSegment(*InfoOr, std::move(Segment));
+  }
+
+  ParseSectionHeaders();
+  if (m_section_headers.empty())
+    return;
+
 
-      ConstString &name = I->section_name;
-      const uint64_t file_size =
-          header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
 
-      addr_t vm_addr, vm_size;
-      std::tie(vm_addr, vm_size) = address_provider.GetAddressAndSize(header);
+    auto InfoOr = address_provider.GetAddressInfo(header);
+    if (!InfoOr)
+      continue;
 
-      SectionType sect_type = GetSectionType(header);
 
-      const uint32_t target_bytes_size =
-          GetTargetByteSize(sect_type, m_arch_spec);
 
-      elf::elf_xword log2align =
-          (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign);
 
-      SectionSP section_sp(new Section(
-          GetModule(), // Module to which this section belongs.
-          this, // ObjectFile to which this section belongs and should read
-                // section data from.
-          SectionIndex(I),     // Section ID.
-          name,                // Section name.
-          sect_type,           // Section type.
-          vm_addr,             // VM address.
-          vm_size,             // VM size in bytes of this section.
-          header.sh_offset,    // Offset of this section in the file.
-          file_size,           // Size of the section as found in the file.
-          log2align,           // Alignment of the section
-          header.sh_flags,     // Flags for this section.
-          target_bytes_size)); // Number of host bytes per target byte
+        InfoOr->Segment, GetModule(), // Module to which this section belongs.
+        this,            // ObjectFile to which this section belongs and should
+                         // read section data from.
+        SectionIndex(I), // Section ID.
+        name,            // Section name.
+        sect_type,       // Section type.
+        InfoOr->Range.GetRangeBase(), // VM address.
+        InfoOr->Range.GetByteSize(),  // VM size in bytes of this section.
+        header.sh_offset,             // Offset of this section in the file.
 
-      section_sp->SetPermissions(GetPermissions(header));
-      section_sp->SetIsThreadSpecific(header.sh_flags & SHF_TLS);
-      m_sections_ap->AddSection(section_sp);
-    }
+    (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_ap)
+        .AddSection(section_sp);
+    address_provider.AddSection(std::move(*InfoOr), std::move(section_sp));
   }
 
   // For eTypeDebugInfo files, the Symbol Vendor will take care of updating the
   // unified section list.
   if (GetType() != eTypeDebugInfo)
     unified_section_list = *m_sections_ap;
 }