[ELF] - Linkerscript: set correct synamic tag entries values when LS is used.

[grimar]

Summary

Previously DT_PREINIT_ARRAYSZ, DT_INIT_ARRAYSZ and DT_FINI_ARRAYSZ
were set to zero when lincerscript was used becase sections sizes are
calculated later that were taken.

Patch delays values calculation for these entries. Testcase is provided.

[evgeny777]

ELF/OutputSections.cpp

755

Can we use OutSec field from Entry?

case Entry::SecSize:
      P->d_un.d_val = E.OutSec->getSize();
      break;

[grimar]

ELF/OutputSections.cpp

755

OutSec field is not set, see:

Entry(int32_t Tag) : Tag(Tag), Kind(SecSize) {}

Problem is that constructor that takes
output section is already busy with SecAddr:

Entry(int32_t Tag, OutputSectionBase<ELFT> *OutSec)
    : Tag(Tag), OutSec(OutSec), Kind(SecAddr) {}

I`ll check what can I do here.

[evgeny777]

ELF/OutputSections.cpp

755

May be just add extra parameter (Kind) ?

[grimar]

• Addressed review comments.

[ruiu]

ELF/OutputSections.h

591–596

You have added three new constructors (a constructor with an optional parameter actually defines two ctors.) It's probably too much. Please remove the default argument at least.

594

Why do you need this?

[grimar]

• Addressed review comments.

ELF/OutputSections.h

594

Oops sorry, I forgot to remove it after addressing comments for first diff. I do not need it, what I was need is first constructor with default argument. I know you don't like to use them, though in this case it seems nicer for me because separates sections size taking case (which is special) from other ones. And also it brings much less changes.

You can see how version without default argument looks like: D23710. I would prever version with default argument (this patch). What do you think ?

[ruiu]

LGTM

ELF/OutputSections.h

class DynamicSection final : public OutputSectionBase<ELFT> {
   // addresses, or section addresses. This struct represents the entry.
   struct Entry {
     int32_t Tag;
     union {
       OutputSectionBase<ELFT> *OutSec;
       uint64_t Val;
       const SymbolBody *Sym;
     };
-    enum KindT { SecAddr, SymAddr, PlainInt } Kind;
+    enum KindT { SecAddr, SecSize, SymAddr, PlainInt } Kind;
     Entry(int32_t Tag, OutputSectionBase<ELFT> *OutSec)
         : Tag(Tag), OutSec(OutSec), Kind(SecAddr) {}
     Entry(int32_t Tag, uint64_t Val) : Tag(Tag), Val(Val), Kind(PlainInt) {}
     Entry(int32_t Tag, const SymbolBody *Sym)
         : Tag(Tag), Sym(Sym), Kind(SymAddr) {}
+    Entry(int32_t Tag) : Tag(Tag), Kind(SecSize) {}
   };
 
   // finalize() fills this vector with the section contents. finalize()
   // cannot directly create final section contents because when the
   // function is called, symbol or section addresses are not fixed yet.
   std::vector<Entry> Entries;
 
 public:
   explicit DynamicSection();
   void finalize() override;

ELF/OutputSections.cpp

template <class ELFT> void DynamicSection<ELFT>::finalize() {
   Add({DT_STRSZ, Out<ELFT>::DynStrTab->getSize()});
   if (Out<ELFT>::GnuHashTab)
     Add({DT_GNU_HASH, Out<ELFT>::GnuHashTab});
   if (Out<ELFT>::HashTab)
     Add({DT_HASH, Out<ELFT>::HashTab});
 
   if (Out<ELFT>::PreinitArray) {
     Add({DT_PREINIT_ARRAY, Out<ELFT>::PreinitArray});
-    Add({DT_PREINIT_ARRAYSZ, Out<ELFT>::PreinitArray->getSize()});
+    Add(Entry(DT_PREINIT_ARRAYSZ));
   }
   if (Out<ELFT>::InitArray) {
     Add({DT_INIT_ARRAY, Out<ELFT>::InitArray});
-    Add({DT_INIT_ARRAYSZ, (uintX_t)Out<ELFT>::InitArray->getSize()});
+    Add(Entry(DT_INIT_ARRAYSZ));
   }
   if (Out<ELFT>::FiniArray) {
     Add({DT_FINI_ARRAY, Out<ELFT>::FiniArray});
-    Add({DT_FINI_ARRAYSZ, (uintX_t)Out<ELFT>::FiniArray->getSize()});
+    Add(Entry(DT_FINI_ARRAYSZ));
   }
 
   if (SymbolBody *B = Symtab<ELFT>::X->find(Config->Init))
     Add({DT_INIT, B});
   if (SymbolBody *B = Symtab<ELFT>::X->find(Config->Fini))
     Add({DT_FINI, B});
 
   uint32_t DtFlags = 0;
if (Config->EMachine == EM_MIPS) {
     if (Out<ELFT>::MipsRldMap)
       Add({DT_MIPS_RLD_MAP, Out<ELFT>::MipsRldMap});
   }
 
   // +1 for DT_NULL
   Header.sh_size = (Entries.size() + 1) * Header.sh_entsize;
 }
 
+template <class ELFT> static uint64_t getValueForTag(int32_t Tag) {
+  if (Tag == DT_PREINIT_ARRAYSZ)
+    return Out<ELFT>::PreinitArray->getSize();
+  if (Tag == DT_INIT_ARRAYSZ)
+    return Out<ELFT>::InitArray->getSize();
+  if (Tag == DT_FINI_ARRAYSZ)
+    return Out<ELFT>::FiniArray->getSize();
+  llvm_unreachable("unknown dynamic section tag type");
+}
+
 template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
 
   for (const Entry &E : Entries) {
     P->d_tag = E.Tag;
     switch (E.Kind) {
     case Entry::SecAddr:
       P->d_un.d_ptr = E.OutSec->getVA();
       break;
+    case Entry::SecSize:
+      P->d_un.d_val = getValueForTag<ELFT>(E.Tag);
+      break;
     case Entry::SymAddr:
       P->d_un.d_ptr = E.Sym->template getVA<ELFT>();
       break;
     case Entry::PlainInt:
       P->d_un.d_val = E.Val;
       break;
     }
     ++P;

test/ELF/linkerscript/linkerscript-dynamic.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
+# RUN: ld.lld -shared %t2.o -o %t2.so
+
+# RUN: echo "SECTIONS { }" > %t.script
+# RUN: ld.lld %t1.o %t2.so -o %t
+# RUN: llvm-readobj -dynamic-table %t | FileCheck %s
+
+# CHECK:      DynamicSection [
+# CHECK-NEXT:  Tag                 Type             Name/Value
+# CHECK:       0x0000000000000021  PREINIT_ARRAYSZ  9 (bytes)
+# CHECK:       0x000000000000001B  INIT_ARRAYSZ     8 (bytes)
+# CHECK:       0x000000000000001C  FINI_ARRAYSZ     10 (bytes)
+
+.globl _start
+_start:
+
+.section .init_array,"aw",@init_array
+  .quad 0
+
+.section .preinit_array,"aw",@preinit_array
+  .quad 0
+  .byte 0
+
+.section .fini_array,"aw",@fini_array
+  .quad 0
+  .short 0