[LLD][ELF] Rename variables and add comments to getISThunkSec [NFC]

[peter.smith]

Summary

Some refactoring split out from D34691 that isn't strictly relating to it. It covers the renaming of some variables as Commands were moved to OutputSections the existing ones still imply commands. I've also tidied up the comments.

[smeenai]

ELF/Relocations.cpp

1028 ↗

(On Diff #114372)

As far as I can see OS isn't used in this function anywhere. Can that parameter be dropped entirely? (I'm fine with that being done in a follow-up if it's possible.)

[peter.smith]

I've removed the unused parameter and have searched for other locations where Cmd is used instead of OS.

[smeenai]

Looks good to me still.

[ruiu]

LGTM

lld/trunk/ELF/Relocations.h

public:
 
   // The number of completed passes of createThunks this permits us
   // to do one time initialization on Pass 0 and put a limit on the
   // number of times it can be called to prevent infinite loops.
   uint32_t Pass = 0;
 
 private:
   void mergeThunks();
-  ThunkSection *getOSThunkSec(OutputSection *Cmd,
+  ThunkSection *getOSThunkSec(OutputSection *OS,
                               std::vector<InputSection *> *ISR);
-  ThunkSection *getISThunkSec(InputSection *IS, OutputSection *OS);
+  ThunkSection *getISThunkSec(InputSection *IS);
   void forEachExecInputSection(
       ArrayRef<OutputSection *> OutputSections,
       std::function<void(OutputSection *, std::vector<InputSection *> *,
                          InputSection *)>
           Fn);
   std::pair<Thunk *, bool> getThunk(SymbolBody &Body, uint32_t Type);
-  ThunkSection *addThunkSection(OutputSection *Cmd,
+  ThunkSection *addThunkSection(OutputSection *OS,
                                 std::vector<InputSection *> *, uint64_t Off);
   // Record all the available Thunks for a Symbol
   llvm::DenseMap<SymbolBody *, std::vector<Thunk *>> ThunkedSymbols;
 
   // Find a Thunk from the Thunks symbol definition, we can use this to find
   // the Thunk from a relocation to the Thunks symbol definition.
   llvm::DenseMap<SymbolBody *, Thunk *> Thunks;
 

lld/trunk/ELF/Relocations.cpp

static uint32_t findEndOfFirstNonExec(OutputSection &Cmd) {
   for (BaseCommand *Base : Cmd.Commands)
     if (auto *ISD = dyn_cast<InputSectionDescription>(Base))
       for (auto *IS : ISD->Sections)
         if ((IS->Flags & SHF_EXECINSTR) == 0)
           return IS->OutSecOff + IS->getSize();
   return 0;
 }
 
-ThunkSection *ThunkCreator::getOSThunkSec(OutputSection *Cmd,
+ThunkSection *ThunkCreator::getOSThunkSec(OutputSection *OS,
                                           std::vector<InputSection *> *ISR) {
   if (CurTS == nullptr) {
-    uint32_t Off = findEndOfFirstNonExec(*Cmd);
-    CurTS = addThunkSection(Cmd, ISR, Off);
+    uint32_t Off = findEndOfFirstNonExec(*OS);
+    CurTS = addThunkSection(OS, ISR, Off);
   }
   return CurTS;
 }
 
-ThunkSection *ThunkCreator::getISThunkSec(InputSection *IS, OutputSection *OS) {
+// Add a Thunk that needs to be placed in a ThunkSection that immediately
+// precedes its Target.
+ThunkSection *ThunkCreator::getISThunkSec(InputSection *IS) {
   ThunkSection *TS = ThunkedSections.lookup(IS);
   if (TS)
     return TS;
 
-  // Find InputSectionRange within TOS that IS is in
-  OutputSection *C = IS->getParent();
+  // Find InputSectionRange within Target Output Section (TOS) that the
+  // InputSection (IS) that we need to precede is in.
+  OutputSection *TOS = IS->getParent();
   std::vector<InputSection *> *Range = nullptr;
-  for (BaseCommand *BC : C->Commands)
+  for (BaseCommand *BC : TOS->Commands)
     if (auto *ISD = dyn_cast<InputSectionDescription>(BC)) {
       InputSection *first = ISD->Sections.front();
       InputSection *last = ISD->Sections.back();
       if (IS->OutSecOff >= first->OutSecOff &&
           IS->OutSecOff <= last->OutSecOff) {
         Range = &ISD->Sections;
         break;
       }
     }
-  TS = addThunkSection(C, Range, IS->OutSecOff);
+  TS = addThunkSection(TOS, Range, IS->OutSecOff);
   ThunkedSections[IS] = TS;
   return TS;
 }
 
-ThunkSection *ThunkCreator::addThunkSection(OutputSection *Cmd,
+ThunkSection *ThunkCreator::addThunkSection(OutputSection *OS,
                                             std::vector<InputSection *> *ISR,
                                             uint64_t Off) {
-  auto *TS = make<ThunkSection>(Cmd, Off);
+  auto *TS = make<ThunkSection>(OS, Off);
   ThunkSections[ISR].push_back(TS);
   return TS;
 }
 
 std::pair<Thunk *, bool> ThunkCreator::getThunk(SymbolBody &Body,
                                                 uint32_t Type) {
   auto Res = ThunkedSymbols.insert({&Body, std::vector<Thunk *>()});
   if (!Res.second) {
if (Pass > 0)
     ThunkSections.clear();
 
   // Create all the Thunks and insert them into synthetic ThunkSections. The
   // ThunkSections are later inserted back into the OutputSection.
 
   // We separate the creation of ThunkSections from the insertion of the
   // ThunkSections back into the OutputSection as ThunkSections are not always
   // inserted into the same OutputSection as the caller.
-  forEachExecInputSection(OutputSections, [&](OutputSection *Cmd,
+  forEachExecInputSection(OutputSections, [&](OutputSection *OS,
                                               std::vector<InputSection *> *ISR,
                                               InputSection *IS) {
     for (Relocation &Rel : IS->Relocations) {
       SymbolBody &Body = *Rel.Sym;
       if (Thunks.find(&Body) != Thunks.end() ||
           !Target->needsThunk(Rel.Expr, Rel.Type, IS->File, Body))
         continue;
       Thunk *T;
       bool IsNew;
       std::tie(T, IsNew) = getThunk(Body, Rel.Type);
       if (IsNew) {
         // Find or create a ThunkSection for the new Thunk
         ThunkSection *TS;
         if (auto *TIS = T->getTargetInputSection())
-          TS = getISThunkSec(TIS, Cmd);
+          TS = getISThunkSec(TIS);
         else
-          TS = getOSThunkSec(Cmd, ISR);
+          TS = getOSThunkSec(OS, ISR);
         TS->addThunk(T);
         Thunks[T->ThunkSym] = T;
       }
       // Redirect relocation to Thunk, we never go via the PLT to a Thunk
       Rel.Sym = T->ThunkSym;
       Rel.Expr = fromPlt(Rel.Expr);
     }
   });