[ELF] Add NMAGIC/OMAGIC support

[shankarke]

Summary

This adds NMAGIC/OMAGIC support to lld ELF.

[ruiu]

include/lld/ReaderWriter/ELFTargetInfo.h

42

Please add a prefix ("MAGIC_" or something) to enum constants. DEFAULT seems a bit confusing in particular.

lib/ReaderWriter/ELF/Chunk.h

83

In what situation it can be unknown?

lib/ReaderWriter/ELF/Reader.cpp

109

We need a better diagnostics here.

lib/ReaderWriter/ELF/SegmentChunks.h

433

This condition appears three times. Let's make it a separate function.

[shankarke]

Thanks for the review.

include/lld/ReaderWriter/ELFTargetInfo.h

42

Ok

lib/ReaderWriter/ELF/Chunk.h

83

I will make it pure virtual

lib/ReaderWriter/ELF/Reader.cpp

109

Will change to better error code.

lib/ReaderWriter/ELF/SegmentChunks.h

433

Ok

[shankarke]

Updated with Ruiu's comments.

[shankarke]

lib/ReaderWriter/ELF/Reader.cpp

109

Couldnt find a better error code. Once we have the diagnostics infrastructure, we should report this properly.

[ruiu]

Just curious, is there any real need for NMAGIC and OMAGIC? My understanding about them is they are used in old Unixes and designed to be compact on disk by overlapping segments in one page. I'm wondering what I'd use these formats for.

[shankarke]

Its still a supported feature in the other linkers including gold, that are available. Some platforms use this to reduce the amount of virtual address space for a process by merging text/data together.

[Bigcheese]

include/lld/ReaderWriter/ELFTargetInfo.h

39–42

Use enum class.

49

This should be the enum type.

[shankarke]

include/lld/ReaderWriter/ELFTargetInfo.h

49

Ok.

[shankarke]

Address comments from Bigcheese.

[Eugene.Zelenko]

Committed in rL184055.

include/lld/ReaderWriter/ELFTargetInfo.h

 
 class TargetHandlerBase {
 public:
   virtual ~TargetHandlerBase() {}
 };
 
 class ELFTargetInfo : public TargetInfo {
 public:
+  enum class OutputMagic : uint8_t {
+    DEFAULT, // The default mode, no specific magic set
+    NMAGIC,  // Disallow shared libraries and dont align sections
+             // PageAlign Data, Mark Text Segment/Data segment RW
+    OMAGIC   // Disallow shared libraries and dont align sections,
+             // Mark Text Segment/Data segment RW
+  };
   llvm::Triple getTriple() const { return _triple; }
   virtual bool is64Bits() const;
   virtual bool isLittleEndian() const;
   virtual uint64_t getPageSize() const { return 0x1000; }
+  OutputMagic getOutputMagic() const { return _outputMagic; }
   uint16_t getOutputType() const { return _outputFileType; }
   uint16_t getOutputMachine() const;
   bool outputYAML() const { return _outputYAML; }
   bool mergeCommonStrings() const { return _mergeCommonStrings; }
   virtual uint64_t getBaseAddress() const { return _baseAddress; }
 
   /// This controls if undefined atoms need to be created for undefines that are
   /// present in a SharedLibrary. If this option is set, undefined atoms are
public:
   /// Relocations that return true will be added to the dynamic relocation
   /// table.
   virtual bool isDynamicRelocation(const DefinedAtom &,
                                    const Reference &) const {
     return false;
   }
   virtual bool validateImpl(raw_ostream &diagnostics);
 
+  /// \brief Does the linker allow dynamic libraries to be linked with ?
+  /// This is true when the output mode of the executable is set to be
+  /// having NMAGIC/OMAGIC
+  virtual bool allowLinkWithDynamicLibraries() const {
+    if (_outputMagic == OutputMagic::NMAGIC ||
+        _outputMagic == OutputMagic::OMAGIC ||
+        _noAllowDynamicLibraries)
+      return false;
+    return true;
+  }
 
   virtual error_code parseFile(std::unique_ptr<MemoryBuffer> &mb,
                         std::vector<std::unique_ptr<File>> &result) const;
 
   static std::unique_ptr<ELFTargetInfo> create(llvm::Triple);
 
   /// \brief Does this relocation belong in the dynamic plt relocation table?
   ///
public:
   void setUseShlibUndefines(bool use) { _useShlibUndefines = use; }
 
   /// \brief Set the dynamic linker path
   void setInterpreter(StringRef dynamicLinker) {
     _dynamicLinkerArg = true;
     _dynamicLinkerPath = dynamicLinker;
   }
 
+  /// \brief Set NMAGIC output kind when the linker specifies --nmagic
+  /// or -n in the command line
+  /// Set OMAGIC output kind when the linker specifies --omagic
+  /// or -N in the command line
+  virtual void setOutputMagic(OutputMagic magic) { _outputMagic = magic; }
+
+  /// \brief Disallow dynamic libraries during linking
+  virtual void setNoAllowDynamicLibraries() { _noAllowDynamicLibraries = true; }
+
   void appendSearchPath(StringRef dirPath) {
     _inputSearchPaths.push_back(dirPath);
   }
   /// Searches directories then calls appendInputFile()
   bool appendLibrary(StringRef libName);
 
 private:
   ELFTargetInfo() LLVM_DELETED_FUNCTION;
 protected:
   ELFTargetInfo(llvm::Triple, std::unique_ptr<TargetHandlerBase>);
 
   virtual Writer &writer() const;
 
   uint16_t                           _outputFileType; // e.g ET_EXEC
   llvm::Triple                       _triple;
   std::unique_ptr<TargetHandlerBase> _targetHandler;
   uint64_t                           _baseAddress;
   bool                               _isStaticExecutable;
   bool                               _outputYAML;
   bool                               _noInhibitExec;
   bool                               _mergeCommonStrings;
   bool                               _runLayoutPass;
   bool                               _useShlibUndefines;
   bool                               _dynamicLinkerArg;
+  bool                               _noAllowDynamicLibraries;
+  OutputMagic                        _outputMagic;
   std::vector<StringRef>             _inputSearchPaths;
   llvm::BumpPtrAllocator             _extraStrings;
   std::unique_ptr<Reader>            _elfReader;
   std::unique_ptr<Writer>            _writer;
   std::unique_ptr<Reader>            _linkerScriptReader;
   StringRef                          _dynamicLinkerPath;
 };
 } // end namespace lld
 
 #endif

lib/Driver/GnuLdDriver.cpp

GnuLdDriver::parse(int argc, const char *argv[], raw_ostream &diagnostics) {
   if (parsedArgs->getLastArg(OPT_use_shlib_undefs))
     options->setUseShlibUndefines(true);
 
   // Handle --dynamic-linker
   if (llvm::opt::Arg *dynamicLinker =
           parsedArgs->getLastArg(OPT_dynamic_linker))
     options->setInterpreter(dynamicLinker->getValue());
 
+  // Handle NMAGIC
+  if (parsedArgs->getLastArg(OPT_nmagic))
+    options->setOutputMagic(ELFTargetInfo::OutputMagic::NMAGIC);
+
+  // Handle OMAGIC
+  if (parsedArgs->getLastArg(OPT_omagic))
+    options->setOutputMagic(ELFTargetInfo::OutputMagic::OMAGIC);
+
+  // Handle --no-omagic
+  if (parsedArgs->getLastArg(OPT_no_omagic)) {
+    options->setOutputMagic(ELFTargetInfo::OutputMagic::DEFAULT);
+    options->setNoAllowDynamicLibraries();
+  }
+
+  // If either of the options NMAGIC/OMAGIC have been set, make the executable
+  // static
+  if (!options->allowLinkWithDynamicLibraries())
+    options->setIsStaticExecutable(true);
+
   // Handle -Lxxx
   for (llvm::opt::arg_iterator it = parsedArgs->filtered_begin(OPT_L),
                                ie = parsedArgs->filtered_end();
        it != ie; ++it) {
     options->appendSearchPath((*it)->getValue());
   }
 
   // Copy mllvm

lib/Driver/LDOptions.td

def no_allow_shlib_undefs : Flag<["--"], "no-allow-shlib-undefined">,
     HelpText<"Donot allow undefined symbols from dynamic library when creating executables">;
 
 def allow_shlib_undefs : Flag<["--"], "allow-shlib-undefined">,
     HelpText<"Allow undefined symbols from dynamic library when creating executables">;
 
 def use_shlib_undefs: Flag<["--"], "use-shlib-undefines">,
     HelpText<"Resolve undefined symbols from dynamic libraries">;
 
+def nmagic : Flag<["--"], "nmagic">,
+    HelpText<"Turn off page alignment of sections, and disable linking against shared libraries">;
+def nmagic_alias : Flag<["-"], "n">, Alias<nmagic>;
+
+def omagic : Flag<["--"], "omagic">,
+    HelpText<"Set the text and data sections to be readable and writable.  Also, do not page-align the data segment, and disable linking against shared libraries.">;
+def omagic_alias : Flag<["-"], "N">, Alias<omagic>;
+
+def no_omagic : Flag<["--"], "no-omagic">,
+    HelpText<"This option negates most of the effects of the -N option. Disable linking with shared libraries">;
+
 // extensions
 def emit_yaml : Flag<["-"], "emit-yaml">, 
     HelpText<"Write YAML instead of ELF">;
 def force_load : Flag<["--"], "force-load">,
     HelpText<"Force load of all members in all static libraries">;

lib/ReaderWriter/ELF/Chunk.h

public:
   enum Kind {
     K_Header, ///< ELF Header
     K_ProgramHeader, ///< Program Header
     K_ELFSegment, ///< Segment
     K_ELFSection, ///< Section
     K_AtomSection, ///< A section containing atoms.
     K_SectionHeader ///< Section header
   };
+  /// \brief the ContentType of the chunk
+  enum ContentType {
+    CT_Unknown,
+    CT_Header,
+    CT_Code,
+    CT_Data,
+    CT_Note,
+    CT_Tls,
+  };
+
   Chunk(StringRef name, Kind kind, const ELFTargetInfo &ti)
       : _name(name), _kind(kind), _fsize(0), _msize(0), _align2(0), _order(0),
-        _ordinal(1), _start(0), _fileoffset(0), _targetInfo(ti) {
-  }
+        _ordinal(1), _start(0), _fileoffset(0), _targetInfo(ti) {}
   virtual ~Chunk() {}
   // Does the chunk occupy disk space
   virtual bool occupiesNoDiskSpace() const { return false; }
   // The name of the chunk
   StringRef name() const { return _name; }
   // Kind of chunk
   Kind kind() const { return _kind; }
   uint64_t            fileSize() const { return _fsize; }
public:
   uint64_t            fileOffset() const { return _fileoffset; }
   void               setFileOffset(uint64_t offset) { _fileoffset = offset; }
   // Output start address of the chunk
   void               setVAddr(uint64_t start) { _start = start; }
   uint64_t            virtualAddr() const { return _start; }
   // Does the chunk occupy memory during execution ?
   uint64_t            memSize() const { return _msize; }
   void setMemSize(uint64_t msize) { _msize = msize; }
+  // Whats the contentType of the chunk ?
+  virtual int getContentType() const = 0;
   // Writer the chunk
   virtual void write(ELFWriter *writer, llvm::FileOutputBuffer &buffer) = 0;
   // Finalize the chunk before assigning offsets/virtual addresses
   virtual void doPreFlight() = 0;
   // Finalize the chunk before writing
   virtual void finalize() = 0;
 
 protected:

lib/ReaderWriter/ELF/DefaultLayout.h

if (!mergedSectionInsert.second) {
       mergedSectionInsert.first->second = mergedSection;
     }
     mergedSection->appendSection(si);
   }
 }
 
 template <class ELFT> void DefaultLayout<ELFT>::assignSectionsToSegments() {
   ScopedTask task(getDefaultDomain(), "assignSectionsToSegments");
+  ELFTargetInfo::OutputMagic outputMagic = _targetInfo.getOutputMagic();
     // TODO: Do we want to give a chance for the targetHandlers
     // to sort segments in an arbitrary order ?
   // sort the sections by their order as defined by the layout
   std::stable_sort(_sections.begin(), _sections.end(),
                    [](Chunk<ELFT> *A, Chunk<ELFT> *B) {
     return A->order() < B->order();
   });
   // Merge all sections
   mergeSimiliarSections();
   // Set the ordinal after sorting the sections
for (auto ai : msi->sections()) {
             segment = new (_allocator)
                 Segment<ELFT>(_targetInfo, segmentName, segmentType);
             additionalSegmentInsert.first->second = segment;
             _segments.push_back(segment);
           }
           segment->append(section);
         }
 
+        // If the output magic is set to OutputMagic::NMAGIC or
+        // OutputMagic::OMAGIC, Place the data alongside text in one single
+        // segment
+        if (outputMagic == ELFTargetInfo::OutputMagic::NMAGIC ||
+            outputMagic == ELFTargetInfo::OutputMagic::OMAGIC)
+          lookupSectionFlag = llvm::ELF::SHF_EXECINSTR | llvm::ELF::SHF_ALLOC |
+                              llvm::ELF::SHF_WRITE;
+
         // Use the flags of the merged Section for the segment
         const SegmentKey key("PT_LOAD", lookupSectionFlag);
         const std::pair<SegmentKey, Segment<ELFT> *> currentSegment(key,
                                                                     nullptr);
         std::pair<typename SegmentMapT::iterator, bool> segmentInsert(
             _segmentMap.insert(currentSegment));
         if (!segmentInsert.second) {
           segment = segmentInsert.first->second;

 
 template<class ELFT>
 void
 DefaultLayout<ELFT>::assignVirtualAddress() {
   if (_segments.empty())
     return;
 
   uint64_t virtualAddress = _targetInfo.getBaseAddress();
+  ELFTargetInfo::OutputMagic outputMagic = _targetInfo.getOutputMagic();
 
   // HACK: This is a super dirty hack. The elf header and program header are
   // not part of a section, but we need them to be loaded at the base address
   // so that AT_PHDR is set correctly by the loader and so they are accessible
   // at runtime. To do this we simply prepend them to the first loadable Segment
   // and let the layout logic take care of it.
   Segment<ELFT> *firstLoadSegment = nullptr;
   for (auto si : _segments) {
if (!newSegmentHeaderAdded)
       break;
     uint64_t fileoffset = 0;
     uint64_t address = virtualAddress;
     // Fix the offsets after adding the program header
     for (auto &si : _segments) {
       // Dont assign offsets for non loadable segments
       if (si->segmentType() != llvm::ELF::PT_LOAD)
         continue;
-      // Align the segment to a page boundary
+      // Align the segment to a page boundary only if the output mode is
+      // not OutputMagic::NMAGIC/OutputMagic::OMAGIC
+      if (outputMagic != ELFTargetInfo::OutputMagic::NMAGIC &&
+          outputMagic != ELFTargetInfo::OutputMagic::OMAGIC)
         fileoffset =
             llvm::RoundUpToAlignment(fileoffset, _targetInfo.getPageSize());
       si->assignOffsets(fileoffset);
       fileoffset = si->fileOffset() + si->fileSize();
     }
     // start assigning virtual addresses
     for (auto si = _segments.begin(); si != _segments.end(); ++si) {
       // Dont assign addresses for non loadable segments
       if ((*si)->segmentType() != llvm::ELF::PT_LOAD)
         continue;
       (*si)->setVAddr(virtualAddress);
       // The first segment has the virtualAddress set to the base address as
       // we have added the file header and the program header dont align the
       // first segment to the pagesize
       (*si)->assignVirtualAddress(address);
       (*si)->setMemSize(address - virtualAddress);
-      virtualAddress = llvm::RoundUpToAlignment(address,
-                                                _targetInfo.getPageSize());
+      if (outputMagic != ELFTargetInfo::OutputMagic::NMAGIC &&
+          outputMagic != ELFTargetInfo::OutputMagic::OMAGIC)
+        virtualAddress =
+            llvm::RoundUpToAlignment(address, _targetInfo.getPageSize());
     }
     _programHeader->resetProgramHeaders();
   }
   Section<ELFT> *section;
   // Fix the offsets of all the atoms within a section
   for (auto &si : _sections) {
     section = dyn_cast<Section<ELFT>>(si);
     if (section && DefaultLayout<ELFT>::hasOutputSegment(section))

lib/ReaderWriter/ELF/ELFTargetInfo.cpp

: _outputFileType(elf::ET_EXEC),
       _targetHandler(std::move(targetHandler)),
       _baseAddress(0),
       _isStaticExecutable(false),
       _outputYAML(false),
       _noInhibitExec(false),
       _mergeCommonStrings(false),
       _runLayoutPass(true),
       _useShlibUndefines(false),
-      _dynamicLinkerArg(false) {}
+      _dynamicLinkerArg(false),
+      _outputMagic(OutputMagic::DEFAULT) {}
 
 bool ELFTargetInfo::is64Bits() const { return getTriple().isArch64Bit(); }
 
 bool ELFTargetInfo::isLittleEndian() const {
   // TODO: Do this properly. It is not defined purely by arch.
   return true;
 }
 

lib/ReaderWriter/ELF/HeaderChunks.h

public:
   void e_shnum(uint16_t shnum)         { _eh.e_shnum = shnum; }
   void e_shstrndx(uint16_t shstrndx)   { _eh.e_shstrndx = shstrndx; }
   uint64_t  fileSize()                 { return sizeof (Elf_Ehdr); }
 
   static inline bool classof(const Chunk<ELFT> *c) {
     return c->Kind() == Chunk<ELFT>::K_Header;
   }
 
+  inline int getContentType() const {
+    return Chunk<ELFT>::CT_Header;
+  }
+
   void write(ELFWriter *writer, llvm::FileOutputBuffer &buffer);
 
   virtual void doPreFlight() {}
 
   void finalize() {}
 
 private:
   Elf_Ehdr _eh;
public:
   void finalize() {}
 
   int64_t entsize() { return sizeof(Elf_Phdr); }
 
   int64_t numHeaders() {
     return _ph.size();
   }
 
+  inline int getContentType() const {
+    return Chunk<ELFT>::CT_Header;
+  }
+
 private:
   Elf_Phdr *allocateProgramHeader(bool &allocatedNew) {
     Elf_Phdr *phdr;
     if (_phi == _ph.end()) {
       phdr = new (_allocator) Elf_Phdr;
       _ph.push_back(phdr);
       _phi = _ph.end();
       allocatedNew = true;
     } else {
       phdr = (*_phi);
       ++_phi;
     }
     return phdr;
   }
 
   std::vector<Elf_Phdr *> _ph;
   PhIterT _phi;
   llvm::BumpPtrAllocator _allocator;
 };
 
 template <class ELFT>
 bool ProgramHeader<ELFT>::addSegment(Segment<ELFT> *segment) {
   bool allocatedNew = false;
+  ELFTargetInfo::OutputMagic outputMagic = this->_targetInfo.getOutputMagic();
   // For segments that are not a loadable segment, we
   // just pick the values directly from the segment as there
   // wouldnt be any slices within that
   if (segment->segmentType() != llvm::ELF::PT_LOAD) {
     Elf_Phdr *phdr = allocateProgramHeader(allocatedNew);
     phdr->p_type = segment->segmentType();
     phdr->p_offset = segment->fileOffset();
     phdr->p_vaddr = segment->virtualAddr();
for (auto slice : segment->slices()) {
     Elf_Phdr *phdr = allocateProgramHeader(allocatedNew);
     phdr->p_type = segment->segmentType();
     phdr->p_offset = slice->fileOffset();
     phdr->p_vaddr = slice->virtualAddr();
     phdr->p_paddr = slice->virtualAddr();
     phdr->p_filesz = slice->fileSize();
     phdr->p_memsz = slice->memSize();
     phdr->p_flags = segment->flags();
-    phdr->p_align = (phdr->p_type == llvm::ELF::PT_LOAD) ?
-                          segment->pageSize() : slice->align2();
+    if (outputMagic != ELFTargetInfo::OutputMagic::NMAGIC &&
+        outputMagic != ELFTargetInfo::OutputMagic::OMAGIC)
+      phdr->p_align = (phdr->p_type == llvm::ELF::PT_LOAD) ? segment->pageSize()
+                                                           : slice->align2();
+    else
+      phdr->p_align = slice->align2();
   }
   this->_fsize = fileSize();
   this->_msize = this->_fsize;
 
   return allocatedNew;
 }
 
 template <class ELFT>
public:
   void finalize() {}
 
   inline uint64_t fileSize() { return sizeof(Elf_Shdr) * _sectionInfo.size(); }
 
   inline uint64_t entsize() {
     return sizeof(Elf_Shdr);
   }
 
+  inline int getContentType() const {
+    return Chunk<ELFT>::CT_Header;
+  }
+
   inline uint64_t numHeaders() {
     return _sectionInfo.size();
   }
 
 private:
   StringTable<ELFT> *_stringSection;
   std::vector<Elf_Shdr*>                  _sectionInfo;
   llvm::BumpPtrAllocator                  _sectionAllocate;

lib/ReaderWriter/ELF/Reader.cpp

case llvm::sys::fs::file_magic::elf_relocatable: {
           getElfArchType(&*mb), MaxAlignment, _elfTargetInfo, std::move(mb),
           ec));
       if (ec)
         return ec;
       result.push_back(std::move(f));
       break;
     }
     case llvm::sys::fs::file_magic::elf_shared_object: {
+      // If the link doesnot allow dynamic libraries to be present during the
+      // link, lets not parse the file and just return
+      if (!_elfTargetInfo.allowLinkWithDynamicLibraries())
+        return llvm::make_error_code(llvm::errc::executable_format_error);
       auto f = createELF<DynamicFileCreateELFTraits>(
           getElfArchType(&*mb), MaxAlignment, _elfTargetInfo, std::move(mb));
       if (!f)
         return f;
       result.push_back(std::move(*f));
       break;
     }
     case llvm::sys::fs::file_magic::archive:

lib/ReaderWriter/ELF/SectionChunks.h

public:
 
   uint64_t getFlags() const { return _flags; }
   uint64_t getEntSize() const { return _entSize; }
   uint32_t getType() const { return _type; }
   uint32_t getLink() const { return _link; }
   uint32_t getInfo() const { return _info; }
   Layout::SegmentType getSegmentType() const { return _segmentType; }
 
+  /// \brief Return the type of content that the section contains
+  virtual int getContentType() const {
+    if (_flags & llvm::ELF::SHF_EXECINSTR)
+      return Chunk<ELFT>::CT_Code;
+    else if (_flags & llvm::ELF::SHF_WRITE)
+      return Chunk<ELFT>::CT_Data;
+    else if (_flags & llvm::ELF::SHF_ALLOC)
+      return Chunk<ELFT>::CT_Code;
+    else
+      return Chunk<ELFT>::CT_Unknown;
+  }
+
   /// \brief convert the segment type to a String for diagnostics and printing
   /// purposes
   StringRef segmentKindToStr() const;
 
   // TODO: Move this down to AtomSection.
   virtual bool findAtomAddrByName(StringRef name, uint64_t &addr) {
     return false;
   }

lib/ReaderWriter/ELF/SegmentChunks.h

 class Segment : public Chunk<ELFT> {
 public:
   typedef typename std::vector<SegmentSlice<ELFT> *>::iterator SliceIter;
   typedef typename std::vector<Chunk<ELFT> *>::iterator SectionIter;
 
   Segment(const ELFTargetInfo &ti, StringRef name,
           const Layout::SegmentType type);
 
+  /// \brief the Order of segments that appear in the output file
   enum SegmentOrder {
     permUnknown,
     permRWX,
     permRX,
     permR,
     permRWL,
     permRW,
     permNonAccess
static inline bool classof(const Chunk<ELFT> *c) {
     return c->kind() == Chunk<ELFT>::K_ELFSegment;
   }
 
   // Getters
   inline int32_t sectionCount() const {
     return _sections.size();
   }
 
+  /// \brief, this function returns the type of segment (PT_*)
   inline Layout::SegmentType segmentType() { return _segmentType; }
 
+  /// \brief return the segment type depending on the content,
+  /// If the content corresponds to Code, this will return Segment::Code
+  /// If the content corresponds to Data, this will return Segment::Data
+  /// If the content corresponds to TLS, this will return Segment::TLS
+  virtual int getContentType() const {
+    int64_t fl = flags();
+    switch (_segmentType) {
+    case llvm::ELF::PT_LOAD: {
+      if (fl && llvm::ELF::PF_X)
+        return Chunk<ELFT>::CT_Code;
+      if (fl && llvm::ELF::PF_W)
+        return Chunk<ELFT>::CT_Data;
+    }
+    case llvm::ELF::PT_TLS:
+      return Chunk<ELFT>::CT_Tls;
+    case llvm::ELF::PT_NOTE:
+      return Chunk<ELFT>::CT_Note;
+    default:
+      return Chunk<ELFT>::CT_Unknown;
+    }
+  }
+
   inline int pageSize() const { return this->_targetInfo.getPageSize(); }
 
   inline int rawflags() const { return _atomflags; }
 
   inline int64_t atomflags() const {
     switch (_atomflags) {
 
     case DefinedAtom::permUnknown:
public:
   inline SliceIter slices_begin() {
     return _segmentSlices.begin();
   }
 
   inline SliceIter slices_end() {
     return _segmentSlices.end();
   }
 
+private:
+
+  /// \brief Check if the chunk needs to be aligned
+  bool needAlign(Chunk<ELFT> *chunk) const {
+    if (chunk->getContentType() == Chunk<ELFT>::CT_Data &&
+        _outputMagic == ELFTargetInfo::OutputMagic::NMAGIC)
+      return true;
+    return false;
+  }
+
+  // Cached value of outputMagic
+  ELFTargetInfo::OutputMagic _outputMagic;
+
 protected:
   /// \brief Section or some other chunk type.
   std::vector<Chunk<ELFT> *> _sections;
   std::vector<SegmentSlice<ELFT> *> _segmentSlices;
   Layout::SegmentType _segmentType;
   uint64_t _flags;
   int64_t _atomflags;
   llvm::BumpPtrAllocator _segmentAllocate;

 
 template <class ELFT>
 Segment<ELFT>::Segment(const ELFTargetInfo &ti, StringRef name,
                        const Layout::SegmentType type)
     : Chunk<ELFT>(name, Chunk<ELFT>::K_ELFSegment, ti), _segmentType(type),
       _flags(0), _atomflags(0) {
   this->_align2 = 0;
   this->_fsize = 0;
+  _outputMagic = ti.getOutputMagic();
 }
 
 // This function actually is used, but not in all instantiations of Segment.
 LLVM_ATTRIBUTE_UNUSED
 static DefinedAtom::ContentPermissions toAtomPerms(uint64_t flags) {
   switch (flags & (SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR)) {
   case SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR:
     return DefinedAtom::permRWX;
   case SHF_ALLOC | SHF_EXECINSTR:
     return DefinedAtom::permR_X;
   case SHF_ALLOC:
     return DefinedAtom::permR__;
   case SHF_ALLOC | SHF_WRITE:
     return DefinedAtom::permRW_;
   default:
     return DefinedAtom::permUnknown;
   }
 }
 
 template <class ELFT> void Segment<ELFT>::append(Section<ELFT> *section) {
   _sections.push_back(section);
   if (_flags < section->getFlags())
-    _flags = section->getFlags();
+    _flags |= section->getFlags();
   if (_atomflags < toAtomPerms(_flags))
     _atomflags = toAtomPerms(_flags);
   if (this->_align2 < section->align2())
     this->_align2 = section->align2();
 }
 
 template <class ELFT>
 bool Segment<ELFT>::compareSegments(Segment<ELFT> *sega, Segment<ELFT> *segb) {
template <class ELFT> void Segment<ELFT>::assignOffsets(uint64_t startOffset) {
   uint64_t curSliceSize = 0;
   // Current Slice File Offset
   uint64_t curSliceFileOffset = 0;
 
   startSectionIter = _sections.begin();
   endSectionIter = _sections.end();
   startSection = 0;
   bool isFirstSection = true;
+  bool isDataPageAlignedForNMagic = false;
   for (auto si = _sections.begin(); si != _sections.end(); ++si) {
     if (isFirstSection) {
+      // If the linker outputmagic is set to OutputMagic::NMAGIC, align the Data
+      // to a page boundary
+      if (!isDataPageAlignedForNMagic && needAlign(*si)) {
+        startOffset = llvm::RoundUpToAlignment(startOffset,
+                                               this->_targetInfo.getPageSize());
+        isDataPageAlignedForNMagic = true;
+      }
       // align the startOffset to the section alignment
       uint64_t newOffset =
         llvm::RoundUpToAlignment(startOffset, (*si)->align2());
       curSliceFileOffset = newOffset;
       sliceAlign = (*si)->align2();
       this->setFileOffset(startOffset);
       (*si)->setFileOffset(newOffset);
       curSliceSize = (*si)->fileSize();
       isFirstSection = false;
     } else {
       uint64_t curOffset = curSliceFileOffset + curSliceSize;
-      uint64_t newOffset =
-        llvm::RoundUpToAlignment(curOffset, (*si)->align2());
+      // If the linker outputmagic is set to OutputMagic::NMAGIC, align the Data
+      // to a page boundary
+      if (!isDataPageAlignedForNMagic && needAlign(*si)) {
+        curOffset = llvm::RoundUpToAlignment(curOffset,
+                                             this->_targetInfo.getPageSize());
+        isDataPageAlignedForNMagic = true;
+      }
+      uint64_t newOffset = llvm::RoundUpToAlignment(curOffset, (*si)->align2());
       SegmentSlice<ELFT> *slice = nullptr;
       // If the newOffset computed is more than a page away, lets create
       // a seperate segment, so that memory is not used up while running
-      if ((newOffset - curOffset) > this->_targetInfo.getPageSize()) {
+      if (((newOffset - curOffset) > this->_targetInfo.getPageSize()) &&
+          (_outputMagic != ELFTargetInfo::OutputMagic::NMAGIC &&
+           _outputMagic != ELFTargetInfo::OutputMagic::OMAGIC)) {
+
         // TODO: use std::find here
         for (auto s : slices()) {
           if (s->startSection() == startSection) {
             slice = s;
             break;
           }
         }
         if (!slice) {
template <class ELFT> void Segment<ELFT>::assignOffsets(uint64_t startOffset) {
   this->_fsize = curSliceFileOffset - startOffset + curSliceSize;
   std::stable_sort(slices_begin(), slices_end(),
                    SegmentSlice<ELFT>::compare_slices);
 }
 
 /// \brief Assign virtual addresses to the slices
 template <class ELFT> void Segment<ELFT>::assignVirtualAddress(uint64_t &addr) {
   bool isTLSSegment = false;
+  bool isDataPageAlignedForNMagic = false;
   uint64_t tlsStartAddr = 0;
 
   for (auto slice : slices()) {
-    // Align to a page
+    // Align to a page only if the output is not
+    // OutputMagic::NMAGIC/OutputMagic::OMAGIC
+    if (_outputMagic != ELFTargetInfo::OutputMagic::NMAGIC &&
+        _outputMagic != ELFTargetInfo::OutputMagic::OMAGIC)
       addr = llvm::RoundUpToAlignment(addr, this->_targetInfo.getPageSize());
+
     // Align to the slice alignment
     addr = llvm::RoundUpToAlignment(addr, slice->align2());
 
     bool virtualAddressSet = false;
     for (auto section : slice->sections()) {
+      // If the linker outputmagic is set to OutputMagic::NMAGIC, align the Data
+      // to a page boundary
+      if (!isDataPageAlignedForNMagic && needAlign(section)) {
+        addr = llvm::RoundUpToAlignment(addr, this->_targetInfo.getPageSize());
+        isDataPageAlignedForNMagic = true;
+      }
       // Align the section address
       addr = llvm::RoundUpToAlignment(addr, section->align2());
       // Check if the segment is of type TLS
       // The sections that belong to the TLS segment have their
       // virtual addresses that are relative To TP
       Section<ELFT> *currentSection = llvm::dyn_cast<Section<ELFT> >(section);
       if (currentSection)
         isTLSSegment = (currentSection->getSegmentType() == llvm::ELF::PT_TLS);

test/elf/X86_64/Inputs/nmagic.c

+int a = 10;
+__thread int b = 20;
+__thread int c;
+__thread int d;
+
+int main() {
+  return 0;
+}

test/elf/X86_64/nmagic.test

+# This tests verifies functionality of NMAGIC that we create only two segments,
+# PT_LOAD, PT_TLS
+# The data segment should be aligned to a page boundary
+RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/nmagic.o  \
+RUN: --noinhibit-exec -o %t --nmagic
+RUN: llvm-readobj -sections %t | FileCheck -check-prefix=NMAGICSECTIONS %s
+RUN: llvm-readobj -program-headers %t | FileCheck -check-prefix=NMAGICPROGRAMHEADERS %s
+
+NMAGICSECTIONS: Sections [
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 0
+NMAGICSECTIONS:     Name:  (0)
+NMAGICSECTIONS:     Type: SHT_NULL (0x0)
+NMAGICSECTIONS:     Flags [ (0x0)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x0
+NMAGICSECTIONS:     Offset: 0x0
+NMAGICSECTIONS:     Size: 0
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 0
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 1
+NMAGICSECTIONS:     Name: .text (1)
+NMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+NMAGICSECTIONS:     Flags [ (0x6)
+NMAGICSECTIONS:       SHF_ALLOC (0x2)
+NMAGICSECTIONS:       SHF_EXECINSTR (0x4)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x4000B0
+NMAGICSECTIONS:     Offset: 0xB0
+NMAGICSECTIONS:     Size: 11
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 4
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 2
+NMAGICSECTIONS:     Name: .note.GNU-stack (7)
+NMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+NMAGICSECTIONS:     Flags [ (0x2)
+NMAGICSECTIONS:       SHF_ALLOC (0x2)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x4000BB
+NMAGICSECTIONS:     Offset: 0xBB
+NMAGICSECTIONS:     Size: 0
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 1
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 3
+NMAGICSECTIONS:     Name: .comment (23)
+NMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+NMAGICSECTIONS:     Flags [ (0x2)
+NMAGICSECTIONS:       SHF_ALLOC (0x2)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x4000BB
+NMAGICSECTIONS:     Offset: 0xBB
+NMAGICSECTIONS:     Size: 43
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 1
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 4
+NMAGICSECTIONS:     Name: .eh_frame (32)
+NMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+NMAGICSECTIONS:     Flags [ (0x2)
+NMAGICSECTIONS:       SHF_ALLOC (0x2)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x4000E8
+NMAGICSECTIONS:     Offset: 0xE8
+NMAGICSECTIONS:     Size: 56
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 8
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 5
+NMAGICSECTIONS:     Name: .tdata (42)
+NMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+NMAGICSECTIONS:     Flags [ (0x403)
+NMAGICSECTIONS:       SHF_ALLOC (0x2)
+NMAGICSECTIONS:       SHF_TLS (0x400)
+NMAGICSECTIONS:       SHF_WRITE (0x1)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x401000
+NMAGICSECTIONS:     Offset: 0x1000
+NMAGICSECTIONS:     Size: 4
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 4
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 6
+NMAGICSECTIONS:     Name: .tbss (49)
+NMAGICSECTIONS:     Type: SHT_NOBITS (0x8)
+NMAGICSECTIONS:     Flags [ (0x403)
+NMAGICSECTIONS:       SHF_ALLOC (0x2)
+NMAGICSECTIONS:       SHF_TLS (0x400)
+NMAGICSECTIONS:       SHF_WRITE (0x1)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x401004
+NMAGICSECTIONS:     Offset: 0x1004
+NMAGICSECTIONS:     Size: 8
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 4
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 7
+NMAGICSECTIONS:     Name: .got.plt (55)
+NMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+NMAGICSECTIONS:     Flags [ (0x3)
+NMAGICSECTIONS:       SHF_ALLOC (0x2)
+NMAGICSECTIONS:       SHF_WRITE (0x1)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x401008
+NMAGICSECTIONS:     Offset: 0x1008
+NMAGICSECTIONS:     Size: 0
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 8
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 8
+NMAGICSECTIONS:     Name: .data (64)
+NMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+NMAGICSECTIONS:     Flags [ (0x3)
+NMAGICSECTIONS:       SHF_ALLOC (0x2)
+NMAGICSECTIONS:       SHF_WRITE (0x1)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x401008
+NMAGICSECTIONS:     Offset: 0x1008
+NMAGICSECTIONS:     Size: 4
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 4
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 9
+NMAGICSECTIONS:     Name: .bss (70)
+NMAGICSECTIONS:     Type: SHT_NOBITS (0x8)
+NMAGICSECTIONS:     Flags [ (0x3)
+NMAGICSECTIONS:       SHF_ALLOC (0x2)
+NMAGICSECTIONS:       SHF_WRITE (0x1)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x40100C
+NMAGICSECTIONS:     Offset: 0x100C
+NMAGICSECTIONS:     Size: 0
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 4
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 10
+NMAGICSECTIONS:     Name: .shstrtab (75)
+NMAGICSECTIONS:     Type: SHT_STRTAB (0x3)
+NMAGICSECTIONS:     Flags [ (0x0)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x0
+NMAGICSECTIONS:     Offset: 0x100C
+NMAGICSECTIONS:     Size: 101
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 1
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 11
+NMAGICSECTIONS:     Name: .symtab (85)
+NMAGICSECTIONS:     Type: SHT_SYMTAB (0x2)
+NMAGICSECTIONS:     Flags [ (0x0)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x0
+NMAGICSECTIONS:     Offset: 0x1078
+NMAGICSECTIONS:     Size: 528
+NMAGICSECTIONS:     Link: 12
+NMAGICSECTIONS:     Info: 2
+NMAGICSECTIONS:     AddressAlignment: 8
+NMAGICSECTIONS:     EntrySize: 24
+NMAGICSECTIONS:   }
+NMAGICSECTIONS:   Section {
+NMAGICSECTIONS:     Index: 12
+NMAGICSECTIONS:     Name: .strtab (93)
+NMAGICSECTIONS:     Type: SHT_STRTAB (0x3)
+NMAGICSECTIONS:     Flags [ (0x0)
+NMAGICSECTIONS:     ]
+NMAGICSECTIONS:     Address: 0x0
+NMAGICSECTIONS:     Offset: 0x1288
+NMAGICSECTIONS:     Size: 246
+NMAGICSECTIONS:     Link: 0
+NMAGICSECTIONS:     Info: 0
+NMAGICSECTIONS:     AddressAlignment: 1
+NMAGICSECTIONS:     EntrySize: 0
+NMAGICSECTIONS:   }
+NMAGICSECTIONS: ]
+
+NMAGICPROGRAMHEADERS: ProgramHeaders [
+NMAGICPROGRAMHEADERS:   ProgramHeader {
+NMAGICPROGRAMHEADERS:     Type: PT_LOAD (0x1)
+NMAGICPROGRAMHEADERS:     Offset: 0x0
+NMAGICPROGRAMHEADERS:     VirtualAddress: 0x400000
+NMAGICPROGRAMHEADERS:     PhysicalAddress: 0x400000
+NMAGICPROGRAMHEADERS:     FileSize: 4108
+NMAGICPROGRAMHEADERS:     MemSize: 4108
+NMAGICPROGRAMHEADERS:     Flags [ (0x7)
+NMAGICPROGRAMHEADERS:       PF_R (0x4)
+NMAGICPROGRAMHEADERS:       PF_W (0x2)
+NMAGICPROGRAMHEADERS:       PF_X (0x1)
+NMAGICPROGRAMHEADERS:     ]
+NMAGICPROGRAMHEADERS:     Alignment: 8
+NMAGICPROGRAMHEADERS:   }
+NMAGICPROGRAMHEADERS:   ProgramHeader {
+NMAGICPROGRAMHEADERS:     Type: PT_TLS (0x7)
+NMAGICPROGRAMHEADERS:     Offset: 0x1000
+NMAGICPROGRAMHEADERS:     VirtualAddress: 0x401000
+NMAGICPROGRAMHEADERS:     PhysicalAddress: 0x401000
+NMAGICPROGRAMHEADERS:     FileSize: 4
+NMAGICPROGRAMHEADERS:     MemSize: 12
+NMAGICPROGRAMHEADERS:     Flags [ (0x6)
+NMAGICPROGRAMHEADERS:       PF_R (0x4)
+NMAGICPROGRAMHEADERS:       PF_W (0x2)
+NMAGICPROGRAMHEADERS:     ]
+NMAGICPROGRAMHEADERS:     Alignment: 4
+NMAGICPROGRAMHEADERS:   }
+NMAGICPROGRAMHEADERS: ]

test/elf/X86_64/omagic.test

+# This tests verifies functionality of omagic that we create only two segments,
+# PT_LOAD, PT_TLS
+# The data segment should not be aligned to a page boundary
+RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/nmagic.o  \
+RUN: --noinhibit-exec -o %t --omagic
+RUN: llvm-readobj -sections %t | FileCheck -check-prefix=OMAGICSECTIONS %s
+RUN: llvm-readobj -program-headers %t | FileCheck -check-prefix=OMAGICPROGRAMHEADERS %s
+
+OMAGICSECTIONS: Sections [
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 0
+OMAGICSECTIONS:     Name:  (0)
+OMAGICSECTIONS:     Type: SHT_NULL (0x0)
+OMAGICSECTIONS:     Flags [ (0x0)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x0
+OMAGICSECTIONS:     Offset: 0x0
+OMAGICSECTIONS:     Size: 0
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 0
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 1
+OMAGICSECTIONS:     Name: .text (1)
+OMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+OMAGICSECTIONS:     Flags [ (0x6)
+OMAGICSECTIONS:       SHF_ALLOC (0x2)
+OMAGICSECTIONS:       SHF_EXECINSTR (0x4)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x4000B0
+OMAGICSECTIONS:     Offset: 0xB0
+OMAGICSECTIONS:     Size: 11
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 4
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 2
+OMAGICSECTIONS:     Name: .note.GNU-stack (7)
+OMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+OMAGICSECTIONS:     Flags [ (0x2)
+OMAGICSECTIONS:       SHF_ALLOC (0x2)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x4000BB
+OMAGICSECTIONS:     Offset: 0xBB
+OMAGICSECTIONS:     Size: 0
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 1
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 3
+OMAGICSECTIONS:     Name: .comment (23)
+OMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+OMAGICSECTIONS:     Flags [ (0x2)
+OMAGICSECTIONS:       SHF_ALLOC (0x2)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x4000BB
+OMAGICSECTIONS:     Offset: 0xBB
+OMAGICSECTIONS:     Size: 43
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 1
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 4
+OMAGICSECTIONS:     Name: .eh_frame (32)
+OMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+OMAGICSECTIONS:     Flags [ (0x2)
+OMAGICSECTIONS:       SHF_ALLOC (0x2)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x4000E8
+OMAGICSECTIONS:     Offset: 0xE8
+OMAGICSECTIONS:     Size: 56
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 8
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 5
+OMAGICSECTIONS:     Name: .tdata (42)
+OMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+OMAGICSECTIONS:     Flags [ (0x403)
+OMAGICSECTIONS:       SHF_ALLOC (0x2)
+OMAGICSECTIONS:       SHF_TLS (0x400)
+OMAGICSECTIONS:       SHF_WRITE (0x1)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x400120
+OMAGICSECTIONS:     Offset: 0x120
+OMAGICSECTIONS:     Size: 4
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 4
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 6
+OMAGICSECTIONS:     Name: .tbss (49)
+OMAGICSECTIONS:     Type: SHT_NOBITS (0x8)
+OMAGICSECTIONS:     Flags [ (0x403)
+OMAGICSECTIONS:       SHF_ALLOC (0x2)
+OMAGICSECTIONS:       SHF_TLS (0x400)
+OMAGICSECTIONS:       SHF_WRITE (0x1)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x400124
+OMAGICSECTIONS:     Offset: 0x124
+OMAGICSECTIONS:     Size: 8
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 4
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 7
+OMAGICSECTIONS:     Name: .got.plt (55)
+OMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+OMAGICSECTIONS:     Flags [ (0x3)
+OMAGICSECTIONS:       SHF_ALLOC (0x2)
+OMAGICSECTIONS:       SHF_WRITE (0x1)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x400128
+OMAGICSECTIONS:     Offset: 0x128
+OMAGICSECTIONS:     Size: 0
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 8
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 8
+OMAGICSECTIONS:     Name: .data (64)
+OMAGICSECTIONS:     Type: SHT_PROGBITS (0x1)
+OMAGICSECTIONS:     Flags [ (0x3)
+OMAGICSECTIONS:       SHF_ALLOC (0x2)
+OMAGICSECTIONS:       SHF_WRITE (0x1)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x400128
+OMAGICSECTIONS:     Offset: 0x128
+OMAGICSECTIONS:     Size: 4
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 4
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 9
+OMAGICSECTIONS:     Name: .bss (70)
+OMAGICSECTIONS:     Type: SHT_NOBITS (0x8)
+OMAGICSECTIONS:     Flags [ (0x3)
+OMAGICSECTIONS:       SHF_ALLOC (0x2)
+OMAGICSECTIONS:       SHF_WRITE (0x1)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x40012C
+OMAGICSECTIONS:     Offset: 0x12C
+OMAGICSECTIONS:     Size: 0
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 4
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 10
+OMAGICSECTIONS:     Name: .shstrtab (75)
+OMAGICSECTIONS:     Type: SHT_STRTAB (0x3)
+OMAGICSECTIONS:     Flags [ (0x0)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x0
+OMAGICSECTIONS:     Offset: 0x12C
+OMAGICSECTIONS:     Size: 101
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 1
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 11
+OMAGICSECTIONS:     Name: .symtab (85)
+OMAGICSECTIONS:     Type: SHT_SYMTAB (0x2)
+OMAGICSECTIONS:     Flags [ (0x0)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x0
+OMAGICSECTIONS:     Offset: 0x198
+OMAGICSECTIONS:     Size: 528
+OMAGICSECTIONS:     Link: 12
+OMAGICSECTIONS:     Info: 2
+OMAGICSECTIONS:     AddressAlignment: 8
+OMAGICSECTIONS:     EntrySize: 24
+OMAGICSECTIONS:   }
+OMAGICSECTIONS:   Section {
+OMAGICSECTIONS:     Index: 12
+OMAGICSECTIONS:     Name: .strtab (93)
+OMAGICSECTIONS:     Type: SHT_STRTAB (0x3)
+OMAGICSECTIONS:     Flags [ (0x0)
+OMAGICSECTIONS:     ]
+OMAGICSECTIONS:     Address: 0x0
+OMAGICSECTIONS:     Offset: 0x3A8
+OMAGICSECTIONS:     Size: 246
+OMAGICSECTIONS:     Link: 0
+OMAGICSECTIONS:     Info: 0
+OMAGICSECTIONS:     AddressAlignment: 1
+OMAGICSECTIONS:     EntrySize: 0
+OMAGICSECTIONS:   }
+OMAGICSECTIONS: ]
+
+OMAGICPROGRAMHEADERS: ProgramHeaders [
+OMAGICPROGRAMHEADERS:   ProgramHeader {
+OMAGICPROGRAMHEADERS:     Type: PT_LOAD (0x1)
+OMAGICPROGRAMHEADERS:     Offset: 0x0
+OMAGICPROGRAMHEADERS:     VirtualAddress: 0x400000
+OMAGICPROGRAMHEADERS:     PhysicalAddress: 0x400000
+OMAGICPROGRAMHEADERS:     FileSize: 300
+OMAGICPROGRAMHEADERS:     MemSize: 300
+OMAGICPROGRAMHEADERS:     Flags [ (0x7)
+OMAGICPROGRAMHEADERS:       PF_R (0x4)
+OMAGICPROGRAMHEADERS:       PF_W (0x2)
+OMAGICPROGRAMHEADERS:       PF_X (0x1)
+OMAGICPROGRAMHEADERS:     ]
+OMAGICPROGRAMHEADERS:     Alignment: 8
+OMAGICPROGRAMHEADERS:   }
+OMAGICPROGRAMHEADERS:   ProgramHeader {
+OMAGICPROGRAMHEADERS:     Type: PT_TLS (0x7)
+OMAGICPROGRAMHEADERS:     Offset: 0x120
+OMAGICPROGRAMHEADERS:     VirtualAddress: 0x400120
+OMAGICPROGRAMHEADERS:     PhysicalAddress: 0x400120
+OMAGICPROGRAMHEADERS:     FileSize: 4
+OMAGICPROGRAMHEADERS:     MemSize: 12
+OMAGICPROGRAMHEADERS:     Flags [ (0x6)
+OMAGICPROGRAMHEADERS:       PF_R (0x4)
+OMAGICPROGRAMHEADERS:       PF_W (0x2)
+OMAGICPROGRAMHEADERS:     ]
+OMAGICPROGRAMHEADERS:     Alignment: 4
+OMAGICPROGRAMHEADERS:   }
+OMAGICPROGRAMHEADERS: ]