[ELF] - Fix an issue when 2 output sections were created from single declaration in script

[grimar]

Summary

I noticed that linkerscript-repsection-va.s was wrong:

For single foo entry:
SECTIONS {.foo : {*(.foo.*)} }
2 output sections were created.

I think that is wrong because:

1. It is really confusing and complicates the understanding of the script output. I think nobody expects to see multiple output sections for single entry.
2. Imagine that some symbols are to be declared: SECTIONS {.foo : {*(.foo.*)} end = .; } what should be the value of end if we have 2 output sections ? Its just confusing.
3. gold and ld do not do that.
4. It also adds a problem for refactoring of script I do.

Patch fixes that bu combining the flags of sections if scripted layouting is used.

[grimar]

Patch was based on wrong assumption that behavior is wrong.
I think behavior is questionable, but for now no need to change it.

ELF/LinkerScript.h

 // This class represents each rule in SECTIONS command.
 struct SectionRule {
   SectionRule(StringRef D, StringRef S)
       : Dest(D), SectionPattern(S) {}
 
   StringRef Dest;
 
   StringRef SectionPattern;
+
+  uint64_t Flags = 0;
 };
 
 // This enum represents what we can observe in SECTIONS tag of script:
 // ExprKind is a location counter change, like ". = . + 0x1000"
 // SectionKind is a description of output section, like ".data :..."
 enum SectionsCommandKind { SectionKind, AssignmentKind };
 
 struct SectionsCommand {

 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript {
   typedef typename ELFT::uint uintX_t;
 
 public:
   typedef PhdrEntry<ELFT> Phdr;
 
+  void scanInputSection(InputSectionBase<ELFT> *S);
+  uintX_t getSectionFlags(InputSectionBase<ELFT> *S);
+
   StringRef getOutputSection(InputSectionBase<ELFT> *S);
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool isDiscarded(InputSectionBase<ELFT> *S);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses(ArrayRef<OutputSectionBase<ELFT> *> S);
   int compareSections(StringRef A, StringRef B);
   void addScriptedSymbols();
   std::vector<Phdr> createPhdrs(ArrayRef<OutputSectionBase<ELFT> *> S);
   bool hasPhdrsCommands();
 
 private:
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   int getSectionIndex(StringRef Name);
   std::vector<size_t> getPhdrIndicesForSection(StringRef Name);
 
   uintX_t Dot;
+
+  llvm::DenseMap<InputSectionBase<ELFT> *, SectionRule *> InputSections;
 };
 
 // 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

uint64_t ExprParser::parseExpr1(uint64_t Lhs, int MinPrec) {
   }
   return Lhs;
 }
 
 // Reads and evaluates an arithmetic expression.
 uint64_t ExprParser::parseExpr() { return parseExpr1(parsePrimary(), 0); }
 
 template <class ELFT>
+void LinkerScript<ELFT>::scanInputSection(InputSectionBase<ELFT> *S) {
+  if (!S || S == &InputSection<ELFT>::Discarded || !S->Live)
+    return;
+
+  auto I = llvm::find_if(Opt.Sections, [&](SectionRule &R) {
+    return globMatch(R.SectionPattern, S->getSectionName());
+  });
+  if (I == Opt.Sections.end())
+    return;
+
+  InputSections[S] = &*I;
+  if (I->Dest == "/DISCARD/")
+    return;
+
+  I->Flags |= S->getSectionHdr()->sh_flags;
+}
+
+template <class ELFT>
+typename ELFT::uint
+LinkerScript<ELFT>::getSectionFlags(InputSectionBase<ELFT> *S) {
+  SectionRule *Rule = InputSections[S];
+  return Rule ? Rule->Flags : S->getSectionHdr()->sh_flags;
+}
+
+template <class ELFT>
 StringRef LinkerScript<ELFT>::getOutputSection(InputSectionBase<ELFT> *S) {
-  for (SectionRule &R : Opt.Sections)
-    if (globMatch(R.SectionPattern, S->getSectionName()))
-      return R.Dest;
-  return "";
+  SectionRule *Rule = InputSections[S];
+  return Rule ? Rule->Dest : "";
 }
 
 template <class ELFT>
 bool LinkerScript<ELFT>::isDiscarded(InputSectionBase<ELFT> *S) {
   return getOutputSection(S) == "/DISCARD/";
 }
 
 template <class ELFT>

ELF/OutputSections.cpp

OutputSectionBase<ELFT> *OutputSectionFactory<ELFT>::lookup(StringRef Name,
   return Map.lookup({Name, Type, Flags, 0});
 }
 
 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;
+  uintX_t Flags = ScriptConfig->DoLayout ? Script<ELFT>::X->getSectionFlags(C)
+                                         : H->sh_flags;
+  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);
 

ELF/Writer.cpp

 // Sort input sections by the special rule for .ctors and .dtors.
 template <class ELFT> static void sortCtorsDtors(OutputSectionBase<ELFT> *S) {
   if (S)
     reinterpret_cast<OutputSection<ELFT> *>(S)->sortCtorsDtors();
 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::createSections() {
+  typedef const std::unique_ptr<elf::ObjectFile<ELFT>> ObjectFile;
+
+  if (ScriptConfig->DoLayout)
+    for (ObjectFile &F : Symtab.getObjectFiles())
+      for (InputSectionBase<ELFT> *C : F->getSections())
+        Script<ELFT>::X->scanInputSection(C);
+
   // Create output sections for input object file sections.
   std::vector<OutputSectionBase<ELFT> *> RegularSections;
   OutputSectionFactory<ELFT> Factory;
-  for (const std::unique_ptr<elf::ObjectFile<ELFT>> &F :
-       Symtab.getObjectFiles()) {
+  for (ObjectFile &F : Symtab.getObjectFiles()) {
     for (InputSectionBase<ELFT> *C : F->getSections()) {
       if (isDiscarded(C)) {
         reportDiscarded(C, F);
         continue;
       }
       OutputSectionBase<ELFT> *Sec;
       bool IsNew;
       std::tie(Sec, IsNew) = Factory.create(C, getOutputSectionName(C));

test/ELF/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