[ELF] - Linkerscript: implemented SORT_BY_INIT_PRIORITY.

[grimar]

Summary

This is PR30386,

SORT_BY_INIT_PRIORITY is a keyword can be used to sort sections by numerical value of the
GCC init_priority attribute encoded in the section name.

[ruiu]

LGTM with a few nits.

ELF/LinkerScript.cpp

113 ↗

(On Diff #71502)

comparePriority

977 ↗

(On Diff #71502)

SortByPriority

test/ELF/linkerscript/sort-init.s

25 ↗

(On Diff #71502)

Remove trailing blank line.

lld/trunk/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, SortByName, SortByAlignment };
+enum SortKind { SortNone, 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;

lld/trunk/ELF/LinkerScript.cpp

 }
 
 static bool fileMatches(const InputSectionDescription *Desc,
                         StringRef Filename) {
   return const_cast<Regex &>(Desc->FileRe).match(Filename) &&
          !const_cast<Regex &>(Desc->ExcludedFileRe).match(Filename);
 }
 
+static bool comparePriority(InputSectionData *A, InputSectionData *B) {
+  return getPriority(A->Name) < getPriority(B->Name);
+}
+
 static bool compareName(InputSectionData *A, InputSectionData *B) {
   return A->Name < B->Name;
 }
 
 static bool compareAlignment(InputSectionData *A, InputSectionData *B) {
   // ">" is not a mistake. Larger alignments are placed before smaller
   // alignments in order to reduce the amount of padding necessary.
   // This is compatible with GNU.
   return A->Alignment > B->Alignment;
 }
 
 static std::function<bool(InputSectionData *, InputSectionData *)>
 getComparator(SortKind K) {
+  if (K == SortByPriority)
+    return comparePriority;
   if (K == SortByName)
     return compareName;
   return compareAlignment;
 }
 
 static bool checkConstraint(uint64_t Flags, ConstraintKind Kind) {
   bool RO = (Kind == ConstraintKind::ReadOnly);
   bool RW = (Kind == ConstraintKind::ReadWrite);
Regex ScriptParser::readFilePatterns() {
   return compileGlobPatterns(V);
 }
 
 SortKind ScriptParser::readSortKind() {
   if (skip("SORT") || skip("SORT_BY_NAME"))
     return SortByName;
   if (skip("SORT_BY_ALIGNMENT"))
     return SortByAlignment;
+  if (skip("SORT_BY_INIT_PRIORITY"))
+    return SortByPriority;
   return SortNone;
 }
 
 InputSectionDescription *
 ScriptParser::readInputSectionRules(StringRef FilePattern) {
   auto *Cmd = new InputSectionDescription(FilePattern);
   expect("(");
 

lld/trunk/ELF/OutputSections.cpp

 void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   assert(C->Live);
   auto *S = cast<InputSection<ELFT>>(C);
   Sections.push_back(S);
   S->OutSec = this;
   this->updateAlignment(S->Alignment);
 }
 
-// If an input string is in the form of "foo.N" where N is a number,
-// return N. Otherwise, returns 65536, which is one greater than the
-// lowest priority.
-static int getPriority(StringRef S) {
-  size_t Pos = S.rfind('.');
-  if (Pos == StringRef::npos)
-    return 65536;
-  int V;
-  if (S.substr(Pos + 1).getAsInteger(10, V))
-    return 65536;
-  return V;
-}
-
 // This function is called after we sort input sections
 // and scan relocations to setup sections' offsets.
 template <class ELFT> void OutputSection<ELFT>::assignOffsets() {
   uintX_t Off = this->Header.sh_size;
   for (InputSection<ELFT> *S : Sections) {
     Off = alignTo(Off, S->Alignment);
     S->OutSecOff = Off;
     Off += S->getSize();

lld/trunk/ELF/Strings.h

 
 #include "lld/Core/LLVM.h"
 #include "llvm/Support/Regex.h"
 #include <vector>
 
 namespace lld {
 namespace elf {
 llvm::Regex compileGlobPatterns(ArrayRef<StringRef> V);
+int getPriority(StringRef S);
 bool hasWildcard(StringRef S);
 std::vector<uint8_t> parseHex(StringRef S);
 bool isValidCIdentifier(StringRef S);
 StringRef unquote(StringRef S);
 
 // Returns a demangled C++ symbol name. If Name is not a mangled
 // name or the system does not provide __cxa_demangle function,
 // it returns an unmodified string.
 std::string demangle(StringRef Name);
 }
 }
 
 #endif

lld/trunk/ELF/Strings.cpp

 #include "llvm/Config/config.h"
 #include "llvm/Demangle/Demangle.h"
 #include <algorithm>
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::elf;
 
+// If an input string is in the form of "foo.N" where N is a number,
+// return N. Otherwise, returns 65536, which is one greater than the
+// lowest priority.
+int elf::getPriority(StringRef S) {
+  size_t Pos = S.rfind('.');
+  if (Pos == StringRef::npos)
+    return 65536;
+  int V;
+  if (S.substr(Pos + 1).getAsInteger(10, V))
+    return 65536;
+  return V;
+}
+
 bool elf::hasWildcard(StringRef S) {
   return S.find_first_of("?*[") != StringRef::npos;
 }
 
 StringRef elf::unquote(StringRef S) {
   if (!S.startswith("\""))
     return S;
   return S.substr(1, S.size() - 2);

lld/trunk/test/ELF/linkerscript/sort-init.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+# RUN: echo "SECTIONS { .init_array : { *(SORT_BY_INIT_PRIORITY(.init_array.*)) } }" > %t1.script
+# RUN: ld.lld --script %t1.script %t1.o -o %t2
+# RUN: llvm-objdump -s %t2 | FileCheck %s
+
+# CHECK:      Contents of section .init_array:
+# CHECK-NEXT: 03020000 00000000 010405
+
+.globl _start
+_start:
+  nop
+
+.section .init_array, "aw", @init_array
+  .align 8
+  .byte 1
+.section .init_array.100, "aw", @init_array
+  .long 2
+.section .init_array.5, "aw", @init_array
+  .byte 3
+.section .init_array, "aw", @init_array
+  .byte 4
+.section .init_array, "aw", @init_array
+  .byte 5