Change which input sections we concatenate

[• espindola]

Summary

After Mark's patch I was wondering what was the rationale for the ELF spec requiring us to merge only sections with matching flags and types. I tried emailing https://groups.google.com/forum/#!forum/generic-abi, but looks like my emails are not being posted (the list is probably moderated). I emailed Cary Coutant instead.

Cary pointed out that the section was a late addition and didn't got the scrutiny it deserved. Given that and the problems found by implementing the letter of the standard, I propose changing lld to merge all sections with the same name and issue errors if the types or some critical flags are different.

This should allow an unmodified firefox linked with lld to run.

This also merges some code with the linkerscript path.

[ruiu]

LGTM with a nit.

ELF/OutputSections.cpp

546

It -> it

[kettenis]

FWIW, the Solaris linker doesn't merge sections purely on based on name, but the GNU linker does so there probably is plenty of code that depends on this "feature".

[emaste]

FreeBSD EFI loader build now fails with:

--- all_subdir_sys ---
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name copy.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name devicename.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name main.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name smbios.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name zfs.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name elf64_freebsd.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name trap.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name comconsole.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name boot.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name interp.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name interp_parse.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name module.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name load_elf32.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name load_elf64.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name disk.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name bcache.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name libefi.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name efipart.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name efinet.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: Section has different type from others with the same name efi_console.o:(.bss)
/tank/emaste/obj/tank/emaste/src/freebsd-xlld/tmp/usr/bin/ld: error: too many errors emitted, stopping now (use -error-limit=0 to see all errors)
cc: error: linker command failed with exit code 1 (use -v to see invocation)
*** [loader.sym.full] Error code 1

Although the EFI loader worked prior to this change, the error is presumably identifying something we need to to fix in the loader.

Could we perhaps indicate the conflicting type in the error message?

ELF/LinkerScript.cpp

for (const std::unique_ptr<BaseCommand> &Base : OutCmd.Commands) {
     for (InputSectionData *S : Cmd->Sections)
       Ret.push_back(static_cast<InputSectionBase<ELFT> *>(S));
   }
 
   return Ret;
 }
 
 template <class ELFT>
-static SectionKey<ELFT::Is64Bits> createKey(InputSectionBase<ELFT> *C,
-                                            StringRef OutsecName) {
-  // When using linker script the merge rules are different.
-  // Unfortunately, linker scripts are name based. This means that expressions
-  // like *(.foo*) can refer to multiple input sections that would normally be
-  // placed in different output sections. We cannot put them in different
-  // output sections or we would produce wrong results for
-  // start = .; *(.foo.*) end = .; *(.bar)
-  // and a mapping of .foo1 and .bar1 to one section and .foo2 and .bar2 to
-  // another. The problem is that there is no way to layout those output
-  // sections such that the .foo sections are the only thing between the
-  // start and end symbols.
-
-  // An extra annoyance is that we cannot simply disable merging of the contents
-  // of SHF_MERGE sections, but our implementation requires one output section
-  // per "kind" (string or not, which size/aligment).
-  // Fortunately, creating symbols in the middle of a merge section is not
-  // supported by bfd or gold, so we can just create multiple section in that
-  // case.
-  typedef typename ELFT::uint uintX_t;
-  uintX_t Flags = C->Flags & (SHF_MERGE | SHF_STRINGS);
-
-  uintX_t Alignment = 0;
-  if (isa<MergeInputSection<ELFT>>(C))
-    Alignment = std::max<uintX_t>(C->Alignment, C->Entsize);
-
-  return SectionKey<ELFT::Is64Bits>{OutsecName, /*Type*/ 0, Flags, Alignment};
-}
-
-template <class ELFT>
 void LinkerScript<ELFT>::addSection(OutputSectionFactory<ELFT> &Factory,
                                     InputSectionBase<ELFT> *Sec,
                                     StringRef Name) {
   OutputSectionBase *OutSec;
   bool IsNew;
-  std::tie(OutSec, IsNew) = Factory.create(createKey(Sec, Name), Sec);
+  std::tie(OutSec, IsNew) = Factory.create(Sec, Name);
   if (IsNew)
     OutputSections->push_back(OutSec);
   OutSec->addSection(Sec);
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::processCommands(OutputSectionFactory<ELFT> &Factory) {
   for (unsigned I = 0; I < Opt.Commands.size(); ++I) {

ELF/OutputSections.h

template <class ELFT> struct Out {
   static OutputSectionBase *PreinitArray;
   static OutputSectionBase *InitArray;
   static OutputSectionBase *FiniArray;
 };
 
 template <bool Is64Bits> struct SectionKey {
   typedef typename std::conditional<Is64Bits, uint64_t, uint32_t>::type uintX_t;
   StringRef Name;
-  uint32_t Type;
   uintX_t Flags;
   uintX_t Alignment;
 };
 
 // This class knows how to create an output section for a given
 // input section. Output section type is determined by various
 // factors, including input section's sh_flags, sh_type and
 // linker scripts.

ELF/OutputSections.cpp

 template <class ELFT>
 static typename ELFT::uint getOutFlags(InputSectionBase<ELFT> *S) {
   return S->Flags & ~SHF_GROUP & ~SHF_COMPRESSED;
 }
 
 template <class ELFT>
 static SectionKey<ELFT::Is64Bits> createKey(InputSectionBase<ELFT> *C,
                                             StringRef OutsecName) {
+  //  The ELF spec just says
+  // ----------------------------------------------------------------
+  // In the first phase, input sections that match in name, type and
+  // attribute flags should be concatenated into single sections.
+  // ----------------------------------------------------------------
+  //
+  // However, It is clear that at least some flags have to be ignored for
+  // section merging. At the very least SHF_GROUP and SHF_COMPRESSED have to be
+  // ignored. We should not have two output .text sections just because one was
+  // in a group and another was not for example.
+  //
+  // It also seems that that wording was a late addition and didn't get the
+  // necessary scrutiny.
+  //
+  // Merging sections with different flags is expected by some users. One
+  // reason is that if one file has
+  //
+  // int *const bar __attribute__((section(".foo"))) = (int *)0;
+  //
+  // gcc with -fPIC will produce a read only .foo section. But if another
+  // file has
+  //
+  // int zed;
+  // int *const bar __attribute__((section(".foo"))) = (int *)&zed;
+  //
+  // gcc with -fPIC will produce a read write section.
+  //
+  // Last but not least, when using linker script the merge rules are forced by
+  // the script. Unfortunately, linker scripts are name based. This means that
+  // expressions like *(.foo*) can refer to multiple input sections with
+  // different flags. We cannot put them in different output sections or we
+  // would produce wrong results for
+  //
+  // start = .; *(.foo.*) end = .; *(.bar)
+  //
+  // and a mapping of .foo1 and .bar1 to one section and .foo2 and .bar2 to
+  // another. The problem is that there is no way to layout those output
+  // sections such that the .foo sections are the only thing between the start
+  // and end symbols.
+  //
+  // Given the above issues, we instead merge sections by name and error on
+  // incompatible types and flags.
+  //
+  // The exception being SHF_MERGE, where we create different output sections
+  // for each alignment. This makes each output section simple. In case of
+  // relocatable object generation we do not try to perform merging and treat
+  // SHF_MERGE sections as regular ones, but also create different output
+  // sections for them to allow merging at final linking stage.
+  //
+  // Fortunately, creating symbols in the middle of a merge section is not
+  // supported by bfd or gold, so the SHF_MERGE exception should not cause
+  // problems with most linker scripts.
+
   typedef typename ELFT::uint uintX_t;
-  uintX_t Flags = getOutFlags(C);
+  uintX_t Flags = C->Flags & (SHF_MERGE | SHF_STRINGS);
 
-  // For SHF_MERGE we create different output sections for each alignment.
-  // This makes each output section simple and keeps a single level mapping from
-  // input to output.
-  // In case of relocatable object generation we do not try to perform merging
-  // and treat SHF_MERGE sections as regular ones, but also create different
-  // output sections for them to allow merging at final linking stage.
   uintX_t Alignment = 0;
   if (isa<MergeInputSection<ELFT>>(C) ||
       (Config->Relocatable && (C->Flags & SHF_MERGE)))
     Alignment = std::max<uintX_t>(C->Alignment, C->Entsize);
 
-  return SectionKey<ELFT::Is64Bits>{OutsecName, C->Type, Flags, Alignment};
+  return SectionKey<ELFT::Is64Bits>{OutsecName, Flags, Alignment};
 }
 
 template <class ELFT>
 std::pair<OutputSectionBase *, bool>
 OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
                                    StringRef OutsecName) {
   SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
   return create(Key, C);
 }
 
+static uint64_t getIncompatibleFlags(uint64_t Flags) {
+  return Flags & (SHF_ALLOC | SHF_TLS);
+}
+
 template <class ELFT>
 std::pair<OutputSectionBase *, bool>
 OutputSectionFactory<ELFT>::create(const SectionKey<ELFT::Is64Bits> &Key,
                                    InputSectionBase<ELFT> *C) {
   uintX_t Flags = getOutFlags(C);
   OutputSectionBase *&Sec = Map[Key];
   if (Sec) {
+    if (getIncompatibleFlags(Sec->Flags) != getIncompatibleFlags(C->Flags))
+      error("Section has flags incompatible with others with the same name " +
+            toString(C));
+    if (Sec->Type != C->Type)
+      error("Section has different type from others with the same name " +
+            toString(C));
     Sec->Flags |= Flags;
     return {Sec, false};
   }
 
   uint32_t Type = C->Type;
   switch (C->kind()) {
   case InputSectionBase<ELFT>::Regular:
   case InputSectionBase<ELFT>::Synthetic:
     Sec = make<OutputSection<ELFT>>(Key.Name, Type, Flags);
     break;
   case InputSectionBase<ELFT>::EHFrame:
     return {Out<ELFT>::EhFrame, false};
   case InputSectionBase<ELFT>::Merge:
     Sec = make<MergeOutputSection<ELFT>>(Key.Name, Type, Flags, Key.Alignment);
     break;
   }
   return {Sec, true};
 }
 
 template <bool Is64Bits>
 typename lld::elf::SectionKey<Is64Bits>
 DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getEmptyKey() {
-  return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0, 0};
+  return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0};
 }
 
 template <bool Is64Bits>
 typename lld::elf::SectionKey<Is64Bits>
 DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getTombstoneKey() {
-  return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getTombstoneKey(), 0, 0,
-                              0};
+  return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getTombstoneKey(), 0, 0};
 }
 
 template <bool Is64Bits>
 unsigned
 DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getHashValue(const Key &Val) {
-  return hash_combine(Val.Name, Val.Type, Val.Flags, Val.Alignment);
+  return hash_combine(Val.Name, Val.Flags, Val.Alignment);
 }
 
 template <bool Is64Bits>
 bool DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::isEqual(const Key &LHS,
                                                            const Key &RHS) {
   return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
-         LHS.Type == RHS.Type && LHS.Flags == RHS.Flags &&
-         LHS.Alignment == RHS.Alignment;
+         LHS.Flags == RHS.Flags && LHS.Alignment == RHS.Alignment;
 }
 
 namespace llvm {
 template struct DenseMapInfo<SectionKey<true>>;
 template struct DenseMapInfo<SectionKey<false>>;
 }
 
 namespace lld {

test/ELF/incompatible-section-flags.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: not ld.lld -shared %t.o -o %t 2>&1 | FileCheck %s
+
+// CHECK: error:  Section has flags incompatible with others with the same name {{.*}}incompatible-section-flags.s.tmp.o:(.foo)
+// CHECK: error:  Section has flags incompatible with others with the same name {{.*}}incompatible-section-flags.s.tmp.o:(.bar)
+
+.section .foo, "awT", @progbits, unique, 1
+.quad 0
+
+.section .foo, "aw", @progbits, unique, 2
+.quad 0
+
+
+.section .bar, "aw", @progbits, unique, 3
+.quad 0
+
+.section .bar, "awT", @progbits, unique, 4
+.quad 0

test/ELF/incompatible-section-types.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: not ld.lld -shared %t.o -o %t 2>&1 | FileCheck %s
+
+// CHECK: error: Section has different type from others with the same name {{.*}}incompatible-section-types.s.tmp.o:(.foo)
+
+.section .foo, "aw", @progbits, unique, 1
+.quad 0
+
+.section .foo, "aw", @nobits, unique, 2
+.quad 0

test/ELF/linkerscript/phdrs.s

 # AT-NEXT:      Flags [ (0x7)
 # AT-NEXT:        PF_R (0x4)
 # AT-NEXT:        PF_W (0x2)
 # AT-NEXT:        PF_X (0x1)
 # AT-NEXT:      ]
 
 ## Check the numetic values for PHDRS.
 # RUN: echo "PHDRS {text PT_LOAD FILEHDR PHDRS; foo 0x11223344; } \
-# RUN:       SECTIONS { . = SIZEOF_HEADERS; .foo : { *(.*) } : text : foo}" > %t1.script
+# RUN:       SECTIONS { . = SIZEOF_HEADERS; .foo : { *(.foo* .text*) } : text : foo}" > %t1.script
 # RUN: ld.lld -o %t2 --script %t1.script %t
 # RUN: llvm-readobj -program-headers %t2 | FileCheck --check-prefix=INT-PHDRS %s
 
 # INT-PHDRS:      ProgramHeaders [
 # INT-PHDRS:        ProgramHeader {
 # INT-PHDRS:           Type:  (0x11223344)
 # INT-PHDRS-NEXT:      Offset: 0xB0
 # INT-PHDRS-NEXT:      VirtualAddress: 0xB0

test/ELF/linkerscript/sections.s

 # RUN: llvm-objdump -section-headers %t2 | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 
 #             Idx Name          Size
 # SEC-DEFAULT: 1 .text         0000000e {{[0-9a-f]*}} TEXT DATA
 # SEC-DEFAULT: 2 .data         00000020 {{[0-9a-f]*}} DATA
 # SEC-DEFAULT: 3 other         00000003 {{[0-9a-f]*}} DATA
 # SEC-DEFAULT: 4 .bss          00000002 {{[0-9a-f]*}} BSS
-# SEC-DEFAULT: 5 .shstrtab     00000002 {{[0-9a-f]*}}
-# SEC-DEFAULT: 6 .comment      00000008 {{[0-9a-f]*}}
-# SEC-DEFAULT: 7 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-DEFAULT: 8 .shstrtab     0000003b {{[0-9a-f]*}}
-# SEC-DEFAULT: 9 .strtab       00000008 {{[0-9a-f]*}}
+# SEC-DEFAULT: 5 .comment      00000008 {{[0-9a-f]*}}
+# SEC-DEFAULT: 6 .symtab       00000030 {{[0-9a-f]*}}
+# SEC-DEFAULT: 7 .shstrtab     0000003b {{[0-9a-f]*}}
+# SEC-DEFAULT: 8 .strtab       00000008 {{[0-9a-f]*}}
 
 # Sections are put in order specified in linker script, other than alloc
 # sections going first.
 # RUN: echo "SECTIONS { \
 # RUN:          .bss : { *(.bss) } \
 # RUN:          other : { *(other) } \
 # RUN:          .shstrtab : { *(.shstrtab) } \
 # RUN:          .symtab : { *(.symtab) } \
 # RUN:          .strtab : { *(.strtab) } \
 # RUN:          .data : { *(.data) } \
 # RUN:          .text : { *(.text) } }" > %t.script
 # RUN: ld.lld -o %t3 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t3 | \
 # RUN:   FileCheck -check-prefix=SEC-ORDER %s
 
 #           Idx Name          Size
 # SEC-ORDER: 1 .bss          00000002 {{[0-9a-f]*}} BSS
 # SEC-ORDER: 2 other         00000003 {{[0-9a-f]*}} DATA
-# SEC-ORDER: 3 .shstrtab     00000002 {{[0-9a-f]*}}
-# SEC-ORDER: 4 .shstrtab     0000003b {{[0-9a-f]*}}
-# SEC-ORDER: 5 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-ORDER: 6 .strtab       00000008 {{[0-9a-f]*}}
-# SEC-ORDER: 7 .data         00000020 {{[0-9a-f]*}} DATA
-# SEC-ORDER: 8 .text         0000000e {{[0-9a-f]*}} TEXT DATA
+# SEC-ORDER: 3 .shstrtab     0000003b {{[0-9a-f]*}}
+# SEC-ORDER: 4 .symtab       00000030 {{[0-9a-f]*}}
+# SEC-ORDER: 5 .strtab       00000008 {{[0-9a-f]*}}
+# SEC-ORDER: 6 .data         00000020 {{[0-9a-f]*}} DATA
+# SEC-ORDER: 7 .text         0000000e {{[0-9a-f]*}} TEXT DATA
 
 # .text and .data have swapped names but proper sizes and types.
 # RUN: echo "SECTIONS { \
 # RUN:          .data : { *(.text) } \
 # RUN:          .text : { *(.data) } }" > %t.script
 # RUN: ld.lld -o %t4 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t4 | \
 # RUN:   FileCheck -check-prefix=SEC-SWAP-NAMES %s
 
 #                Idx Name          Size
 # SEC-SWAP-NAMES: 1 .data         0000000e {{[0-9a-f]*}} TEXT DATA
 # SEC-SWAP-NAMES: 2 .text         00000020 {{[0-9a-f]*}} DATA
 # SEC-SWAP-NAMES: 3 other         00000003 {{[0-9a-f]*}} DATA
 # SEC-SWAP-NAMES: 4 .bss          00000002 {{[0-9a-f]*}} BSS
-# SEC-SWAP-NAMES: 5 .shstrtab     00000002 {{[0-9a-f]*}}
-# SEC-SWAP-NAMES: 6 .comment      00000008 {{[0-9a-f]*}}
-# SEC-SWAP-NAMES: 7 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-SWAP-NAMES: 8 .shstrtab     0000003b {{[0-9a-f]*}}
-# SEC-SWAP-NAMES: 9 .strtab       00000008 {{[0-9a-f]*}}
+# SEC-SWAP-NAMES: 5 .comment      00000008 {{[0-9a-f]*}}
+# SEC-SWAP-NAMES: 6 .symtab       00000030 {{[0-9a-f]*}}
+# SEC-SWAP-NAMES: 7 .shstrtab     0000003b {{[0-9a-f]*}}
+# SEC-SWAP-NAMES: 8 .strtab       00000008 {{[0-9a-f]*}}
 
 # .shstrtab from the input object file is discarded.
 # RUN: echo "SECTIONS { \
 # RUN:          /DISCARD/ : { *(.shstrtab) } }" > %t.script
 # RUN: ld.lld -o %t5 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t5 | \
 # RUN:   FileCheck -check-prefix=SEC-DISCARD %s
 

 # RUN: ld.lld -o %t6 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t6 | \
 # RUN:   FileCheck -check-prefix=SEC-MULTI %s
 
 #           Idx Name          Size
 # SEC-MULTI: 1 .text         0000000e {{[0-9a-f]*}} TEXT DATA
 # SEC-MULTI: 2 .data         00000023 {{[0-9a-f]*}} DATA
 # SEC-MULTI: 3 .bss          00000002 {{[0-9a-f]*}} BSS
-# SEC-MULTI: 4 .shstrtab     00000002 {{[0-9a-f]*}}
-# SEC-MULTI: 5 .comment      00000008 {{[0-9a-f]*}}
-# SEC-MULTI: 6 .symtab       00000030 {{[0-9a-f]*}}
-# SEC-MULTI: 7 .shstrtab     00000035 {{[0-9a-f]*}}
-# SEC-MULTI: 8 .strtab       00000008 {{[0-9a-f]*}}
+# SEC-MULTI: 4 .comment      00000008 {{[0-9a-f]*}}
+# SEC-MULTI: 5 .symtab       00000030 {{[0-9a-f]*}}
+# SEC-MULTI: 6 .shstrtab     00000035 {{[0-9a-f]*}}
+# SEC-MULTI: 7 .strtab       00000008 {{[0-9a-f]*}}
 
 .globl _start
 _start:
     mov $60, %rax
     mov $42, %rdi
 
 .section .data,"aw"
 .quad 10, 10, 20, 20
 .section other,"aw"
 .short 10
 .byte 20
-.section .shstrtab,""
-.short 20
 .section .bss,"",@nobits
 .short 0

test/ELF/section-name.s

 .section .rodata.a,"a"
 .byte 0
 .section .rodata,"a"
 .byte 0
 .section .data.a,"aw"
 .byte 0
 .section .data,"aw"
 .byte 0
-.section .bss.a,"",@nobits
+.section .bss.a,"aw",@nobits
 .byte 0
-.section .bss,"",@nobits
+.section .bss,"aw",@nobits
 .byte 0
 .section .foo.a,"aw"
 .byte 0
 .section .foo,"aw"
 .byte 0
 .section .data.rel.ro,"aw",%progbits
 .byte 0
 .section .data.rel.ro.a,"aw",%progbits

 // CHECK:  2 .gcc_except_table 00000001
 // CHECK:  3 .text         00000002
 // CHECK:  4 .tdata        00000001
 // CHECK:  5 .tbss         00000001
 // CHECK:  6 .data.rel.ro  00000004
 // CHECK:  7 .data         00000002
 // CHECK:  8 .foo.a        00000001
 // CHECK:  9 .foo          00000001
-// CHECK: 10 .bss          00000001
-// CHECK: 11 .bss          00000001
-// CHECK: 12 .comment      00000008
-// CHECK: 13 .symtab       00000060
-// CHECK: 14 .shstrtab     00000075
-// CHECK: 15 .strtab       0000001d
+// CHECK: 10 .bss          00000002
+// CHECK: 11 .comment      00000008
+// CHECK: 12 .symtab       00000060
+// CHECK: 13 .shstrtab     00000075
+// CHECK: 14 .strtab       0000001d

test/ELF/string-table.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 // RUN: ld.lld %t -o %t2
 // RUN: llvm-readobj -sections %t2 | FileCheck %s
 // REQUIRES: x86
 
 .global _start
 _start:
 
-.section        foobar,"",@progbits,unique,1
-.section        foobar,"T",@progbits,unique,2
-.section        foobar,"",@nobits,unique,3
-.section        foobar,"",@nobits,unique,4
+.section        foobar,"",@progbits
 
 .section bar, "a"
 
 // Both sections are in the output and that the alloc section is first:
 // CHECK:      Name: bar
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:  SHF_ALLOC
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x200120
 
 // CHECK:      Name: foobar
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x0
 
-// CHECK:      Name: foobar
-// CHECK-NEXT: Type: SHT_PROGBITS
-// CHECK-NEXT: Flags [
-// CHECK-NEXT:   SHF_TLS
-// CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x0
-
-// CHECK:      Name: foobar
-// CHECK-NEXT: Type: SHT_NOBITS
-// CHECK-NEXT: Flags [
-// CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x0
-
 // CHECK-NOT:  Name: foobar