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

(On Diff #65461)

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

99–100 ↗

(On Diff #65461)

I'd pass InputSectionDescription * instead.

686 ↗

(On Diff #65461)

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 ↗

(On Diff #65461)

if (skip("EXCLUDE_FILE")) {

[davide]

Rui's comments.

[ruiu]

ELF/LinkerScript.cpp

670 ↗

(On Diff #65637)

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

681 ↗

(On Diff #65637)

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

694 ↗

(On Diff #65637)

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

681 ↗

(On Diff #65637)

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

681 ↗

(On Diff #65637)

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 ↗

(On Diff #65641)

push_back(std::move(InCmd))

[grimar]

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

8

excessive space at the end

14

I think you want to use CHECK-NEXT here.

32

Ditto.

lld/trunk/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);

lld/trunk/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("&", 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.push_back(std::move(InCmd));
   expect(")");
 }
 
 void ScriptParser::readAlign(OutputSectionCommand *Cmd) {
   expect("(");
   Cmd->AlignExpr = readExpr();
   expect(")");
 }

lld/trunk/test/ELF/linkerscript/Inputs/include.s

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

lld/trunk/test/ELF/linkerscript/Inputs/notinclude.s

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

lld/trunk/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