[lld][ELF] Apply segments from linker scripts

[denis-protivensky]

Summary

Put sections to segments according to linker scripts if available.
Rework the code of TargetLayout::assignSectionsToSegments so it operates on the given list of segments, which can be either read from linker scripts or constructed as before.
Handle NONE segments defined in linker scripts by putting corresponding sections to PT_NULL segment.
Consider flags set for segments through linker scripts.

NOTE: handling program header, as well as PHDRS and FILEHDR attributes of PHDRS command will be implemented separately.

[denis-protivensky]

Ping.

[Bigcheese]

lgtm

lld/trunk/include/lld/ReaderWriter/LinkerScript.h

 class PHDR {
 public:
   PHDR(StringRef name, uint64_t type, bool includeFileHdr, bool includePHDRs,
        const Expression *at, uint64_t flags)
       : _name(name), _type(type), _includeFileHdr(includeFileHdr),
         _includePHDRs(includePHDRs), _at(at), _flags(flags) {}
 
   StringRef name() const { return _name; }
+  uint64_t type() const { return _type; }
+  uint64_t flags() const { return _flags; }
+  bool isNone() const;
 
   void dump(raw_ostream &os) const;
 
-  /// Special header that discards output sections assigned to it.
-  static const PHDR *NONE;
-
 private:
   StringRef _name;
   uint64_t _type;
   bool _includeFileHdr;
   bool _includePHDRs;
   const Expression *_at;
   uint64_t _flags;
 };

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

StringRef getOutputSectionName(StringRef archivePath, StringRef memberPath,
                                  StringRef inputSectionName) const override {
     return llvm::StringSwitch<StringRef>(inputSectionName)
         .StartsWith(".ARM.exidx", ".ARM.exidx")
         .StartsWith(".ARM.extab", ".ARM.extab")
         .Default(TargetLayout::getOutputSectionName(archivePath, memberPath,
                                                     inputSectionName));
   }
 
-  SegmentType getSegmentType(Section<ELF32LE> *section) const override {
+  SegmentType getSegmentType(const Section<ELF32LE> *section) const override {
     switch (section->order()) {
     case ORDER_ARM_EXIDX:
       return llvm::ELF::PT_ARM_EXIDX;
     default:
       return TargetLayout::getSegmentType(section);
     }
   }
 

lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

if (contentType == DefinedAtom::typeDataFast ||
         contentType == DefinedAtom::typeZeroFillFast)
       return &_sdataSection;
     return TargetLayout::createSection(name, contentType, contentPermissions,
                                        sectionOrder);
   }
 
   /// \brief get the segment type for the section thats defined by the target
   TargetLayout::SegmentType
-  getSegmentType(Section<ELF32LE> *section) const override {
+  getSegmentType(const Section<ELF32LE> *section) const override {
     if (section->order() == ORDER_SDATA)
       return PT_LOAD;
     return TargetLayout::getSegmentType(section);
   }
 
   Section<ELF32LE> *getSDataSection() { return &_sdataSection; }
 
   uint64_t getGOTSymAddr() {

lld/trunk/lib/ReaderWriter/ELF/Mips/MipsTargetLayout.h

public:
   const MipsPLTSection<ELFT> &getPLTSection() const { return *_pltSection; }
 
   AtomSection<ELFT> *
   createSection(StringRef name, int32_t type,
                 DefinedAtom::ContentPermissions permissions,
                 typename TargetLayout<ELFT>::SectionOrder order) override;
 
   typename TargetLayout<ELFT>::SegmentType
-  getSegmentType(Section<ELFT> *section) const override;
+  getSegmentType(const Section<ELFT> *section) const override;
 
   /// \brief GP offset relative to .got section.
   uint64_t getGPOffset() const { return 0x7FF0; }
 
   /// \brief Get '_gp' symbol address.
   uint64_t getGPAddr();
 
   /// \brief Return the section order for a input section

lld/trunk/lib/ReaderWriter/ELF/Mips/MipsTargetLayout.cpp

if (type == DefinedAtom::typeGOT && name == ".got")
     return _gotSection;
   if (type == DefinedAtom::typeStub && name == ".plt")
     return _pltSection;
   return TargetLayout<ELFT>::createSection(name, type, permissions, order);
 }
 
 template <class ELFT>
 typename TargetLayout<ELFT>::SegmentType
-MipsTargetLayout<ELFT>::getSegmentType(Section<ELFT> *section) const {
+MipsTargetLayout<ELFT>::getSegmentType(const Section<ELFT> *section) const {
   switch (section->order()) {
   case ORDER_MIPS_REGINFO:
     return _abiInfo.hasMipsAbiSection() ? llvm::ELF::PT_LOAD
                                         : llvm::ELF::PT_MIPS_REGINFO;
   case ORDER_MIPS_OPTIONS:
     return llvm::ELF::PT_LOAD;
   case ORDER_MIPS_ABI_FLAGS:
     return llvm::ELF::PT_MIPS_ABIFLAGS;

lld/trunk/lib/ReaderWriter/ELF/SectionChunks.h

public:
   setSegmentType(const typename TargetLayout<ELFT>::SegmentType segmentType) {
     this->_segmentType = segmentType;
   }
 
   virtual const AtomLayout *findAtomLayoutByName(StringRef) const {
     return nullptr;
   }
 
+  const OutputSection<ELFT> *getOutputSection() const {
+    return _outputSection;
+  }
+
   void setOutputSection(OutputSection<ELFT> *os, bool isFirst = false) {
     _outputSection = os;
     _isFirstSectionInOutputSection = isFirst;
   }
 
   static bool classof(const Chunk<ELFT> *c) {
     return c->kind() == Chunk<ELFT>::Kind::ELFSection ||
            c->kind() == Chunk<ELFT>::Kind::AtomSection;

lld/trunk/lib/ReaderWriter/ELF/SegmentChunks.h

public:
   void assignVirtualAddress(uint64_t addr);
 
   // Write the Segment
   void write(ELFWriter *writer, TargetLayout<ELFT> &layout,
              llvm::FileOutputBuffer &buffer);
 
   int64_t flags() const;
 
+  // Set segment flags directly.
+  void setSegmentFlags(uint64_t flags);
+
   /// Prepend a generic chunk to the segment.
   void prepend(Chunk<ELFT> *c) {
     _sections.insert(_sections.begin(), c);
   }
 
   /// Finalize the segment, before we want to write the segment header
   /// information
   void finalize();

 
 protected:
   /// \brief Section or some other chunk type.
   std::vector<Chunk<ELFT> *> _sections;
   std::vector<SegmentSlice<ELFT> *> _segmentSlices;
   typename TargetLayout<ELFT>::SegmentType _segmentType;
   uint64_t _flags;
   int64_t _atomflags;
+  bool _segmentFlags;
   llvm::BumpPtrAllocator _segmentAllocate;
 };
 
 /// This chunk represents a linker script expression that needs to be calculated
 /// at the time the virtual addresses for the parent segment are being assigned.
 template <class ELFT> class ExpressionChunk : public Chunk<ELFT> {
 public:
   ExpressionChunk(ELFLinkingContext &ctx, const script::SymbolAssignment *expr)

lld/trunk/lib/ReaderWriter/ELF/SegmentChunks.cpp

bool SegmentSlice<ELFT>::compare_slices(SegmentSlice<ELFT> *a,
                                         SegmentSlice<ELFT> *b) {
   return a->startSection() < b->startSection();
 }
 
 template <class ELFT>
 Segment<ELFT>::Segment(const ELFLinkingContext &ctx, StringRef name,
                        const typename TargetLayout<ELFT>::SegmentType type)
     : Chunk<ELFT>(name, Chunk<ELFT>::Kind::ELFSegment, ctx), _segmentType(type),
-      _flags(0), _atomflags(0) {
+      _flags(0), _atomflags(0), _segmentFlags(false) {
   this->_alignment = 1;
   this->_fsize = 0;
   _outputMagic = ctx.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;
   }
 }
 
+// This function actually is used, but not in all instantiations of Segment.
+LLVM_ATTRIBUTE_UNUSED
+static DefinedAtom::ContentPermissions toAtomPermsSegment(uint64_t flags) {
+  switch (flags & (llvm::ELF::PF_R | llvm::ELF::PF_W | llvm::ELF::PF_X)) {
+  case llvm::ELF::PF_R | llvm::ELF::PF_W | llvm::ELF::PF_X:
+    return DefinedAtom::permRWX;
+  case llvm::ELF::PF_R | llvm::ELF::PF_X:
+    return DefinedAtom::permR_X;
+  case llvm::ELF::PF_R:
+    return DefinedAtom::permR__;
+  case llvm::ELF::PF_R | llvm::ELF::PF_W:
+    return DefinedAtom::permRW_;
+  default:
+    return DefinedAtom::permUnknown;
+  }
+}
+
 template <class ELFT> void Segment<ELFT>::append(Chunk<ELFT> *chunk) {
   _sections.push_back(chunk);
   Section<ELFT> *section = dyn_cast<Section<ELFT>>(chunk);
   if (!section)
     return;
+  if (this->_alignment < section->alignment())
+    this->_alignment = section->alignment();
+
+  if (_segmentFlags)
+    return;
   if (_flags < section->getFlags())
     _flags |= section->getFlags();
   if (_atomflags < toAtomPerms(_flags))
     _atomflags = toAtomPerms(_flags);
-  if (this->_alignment < section->alignment())
-    this->_alignment = section->alignment();
 }
 
 template <class ELFT>
 bool Segment<ELFT>::compareSegments(Segment<ELFT> *sega, Segment<ELFT> *segb) {
   int64_t type1 = sega->segmentType();
   int64_t type2 = segb->segmentType();
 
   if (type1 == type2)

 void Segment<ELFT>::write(ELFWriter *writer, TargetLayout<ELFT> &layout,
                           llvm::FileOutputBuffer &buffer) {
   for (auto slice : slices())
     for (auto section : slice->sections())
       section->write(writer, layout, buffer);
 }
 
 template <class ELFT> int64_t Segment<ELFT>::flags() const {
+  if (_segmentFlags)
+    return (int64_t)_flags;
+
   int64_t fl = 0;
   if (_flags & llvm::ELF::SHF_ALLOC)
     fl |= llvm::ELF::PF_R;
   if (_flags & llvm::ELF::SHF_WRITE)
     fl |= llvm::ELF::PF_W;
   if (_flags & llvm::ELF::SHF_EXECINSTR)
     fl |= llvm::ELF::PF_X;
   return fl;
 }
 
+template <class ELFT> void Segment<ELFT>::setSegmentFlags(uint64_t flags) {
+  assert(!_segmentFlags && !_flags && "Flags has already been set");
+  _segmentFlags = true;
+  _flags = flags;
+  _atomflags = toAtomPermsSegment(flags);
+}
+
 template <class ELFT> void Segment<ELFT>::finalize() {
   // We want to finalize the segment values for now only for non loadable
   // segments, since those values are not set in the Layout
   if (_segmentType == llvm::ELF::PT_LOAD)
     return;
   // The size is the difference of the
   // last section to the first section, especially for TLS because
   // the TLS segment contains both .tdata/.tbss

lld/trunk/lib/ReaderWriter/ELF/TargetLayout.h

bool operator()(const SectionKey &lhs, const SectionKey &rhs) const {
       return ((lhs._name == rhs._name) && (lhs._perm == rhs._perm) &&
               (lhs._path == rhs._path));
     }
   };
 
   typedef typename std::vector<Chunk<ELFT> *>::iterator ChunkIter;
   typedef typename std::vector<Segment<ELFT> *>::iterator SegmentIter;
 
-  // The additional segments are used to figure out
-  // if there is a segment by that type already created
-  // For example : PT_TLS, we have two sections .tdata/.tbss
-  // that are part of PT_TLS, we need to create this additional
-  // segment only once
-  typedef std::pair<int64_t, int64_t> AdditionalSegmentKey;
-  // The segments are created using
-  // SegmentName, Segment flags
-  typedef std::pair<StringRef, int64_t> SegmentKey;
+  // Properties used during segment creation
+  struct SegmentKey {
+    SegmentKey(StringRef name, int64_t type, uint64_t flags, bool segFlags)
+        : _name(name), _type(type), _flags(flags),
+          _segmentFlags(segFlags && flags != 0) {}
+    StringRef _name = "";
+    int64_t _type = 0;
+    uint64_t _flags = 0;
+    bool _segmentFlags = false;
+  };
 
-  // HashKey for the Segment
-  class SegmentHashKey {
-  public:
-    int64_t operator() (const SegmentKey &k) const {
-      // k.first = SegmentName
-      // k.second = SegmentFlags
-      return llvm::hash_combine(k.first, k.second);
+  struct SegmentKeyHash {
+    int64_t operator()(const SegmentKey &k) const {
+      return llvm::hash_combine(k._name, k._type, k._flags);
     }
   };
 
-  class AdditionalSegmentHashKey {
-  public:
-    int64_t operator()(const AdditionalSegmentKey &k) const {
-      // k.first = SegmentName
-      // k.second = SegmentFlags
-      return llvm::hash_combine(k.first, k.second);
+  struct SegmentKeyEq {
+    bool operator()(const SegmentKey &lhs, const SegmentKey &rhs) const {
+      return ((lhs._name == rhs._name) && (lhs._type == rhs._type) &&
+              (lhs._flags == rhs._flags));
     }
   };
 
-  // Output Sections contain the map of Sectionnames to a vector of sections,
+  // Output Sections contain the map of Section names to a vector of sections,
   // that have been merged to form a single section
   typedef llvm::StringMap<OutputSection<ELFT> *> OutputSectionMapT;
   typedef
       typename std::vector<OutputSection<ELFT> *>::iterator OutputSectionIter;
 
   typedef std::unordered_map<SectionKey, AtomSection<ELFT> *, SectionKeyHash,
                              SectionKeyEq> SectionMapT;
-  typedef std::unordered_map<AdditionalSegmentKey, Segment<ELFT> *,
-                             AdditionalSegmentHashKey> AdditionalSegmentMapT;
-  typedef std::unordered_map<SegmentKey, Segment<ELFT> *, SegmentHashKey>
-  SegmentMapT;
+  typedef std::unordered_map<SegmentKey, Segment<ELFT> *, SegmentKeyHash,
+                             SegmentKeyEq> SegmentMapT;
 
   typedef typename std::vector<AtomLayout *>::iterator AbsoluteAtomIterT;
 
   typedef llvm::DenseSet<const Atom *> AtomSetT;
 
   TargetLayout(ELFLinkingContext &ctx)
       : _ctx(ctx), _linkerScriptSema(ctx.linkerScriptSema()) {}
 
public:
 
   /// \brief Gets or creates a section.
   AtomSection<ELFT> *
   getSection(StringRef name, int32_t contentType,
              DefinedAtom::ContentPermissions contentPermissions,
              const DefinedAtom *da);
 
   /// \brief Gets the segment for a output section
-  virtual SegmentType getSegmentType(Section<ELFT> *section) const;
+  virtual SegmentType getSegmentType(const Section<ELFT> *section) const;
 
   /// \brief Returns true/false depending on whether the section has a Output
   //         segment or not
   static bool hasOutputSegment(Section<ELFT> *section);
 
   /// \brief Append the Atom to the layout and create appropriate sections.
   /// \returns A reference to the atom layout or an error. The atom layout will
   /// be updated as linking progresses.
AtomLayout *findAbsoluteAtom(StringRef name) {
     if (iter == _absoluteAtoms.end())
       return nullptr;
     return *iter;
   }
 
   // Output sections with the same name into a OutputSection
   void createOutputSections();
 
-  // Check that output section has proper segment set
-  void checkOutputSectionSegment(const OutputSection<ELFT> *sec);
+  // Query for custom segments of the given section
+  std::vector<const script::PHDR *>
+  getCustomSegments(const Section<ELFT> *section) const;
+
+  // Query for custom segments of the given output section
+  std::vector<const script::PHDR *>
+  getCustomSegments(const OutputSection<ELFT> *sec) const;
+
+  // Query for segments based on output and input sections
+  std::vector<SegmentKey> getSegmentsForSection(const OutputSection<ELFT> *os,
+                                                const Section<ELFT> *sec) const;
 
   /// \brief Sort the sections by their order as defined by the layout,
   /// preparing all sections to be assigned to a segment.
   virtual void sortInputSections();
 
   /// \brief Add extra chunks to a segment just before including the input
   /// section given by <archivePath, memberPath, sectionName>. This
   /// is used to add linker script expressions before each section.
protected:
 
   /// \brief Sort segements stored in the _segments
   virtual void sortSegments();
 
 protected:
   llvm::BumpPtrAllocator _allocator;
   SectionMapT _sectionMap;
   OutputSectionMapT _outputSectionMap;
-  AdditionalSegmentMapT _additionalSegmentMap;
   SegmentMapT _segmentMap;
   std::vector<Chunk<ELFT> *> _sections;
   std::vector<Segment<ELFT> *> _segments;
   std::vector<OutputSection<ELFT> *> _outputSections;
   ELFHeader<ELFT> *_elfHeader;
   ProgramHeader<ELFT> *_programHeader;
   unique_bump_ptr<RelocationTable<ELFT>> _dynamicRelocationTable;
   unique_bump_ptr<RelocationTable<ELFT>> _pltRelocationTable;

lld/trunk/lib/ReaderWriter/ELF/TargetLayout.cpp

return llvm::StringSwitch<StringRef>(inputSectionName)
       .StartsWith(".init_array", ".init_array")
       .StartsWith(".fini_array", ".fini_array")
       .Default(inputSectionName);
 }
 
 /// \brief Gets the segment for a output section
 template <class ELFT>
 typename TargetLayout<ELFT>::SegmentType
-TargetLayout<ELFT>::getSegmentType(Section<ELFT> *section) const {
+TargetLayout<ELFT>::getSegmentType(const Section<ELFT> *section) const {
   switch (section->order()) {
   case ORDER_INTERP:
     return llvm::ELF::PT_INTERP;
 
   case ORDER_TEXT:
   case ORDER_HASH:
   case ORDER_DYNAMIC_SYMBOLS:
   case ORDER_DYNAMIC_STRINGS:
const std::pair<StringRef, OutputSection<ELFT> *> currentOutputSection(
         section->outputSectionName(), nullptr);
     std::pair<typename OutputSectionMapT::iterator, bool> outputSectionInsert(
         _outputSectionMap.insert(currentOutputSection));
     if (!outputSectionInsert.second) {
       outputSection = outputSectionInsert.first->second;
     } else {
       outputSection = new (_allocator.Allocate<OutputSection<ELFT>>())
           OutputSection<ELFT>(section->outputSectionName());
-      checkOutputSectionSegment(outputSection);
       _outputSections.push_back(outputSection);
       outputSectionInsert.first->second = outputSection;
     }
     outputSection->appendSection(section);
   }
 }
 
-// Check that output section has proper segment set
 template <class ELFT>
-void TargetLayout<ELFT>::checkOutputSectionSegment(
-    const OutputSection<ELFT> *sec) {
+std::vector<const script::PHDR *>
+TargetLayout<ELFT>::getCustomSegments(const OutputSection<ELFT> *sec) const {
   std::vector<const script::PHDR *> phdrs;
   if (_linkerScriptSema.getPHDRsForOutputSection(sec->name(), phdrs)) {
     llvm::report_fatal_error(
         "Linker script has wrong segments set for output sections");
   }
+  return phdrs;
+}
+
+template <class ELFT>
+std::vector<const script::PHDR *>
+TargetLayout<ELFT>::getCustomSegments(const Section<ELFT> *section) const {
+  auto sec = section->getOutputSection();
+  assert(sec && "Output section should be already set for input section");
+  return getCustomSegments(sec);
+}
+
+template <class ELFT>
+std::vector<typename TargetLayout<ELFT>::SegmentKey>
+TargetLayout<ELFT>::getSegmentsForSection(const OutputSection<ELFT> *os,
+                                          const Section<ELFT> *sec) const {
+  std::vector<SegmentKey> segKeys;
+  auto phdrs = getCustomSegments(os);
+  if (!phdrs.empty()) {
+    if (phdrs.size() == 1 && phdrs[0]->isNone()) {
+      segKeys.emplace_back("NONE", llvm::ELF::PT_NULL, 0, false);
+      return segKeys;
+    }
+
+    for (auto phdr : phdrs) {
+      segKeys.emplace_back(phdr->name(), phdr->type(), phdr->flags(), true);
+    }
+    return segKeys;
+  }
+
+  uint64_t flags = getLookupSectionFlags(os);
+  int64_t segmentType = getSegmentType(sec);
+  StringRef segmentName = sec->segmentKindToStr();
+
+  // We need a separate segment for sections that don't have
+  // the segment type to be PT_LOAD
+  if (segmentType != llvm::ELF::PT_LOAD)
+    segKeys.emplace_back(segmentName, segmentType, flags, false);
+
+  if (segmentType == llvm::ELF::PT_NULL)
+    return segKeys;
+
+  // If the output magic is set to OutputMagic::NMAGIC or
+  // OutputMagic::OMAGIC, Place the data alongside text in one single
+  // segment
+  ELFLinkingContext::OutputMagic outputMagic = _ctx.getOutputMagic();
+  if (outputMagic == ELFLinkingContext::OutputMagic::NMAGIC ||
+      outputMagic == ELFLinkingContext::OutputMagic::OMAGIC)
+    flags =
+        llvm::ELF::SHF_EXECINSTR | llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE;
+
+  segKeys.emplace_back("LOAD", llvm::ELF::PT_LOAD, flags, false);
+  return segKeys;
 }
 
 template <class ELFT>
 uint64_t
 TargetLayout<ELFT>::getLookupSectionFlags(const OutputSection<ELFT> *os) const {
   uint64_t flags = os->flags();
   if (!(flags & llvm::ELF::SHF_WRITE) && _ctx.mergeRODataToTextSegment())
     flags &= ~llvm::ELF::SHF_EXECINSTR;
 
   // Merge string sections into Data segment itself
   flags &= ~(llvm::ELF::SHF_STRINGS | llvm::ELF::SHF_MERGE);
 
   // Merge the TLS section into the DATA segment itself
   flags &= ~(llvm::ELF::SHF_TLS);
   return flags;
 }
 
 template <class ELFT> void TargetLayout<ELFT>::assignSectionsToSegments() {
   ScopedTask task(getDefaultDomain(), "assignSectionsToSegments");
-  ELFLinkingContext::OutputMagic outputMagic = _ctx.getOutputMagic();
   // sort the sections by their order as defined by the layout
   sortInputSections();
 
   // Create output sections.
   createOutputSections();
 
   // Finalize output section layout.
   finalizeOutputSectionLayout();
 
   // Set the ordinal after sorting the sections
   int ordinal = 1;
   for (auto osi : _outputSections) {
     osi->setOrdinal(ordinal);
     for (auto ai : osi->sections()) {
       ai->setOrdinal(ordinal);
     }
     ++ordinal;
   }
   for (auto osi : _outputSections) {
     for (auto section : osi->sections()) {
       if (!hasOutputSegment(section))
         continue;
 
       osi->setLoadableSection(section->isLoadableSection());
-
-      // Get the segment type for the section
-      int64_t segmentType = getSegmentType(section);
-
       osi->setHasSegment();
-      section->setSegmentType(segmentType);
-      StringRef segmentName = section->segmentKindToStr();
 
-      uint64_t lookupSectionFlag = getLookupSectionFlags(osi);
+      auto segKeys = getSegmentsForSection(osi, section);
+      assert(!segKeys.empty() && "Must always be at least one segment");
+      section->setSegmentType(segKeys[0]._type);
+
+      for (auto key : segKeys) {
+        // Try to find non-load (real) segment type if possible
+        if (key._type != llvm::ELF::PT_LOAD)
+          section->setSegmentType(key._type);
 
-      Segment<ELFT> *segment;
-      // We need a separate segment for sections that don't have
-      // the segment type to be PT_LOAD
-      if (segmentType != llvm::ELF::PT_LOAD) {
-        const AdditionalSegmentKey key(segmentType, lookupSectionFlag);
-        const std::pair<AdditionalSegmentKey, Segment<ELFT> *>
-            additionalSegment(key, nullptr);
-        std::pair<typename AdditionalSegmentMapT::iterator, bool>
-            additionalSegmentInsert(
-                _additionalSegmentMap.insert(additionalSegment));
-        if (!additionalSegmentInsert.second) {
-          segment = additionalSegmentInsert.first->second;
-        } else {
-          segment =
-              new (_allocator) Segment<ELFT>(_ctx, segmentName, segmentType);
-          additionalSegmentInsert.first->second = segment;
-          _segments.push_back(segment);
-        }
-        segment->append(section);
-      }
-      if (segmentType == llvm::ELF::PT_NULL)
-        continue;
-
-      // If the output magic is set to OutputMagic::NMAGIC or
-      // OutputMagic::OMAGIC, Place the data alongside text in one single
-      // segment
-      if (outputMagic == ELFLinkingContext::OutputMagic::NMAGIC ||
-          outputMagic == ELFLinkingContext::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);
+        const std::pair<SegmentKey, Segment<ELFT> *> currentSegment(key,
+                                                                    nullptr);
         std::pair<typename SegmentMapT::iterator, bool> segmentInsert(
             _segmentMap.insert(currentSegment));
+        Segment<ELFT> *segment;
         if (!segmentInsert.second) {
           segment = segmentInsert.first->second;
         } else {
-        segment =
-            new (_allocator) Segment<ELFT>(_ctx, "PT_LOAD", llvm::ELF::PT_LOAD);
+          segment = new (_allocator) Segment<ELFT>(_ctx, key._name, key._type);
+          if (key._segmentFlags)
+            segment->setSegmentFlags(key._flags);
           segmentInsert.first->second = segment;
           _segments.push_back(segment);
         }
+        if (key._type == llvm::ELF::PT_LOAD) {
           // Insert chunks with linker script expressions that occur at this
           // point, just before appending a new input section
           addExtraChunksToSegment(segment, section->archivePath(),
                                   section->memberPath(),
                                   section->inputSectionName());
+        }
         segment->append(section);
       }
     }
+  }
   if (_ctx.isDynamic() && !_ctx.isDynamicLibrary()) {
     Segment<ELFT> *segment = new (_allocator) ProgramHeaderSegment<ELFT>(_ctx);
     _segments.push_back(segment);
     segment->append(_elfHeader);
     segment->append(_programHeader);
   }
 }
 

lld/trunk/lib/ReaderWriter/LinkerScript.cpp

if (_fillStream.size() > 0) {
     os << " =";
     dumpByteStream(os, _fillStream);
   } else if (_fillExpr) {
     os << " =";
     _fillExpr->dump(os);
   }
 }
 
+// Special header that discards output sections assigned to it.
+static const PHDR PHDR_NONE("NONE", 0, false, false, nullptr, 0);
+
+bool PHDR::isNone() const {
+  return this == &PHDR_NONE;
+}
+
 void PHDR::dump(raw_ostream &os) const {
   os << _name << " " << _type;
   if (_includeFileHdr)
     os << " FILEHDR";
   if (_includePHDRs)
     os << " PHDRS";
   if (_at) {
     os << " AT (";
     _at->dump(os);
     os << ")";
   }
   if (_flags)
     os << " FLAGS (" << _flags << ")";
   os << ";\n";
 }
 
-static PHDR none("NONE", 0, false, false, NULL, 0);
-const PHDR *PHDR::NONE = &none;
-
 void PHDRS::dump(raw_ostream &os) const {
   os << "PHDRS\n{\n";
   for (auto &&phdr : _phdrs) {
     phdr->dump(os);
   }
   os << "}\n";
 }
 
for (auto *cmd : parser->get()->_commands) {
           phdrs[p->name()] = p;
       }
     }
   }
   const bool noPhdrs = phdrs.empty();
 
   // Add NONE header to the map provided there's no user-defined
   // header with the same name.
-  if (!_sectionToPHDR.count(PHDR::NONE->name()))
-    phdrs[PHDR::NONE->name()] = PHDR::NONE;
+  if (!_sectionToPHDR.count(PHDR_NONE.name()))
+    phdrs[PHDR_NONE.name()] = &PHDR_NONE;
 
   // Match output sections to available headers.
-  llvm::SmallVector<const PHDR *, 2> phdrsCur, phdrsLast { PHDR::NONE };
+  llvm::SmallVector<const PHDR *, 2> phdrsCur, phdrsLast { &PHDR_NONE };
   for (const Command *cmd : _layoutCommands) {
     auto osd = dyn_cast<OutputSectionDescription>(cmd);
     if (!osd || osd->isDiscarded())
       continue;
 
     phdrsCur.clear();
     for (StringRef name : osd->PHDRs()) {
       auto it = phdrs.find(name);

lld/trunk/test/elf/linkerscript/phdrs-all-none.test

+/*
+Test when all segments are marked as NONE.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix NONE-ALL-PHDRS %s
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    text PT_LOAD;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :NONE
+  .data : { *(.data) }
+}
+
+/*
+NONE-ALL-PHDRS: .text {{[0-9a-f]+}} 0000000000000000
+NONE-ALL-PHDRS: .data {{[0-9a-f]+}} 000000000000002c
+*/

lld/trunk/test/elf/linkerscript/phdrs-different.test

+/*
+Test sections put to different segments.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix DIFF-PHDRS-SECS %s
+RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix DIFF-PHDRS-HDRS %s
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+  text PT_LOAD;
+  data PT_LOAD;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) } :data
+}
+
+/*
+DIFF-PHDRS-SECS: .text {{[0-9a-f]+}} 00000000004000e8
+DIFF-PHDRS-SECS: .data {{[0-9a-f]+}} 0000000000401000
+
+DIFF-PHDRS-HDRS: ProgramHeader {
+DIFF-PHDRS-HDRS: Type: PT_LOAD (0x1)
+DIFF-PHDRS-HDRS: VirtualAddress: 0x400000
+DIFF-PHDRS-HDRS: Flags [ (0x5)
+DIFF-PHDRS-HDRS: PF_R (0x4)
+DIFF-PHDRS-HDRS: PF_X (0x1)
+DIFF-PHDRS-HDRS: ]
+DIFF-PHDRS-HDRS: }
+DIFF-PHDRS-HDRS: ProgramHeader {
+DIFF-PHDRS-HDRS: Type: PT_LOAD (0x1)
+DIFF-PHDRS-HDRS: VirtualAddress: 0x401000
+DIFF-PHDRS-HDRS: Flags [ (0x6)
+DIFF-PHDRS-HDRS: PF_R (0x4)
+DIFF-PHDRS-HDRS: PF_W (0x2)
+DIFF-PHDRS-HDRS: ]
+DIFF-PHDRS-HDRS: }
+*/

lld/trunk/test/elf/linkerscript/phdrs-flags.test

+/*
+Test sections put to different segments with FLAGS attribute set.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix FLAGS-PHDRS-SECS %s
+RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix FLAGS-PHDRS-HDRS %s
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    text PT_LOAD FLAGS(0x5);
+    data PT_LOAD FLAGS(0x7);
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) } :data
+}
+
+/*
+FLAGS-PHDRS-SECS: .text {{[0-9a-f]+}} 0000000000401000
+FLAGS-PHDRS-SECS: .data {{[0-9a-f]+}} 00000000004000e8
+
+FLAGS-PHDRS-HDRS: ProgramHeader {
+FLAGS-PHDRS-HDRS: Type: PT_LOAD (0x1)
+FLAGS-PHDRS-HDRS: VirtualAddress: 0x400000
+FLAGS-PHDRS-HDRS: Flags [ (0x7)
+FLAGS-PHDRS-HDRS: PF_R (0x4)
+FLAGS-PHDRS-HDRS: PF_W (0x2)
+FLAGS-PHDRS-HDRS: PF_X (0x1)
+FLAGS-PHDRS-HDRS: ]
+FLAGS-PHDRS-HDRS: }
+FLAGS-PHDRS-HDRS: ProgramHeader {
+FLAGS-PHDRS-HDRS: Type: PT_LOAD (0x1)
+FLAGS-PHDRS-HDRS: VirtualAddress: 0x401000
+FLAGS-PHDRS-HDRS: Flags [ (0x5)
+FLAGS-PHDRS-HDRS: PF_R (0x4)
+FLAGS-PHDRS-HDRS: PF_X (0x1)
+FLAGS-PHDRS-HDRS: ]
+FLAGS-PHDRS-HDRS: }
+*/

lld/trunk/test/elf/linkerscript/phdrs-one-none.test

+/*
+Test when one segment is marked as NONE.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix NONE-PHDRS-SECS %s
+RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix NONE-PHDRS-HDRS %s
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+  text PT_LOAD;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) } :NONE
+}
+
+/*
+NONE-PHDRS-SECS: .text {{[0-9a-f]+}} 00000000004000b0
+NONE-PHDRS-SECS: .data {{[0-9a-f]+}} 0000000000000000
+
+NONE-PHDRS-HDRS: ProgramHeader {
+NONE-PHDRS-HDRS: Type: PT_LOAD (0x1)
+NONE-PHDRS-HDRS: VirtualAddress: 0x400000
+NONE-PHDRS-HDRS: Flags [ (0x5)
+NONE-PHDRS-HDRS: PF_R (0x4)
+NONE-PHDRS-HDRS: PF_X (0x1)
+NONE-PHDRS-HDRS: ]
+NONE-PHDRS-HDRS: }
+*/

lld/trunk/test/elf/linkerscript/phdrs-same-flags.test

+/*
+Test sections put to same segment with FLAGS attribute set.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix FLAGS-PHDRS-SECS %s
+RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix FLAGS-PHDRS-HDRS %s
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    text PT_LOAD FLAGS(0x4);
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+FLAGS-PHDRS-SECS: .text {{[0-9a-f]+}} 00000000004000b0
+FLAGS-PHDRS-SECS: .data {{[0-9a-f]+}} 00000000004000dc
+
+FLAGS-PHDRS-HDRS: ProgramHeader {
+FLAGS-PHDRS-HDRS: Type: PT_LOAD (0x1)
+FLAGS-PHDRS-HDRS: VirtualAddress: 0x400000
+FLAGS-PHDRS-HDRS: Flags [ (0x4)
+FLAGS-PHDRS-HDRS: PF_R (0x4)
+FLAGS-PHDRS-HDRS: ]
+FLAGS-PHDRS-HDRS: }
+*/

lld/trunk/test/elf/linkerscript/phdrs-same.test

+/*
+Test sections put to same segment.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix SAME-PHDRS-SECS %s
+RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix SAME-PHDRS-HDRS %s
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+  text PT_LOAD;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+SAME-PHDRS-SECS: .text {{[0-9a-f]+}} 00000000004000b0
+SAME-PHDRS-SECS: .data {{[0-9a-f]+}} 00000000004000dc
+
+SAME-PHDRS-HDRS: ProgramHeader {
+SAME-PHDRS-HDRS: Type: PT_LOAD (0x1)
+SAME-PHDRS-HDRS: VirtualAddress: 0x400000
+SAME-PHDRS-HDRS: Flags [ (0x5)
+SAME-PHDRS-HDRS: PF_R (0x4)
+SAME-PHDRS-HDRS: PF_X (0x1)
+SAME-PHDRS-HDRS: ]
+SAME-PHDRS-HDRS: }
+*/