arch, base: Stop assuming object files have three segments.

The ObjectFile class has hardcoded assumptions that there are three
segments, text, bss and data. There are some files which have one
"segment" like raw files, where the entire file's contents are
considered a single segment. There are also ELF files which can have
an arbitrary number of segments, and those segments can hold any
number of sections, including the text, data and/or bss sections.

Removing this assumption frees up some object file formats from having
to twist themselves to fit in that structure, possibly introducing
ambiguities when some segments may fulfill multiple roles.

Change-Id: I976e06a3a90ef852b17a6485e2595b006b2090d5
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/21463
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: Andreas Sandberg <andreas.sandberg@arm.com>
Maintainer: Gabe Black <gabeblack@google.com>
diff --git a/src/arch/alpha/process.cc b/src/arch/alpha/process.cc
index d0bfa79..59cbebc 100644
--- a/src/arch/alpha/process.cc
+++ b/src/arch/alpha/process.cc
@@ -54,12 +54,10 @@
       objFile)
 {
     fatal_if(params->useArchPT, "Arch page tables not implemented.");
-    Addr brk_point = objFile->dataBase() + objFile->dataSize() +
-                     objFile->bssSize();
-    brk_point = roundUp(brk_point, PageBytes);
+    Addr brk_point = roundUp(objFile->maxSegmentAddr(), PageBytes);
 
     // Set up stack.  On Alpha, stack goes below the image.
-    Addr stack_base = objFile->textBase() - (409600 + 4096);
+    Addr stack_base = objFile->minSegmentAddr() - (409600 + 4096);
 
     // Set up region for mmaps.
     Addr mmap_end = 0x10000;
diff --git a/src/arch/alpha/system.cc b/src/arch/alpha/system.cc
index 7bff6da..31e7aa0 100644
--- a/src/arch/alpha/system.cc
+++ b/src/arch/alpha/system.cc
@@ -57,11 +57,13 @@
      */
     // Load Console Code
     console = createObjectFile(params()->console);
+    console->setLoadMask(loadAddrMask);
     if (console == NULL)
         fatal("Could not load console file %s", params()->console);
 
     // Load pal file
     pal = createObjectFile(params()->pal);
+    pal->setLoadMask(loadAddrMask);
     if (pal == NULL)
         fatal("Could not load PALcode file %s", params()->pal);
 
@@ -109,8 +111,8 @@
     System::initState();
 
     // Load program sections into memory
-    pal->loadSegments(physProxy, loadAddrMask);
-    console->loadSegments(physProxy, loadAddrMask);
+    pal->loadSegments(physProxy);
+    console->loadSegments(physProxy);
 
     /**
      * Copy the osflags (kernel arguments) into the consoles
diff --git a/src/arch/arm/freebsd/system.cc b/src/arch/arm/freebsd/system.cc
index 6e544a7..764f036 100644
--- a/src/arch/arm/freebsd/system.cc
+++ b/src/arch/arm/freebsd/system.cc
@@ -132,7 +132,7 @@
     if (ra)
         bootReleaseAddr = ra & ~ULL(0x7F);
 
-    dtb_file->setTextBase(params()->atags_addr + loadAddrOffset);
+    dtb_file->setLoadOffset(params()->atags_addr + loadAddrOffset);
     dtb_file->loadSegments(physProxy);
     delete dtb_file;
 
diff --git a/src/arch/arm/linux/system.cc b/src/arch/arm/linux/system.cc
index f03a5c6..a0869b4 100644
--- a/src/arch/arm/linux/system.cc
+++ b/src/arch/arm/linux/system.cc
@@ -151,7 +151,7 @@
                  "to DTB file: %s\n", params()->dtb_filename);
         }
 
-        dtb_file->setTextBase(params()->atags_addr + loadAddrOffset);
+        dtb_file->setLoadOffset(params()->atags_addr + loadAddrOffset);
         dtb_file->loadSegments(physProxy);
         delete dtb_file;
     } else {
diff --git a/src/arch/arm/process.cc b/src/arch/arm/process.cc
index 1a1d4a2..f985726 100644
--- a/src/arch/arm/process.cc
+++ b/src/arch/arm/process.cc
@@ -75,8 +75,7 @@
                            ObjectFile::Arch _arch)
     : ArmProcess(params, objFile, _arch)
 {
-    Addr brk_point = roundUp(objFile->dataBase() + objFile->dataSize() +
-                             objFile->bssSize(), PageBytes);
+    Addr brk_point = roundUp(objFile->maxSegmentAddr(), PageBytes);
     Addr stack_base = 0xbf000000L;
     Addr max_stack_size = 8 * 1024 * 1024;
     Addr next_thread_stack_base = stack_base - max_stack_size;
@@ -90,8 +89,7 @@
                            ObjectFile::Arch _arch)
     : ArmProcess(params, objFile, _arch)
 {
-    Addr brk_point = roundUp(objFile->dataBase() + objFile->dataSize() +
-                             objFile->bssSize(), PageBytes);
+    Addr brk_point = roundUp(objFile->maxSegmentAddr(), PageBytes);
     Addr stack_base = 0x7fffff0000L;
     Addr max_stack_size = 8 * 1024 * 1024;
     Addr next_thread_stack_base = stack_base - max_stack_size;
diff --git a/src/arch/mips/process.cc b/src/arch/mips/process.cc
index e3405fd..1808372 100644
--- a/src/arch/mips/process.cc
+++ b/src/arch/mips/process.cc
@@ -65,8 +65,7 @@
     Addr next_thread_stack_base = stack_base - max_stack_size;
 
     // Set up break point (Top of Heap)
-    Addr brk_point = objFile->dataBase() + objFile->dataSize() +
-                     objFile->bssSize();
+    Addr brk_point = objFile->maxSegmentAddr();
     brk_point = roundUp(brk_point, PageBytes);
 
     // Set up region for mmaps.  Start it 1GB above the top of the heap.
diff --git a/src/arch/power/process.cc b/src/arch/power/process.cc
index 467c820..b391773 100644
--- a/src/arch/power/process.cc
+++ b/src/arch/power/process.cc
@@ -56,8 +56,7 @@
 {
     fatal_if(params->useArchPT, "Arch page tables not implemented.");
     // Set up break point (Top of Heap)
-    Addr brk_point = objFile->dataBase() + objFile->dataSize() +
-                     objFile->bssSize();
+    Addr brk_point = objFile->maxSegmentAddr();
     brk_point = roundUp(brk_point, PageBytes);
 
     Addr stack_base = 0xbf000000L;
diff --git a/src/arch/riscv/process.cc b/src/arch/riscv/process.cc
index ca3f0e2..e15197d 100644
--- a/src/arch/riscv/process.cc
+++ b/src/arch/riscv/process.cc
@@ -75,8 +75,7 @@
     const Addr stack_base = 0x7FFFFFFFFFFFFFFFL;
     const Addr max_stack_size = 8 * 1024 * 1024;
     const Addr next_thread_stack_base = stack_base - max_stack_size;
-    const Addr brk_point = roundUp(objFile->bssBase() + objFile->bssSize(),
-            PageBytes);
+    const Addr brk_point = roundUp(objFile->maxSegmentAddr(), PageBytes);
     const Addr mmap_end = 0x4000000000000000L;
     memState = make_shared<MemState>(brk_point, stack_base, max_stack_size,
             next_thread_stack_base, mmap_end);
@@ -88,8 +87,7 @@
     const Addr stack_base = 0x7FFFFFFF;
     const Addr max_stack_size = 8 * 1024 * 1024;
     const Addr next_thread_stack_base = stack_base - max_stack_size;
-    const Addr brk_point = roundUp(objFile->bssBase() + objFile->bssSize(),
-            PageBytes);
+    const Addr brk_point = roundUp(objFile->maxSegmentAddr(), PageBytes);
     const Addr mmap_end = 0x40000000L;
     memState = make_shared<MemState>(brk_point, stack_base, max_stack_size,
                                      next_thread_stack_base, mmap_end);
diff --git a/src/arch/sparc/process.hh b/src/arch/sparc/process.hh
index eeb2671..f8f19f2 100644
--- a/src/arch/sparc/process.hh
+++ b/src/arch/sparc/process.hh
@@ -78,8 +78,7 @@
     Sparc32Process(ProcessParams * params, ObjectFile *objFile)
         : SparcProcess(params, objFile, 0)
     {
-        Addr brk_point = objFile->dataBase() + objFile->dataSize() +
-                         objFile->bssSize();
+        Addr brk_point = objFile->maxSegmentAddr();
         brk_point = roundUp(brk_point, SparcISA::PageBytes);
 
         // Reserve 8M for main stack.
@@ -123,8 +122,7 @@
     Sparc64Process(ProcessParams * params, ObjectFile *objFile)
         : SparcProcess(params, objFile, 2047)
     {
-        Addr brk_point = objFile->dataBase() + objFile->dataSize() +
-                         objFile->bssSize();
+        Addr brk_point = objFile->maxSegmentAddr();
         brk_point = roundUp(brk_point, SparcISA::PageBytes);
 
         Addr max_stack_size = 8 * 1024 * 1024;
diff --git a/src/arch/sparc/system.cc b/src/arch/sparc/system.cc
index 5896061..e9615b0 100644
--- a/src/arch/sparc/system.cc
+++ b/src/arch/sparc/system.cc
@@ -137,22 +137,22 @@
     System::initState();
 
     // Load reset binary into memory
-    reset->setTextBase(params()->reset_addr);
+    reset->setLoadOffset(params()->reset_addr);
     reset->loadSegments(physProxy);
     // Load the openboot binary
-    openboot->setTextBase(params()->openboot_addr);
+    openboot->setLoadOffset(params()->openboot_addr);
     openboot->loadSegments(physProxy);
     // Load the hypervisor binary
-    hypervisor->setTextBase(params()->hypervisor_addr);
+    hypervisor->setLoadOffset(params()->hypervisor_addr);
     hypervisor->loadSegments(physProxy);
     // Load the nvram image
-    nvram->setTextBase(params()->nvram_addr);
+    nvram->setLoadOffset(params()->nvram_addr);
     nvram->loadSegments(physProxy);
     // Load the hypervisor description image
-    hypervisor_desc->setTextBase(params()->hypervisor_desc_addr);
+    hypervisor_desc->setLoadOffset(params()->hypervisor_desc_addr);
     hypervisor_desc->loadSegments(physProxy);
     // Load the partition description image
-    partition_desc->setTextBase(params()->partition_desc_addr);
+    partition_desc->setLoadOffset(params()->partition_desc_addr);
     partition_desc->loadSegments(physProxy);
 
 
diff --git a/src/arch/x86/process.cc b/src/arch/x86/process.cc
index 60f4f47..c743685 100644
--- a/src/arch/x86/process.cc
+++ b/src/arch/x86/process.cc
@@ -136,8 +136,7 @@
     vsyscallPage.vtimeOffset = 0x400;
     vsyscallPage.vgettimeofdayOffset = 0x0;
 
-    Addr brk_point = roundUp(objFile->dataBase() + objFile->dataSize() +
-                             objFile->bssSize(), PageBytes);
+    Addr brk_point = roundUp(objFile->maxSegmentAddr(), PageBytes);
     Addr stack_base = 0x7FFFFFFFF000ULL;
     Addr max_stack_size = 8 * 1024 * 1024;
     Addr next_thread_stack_base = stack_base - max_stack_size;
@@ -176,8 +175,7 @@
     vsyscallPage.vsyscallOffset = 0x400;
     vsyscallPage.vsysexitOffset = 0x410;
 
-    Addr brk_point = roundUp(objFile->dataBase() + objFile->dataSize() +
-                             objFile->bssSize(), PageBytes);
+    Addr brk_point = roundUp(objFile->maxSegmentAddr(), PageBytes);
     Addr stack_base = _gdtStart;
     Addr max_stack_size = 8 * 1024 * 1024;
     Addr next_thread_stack_base = stack_base - max_stack_size;
diff --git a/src/base/loader/aout_object.cc b/src/base/loader/aout_object.cc
index e3f703e..9765158 100644
--- a/src/base/loader/aout_object.cc
+++ b/src/base/loader/aout_object.cc
@@ -61,21 +61,14 @@
 
     entry = execHdr->entry;
 
-    text.base = N_TXTADDR(*execHdr);
-    text.size = execHdr->tsize;
-    text.data = fileData + N_TXTOFF(*execHdr);
+    addSegment("text", N_TXTADDR(*execHdr), fileData + N_TXTOFF(*execHdr),
+            execHdr->tsize);
+    addSegment("data", N_DATADDR(*execHdr), fileData + N_DATOFF(*execHdr),
+            execHdr->dsize);
+    addSegment("bss", N_BSSADDR(*execHdr), nullptr, execHdr->bsize);
 
-    data.base = N_DATADDR(*execHdr);
-    data.size = execHdr->dsize;
-    data.data = fileData + N_DATOFF(*execHdr);
-
-    bss.base = N_BSSADDR(*execHdr);
-    bss.size = execHdr->bsize;
-    bss.data = NULL;
-
-    DPRINTFR(Loader, "text: 0x%x %d\ndata: 0x%x %d\nbss: 0x%x %d\n",
-             text.base, text.size, data.base, data.size,
-             bss.base, bss.size);
+    for (auto &seg: segments)
+        DPRINTFR(Loader, "%s\n", *seg);
 }
 
 
diff --git a/src/base/loader/dtb_object.cc b/src/base/loader/dtb_object.cc
index 92e305f..275139a 100644
--- a/src/base/loader/dtb_object.cc
+++ b/src/base/loader/dtb_object.cc
@@ -53,20 +53,10 @@
 
 DtbObject::DtbObject(const std::string &_filename, size_t _len, uint8_t *_data,
                      Arch _arch, OpSys _opSys)
-    : ObjectFile(_filename, _len, _data, _arch, _opSys)
+    : ObjectFile(_filename, _len, _data, _arch, _opSys),
+    data(new Segment{ "data", 0, fileData, len })
 {
-    text.base = 0;
-    text.size = len;
-    text.data = fileData;
-
-    data.base = 0;
-    data.size = 0;
-    data.data = nullptr;
-
-    bss.base = 0;
-    bss.size = 0;
-    bss.data = nullptr;
-
+    segments.emplace_back(data);
     fileDataMmapped = true;
 }
 
@@ -92,10 +82,10 @@
     const char* property_name = "bootargs";
 
     // Make a new buffer that has extra space to add nodes/properties
-    int newLen = 2*this->len;
-    uint8_t* fdt_buf_w_space = new uint8_t[newLen];
+    int newLen = 2 * this->len;
+    uint8_t *fdt_buf_w_space = new uint8_t[newLen];
     // Copy and unpack flattened device tree into new buffer
-    int ret = fdt_open_into((void*)fileData, (void*)fdt_buf_w_space, (newLen));
+    int ret = fdt_open_into((void *)fileData, (void *)fdt_buf_w_space, newLen);
     if (ret < 0) {
         warn("Error resizing buffer of flattened device tree, "
              "errno: %d\n", ret);
@@ -104,14 +94,15 @@
     }
 
     // First try finding the /chosen node in the dtb
-    int offset = fdt_path_offset((void*)fdt_buf_w_space, full_path_node_name);
+    int offset = fdt_path_offset((void *)fdt_buf_w_space, full_path_node_name);
     if (offset < 0) {
         // try adding the node by walking dtb tree to proper insertion point
-        offset = fdt_path_offset((void*)fdt_buf_w_space, root_path);
-        offset = fdt_add_subnode((void*)fdt_buf_w_space, offset, node_name);
+        offset = fdt_path_offset((void *)fdt_buf_w_space, root_path);
+        offset = fdt_add_subnode((void *)fdt_buf_w_space, offset, node_name);
         // if we successfully add the subnode, get the offset
         if (offset >= 0)
-          offset = fdt_path_offset((void*)fdt_buf_w_space, full_path_node_name);
+          offset = fdt_path_offset((void *)fdt_buf_w_space,
+                                   full_path_node_name);
 
         if (offset < 0) {
             warn("Error finding or adding \"chosen\" subnode to flattened "
@@ -122,8 +113,8 @@
     }
 
     // Set the bootargs property in the /chosen node
-    ret = fdt_setprop((void*)fdt_buf_w_space, offset, property_name,
-                      (const void*)_args, len+1);
+    ret = fdt_setprop((void *)fdt_buf_w_space, offset, property_name,
+                      (const void *)_args, len+1);
     if (ret < 0) {
         warn("Error setting \"bootargs\" property to flattened device tree, "
              "errno: %d\n", ret);
@@ -132,7 +123,7 @@
     }
 
     // Repack the dtb for kernel use
-    ret = fdt_pack((void*)fdt_buf_w_space);
+    ret = fdt_pack((void *)fdt_buf_w_space);
     if (ret < 0) {
         warn("Error re-packing flattened device tree structure, "
              "errno: %d\n", ret);
@@ -140,8 +131,8 @@
         return false;
     }
 
-    text.size = newLen;
-    text.data = fdt_buf_w_space;
+    data->size = newLen;
+    data->data = fdt_buf_w_space;
 
     // clean up old buffer and set to new fdt blob
     munmap(fileData, this->len);
@@ -155,7 +146,7 @@
 Addr
 DtbObject::findReleaseAddr()
 {
-    void *fd = (void*)fileData;
+    void *fd = (void *)fileData;
 
     int offset = fdt_path_offset(fd, "/cpus/cpu@0");
     int len;
@@ -164,9 +155,11 @@
     Addr rel_addr = 0;
 
     if (len > 3)
-        rel_addr = betoh(*static_cast<const uint32_t*>(temp));
-    if (len == 8)
-        rel_addr = (rel_addr << 32) | betoh(*(static_cast<const uint32_t*>(temp)+1));
+        rel_addr = betoh(*static_cast<const uint32_t *>(temp));
+    if (len == 8) {
+        rel_addr = (rel_addr << 32) |
+            betoh(*(static_cast<const uint32_t *>(temp) + 1));
+    }
 
     return rel_addr;
 }
diff --git a/src/base/loader/dtb_object.hh b/src/base/loader/dtb_object.hh
index c49b144..7cb842e 100644
--- a/src/base/loader/dtb_object.hh
+++ b/src/base/loader/dtb_object.hh
@@ -49,6 +49,8 @@
          */
         bool fileDataMmapped;
 
+        Segment *data;
+
     public:
         virtual ~DtbObject();
 
diff --git a/src/base/loader/ecoff_object.cc b/src/base/loader/ecoff_object.cc
index 76b91dd..56f9b35 100644
--- a/src/base/loader/ecoff_object.cc
+++ b/src/base/loader/ecoff_object.cc
@@ -73,21 +73,14 @@
 
     entry = aoutHdr->entry;
 
-    text.base = aoutHdr->text_start;
-    text.size = aoutHdr->tsize;
-    text.data = fileData + ECOFF_TXTOFF(execHdr);
+    addSegment("text", aoutHdr->text_start, fileData + ECOFF_TXTOFF(execHdr),
+            aoutHdr->tsize);
+    addSegment("data", aoutHdr->data_start, fileData + ECOFF_DATOFF(execHdr),
+            aoutHdr->dsize);
+    addSegment("bss", aoutHdr->bss_start, nullptr, aoutHdr->bsize);
 
-    data.base = aoutHdr->data_start;
-    data.size = aoutHdr->dsize;
-    data.data = fileData + ECOFF_DATOFF(execHdr);
-
-    bss.base = aoutHdr->bss_start;
-    bss.size = aoutHdr->bsize;
-    bss.data = nullptr;
-
-    DPRINTFR(Loader, "text: %#x %d\ndata: %#x %d\nbss: %#x %d\n",
-             text.base, text.size, data.base, data.size,
-             bss.base, bss.size);
+    for (auto &seg: segments)
+        DPRINTFR(Loader, "%s\n", *seg);
 }
 
 bool
diff --git a/src/base/loader/elf_object.cc b/src/base/loader/elf_object.cc
index 3279195..4dee7d2 100644
--- a/src/base/loader/elf_object.cc
+++ b/src/base/loader/elf_object.cc
@@ -293,45 +293,8 @@
 
     entry = ehdr.e_entry;
 
-    // initialize segment sizes to 0 in case they're not present
-    text.size = data.size = bss.size = 0;
-    text.base = data.base = bss.base = 0;
-
     int sec_idx = 1;
 
-    // The first address of some important sections.
-    Addr text_sec_start = 0;
-    Addr data_sec_start = 0;
-    Addr bss_sec_start = 0;
-
-    // Get the first section
-    Elf_Scn *section = elf_getscn(elf, sec_idx);
-
-    // Find the beginning of the most interesting sections.
-    while (section) {
-        GElf_Shdr shdr;
-        gelf_getshdr(section, &shdr);
-        char *sec_name = elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name);
-
-        if (sec_name) {
-            if (!strcmp(".text", sec_name)) {
-                text_sec_start = shdr.sh_addr;
-            } else if (!strcmp(".data", sec_name)) {
-                data_sec_start = shdr.sh_addr;
-            } else if (!strcmp(".bss", sec_name)) {
-                bss_sec_start = shdr.sh_addr;
-            }
-        } else {
-            Elf_Error errorNum = (Elf_Error)elf_errno();
-            if (errorNum != ELF_E_NONE) {
-                const char *errorMessage = elf_errmsg(errorNum);
-                fatal("Error from libelf: %s.\n", errorMessage);
-            }
-        }
-
-        section = elf_getscn(elf, ++sec_idx);
-    }
-
     // Go through all the segments in the program, record them, and scrape
     // out information about the text, data, and bss areas needed by other
     // code.
@@ -348,50 +311,54 @@
         ldMin = std::min(ldMin, phdr.p_vaddr);
         ldMax = std::max(ldMax, phdr.p_vaddr + phdr.p_memsz);
 
-        // Check to see if this segment contains the bss section.
-        if (phdr.p_paddr <= bss_sec_start &&
-            phdr.p_paddr + phdr.p_memsz > bss_sec_start &&
-            phdr.p_memsz - phdr.p_filesz > 0) {
-            bss.base = phdr.p_paddr + phdr.p_filesz;
-            bss.size = phdr.p_memsz - phdr.p_filesz;
-            bss.data = nullptr;
+        std::string name;
+
+        // Get the first section
+        Elf_Scn *section = elf_getscn(elf, sec_idx);
+
+        // Name segments after the sections they contain.
+        while (section) {
+            GElf_Shdr shdr;
+            gelf_getshdr(section, &shdr);
+            char *sec_name = elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name);
+
+            if (!sec_name) {
+                Elf_Error errorNum = (Elf_Error)elf_errno();
+                if (errorNum != ELF_E_NONE) {
+                    const char *errorMessage = elf_errmsg(errorNum);
+                    fatal("Error from libelf: %s.\n", errorMessage);
+                }
+            }
+
+            if (shdr.sh_addr >= ldMin && shdr.sh_addr < ldMax) {
+                if (name != "")
+                    name += ",";
+                name += sec_name;
+            }
+
+            section = elf_getscn(elf, ++sec_idx);
         }
 
-        // Check to see if this is the text or data segment
-        if (phdr.p_vaddr <= text_sec_start &&
-            phdr.p_vaddr + phdr.p_filesz > text_sec_start) {
-
-            // If this value is nonzero, we need to flip the relocate flag.
-            if (phdr.p_vaddr != 0)
-                relocate = false;
-
-            text.base = phdr.p_paddr;
-            text.size = phdr.p_filesz;
-            text.data = fileData + phdr.p_offset;
-        } else if (phdr.p_vaddr <= data_sec_start &&
-                   phdr.p_vaddr + phdr.p_filesz > data_sec_start) {
-            data.base = phdr.p_paddr;
-            data.size = phdr.p_filesz;
-            data.data = fileData + phdr.p_offset;
-        } else {
-            // If it's none of the above but is loadable,
-            // load the filesize worth of data
-            Segment extra;
-            extra.base = phdr.p_paddr;
-            extra.size = phdr.p_filesz;
-            extra.data = fileData + phdr.p_offset;
-            extraSegments.push_back(extra);
+        addSegment(name, phdr.p_paddr, fileData + phdr.p_offset,
+                phdr.p_filesz);
+        Addr uninitialized = phdr.p_memsz - phdr.p_filesz;
+        if (uninitialized) {
+            // There may be parts of a segment which aren't included in the
+            // file. In those cases, we need to create a new segment with no
+            // data to take up the extra space. This should be zeroed when
+            // loaded into memory.
+            addSegment(name + "(uninitialized)", phdr.p_paddr + phdr.p_filesz,
+                    nullptr, uninitialized);
         }
     }
 
     // should have found at least one loadable segment
-    warn_if(text.size == 0,
-            "Empty .text segment in '%s'. ELF file corrupted?\n",
+    warn_if(segments.empty(),
+            "No loadable segments in '%s'. ELF file corrupted?\n",
             filename);
 
-    DPRINTFR(Loader, "text: %#x %d\ndata: %#x %d\nbss: %#x %d\n",
-             text.base, text.size, data.base, data.size,
-             bss.base, bss.size);
+    for (auto &seg: segments)
+        DPRINTFR(Loader, "%s\n", *seg);
 
     elf_end(elf);
 
@@ -498,20 +465,13 @@
 }
 
 bool
-ElfObject::loadSegments(const PortProxy& mem_proxy, Addr addr_mask,
-                        Addr offset)
+ElfObject::loadSegments(const PortProxy &mem_proxy)
 {
-    if (!ObjectFile::loadSegments(mem_proxy, addr_mask, offset))
+    if (!ObjectFile::loadSegments(mem_proxy))
         return false;
 
-    for (auto seg : extraSegments) {
-        if (!loadSegment(&seg, mem_proxy, addr_mask, offset)) {
-            return false;
-        }
-    }
-
     if (interpreter)
-        interpreter->loadSegments(mem_proxy, addr_mask, offset);
+        interpreter->loadSegments(mem_proxy);
 
     return true;
 }
@@ -570,9 +530,6 @@
     entry += bias_addr;
 
     // Patch segments with the bias_addr.
-    text.base += bias_addr;
-    data.base += bias_addr;
-    bss.base  += bias_addr;
-    for (auto &segment : extraSegments)
-        segment.base += bias_addr;
+    for (auto &segment : segments)
+        segment->base += bias_addr;
 }
diff --git a/src/base/loader/elf_object.hh b/src/base/loader/elf_object.hh
index 244b9fc..f2af414 100644
--- a/src/base/loader/elf_object.hh
+++ b/src/base/loader/elf_object.hh
@@ -86,13 +86,10 @@
     void getSections();
     bool sectionExists(std::string sec);
 
-    std::vector<Segment> extraSegments;
-
   public:
     virtual ~ElfObject() {}
 
-    bool loadSegments(const PortProxy& mem_proxy, Addr addr_mask = maxAddr,
-                      Addr offset = 0) override;
+    bool loadSegments(const PortProxy &mem_proxy) override;
 
     virtual bool loadAllSymbols(SymbolTable *symtab, Addr base = 0,
                                 Addr offset = 0, Addr addr_mask = maxAddr)
diff --git a/src/base/loader/object_file.cc b/src/base/loader/object_file.cc
index 8a6b063..d63b222 100644
--- a/src/base/loader/object_file.cc
+++ b/src/base/loader/object_file.cc
@@ -57,10 +57,8 @@
                        size_t _len, uint8_t *_data,
                        Arch _arch, OpSys _op_sys)
     : filename(_filename), fileData(_data), len(_len),
-      arch(_arch), opSys(_op_sys), entry(0),
-      text{0, nullptr, 0}, data{0, nullptr, 0}, bss{0, nullptr, 0}
-{
-}
+      arch(_arch), opSys(_op_sys), entry(0)
+{}
 
 
 ObjectFile::~ObjectFile()
@@ -73,11 +71,10 @@
 
 
 bool
-ObjectFile::loadSegment(Segment *seg, const PortProxy& mem_proxy,
-                        Addr addr_mask, Addr offset)
+ObjectFile::loadSegment(Segment *seg, const PortProxy &mem_proxy)
 {
     if (seg->size != 0) {
-        Addr addr = (seg->base & addr_mask) + offset;
+        Addr addr = (seg->base & loadMask) + loadOffset;
         if (seg->data) {
             mem_proxy.writeBlob(addr, seg->data, seg->size);
         } else {
@@ -90,12 +87,12 @@
 
 
 bool
-ObjectFile::loadSegments(const PortProxy& mem_proxy, Addr addr_mask,
-                         Addr offset)
+ObjectFile::loadSegments(const PortProxy &proxy)
 {
-    return (loadSegment(&text, mem_proxy, addr_mask, offset)
-            && loadSegment(&data, mem_proxy, addr_mask, offset)
-            && loadSegment(&bss, mem_proxy, addr_mask, offset));
+    for (auto &seg: segments)
+        if (!loadSegment(seg.get(), proxy))
+            return false;
+    return true;
 }
 
 namespace
diff --git a/src/base/loader/object_file.hh b/src/base/loader/object_file.hh
index db995f5..e5053ad 100644
--- a/src/base/loader/object_file.hh
+++ b/src/base/loader/object_file.hh
@@ -33,7 +33,9 @@
 #define __OBJECT_FILE_HH__
 
 #include <limits>
+#include <memory>
 #include <string>
+#include <vector>
 
 #include "base/logging.hh"
 #include "base/types.hh"
@@ -72,10 +74,14 @@
         FreeBSD
     };
 
+    static const Addr maxAddr = std::numeric_limits<Addr>::max();
+
   protected:
     const std::string filename;
     uint8_t *fileData;
     size_t len;
+    Addr loadOffset=0;
+    Addr loadMask=maxAddr;
 
     Arch arch;
     OpSys opSys;
@@ -86,10 +92,7 @@
   public:
     virtual ~ObjectFile();
 
-    static const Addr maxAddr = std::numeric_limits<Addr>::max();
-
-    virtual bool loadSegments(const PortProxy &mem_proxy,
-                              Addr mask=maxAddr, Addr offset=0);
+    virtual bool loadSegments(const PortProxy &mem_proxy);
 
     virtual bool loadAllSymbols(SymbolTable *symtab, Addr base = 0,
                                 Addr offset=0, Addr mask=maxAddr) = 0;
@@ -114,41 +117,76 @@
     Arch  getArch()  const { return arch; }
     OpSys getOpSys() const { return opSys; }
 
-  protected:
-
     struct Segment
     {
+        std::string name;
         Addr base;
         uint8_t *data;
         size_t size;
     };
 
+  protected:
     Addr entry;
 
-    Segment text;
-    Segment data;
-    Segment bss;
+    std::vector<std::unique_ptr<Segment>> segments;
 
-    bool loadSegment(Segment *seg, const PortProxy &mem_proxy, Addr mask,
-                     Addr offset=0);
+    void
+    addSegment(std::string name, Addr base, uint8_t *data, size_t size)
+    {
+        Segment *seg = new Segment;
+        seg->name = name;
+        seg->base = base;
+        seg->data = data;
+        seg->size = size;
+        segments.emplace_back(seg);
+    }
+
+    bool loadSegment(Segment *seg, const PortProxy &mem_proxy);
 
   public:
     Addr entryPoint() const { return entry; }
 
-    Addr textBase() const { return text.base; }
-    Addr dataBase() const { return data.base; }
-    Addr bssBase() const { return bss.base; }
+    Addr
+    maxSegmentAddr() const
+    {
+        Addr max = 0;
+        for (auto &seg: segments) {
+            Addr end = seg->base + seg->size;
+            if (end > max)
+                max = end;
+        }
+        return max;
+    }
 
-    size_t textSize() const { return text.size; }
-    size_t dataSize() const { return data.size; }
-    size_t bssSize() const { return bss.size; }
+    Addr
+    minSegmentAddr() const
+    {
+        Addr min = maxAddr;
+        for (auto &seg: segments)
+            if (seg->base < min)
+                min = seg->base;
+        return min;
+    }
+
+    bool
+    contains(Addr addr) const
+    {
+        for (auto &seg: segments) {
+            Addr start = seg->base;
+            Addr end = seg->base + seg->size;
+            if (addr >= start && addr < end)
+                return true;
+        }
+        return false;
+    }
 
     /* This function allows you to override the base address where
      * a binary is going to be loaded or set it if the binary is just a
      * blob that doesn't include an object header.
      * @param a address to load the binary/text section at
      */
-    void setTextBase(Addr a) { text.base = a; }
+    void setLoadOffset(Addr val) { loadOffset = val; }
+    void setLoadMask(Addr val) { loadMask = val; }
 
     /**
      * Each instance of a Loader subclass will have a chance to try to load
@@ -183,6 +221,13 @@
     static Process *tryLoaders(ProcessParams *params, ObjectFile *obj_file);
 };
 
+static inline std::ostream &
+operator << (std::ostream &os, const ObjectFile::Segment &seg)
+{
+    ccprintf(os, "%s: %#x %d", seg.name, seg.base, seg.size);
+    return os;
+}
+
 ObjectFile *createObjectFile(const std::string &fname, bool raw = false);
 
 
diff --git a/src/base/loader/raw_object.cc b/src/base/loader/raw_object.cc
index 9662d86..b0ece3b 100644
--- a/src/base/loader/raw_object.cc
+++ b/src/base/loader/raw_object.cc
@@ -43,23 +43,10 @@
 
 RawObject::RawObject(const std::string &_filename, size_t _len,
         uint8_t *_data, Arch _arch, OpSys _opSys)
-    : ObjectFile(_filename, _len, _data, _arch, _opSys)
+    : ObjectFile(_filename, _len, _data, _arch, _opSys),
+    data(new Segment{ "data", 0, fileData, len })
 {
-    text.base = 0;
-    text.size = len;
-    text.data = fileData;
-
-    data.base = 0;
-    data.size = 0;
-    data.data = nullptr;
-
-    bss.base = 0;
-    bss.size = 0;
-    bss.data = nullptr;
-
-    DPRINTFR(Loader, "text: %#x %d\ndata: %#x %d\nbss: %#x %d\n",
-             text.base, text.size, data.base, data.size,
-             bss.base, bss.size);
+    segments.emplace_back(data);
 }
 
 bool
diff --git a/src/base/loader/raw_object.hh b/src/base/loader/raw_object.hh
index 6931a13..9eb9291 100644
--- a/src/base/loader/raw_object.hh
+++ b/src/base/loader/raw_object.hh
@@ -38,6 +38,9 @@
   protected:
     RawObject(const std::string &_filename, size_t _len,
               uint8_t *_data, Arch _arch, OpSys _opSys);
+
+    Segment *data;
+
   public:
     virtual ~RawObject() {}
 
diff --git a/src/sim/syscall_emul.hh b/src/sim/syscall_emul.hh
index fb6e9a1..6c3b172 100644
--- a/src/sim/syscall_emul.hh
+++ b/src/sim/syscall_emul.hh
@@ -1888,19 +1888,14 @@
         // this will not work since there is a single global symbol table.
         ObjectFile *interpreter = p->getInterpreter();
         if (interpreter) {
-            Addr text_start = interpreter->textBase();
-            Addr text_end = text_start + interpreter->textSize();
-
-            Addr pc = tc->pcState().pc();
-
-            if (pc >= text_start && pc < text_end) {
+            if (interpreter->contains(tc->pcState().instAddr())) {
                 std::shared_ptr<FDEntry> fdep = (*p->fds)[tgt_fd];
                 auto ffdp = std::dynamic_pointer_cast<FileFDEntry>(fdep);
                 ObjectFile *lib = createObjectFile(ffdp->getFileName());
 
                 if (lib) {
                     lib->loadAllSymbols(debugSymbolTable,
-                                        lib->textBase(), start);
+                                        lib->minSegmentAddr(), start);
                 }
             }
         }
diff --git a/src/sim/system.cc b/src/sim/system.cc
index 73f93a2..bf8b452 100644
--- a/src/sim/system.cc
+++ b/src/sim/system.cc
@@ -152,14 +152,16 @@
         } else {
             // Get the kernel code
             kernel = createObjectFile(params()->kernel);
+            kernel->setLoadOffset(loadAddrOffset);
+            kernel->setLoadMask(loadAddrMask);
             inform("kernel located at: %s", params()->kernel);
 
             if (kernel == NULL)
                 fatal("Could not load kernel file %s", params()->kernel);
 
             // setup entry points
-            kernelStart = kernel->textBase();
-            kernelEnd = kernel->bssBase() + kernel->bssSize();
+            kernelStart = kernel->minSegmentAddr();
+            kernelEnd = kernel->maxSegmentAddr();
             kernelEntry = kernel->entryPoint();
 
             // If load_addr_mask is set to 0x0, then auto-calculate
@@ -168,6 +170,7 @@
             if (loadAddrMask == 0) {
                 Addr shift_amt = findMsbSet(kernelEnd - kernelStart) + 1;
                 loadAddrMask = ((Addr)1 << shift_amt) - 1;
+                kernel->setLoadMask(loadAddrMask);
             }
 
             // load symbols
@@ -192,6 +195,8 @@
             ObjectFile *obj = createObjectFile(obj_name);
             fatal_if(!obj, "Failed to additional kernel object '%s'.\n",
                      obj_name);
+            obj->setLoadOffset(loadAddrOffset);
+            obj->setLoadMask(loadAddrMask);
             kernelExtras.push_back(obj);
         }
     }
@@ -327,11 +332,9 @@
                 }
             }
             // Load program sections into memory
-            kernel->loadSegments(physProxy, loadAddrMask, loadAddrOffset);
-            for (const auto &extra_kernel : kernelExtras) {
-                extra_kernel->loadSegments(physProxy, loadAddrMask,
-                                           loadAddrOffset);
-            }
+            kernel->loadSegments(physProxy);
+            for (const auto &extra_kernel : kernelExtras)
+                extra_kernel->loadSegments(physProxy);
 
             DPRINTF(Loader, "Kernel start = %#x\n", kernelStart);
             DPRINTF(Loader, "Kernel end   = %#x\n", kernelEnd);