[LLD][ELF] Move creation of .ARM.exidx sentinel before LinkerScript creation

[peter.smith]

Summary

This change moves the creation of the .ARM.exidx sentinel section forward so that it is assigned to an OutputSection/InputSectionDescription with the existing .ARM.exidx sections.

A consequence of moving the .ARM.exidx creation earlier is that we can no longer guarantee that it will be already last in the table so we must account for this in the comparison function.

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 patch to just append the .ARM.exidx sentinel section to an existing LinkerScript InputSectionDescription.

To do the insertion I've moved the LinkerScript::inputSectionRanges() function from D33500 so we can use it do the insertion and updated D33500.

[peter.smith]

Updated patch to use Script->getCmd(OS) as suggested.

I removed the comment "This function adds linker-created Out::* sections." as it seemed to be out of date as we don't have Out:: sections any more. I'm happy to put it back in or change it to something more specific like: " // Add any linker dependent sections that are dependent on the OutputSections"

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 (I == Opt.Commands.end()) {
       }
       auto *ISD = make<InputSectionDescription>("");
       ISD->Sections.push_back(cast<InputSection>(S));
       Cmd->Commands.push_back(ISD);
     }
   }
 }
 
+// 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;
+}
+
 uint64_t LinkerScript::advance(uint64_t Size, unsigned Align) {
   bool IsTbss = (CurOutSec->Flags & SHF_TLS) && CurOutSec->Type == SHT_NOBITS;
   uint64_t Start = IsTbss ? Dot + ThreadBssOffset : Dot;
   Start = alignTo(Start, Align);
   uint64_t End = Start + Size;
 
   if (IsTbss)
     ThreadBssOffset = End - Dot;

ELF/Writer.cpp

if (InX::DynSymTab && S->includeInDynsym()) {
           In<ELFT>::VerNeed->addSymbol(SS);
     }
   }
 
   // Do not proceed if there was an undefined symbol.
   if (ErrorCount)
     return;
 
-  // So far we have added sections from input object files.
-  // This function adds linker-created Out::* sections.
   addPredefinedSections();
   removeUnusedSyntheticSections(OutputSections);
 
   sortSections();
 
   // This is a bit of a hack. A value of 0 means undef, so we set it
   // to 1 t make __ehdr_start defined. The section number is not
   // particularly relevant.
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   applySynthetic({InX::SymTab, InX::ShStrTab, InX::StrTab},
                  [](SyntheticSection *SS) { SS->postThunkContents(); });
 }
 
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
   // ARM ABI requires .ARM.exidx to be terminated by some piece of data.
   // We have the terminater synthetic section class. Add that at the end.
   auto *OS = dyn_cast_or_null<OutputSection>(findSection(".ARM.exidx"));
-  if (OS && !OS->Sections.empty() && !Config->Relocatable)
-    OS->addSection(make<ARMExidxSentinelSection>());
+  if (!OS || OS->Sections.empty() || Config->Relocatable)
+    return;
+
+  auto *Sentinel = make<ARMExidxSentinelSection>();
+  OS->addSection(Sentinel);
+  // If there are linker script commands existing at this point then add the
+  // sentinel to these too.
+  std::vector<std::vector<InputSection *> *> Ranges =
+      Script->inputSectionRanges(OS->Name);
+  if (!Ranges.empty())
+    Ranges.back()->push_back(Sentinel);
 }
 
 // The linker is expected to define SECNAME_start and SECNAME_end
 // symbols for a few sections. This function defines them.
 template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
   auto Define = [&](StringRef Start, StringRef End, OutputSection *OS) {
     // These symbols resolve to the image base if the section does not exist.
     // A special value -1 indicates end of the section.