[LinkerScript] Support EXCLUDE_FILE inside KEEP

[davide]

Summary

We can support also EXCLUDE_FILE as top-level directive, but I'd rather do that in a separate patch.

[davide]

Sorry, I updated a stale version of the tests. I'll update a new version of the tests soon.

[ruiu]

ELF/LinkerScript.cpp

82

Maybe we should return std::vector<std::pair<StringRef, InputSectionDescription *>> instead.

99–100

I'd pass InputSectionDescription * instead.

686

The grammar of KEEP is

KEEP := "KEEP" "(" FILE_PATTERN ")"
FILE_PATTERN := GLOB+ "(" "EXCLUDE_FILE" "(" GLOB+ ")" GLOB+ ")"
              |  GLOB+ "(" GLOB+ ")" GLOB+ ")"

where GLOB is any glob pattern. FILE_PATTERN is the same as one of the SECTIONS subcommands.

So I think you want to define readFilePattern and use it both from this function and from readOutputSectionDescription.

694–695

if (skip("EXCLUDE_FILE")) {

[davide]

Rui's comments.

[ruiu]

ELF/LinkerScript.cpp

687

How about changing the return type of the function to InputSectionDescription * so that you don't need to pass OutputSectionCommand * to this function?

699

KeptSections shouldn't be updated in this function because this function should be agnostic of the context.

712

If you change the return type, then you can write

InputSectionCommand *InCmd = readFilePattern();
Opt.KeptSections.insert(Opt.KeptSections.end(), InCmd.Patterns.begin(), InCmd.Patterns.end());
Cmd.emplace_back(InCmd);

[davide]

ELF/LinkerScript.cpp

699

So maybe we can pass an argument std::vector<StringRef> to collect the list of tokens and use that in readKeep() ?

[ruiu]

ELF/LinkerScript.cpp

699

File pattern consists of file names followed by section names, so std::vector<StringRef> is not enough because it is unstructured. Did you read my comment at line 694? Didn't it work?

[ruiu]

LGTM with a nit.

ELF/LinkerScript.cpp

716

push_back(std::move(InCmd))

[grimar]

lld/trunk/test/ELF/linkerscript/linkerscript-excludefile.s

8 ↗

(On Diff #65644)

excessive space at the end

14 ↗

(On Diff #65644)

I think you want to use CHECK-NEXT here.

32 ↗

(On Diff #65644)

Ditto.

ELF/LinkerScript.h

struct OutputSectionCommand : BaseCommand {
   std::vector<StringRef> Phdrs;
   std::vector<uint8_t> Filler;
   ConstraintKind Constraint = ConstraintKind::NoConstraint;
 };
 
 struct InputSectionDescription : BaseCommand {
   InputSectionDescription() : BaseCommand(InputSectionKind) {}
   static bool classof(const BaseCommand *C);
+  std::vector<StringRef> ExcludedFiles;
   std::vector<StringRef> Patterns;
 };
 
 struct PhdrsCommand {
   StringRef Name;
   unsigned Type;
   bool HasFilehdr;
   bool HasPhdrs;
public:
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses(ArrayRef<OutputSectionBase<ELFT> *> S);
   int compareSections(StringRef A, StringRef B);
   void addScriptedSymbols();
   bool hasPhdrsCommands();
 
 private:
-  std::vector<std::pair<StringRef, ArrayRef<StringRef>>> getSectionMap();
+  std::vector<std::tuple<StringRef, ArrayRef<StringRef>, ArrayRef<StringRef>>>
+  getSectionMap();
 
   std::vector<InputSectionBase<ELFT> *>
-  getInputSections(ArrayRef<StringRef> Patterns);
+  getInputSections(ArrayRef<StringRef> Patterns,
+                   ArrayRef<StringRef> ExcludedFiles);
 
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   std::vector<OutputSectionBase<ELFT> *>
   filter(std::vector<OutputSectionBase<ELFT> *> &Sections);
 
   int getSectionIndex(StringRef Name);

ELF/LinkerScript.cpp

static bool match(ArrayRef<StringRef> Patterns, StringRef S) {
   return false;
 }
 
 // Create a vector of (<output section name>, <input section name patterns>).
 // For example, if a returned vector contains (".text" (".foo.*" ".bar.*")),
 // input sections start with ".foo." or ".bar." should be added to
 // ".text" section.
 template <class ELFT>
-std::vector<std::pair<StringRef, ArrayRef<StringRef>>>
+std::vector<std::tuple<StringRef, ArrayRef<StringRef>, ArrayRef<StringRef>>>
 LinkerScript<ELFT>::getSectionMap() {
-  std::vector<std::pair<StringRef, ArrayRef<StringRef>>> Ret;
+  std::vector<std::tuple<StringRef, ArrayRef<StringRef>, ArrayRef<StringRef>>>
+      Ret;
 
   for (const std::unique_ptr<BaseCommand> &Base1 : Opt.Commands)
     if (auto *Cmd1 = dyn_cast<OutputSectionCommand>(Base1.get()))
       for (const std::unique_ptr<BaseCommand> &Base2 : Cmd1->Commands)
         if (auto *Cmd2 = dyn_cast<InputSectionDescription>(Base2.get()))
-          Ret.emplace_back(Cmd1->Name, Cmd2->Patterns);
+          Ret.emplace_back(Cmd1->Name, Cmd2->Patterns, Cmd2->ExcludedFiles);
 
   return Ret;
 }
 
 // Returns input sections filtered by given glob patterns.
 template <class ELFT>
 std::vector<InputSectionBase<ELFT> *>
-LinkerScript<ELFT>::getInputSections(ArrayRef<StringRef> Patterns) {
+LinkerScript<ELFT>::getInputSections(ArrayRef<StringRef> Patterns,
+                                     ArrayRef<StringRef> ExcludedFiles) {
   std::vector<InputSectionBase<ELFT> *> Ret;
   for (const std::unique_ptr<ObjectFile<ELFT>> &F :
        Symtab<ELFT>::X->getObjectFiles())
     for (InputSectionBase<ELFT> *S : F->getSections())
       if (!isDiscarded(S) && !S->OutSec && match(Patterns, S->getSectionName()))
+        if (ExcludedFiles.empty() ||
+            !match(ExcludedFiles, sys::path::filename(F->getName())))
           Ret.push_back(S);
   return Ret;
 }
 
 template <class ELFT>
 std::vector<OutputSectionBase<ELFT> *>
 LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
   std::vector<OutputSectionBase<ELFT> *> Ret;
 
   // Add input section to output section. If there is no output section yet,
   // then create it and add to output section list.
   auto Add = [&](InputSectionBase<ELFT> *C, StringRef Name) {
     OutputSectionBase<ELFT> *Sec;
     bool IsNew;
     std::tie(Sec, IsNew) = Factory.create(C, Name);
     if (IsNew)
       Ret.push_back(Sec);
     Sec->addSection(C);
   };
 
   for (auto &P : getSectionMap()) {
-    StringRef OutputName = P.first;
-    ArrayRef<StringRef> InputPatterns = P.second;
-    for (InputSectionBase<ELFT> *S : getInputSections(InputPatterns)) {
+    StringRef OutputName = std::get<0>(P);
+    ArrayRef<StringRef> InputPatterns = std::get<1>(P);
+    ArrayRef<StringRef> ExcludedFiles = std::get<2>(P);
+    for (InputSectionBase<ELFT> *S :
+         getInputSections(InputPatterns, ExcludedFiles)) {
       if (OutputName == "/DISCARD/") {
         S->Live = false;
         reportDiscarded(S);
         continue;
       }
       Add(S, OutputName);
     }
   }
return StringSwitch<int>(Op)
       .Case(">=", 2)
       .Case("<=", 2)
       .Case("==", 2)
       .Case("!=", 2)
       .Case("&", 1)
       .Default(-1);
 }
 
 void ScriptParser::readKeep(OutputSectionCommand *Cmd) {
   expect("(");
   expect("*");
   expect("(");
+
   auto *InCmd = new InputSectionDescription();
   Cmd->Commands.emplace_back(InCmd);
+
+  if (peek() == "EXCLUDE_FILE") {
+    next();
+    expect("(");
+    while (!Error && !skip(")"))
+      InCmd->ExcludedFiles.push_back(next());
+    Opt.KeptSections.push_back(peek());
+    InCmd->Patterns.push_back(next());
+    expect(")");
+  } else {
     while (!Error && !skip(")")) {
       Opt.KeptSections.push_back(peek());
       InCmd->Patterns.push_back(next());
     }
+  }
   expect(")");
 }
 
 void ScriptParser::readOutputSectionDescription(StringRef OutSec) {
   OutputSectionCommand *Cmd = new OutputSectionCommand(OutSec);
   Opt.Commands.emplace_back(Cmd);
 
   // Read an address expression.
   // https://sourceware.org/binutils/docs/ld/Output-Section-Address.html#Output-Section-Address
   if (peek() != ":")
     Cmd->AddrExpr = readExpr();
 
   expect(":");
 
   // Parse constraints.
   if (skip("ONLY_IF_RO"))
     Cmd->Constraint = ConstraintKind::ReadOnly;

test/ELF/linkerscript/Inputs/include.s

+.section .text
+.globl _potato
+_potato:
+  nop
+  nop

test/ELF/linkerscript/Inputs/notinclude.s

+.section .text
+.globl tomato
+tomato:
+  movl $1, %eax

test/ELF/linkerscript/linkerscript-excludefile.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
+# RUN:   %p/Inputs/include.s -o %t2
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
+# RUN:   %p/Inputs/notinclude.s -o %t3.notinclude
+
+# RUN: echo "SECTIONS {} " > %t.script
+# RUN: ld.lld -o %t --script %t.script %t1 %t2 %t3.notinclude
+# RUN: llvm-objdump -d %t | \
+# RUN:   FileCheck %s
+
+# CHECK: Disassembly of section .text:
+# CHECK: _start:
+# CHECK:      120:       48 c7 c0 3c 00 00 00    movq    $60, %rax
+# CHECK:      127:       48 c7 c7 2a 00 00 00    movq    $42, %rdi
+# CHECK:      12e:       00 00   addb    %al, (%rax)
+# CHECK: _potato:
+# CHECK:      130:       90      nop
+# CHECK:      131:       90      nop
+# CHECK:      132:       00 00   addb    %al, (%rax)
+# CHECK: tomato:
+# CHECK:      134:       b8 01 00 00 00  movl    $1, %eax
+
+# RUN: echo "SECTIONS { .patatino : \
+# RUN: { KEEP(*(EXCLUDE_FILE(*notinclude) .text)) } }" \
+# RUN:  > %t.script
+# RUN: ld.lld -o %t2 --script %t.script %t1 %t2 %t3.notinclude
+# RUN: llvm-objdump -d %t2 | \
+# RUN:   FileCheck %s --check-prefix=EXCLUDE
+
+# CHECK: Disassembly of section .patatino:
+# CHECK: _start:
+# CHECK:      120:       48 c7 c0 3c 00 00 00    movq    $60, %rax
+# CHECK:      127:       48 c7 c7 2a 00 00 00    movq    $42, %rdi
+# CHECK:      12e:       00 00   addb    %al, (%rax)
+# CHECK: _potato:
+# CHECK:      130:       90      nop
+# CHECK:      131:       90      nop
+# CHECK: Disassembly of section .text:
+# CHECK: tomato:
+# CHECK:      134:       b8 01 00 00 00  movl    $1, %eax
+
+.section .text
+.globl _start
+_start:
+    mov $60, %rax
+    mov $42, %rdi