[ELF] - Let linkerscript to use own outputsections factory.

[grimar]

Summary

Currenly when linking FreeBSD kernel LLD produces 7 different .rodata sections because of difference
in attributes:

[ 6] .rodata           PROGBITS         ffffffff80c87c8c  00c86c8c
     00000000000e6e4d  0000000000000001 AMS       0     0     1
[ 7] .rodata           PROGBITS         ffffffff80d6eae0  00d6dae0
     0000000000246f00  0000000000000000   A       0     0     32
[ 8] .rodata           PROGBITS         ffffffff80fb59e0  00fb49e0
     00000000000001f0  0000000000000010  AM       0     0     16
[ 9] .rodata           PROGBITS         ffffffff80fb5bd0  00fb4bd0
     00000000000002a0  0000000000000004 AMS       0     0     16
[10] .rodata           PROGBITS         ffffffff80fb5e70  00fb4e70
     0000000000000108  0000000000000008  AM       0     0     8
[11] .rodata           PROGBITS         ffffffff80fb5f78  00fb4f78
     000000000000000c  0000000000000004 AMS       0     0     4
[12] .rodata           PROGBITS         ffffffff80fb5f88  00fb4f88
     0000000000001158  0000000000000001 AMS       0     0     8

At the same time ld produce only one. That probably means we need to use different logic for
creating output sections when do scripted layout.

Patch stops exporting regular output sections factory and introduces new one for using from
linker script side. That allowed to implement combining of output sections with different attributes.

Currently implemention does not support combine of SHT_MERGE sections with non-SHT_MERGE. But I believe
it should be not hard to implement basing on these new changes. One of possible way probably would be
to do scan of input sections to find out if there is a mix of "aM" vs "a" for example, and if so - do not create
megreable output section, but create regular one that should support adding mergeable input sections
as regular ones.

[grimar]

• Cosmetic changes.

[grimar]

• Simplify LinkerScript<ELFT>::assignAddresses() (since this patch makes output sections to be unique by name,

there is no more need in loops like "for each section with this name... assign address")

[ruiu]

Is there any problem if we group sections just by name?

[grimar]

In D23315#510206, @ruiu wrote:

Is there any problem if we group sections just by name?

Do you mean group into one output section by name ? That is exactly what this patch do.
For linkerscript's OutputSectionFactory "key" is simple StringRef which is output section name.
And I combine the flags when add more sections.

[grimar]

Main change of this patch which do all logic is class OutputSectionFactory in LinkerScript.cpp.
All other changes mostly for moving default factory back to writer and for stop exporting it.

[grimar]

• Rebased.

[grimar]

• Cosmetic changes.

[ruiu]

I do not see a benefit of doing this with a factory class. Actually I'm starting to regret to introduce the factory class to do this relatively simple things. We are doing too much object-oriented dance here. I believe this can be done just by a simple function.

[grimar]

Another patch was landed for this.

ELF/Driver.cpp

 //===- Driver.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Config.h"
 #include "Error.h"
 #include "ICF.h"
 #include "InputFiles.h"
 #include "InputSection.h"
+#include "OutputSections.h"
 #include "LinkerScript.h"
 #include "Strings.h"
 #include "SymbolListFile.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "Writer.h"
 #include "lld/Driver/Driver.h"
 #include "llvm/ADT/StringExtras.h"

ELF/LinkerScript.h

 #include "llvm/Support/MemoryBuffer.h"
 #include <functional>
 
 namespace lld {
 namespace elf {
 class SymbolBody;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class OutputSectionBase;
-template <class ELFT> class OutputSectionFactory;
 template <class ELFT> class DefinedCommon;
 
 typedef std::function<uint64_t(uint64_t)> Expr;
 
 // Parses a linker script. Calling this function updates
 // Config and ScriptConfig.
 void readLinkerScript(MemoryBufferRef MB);
 

 
 extern ScriptConfiguration *ScriptConfig;
 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript {
   typedef typename ELFT::uint uintX_t;
 
 public:
-  void createSections(OutputSectionFactory<ELFT> &Factory);
+  void createSections();
 
   std::vector<PhdrEntry<ELFT>> createPhdrs();
 
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses();
   int compareSections(StringRef A, StringRef B);
   bool hasPhdrsCommands();
private:
 
   void filter();
 
   int getSectionIndex(StringRef Name);
   std::vector<size_t> getPhdrIndices(StringRef SectionName);
   size_t getPhdrIndex(StringRef PhdrName);
 
   uintX_t Dot;
+
+  std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> OwningSections;
 };
 
 // Variable template is a C++14 feature, so we can't template
 // a global variable. Use a struct to workaround.
 template <class ELFT> struct Script { static LinkerScript<ELFT> *X; };
 template <class ELFT> LinkerScript<ELFT> *Script<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/LinkerScript.cpp

LinkerScript<ELFT>::getInputSections(const InputSectionDescription *I) {
 
   if ((llvm::find(Patterns, "COMMON") != Patterns.end()))
     Ret.push_back(CommonInputSection<ELFT>::X);
 
   return Ret;
 }
 
 namespace {
+template <class ELFT> class OutputSectionFactory {
+  typedef typename ELFT::Shdr Elf_Shdr;
+  typedef typename ELFT::uint uintX_t;
+  typedef std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> Map;
+
+private:
+  Map &OutputSections;
+
+  OutputSectionBase<ELFT> *allocSection(unsigned Kind, StringRef Name,
+                                        uintX_t Flags, uintX_t Alignment,
+                                        uint32_t Type) {
+    switch (Kind) {
+    case InputSectionBase<ELFT>::Regular:
+      return new OutputSection<ELFT>(Name, Type, Flags);
+    default:
+      llvm_unreachable("unknown section kind");
+    }
+  }
+
+public:
+  OutputSectionFactory(Map &OutputSections) : OutputSections(OutputSections) {}
+
+  std::pair<OutputSectionBase<ELFT> *, bool> create(InputSectionBase<ELFT> *C,
+                                                    StringRef OutsecName) {
+    bool IsNew = true;
+    OutputSectionBase<ELFT> *Sec = nullptr;
+    for (std::unique_ptr<OutputSectionBase<ELFT>> &S : OutputSections)
+      if (S->getName() == OutsecName) {
+        Sec = S.get();
+        IsNew = false;
+        break;
+      }
+
+    const Elf_Shdr *H = C->getSectionHdr();
+    uintX_t Flags = H->sh_flags & ~SHF_GROUP & ~SHF_COMPRESSED;
+    uintX_t Alignment = 0;
+    if (isa<MergeInputSection<ELFT>>(C))
+      Alignment = std::max(H->sh_addralign, H->sh_entsize);
+    uint32_t Type = H->sh_type;
+
+    if (!Sec) {
+      Sec = allocSection(C->SectionKind, OutsecName, Flags, Alignment, Type);
+      OutputSections.emplace_back(Sec);
+    } else {
+      if ((Sec->getFlags() & SHF_MERGE) != (Flags & SHF_MERGE))
+        fatal("combine of mergeable and non-mergeable sections is not "
+              "supported yet");
+
+      Sec->updateAlignment(Alignment);
+      Sec->combineFlags(Flags);
+    }
+
+    return std::make_pair(Sec, IsNew);
+  }
+};
+
 template <class ELFT> class LayoutInputSection : public InputSection<ELFT> {
 public:
   LayoutInputSection(SymbolAssignment *Cmd);
   static bool classof(const InputSectionBase<ELFT> *S);
   SymbolAssignment *Cmd;
 
 private:
   typename ELFT::Shdr Hdr;

 template <class ELFT>
 static std::function<bool(InputSectionBase<ELFT> *, InputSectionBase<ELFT> *)>
 getComparator(SortKind K) {
   if (K == SortByName)
     return compareName<ELFT>;
   return compareAlignment<ELFT>;
 }
 
-template <class ELFT>
-void LinkerScript<ELFT>::createSections(
-    OutputSectionFactory<ELFT> &Factory) {
+template <class ELFT> void LinkerScript<ELFT>::createSections() {
+  OutputSectionFactory<ELFT> Factory(OwningSections);
   OutputSectionBuilder<ELFT> Builder(Factory, OutputSections);
 
   auto Add = [&](StringRef OutputName, const InputSectionDescription *Cmd) {
     std::vector<InputSectionBase<ELFT> *> Sections = getInputSections(Cmd);
     if (OutputName == "/DISCARD/") {
       for (InputSectionBase<ELFT> *S : Sections) {
         S->Live = false;
         reportDiscarded(S);

ELF/OutputSections.h

public:
   uintX_t getSize() const { return Header.sh_size; }
   void setSize(uintX_t Val) { Header.sh_size = Val; }
   uintX_t getFlags() const { return Header.sh_flags; }
   uint32_t getPhdrFlags() const;
   uintX_t getFileOff() const { return Header.sh_offset; }
   uintX_t getAlignment() const { return Header.sh_addralign; }
   uint32_t getType() const { return Header.sh_type; }
 
+  void combineFlags(uintX_t Flag) { Header.sh_flags |= Flag; }
+
   void updateAlignment(uintX_t Alignment) {
     if (Alignment > Header.sh_addralign)
       Header.sh_addralign = Alignment;
   }
 
   // If true, this section will be page aligned on disk.
   // Typically the first section of each PT_LOAD segment has this flag.
   bool PageAlign = false;
template <class ELFT> struct Out {
   static OutputSectionBase<ELFT> *ElfHeader;
   static OutputSectionBase<ELFT> *ProgramHeaders;
 
   static OutputSectionBase<ELFT> *PreinitArray;
   static OutputSectionBase<ELFT> *InitArray;
   static OutputSectionBase<ELFT> *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.
-template <class ELFT> class OutputSectionFactory {
-  typedef typename ELFT::Shdr Elf_Shdr;
-  typedef typename ELFT::uint uintX_t;
-  typedef typename elf::SectionKey<ELFT::Is64Bits> Key;
-
-public:
-  std::pair<OutputSectionBase<ELFT> *, bool> create(InputSectionBase<ELFT> *C,
-                                                    StringRef OutsecName);
-
-private:
-  Key createKey(InputSectionBase<ELFT> *C, StringRef OutsecName);
-
-  llvm::SmallDenseMap<Key, OutputSectionBase<ELFT> *> Map;
-  std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> OwningSections;
-};
-
 template <class ELFT> BuildIdSection<ELFT> *Out<ELFT>::BuildId;
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> EhFrameHeader<ELFT> *Out<ELFT>::EhFrameHdr;
 template <class ELFT> EhOutputSection<ELFT> *Out<ELFT>::EhFrame;
 template <class ELFT> GnuHashTableSection<ELFT> *Out<ELFT>::GnuHashTab;
 template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;

 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::ProgramHeaders;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::PreinitArray;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::InitArray;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::FiniArray;
 
 } // namespace elf
 } // namespace lld
 
-namespace llvm {
-template <bool Is64Bits> struct DenseMapInfo<lld::elf::SectionKey<Is64Bits>> {
-  typedef typename lld::elf::SectionKey<Is64Bits> Key;
-
-  static Key getEmptyKey();
-  static Key getTombstoneKey();
-  static unsigned getHashValue(const Key &Val);
-  static bool isEqual(const Key &LHS, const Key &RHS);
-};
-}
-
 #endif

ELF/OutputSections.cpp

 template <class ELFT>
 void MipsOptionsOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   auto *S = cast<MipsOptionsInputSection<ELFT>>(C);
   if (S->Reginfo)
     GprMask |= S->Reginfo->ri_gprmask;
   S->OutSec = this;
 }
 
-template <class ELFT>
-std::pair<OutputSectionBase<ELFT> *, bool>
-OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
-                                   StringRef OutsecName) {
-  SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
-  OutputSectionBase<ELFT> *&Sec = Map[Key];
-  if (Sec)
-    return {Sec, false};
-
-  switch (C->SectionKind) {
-  case InputSectionBase<ELFT>::Regular:
-    Sec = new OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
-    break;
-  case InputSectionBase<ELFT>::EHFrame:
-    return {Out<ELFT>::EhFrame, false};
-  case InputSectionBase<ELFT>::Merge:
-    Sec = new MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags,
-                                       Key.Alignment);
-    break;
-  case InputSectionBase<ELFT>::MipsReginfo:
-    Sec = new MipsReginfoOutputSection<ELFT>();
-    break;
-  case InputSectionBase<ELFT>::MipsOptions:
-    Sec = new MipsOptionsOutputSection<ELFT>();
-    break;
-  case InputSectionBase<ELFT>::Layout:
-    llvm_unreachable("Invalid section type");
-  }
-  OwningSections.emplace_back(Sec);
-  return {Sec, true};
-}
-
-template <class ELFT>
-SectionKey<ELFT::Is64Bits>
-OutputSectionFactory<ELFT>::createKey(InputSectionBase<ELFT> *C,
-                                      StringRef OutsecName) {
-  const Elf_Shdr *H = C->getSectionHdr();
-  uintX_t Flags = H->sh_flags & ~SHF_GROUP & ~SHF_COMPRESSED;
-
-  // 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.
-  uintX_t Alignment = 0;
-  if (isa<MergeInputSection<ELFT>>(C))
-    Alignment = std::max(H->sh_addralign, H->sh_entsize);
-
-  uint32_t Type = H->sh_type;
-  return SectionKey<ELFT::Is64Bits>{OutsecName, Type, Flags, Alignment};
-}
-
-template <bool Is64Bits>
-typename lld::elf::SectionKey<Is64Bits>
-DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getEmptyKey() {
-  return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 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};
-}
-
-template <bool Is64Bits>
-unsigned
-DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getHashValue(const Key &Val) {
-  return hash_combine(Val.Name, Val.Type, 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;
-}
-
-namespace llvm {
-template struct DenseMapInfo<SectionKey<true>>;
-template struct DenseMapInfo<SectionKey<false>>;
-}
-
 namespace lld {
 namespace elf {
 template class OutputSectionBase<ELF32LE>;
 template class OutputSectionBase<ELF32BE>;
 template class OutputSectionBase<ELF64LE>;
 template class OutputSectionBase<ELF64BE>;
 
 template class EhFrameHeader<ELF32LE>;

 template class BuildIdSha1<ELF32BE>;
 template class BuildIdSha1<ELF64LE>;
 template class BuildIdSha1<ELF64BE>;
 
 template class BuildIdHexstring<ELF32LE>;
 template class BuildIdHexstring<ELF32BE>;
 template class BuildIdHexstring<ELF64LE>;
 template class BuildIdHexstring<ELF64BE>;
-
-template class OutputSectionFactory<ELF32LE>;
-template class OutputSectionFactory<ELF32BE>;
-template class OutputSectionFactory<ELF64LE>;
-template class OutputSectionFactory<ELF64BE>;
 }
 }

ELF/Writer.cpp

 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf;
 
 namespace {
+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;
+};
+}
+
+namespace llvm {
+template <bool Is64Bits> struct DenseMapInfo<SectionKey<Is64Bits>> {
+  static SectionKey<Is64Bits> getEmptyKey() {
+    return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0,
+                                0};
+  }
+  static SectionKey<Is64Bits> getTombstoneKey() {
+    return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getTombstoneKey(), 0,
+                                0, 0};
+  }
+  static unsigned getHashValue(const SectionKey<Is64Bits> &Val) {
+    return hash_combine(Val.Name, Val.Type, Val.Flags, Val.Alignment);
+  }
+  static bool isEqual(const SectionKey<Is64Bits> &LHS,
+                      const SectionKey<Is64Bits> &RHS) {
+    return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
+           LHS.Type == RHS.Type && LHS.Flags == RHS.Flags &&
+           LHS.Alignment == RHS.Alignment;
+  }
+};
+}
+
+namespace {
+// 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.
+template <class ELFT> class OutputSectionFactory {
+  typedef typename ELFT::Shdr Elf_Shdr;
+  typedef typename ELFT::uint uintX_t;
+  typedef typename SectionKey<ELFT::Is64Bits> SectionKey;
+
+public:
+  std::pair<OutputSectionBase<ELFT> *, bool> create(InputSectionBase<ELFT> *C,
+                                                    StringRef OutsecName) {
+    SectionKey Key = createKey(C, OutsecName);
+    OutputSectionBase<ELFT> *&Sec = Map[Key];
+    if (Sec)
+      return {Sec, false};
+
+    switch (C->SectionKind) {
+    case InputSectionBase<ELFT>::Regular:
+      Sec = new OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+      break;
+    case InputSectionBase<ELFT>::EHFrame:
+      return {Out<ELFT>::EhFrame, false};
+    case InputSectionBase<ELFT>::Merge:
+      Sec = new MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags,
+                                         Key.Alignment);
+      break;
+    case InputSectionBase<ELFT>::MipsReginfo:
+      Sec = new MipsReginfoOutputSection<ELFT>();
+      break;
+    case InputSectionBase<ELFT>::MipsOptions:
+      Sec = new MipsOptionsOutputSection<ELFT>();
+      break;
+    case InputSectionBase<ELFT>::Layout:
+      llvm_unreachable("Invalid section type");
+    }
+    OwningSections.emplace_back(Sec);
+    return {Sec, true};
+  }
+
+private:
+  SectionKey createKey(InputSectionBase<ELFT> *C, StringRef OutsecName) {
+    const Elf_Shdr *H = C->getSectionHdr();
+    uintX_t Flags = H->sh_flags & ~SHF_GROUP & ~SHF_COMPRESSED;
+
+    // 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.
+    uintX_t Alignment = 0;
+    if (isa<MergeInputSection<ELFT>>(C))
+      Alignment = std::max(H->sh_addralign, H->sh_entsize);
+
+    uint32_t Type = H->sh_type;
+    return {OutsecName, Type, Flags, Alignment};
+  }
+
+  llvm::SmallDenseMap<SectionKey, OutputSectionBase<ELFT> *> Map;
+  std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> OwningSections;
+};
+
 // The writer writes a SymbolTable result to a file.
 template <class ELFT> class Writer {
 public:
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Ehdr Elf_Ehdr;
   typedef typename ELFT::Phdr Elf_Phdr;
   typedef typename ELFT::Sym Elf_Sym;
template <class ELFT> void Writer<ELFT>::run() {
   if (Target->NeedsThunks)
     forEachRelSec(createThunks<ELFT>);
 
   CommonInputSection<ELFT> Common(getCommonSymbols<ELFT>());
   CommonInputSection<ELFT>::X = &Common;
 
   Script<ELFT>::X->OutputSections = &OutputSections;
   if (ScriptConfig->HasContents)
-    Script<ELFT>::X->createSections(Factory);
+    Script<ELFT>::X->createSections();
   else
     createSections();
 
   finalizeSections();
   if (HasError)
     return;
 
   if (Config->Relocatable) {

test/ELF/linkerscript/linkerscript-merge-sections.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "SECTIONS { .aaa : { *(.aaa.*) } }" > %t.script
+# RUN: ld.lld -o %t1.out --script %t.script %t
+# RUN: llvm-objdump -section-headers %t1.out | FileCheck %s
+
+# CHECK:      Sections:
+# CHECK-NEXT:  Idx Name          Size      Address          Type
+# CHECK-NEXT:    0               00000000 0000000000000000
+# CHECK-NEXT:    1 .aaa          00000038 0000000000000160 TEXT DATA
+# CHECK-NEXT:    2 .text         00000001 0000000000000198 TEXT DATA
+# CHECK-NEXT:    3 .symtab       00000030 0000000000000000
+# CHECK-NEXT:    4 .shstrtab     00000026 0000000000000000
+# CHECK-NEXT:    5 .strtab       00000008 0000000000000000
+
+.global _start
+_start:
+ nop
+
+.section .aaa.3, "a"
+.align 1
+.quad 1
+
+
+.section .aaa.4, "awS"
+.align 2
+.quad 2
+
+.section .aaa.1, "aS"
+.align 4
+.quad 3
+
+.section .aaa.2, "ax"
+.align 8
+.quad 4
+
+.section .aaa.2, "ax"
+.align 16
+.quad 5

test/ELF/linkerscript/linkerscript-repsection-va.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS {.foo : {*(.foo.*)} }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size      Address          Type
 # CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .foo          00000004 0000000000000158 DATA
-# CHECK-NEXT:   2 .foo          00000004 000000000000015c DATA
-# CHECK-NEXT:   3 .text         00000001 0000000000000160 TEXT DATA
+# CHECK-NEXT:   1 .foo          00000008 0000000000000158 DATA
+# CHECK-NEXT:   2 .text         00000001 0000000000000160 TEXT DATA
 
 .global _start
 _start:
  nop
 
 .section .foo.1,"a"
 foo1:
  .long 0
 
 .section .foo.2,"aw"
 foo2:
  .long 0