Address review feedback

- `auto` over `const auto` for lambdas
- Inline `alreadyAssignedToOutCmd`
- Use `.lds` as linker script file extension in test
- Move RUN, CHECK and test descriptors into split files
- Add another duplicate class definition to test
- Remove dead `loc` variable
- Add missing braces to an `if` statement with braced `else`
- Remove "An error is reported when" from test descriptions
- Remove the 'd' from "SHF_MERGEd sections"
- Use `errorOrWarn` for errors that still allow an object file to be
  produced
- Add tests that a class reference can be used in /DISCARD/ or INSERT.
- Update spill comment.
- Tighten doc wording.
- Add PR number to release notes.

Author: mysterymath

lld/ELF/LinkerScript.cpp

@@ -497,14 +497,9 @@ LinkerScript::computeInputSections(const InputSectionDescription *cmd,
   SmallVector<InputSectionBase *, 0> ret;
   DenseSet<InputSectionBase *> spills;
 
-  // Returns whether an input section was already assigned to an earlier input
-  // section description in this output section or section class.
-  const auto alreadyAssignedToOutCmd =
-      [&outCmd](InputSectionBase *sec) { return sec->parent == &outCmd; };
-
   // Returns whether an input section's flags match the input section
   // description's specifiers.
-  const auto flagsMatch = [cmd](InputSectionBase *sec) {
+  auto flagsMatch = [cmd](InputSectionBase *sec) {
     return (sec->flags & cmd->withFlags) == cmd->withFlags &&
            (sec->flags & cmd->withoutFlags) == 0;
   };
@@ -547,7 +542,7 @@ LinkerScript::computeInputSections(const InputSectionDescription *cmd,
           continue;
 
         if (!cmd->matchesFile(sec->file) || pat.excludesFile(sec->file) ||
-            alreadyAssignedToOutCmd(sec) || !flagsMatch(sec))
+            sec->parent == &outCmd || !flagsMatch(sec))
           continue;
 
         if (sec->parent) {
@@ -597,33 +592,35 @@ LinkerScript::computeInputSections(const InputSectionDescription *cmd,
   } else {
     SectionClassDesc *scd = script->sectionClasses.lookup(cmd->classRef);
     if (!scd) {
-      error("undefined section class '" + cmd->classRef + "'");
+      errorOrWarn("undefined section class '" + cmd->classRef + "'");
       return ret;
     }
     if (!scd->sc.assigned) {
-      error("section class '" + cmd->classRef + "' referenced by '" +
-            outCmd.name + "' before class definition");
+      errorOrWarn("section class '" + cmd->classRef + "' referenced by '" +
+                  outCmd.name + "' before class definition");
       return ret;
     }
 
     for (InputSectionDescription *isd : scd->sc.commands) {
       for (InputSectionBase *sec : isd->sectionBases) {
-        if (alreadyAssignedToOutCmd(sec) || !flagsMatch(sec))
+        if (sec->parent == &outCmd || !flagsMatch(sec))
           continue;
         bool isSpill = sec->parent && isa<OutputSection>(sec->parent);
-        if (!sec->parent || (isSpill && outCmd.name == "/DISCARD/"))
-          error("section '" + sec->name + "' cannot spill from/to /DISCARD/");
+        if (!sec->parent || (isSpill && outCmd.name == "/DISCARD/")) {
+          errorOrWarn("section '" + sec->name + "' cannot spill from/to /DISCARD/");
+          continue;
+        }
         if (isSpill)
           spills.insert(sec);
         ret.push_back(sec);
       }
     }
   }
 
-  // The flag --enable-non-contiguous-regions may cause sections to match an
-  // InputSectionDescription in more than one OutputSection. Matches after the
-  // first were collected in the spills set, so replace these with potential
-  // spill sections.
+  // The flag --enable-non-contiguous-regions or the section CLASS syntax may
+  // cause sections to match an InputSectionDescription in more than one
+  // OutputSection. Matches after the first were collected in the spills set, so
+  // replace these with potential spill sections.
   if (!spills.empty()) {
     for (InputSectionBase *&sec : ret) {
       if (!spills.contains(sec))
@@ -790,8 +787,9 @@ void LinkerScript::processSectionCommands() {
         for (InputSectionBase *isec : isd->sectionBases)
           if (isa<PotentialSpillSection>(isec) ||
               potentialSpillLists.contains(isec))
-            error("section '" + isec->name +
-                  "' cannot spill from/to INSERT section '" + os->name + "'");
+            errorOrWarn("section '" + isec->name +
+                        "' cannot spill from/to INSERT section '" + os->name +
+                        "'");
       }
     }
   }
@@ -809,8 +807,9 @@ void LinkerScript::processSectionCommands() {
     for (InputSectionDescription *isd : sc->sc.commands)
       for (InputSectionBase *sec : isd->sectionBases)
         if (sec->parent && isa<SectionClass>(sec->parent))
-          error("section '" + sec->name + "' assigned to class '" +
-                sec->parent->name + "' but unreferenced by any output section");
+          errorOrWarn("section '" + sec->name + "' assigned to class '" +
+                      sec->parent->name +
+                      "' but unreferenced by any output section");
 }
 
 void LinkerScript::processSymbolAssignments() {

lld/ELF/ScriptParser.cpp

@@ -608,17 +608,16 @@ SmallVector<SectionCommand *, 0> ScriptParser::readOverlay() {
 }
 
 SectionClassDesc *ScriptParser::readSectionClassDescription() {
-  std::string loc = getCurrentLocation();
   StringRef name = readSectionClassName();
   SectionClassDesc *desc = make<SectionClassDesc>(name);
   if (!script->sectionClasses.insert({name, desc}).second)
     setError("section class '" + name + "' already defined");
   expect("{");
   while (!errorCount() && !consume("}")) {
     StringRef tok = next();
-    if (tok == "(" || tok == ")")
+    if (tok == "(" || tok == ")") {
       setError("expected filename pattern");
-    else if (peek() == "(") {
+    } else if (peek() == "(") {
       InputSectionDescription *isd = readInputSectionDescription(tok);
       if (!isd->classRef.empty())
         setError("section class '" + name + "' references class '" +

lld/docs/ELF/linker_script.rst

@@ -201,7 +201,8 @@ using ``DATA_SEGMENT_RELRO_END``.
 Section Classes
 ~~~~~~~~~~~~~~~
 
-``SECTIONS`` commands can define classes of input sections:
+The ``CLASS`` keyword inside a ``SECTIONS`` command defines classes of input
+sections:
 
 ::
 
@@ -213,7 +214,7 @@ Section Classes
     }
   }
 
-Input section descriptions can refer to a class using ``CLASS(class_name)``
+Input section descriptions refer to a class using ``CLASS(class_name)``
 instead of the usual filename and section name patterns. For example:
 
 ::
@@ -223,11 +224,11 @@ instead of the usual filename and section name patterns. For example:
     .rodata { *(.rodata) CLASS(c) (*.rodata.later) }
   }
 
-Input sections that are assigned to a class cannot be matched by later
-wildcards, just as if they had been assigned to an earlier output section. If a
-class is referenced in multiple output sections, when a memory region would
-overflow, the linker spills input sections from a reference to later references
-rather than failing the link.
+Input sections that are assigned to a class are not matched by later patterns,
+just as if they had been assigned to an earlier output section. If a class is
+referenced in multiple output sections, when a memory region would overflow,
+the linker spills input sections from a reference to later references rather
+than failing the link.
 
 Classes cannot reference other classes; an input section is assigned to at most
 one class.
@@ -240,10 +241,9 @@ Non-contiguous regions
 
 The flag ``--enable-non-contiguous-regions`` provides a version of the above
 spilling functionality that is more compatible with GNU LD. It allows input
-sections to spill to later wildcard matches. (This globally changes the
-behavior of wildcards.) Unlike GNU ld, ``/DISCARD/`` only matches
-previously-unmatched sections (i.e., the flag does not affect it). Also, if a
-section fails to fit at any of its matches, the link fails instead of
-discarding the section. Accordingly, the GNU flag
-``--enable-non-contiguous-regions-warnings`` is not implemented, as it exists
-to warn about such occurrences.
+sections to spill to later pattern matches. (This globally changes the behavior
+of patterns.) Unlike GNU ld, ``/DISCARD/`` only matches previously-unmatched
+sections (i.e., the flag does not affect it). Also, if a section fails to fit
+at any of its matches, the link fails instead of discarding the section.
+Accordingly, the GNU flag ``--enable-non-contiguous-regions-warnings`` is not
+implemented, as it exists to warn about such occurrences.

lld/docs/ReleaseNotes.rst

@@ -31,8 +31,8 @@ ELF Improvements
   regions by automatically spilling to later class references if a region would
   overflow. This reduces the toil of manually packing regions (typical for
   embedded). It also makes full LTO feasible in such cases, since IR merging
-  currently prevents the linker script from referring to input files. (TODO: PR
-  Reference)
+  currently prevents the linker script from referring to input files.
+  (`#95323 <https://github.com/llvm/llvm-project/pull/95323>`_)
 
 Breaking changes
 ----------------