[ELF2] SECTIONS command basic support

[denis-protivensky]

Summary

Add support of SECTIONS command:

• determine output section by input section name
• discard input sections
• order output sections accordingly
• don't add bounding symbols (__start/__stop) for sections defined in the linker script

[grimar]

ELF/Writer.cpp

460

This could be in class declaration.

510

Does not seem that llvm_unreachable is really needed. Code just few lines above creates OutputSections or MergeOutputSections, no any other choices.

922

This would work a bit faster in some cases:

if (Config->OutputSections.find(A->getName()) == ItEnd ||
Config->OutputSections.find(B->getName()) == ItEnd )
{...

[denis-protivensky]

ELF/Writer.cpp

460

Ok.

510

There are other choices coming from the cached values of Map. It now holds only Bss before the loop, but who knows what can be added later. That's a good form of protection.

922

I don't think we should sacrifice readability since performance benefit is not clear here.
I need iterators after this check, and I don't want to write C-style code like:

if ((ItA = Config->.... ) == ItEnd ||
  ((ItB = Config->.... ) == ItEnd))

I will moreover need to define full iterator types before usage instead of auto deduction.

[grimar]

ELF/Writer.cpp

922

I didnt notice at first that you use ItA/ItB after that. Ok then.

[denis-protivensky]

ELF/Writer.cpp

922

I actually can break it up into two separate checks so it'll be more optimal and won't affect code style.

[grimar]

ELF/Writer.cpp

922

I thought about that but for me it will look not very readable. Not sure if that possible little speed up worth that.

[ruiu]

ELF/OutputSections.h

98–99 ↗

(On Diff #38634)

Why do you need this?

ELF/Writer.cpp

93–108

No, please don't make another Writer class. This is over-engineering. There's no such need to support two writers, one for ELF without linker script and another for ELF + linker script.

[denis-protivensky]

Updated:

• Remove dynamic casting of output section classes
• Remove separate class for linker script support
• Move linker script-related code to Writer and use conditional checks where needed

[grimar]

ELF/Config.h

38

May be regroup would look better ?

llvm::StringRef InputFile;
std::vector<llvm::StringRef> Names;
std::vector<llvm::StringRef> ExcludeFiles;

ELF/Writer.cpp

460

What about next one ?

 if (!IS || !IS->isLive() || IS == &InputSection<ELFT>::Discarded)
    return true;

return hasCustomSections() && InputToOutputSection.lookup(IS->getSectionName()) == "/DISCARD/";

910

I think you want to use & after autos:
auto &OutSec, auto &InSec ...

[denis-protivensky]

ELF/Config.h

38

Ok, maybe.

ELF/Writer.cpp

460

A matter of taste again. Okay.

910

Yes, that's right.

[denis-protivensky]

Update:

• Style fixes
• Use reference in range-for-loop (auto &)

[ruiu]

ELF/LinkerScript.cpp

250

I wouldn't write this in this functional style. This can be written in a plain C style if you define skip(S) which returns true if the next token is S.

expect("(");
while (!skip(")") {
  StringRef Tok = next();
  if (Tok == "EXCLUDE_FILE") {
  ...

ELF/Writer.cpp

461–465

Why don't you create start/stop symbols if the section is defined using a linker script? Is that a documented behavior?

615–635

I don't like to add more code to createSections() which is already too long. Move this lambda out of this function.

[grimar]

ELF/Writer.cpp

910

I think you can do the same for auto Name.

[denis-protivensky]

ELF/LinkerScript.cpp

250

mapBraces actually does the same. I can change peek to skip, but why to produce code duplication where it can be avoided? Procedural style may be more cumbersome here than the current functional implementation.

ELF/Writer.cpp

461–465

If one defines output section description, they may define all needed symbols manually.
That's why I think any default actions that can be achieved with linker script should be suppressed.

615–635

I need RegularSections, which is local to the method. It's captured in the lambda, and I think it would be ugly to pass it to the comparison function along with two output sections to compare. Any ideas how to make it better?

910

I'll use real types instead.

[ruiu]

ELF/LinkerScript.cpp

250

By duplicate, do you mean this part? I don't think this is duplicate.

expect("(");
while (!skip(")") {

ELF/Writer.cpp

615–635

Why do you need RegularSections in the first place? What is this !RegularSections.(A)||!RegularSections.count(B) condition for?

[denis-protivensky]

ELF/Writer.cpp

615–635

The intent is to sort 'specific' sections like .symtab, .strtab and others with default sorting order even if some of these names are defined in linker script. Can't figure out why the tests pass without this check as I thought I specifically checked that case. Will look at this more.

[ruiu]

2015/10/29 8:31 "Denis Protivensky" <[e-mail]>:

denis-protivensky added inline comments.

Comment at: ELF/Writer.cpp:614
@@ -574,3 +613,3 @@

• std::stable_sort(OutputSections.begin(), OutputSections.end(),
• compareOutputSections<ELFT>);

+ std::stable_sort(

+ OutputSections.begin(), OutputSections.end(),

ruiu wrote:

denis-protivensky wrote:

ruiu wrote:

I don't like to add more code to createSections() which is already

too long. Move this lambda out of this function.

I need RegularSections, which is local to the method. It's captured

in the lambda, and I think it would be ugly to pass it to the comparison
function along with two output sections to compare. Any ideas how to make
it better?

Why do you need RegularSections in the first place? What is this

!RegularSections.(A)||!RegularSections.count(B) condition for?

The intent is to sort 'specific' sections like .symtab, .strtab and

others with default sorting order even if some of these names are defined
in linker script. Can't figure out why the tests pass without this check as
I thought I specifically checked that case. Will look at this more.

I don't think we need that protection. If users try to reorder such
sections, we should do that as instructed, no?

http://reviews.llvm.org/D14140

[denis-protivensky]

I don't think we need that protection. If users try to reorder such
sections, we should do that as instructed, no?

First of all, I reproduced the case when defining 'specific' section in the SECTIONS command affects its ordering in the resulting file without the check, so this check works as I expected.

Concerning ordering of 'specific' sections:
The goal of the SECTIONS command is to layout sections from input files to the corresponding output sections. 'Specific' sections as .got, .plt, .interp and most others don't have input sections at all and are generated by the linker logic. This means that we cannot affect the contents of such sections, and the output section description command of format

.interp : { *(.interp) }

is void because there are no input .interp sections, and such empty output sections are discarded by linker rules. The only way this format of command worked is to define custom .interp section (possibly of SHT_PROGBITS/_NOBITS type). Then it will be considered during layout, but that's a specific case and it's checked in tests (with .shstrtab custom section).
I conclude that output section descriptions affect only PROGBITS/NOBITS section types, which are represented as OutputSection/MergeOutputSection in lld, and we currently create only these sections from output section descriptions.
That's why I think the ordering should also affect only these sections, which are stored in RegularSections map in code.

Just as a note: ld doesn't seem as well to reorder 'specific' sections even if defined in linker script.

[denis-protivensky]

ELF/LinkerScript.cpp

250

Do you think this code:

expect("(");
while (!skip(")")) {
  StringRef Tok = next();
  if (Tok == "EXCLUDE_FILE") {
    expect("(");
    while (!skip(")"))
      InSec.ExcludeFiles.push_back(next());
  } else
    InSec.Names.push_back(Tok);
}

is simpler and more clear than the original one:

mapBraces("(", ")", [this, &InSec]() {
  StringRef Tok = next();
  if (Tok == "EXCLUDE_FILE")
    mapBraces("(", ")",
              [this, &InSec]() { InSec.ExcludeFiles.push_back(next()); });
  else
    InSec.Names.push_back(Tok);
});

?

[ruiu]

I think this falls in the category of undefined behaviors if there was a
spec of the linker script. Since there's no standard or specification for
the linker script, we need to do something that we think reasonable. A
pitfall we want to avoid is to copy every detail of the GNU linker. So can
you please minimize the impact of the patch to the regular flow? I'd
restore code for start/stop symbols and for RegularSections, and
reorder "non-regular" sections if instructed to do so.

[ruiu]

ELF/LinkerScript.cpp

250

Yes, I do think so (as a C/C++ programmer and as a Scheme programmer). The former is much more straightforward C++ and easier to understand than the latter, especially for people who are not very familiar with all the code in this file.

[denis-protivensky]

Updated:

• Replace mapBraces method with procedural checks in the linker script parser
• Change peek() -> skip() in the parser
• Remove custom bounding symbols processing for linker script
• Remove checks for regular section ordering for linker script
• Change section comparison lambda with method
• Remove not used fields of input section description struct

[ruiu]

ELF/Config.h

33–35

A struct with one field doesn't have much value. Please remove.

ELF/LinkerScript.cpp

52–56

Move readInputSectionDescription and readOutputSectionDescription at the end of this list (after one blank line) so that helper functions are not mixed with readers for top-level constructs.

154–155

Remove this blank line and a comment. (If you really want to add a comment to this short function, write that as a function comment, but I think we don't need that.)

251–253

You can remove {}.

ELF/Writer.cpp

435

Do you really need to check for that? If it's empty, find() will not find anything, so this check seems extraneous.

453

Rename discardInputSection -> isDiscarded

456

Is this check needed?

463

Is this needed?

615–636

This may be able to be written as

std::stable_sort(OutputSections.begin(), OutputSections.end(), compareSections);

[denis-protivensky]

Updated:

• Style fixes in linker script
• Remove InputSectionDescription
• Remove hasCustomSections check
• Rename discardInputSection -> isDiscarded
• Make compareSections static

[ruiu]

ELF/Writer.cpp

554–562

for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles())
  for (InputSectionBase<ELFT> *C : F->getSections())
    if (!isDiscarded(C))
      if (auto *S = dyn_cast<InputSection<ELFT>>(C))
        scanRelocs(*S);

905–910

Looks like OutputSectionDescription doesn't have to be a struct. We can make Config->OutputSections of type StringMap<StringRef> which maps input section names to output section names.

[• rafael]

First of all, I reproduced the case when defining 'specific' section in the SECTIONS command affects its ordering in the resulting file without the check, so this check works as I expected.

Concerning ordering of 'specific' sections:
The goal of the SECTIONS command is to layout sections from input files to the corresponding output sections. 'Specific' sections as .got, .plt, .interp and most others don't have input sections at all and are generated by the linker logic. This means that we cannot affect the contents of such sections, and the output section description command of format

.interp : { *(.interp) }

is void because there are no input .interp sections, and such empty output sections are discarded by linker rules. The only way this format of command worked is to define custom .interp section (possibly of SHT_PROGBITS/_NOBITS type). Then it will be considered during layout, but that's a specific case and it's checked in tests (with .shstrtab custom section).
I conclude that output section descriptions affect only PROGBITS/NOBITS section types, which are represented as OutputSection/MergeOutputSection in lld, and we currently create only these sections from output section descriptions.
That's why I think the ordering should also affect only these sections, which are stored in RegularSections map in code.

Just as a note: ld doesn't seem as well to reorder 'specific' sections even if defined in linker script.

It is not clear if this is needed by real program. For now just leave
it out to have a simpler code. Even if it is needed, it would be
better to just organize the code as

• add sections from input files
• sort
• add linker generated sections
• sort the end + merge

no?
Cheers,
Rafael

[denis-protivensky]

In D14140#282350, @rafael wrote:

It is not clear if this is needed by real program. For now just leave
it out to have a simpler code. Even if it is needed, it would be
better to just organize the code as

• add sections from input files
• sort
• add linker generated sections
• sort the end + merge

no?

I'll leave simpler code, thanks.

ELF/Writer.cpp

554–562

Ok.

905–910

I can't substitute MapVector with StringMap since I need to know original ordering of output sections defined in linker script so I can sort them accordingly.
I'll remove the OutputSectionDescription structure and use MapVector<StringRef, std::vector<StringRef>> instead.

[denis-protivensky]

Updated:

• Remove OutputSectionDescription structure
• Simplify checks in scan relocs loop

[ruiu]

One question is the performance with this patch. Does this slow down the linker? If so, how much?

ELF/Writer.cpp

905

Can you avoid using a word "parse" here? Linker scripts are and should be parsed by LinkerScript.cpp, so every time I see this name, it feels like a domain error. I don't have a good suggestion, but I'd probably name createSectionMap or something.

[denis-protivensky]

Updated:

• Rename parseSectionDescriptions -> buildSectionMap

[denis-protivensky]

In D14140#285339, @ruiu wrote:

One question is the performance with this patch. Does this slow down the linker? If so, how much?

The average of 20 iterations of self-linking lld on my machine:

• without the patch = 420 ms
• with the patch = 425 ms

[ruiu]

LGTM with a nit.

ELF/Writer.cpp

42

Please move this to the beginning of Writer<ELFT>::run().

ELF/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_CONFIG_H
 #define LLD_ELF_CONFIG_H
 
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ELF.h"
 
 #include <vector>
 
 namespace lld {
 namespace elf2 {
 
 class InputFile;
 class SymbolBody;
 
 enum ELFKind {
   ELFNoneKind,
   ELF32LEKind,
   ELF32BEKind,
   ELF64LEKind,
   ELF64BEKind
 };
 
+struct InputSectionDescription {
+  std::vector<llvm::StringRef> Names;
+  llvm::StringRef InputFile;
+  std::vector<llvm::StringRef> ExcludeFiles;
+};
+
+struct OutputSectionDescription {
+  llvm::StringRef Name;
+  std::vector<InputSectionDescription> InputSections;
+};
+
 struct Configuration {
   SymbolBody *EntrySym = nullptr;
   InputFile *FirstElf = nullptr;
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
+  llvm::MapVector<llvm::StringRef, OutputSectionDescription> OutputSections;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;

ELF/LinkerScript.cpp

public:
   LinkerScript(BumpPtrAllocator *A, StringRef S)
       : Saver(*A), Tokens(tokenize(S)) {}
   void run();
 
 private:
   static std::vector<StringRef> tokenize(StringRef S);
   static StringRef skipSpace(StringRef S);
   StringRef next();
+  StringRef peek();
   bool atEOF() { return Tokens.size() == Pos; }
   void expect(StringRef Expect);
+  template <class Function>
+  void mapBraces(StringRef OpenBrace, StringRef CloseBrace, Function F);
 
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
   void readGroup();
   void readInclude();
+  void readInputSectionDescription(OutputSectionDescription &OutSec);
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
+  void readOutputSectionDescription();
   void readSearchDir();
+  void readSections();
 
   StringSaver Saver;
   std::vector<StringRef> Tokens;
   size_t Pos = 0;
 };
 }
 
 void LinkerScript::run() {
while (!atEOF()) {
     } else if (Tok == "OUTPUT") {
       readOutput();
     } else if (Tok == "OUTPUT_ARCH") {
       readOutputArch();
     } else if (Tok == "OUTPUT_FORMAT") {
       readOutputFormat();
     } else if (Tok == "SEARCH_DIR") {
       readSearchDir();
+    } else if (Tok == "SECTIONS") {
+      readSections();
     } else {
       error("unknown directive: " + Tok);
     }
   }
 }
 
 // Split S into linker script tokens.
 std::vector<StringRef> LinkerScript::tokenize(StringRef S) {
for (;;) {
     size_t Size = S.size();
     S = S.ltrim();
     if (S.size() == Size)
       return S;
   }
 }
 
 StringRef LinkerScript::next() {
-  if (Pos == Tokens.size())
+  if (atEOF())
     error("unexpected EOF");
   return Tokens[Pos++];
 }
 
+StringRef LinkerScript::peek() {
+  if (atEOF())
+    error("unexpected EOF");
+  return Tokens[Pos];
+}
+
 void LinkerScript::expect(StringRef Expect) {
   StringRef Tok = next();
   if (Tok != Expect)
     error(Expect + " expected, but got " + Tok);
 }
 
+template <class Function>
+void LinkerScript::mapBraces(StringRef OpenBrace, StringRef CloseBrace,
+                             Function F) {
+  expect(OpenBrace);
+  while (peek() != CloseBrace)
+    F();
+  expect(CloseBrace);
+}
+
 void LinkerScript::addFile(StringRef S) {
   if (sys::path::is_absolute(S)) {
     Driver->addFile(S);
   } else if (S.startswith("=")) {
     if (Config->Sysroot.empty())
       Driver->addFile(S.substr(1));
     else
       Driver->addFile(Saver.save(Config->Sysroot + "/" + S.substr(1)));
void LinkerScript::readInclude() {
   auto MBOrErr = MemoryBuffer::getFile(Tok);
   error(MBOrErr, "cannot open " + Tok);
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   StringRef S = Saver.save(MB->getMemBufferRef().getBuffer());
   std::vector<StringRef> V = tokenize(S);
   Tokens.insert(Tokens.begin() + Pos, V.begin(), V.end());
 }
 
+void LinkerScript::readInputSectionDescription(
+    OutputSectionDescription &OutSec) {
+  OutSec.InputSections.emplace_back();
+  InputSectionDescription &InSec = OutSec.InputSections.back();
+
+  InSec.InputFile = next();
+  mapBraces("(", ")", [this, &InSec]() {
+    StringRef Tok = next();
+    if (Tok == "EXCLUDE_FILE")
+      mapBraces("(", ")",
+                [this, &InSec]() { InSec.ExcludeFiles.push_back(next()); });
+    else
+      InSec.Names.push_back(Tok);
+  });
+}
+
 void LinkerScript::readOutput() {
   // -o <file> takes predecence over OUTPUT(<file>).
   expect("(");
   StringRef Tok = next();
   if (Config->OutputFile.empty())
     Config->OutputFile = Tok;
   expect(")");
 }
void LinkerScript::readOutputFormat() {
   if (Tok != ",")
     error("unexpected token: " + Tok);
   next();
   expect(",");
   next();
   expect(")");
 }
 
+void LinkerScript::readOutputSectionDescription() {
+  StringRef Name = next();
+  OutputSectionDescription &OutSec = Config->OutputSections[Name];
+  OutSec.Name = Name;
+
+  expect(":");
+  mapBraces("{", "}",
+            [this, &OutSec]() { readInputSectionDescription(OutSec); });
+}
+
 void LinkerScript::readSearchDir() {
   expect("(");
   Config->SearchPaths.push_back(next());
   expect(")");
 }
 
+void LinkerScript::readSections() {
+  mapBraces("{", "}", [this]() { readOutputSectionDescription(); });
+}
+
 // Entry point. The other functions or classes are private to this file.
 void lld::elf2::readLinkerScript(BumpPtrAllocator *A, MemoryBufferRef MB) {
   LinkerScript(A, MB.getBuffer()).run();
 }

ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
 namespace {
 // The writer writes a SymbolTable result to a file.
 template <class ELFT> class Writer {
 public:
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
   typedef typename ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
   typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
-  Writer(SymbolTable<ELFT> &S) : Symtab(S) {}
+  Writer(SymbolTable<ELFT> &S) : Symtab(S) {
+    parseSectionDescriptions();
+  }
   void run();
 
 private:
   void copyLocalSymbols();
   void createSections();
   template <bool isRela>
   void scanRelocs(const InputSection<ELFT> &C,
                   iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels);
   void scanRelocs(const InputSection<ELFT> &C);
   void assignAddresses();
   void openFile(StringRef OutputPath);
   void writeHeader();
   void writeSections();
+  bool discardInputSection(InputSectionBase<ELFT> *IS) const;
+  StringRef getOutputSectionName(StringRef S) const;
+  bool hasBoundingSymbols(OutputSectionBase<ELFT> *OS) const;
   bool needsInterpSection() const {
     return !Symtab.getSharedFiles().empty() && !Config->DynamicLinker.empty();
   }
   bool isOutputDynamic() const {
     return !Symtab.getSharedFiles().empty() || Config->Shared;
   }
   uintX_t getVAStart() const { return Config->Shared ? 0 : Target->getVAStart(); }
   uintX_t getEntryAddr() const;
   int getPhdrsNum() const;
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
   SpecificBumpPtrAllocator<OutputSection<ELFT>> SecAlloc;
   SpecificBumpPtrAllocator<MergeOutputSection<ELFT>> MSecAlloc;
   BumpPtrAllocator Alloc;
   std::vector<OutputSectionBase<ELFT> *> OutputSections;
   unsigned getNumSections() const { return OutputSections.size() + 1; }
 
   void addStartStopSymbols(OutputSectionBase<ELFT> *Sec);
   void setPhdr(Elf_Phdr *PH, uint32_t Type, uint32_t Flags, uintX_t FileOff,
                uintX_t VA, uintX_t Size, uintX_t Align);
   void copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT> *From);
+  void parseSectionDescriptions();
 
   SymbolTable<ELFT> &Symtab;
   std::vector<Elf_Phdr> Phdrs;
 
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
+
+  llvm::StringMap<llvm::StringRef> InputToOutputSection;
 };
 } // anonymous namespace
 
 template <class ELFT> void lld::elf2::writeResult(SymbolTable<ELFT> *Symtab) {
   // Initialize output sections that are handled by Writer specially.
   // Don't reorder because the order of initialization matters.
   InterpSection<ELFT> Interp;
   Out<ELFT>::Interp = &Interp;
   StringTableSection<ELFT> ShStrTab(".shstrtab", false);
   Out<ELFT>::ShStrTab = &ShStrTab;
   StringTableSection<ELFT> StrTab(".strtab", false);
   if (!Config->StripAll)
     Out<ELFT>::StrTab = &StrTab;
   StringTableSection<ELFT> DynStrTab(".dynstr", true);
   Out<ELFT>::DynStrTab = &DynStrTab;
   OutputSection<ELFT> Bss(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
   Out<ELFT>::Bss = &Bss;
   GotSection<ELFT> Got;
   Out<ELFT>::Got = &Got;
   GotPltSection<ELFT> GotPlt;
   if (Target->supportsLazyRelocations())
     Out<ELFT>::GotPlt = &GotPlt;
   PltSection<ELFT> Plt;
   Out<ELFT>::Plt = &Plt;
   std::unique_ptr<SymbolTableSection<ELFT>> SymTab;
   if (!Config->StripAll) {
for (const Elf_Sym &Sym : F->getLocalSymbols()) {
       if (!shouldKeepInSymtab<ELFT>(*F, SymName, Sym))
         continue;
       if (Out<ELFT>::SymTab)
         Out<ELFT>::SymTab->addLocalSymbol(SymName);
     }
   }
 }
 
+static bool hasCustomSections() { return !Config->OutputSections.empty(); }
+
 // PPC64 has a number of special SHT_PROGBITS+SHF_ALLOC+SHF_WRITE sections that
 // we would like to make sure appear is a specific order to maximize their
 // coverage by a single signed 16-bit offset from the TOC base pointer.
 // Conversely, the special .tocbss section should be first among all SHT_NOBITS
 // sections. This will put it next to the loaded special PPC64 sections (and,
 // thus, within reach of the TOC base pointer).
 static int getPPC64SectionRank(StringRef SectionName) {
   return StringSwitch<int>(SectionName)
for (SharedSymbol<ELFT> *C : Syms) {
     // enough unconditionally.
     Off = RoundUpToAlignment(Off, 16);
     C->OffsetInBSS = Off;
     Off += Sym.st_size;
   }
   Out<ELFT>::Bss->setSize(Off);
 }
 
-static StringRef getOutputName(StringRef S) {
+template <class ELFT>
+StringRef Writer<ELFT>::getOutputSectionName(StringRef S) const {
+  if (hasCustomSections()) {
+    auto It = InputToOutputSection.find(S);
+    if (It != std::end(InputToOutputSection))
+      return It->second;
+  }
+
   if (S.startswith(".text."))
     return ".text";
   if (S.startswith(".rodata."))
     return ".rodata";
   if (S.startswith(".data."))
     return ".data";
   if (S.startswith(".bss."))
     return ".bss";
   return S;
 }
 
+template <class ELFT>
+bool Writer<ELFT>::discardInputSection(InputSectionBase<ELFT> *IS) const {
+  if (!IS || !IS->isLive() || IS == &InputSection<ELFT>::Discarded)
+    return true;
+  if (hasCustomSections())
+    return InputToOutputSection.lookup(IS->getSectionName()) == "/DISCARD/";
+  return false;
+}
+
+template <class ELFT>
+bool Writer<ELFT>::hasBoundingSymbols(OutputSectionBase<ELFT> *OS) const {
+  if (!hasCustomSections())
+    return true;
+  return OS && Config->OutputSections.count(OS->getName()) == 0;
+}
+
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::createSections() {
   // .interp needs to be on the first page in the output file.
   if (needsInterpSection())
     OutputSections.push_back(Out<ELFT>::Interp);
 
   SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSectionBase<ELFT> *> Map;
+  DenseSet<OutputSectionBase<ELFT> *> RegularSections;
 
   OutputSections.push_back(Out<ELFT>::Bss);
+  RegularSections.insert(Out<ELFT>::Bss);
   Map[{Out<ELFT>::Bss->getName(), Out<ELFT>::Bss->getType(),
        Out<ELFT>::Bss->getFlags(), 0}] = Out<ELFT>::Bss;
 
-  std::vector<OutputSectionBase<ELFT> *> RegularSections;
-
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
     for (InputSectionBase<ELFT> *C : F->getSections()) {
-      if (!C || !C->isLive() || C == &InputSection<ELFT>::Discarded)
+      if (discardInputSection(C))
         continue;
       const Elf_Shdr *H = C->getSectionHdr();
       uintX_t OutFlags = H->sh_flags & ~SHF_GROUP;
       // For SHF_MERGE we create different output sections for each sh_entsize.
       // This makes each output section simple and keeps a single level
       // mapping from input to output.
       auto *IS = dyn_cast<InputSection<ELFT>>(C);
       uintX_t EntSize = IS ? 0 : H->sh_entsize;
-      SectionKey<ELFT::Is64Bits> Key{getOutputName(C->getSectionName()),
+      SectionKey<ELFT::Is64Bits> Key{getOutputSectionName(C->getSectionName()),
                                      H->sh_type, OutFlags, EntSize};
       OutputSectionBase<ELFT> *&Sec = Map[Key];
       if (!Sec) {
         if (IS)
           Sec = new (SecAlloc.Allocate())
               OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
         else
           Sec = new (MSecAlloc.Allocate())
               MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
         OutputSections.push_back(Sec);
-        RegularSections.push_back(Sec);
+        RegularSections.insert(Sec);
       }
       if (IS)
         static_cast<OutputSection<ELFT> *>(Sec)->addSection(IS);
       else
         static_cast<MergeOutputSection<ELFT> *>(Sec)
             ->addSection(cast<MergeInputSection<ELFT>>(C));
     }
   }
 
   Out<ELFT>::Dynamic->PreInitArraySec = Map.lookup(
       {".preinit_array", SHT_PREINIT_ARRAY, SHF_WRITE | SHF_ALLOC, 0});
   Out<ELFT>::Dynamic->InitArraySec =
       Map.lookup({".init_array", SHT_INIT_ARRAY, SHF_WRITE | SHF_ALLOC, 0});
   Out<ELFT>::Dynamic->FiniArraySec =
       Map.lookup({".fini_array", SHT_FINI_ARRAY, SHF_WRITE | SHF_ALLOC, 0});
 
   auto AddStartEnd = [&](StringRef Start, StringRef End,
                          OutputSectionBase<ELFT> *OS) {
+    if (!hasBoundingSymbols(OS))
+      return;
     if (OS) {
       Symtab.addSyntheticSym(Start, *OS, 0);
       Symtab.addSyntheticSym(End, *OS, OS->getSize());
     } else {
       Symtab.addIgnoredSym(Start);
       Symtab.addIgnoredSym(End);
     }
   };
 
   AddStartEnd("__preinit_array_start", "__preinit_array_end",
               Out<ELFT>::Dynamic->PreInitArraySec);
   AddStartEnd("__init_array_start", "__init_array_end",
               Out<ELFT>::Dynamic->InitArraySec);
   AddStartEnd("__fini_array_start", "__fini_array_end",
               Out<ELFT>::Dynamic->FiniArraySec);
 
   for (OutputSectionBase<ELFT> *Sec : RegularSections)
+    if (hasBoundingSymbols(Sec))
       addStartStopSymbols(Sec);
 
   // __tls_get_addr is defined by the dynamic linker for dynamic ELFs. For
   // static linking the linker is required to optimize away any references to
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
   if (!isOutputDynamic())
     Symtab.addIgnoredSym("__tls_get_addr");
 
   // Scan relocations. This must be done after every symbol is declared so that
   // we can correctly decide if a dynamic relocation is needed.
-  for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles())
-    for (InputSectionBase<ELFT> *B : F->getSections())
-      if (auto *S = dyn_cast_or_null<InputSection<ELFT>>(B))
-        if (S != &InputSection<ELFT>::Discarded)
-          if (S->isLive())
-            scanRelocs(*S);
+  for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
+    for (InputSectionBase<ELFT> *C : F->getSections()) {
+      if (discardInputSection(C))
+        continue;
+      if (auto *S = dyn_cast<InputSection<ELFT>>(C))
+    }
+  }
 
   std::vector<DefinedCommon<ELFT> *> CommonSymbols;
   std::vector<SharedSymbol<ELFT> *> SharedCopySymbols;
   for (auto &P : Symtab.getSymbols()) {
     SymbolBody *Body = P.second->Body;
     if (auto *U = dyn_cast<Undefined<ELFT>>(Body))
       if (!U->isWeak() && !U->canKeepUndefined())
         reportUndefined<ELFT>(Symtab, *Body);
 
template <class ELFT> void Writer<ELFT>::createSections() {
   }
   if (!Out<ELFT>::Got->empty())
     OutputSections.push_back(Out<ELFT>::Got);
   if (Out<ELFT>::GotPlt && !Out<ELFT>::GotPlt->empty())
     OutputSections.push_back(Out<ELFT>::GotPlt);
   if (!Out<ELFT>::Plt->empty())
     OutputSections.push_back(Out<ELFT>::Plt);
 
-  std::stable_sort(OutputSections.begin(), OutputSections.end(),
-                   compareOutputSections<ELFT>);
+  std::stable_sort(
+      OutputSections.begin(), OutputSections.end(),
+      [this, &RegularSections](OutputSectionBase<ELFT> *A,
+                               OutputSectionBase<ELFT> *B) -> bool {
+        if (!hasCustomSections())
+          return compareOutputSections(A, B);
+
+        // The following is a comparison of sections defined in linker script.
+        if (!RegularSections.count(A) || !RegularSections.count(B))
+          return compareOutputSections(A, B);
+
+        auto ItA = Config->OutputSections.find(A->getName());
+        auto ItEnd = std::end(Config->OutputSections);
+        if (ItA == ItEnd)
+          return compareOutputSections(A, B);
+        auto ItB = Config->OutputSections.find(B->getName());
+        if (ItB == ItEnd)
+          return compareOutputSections(A, B);
+
+        return std::distance(ItA, ItB) > 0;
+      });
 
   for (unsigned I = 0, N = OutputSections.size(); I < N; ++I)
     OutputSections[I]->SectionIndex = I + 1;
 
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Out<ELFT>::ShStrTab->add(Sec->getName());
 
   // Fill the DynStrTab early because Dynamic adds strings to
   // DynStrTab but .dynstr may appear before .dynamic.
void Writer<ELFT>::copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT> *From) {
   PH->p_offset = From->getFileOff();
   PH->p_vaddr = From->getVA();
   PH->p_paddr = From->getVA();
   PH->p_filesz = From->getSize();
   PH->p_memsz = From->getSize();
   PH->p_align = From->getAlign();
 }
 
+template <class ELFT> void Writer<ELFT>::parseSectionDescriptions() {
+  for (auto OutSec : Config->OutputSections)
+    for (auto InSec : OutSec.second.InputSections)
+      for (auto Name : InSec.Names)
+        InputToOutputSection[Name] = OutSec.second.Name;
+}
+
 template void lld::elf2::writeResult<ELF32LE>(SymbolTable<ELF32LE> *Symtab);
 template void lld::elf2::writeResult<ELF32BE>(SymbolTable<ELF32BE> *Symtab);
 template void lld::elf2::writeResult<ELF64LE>(SymbolTable<ELF64LE> *Symtab);
 template void lld::elf2::writeResult<ELF64BE>(SymbolTable<ELF64BE> *Symtab);

test/elf2/linkerscript-sections.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# Empty SECTIONS command.
+# RUN: echo "SECTIONS {}" > %t.script
+# RUN: ld.lld2 -o %t1 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t1 | \
+# RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
+
+# SECTIONS command with the same order as default.
+# RUN: echo "SECTIONS { \
+# RUN:          .text : { *(.text) } \
+# RUN:          .data : { *(.data) } }" \ > %t.script
+# RUN: ld.lld2 -o %t2 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t2 | \
+# RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
+
+#             Idx Name          Size
+# SEC-DEFAULT: 1 .text         0000000e {{[0-9a-f]*}} TEXT DATA
+# SEC-DEFAULT: 2 .data         00000020 {{[0-9a-f]*}} DATA
+# SEC-DEFAULT: 3 other         00000003 {{[0-9a-f]*}} DATA
+# SEC-DEFAULT: 4 .bss          00000002 {{[0-9a-f]*}} BSS
+# SEC-DEFAULT: 5 .shstrtab     00000002 {{[0-9a-f]*}}
+# SEC-DEFAULT: 6 .symtab       00000030 {{[0-9a-f]*}}
+# SEC-DEFAULT: 7 .shstrtab     00000032 {{[0-9a-f]*}}
+# SEC-DEFAULT: 8 .strtab       00000008 {{[0-9a-f]*}}
+
+# Sections are put in order specified in linker script.
+# .shstrtab affects only regular section from the input file.
+# RUN: echo "SECTIONS { \
+# RUN:          .bss : { *(.bss) } \
+# RUN:          other : { *(other) } \
+# RUN:          .shstrtab : { *(.shstrtab) } \
+# RUN:          .data : { *(.data) } \
+# RUN:          .text : { *(.text) } }" \ > %t.script
+# RUN: ld.lld2 -o %t3 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t3 | \
+# RUN:   FileCheck -check-prefix=SEC-ORDER %s
+
+#           Idx Name          Size
+# SEC-ORDER: 1 .bss          00000002 {{[0-9a-f]*}} BSS
+# SEC-ORDER: 2 other         00000003 {{[0-9a-f]*}} DATA
+# SEC-ORDER: 3 .shstrtab     00000002 {{[0-9a-f]*}}
+# SEC-ORDER: 4 .data         00000020 {{[0-9a-f]*}} DATA
+# SEC-ORDER: 5 .text         0000000e {{[0-9a-f]*}} TEXT DATA
+# SEC-ORDER: 6 .symtab       00000030 {{[0-9a-f]*}}
+# SEC-ORDER: 7 .shstrtab     00000032 {{[0-9a-f]*}}
+# SEC-ORDER: 8 .strtab       00000008 {{[0-9a-f]*}}
+
+# .text and .data have swapped names but proper sizes and types.
+# RUN: echo "SECTIONS { \
+# RUN:          .data : { *(.text) } \
+# RUN:          .text : { *(.data) } }" \ > %t.script
+# RUN: ld.lld2 -o %t4 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t4 | \
+# RUN:   FileCheck -check-prefix=SEC-SWAP-NAMES %s
+
+#                Idx Name          Size
+# SEC-SWAP-NAMES: 1 .data         0000000e {{[0-9a-f]*}} TEXT DATA
+# SEC-SWAP-NAMES: 2 .text         00000020 {{[0-9a-f]*}} DATA
+# SEC-SWAP-NAMES: 3 other         00000003 {{[0-9a-f]*}} DATA
+# SEC-SWAP-NAMES: 4 .bss          00000002 {{[0-9a-f]*}} BSS
+# SEC-SWAP-NAMES: 5 .shstrtab     00000002 {{[0-9a-f]*}}
+# SEC-SWAP-NAMES: 6 .symtab       00000030 {{[0-9a-f]*}}
+# SEC-SWAP-NAMES: 7 .shstrtab     00000032 {{[0-9a-f]*}}
+# SEC-SWAP-NAMES: 8 .strtab       00000008 {{[0-9a-f]*}}
+
+# .shstrtab from the input object file is discarded.
+# RUN: echo "SECTIONS { \
+# RUN:          /DISCARD/ : { *(.shstrtab) } }" \ > %t.script
+# RUN: ld.lld2 -o %t5 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t5 | \
+# RUN:   FileCheck -check-prefix=SEC-DISCARD %s
+
+#             Idx Name          Size
+# SEC-DISCARD: 1 .text         0000000e {{[0-9a-f]*}} TEXT DATA
+# SEC-DISCARD: 2 .data         00000020 {{[0-9a-f]*}} DATA
+# SEC-DISCARD: 3 other         00000003 {{[0-9a-f]*}} DATA
+# SEC-DISCARD: 4 .bss          00000002 {{[0-9a-f]*}} BSS
+# SEC-DISCARD: 5 .symtab       00000030 {{[0-9a-f]*}}
+# SEC-DISCARD: 6 .shstrtab     00000032 {{[0-9a-f]*}}
+# SEC-DISCARD: 7 .strtab       00000008 {{[0-9a-f]*}}
+
+# Multiple SECTIONS command specifying additional input section descriptions
+# for the same output section description - input sections are merged into
+# one output section.
+# RUN: echo "SECTIONS { \
+# RUN:          .text : { *(.text) } \
+# RUN:          .data : { *(.data) } } \
+# RUN:       SECTIONS { \
+# RUN:          .data : { *(other) } }" \ > %t.script
+# RUN: ld.lld2 -o %t6 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t6 | \
+# RUN:   FileCheck -check-prefix=SEC-MULTI %s
+
+#           Idx Name          Size
+# SEC-MULTI: 1 .text         0000000e {{[0-9a-f]*}} TEXT DATA
+# SEC-MULTI: 2 .data         00000023 {{[0-9a-f]*}} DATA
+# SEC-MULTI: 3 .bss          00000002 {{[0-9a-f]*}} BSS
+# SEC-MULTI: 4 .shstrtab     00000002 {{[0-9a-f]*}}
+# SEC-MULTI: 5 .symtab       00000030 {{[0-9a-f]*}}
+# SEC-MULTI: 6 .shstrtab     0000002c {{[0-9a-f]*}}
+# SEC-MULTI: 7 .strtab       00000008 {{[0-9a-f]*}}
+
+# No bounding symbols added for custom sections with valid C-identifier
+# names if section is present in the SECTIONS command.
+# RUN: echo "SECTIONS { \
+# RUN:          other : { *(other) } }" \ > %t.script
+# RUN: ld.lld2 -o %t7 --script %t.script %t -u __start_other -u __stop_other
+# RUN: llvm-objdump -t %t7 | \
+# RUN:   FileCheck -check-prefix=SEC-NO-BOUND-SYM %s
+
+# SEC-NO-BOUND-SYM: 0000000000000000 *UND* 00000000 {{.*}} __start_other
+# SEC-NO-BOUND-SYM: 0000000000000000 *UND* 00000000 {{.*}} __stop_other
+
+# Bounding symbols are added for custom sections with valid C-identifier
+# names if section is not present in the SECTIONS command.
+# RUN: echo "SECTIONS { \
+# RUN:          .data : { *(.data) } }" \ > %t.script
+# RUN: ld.lld2 -o %t8 --script %t.script %t -u __start_other -u __stop_other
+# RUN: llvm-objdump -t %t8 | \
+# RUN:   FileCheck -check-prefix=SEC-HAS-BOUND-SYM %s
+
+# SEC-HAS-BOUND-SYM: {{[0-9a-f]*}} other 00000000 {{.*}} __start_other
+# SEC-HAS-BOUND-SYM: {{[0-9a-f]*}} other 00000000 {{.*}} __stop_other
+
+.globl _start;
+_start:
+    mov $60, %rax
+    mov $42, %rdi
+
+.section .data,"aw"
+.quad 10, 10, 20, 20
+.section other,"aw"
+.short 10
+.byte 20
+.section .shstrtab,""
+.short 20
+.section .bss,"",@nobits
+.short 0