[ELF/LinkerScript] Support ONLY_IF_{RO, RW} directive

[davide]

Including llvm-commits.

[ruiu]

Is this a feature to build FreeBSD?

ELF/LinkerScript.cpp

269 ↗

(On Diff #65013)

I would not use a default argument here.

282 ↗

(On Diff #65013)

Why don't you set Live flag of the section to false?

816 ↗

(On Diff #65013)

You can write

if (skip("ONLY_IF_RO"))

ELF/LinkerScript.h

70 ↗

(On Diff #65013)

ConstraintKind Constraint = NoConstraint;

[davide]

In D22660#492409, @ruiu wrote:

Is this a feature to build FreeBSD?

https://svnweb.freebsd.org/base/head/sys/conf/ldscript.amd64?revision=284870&view=markup#l78
As a general note, I'm going to implement only linker script directives/linker features for software running in the wild. You can keep that in mind.
Going to update the patch in a minute.

[davide]

Addressed comments (at least a subset of them).

ELF/LinkerScript.cpp

282 ↗

(On Diff #65013)

From what I see OutputSections have no Live flag, so, I assume you mean InputSections.
I'm not very familiar with the gc code, so I'll ask you. Is marking a single InputSection "dead" enough to prevent the output section to appear in the output?
You set the Live flag to false while processing \DISCARD\ in order to avoid input sections to appear in the output, but the semantic is a little bit different here.

Thanks!

[ruiu]

I really appreciate adding linker script features as-needed basis. Still I got to ask for a reference if its not in a commit message, so please include a sentence that "it's used by FreeBSD kernel". :)

ELF/LinkerScript.cpp

277 ↗

(On Diff #65018)

I see the reason why you need it, but it can be done without adding a new field to OutputSection because this flag is used only in this function. You can define

DenseSet<OitputSectionBase<ELFT>> Removed;

and add a section to the set of it needs to be removed at end of this function.

[ruiu]

LGTM with a nit.

ELF/LinkerScript.cpp

815 ↗

(On Diff #65024)

You want to remove this line.

lld/trunk/ELF/LinkerScript.h

 struct SymbolAssignment : BaseCommand {
   SymbolAssignment(StringRef Name, std::vector<StringRef> &Expr)
       : BaseCommand(AssignmentKind), Name(Name), Expr(std::move(Expr)) {}
   static bool classof(const BaseCommand *C);
   StringRef Name;
   std::vector<StringRef> Expr;
 };
 
+// Linker scripts allow additional constraints to be put on ouput sections.
+// An output section will only be created if all of its input sections are
+// read-only
+// or all of its input sections are read-write by using the keyword ONLY_IF_RO
+// and ONLY_IF_RW respectively.
+enum ConstraintKind { NoConstraint, ReadOnly, ReadWrite };
+
 struct OutputSectionCommand : BaseCommand {
   OutputSectionCommand(StringRef Name)
       : BaseCommand(OutputSectionKind), Name(Name) {}
   static bool classof(const BaseCommand *C);
   StringRef Name;
   std::vector<std::unique_ptr<BaseCommand>> Commands;
   std::vector<StringRef> Phdrs;
   std::vector<uint8_t> Filler;
+  ConstraintKind Constraint = NoConstraint;
 };
 
 struct InputSectionDescription : BaseCommand {
   InputSectionDescription() : BaseCommand(InputSectionKind) {}
   static bool classof(const BaseCommand *C);
   std::vector<StringRef> Patterns;
 };
 

lld/trunk/ELF/LinkerScript.cpp

static bool match(StringRef Pattern, ArrayRef<StringRef> Arr) {
   return false;
 }
 
 template <class ELFT>
 std::vector<OutputSectionBase<ELFT> *>
 LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
   typedef const std::unique_ptr<ObjectFile<ELFT>> ObjectFile;
   std::vector<OutputSectionBase<ELFT> *> Result;
+  DenseSet<OutputSectionBase<ELFT> *> Removed;
 
   // Add input section to output section. If there is no output section yet,
   // then create it and add to output section list.
-  auto AddInputSec = [&](InputSectionBase<ELFT> *C, StringRef Name) {
+  auto AddInputSec = [&](InputSectionBase<ELFT> *C, StringRef Name,
+                         ConstraintKind Constraint) {
     OutputSectionBase<ELFT> *Sec;
     bool IsNew;
     std::tie(Sec, IsNew) = Factory.create(C, Name);
     if (IsNew)
       Result.push_back(Sec);
+    if ((!(C->getSectionHdr()->sh_flags & SHF_WRITE)) &&
+        Constraint == ReadWrite) {
+      Removed.insert(Sec);
+      return;
+    }
+    if ((C->getSectionHdr()->sh_flags & SHF_WRITE) && Constraint == ReadOnly) {
+      Removed.insert(Sec);
+      return;
+    }
     Sec->addSection(C);
   };
 
   // Select input sections matching rule and add them to corresponding
   // output section. Section rules are processed in order they're listed
   // in script, so correct input section order is maintained by design.
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     auto *OutCmd = dyn_cast<OutputSectionCommand>(Base.get());
for (const std::unique_ptr<BaseCommand> &Cmd : OutCmd->Commands) {
         for (InputSectionBase<ELFT> *S : F->getSections()) {
           if (isDiscarded(S) || S->OutSec)
             continue;
 
           if (match(S->getSectionName(), InCmd->Patterns)) {
             if (OutCmd->Name == "/DISCARD/")
               S->Live = false;
             else
-              AddInputSec(S, OutCmd->Name);
+              AddInputSec(S, OutCmd->Name, OutCmd->Constraint);
           }
         }
       }
     }
   }
 
   // Add all other input sections, which are not listed in script.
   for (ObjectFile &F : Symtab<ELFT>::X->getObjectFiles())
     for (InputSectionBase<ELFT> *S : F->getSections()) {
       if (!isDiscarded(S)) {
         if (!S->OutSec)
-          AddInputSec(S, getOutputSectionName(S));
+          AddInputSec(S, getOutputSectionName(S), NoConstraint);
       } else
         reportDiscarded(S, F);
     }
 
+  // Remove from the output all the sections which did not met the constraints.
+  Result.erase(std::remove_if(Result.begin(), Result.end(),
+                              [&](OutputSectionBase<ELFT> *Sec) {
+                                return Removed.count(Sec);
+                              }),
+               Result.end());
   return Result;
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::dispatchAssignment(SymbolAssignment *Cmd) {
   uint64_t Val = evalExpr(Cmd->Expr, Dot);
   if (Cmd->Name == ".") {
     Dot = Val;
void ScriptParser::readLocationCounterValue() {
   else
     Opt.Commands.push_back(llvm::make_unique<SymbolAssignment>(".", Expr));
 }
 
 void ScriptParser::readOutputSectionDescription(StringRef OutSec) {
   OutputSectionCommand *Cmd = new OutputSectionCommand(OutSec);
   Opt.Commands.emplace_back(Cmd);
   expect(":");
+
+  // Parse constraints.
+  if (skip("ONLY_IF_RO"))
+    Cmd->Constraint = ReadOnly;
+  if (skip("ONLY_IF_RW"))
+    Cmd->Constraint = ReadWrite;
   expect("{");
 
   while (!Error && !skip("}")) {
     StringRef Tok = next();
     if (Tok == "*") {
       auto *InCmd = new InputSectionDescription();
       Cmd->Commands.emplace_back(InCmd);
       expect("(");

lld/trunk/test/ELF/linkerscript-sections-constraint.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "SECTIONS { \
+# RUN:  .writable : ONLY_IF_RW { *(.writable) } \
+# RUN:  .readable : ONLY_IF_RO { *(.readable) }}" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t1 | \
+# RUN:   FileCheck -check-prefix=BASE %s
+# BASE: Sections:
+# BASE-NEXT: Idx Name          Size      Address          Type
+# BASE-NEXT:   0               00000000 0000000000000000
+# BASE-NEXT:   1 .writable     00000004 0000000000000190 DATA
+# BASE-NEXT:   2 .readable     00000004 0000000000000194 DATA
+
+# RUN: echo "SECTIONS { \
+# RUN:  .writable : ONLY_IF_RO { *(.writable) } \
+# RUN:  .readable : ONLY_IF_RW { *(.readable) }}" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t1 | \
+# RUN:   FileCheck -check-prefix=NOSECTIONS %s
+# NOSECTIONS: Sections:
+# NOSECTIONS-NOT: .writable
+# NOSECTIONS-NOT: .readable
+
+.global _start
+_start:
+  nop
+
+.section .writable, "aw"
+writable:
+ .long 1
+
+.section .readable, "a"
+readable:
+ .long 2