demo

ELF/Config.h

struct Configuration {
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef LtoAAPipeline;
   llvm::StringRef LtoNewPmPasses;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
+  llvm::StringRef SortSection;
   llvm::StringRef Sysroot;
   std::string RPath;
   std::vector<VersionDefinition> VersionDefinitions;
   std::vector<llvm::StringRef> AuxiliaryList;
   std::vector<llvm::StringRef> DynamicList;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
   std::vector<SymbolVersion> VersionScriptGlobals;

ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
   Config->Entry = getString(Args, OPT_entry);
   Config->Fini = getString(Args, OPT_fini, "_fini");
   Config->Init = getString(Args, OPT_init, "_init");
   Config->LtoAAPipeline = getString(Args, OPT_lto_aa_pipeline);
   Config->LtoNewPmPasses = getString(Args, OPT_lto_newpm_passes);
   Config->OutputFile = getString(Args, OPT_o);
   Config->SoName = getString(Args, OPT_soname);
+  Config->SortSection = getString(Args, OPT_sort_section);
   Config->Sysroot = getString(Args, OPT_sysroot);
 
   Config->Optimize = getInteger(Args, OPT_O, 1);
   Config->LtoO = getInteger(Args, OPT_lto_O, 2);
   if (Config->LtoO > 3)
     error("invalid optimization level for LTO: " + getString(Args, OPT_lto_O));
   Config->LtoJobs = getInteger(Args, OPT_lto_jobs, 1);
   if (Config->LtoJobs == 0)

ELF/LinkerScript.h

struct OutputSectionCommand : BaseCommand {
   Expr LmaExpr;
   Expr SubalignExpr;
   std::vector<std::unique_ptr<BaseCommand>> Commands;
   std::vector<StringRef> Phdrs;
   std::vector<uint8_t> Filler;
   ConstraintKind Constraint = ConstraintKind::NoConstraint;
 };
 
-enum SortKind { SortNone, SortByPriority, SortByName, SortByAlignment };
+enum SortKind { SortNone = 1, SortByPriority, SortByName, SortByAlignment };
 
 struct InputSectionDescription : BaseCommand {
   InputSectionDescription(StringRef FilePattern)
       : BaseCommand(InputSectionKind),
         FileRe(compileGlobPatterns({FilePattern})) {}
   static bool classof(const BaseCommand *C);
   llvm::Regex FileRe;
-  SortKind SortOuter = SortNone;
-  SortKind SortInner = SortNone;
+  unsigned SortOuter = 0;
+  unsigned SortInner = 0;
   llvm::Regex ExcludedFileRe;
   llvm::Regex SectionRe;
 };
 
 struct AssertCommand : BaseCommand {
   AssertCommand(Expr E) : BaseCommand(AssertKind), Expression(E) {}
   static bool classof(const BaseCommand *C);
   Expr Expression;

ELF/LinkerScript.cpp

if (auto *OutCmd = dyn_cast<SymbolAssignment>(Base.get())) {
       continue;
     }
 
     auto *Cmd = cast<InputSectionDescription>(Base.get());
     std::vector<InputSectionBase<ELFT> *> V = getInputSections(Cmd);
     if (!matchConstraints<ELFT>(V, OutCmd.Constraint))
       continue;
     if (Cmd->SortInner)
-      std::stable_sort(V.begin(), V.end(), getComparator(Cmd->SortInner));
+      std::stable_sort(V.begin(), V.end(),
+                       getComparator((SortKind)Cmd->SortInner));
     if (Cmd->SortOuter)
-      std::stable_sort(V.begin(), V.end(), getComparator(Cmd->SortOuter));
+      std::stable_sort(V.begin(), V.end(),
+                       getComparator((SortKind)Cmd->SortOuter));
 
     // Add all input sections corresponding to rule 'Cmd' to
     // resulting vector. We do not add duplicate input sections.
     for (InputSectionBase<ELFT> *S : V)
       if (SectionIndex.insert(S).second)
         Ret.push_back(S);
   }
   return Ret;
private:
   std::vector<uint8_t> readFill();
   OutputSectionCommand *readOutputSectionDescription(StringRef OutSec);
   std::vector<uint8_t> readOutputSectionFiller(StringRef Tok);
   std::vector<StringRef> readOutputSectionPhdrs();
   InputSectionDescription *readInputSectionDescription(StringRef Tok);
   Regex readFilePatterns();
   InputSectionDescription *readInputSectionRules(StringRef FilePattern);
   unsigned readPhdrType();
-  SortKind readSortKind();
+  unsigned readSortKind();
   SymbolAssignment *readProvideHidden(bool Provide, bool Hidden);
   SymbolAssignment *readProvideOrAssignment(StringRef Tok, bool MakeAbsolute);
   void readSort();
   Expr readAssert();
 
   Expr readExpr();
   Expr readExpr1(Expr Lhs, int MinPrec);
   Expr readPrimary();

 
 Regex ScriptParser::readFilePatterns() {
   std::vector<StringRef> V;
   while (!Error && !skip(")"))
     V.push_back(next());
   return compileGlobPatterns(V);
 }
 
-SortKind ScriptParser::readSortKind() {
+unsigned ScriptParser::readSortKind() {
   if (skip("SORT") || skip("SORT_BY_NAME"))
     return SortByName;
   if (skip("SORT_BY_ALIGNMENT"))
     return SortByAlignment;
+  if (skip("SORT_NONE"))
+    return SortNone;
   if (skip("SORT_BY_INIT_PRIORITY"))
     return SortByPriority;
+  return 0;
+}
+
+static SortKind getSortKind() {
+  if (Config->SortSection == "alignment")
+    return SortByAlignment;
+  if (Config->SortSection == "name")
+    return SortByName;
+  if (!Config->SortSection.empty())
+    warning("unknown --sort-section rule ignored: " + Config->SortSection);
   return SortNone;
 }
 
+static void applySortKind(InputSectionDescription *Cmd) {
+  // `SORT_NONE' disables section sorting by ignoring the command line
+  // section sorting option.
+  if (Cmd->SortOuter == SortNone) {
+    Cmd->SortOuter = 0;
+    return;
+  }
+
+  if (Cmd->SortOuter != SortNone) {
+    // If the section sorting command in linker script is nested, the command
+    // line option will be ignored.
+    if (Cmd->SortInner != SortNone)
+      return;
+    // If the section sorting command in linker script isn't nested, the
+    // command line option will make the section sorting command to be treated
+    // as nested sorting command.
+    Cmd->SortInner = getSortKind();
+    return;
+  }
+  // If sorting rule not specified, use command line option.
+  Cmd->SortOuter = getSortKind();
+}
+
 InputSectionDescription *
 ScriptParser::readInputSectionRules(StringRef FilePattern) {
   auto *Cmd = new InputSectionDescription(FilePattern);
   expect("(");
 
   // Read EXCLUDE_FILE().
   if (skip("EXCLUDE_FILE")) {
     expect("(");
     Cmd->ExcludedFileRe = readFilePatterns();
   }
 
   // Read SORT().
-  if (SortKind K1 = readSortKind()) {
+  if (unsigned K1 = readSortKind()) {
     Cmd->SortOuter = K1;
     expect("(");
-    if (SortKind K2 = readSortKind()) {
+    if (unsigned K2 = readSortKind()) {
       Cmd->SortInner = K2;
       expect("(");
       Cmd->SectionRe = readFilePatterns();
       expect(")");
     } else {
       Cmd->SectionRe = readFilePatterns();
     }
     expect(")");
+    applySortKind(Cmd);
     return Cmd;
   }
 
+  applySortKind(Cmd);
   Cmd->SectionRe = readFilePatterns();
   return Cmd;
 }
 
 InputSectionDescription *
 ScriptParser::readInputSectionDescription(StringRef Tok) {
   // Input section wildcard can be surrounded by KEEP.
   // https://sourceware.org/binutils/docs/ld/Input-Section-Keep.html#Input-Section-Keep

ELF/Options.td

 
 def section_start: S<"section-start">, MetaVarName<"<address>">,
   HelpText<"Set address of section">;
 
 def shared: F<"shared">, HelpText<"Build a shared object">;
 
 def soname: J<"soname=">, HelpText<"Set DT_SONAME">;
 
+def sort_section: S<"sort-section">, HelpText<"Specifies sections sorting rule when linkerscript is used">;
+
 def start_lib: F<"start-lib">,
   HelpText<"Start a grouping of objects that should be treated as if they were together in an archive">;
 
 def strip_all: F<"strip-all">, HelpText<"Strip all symbols">;
 
 def strip_debug: F<"strip-debug">, HelpText<"Strip debugging information">;
 
 def sysroot: J<"sysroot=">, HelpText<"Set the system root">;

test/ELF/linkerscript/sort-nested.s

 # RUN: ld.lld -o %t2 --script %t2.script %t1.o %t2.o
 # RUN: llvm-objdump -s %t2 | FileCheck -check-prefix=SORTED_NA %s
 # SORTED_NA: Contents of section .aaa:
 # SORTED_NA:   01000000 00000000 00000000 00000000
 # SORTED_NA:   11000000 00000000 22000000 00000000
 # SORTED_NA:   02000000 00000000 00000000 00000000
 # SORTED_NA:   55000000 00000000
 
+## If the section sorting command in linker script isn't nested, the
+## command line option will make the section sorting command to be treated
+## as nested sorting command.
+# RUN: echo "SECTIONS { .aaa : { *(SORT_BY_ALIGNMENT(.aaa.*)) } }" > %t3.script
+# RUN: ld.lld --sort-section name -o %t3 --script %t3.script %t1.o %t2.o
+# RUN: llvm-objdump -s %t3 | FileCheck -check-prefix=SORTED_AN %s
+# RUN: echo "SECTIONS { .aaa : { *(SORT_BY_NAME(.aaa.*)) } }" > %t4.script
+# RUN: ld.lld --sort-section alignment -o %t4 --script %t4.script %t1.o %t2.o
+# RUN: llvm-objdump -s %t4 | FileCheck -check-prefix=SORTED_NA %s
+
 .global _start
 _start:
  nop
 
 .section .aaa.1, "a"
 .align 32
 .quad 1
 
 .section .aaa.2, "a"
 .align 2
 .quad 2
 
 .section .aaa.5, "a"
 .align 16
 .quad 0x55

test/ELF/linkerscript/sort.s

 # SORTED_ALIGNMENT-NEXT:  0130 00000000 00000000 00000000 00000000
 # SORTED_ALIGNMENT-NEXT:  0140 11000000 00000000 00000000 00000000
 # SORTED_ALIGNMENT-NEXT:  0150 04000000 00000000 00000000 00000000
 # SORTED_ALIGNMENT-NEXT:  0160 22000000 00000000 03000000 00000000
 # SORTED_ALIGNMENT-NEXT:  0170 33000000 00000000 02000000 00000000
 # SORTED_ALIGNMENT-NEXT:  0180 44000000 00000000 01000000 00000000
 # SORTED_ALIGNMENT-NEXT:  0190 55000000 00000000
 
+## SORT_NONE itself does not sort anything.
+# RUN: echo "SECTIONS { .aaa : { *(SORT_NONE(.aaa.*)) } }" > %t6.script
+# RUN: ld.lld -o %t7 --script %t6.script %t2.o %t1.o
+# RUN: llvm-objdump -s %t7 | FileCheck -check-prefix=UNSORTED %s
+
+## Check --sort-section alignment option.
+# RUN: echo "SECTIONS { .aaa : { *(.aaa.*) } }" > %t7.script
+# RUN: ld.lld --sort-section alignment -o %t8 --script %t7.script %t1.o %t2.o
+# RUN: llvm-objdump -s %t8 | FileCheck -check-prefix=SORTED_ALIGNMENT %s
+
+## Check --sort-section name option.
+# RUN: echo "SECTIONS { .aaa : { *(.aaa.*) } }" > %t8.script
+# RUN: ld.lld --sort-section name -o %t9 --script %t8.script %t1.o %t2.o
+# RUN: llvm-objdump -s %t9 | FileCheck -check-prefix=SORTED_B %s
+
+## SORT_NONE disables the --sort-section.
+# RUN: echo "SECTIONS { .aaa : { *(SORT_NONE(.aaa.*)) } }" > %t9.script
+# RUN: ld.lld --sort-section name -o %t10 --script %t9.script %t2.o %t1.o
+# RUN: llvm-objdump -s %t10 | FileCheck -check-prefix=UNSORTED %s
+
+
 .global _start
 _start:
  nop
 
 .section .aaa.5, "a"
 .align 32
 .quad 5