[ELF] Support (TYPE=<value>) to customize the output section type

[MaskRay]

Summary

The current output section type allows to set the ELF section type to
SHT_PROGBITS or SHT_NOLOAD. This patch allows an arbitrary section value
to be specified. Some common SHT_* literal names are supported as well.

SECTIONS {
  note (TYPE=SHT_NOTE) : { BYTE(8) *(note) }
  init_array ( TYPE=14 ) : { QUAD(14) }
  fini_array (TYPE = SHT_FINI_ARRAY) : { QUAD(15) }
}

When sh_type is specified, it is an error if an input section has a different type.

Our syntax is compatible with GNU ld 2.39 (https://sourceware.org/bugzilla/show_bug.cgi?id=28841).

[peter.smith]

Not had a chance to look through the code, this is based on the description and the test so my apologies if the answers are in the code.

Initial thoughts are that this could be quite useful for creating more specific types from more general ones like raw data, although in the majority of cases input section type != output section type is likely a mistake. I'm guessing the interesting part will be dealing with the error and edge cases. For example:

• Do the input sections have to be compatible with the output section type?
• If they are not compatible, which takes precedent the input or output section type?
• Are there, for want of a better word, coercions from one type to another, for example can SHT_NOBITS input sections be coerced into SHT_PROGBITS so that zeroes are written into the file.

I note in the example that all of your examples are of the form of linker script data directives BYTE, QUAD etc. Would it make sense to restrict this to OutputSections with no InputSections or at least non executable input sections?

[MaskRay]

I do intend to report a type mismatch error.
The previous diff had an issue that this is not detected.
The uploaded one has fixed it.

So I pick this choice:

Do the input sections have to be compatible with the output section type?

I note in the example that all of your examples are of the form of linker script data directives BYTE, QUAD etc. Would it make sense to restrict this to OutputSections with no InputSections or at least non executable input sections?

I think .init_array (TYPE=SHT_INIT_ARRAY) : { *(.init_array) } should be supported.
In addition, our orphan placement rule may place input sections of the same name into the output section.
It seems odd to reject them.

[peter.smith]

Thanks for the update. The intent is clearer now. I've left some small suggestions.

lld/ELF/ScriptParser.cpp

792

I'm interested in why SHT_STRTAB that is usually only accessed from linker generated symbol tables. While in theory it could be constructed by a user created section, what symbol table would reference it with the sh_link field.

796

Worth undefining ECase after its last use?

797–798

Comment will need updating to include (TYPE)

823

It will be worth checking that there is a SHT_ prefix here so we can give a better error message if someone has used an unsupported type like SHT_DYNAMIC.

lld/docs/ELF/linker_script.rst

109

Suggest `if an input section in *S* has a different type.

lld/test/ELF/linkerscript/custom-section-type.s

63

For SHT_INIT_ARRAY et-al to be practically useful I guess we're looking at something like

.init_array { QUAD(function_name) }

As the address of the function to execute won't usually be known when writing the script. Is it worth making the test reflect that?

[MaskRay]

Thanks for the comments. Updated.

[MaskRay]

update test

lld/ELF/ScriptParser.cpp

792

Nick suggested SHT_STRTAB in https://sourceware.org/pipermail/binutils/2022-February/119594.html

I agree that SHT_STRTAB is not easily usable, so I have dropped it in the diff. We can add it when the need comes.

[peter.smith]

One more section type SHT_GROUP that I think we should disallow, although if GNU ld would prefer to include that we should prefer compatibility.

I'm not sure what the best policy is on setting approval as we've got a dependency on binutils. I'm happy with the implementation. Perhaps it would be useful to commit with an [ALPHA] tag, with explanation, to the feature? That way we reserve the right to make small modifications to the interface to maintain consistency with GNU ld.

lld/ELF/ScriptParser.cpp

794

I think SHT_GROUP may also be too difficult to use without further extensions to linker scripts. It would only be useful in ld -r links as groups don't mean anything in ELF executables and shared libraries. To effectively use them from a linker script we'd need something like SH_IDX("output section name") which the linker would fill in the sh_idx in the output ELF file. I don't think a user could be expected to hard code a number in the linker script.

Apologies I didn't spot this one on the first go.

[MaskRay]

Remove SHT_GROUP.

Thanks for the comments.
The urgence of this syntax is dependent on how much systemd/Fedora abuses the .note* ==> SHT_NOTE behavior
https://bugzilla.redhat.com/show_bug.cgi?id=2052801
Right now now too urgent to me.
We can give binutils more time and I'll keep pinging the binutils discussion.
If for some reason we need to push this earlier, I'll consider adding "experimental".

[MaskRay]

GNU ld added the (TYPE=...) syntax today: https://sourceware.org/pipermail/binutils/2022-February/119789.html
... but it additionally added the awkward .ro.note (READONLY (TYPE=SHT_NOTE)) : { LONG(5678); }.

I think READONLY is an ill advice and we should not follow.

This patch is compatible with GNU ld supported syntax and I think we can move forward.

[peter.smith]

LGTM. At least if we start off without READONLY then we can put it in later if it is needed.

[MaskRay]

Update doc.
Actually remove SHT_GROUP support from code but keep the test

[nathanchance]

I have not done a bisect but it seems likely that this change breaks linking modules for the arm64 Linux kernel, is this expected?

$ make -skj"$(nproc)" ARCH=arm64 LLVM=1 mrproper defconfig all
...
ld.lld: error: section type mismatch for .plt
>>> <internal>:(.plt): SHT_PROGBITS
>>> output section .plt: SHT_NOBITS
...

I believe the .plt handling in the linker script comes from https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/arm64/include/asm/module.lds.h?h=v5.17-rc4.

[MaskRay]

In D118840#3331173, @nathanchance wrote:

I have not done a bisect but it seems likely that this change breaks linking modules for the arm64 Linux kernel, is this expected?

$ make -skj"$(nproc)" ARCH=arm64 LLVM=1 mrproper defconfig all
...
ld.lld: error: section type mismatch for .plt
>>> <internal>:(.plt): SHT_PROGBITS
>>> output section .plt: SHT_NOBITS
...

I believe the .plt handling in the linker script comes from https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/arm64/include/asm/module.lds.h?h=v5.17-rc4.

I do not know whether we want to remove the error for NOLOAD.

.plt 0 (NOLOAD) : { BYTE(0) } looks questionable to me.

Seems that it needs /DISCARD/ : { *(.plt) } if it just wants to leave a one-byte .plt but ignoring the regular .plt.

Alternatively/preferably, drop (NOLOAD). @ardb for kernel fd045f6cd98ec4953147b318418bd45e441e52a3

edit: sent https://lore.kernel.org/linux-arm-kernel/[e-mail]/T/#u
sent one for riscv as well.

[ardb]

In D118840#3331178, @MaskRay wrote:

In D118840#3331173, @nathanchance wrote:

I have not done a bisect but it seems likely that this change breaks linking modules for the arm64 Linux kernel, is this expected?

$ make -skj"$(nproc)" ARCH=arm64 LLVM=1 mrproper defconfig all
...
ld.lld: error: section type mismatch for .plt
>>> <internal>:(.plt): SHT_PROGBITS
>>> output section .plt: SHT_NOBITS
...

I believe the .plt handling in the linker script comes from https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/arm64/include/asm/module.lds.h?h=v5.17-rc4.

I do not know whether we want to remove the error for NOLOAD.

.plt 0 (NOLOAD) : { BYTE(0) } looks questionable to me.

Seems that it needs /DISCARD/ : { *(.plt) } if it just wants to leave a one-byte .plt but ignoring the regular .plt.

Alternatively/preferably, drop (NOLOAD). @ardb for kernel fd045f6cd98ec4953147b318418bd45e441e52a3

edit: sent https://lore.kernel.org/linux-arm-kernel/[e-mail]/T/#u
sent one for riscv as well.

These .plt sections have nothing to do with linker emitted PLTs, so perhaps the name should be improved.

These sections are instantiated by the module loader at runtime, but in order for the module loader to be able to create a section of arbitrary size, it needs to be present in the object file to begin with. This is why the dummy byte is inserted, as otherwise, the section is dropped.

The purpose of these sections is to carry veneers that may or may not be needed to fix up out-of-range direct branches from the module code into the kernel itself or other modules. Whether such veneers are necessary depends on the actual load address of the module. (Veneers are also emitted to work around the Cortex-A53 ADRP erratum #843419, if needed)

If the section name '.plt' is special in some way, I'd be happy to prepare a kernel patch that renames these into something more suitable.

[nathanchance]

In D118840#3331575, @ardb wrote:

If the section name '.plt' is special in some way, I'd be happy to prepare a kernel patch that renames these into something more suitable.

Would this suggested change replace Fangrui's existing patch?

Regardless, @MaskRay, would you consider dropping this error for the time being until the kernel can be patched? At minimum, it is going to take a few weeks for the patch to land in Linus's tree and get backported to stable and I would like to avoid carrying any change in our continuous integration, as it adds additional maintenance overhead. Not to mention we are not the only continuous integration setup that tests with tip of tree LLVM so this breakage is going to be noticed by multiple parties, who won't have the ability to apply patches.

[MaskRay]

In D118840#3332118, @nathanchance wrote:

In D118840#3331575, @ardb wrote:

If the section name '.plt' is special in some way, I'd be happy to prepare a kernel patch that renames these into something more suitable.

Would this suggested change replace Fangrui's existing patch?

Regardless, @MaskRay, would you consider dropping this error for the time being until the kernel can be patched? At minimum, it is going to take a few weeks for the patch to land in Linus's tree and get backported to stable and I would like to avoid carrying any change in our continuous integration, as it adds additional maintenance overhead. Not to mention we are not the only continuous integration setup that tests with tip of tree LLVM so this breakage is going to be noticed by multiple parties, who won't have the ability to apply patches.

Downgraded (NOLOAD) error to warning with https://reviews.llvm.org/rGcb0a4bb5be10636aaec3ecb56ed586dee3eb0b9e

https://github.com/ClangBuiltLinux/linux/issues/1597 has more discussions.

[manojgupta]

This change is breaking rust embedded use cases where NOLOAD in a linker script is no longer being honored. So we had to revert it (locally) in ChromeOS.

example:

#[link_section = ".arena"]
static mut IMAGE_DATA: [i8; NUM_PIXELS] = [0i8; NUM_PIXELS];

Linker script :

PROVIDE( end = . );
      SECTIONS {
          .arena (NOLOAD) :
          {
                  _farena = .;
                  *(.arena)
                  _earena = .;
          } > arena
      }

With this commit where NOBITS is changed to PROGBITS.

Before:
  [ 8] .arena            NOBITS          60000000 006000 012c00 00  WA  0   0  1
After:
  [ 8] .arena            PROGBITS        60000000 006000 012c00 00  WA  0   0  1

This seems to break a common use case in rust embedded
e.g. https://github.com/rust-embedded/cortex-m/commit/94fbbe01189f97aefa8d6a97cc7cd73e5c6f6ec9

Rust currently do not have a specify to section type and I am not sure llvm even provides an API for that.

@peter.smith wdyt? Should this be reverted for now since it breaks rust embedded without any short term alternatives.
Fangrui currently is out so we prefer to not revert outright before consulting you.

[MaskRay]

In D118840#3495114, @manojgupta wrote:

This change is breaking rust embedded use cases where NOLOAD in a linker script is no longer being honored. So we had to revert it (locally) in ChromeOS.

example:

#[link_section = ".arena"]
static mut IMAGE_DATA: [i8; NUM_PIXELS] = [0i8; NUM_PIXELS];

Linker script :

PROVIDE( end = . );
      SECTIONS {
          .arena (NOLOAD) :
          {
                  _farena = .;
                  *(.arena)
                  _earena = .;
          } > arena
      }

With this commit where NOBITS is changed to PROGBITS.

Before:
  [ 8] .arena            NOBITS          60000000 006000 012c00 00  WA  0   0  1
After:
  [ 8] .arena            PROGBITS        60000000 006000 012c00 00  WA  0   0  1

This seems to break a common use case in rust embedded
e.g. https://github.com/rust-embedded/cortex-m/commit/94fbbe01189f97aefa8d6a97cc7cd73e5c6f6ec9

Rust currently do not have a specify to section type and I am not sure llvm even provides an API for that.

@peter.smith wdyt? Should this be reverted for now since it breaks rust embedded without any short term alternatives.
Fangrui currently is out so we prefer to not revert outright before consulting you.

This is an issue with the Rust linker script and I don't think there is sufficient justification to revert the patch in the upstream. (Reverting Chrome OS local one is certainly fine).
Think of another case that an input .arena has type SHT_PROGBITS but with non-all-zero content, the output type being SHT_NOBITS will be broken without any diagnostic.

In the current state, ld.lld actually emits a warning:

% ld.lld @response.txt 
ld.lld: warning: section type mismatch for .arena
>>> path/to/fpga_rom-2c6c7738d58296f2.fpga_rom.52cb7a2a-cgu.0.rcgu.o:(.arena): SHT_PROGBITS
>>> output section .arena: SHT_NOBITS

Whether it is necessary to have support SHT_NOBITS output with SHT_PROGBITS input without any diagnostic? I think there is no sufficient evidence this is a common request.

To be fair, there are more problems with the linker script, including the superfluous parens surrounding input section descriptions { ... (*(.trap)) (*(.trap.rust)) }.
This does not work with GNU ld but currently is not detected by lld.

[manojgupta]

We can close the discussion as Fangrui has uploaded https://reviews.llvm.org/D125074 to keep older behavior.

lld/ELF/OutputSections.h

public:
   SmallVector<SectionCommand *, 0> commands;
   SmallVector<StringRef, 0> phdrs;
   llvm::Optional<std::array<uint8_t, 4>> filler;
   ConstraintKind constraint = ConstraintKind::NoConstraint;
   std::string location;
   std::string memoryRegionName;
   std::string lmaRegionName;
   bool nonAlloc = false;
-  bool noload = false;
+  bool typeIsSet = false;
   bool expressionsUseSymbols = false;
   bool usedInExpression = false;
   bool inOverlay = false;
 
   // Tracks whether the section has ever had an input section added to it, even
   // if the section was later removed (e.g. because it is a synthetic section
   // that wasn't needed). This is needed for orphan placement.
   bool hasInputSections = false;

lld/ELF/OutputSections.cpp

void OutputSection::recordSection(InputSectionBase *isec) {
   auto *isd = cast<InputSectionDescription>(commands.back());
   isd->sectionBases.push_back(isec);
 }
 
 // Update fields (type, flags, alignment, etc) according to the InputSection
 // isec. Also check whether the InputSection flags and type are consistent with
 // other InputSections.
 void OutputSection::commitSection(InputSection *isec) {
+  if (LLVM_UNLIKELY(type != isec->type)) {
+    if (hasInputSections || typeIsSet) {
+      if (typeIsSet || !canMergeToProgbits(type) ||
+          !canMergeToProgbits(isec->type)) {
+        errorOrWarn("section type mismatch for " + isec->name + "\n>>> " +
+                    toString(isec) + ": " +
+                    getELFSectionTypeName(config->emachine, isec->type) +
+                    "\n>>> output section " + name + ": " +
+                    getELFSectionTypeName(config->emachine, type));
+      }
+      type = SHT_PROGBITS;
+    } else {
+      type = isec->type;
+    }
+  }
   if (!hasInputSections) {
     // If IS is the first section to be added to this section,
     // initialize type, entsize and flags from isec.
     hasInputSections = true;
-    type = isec->type;
     entsize = isec->entsize;
     flags = isec->flags;
   } else {
     // Otherwise, check if new type or flags are compatible with existing ones.
     if ((flags ^ isec->flags) & SHF_TLS)
-      error("incompatible section flags for " + name + "\n>>> " + toString(isec) +
-            ": 0x" + utohexstr(isec->flags) + "\n>>> output section " + name +
-            ": 0x" + utohexstr(flags));
-
-    if (type != isec->type) {
-      if (!canMergeToProgbits(type) || !canMergeToProgbits(isec->type))
-        error("section type mismatch for " + isec->name + "\n>>> " +
-              toString(isec) + ": " +
-              getELFSectionTypeName(config->emachine, isec->type) +
-              "\n>>> output section " + name + ": " +
-              getELFSectionTypeName(config->emachine, type));
-      type = SHT_PROGBITS;
-    }
+      error("incompatible section flags for " + name + "\n>>> " +
+            toString(isec) + ": 0x" + utohexstr(isec->flags) +
+            "\n>>> output section " + name + ": 0x" + utohexstr(flags));
   }
-  if (noload)
-    type = SHT_NOBITS;
 
   isec->parent = this;
   uint64_t andMask =
       config->emachine == EM_ARM ? (uint64_t)SHF_ARM_PURECODE : 0;
   uint64_t orMask = ~andMask;
   uint64_t andFlags = (flags & isec->flags) & andMask;
   uint64_t orFlags = (flags | isec->flags) & orMask;
   flags = andFlags | orFlags;
template <class ELFT> void OutputSection::writeTo(uint8_t *buf) {
 
   // Linker scripts may have BYTE()-family commands with which you
   // can write arbitrary bytes to the output. Process them if any.
   for (SectionCommand *cmd : commands)
     if (auto *data = dyn_cast<ByteCommand>(cmd))
       writeInt(buf + data->offset, data->expression().getValue(), data->size);
 }
 
-static void finalizeShtGroup(OutputSection *os,
-                             InputSection *section) {
-  assert(config->relocatable);
-
+static void finalizeShtGroup(OutputSection *os, InputSection *section) {
   // sh_link field for SHT_GROUP sections should contain the section index of
   // the symbol table.
   os->link = in.symTab->getParent()->sectionIndex;
 
+  if (!section)
+    return;
+
   // sh_info then contain index of an entry in symbol table section which
   // provides signature of the section group.
   ArrayRef<Symbol *> symbols = section->file->getSymbols();
   os->info = in.symTab->getSymbolIndex(symbols[section->info]);
 
   // Some group members may be combined or discarded, so we need to compute the
   // new size. The content will be rewritten in InputSection::copyShtGroup.
   DenseSet<uint32_t> seen;

lld/ELF/ScriptParser.cpp

Expr ScriptParser::readAssert() {
 
   return [=] {
     if (!e().getValue())
       errorOrWarn(msg);
     return script->getDot();
   };
 }
 
+#define ECase(X)                                                               \
+  { #X, X }
+constexpr std::pair<const char *, unsigned> typeMap[] = {
+    ECase(SHT_PROGBITS),   ECase(SHT_NOTE),       ECase(SHT_NOBITS),
+    ECase(SHT_INIT_ARRAY), ECase(SHT_FINI_ARRAY), ECase(SHT_PREINIT_ARRAY),
+};
+#undef ECase
+
 // Tries to read the special directive for an output section definition which
-// can be one of following: "(NOLOAD)", "(COPY)", "(INFO)" or "(OVERLAY)".
-// Tok1 and Tok2 are next 2 tokens peeked. See comment for readSectionAddressType below.
+// can be one of following: "(NOLOAD)", "(COPY)", "(INFO)", "(OVERLAY)", and
+// "(TYPE=<value>)".
+// Tok1 and Tok2 are next 2 tokens peeked. See comment for
+// readSectionAddressType below.
 bool ScriptParser::readSectionDirective(OutputSection *cmd, StringRef tok1, StringRef tok2) {
   if (tok1 != "(")
     return false;
-  if (tok2 != "NOLOAD" && tok2 != "COPY" && tok2 != "INFO" && tok2 != "OVERLAY")
+  if (tok2 != "NOLOAD" && tok2 != "COPY" && tok2 != "INFO" &&
+      tok2 != "OVERLAY" && tok2 != "TYPE")
     return false;
 
   expect("(");
   if (consume("NOLOAD")) {
-    cmd->noload = true;
     cmd->type = SHT_NOBITS;
+    cmd->typeIsSet = true;
+  } else if (consume("TYPE")) {
+    expect("=");
+    StringRef value = peek();
+    auto it = llvm::find_if(typeMap, [=](auto e) { return e.first == value; });
+    if (it != std::end(typeMap)) {
+      // The value is a recognized literal SHT_*.
+      cmd->type = it->second;
+      skip();
+    } else if (value.startswith("SHT_")) {
+      setError("unknown section type " + value);
+    } else {
+      // Otherwise, read an expression.
+      cmd->type = readExpr()().getValue();
+    }
+    cmd->typeIsSet = true;
   } else {
     skip(); // This is "COPY", "INFO" or "OVERLAY".
     cmd->nonAlloc = true;
   }
   expect(")");
   return true;
 }
 
 // Reads an expression and/or the special directive for an output
 // section definition. Directive is one of following: "(NOLOAD)",
 // "(COPY)", "(INFO)" or "(OVERLAY)".
 //
 // An output section name can be followed by an address expression
 // and/or directive. This grammar is not LL(1) because "(" can be
 // interpreted as either the beginning of some expression or beginning
 // of directive.
 //
 // https://sourceware.org/binutils/docs/ld/Output-Section-Address.html
 // https://sourceware.org/binutils/docs/ld/Output-Section-Type.html
 void ScriptParser::readSectionAddressType(OutputSection *cmd) {
-  if (readSectionDirective(cmd, peek(), peek2()))
+  // Temporarily set inExpr to support TYPE=<value> without spaces.
+  bool saved = std::exchange(inExpr, true);
+  bool isDirective = readSectionDirective(cmd, peek(), peek2());
+  inExpr = saved;
+  if (isDirective)
     return;
 
   cmd->addrExpr = readExpr();
   if (peek() == "(" && !readSectionDirective(cmd, "(", peek2()))
     setError("unknown section directive: " + peek2());
 }
 
 static Expr checkAlignment(Expr e, std::string &loc) {

lld/docs/ELF/linker_script.rst

 Output section type
 -------------------
 
 When an *OutputSection* *S* has ``(type)``, LLD will set ``sh_type`` or
 ``sh_flags`` of *S*. ``type`` is one of:
 
 - ``NOLOAD``: set ``sh_type`` to ``SHT_NOBITS``.
 - ``COPY``, ``INFO``, ``OVERLAY``: clear the ``SHF_ALLOC`` bit in ``sh_flags``.
+- ``TYPE=<value>``: set ``sh_type`` to the specified value. ``<value>`` must be
+  an integer or one of ``SHT_PROGBITS, SHT_NOTE, SHT_NOBITS, SHT_INIT_ARRAY,
+  SHT_FINI_ARRAY, SHT_PREINIT_ARRAY``.
+
+When ``sh_type`` is specified, it is an error if an input section in *S* has a
+different type.
 
 Output section alignment
 ------------------------
 
 sh_addralign of an *OutputSection* *S* is the maximum of
 ``ALIGN(section_align)`` and the maximum alignment of the input sections in
 *S*.
 

lld/test/ELF/linkerscript/custom-section-type.s

+# REQUIRES: x86
+## TYPE=<value> customizes the output section type.
+
+# RUN: rm -rf %t && split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t/a.s -o %t/a.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t/mismatch.s -o %t/mismatch.o
+# RUN: ld.lld -T %t/a.lds %t/a.o -o %t/a
+# RUN: llvm-readelf -S %t/a | FileCheck %s
+
+# RUN: ld.lld -r -T %t/a.lds %t/a.o -o %t/a.ro
+# RUN: llvm-readelf -S %t/a.ro | FileCheck %s
+
+# CHECK:       [Nr] Name              Type            Address          Off      Size   ES Flg Lk Inf Al
+# CHECK-NEXT:  [ 0]                   NULL            [[#%x,]]         [[#%x,]] 000000 00      0   0  0
+# CHECK-NEXT:  [ 1] progbits          PROGBITS        [[#%x,]]         [[#%x,]] 000001 00   A  0   0  1
+# CHECK-NEXT:  [ 2] note              NOTE            [[#%x,]]         [[#%x,]] 000002 00   A  0   0  1
+# CHECK-NEXT:  [ 3] nobits            NOBITS          [[#%x,]]         [[#%x,]] 000001 00   A  0   0  1
+# CHECK-NEXT:  [ 4] init_array        INIT_ARRAY      [[#%x,]]         [[#%x,]] 000008 00   A  0   0  1
+# CHECK-NEXT:  [ 5] fini_array        FINI_ARRAY      [[#%x,]]         [[#%x,]] 000008 00   A  0   0  1
+# CHECK-NEXT:  [ 6] preinit_array     PREINIT_ARRAY   [[#%x,]]         [[#%x,]] 000008 00   A  0   0  1
+# CHECK-NEXT:  [ 7] group             GROUP           [[#%x,]]         [[#%x,]] 000004 00   A [[#SYMTAB:]] 0  1
+# CHECK-NEXT:  [ 8] expr              0x42: <unknown> [[#%x,]]         [[#%x,]] 000001 00   A  0   0  1
+# CHECK:       [[[#SYMTAB]]] .symtab  SYMTAB
+
+# RUN: not ld.lld -T %t/a.lds %t/a.o %t/mismatch.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR1
+
+# ERR1:      error: section type mismatch for progbits
+# ERR1-NEXT: >>> {{.*}}.o:(progbits): SHT_NOTE
+# ERR1-NEXT: >>> output section progbits: SHT_PROGBITS
+# ERR1:      error: section type mismatch for expr
+# ERR1-NEXT: >>> {{.*}}.o:(expr): Unknown
+# ERR1-NEXT: >>> output section expr: Unknown
+
+# RUN: ld.lld -T %t/a.lds %t/a.o %t/mismatch.o -o %t/mismatch --noinhibit-exec
+# RUN: llvm-readelf -S %t/mismatch | FileCheck %s --check-prefix=MISMATCH
+
+## Mismatched progbits and expr are changed to SHT_PROGBITS.
+# MISMATCH: progbits PROGBITS
+# MISMATCH: note     NOTE
+# MISMATCH: expr     PROGBITS
+
+# RUN: not ld.lld -T %t/unknown1.lds %t/a.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=UNKNOWN1
+# UNKNOWN1: error: {{.*}}.lds:1: symbol not found: foo
+
+## For a symbol named SHT_*, give a better diagnostic.
+# RUN: not ld.lld -T %t/unknown2.lds %t/a.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=UNKNOWN2
+# UNKNOWN2: error: {{.*}}.lds:1: unknown section type SHT_DYNAMIC
+
+# RUN: not ld.lld -T %t/parseerr1.lds %t/a.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=PARSEERR1
+# PARSEERR1: error: {{.*}}.lds:1: = expected, but got )
+
+#--- a.s
+.globl _start, myinit
+_start:
+  ret
+myinit:
+  ret
+
+## Compatible with TYPE = SHT_NOTE below.
+.section note,"a",@note
+.byte 0
+
+#--- a.lds
+SECTIONS {
+  progbits (TYPE=SHT_PROGBITS) : { BYTE(1) }
+  note (TYPE = SHT_NOTE) : { BYTE(7) *(note) }
+  nobits ( TYPE=SHT_NOBITS) : { BYTE(8) }
+  init_array (TYPE=SHT_INIT_ARRAY ) : { QUAD(myinit) }
+  fini_array (TYPE=SHT_FINI_ARRAY) : { QUAD(15) }
+  preinit_array (TYPE=SHT_PREINIT_ARRAY) : { QUAD(16) }
+  group (TYPE=17) : { LONG(17) }
+  expr (TYPE=0x41+1) : { BYTE(0x42) *(expr) }
+}
+
+#--- mismatch.s
+.section progbits,"a",@note
+.byte 0
+
+.section expr,"a",@12345
+.byte 0
+
+#--- unknown1.lds
+SECTIONS { err (TYPE=foo) : {} }
+
+#--- unknown2.lds
+SECTIONS { err (TYPE=SHT_DYNAMIC) : {} }
+
+#--- parseerr1.lds
+SECTIONS { err (TYPE) : {} }

lld/test/ELF/linkerscript/noload.s

 # REQUIRES: x86
 # RUN: split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %t/asm -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/mismatch.s -o %t/mismatch.o
 # RUN: ld.lld --script %t/lds %t.o -o %t/out
 # RUN: llvm-readelf -S -l %t/out | FileCheck %s
 
 # CHECK:      Name                 Type   Address          Off               Size
 # CHECK:      .data_noload_a       NOBITS 0000000000000000 [[OFF:[0-9a-f]+]] 001000
 # CHECK-NEXT: .data_noload_b       NOBITS 0000000000010000 [[OFF]]           001000
 # CHECK-NEXT: .no_input_sec_noload NOBITS 0000000000011000 [[OFF]]           000001
 
 # CHECK:      Type Offset   VirtAddr           PhysAddr
 # CHECK-NEXT: LOAD 0x001000 0x0000000000000000 0x0000000000000000
 # CHECK-NEXT: LOAD 0x001000 0x0000000000020000 0x0000000000020000
 
 # CHECK:      00 .data_noload_a .data_noload_b .no_input_sec_noload {{$}}
 # CHECK:      01 .text {{$}}
 
+# RUN: not ld.lld --script %t/lds %t.o %t/mismatch.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR
+
+# ERR: error: section type mismatch for .data_noload_a
+
 #--- asm
 .section .text,"ax",@progbits
   nop
 
-.section .data_noload_a,"aw",@progbits
+.section .data_noload_a,"aw",@nobits
 .zero 4096
 
-.section .data_noload_b,"aw",@progbits
+.section .data_noload_b,"aw",@nobits
 .zero 4096
 
+#--- mismatch.s
+.section .data_noload_a,"aw",@progbits
+.byte 1
+
 #--- lds
 SECTIONS {
   .data_noload_a (NOLOAD) : { *(.data_noload_a) }
   .data_noload_b (0x10000) (NOLOAD) : { *(.data_noload_b) }
   .no_input_sec_noload (NOLOAD) : { . += 1; }
   .text (0x20000) : { *(.text) }
 }