[ELF] - Reset output section size when assigning offsets.

[grimar]

Summary

In many places we reset Size to 0 before calling assignOffsets()
manually. Sometimes we don't do that.
It looks we can just always do that inside.

Previous code had:

template <class ELFT> void OutputSection::assignOffsets() {
  uint64_t Off = Size;

And tests feels fine with Off = 0. I think Off = Size make no sence.

[ruiu]

LGTM. Nice.

lld/trunk/ELF/OutputSections.cpp

static bool compareByFilePosition(InputSection *A, InputSection *B) {
   if (AOut != BOut)
     return AOut->SectionIndex < BOut->SectionIndex;
   return LA->OutSecOff < LB->OutSecOff;
 }
 
 template <class ELFT> void OutputSection::finalize() {
   if ((this->Flags & SHF_LINK_ORDER) && !this->Sections.empty()) {
     std::sort(Sections.begin(), Sections.end(), compareByFilePosition<ELFT>);
-    Size = 0;
     assignOffsets<ELFT>();
 
     // We must preserve the link order dependency of sections with the
     // SHF_LINK_ORDER flag. The dependency is indicated by the sh_link field. We
     // need to translate the InputSection sh_link to the OutputSection sh_link,
     // all InputSections in the OutputSection have the same dependency.
     if (auto *D = this->Sections.front()->template getLinkOrderDep<ELFT>())
       this->Link = D->OutSec->SectionIndex;
void OutputSection::addSection(InputSectionBase *C) {
   // Probably we sholuld handle that as an error. But for now we just
   // pick the largest sh_entsize.
   this->Entsize = std::max(this->Entsize, S->Entsize);
 }
 
 // This function is called after we sort input sections
 // and scan relocations to setup sections' offsets.
 template <class ELFT> void OutputSection::assignOffsets() {
-  uint64_t Off = this->Size;
+  uint64_t Off = 0;
   for (InputSection *S : Sections) {
     Off = alignTo(Off, S->Alignment);
     S->OutSecOff = Off;
     Off += S->template getSize<ELFT>();
   }
   this->Size = Off;
 }
 

lld/trunk/ELF/Relocations.cpp

if (A->OutSecOff == B->OutSecOff)
       if (auto *TA = dyn_cast<ThunkSection<ELFT>>(A))
         if (TA && TA->getTargetInputSection() == B)
           return true;
     return false;
   };
   std::merge(OS->Sections.begin(), OS->Sections.end(), Thunks.begin(),
              Thunks.end(), std::back_inserter(Tmp), MergeCmp);
   OS->Sections = std::move(Tmp);
-  OS->Size = 0;
   OS->assignOffsets<ELFT>();
 }
 
 // Process all relocations from the InputSections that have been assigned
 // to OutputSections and redirect through Thunks if needed.
 //
 // createThunks must be called after scanRelocs has created the Relocations for
 // each InputSection. It must be called before the static symbol table is

lld/trunk/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::sortSections() {
   Script<ELFT>::X->adjustSectionsAfterSorting();
 }
 
 template <class ELFT>
 static void finalizeSynthetic(const std::vector<SyntheticSection *> &Sections) {
   for (SyntheticSection *SS : Sections)
     if (SS && SS->OutSec && !SS->empty()) {
       SS->finalizeContents();
-      SS->OutSec->Size = 0;
       SS->OutSec->template assignOffsets<ELFT>();
     }
 }
 
 // We need to add input synthetic sections early in createSyntheticSections()
 // to make them visible from linkescript side. But not all sections are always
 // required to be in output. For example we don't need dynamic section content
 // sometimes. This function filters out such unused sections from output.