[LLD][ELF] .ARM.exidx sentinel section writeTo() should use InputSectionDescriptions.

[peter.smith]

Summary

This change converts the writing of the .ARM.exidx sentinel section to use the InputSectionDescriptions instead of OutputSection::Sections this is in preparation for the retirement of OutputSection::Sections.

To use the InputSectionDescriptions we need a way of obtaining them from the OutputSection. I've chosen to add member function to extract a vector of the InputSectionDescriptions. For this particular use case it might be better to offer a more functional Script->forEachInputSection(OutSecName, lambda) interface. However some
other use cases such as processing Thunks may need to insert directly into InputSections so I've used the interface that exposes these.

I've split this out from D33239 as it is a logical intermediate step towards converting the SHF_LINK_ORDER processing to use InputSectionDescriptions.

[peter.smith]

Updated due to D33496 needing inputSectionRanges() so we don't need to add it here as well. This patch now depends on D33496.

[ruiu]

ELF/SyntheticSections.cpp

2201

This inputSectionRanges function doesn't seem to be defined. What am I missing?

[peter.smith]

The inputSectionRanges() was previously defined in D33496, I've removed it from that review to use Script->getCmd() instead. Sorry for the confusion.

I've now put it back here using an OutputSection* and getCmd() instead of StringRef, I've also started the search for the InputSection that precedes the Sentinel from the end as the sections are sorted in ascending order.

[peter.smith]

Updated patch to account for changes in D33496 which meant that we can guarantee that both the Sentinel and the preceding InputSection are in the same InputSectionDescription. This permits a simpler implementation here.

ELF/LinkerScript.h

public:
   uint64_t getOutputSectionSize(StringRef S);
   void discard(ArrayRef<InputSectionBase *> V);
 
   ExprValue getSymbolValue(const Twine &Loc, StringRef S);
   bool isDefined(StringRef S);
 
   std::vector<OutputSection *> *OutputSections;
   void fabricateDefaultCommands();
+  std::vector<std::vector<InputSection *> *>
+  inputSectionRanges(StringRef S);
   void addOrphanSections(OutputSectionFactory &Factory);
   void removeEmptyCommands();
   void adjustSectionsBeforeSorting();
   void adjustSectionsAfterSorting();
 
   std::vector<PhdrEntry> createPhdrs();
   bool ignoreInterpSection();
 

ELF/LinkerScript.cpp

if (Sec->Sections.size()) {
       }
     }
   }
   // SECTIONS commands run before other non SECTIONS commands
   Commands.insert(Commands.end(), Opt.Commands.begin(), Opt.Commands.end());
   Opt.Commands = std::move(Commands);
 }
 
+// For an OutputSection S, return the InputSectionDescriptions that are
+// associated with S. The intention is that callers can iterate over
+// InputSectionDescription::Sections and insert sections such as Thunks.
+std::vector<std::vector<InputSection *> *>
+LinkerScript::inputSectionRanges(StringRef S) {
+  std::vector<std::vector<InputSection *> *> Ranges;
+  auto OutCmdPos = std::find_if(
+      Opt.Commands.begin(), Opt.Commands.end(), [=](BaseCommand *Cmd) {
+        if (auto *OSCmd = dyn_cast<OutputSectionCommand>(Cmd))
+          return (OSCmd->Name == S);
+        return false;
+      });
+  if (OutCmdPos == Opt.Commands.end())
+    return Ranges;
+  auto *OutCmd = cast<OutputSectionCommand>(*OutCmdPos);
+  for (auto *BaseCmd : OutCmd->Commands) {
+    if (auto *ISD = dyn_cast<InputSectionDescription>(BaseCmd))
+      Ranges.push_back(&ISD->Sections);
+  }
+  return Ranges;
+}
+
 // Add sections that didn't match any sections command.
 void LinkerScript::addOrphanSections(OutputSectionFactory &Factory) {
   for (InputSectionBase *S : InputSections) {
     if (!S->Live || S->OutSec)
       continue;
     StringRef Name = getOutputSectionName(S->Name);
     auto I = std::find_if(
         Opt.Commands.begin(), Opt.Commands.end(), [&](BaseCommand *Base) {

ELF/SyntheticSections.cpp

 ARMExidxSentinelSection::ARMExidxSentinelSection()
     : SyntheticSection(SHF_ALLOC | SHF_LINK_ORDER, SHT_ARM_EXIDX,
                        Config->Wordsize, ".ARM.exidx") {}
 
 // Write a terminating sentinel entry to the end of the .ARM.exidx table.
 // This section will have been sorted last in the .ARM.exidx table.
 // This table entry will have the form:
 // | PREL31 upper bound of code that has exception tables | EXIDX_CANTUNWIND |
+// The sentinel must have the PREL31 value of an address higher than any
+// address described by any other table entry.
 void ARMExidxSentinelSection::writeTo(uint8_t *Buf) {
-  // Get the InputSection before us, we are by definition last
-  auto RI = cast<OutputSection>(this->OutSec)->Sections.rbegin();
-  InputSection *LE = *(++RI);
-  InputSection *LC = cast<InputSection>(LE->getLinkOrderDep());
-  uint64_t S = LC->OutSec->Addr + LC->getOffset(LC->getSize());
-  uint64_t P = this->getVA();
+  uint64_t S = 0;
+  uint64_t P = getVA();
+  std::vector<std::vector<InputSection *> *> Ranges =
+    Script->inputSectionRanges(OutSec->Name);
+  for (std::vector<InputSection*> *Range : Ranges)
+    for (InputSection* IS : *Range)
+      if (IS->kind() != InputSectionBase::Synthetic) {
+        InputSection *LS = cast<InputSection>(IS->getLinkOrderDep());
+        S = std::max(S, LS->OutSec->Addr + LS->getOffset(LS->getSize()));
+      }
   Target->relocateOne(Buf, R_ARM_PREL31, S - P);
   write32le(Buf + 4, 0x1);
 }
 
 ThunkSection::ThunkSection(OutputSection *OS, uint64_t Off)
     : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS,
                        Config->Wordsize, ".text.thunk") {
   this->OutSec = OS;