[ELF] - Refactoring of Writer<ELFT>::scanRelocs()

[grimar]

Summary

Code for handling TLS relocations was moved out scanRelocs() to new function handleTlsRelocations().
That is because scanRelocs already too large to put more TLS code into it.

[ruiu]

LGTM

ELF/Writer.cpp

195

Instead of parameterizing isRela, you can parameterize RelT and change the function signature to bool(unsigned Type, SymbolBody *, InputSectionBase<ELFT> &, RelT &RI)

196

Relocations -> Relocation because this function handles one relocation at a time.

[grimar]

ELF/Writer.cpp

196

Ok, fixed. Just in case my meaning was "handle different types of TLS relocations" so I put (s).

ELF/Writer.cpp

static bool isEqual(const SectionKey<Is64Bits> &LHS,
                       const SectionKey<Is64Bits> &RHS) {
     return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
            LHS.Type == RHS.Type && LHS.Flags == RHS.Flags &&
            LHS.EntSize == RHS.EntSize;
   }
 };
 }
 
+template <class ELFT, bool isRela>
+static bool handleTlsRelocations(unsigned Type, SymbolBody *Body,
+                                 InputSectionBase<ELFT> &C,
+                                 const Elf_Rel_Impl<ELFT, isRela> &RI) {
+  if (Target->isTlsLocalDynamicReloc(Type)) {
+    if (Target->isTlsOptimized(Type, nullptr))
+      return true;
+    if (Out<ELFT>::Got->addCurrentModuleTlsIndex())
+      Out<ELFT>::RelaDyn->addReloc({&C, &RI});
+    return true;
+  }
+
+  if (!Body || !Body->isTls())
+    return false;
+
+  if (Target->isTlsGlobalDynamicReloc(Type)) {
+    bool Opt = Target->isTlsOptimized(Type, Body);
+    if (!Opt && Out<ELFT>::Got->addDynTlsEntry(Body)) {
+      Out<ELFT>::RelaDyn->addReloc({&C, &RI});
+      Out<ELFT>::RelaDyn->addReloc({nullptr, nullptr});
+      Body->setUsedInDynamicReloc();
+      return true;
+    }
+    if (!canBePreempted(Body, true))
+      return true;
+  }
+  return !Target->isTlsDynReloc(Type, *Body);
+}
+
 // The reason we have to do this early scan is as follows
 // * To mmap the output file, we need to know the size
 // * For that, we need to know how many dynamic relocs we will have.
 // It might be possible to avoid this by outputting the file with write:
 // * Write the allocated output sections, computing addresses.
 // * Apply relocations, recording which ones require a dynamic reloc.
 // * Write the dynamic relocations.
 // * Write the rest of the file.
for (const RelType &RI : Rels) {
 
     // Ignore "hint" relocation because it is for optional code optimization.
     if (Target->isHintReloc(Type))
       continue;
 
     if (Target->isGotRelative(Type))
       HasGotOffRel = true;
 
-    if (Target->isTlsLocalDynamicReloc(Type)) {
-      if (Target->isTlsOptimized(Type, nullptr))
-        continue;
-      if (Out<ELFT>::Got->addCurrentModuleTlsIndex())
-        Out<ELFT>::RelaDyn->addReloc({&C, &RI});
-      continue;
-    }
-
     // Set "used" bit for --as-needed.
     if (Body && Body->isUndefined() && !Body->isWeak())
       if (auto *S = dyn_cast<SharedSymbol<ELFT>>(Body->repl()))
         S->File->IsUsed = true;
 
     if (Body)
       Body = Body->repl();
 
-    if (Body && Body->isTls() && Target->isTlsGlobalDynamicReloc(Type)) {
-      bool Opt = Target->isTlsOptimized(Type, Body);
-      if (!Opt && Out<ELFT>::Got->addDynTlsEntry(Body)) {
-        Out<ELFT>::RelaDyn->addReloc({&C, &RI});
-        Out<ELFT>::RelaDyn->addReloc({nullptr, nullptr});
-        Body->setUsedInDynamicReloc();
-        continue;
-      }
-      if (!canBePreempted(Body, true))
-        continue;
-    }
-
-    if (Body && Body->isTls() && !Target->isTlsDynReloc(Type, *Body))
+    if (handleTlsRelocations<ELFT>(Type, Body, C, RI))
       continue;
 
     if (Target->relocNeedsDynRelative(Type)) {
       RelType *Rel = new (Alloc) RelType;
       Rel->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
       Rel->r_offset = RI.r_offset;
       Out<ELFT>::RelaDyn->addReloc({&C, Rel});
     }