[ELF] Bypass section type check.

[evgeny777]

Summary

r291107 has broken things for me, because I have following in my linker script:

.data : {
  *(.data*)
  /* .. other "aw" sections go here  ... */
  PROVIDE_HIDDEN(__init_array_start = .);
  *(.init_array*)
  PROVIDE_HIDDEN(__init_array_end = .);
}

This patch bypasses type check when section comes from linker script (it might make sense to eliminate it completely, though).

[ruiu]

I think I want to avoid adding an "if linker script" condition and instead want to solve a problem in a generic way.

So what are we trying to check there? If the check is too picky, we should just remove it. If it is needed for some critical errors (such as turning non-executable sections to executable sections), we should check for that.

[evgeny777]

I don't know why this type check was added, but it prevents from joining .init_array with any other section by linker script.
If Rafael doesn't mind removing it I'm ok with that as well.

[evgeny777]

Rafael, can you please look at this? Thanks.

lld/trunk/ELF/LinkerScript.cpp

 }
 
 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(Sec, Name);
+  std::tie(OutSec, IsNew) = Factory.create(Sec, Name, true);
   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) {

lld/trunk/ELF/OutputSections.h

 // linker scripts.
 template <class ELFT> class OutputSectionFactory {
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::uint uintX_t;
 
 public:
   OutputSectionFactory();
   ~OutputSectionFactory();
-  std::pair<OutputSectionBase *, bool> create(InputSectionBase<ELFT> *C,
-                                              StringRef OutsecName);
-  std::pair<OutputSectionBase *, bool> create(const SectionKey &Key,
-                                              InputSectionBase<ELFT> *C);
+  std::pair<OutputSectionBase *, bool>
+  create(InputSectionBase<ELFT> *C, StringRef OutsecName, bool IsScripted);
+  std::pair<OutputSectionBase *, bool>
+  create(const SectionKey &Key, InputSectionBase<ELFT> *C, bool IsScripted);
 
 private:
   llvm::SmallDenseMap<SectionKey, OutputSectionBase *> Map;
 };
 
 template <class ELFT> uint64_t getHeaderSize() {
   if (Config->OFormatBinary)
     return 0;

lld/trunk/ELF/OutputSections.cpp

 
 template <class ELFT> OutputSectionFactory<ELFT>::OutputSectionFactory() {}
 
 template <class ELFT> OutputSectionFactory<ELFT>::~OutputSectionFactory() {}
 
 template <class ELFT>
 std::pair<OutputSectionBase *, bool>
 OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
-                                   StringRef OutsecName) {
+                                   StringRef OutsecName, bool IsScripted) {
   SectionKey Key = createKey(C, OutsecName);
-  return create(Key, C);
+  return create(Key, C, IsScripted);
 }
 
 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 &Key,
-                                   InputSectionBase<ELFT> *C) {
+                                   InputSectionBase<ELFT> *C, bool IsScripted) {
   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));
+
      // Convert notbits to progbits if they are mixed. This happens is some
      // linker scripts.
      if (Sec->Type == SHT_NOBITS && C->Type == SHT_PROGBITS)
        Sec->Type = SHT_PROGBITS;
-    if (Sec->Type != C->Type &&
+    if (!IsScripted && Sec->Type != C->Type &&
         !(Sec->Type == SHT_PROGBITS && C->Type == SHT_NOBITS))
       error("Section has different type from others with the same name " +
             toString(C));
     Sec->Flags |= Flags;
     return {Sec, false};
   }
 
   uint32_t Type = C->Type;

lld/trunk/ELF/Writer.cpp

void Writer<ELFT>::addInputSec(InputSectionBase<ELFT> *IS) {
 
   if (!IS->Live) {
     reportDiscarded(IS);
     return;
   }
   OutputSectionBase *Sec;
   bool IsNew;
   StringRef OutsecName = getOutputSectionName(IS->Name);
-  std::tie(Sec, IsNew) = Factory.create(IS, OutsecName);
+  std::tie(Sec, IsNew) = Factory.create(IS, OutsecName, false);
   if (IsNew)
     OutputSections.push_back(Sec);
   Sec->addSection(IS);
 }
 
 template <class ELFT> void Writer<ELFT>::createSections() {
   for (InputSectionBase<ELFT> *IS : Symtab<ELFT>::X->Sections)
     addInputSec(IS);

lld/trunk/test/ELF/linkerscript/section-types.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "SECTIONS { " > %t.script
+# RUN: echo ".bar : { *(.foo) *(.init_array) }" >> %t.script
+# RUN: echo "}" >> %t.script
+
+# RUN: ld.lld -o %t1 --script %t.script %t
+
+.section .foo,"aw"
+  .quad 1
+
+.section .init_array,"aw",@init_array
+  .quad 0