Index: ELF/LinkerScript.h =================================================================== --- ELF/LinkerScript.h +++ ELF/LinkerScript.h @@ -99,18 +99,25 @@ // This struct represents one section match pattern in SECTIONS() command. // It can optionally have negative match pattern for EXCLUDED_FILE command. +// Also it may be surrounded with SORT() command, so contains sorting rules. struct SectionPattern { - SectionPattern(llvm::Regex &&Re1, llvm::Regex &&Re2) + SectionPattern(llvm::Regex &&Re1, llvm::Regex &&Re2, SortSectionPolicy So1, + SortSectionPolicy So2) : ExcludedFileRe(std::forward(Re1)), - SectionRe(std::forward(Re2)) {} + SectionRe(std::forward(Re2)), SortOuter(So1), + SortInner(So2) {} SectionPattern(SectionPattern &&Other) { std::swap(ExcludedFileRe, Other.ExcludedFileRe); std::swap(SectionRe, Other.SectionRe); + std::swap(SortOuter, Other.SortOuter); + std::swap(SortInner, Other.SortInner); } llvm::Regex ExcludedFileRe; llvm::Regex SectionRe; + SortSectionPolicy SortOuter = SortSectionPolicy::Default; + SortSectionPolicy SortInner = SortSectionPolicy::Default; }; struct InputSectionDescription : BaseCommand { @@ -119,8 +126,6 @@ FileRe(compileGlobPatterns({FilePattern})) {} static bool classof(const BaseCommand *C); llvm::Regex FileRe; - SortSectionPolicy SortOuter = SortSectionPolicy::Default; - SortSectionPolicy SortInner = SortSectionPolicy::Default; // Input sections that matches at least one of SectionPatterns // will be associated with this InputSectionDescription. Index: ELF/LinkerScript.cpp =================================================================== --- ELF/LinkerScript.cpp +++ ELF/LinkerScript.cpp @@ -156,12 +156,21 @@ }); } +static void sortSections(std::vector::iterator S, + std::vector::iterator E, + SortSectionPolicy K) { + if (K != SortSectionPolicy::Default && K != SortSectionPolicy::None) + std::stable_sort(S, E, getComparator(K)); +} + // Compute and remember which sections the InputSectionDescription matches. template void LinkerScript::computeInputSections(InputSectionDescription *I) { // Collects all sections that satisfy constraints of I // and attach them to I. for (SectionPattern &Pat : I->SectionPatterns) { + size_t SizeBefore = I->Sections.size(); + for (ObjectFile *F : Symtab::X->getObjectFiles()) { StringRef Filename = sys::path::filename(F->getName()); if (!I->FileRe.match(Filename) || Pat.ExcludedFileRe.match(Filename)) @@ -173,15 +182,28 @@ if (Pat.SectionRe.match("COMMON")) I->Sections.push_back(CommonInputSection::X); } - } - // Sort for SORT() commands. - if (I->SortInner != SortSectionPolicy::Default) - std::stable_sort(I->Sections.begin(), I->Sections.end(), - getComparator(I->SortInner)); - if (I->SortOuter != SortSectionPolicy::Default) - std::stable_sort(I->Sections.begin(), I->Sections.end(), - getComparator(I->SortOuter)); + // Sort sections as instructed by SORT-family commands and --sort-section + // option. Because SORT-family commands can be nested at most two depth + // (e.g. SORT_BY_NAME(SORT_BY_ALIGNMENT(.text.*))) and because the command + // line option is respected even if a SORT command is given, the exact + // behavior we have here is a bit complicated. Here are the rules. + // + // 1. If two SORT commands are given, --sort-section is ignored. + // 2. If one SORT command is given, and if it is not SORT_NONE, + // --sort-section is handled as an inner SORT command. + // 3. If one SORT command is given, and if it is SORT_NONE, don't sort. + // 4. If no SORT command is given, sort according to --sort-section. + auto ItS = I->Sections.begin() + SizeBefore; + auto ItE = I->Sections.end(); + if (Pat.SortOuter != SortSectionPolicy::None) { + if (Pat.SortInner == SortSectionPolicy::Default) + sortSections(ItS, ItE, Config->SortSection); + else + sortSections(ItS, ItE, Pat.SortInner); + sortSections(ItS, ItE, Pat.SortOuter); + } + } // We do not add duplicate input sections, so mark them with a dummy output // section for now. @@ -739,7 +761,9 @@ std::vector readOutputSectionPhdrs(); InputSectionDescription *readInputSectionDescription(StringRef Tok); Regex readFilePatterns(); - void readSectionExcludes(InputSectionDescription *Cmd); + void readInputSectionsList(std::vector &Out, + SortSectionPolicy K1, SortSectionPolicy K2); + bool readSortedInputSectionsList(std::vector &Out); InputSectionDescription *readInputSectionRules(StringRef FilePattern); unsigned readPhdrType(); SortSectionPolicy readSortKind(); @@ -1035,27 +1059,6 @@ return SortSectionPolicy::Default; } -static void selectSortKind(InputSectionDescription *Cmd) { - if (Cmd->SortOuter == SortSectionPolicy::None) { - Cmd->SortOuter = SortSectionPolicy::Default; - return; - } - - if (Cmd->SortOuter != SortSectionPolicy::Default) { - // If the section sorting command in linker script is nested, the command - // line option will be ignored. - if (Cmd->SortInner != SortSectionPolicy::Default) - 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 = Config->SortSection; - return; - } - // If sorting rule not specified, use command line option. - Cmd->SortOuter = Config->SortSection; -} - // Method reads a list of sequence of excluded files and section globs given in // a following form: ((EXCLUDE_FILE(file_pattern+))? section_pattern+)+ // Example: *(.foo.1 EXCLUDE_FILE (*a.o) .foo.2 EXCLUDE_FILE (*b.o) .foo.3) @@ -1063,21 +1066,23 @@ // * Include .foo.1 from every file. // * Include .foo.2 from every file but a.o // * Include .foo.3 from every file but b.o -void ScriptParser::readSectionExcludes(InputSectionDescription *Cmd) { +void ScriptParser::readInputSectionsList(std::vector &Out, + SortSectionPolicy SortOut, + SortSectionPolicy SortIn) { Regex ExcludeFileRe; std::vector V; while (!Error) { - if (skip(")")) { - Cmd->SectionPatterns.push_back( - {std::move(ExcludeFileRe), compileGlobPatterns(V)}); + if (peek() == ")") { + Out.push_back( + {std::move(ExcludeFileRe), compileGlobPatterns(V), SortOut, SortIn}); return; } if (skip("EXCLUDE_FILE")) { if (!V.empty()) { - Cmd->SectionPatterns.push_back( - {std::move(ExcludeFileRe), compileGlobPatterns(V)}); + Out.push_back({std::move(ExcludeFileRe), compileGlobPatterns(V), + SortOut, SortIn}); V.clear(); } @@ -1090,32 +1095,44 @@ } } +bool ScriptParser::readSortedInputSectionsList( + std::vector &Out) { + SortSectionPolicy SortOut = readSortKind(); + if (SortOut == SortSectionPolicy::Default) + return false; + + expect("("); + SortSectionPolicy SortIn = readSortKind(); + if (SortIn != SortSectionPolicy::Default) { + expect("("); + readInputSectionsList(Out, SortOut, SortIn); + expect(")"); + } else { + readInputSectionsList(Out, SortOut, SortIn); + } + return true; +} + +// Section pattern grammar can have complex expressions, for example: +// *(SORT(.foo.* EXCLUDE_FILE (*file1.o) .bar.*) .bar.* SORT(.zed.*)) +// Generally is a sequence of globs and excludes that may be wrapped in a SORT() +// commands, like: SORT(glob0) glob1 glob2 SORT(glob4) +// This methods handles wrapping sequences of excluded files and section globs +// into SORT() if that needed and reads them all. InputSectionDescription * ScriptParser::readInputSectionRules(StringRef FilePattern) { auto *Cmd = new InputSectionDescription(FilePattern); expect("("); - // Read SORT(). - SortSectionPolicy K1 = readSortKind(); - if (K1 != SortSectionPolicy::Default) { - Cmd->SortOuter = K1; - expect("("); - SortSectionPolicy K2 = readSortKind(); - if (K2 != SortSectionPolicy::Default) { - Cmd->SortInner = K2; - expect("("); - Cmd->SectionPatterns.push_back({Regex(), readFilePatterns()}); + while (!HasError && !skip(")")) { + if (readSortedInputSectionsList(Cmd->SectionPatterns)) { expect(")"); - } else { - Cmd->SectionPatterns.push_back({Regex(), readFilePatterns()}); + continue; } - expect(")"); - selectSortKind(Cmd); - return Cmd; - } - selectSortKind(Cmd); - readSectionExcludes(Cmd); + readInputSectionsList(Cmd->SectionPatterns, SortSectionPolicy::Default, + SortSectionPolicy::Default); + } return Cmd; } Index: test/ELF/linkerscript/sort2.s =================================================================== --- test/ELF/linkerscript/sort2.s +++ test/ELF/linkerscript/sort2.s @@ -0,0 +1,39 @@ +# REQUIRES: x86 +# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %tfile1.o + +# RUN: echo "SECTIONS { .abc : { *(SORT(.foo.*) .bar.*) } }" > %t1.script +# RUN: ld.lld -o %t1 --script %t1.script %tfile1.o +# RUN: llvm-objdump -s %t1 | FileCheck %s + +# CHECK: Contents of section .abc: +# CHECK: 0120 01000000 00000000 02000000 00000000 +# CHECK: 0130 03000000 00000000 04000000 00000000 +# CHECK: 0140 06000000 00000000 05000000 00000000 + +# RUN: echo "SECTIONS { \ +# RUN: .abc : { *(SORT(.foo.* EXCLUDE_FILE (*file1.o) .bar.*) .bar.*) } \ +# RUN: }" > %t2.script +# RUN: ld.lld -o %t2 --script %t2.script %tfile1.o +# RUN: llvm-objdump -s %t2 | FileCheck %s + +.text +.globl _start +_start: + +.section .foo.2,"a" + .quad 2 + +.section .foo.3,"a" + .quad 3 + +.section .foo.1,"a" + .quad 1 + +.section .bar.4,"a" + .quad 4 + +.section .bar.6,"a" + .quad 6 + +.section .bar.5,"a" + .quad 5