[ELF] - Linkerscript: create multiple output sections for inputs with different attributes.

[grimar]

Summary

Previously we combined sections by name if linkerscript was used.
For that we had to disable SHF_MERGE handling temporarily, but then
found that implementing it properly will require additional complexity layers like
subsections or something.
At the same time looks we can live with multiple output sections approach for now.
That patch do this change.

[ruiu]

Sorry for the belated response. Let's try this. LGTM.

ELF/LinkerScript.cpp

366

findSection*s*

368

Out -> Ret (it is more conventional.)

369–373

for (OutputSectionBase<ELFT> *Sec : Sections)
  if (Sec->getName() == Cmd.Name && checkConstraint(Sec->getFlags(), Cmd.Constraint))
    Out.push_back(Sec);

ELF/LinkerScript.cpp

if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
         discard(*Cmd);
         continue;
       }
 
       std::vector<InputSectionBase<ELFT> *> V = createInputSectionList(*Cmd);
       if (V.empty())
         continue;
 
+      for (InputSectionBase<ELFT> *Sec : V) {
         OutputSectionBase<ELFT> *OutSec;
         bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(V.front(), Cmd->Name);
+        std::tie(OutSec, IsNew) = Factory.create(Sec, Cmd->Name);
         if (IsNew)
           OutputSections->push_back(OutSec);
 
         uint32_t Subalign = Cmd->SubalignExpr ? Cmd->SubalignExpr(0) : 0;
-      for (InputSectionBase<ELFT> *Sec : V) {
         if (Subalign)
           Sec->Alignment = Subalign;
         OutSec->addSection(Sec);
       }
     }
   }
 
   // Add orphan sections.
for (InputSection<ELFT> *I : OutSec->Sections) {
     // .foo { *(.aaa) a = SIZEOF(.foo); *(.bbb) }
     Sec->setSize(Off);
     // Add symbols following current input section.
     AssignSuccessors(I);
   }
 }
 
 template <class ELFT>
-static OutputSectionBase<ELFT> *
+static std::vector<OutputSectionBase<ELFT> *>
 findSection(OutputSectionCommand &Cmd,
             ArrayRef<OutputSectionBase<ELFT> *> Sections) {
+  std::vector<OutputSectionBase<ELFT> *> Out;
   for (OutputSectionBase<ELFT> *Sec : Sections) {
     if (Sec->getName() != Cmd.Name)
       continue;
     if (checkConstraint(Sec->getFlags(), Cmd.Constraint))
-      return Sec;
+      Out.push_back(Sec);
   }
-  return nullptr;
+  return Out;
 }
 
 template <class ELFT> void LinkerScript<ELFT>::assignAddresses() {
   // Orphan sections are sections present in the input files which
   // are not explicitly placed into the output file by the linker script.
   // We place orphan sections at end of file.
   // Other linkers places them using some heuristics as described in
   // https://sourceware.org/binutils/docs/ld/Orphan-Sections.html#Orphan-Sections.
for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     }
 
     if (auto *Cmd = dyn_cast<AssertCommand>(Base.get())) {
       Cmd->Expression(Dot);
       continue;
     }
 
     auto *Cmd = cast<OutputSectionCommand>(Base.get());
-    OutputSectionBase<ELFT> *Sec = findSection<ELFT>(*Cmd, *OutputSections);
-    if (!Sec)
-      continue;
-
+    for (OutputSectionBase<ELFT> *Sec :
+         findSection<ELFT>(*Cmd, *OutputSections)) {
       if (Cmd->AddrExpr)
         Dot = Cmd->AddrExpr(Dot);
 
       if (Cmd->AlignExpr)
         Sec->updateAlignment(Cmd->AlignExpr(Dot));
 
       if ((Sec->getFlags() & SHF_TLS) && Sec->getType() == SHT_NOBITS) {
         uintX_t TVA = Dot + ThreadBssOffset;
         TVA = alignTo(TVA, Sec->getAlignment());
         Sec->setVA(TVA);
         assignOffsets(Cmd, Sec);
         ThreadBssOffset = TVA - Dot + Sec->getSize();
         continue;
       }
 
       if (!(Sec->getFlags() & SHF_ALLOC)) {
         assignOffsets(Cmd, Sec);
         continue;
       }
 
       Dot = alignTo(Dot, Sec->getAlignment());
       Sec->setVA(Dot);
       assignOffsets(Cmd, Sec);
       MinVA = std::min(MinVA, Dot);
       Dot += Sec->getSize();
     }
+  }
 
   // ELF and Program headers need to be right before the first section in
   // memory. Set their addresses accordingly.
   MinVA = alignDown(MinVA - Out<ELFT>::ElfHeader->getSize() -
                         Out<ELFT>::ProgramHeaders->getSize(),
                     Target->PageSize);
   Out<ELFT>::ElfHeader->setVA(MinVA);
   Out<ELFT>::ProgramHeaders->setVA(Out<ELFT>::ElfHeader->getSize() + MinVA);

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 { .foo : { *(.foo.*) } }" > %t.script
-# RUN: ld.lld -o %t1 --script %t.script %t
-# RUN: llvm-objdump -s %t1 | FileCheck %s
-# CHECK:      Contents of section .foo:
-# CHECK-NEXT:  0158 01000000 02000000 00000000 73686f72  ............shor
-# CHECK-NEXT:  0168 7420756e 7369676e 65642069 6e7400    t unsigned int.
-
-.global _start
-_start:
-  nop
-
-.section .foo.1, "aw"
-writable:
- .long 1
-
-.section .foo.2, "aM",@progbits,1
-readable:
- .long 2
-
-.section .foo.3, "awx"
- .long 0
-
-.section .foo.4, "MS",@progbits,1
-.LASF2:
- .string "short unsigned int"

test/ELF/linkerscript/linkerscript-phdrs.s

 # CHECK:     ProgramHeaders [
 # CHECK-NEXT:  ProgramHeader {
 # CHECK-NEXT:    Type: PT_LOAD (0x1)
 # CHECK-NEXT:    Offset: 0x0
 # CHECK-NEXT:    VirtualAddress: 0x10000000
 # CHECK-NEXT:    PhysicalAddress: 0x10000000
 # CHECK-NEXT:    FileSize: 521
 # CHECK-NEXT:    MemSize: 521
-# CHECK-NEXT:    Flags [ (0x5)
+# CHECK-NEXT:    Flags [ (0x7)
 # CHECK-NEXT:      PF_R (0x4)
+# CHECK-NEXT:      PF_W (0x2)
 # CHECK-NEXT:      PF_X (0x1)
 # CHECK-NEXT:    ]
 
 .global _start
 _start:
  nop
 
 .section .foo.1,"a"
 foo1:
  .long 0
 
 .section .foo.2,"aw"
 foo2:
  .long 0

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          00000008 0000000000000120 DATA
-# CHECK-NEXT:   2 .text         00000001 0000000000000128 TEXT DATA
+# CHECK-NEXT:   1 .foo          00000004 0000000000000158 DATA
+# CHECK-NEXT:   2 .foo          00000004 000000000000015c DATA
+# CHECK-NEXT:   3 .text         00000001 0000000000000160 TEXT DATA
 
 .global _start
 _start:
  nop
 
 .section .foo.1,"a"
 foo1:
  .long 0
 
 .section .foo.2,"aw"
 foo2:
  .long 0