[llvm-objdump] [NFC] Use a single vector to store all symbol mappings.

[jacek]

Summary

This is a preparation for D149095. D156190 introduced AllMappingSymbols, which is close to what CHPE map. CHPE map operates on ranges that may cross sections. This patch uses a single vector for all mappings and leaves handling of mapping from other sections up to getMappingSymbolKind.

[jhenderson]

LGTM.

[foad]

Hi @jacek, this causes a few test failures if you configure with -DLLVM_ENABLE_EXPENSIVE_CHECKS=ON -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=CSKY:

Failed Tests (7):
  LLVM :: DebugInfo/CSKY/dwarf-csky-relocs.ll
  LLVM :: MC/CSKY/3e3r1.s
  LLVM :: MC/CSKY/801.s
  LLVM :: MC/CSKY/basic-16bit.s
  LLVM :: MC/CSKY/basic.s
  LLVM :: MC/CSKY/fpuv2.s
  LLVM :: MC/CSKY/fpuv3.s

@Zeson FYI.

[jacek]

In D156622#4554313, @foad wrote:

Hi @jacek, this causes a few test failures if you configure with -DLLVM_ENABLE_EXPENSIVE_CHECKS=ON -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=CSKY:

I think I can see what's going wrong, sections like .csky.attributes may interleave with other sections in MappingSymbols. I will revert the patch and implement it differently, sorry about that.

llvm/tools/llvm-objdump/llvm-objdump.cpp

static bool shouldAdjustVA(const SectionRef &Section) {
   if (Obj->isELF())
     return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
   return false;
 }
 
 
 typedef std::pair<uint64_t, char> MappingSymbolPair;
 static char getMappingSymbolKind(ArrayRef<MappingSymbolPair> MappingSymbols,
-                                 uint64_t Address) {
-  auto It =
-      partition_point(MappingSymbols, [Address](const MappingSymbolPair &Val) {
-        return Val.first <= Address;
-      });
+                                 uint64_t SectionAddress, uint64_t Index) {
+  auto It = partition_point(MappingSymbols, [=](const MappingSymbolPair &Val) {
+    return Val.first <= SectionAddress + Index;
   // Return zero for any address before the first mapping symbol; this means
   // we should use the default disassembly mode, depending on the target.
-  if (It == MappingSymbols.begin())
+  if (It == MappingSymbols.begin() || (--It)->first < SectionAddress)
     return '\x00';
-  return (It - 1)->second;
+  return It->second;
 }
 
 static uint64_t dumpARMELFData(uint64_t SectionAddr, uint64_t Index,
                                uint64_t End, const ObjectFile &Obj,
                                ArrayRef<uint8_t> Bytes,
-                               ArrayRef<MappingSymbolPair> MappingSymbols,
                                const MCSubtargetInfo &STI, raw_ostream &OS) {
   support::endianness Endian =
       Obj.isLittleEndian() ? support::little : support::big;
   size_t Start = OS.tell();
   OS << format("%8" PRIx64 ": ", SectionAddr + Index);
   if (Index + 4 <= End) {
     dumpBytes(Bytes.slice(Index, 4), OS);
     AlignToInstStartColumn(Start, STI, OS);
disassembleObject(ObjectFile &Obj, const ObjectFile &DbgObj,
   std::map<SectionRef, std::vector<RelocationRef>> RelocMap;
   if (InlineRelocs)
     RelocMap = getRelocsMap(Obj);
   bool Is64Bits = Obj.getBytesInAddress() > 4;
 
   // Create a mapping from virtual address to symbol name.  This is used to
   // pretty print the symbols while disassembling.
   std::map<SectionRef, SectionSymbolsTy> AllSymbols;
-  std::map<SectionRef, SmallVector<MappingSymbolPair, 0>> AllMappingSymbols;
+  std::vector<MappingSymbolPair> MappingSymbols;
   SectionSymbolsTy AbsoluteSymbols;
   const StringRef FileName = Obj.getFileName();
   const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(&Obj);
   for (const SymbolRef &Symbol : Obj.symbols()) {
     Expected<StringRef> NameOrErr = Symbol.getName();
     if (!NameOrErr) {
       reportWarning(toString(NameOrErr.takeError()), FileName);
       continue;
     }
     if (NameOrErr->empty() && !(Obj.isXCOFF() && SymbolDescription))
       continue;
 
     if (Obj.isELF() &&
         (cantFail(Symbol.getFlags()) & SymbolRef::SF_FormatSpecific)) {
       // Symbol is intended not to be displayed by default (STT_FILE,
       // STT_SECTION, or a mapping symbol). Ignore STT_SECTION symbols. We will
       // synthesize a section symbol if no symbol is defined at offset 0.
       //
       // For a mapping symbol, store it within both AllSymbols and
-      // AllMappingSymbols. If --show-all-symbols is unspecified, its label will
+      // MappingSymbols. If --show-all-symbols is unspecified, its label will
       // not be printed in disassembly listing.
       if (getElfSymbolType(Obj, Symbol) != ELF::STT_SECTION &&
           hasMappingSymbols(Obj)) {
         section_iterator SecI = unwrapOrError(Symbol.getSection(), FileName);
         if (SecI != Obj.section_end()) {
-          uint64_t SectionAddr = SecI->getAddress();
           uint64_t Address = cantFail(Symbol.getAddress());
           StringRef Name = *NameOrErr;
           if (Name.consume_front("$") && Name.size() &&
               strchr("adtx", Name[0])) {
-            AllMappingSymbols[*SecI].emplace_back(Address - SectionAddr,
-                                                  Name[0]);
+            MappingSymbols.emplace_back(Address, Name[0]);
             AllSymbols[*SecI].push_back(
                 createSymbolInfo(Obj, Symbol, /*MappingSymbol=*/true));
           }
         }
       }
       continue;
     }
 
for (const SymbolRef &Symbol : Obj.symbols()) {
 
     section_iterator SecI = unwrapOrError(Symbol.getSection(), FileName);
     if (SecI != Obj.section_end())
       AllSymbols[*SecI].push_back(createSymbolInfo(Obj, Symbol));
     else
       AbsoluteSymbols.push_back(createSymbolInfo(Obj, Symbol));
   }
 
+  llvm::sort(MappingSymbols);
+
   if (AllSymbols.empty() && Obj.isELF())
     addDynamicElfSymbols(cast<ELFObjectFileBase>(Obj), AllSymbols);
 
   if (Obj.isWasm())
     addMissingWasmCodeSymbols(cast<WasmObjectFile>(Obj), AllSymbols);
 
   if (Obj.isELF() && Obj.sections().empty())
     createFakeELFSections(Obj);
for (const SectionRef &Section : ToolSectionFilter(Obj)) {
 
     // For relocatable object files, read the LLVM_BB_ADDR_MAP section
     // corresponding to this section, if present.
     if (SymbolizeOperands && Obj.isRelocatableObject())
       ReadBBAddrMap(Section.getIndex());
 
     // Get the list of all the symbols in this section.
     SectionSymbolsTy &Symbols = AllSymbols[Section];
-    auto &MappingSymbols = AllMappingSymbols[Section];
-    llvm::sort(MappingSymbols);
 
     ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(
         unwrapOrError(Section.getContents(), Obj.getFileName()));
 
     std::vector<std::unique_ptr<std::string>> SynthesizedLabelNames;
     if (Obj.isELF() && Obj.getArch() == Triple::amdgcn) {
       // AMDGPU disassembler uses symbolizer for printing labels
       addSymbolizer(*DT->Context, DT->TheTarget, TripleName, DT->DisAsm.get(),
for (size_t SI = 0, SE = Symbols.size(); SI != SE;) {
       }
 
       while (Index < End) {
         // ARM and AArch64 ELF binaries can interleave data and text in the
         // same section. We rely on the markers introduced to understand what
         // we need to dump. If the data marker is within a function, it is
         // denoted as a word/short etc.
         if (!MappingSymbols.empty()) {
-          char Kind = getMappingSymbolKind(MappingSymbols, Index);
+          char Kind = getMappingSymbolKind(MappingSymbols, SectionAddr, Index);
           DumpARMELFData = Kind == 'd';
           if (SecondaryTarget) {
             if (Kind == 'a') {
               DT = PrimaryIsThumb ? &*SecondaryTarget : &PrimaryTarget;
             } else if (Kind == 't') {
               DT = PrimaryIsThumb ? &PrimaryTarget : &*SecondaryTarget;
             }
           }
         }
 
         if (DumpARMELFData) {
           Size = dumpARMELFData(SectionAddr, Index, End, Obj, Bytes,
-                                MappingSymbols, *DT->SubtargetInfo, FOS);
+                                *DT->SubtargetInfo, FOS);
         } else {
           // When -z or --disassemble-zeroes are given we always dissasemble
           // them. Otherwise we might want to skip zero bytes we see.
           if (!DisassembleZeroes) {
             uint64_t MaxOffset = End - Index;
             // For --reloc: print zero blocks patched by relocations, so that
             // relocations can be shown in the dump.
             if (RelCur != RelEnd)