[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.

98–101

I'd pass InputSectionDescription * instead.

669–670

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.

673–674

if (skip("EXCLUDE_FILE")) {

[davide]

Rui's comments.

[ruiu]

ELF/LinkerScript.cpp

670

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

673–679

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

690

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

673–679

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

673–679

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

694

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::pair<StringRef, const InputSectionDescription *>>
+  getSectionMap();
 
   std::vector<InputSectionBase<ELFT> *>
-  getInputSections(ArrayRef<StringRef> Patterns);
+  getInputSections(const InputSectionDescription *);
 
   // "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::pair<StringRef, const InputSectionDescription *>>
 LinkerScript<ELFT>::getSectionMap() {
-  std::vector<std::pair<StringRef, ArrayRef<StringRef>>> Ret;
+  std::vector<std::pair<StringRef, const InputSectionDescription *>> 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);
 
   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(const InputSectionDescription *I) {
+  ArrayRef<StringRef> Patterns = I->Patterns;
+  ArrayRef<StringRef> ExcludedFiles = I->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)) {
+    const InputSectionDescription *I = P.second;
+    for (InputSectionBase<ELFT> *S : getInputSections(I)) {
       if (OutputName == "/DISCARD/") {
         S->Live = false;
         reportDiscarded(S);
         continue;
       }
       Add(S, OutputName);
     }
   }
public:
   void run();
 
 private:
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
+  std::unique_ptr<InputSectionDescription> readFilePattern();
   void readGroup();
   void readKeep(OutputSectionCommand *Cmd);
   void readInclude();
   void readNothing() {}
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readPhdrs();
return StringSwitch<int>(Op)
       .Case(">", 2)
       .Case(">=", 2)
       .Case("<=", 2)
       .Case("==", 2)
       .Case("!=", 2)
       .Case("&", 1)
       .Default(-1);
 }
 
-void ScriptParser::readKeep(OutputSectionCommand *Cmd) {
-  expect("(");
+std::unique_ptr<InputSectionDescription> ScriptParser::readFilePattern() {
   expect("*");
   expect("(");
-  auto *InCmd = new InputSectionDescription();
-  Cmd->Commands.emplace_back(InCmd);
-  while (!Error && !skip(")")) {
-    Opt.KeptSections.push_back(peek());
+
+  auto InCmd = llvm::make_unique<InputSectionDescription>();
+
+  if (skip("EXCLUDE_FILE")) {
+    expect("(");
+    while (!Error && !skip(")"))
+      InCmd->ExcludedFiles.push_back(next());
+    InCmd->Patterns.push_back(next());
+    expect(")");
+  } else {
+    while (!Error && !skip(")"))
       InCmd->Patterns.push_back(next());
   }
+  return InCmd;
+}
+
+void ScriptParser::readKeep(OutputSectionCommand *Cmd) {
+  expect("(");
+  std::unique_ptr<InputSectionDescription> InCmd = readFilePattern();
+  Opt.KeptSections.insert(Opt.KeptSections.end(), InCmd->Patterns.begin(),
+                          InCmd->Patterns.end());
+  Cmd->Commands.emplace_back(InCmd.release());
   expect(")");
 }
 
 void ScriptParser::readAlign(OutputSectionCommand *Cmd) {
   expect("(");
   Cmd->AlignExpr = readExpr();
   expect(")");
 }

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
+
+# EXCLUDE: Disassembly of section .patatino:
+# EXCLUDE: _start:
+# EXCLUDE:      120:       48 c7 c0 3c 00 00 00    movq    $60, %rax
+# EXCLUDE:      127:       48 c7 c7 2a 00 00 00    movq    $42, %rdi
+# EXCLUDE:      12e:       00 00   addb    %al, (%rax)
+# EXCLUDE: _potato:
+# EXCLUDE:      130:       90      nop
+# EXCLUDE:      131:       90      nop
+# EXCLUDE: Disassembly of section .text:
+# EXCLUDE: tomato:
+# EXCLUDE:      134:       b8 01 00 00 00  movl    $1, %eax
+
+.section .text
+.globl _start
+_start:
+    mov $60, %rax
+    mov $42, %rdi