[ELF] Add OVERWRITE_SECTIONS command

[MaskRay]

Summary

This implements https://sourceware.org/bugzilla/show_bug.cgi?id=26404

An OVERWRITE_SECTIONS command is a SECTIONS variant which contains several
output section descriptions. The output sections do not have specify an order.
Similar to INSERT [BEFORE|AFTER], LinkerScript::hasSectionsCommand is not
set, so the built-in rules (see docs/ELF/linker_script.rst) still apply.
OVERWRITE_SECTIONS can be more convenient than INSERT because it does not
need an anchor section.

The initial syntax is intentionally narrow to facilitate backward compatible
extensions in the future. Symbol assignments cannot be used.

This feature is versatile. To list a few usage:

• Use section : { KEEP(...) } to retain input sections under GC
• Define encapsulation symbols (start/end) for an output section
• Use section : ALIGN(...) : { ... } to overalign an output section (similar to ld64 -sectalign)

When an output section is specified by both OVERWRITE_SECTIONS and
INSERT, INSERT is processed after overwrite sections. To make this work,
this patch changes InsertCommand to use name based matching instead of pointer
based matching. (This may cause a difference when INSERT moves one output
section more than once. Such duplicate commands should not be used in practice
(seems that in GNU ld the output sections may just disappear).)

A linker script can be used without -T/--script. The traditional SECTIONS
commands are concatenated, so a wrong rule can be more noticeable from the
section order. This feature if misused can be less noticeable, just like
INSERT.

[peter.smith]

Will take a look this week. Apologies, bit behind due to UK public holiday on Monday.

[peter.smith]

Sorry for the delay in responding. I'm in favour of adding this as it should combine well with LLD when no default linker script is used.

I'm thinking overwrite-section-script may be a better name than --overwrite-script. It would reinforce the narrow nature of the script, to overwrite specific SECTIONS commands, and also help people not seeing it as overwriting their whole linker script.

With respect to Roland's comment in https://sourceware.org/bugzilla/show_bug.cgi?id=26404#c10 one way of having this work by adding another script fragment would be to add a keyword at the top of the linker script for example:

/* This linker script fragment is an overwrite script */
OVERWRITE_SCRIPT()

Will be good to have a test to show how --overwrite-script combines with INSERT AFTER and INSERT BEFORE

lld/ELF/Driver.cpp

222

Could we put /* overwrite */ before the false.

lld/ELF/Options.td

369

I'd recommend being more specific here
"Read a script containing SECTION commands that replace SECTIONS in the main or default linker script."

Will be good to update docs/ld.lld.1 and perhaps the release notes?

lld/ELF/ScriptParser.cpp

282

expect("SECTIONS") will do a good job of preventing other linker script commands, but it may leave people wondering why? Would it be possible to do something like:

expect("SECTIONS")
if (!errorCount())
  // Diagnostic "overwrite script can only contain SECTIONS commands."

lld/test/ELF/linkerscript/overwrite-script.test

106

Will be good to have a diagnostic for an overwrite script that doesn't contain SECTIONS.

[MaskRay]

• Rename to --overwrite-section-script
• Test INSERT
• Test A = 1; outside SECTIONS

[MaskRay]

In D103303#2796607, @peter.smith wrote:

Sorry for the delay in responding. I'm in favour of adding this as it should combine well with LLD when no default linker script is used.

I'm thinking overwrite-section-script may be a better name than --overwrite-script. It would reinforce the narrow nature of the script, to overwrite specific SECTIONS commands, and also help people not seeing it as overwriting their whole linker script.

Much appreciate your review. I agree that --overwrite-section-script is better.

With respect to Roland's comment in https://sourceware.org/bugzilla/show_bug.cgi?id=26404#c10 one way of having this work by adding another script fragment would be to add a keyword at the top of the linker script for example:

/* This linker script fragment is an overwrite script */
OVERWRITE_SCRIPT()

This would add some complexity to readLinkerScript as we will need to check the first token. Do we really need it?
This is just a matter between $file and -Wl,--overwrite-script=$file in the build system.

[mcgrathr]

In D103303#2797099, @MaskRay wrote:

This would add some complexity to readLinkerScript as we will need to check the first token. Do we really need it?
This is just a matter between $file and -Wl,--overwrite-script=$file in the build system.

That is no small matter in many build systems. Switches that name input files are especially difficult in general.

Even if you have no sympathy for build systems you don't know about, requiring a switch precludes using this functionality as a "transparent" part of a library implementation. Supporting "just add -lfoo to your compile" as the end-user API for using a library is highly desireable, and often a non-negotiable requirement. Having a libfoo.a input linker script that wraps an INPUT ( libfoo-impl.a ) along with other magic is a well-worn and very successful technique. The use cases you cite as motivations for adding this feature in the first place are exactly the kinds of things one would like to encapsulate as "hidden magic" in a library that's "just linked".

[peter.smith]

Thanks for the updates.

One idea that might work better for the linker script fragment is to use a new keyword. For example instead of using --overwrite-section-script and SECTIONS. Use a new keyword like OVERWRITE_SECTIONS this could essentially be mixed in with any other linker script without needing --overwrite-section-script.

[mcgrathr]

In D103303#2798557, @peter.smith wrote:

Thanks for the updates.

One idea that might work better for the linker script fragment is to use a new keyword. For example instead of using --overwrite-section-script and SECTIONS. Use a new keyword like OVERWRITE_SECTIONS this could essentially be mixed in with any other linker script without needing --overwrite-section-script.

I think that's an excellent idea. The new command really has different semantics from the old one, so making it a different keyword feels right.
It also makes it much simpler to have clear rules about what linker constructs are allowed in what kinds of contexts. Another syntax that would have equivalent properties from the user's point of view would be a trailing OVERWRITE keyword. That frankly seems less clear than OVERWRITE_SECTIONS, but it's more consistent with the existing SECTIONS { ... } INSERT ... syntax.

[MaskRay]

Use OVERWRITE_SECTIONS
Delete --overwrite-section-script

[MaskRay]

Introducing new syntax was my initial thought. Now I agree that having overwrite in the name is useful, OVERWRITE_SECTIONS looks great to me.
It now feels to me that --overwrite-section-script is less essential so I just removed the option from the patch.

[peter.smith]

Thanks very much for the update. I've made a few suggestions for the documentation.

One case I wanted to check was something like the following:

OVERWRITE_SECTIONS {
  orphan_section_name_matching_nothing_seen_before : { ... }
}

SECTIONS {
  another_orphan_section_name_matching_nothing_seen_before_including_overwrite : { ... }
} INSERT AFTER orphan_section_name_matching_nothing_seen_before

Would that place "orphan_section_name_matching_nothing_seen_before" using orphan rules then "orphan_section_name_matching_nothing_seen_before" immediately after it?

lld/docs/ELF/linker_script.rst

57 ↗

(On Diff #349948)

Suggest adding something like the insertion occurs after input sections have been mapped to output sections but before orphan sections have been processed.

59 ↗

(On Diff #349948)

A suggestion to avoid the "absence of a non-insert" which is difficult to parse.

In the case where no linker script has been provided or every `SECTIONS` command is followed by INSERT, LLD applies built-in rules which are similar to GNU ld's internal linker scripts.

146 ↗

(On Diff #349948)

"also appears in a `SECTIONS` command," might read a bit better. Only a weak suggestion though.

150 ↗

(On Diff #349948)

"also appears in"?

155 ↗

(On Diff #349948)

I got a little confused about this at first. Maybe worth being more specific:
"will be provided by the description in the `OVERWRITE_SECTIONS` command."

[MaskRay]

Thanks for the comments. Addressed and add another INSERT test.

[peter.smith]

LGTM thanks. One tiny typo spotted in a comment in the test.

lld/test/ELF/linkerscript/overwrite-sections.test

81 ↗

(On Diff #350384)

typo "than -> then"

[MaskRay]

fix a typo

[MaskRay]

I'll push this next week.

lld/ELF/Driver.cpp

void LinkerDriver::addFile(StringRef path, bool withLOption) {
 
   if (config->formatBinary) {
     files.push_back(make<BinaryFile>(mbref));
     return;
   }
 
   switch (identify_magic(mbref.getBuffer())) {
   case file_magic::unknown:
-    readLinkerScript(mbref);
+    readLinkerScript(mbref, false);
     return;
   case file_magic::archive: {
     // Handle -whole-archive.
     if (inWholeArchive) {
       for (const auto &p : getArchiveMembers(mbref))
         files.push_back(createObjectFile(p.first, path, p.second));
       return;
     }
case OPT_defsym: {
       std::tie(from, to) = StringRef(arg->getValue()).split('=');
       if (from.empty() || to.empty())
         error("-defsym: syntax error: " + StringRef(arg->getValue()));
       else
         readDefsym(from, MemoryBufferRef(to, "-defsym"));
       break;
     }
     case OPT_script:
+    case OPT_overwrite_script:
       if (Optional<std::string> path = searchScript(arg->getValue())) {
         if (Optional<MemoryBufferRef> mb = readFile(*path))
-          readLinkerScript(*mb);
+          readLinkerScript(*mb,
+                           arg->getOption().getID() == OPT_overwrite_script);
         break;
       }
       error(Twine("cannot find linker script ") + arg->getValue());
       break;
     case OPT_as_needed:
       config->asNeeded = true;
       break;
     case OPT_format:

lld/ELF/LinkerScript.h

public:
 
   // A list of symbols referenced by the script.
   std::vector<llvm::StringRef> referencedSymbols;
 
   // Used to implement INSERT [AFTER|BEFORE]. Contains output sections that need
   // to be reordered.
   std::vector<InsertCommand> insertCommands;
 
+  // OutputSections specified by --overwrite-script.
+  std::vector<OutputSection *> overwriteSections;
+
   // Sections that will be warned/errored by --orphan-handling.
   std::vector<const InputSectionBase *> orphanSections;
 };
 
 extern LinkerScript *script;
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // LLD_ELF_LINKER_SCRIPT_H

lld/ELF/LinkerScript.cpp

if (auto *cmd = dyn_cast<InputSectionDescription>(base)) {
       ret.insert(ret.end(), cmd->sectionBases.begin(), cmd->sectionBases.end());
     }
   }
   return ret;
 }
 
 // Create output sections described by SECTIONS commands.
 void LinkerScript::processSectionCommands() {
-  size_t i = 0;
-  for (BaseCommand *base : sectionCommands) {
-    if (auto *sec = dyn_cast<OutputSection>(base)) {
-      std::vector<InputSectionBase *> v = createInputSectionList(*sec);
+  auto process = [this](OutputSection *osec) {
+    std::vector<InputSectionBase *> v = createInputSectionList(*osec);
 
-      // The output section name `/DISCARD/' is special.
-      // Any input section assigned to it is discarded.
-      if (sec->name == "/DISCARD/") {
-        for (InputSectionBase *s : v)
-          discard(s);
-        discardSynthetic(*sec);
-        sec->sectionCommands.clear();
-        continue;
-      }
+    if (osec->name == "/DISCARD/") {
+      discardSynthetic(*osec);
+      osec->sectionCommands.clear();
+      return false;
 
-      // This is for ONLY_IF_RO and ONLY_IF_RW. An output section directive
-      // ".foo : ONLY_IF_R[OW] { ... }" is handled only if all member input
-      // sections satisfy a given constraint. If not, a directive is handled
-      // as if it wasn't present from the beginning.
-      //
-      // Because we'll iterate over SectionCommands many more times, the easy
-      // way to "make it as if it wasn't present" is to make it empty.
-      if (!matchConstraints(v, sec->constraint)) {
-        for (InputSectionBase *s : v)
-          s->parent = nullptr;
-        sec->sectionCommands.clear();
-        continue;
-      }
+    if (!matchConstraints(v, osec->constraint)) {
+      osec->sectionCommands.clear();
+      return false;
 
-      // Handle subalign (e.g. ".foo : SUBALIGN(32) { ... }"). If subalign
-      // is given, input sections are aligned to that value, whether the
-      // given value is larger or smaller than the original section alignment.
-      if (sec->subalignExpr) {
-        uint32_t subalign = sec->subalignExpr().getValue();
-        for (InputSectionBase *s : v)
-          s->alignment = subalign;
-      }
+    if (osec->subalignExpr) {
+      uint32_t subalign = osec->subalignExpr().getValue();
 
-      // Set the partition field the same way OutputSection::recordSection()
-      // does. Partitions cannot be used with the SECTIONS command, so this is
-      // always 1.
-      sec->partition = 1;
+    osec->partition = 1;
+    return true;
+  };
 
-      sec->sectionIndex = i++;
+  // Process --overwrite-script first so that it can overwrite the main script
+  // or orphans.
+  DenseMap<StringRef, OutputSection *> map;
+  size_t i = 0;
+  for (OutputSection *osec : overwriteSections)
+    if (process(osec) && !map.try_emplace(osec->name, osec).second)
+      warn("--overwrite-script specifies duplicate " + osec->name);
+  for (BaseCommand *&base : sectionCommands)
+    if (auto *osec = dyn_cast<OutputSection>(base)) {
+      if (OutputSection *overwrite = map.lookup(osec->name)) {
+        log(osec->name + " is overwritten by --overwrite-script to " +
+            overwrite->location);
+        overwrite->sectionIndex = i++;
+        base = overwrite;
+      } else if (process(osec)) {
+        osec->sectionIndex = i++;
       }
     }
+
+  // If an --overwrite-script specified output section is not in
+  // sectionCommands, append it to the end. The section will be inserted by
+  // orphan placement.
+  for (OutputSection *osec : overwriteSections)
+    if (osec->partition == 1 && osec->sectionIndex == UINT32_MAX)
+      sectionCommands.push_back(osec);
 }
 
 void LinkerScript::processSymbolAssignments() {
   // Dot outside an output section still represents a relative address, whose
   // sh_shndx should not be SHN_UNDEF or SHN_ABS. Create a dummy aether section
   // that fills the void outside a section. It has an index of one, which is
   // indistinguishable from any other regular section index.
   aether = make<OutputSection>("", 0, SHF_ALLOC);

lld/ELF/Options.td

 
 def relocatable: F<"relocatable">, HelpText<"Create relocatable object file">;
 
 defm retain_symbols_file:
   Eq<"retain-symbols-file", "Retain only the symbols listed in the file">,
   MetaVarName<"<file>">;
 
 defm script: Eq<"script", "Read linker script">;
+defm overwrite_script: EEq<"overwrite-script", "Read a script which overrides the main script">;
 
 defm section_start: Eq<"section-start", "Set address of section">,
   MetaVarName<"<address>">;
 
 def shared: F<"shared">, HelpText<"Build a shared object">;
 
 defm soname: Eq<"soname", "Set DT_SONAME">;
 

lld/ELF/ScriptParser.h

 #include "lld/Common/LLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace lld {
 namespace elf {
 
 // Parses a linker script. Calling this function updates
 // lld::elf::config and lld::elf::script.
-void readLinkerScript(MemoryBufferRef mb);
+void readLinkerScript(MemoryBufferRef mb, bool overwrite);
 
 // Parses a version script.
 void readVersionScript(MemoryBufferRef mb);
 
 void readDynamicList(MemoryBufferRef mb);
 
 // Parses the defsym expression.
 void readDefsym(StringRef name, MemoryBufferRef mb);
 
 bool hasWildcard(StringRef s);
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/ScriptParser.cpp

for (; !path.empty(); path = sys::path::parent_path(path)) {
       if (!sys::fs::equivalent(config->sysroot, path))
         continue;
       isUnderSysroot = true;
       return;
     }
   }
 
   void readLinkerScript();
+  void readOverwriteScript();
   void readVersionScript();
   void readDynamicList();
   void readDefsym(StringRef name);
 
 private:
   void addFile(StringRef path);
 
   void readAsNeeded();
while (!atEOF()) {
     } else if (SymbolAssignment *cmd = readAssignment(tok)) {
       script->sectionCommands.push_back(cmd);
     } else {
       setError("unknown directive: " + tok);
     }
   }
 }
 
+void ScriptParser::readOverwriteScript() {
+  while (!atEOF() && !errorCount()) {
+    expect("SECTIONS");
+    expect("{");
+    if (!errorCount())
+      script->overwriteSections.push_back(readOutputSectionDescription(next()));
+    expect("}");
+  }
+}
+
 void ScriptParser::readDefsym(StringRef name) {
   if (errorCount())
     return;
   Expr e = readExpr();
   if (!atEOF())
     setError("EOF expected, but got " + next());
   SymbolAssignment *cmd = make<SymbolAssignment>(name, e, getCurrentLocation());
   script->sectionCommands.push_back(cmd);
for (char c : next().lower()) {
     if (invert)
       negFlags |= flag;
     else
       flags |= flag;
   }
   return {flags, negFlags};
 }
 
-void elf::readLinkerScript(MemoryBufferRef mb) {
+void elf::readLinkerScript(MemoryBufferRef mb, bool overwrite) {
   llvm::TimeTraceScope timeScope("Read linker script",
                                  mb.getBufferIdentifier());
+  if (overwrite)
+    ScriptParser(mb).readOverwriteScript();
+  else
     ScriptParser(mb).readLinkerScript();
 }
 
 void elf::readVersionScript(MemoryBufferRef mb) {
   llvm::TimeTraceScope timeScope("Read version script",
                                  mb.getBufferIdentifier());
   ScriptParser(mb).readVersionScript();
 }
 

lld/test/ELF/linkerscript/overwrite-script-discard.test

+# REQUIRES: x86
+# RUN: split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/a.s -o %t/a.o
+
+## /DISCARD/ specified by --overwrite-script can discard sections as well.
+
+# RUN: ld.lld --overwrite-script %t/overwrite.lds -T %t/main.lds %t/a.o -o %t1 2>&1 | count 0
+# RUN: llvm-readelf -S -l %t1 | FileCheck %s
+# RUN: ld.lld --overwrite-script %t/overwrite.lds --overwrite-script %t/overwrite.lds -T %t/main.lds %t/a.o -o %t1 2>&1 | count 0
+# RUN: llvm-readelf -S -l %t1 | FileCheck %s
+
+# CHECK:     Name
+# CHECK-NOT: .data
+
+#--- a.s
+.globl _start
+_start:
+
+.section .data.1,"aw"; .byte 1
+.section .data.2,"aw"; .byte 2
+
+#--- main.lds
+SECTIONS {
+  /DISCARD/ : { *(.data.1) }
+}
+
+#--- overwrite.lds
+SECTIONS {
+  /DISCARD/ : { *(.data.2) }
+}

lld/test/ELF/linkerscript/overwrite-script.test

+# REQUIRES: x86
+# RUN: rm -rf %t && split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/a.s -o %t/a.o
+
+## There is no main linker script. --overwrite-script defines output section
+## descriptions and follows the usual orphan placement rules.
+
+# RUN: ld.lld --overwrite-script %t/overwrite1.lds %t/a.o -o %t1
+# RUN: llvm-readelf -S %t1 | FileCheck %s --check-prefix=CHECK1
+
+# CHECK1:      Name      Type     Address  Off      Size   ES Flg Lk Inf Al
+# CHECK1-NEXT:           NULL     [[#%x,]] [[#%x,]] 000000
+# CHECK1-NEXT: .text     PROGBITS [[#%x,]] [[#%x,]] 000001 00  AX  0   0  4
+# CHECK1-NEXT: .foo.text PROGBITS [[#%x,]] [[#%x,]] 000002 00 WAX  0   0  8
+# CHECK1-NEXT: .data     PROGBITS [[#%x,]] [[#%x,]] 000001 00  WA  0   0  1
+# CHECK1-NEXT: .comment  PROGBITS {{.*}}
+
+# RUN: ld.lld --overwrite-script %t/overwrite1.lds --overwrite-script %t/overwrite1.lds %t/a.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=WARN1
+
+# WARN1: warning: --overwrite-script specifies duplicate .foo.text
+
+## The output section description order (.foo.data .foo.text) does not affect
+## the output order.
+
+# RUN: ld.lld --overwrite-script %t/overwrite2.lds %t/a.o -o %t2
+# RUN: llvm-readelf -S -s %t2 | FileCheck %s --check-prefix=CHECK2
+
+# CHECK2:      [Nr] Name      Type     Address  Off      Size   ES Flg Lk Inf Al
+# CHECK2-NEXT: [ 0]           NULL     [[#%x,]] [[#%x,]] 000000
+# CHECK2-NEXT: [ 1] .text     PROGBITS [[#%x,]] [[#%x,]] 000001 00  AX  0   0  4
+# CHECK2-NEXT: [ 2] .foo.text PROGBITS [[#%x,]] [[#%x,]] 000001 00  AX  0   0  1
+# CHECK2-NEXT: [ 3] .data     PROGBITS [[#%x,]] [[#%x,]] 000001 00  WA  0   0  1
+# CHECK2-NEXT: [ 4] .foo.data PROGBITS [[#%x,]] [[#%x,]] 000001 00  WA  0   0  1
+# CHECK2-NEXT: [ 5] .comment  PROGBITS {{.*}}
+
+# CHECK2:        Num: Value            Size Type   Bind   Vis     Ndx Name
+# CHECK2:      [[#]]: [[#%x,ADDR:]]       0  NOTYPE GLOBAL DEFAULT   4 FOO_DATA_START
+# CHECK2-NEXT: [[#]]: {{0*}}[[#ADDR+1]]   0  NOTYPE GLOBAL DEFAULT   4 FOO_DATA_END
+# CHECK2-NEXT: [[#]]: [[#%x,ADDR:]]       0  NOTYPE GLOBAL DEFAULT   2 FOO_TEXT_START
+# CHECK2-NEXT: [[#]]: {{0*}}[[#ADDR+1]]   0  NOTYPE GLOBAL DEFAULT   2 FOO_TEXT_END
+
+## --overwrite-script is processed before the main script. The main script
+## specifies the output order. The alignment of .foo.text is specified by
+## --overwrite-script insteaad of the main script.
+
+# RUN: ld.lld -T %t/main.lds --overwrite-script %t/overwrite1.lds %t/a.o -o %t3 2>&1 | count 0
+# RUN: llvm-readelf -S %t3 | FileCheck %s --check-prefix=CHECK3
+# RUN: ld.lld --overwrite-script %t/overwrite1.lds -T %t/main.lds %t/a.o -o %t3 2>&1 | count 0
+# RUN: llvm-readelf -S %t3 | FileCheck %s --check-prefix=CHECK3
+
+# CHECK3:      Name      Type     Address  Off      Size   ES Flg Lk Inf Al
+# CHECK3-NEXT:           NULL     [[#%x,]] [[#%x,]] 000000
+# CHECK3-NEXT: .data     PROGBITS [[#%x,]] [[#%x,]] 000001 00  WA  0   0  1
+# CHECK3-NEXT: .text     PROGBITS [[#%x,]] [[#%x,]] 000001 00  AX  0   0  4
+# CHECK3-NEXT: .foo.text PROGBITS [[#%x,]] [[#%x,]] 000002 00 WAX  0   0  8
+# CHECK3-NEXT: .comment  PROGBITS {{.*}}
+
+# RUN: ld.lld -T %t/main.lds --overwrite-script %t/overwrite1.lds %t/a.o -o %t3 --verbose 2>&1 | FileCheck %s --check-prefix=VERBOSE3
+
+# VERBOSE3: .foo.text is overwritten by --overwrite-script to {{.*}}overwrite1.lds:[[#]]
+
+#--- a.s
+.globl _start
+_start:
+
+.section .foo.text,"ax"; .byte 1
+.section .foo.data,"aw"; .byte 2
+.section .text.1,"ax"; .byte 3
+.section .data.1,"aw"; .byte 4
+
+#--- main.lds
+SECTIONS {
+  .data : { *(.data*) }
+  .foo.data : { *(.foo.data) }
+  .text : { *(.text*) }
+  .foo.text : ALIGN(16) { *(.foo.text) }
+}
+
+#--- overwrite1.lds
+SECTIONS {
+  .foo.text : ALIGN(8) { *(.foo.data .foo.text) }
+}
+
+#--- overwrite2.lds
+SECTIONS {
+  .foo.data : { FOO_DATA_START = .; *(.foo.data) FOO_DATA_END = .;  }
+}
+SECTIONS {
+  .foo.text : { FOO_TEXT_START = .; *(.foo.text) FOO_TEXT_END = .;  }
+}
+
+#--- err1.lds
+# RUN: not ld.lld --overwrite-script %t/err1.lds %t/a.o -o /dev/null 2>&1 | FileCheck %s -DFILE=%t/err1.lds --check-prefix=ERR1
+# ERR1: error: [[FILE]]:[[#@LINE+3]]: } expected, but got .foo.text
+SECTIONS {
+  .foo.data : {}
+  .foo.text : {}
+}
+
+#--- err2.lds
+## TODO: Fix the diagnostic 'malformed number'
+# RUN: not ld.lld --overwrite-script %t/err2.lds %t/a.o -o /dev/null 2>&1 | FileCheck %s -DFILE=%t/err2.lds --check-prefix=ERR2
+# ERR2: error: [[FILE]]:[[#@LINE+2]]: malformed number: =
+SECTIONS {
+  A = 1;
+}