Relocations.cpp

  }
}

ThunkSection *ThunkCreator::getOSThunkSec(OutputSection *OS) {
  if (CurTS == nullptr) {
    uint32_t Off = 0;
    for (auto *IS : OS->Sections) {
      Off = IS->OutSecOff + IS->getSize();
      if ((IS->Flags & SHF_EXECINSTR) == 0)
        break;
    }
    CurTS = make<ThunkSection>(OS, Off);
    ThunkSections[&OS->Sections].push_back(CurTS);
  }
  return CurTS;
}

ThunkSection *ThunkCreator::getISThunkSec(InputSection *IS, OutputSection *OS) {
  ThunkSection *TS = ThunkedSections.lookup(IS);
  if (TS)
    return TS;
  auto *TOS = IS->getParent();
  TS = make<ThunkSection>(TOS, IS->OutSecOff);
  ThunkSections[&TOS->Sections].push_back(TS);
  ThunkedSections[IS] = TS;
  return TS;
}

std::pair<Thunk *, bool> ThunkCreator::getThunk(SymbolBody &Body,
                                                uint32_t Type) {
  auto res = ThunkedSymbols.insert({&Body, nullptr});
  if (res.second)
    res.first->second = addThunk(Type, Body);
  return std::make_pair(res.first->second, res.second);
}

// Call Fn on every executable InputSection accessed via the linker script
// InputSectionDescription::Sections.
void ThunkCreator::forEachExecInputSection(
    ArrayRef<OutputSection *> OutputSections,
    std::function<void(OutputSection *, InputSection *)> Fn) {
  for (OutputSection *OS : OutputSections) {
    if (!(OS->Flags & SHF_ALLOC) || !(OS->Flags & SHF_EXECINSTR))
      continue;
    CurTS = nullptr;
    for (InputSection *IS : OS->Sections)
      Fn(OS, IS);
  }
}

// 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
// finalized. If any Thunks are added to an OutputSection the output section
// offsets of the InputSections will change.
//
// FIXME: All Thunks are assumed to be in range of the relocation. Range
// extension Thunks are not yet supported.
bool ThunkCreator::createThunks(ArrayRef<OutputSection *> OutputSections) {
  // 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 *OS, InputSection *IS) {
        for (Relocation &Rel : IS->Relocations) {
          SymbolBody &Body = *Rel.Sym;
          if (!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, OS);
            else
              TS = getOSThunkSec(OS);
            TS->addThunk(T);
          }
          // Redirect relocation to Thunk, we never go via the PLT to a Thunk
          Rel.Sym = T->ThunkSym;
          Rel.Expr = fromPlt(Rel.Expr);
        }
      });

  // Merge all created synthetic ThunkSections back into OutputSection
  mergeThunks();
  return !ThunkSections.empty();
}

template void elf::scanRelocations<ELF32LE>(InputSectionBase &);
template void elf::scanRelocations<ELF32BE>(InputSectionBase &);
template void elf::scanRelocations<ELF64LE>(InputSectionBase &);
template void elf::scanRelocations<ELF64BE>(InputSectionBase &);