demo

[grimar]

Summary

for demo purposes only

ELF/SyntheticSections.cpp

 static std::vector<std::pair<uint64_t, uint64_t>>
 readCuList(DWARFContext &Dwarf, InputSection *Sec) {
   std::vector<std::pair<uint64_t, uint64_t>> Ret;
   for (std::unique_ptr<DWARFCompileUnit> &CU : Dwarf.compile_units())
     Ret.push_back({Sec->OutSecOff + CU->getOffset(), CU->getLength() + 4});
   return Ret;
 }
 
-static InputSectionBase *findSection(ArrayRef<InputSectionBase *> Arr,
+// Finds input section Offset belongs to in [Begin, End] interval which must be
+// sorted by offset in file. Algorithm used is binary search. We can not simply use
+// std::lower_bound instead because have input sections that are discarded
+// or even just null.
+static InputSectionBase *findSection(InputSectionBase *const *Begin,
+                                     InputSectionBase *const *End,
                                      uint64_t Offset) {
-  for (InputSectionBase *S : Arr)
-    if (S && S != &InputSection::Discarded)
-      if (Offset >= S->getOffsetInFile() &&
-          Offset < S->getOffsetInFile() + S->getSize())
-        return S;
+  while (!*Begin || *Begin == &InputSection::Discarded)
+    if (++Begin > End)
+      return nullptr;
+
+  while (!*End || *End == &InputSection::Discarded)
+    if (--End < Begin)
+      return nullptr;
+
+  if ((*Begin)->getOffsetInFile() > Offset ||
+      Offset > (*End)->getOffsetInFile() + (*End)->getSize())
+    return nullptr;
+
+  if (Begin == End)
+    return *Begin;
+
+  size_t N = (End - Begin) / 2;
+  InputSectionBase *const *Mid = Begin + N;
+  if (InputSectionBase *Ret = findSection(Mid + 1, End, Offset))
+    return Ret;
+  if (InputSectionBase *Ret = findSection(Begin, Mid, Offset))
+    return Ret;
   return nullptr;
 }
 
 static std::vector<AddressEntry>
 readAddressArea(DWARFContext &Dwarf, InputSection *Sec, size_t CurrentCU) {
   std::vector<AddressEntry> Ret;
 
+  ArrayRef<InputSectionBase *> Arr = Sec->File->getSections();
   for (std::unique_ptr<DWARFCompileUnit> &CU : Dwarf.compile_units()) {
     DWARFAddressRangesVector Ranges;
     CU->collectAddressRanges(Ranges);
 
-    ArrayRef<InputSectionBase *> Sections = Sec->File->getSections();
-    for (std::pair<uint64_t, uint64_t> &R : Ranges)
-      if (InputSectionBase *S = findSection(Sections, R.first))
-        Ret.push_back({S, R.first - S->getOffsetInFile(),
-                       R.second - S->getOffsetInFile(), CurrentCU});
+    for (std::pair<uint64_t, uint64_t> &R : Ranges) {
+      InputSectionBase *IS =
+          findSection(Arr.begin(), Arr.begin() + Arr.size() - 1, R.first);
+      if (IS)
+        Ret.push_back({IS, R.first - IS->getOffsetInFile(),
+                       R.second - IS->getOffsetInFile(), CurrentCU});
+    }
     ++CurrentCU;
   }
   return Ret;
 }
 
 static std::vector<std::pair<StringRef, uint8_t>>
 readPubNamesAndTypes(DWARFContext &Dwarf, bool IsLE) {
   StringRef Data[] = {Dwarf.getGnuPubNamesSection(),
                       Dwarf.getGnuPubTypesSection()};
 
   std::vector<std::pair<StringRef, uint8_t>> Ret;
   for (StringRef D : Data) {
     DWARFDebugPubTable PubTable(D, IsLE, true);
     for (const DWARFDebugPubTable::Set &Set : PubTable.getData())
       for (const DWARFDebugPubTable::Entry &Ent : Set.Entries)
         Ret.push_back({Ent.Name, Ent.Descriptor.toBits()});
   }
   return Ret;
 }
 
 class ObjInfoTy : public llvm::LoadedObjectInfo {
   uint64_t getSectionLoadAddress(const object::SectionRef &Sec) const override {
     auto &S = static_cast<const object::ELFSectionRef &>(Sec);
+
+    //ELFObjectFile< S.getObject()
+
     if (S.getFlags() & ELF::SHF_ALLOC)
       return S.getOffset();
+    //assert(false);
     return 0;
   }
 
   std::unique_ptr<llvm::LoadedObjectInfo> clone() const override { return {}; }
 };
 
 void GdbIndexSection::readDwarf(InputSection *Sec) {
   Expected<std::unique_ptr<object::ObjectFile>> Obj =