llvm/tools/llvm-readobj/ObjDumper.h

   1 //===-- ObjDumper.h ---------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
  10 #define LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
  11
  12 #include <functional>
  13 #include <memory>
  14 #include <system_error>
  15
  16 #include "llvm/ADT/STLFunctionalExtras.h"
  17 #include "llvm/ADT/SmallVector.h"
  18 #include "llvm/ADT/StringMap.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/Object/ObjectFile.h"
  21 #include "llvm/Support/CommandLine.h"
  22
  23 #include <unordered_set>
  24
  25 namespace llvm {
  26 namespace object {
  27 class Archive;
  28 class COFFImportFile;
  29 class ObjectFile;
  30 class XCOFFObjectFile;
  31 class ELFObjectFileBase;
  32 } // namespace object
  33 namespace codeview {
  34 class GlobalTypeTableBuilder;
  35 class MergingTypeTableBuilder;
  36 } // namespace codeview
  37
  38 class ScopedPrinter;
  39
  40 // Comparator to compare symbols.
  41 // Usage: the caller registers predicates (i.e., how to compare the symbols) by
  42 // calling addPredicate(). The order in which predicates are registered is also
  43 // their priority.
  44 class SymbolComparator {
  45 public:
  46   using CompPredicate =
  47       std::function<bool(object::SymbolRef, object::SymbolRef)>;
  48
  49   // Each Obj format has a slightly different way of retrieving a symbol's info
  50   // So we defer the predicate's impl to each format.
  51   void addPredicate(CompPredicate Pred) { Predicates.push_back(Pred); }
  52
  53   bool operator()(object::SymbolRef LHS, object::SymbolRef RHS) {
  54     for (CompPredicate Pred : Predicates) {
  55       if (Pred(LHS, RHS))
  56         return true;
  57       if (Pred(RHS, LHS))
  58         return false;
  59     }
  60     return false;
  61   }
  62
  63 private:
  64   SmallVector<CompPredicate, 2> Predicates;
  65 };
  66
  67 class ObjDumper {
  68 public:
  69   ObjDumper(ScopedPrinter &Writer, StringRef ObjName);
  70   virtual ~ObjDumper();
  71
  72   virtual bool canDumpContent() { return true; }
  73
  74   virtual void printFileSummary(StringRef FileStr, object::ObjectFile &Obj,
  75                                 ArrayRef<std::string> InputFilenames,
  76                                 const object::Archive *A);
  77   virtual void printFileHeaders() = 0;
  78   virtual void printSectionHeaders() = 0;
  79   virtual void printRelocations() = 0;
  80   virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols,
  81                             bool ExtraSymInfo) {
  82     if (PrintSymbols)
  83       printSymbols(ExtraSymInfo);
  84     if (PrintDynamicSymbols)
  85       printDynamicSymbols();
  86   }
  87   virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols,
  88                             bool ExtraSymInfo,
  89                             std::optional<SymbolComparator> SymComp) {
  90     if (SymComp) {
  91       if (PrintSymbols)
  92         printSymbols(SymComp);
  93       if (PrintDynamicSymbols)
  94         printDynamicSymbols(SymComp);
  95     } else {
  96       printSymbols(PrintSymbols, PrintDynamicSymbols, ExtraSymInfo);
  97     }
  98   }
  99   virtual void printProgramHeaders(bool PrintProgramHeaders,
 100                                    cl::boolOrDefault PrintSectionMapping) {
 101     if (PrintProgramHeaders)
 102       printProgramHeaders();
 103     if (PrintSectionMapping == cl::BOU_TRUE)
 104       printSectionMapping();
 105   }
 106
 107   virtual void printUnwindInfo() = 0;
 108
 109   // Symbol comparison functions.
 110   virtual bool canCompareSymbols() const { return false; }
 111   virtual bool compareSymbolsByName(object::SymbolRef LHS,
 112                                     object::SymbolRef RHS) const {
 113     return true;
 114   }
 115   virtual bool compareSymbolsByType(object::SymbolRef LHS,
 116                                     object::SymbolRef RHS) const {
 117     return true;
 118   }
 119
 120   // Only implemented for ELF at this time.
 121   virtual void printDependentLibs() {}
 122   virtual void printDynamicRelocations() { }
 123   virtual void printDynamicTable() { }
 124   virtual void printNeededLibraries() { }
 125   virtual void printSectionAsHex(StringRef SectionName) {}
 126   virtual void printHashTable() { }
 127   virtual void printGnuHashTable() {}
 128   virtual void printHashSymbols() {}
 129   virtual void printLoadName() {}
 130   virtual void printVersionInfo() {}
 131   virtual void printGroupSections() {}
 132   virtual void printHashHistograms() {}
 133   virtual void printCGProfile() {}
 134   virtual void printBBAddrMaps() {}
 135   virtual void printAddrsig() {}
 136   virtual void printNotes() {}
 137   virtual void printELFLinkerOptions() {}
 138   virtual void printStackSizes() {}
 139   virtual void printSectionDetails() {}
 140   virtual void printArchSpecificInfo() {}
 141   virtual void printMemtag() {}
 142
 143   // Only implemented for PE/COFF.
 144   virtual void printCOFFImports() { }
 145   virtual void printCOFFExports() { }
 146   virtual void printCOFFDirectives() { }
 147   virtual void printCOFFBaseReloc() { }
 148   virtual void printCOFFDebugDirectory() { }
 149   virtual void printCOFFTLSDirectory() {}
 150   virtual void printCOFFResources() {}
 151   virtual void printCOFFLoadConfig() { }
 152   virtual void printCodeViewDebugInfo() { }
 153   virtual void
 154   mergeCodeViewTypes(llvm::codeview::MergingTypeTableBuilder &CVIDs,
 155                      llvm::codeview::MergingTypeTableBuilder &CVTypes,
 156                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVIDs,
 157                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVTypes,
 158                      bool GHash) {}
 159
 160   // Only implemented for XCOFF.
 161   virtual void printStringTable() {}
 162   virtual void printAuxiliaryHeader() {}
 163   virtual void printExceptionSection() {}
 164   virtual void printLoaderSection(bool PrintHeader, bool PrintSymbols,
 165                                   bool PrintRelocations) {}
 166
 167   // Only implemented for MachO.
 168   virtual void printMachODataInCode() { }
 169   virtual void printMachOVersionMin() { }
 170   virtual void printMachODysymtab() { }
 171   virtual void printMachOSegment() { }
 172   virtual void printMachOIndirectSymbols() { }
 173   virtual void printMachOLinkerOptions() { }
 174
 175   virtual void printStackMap() const = 0;
 176
 177   void printAsStringList(StringRef StringContent, size_t StringDataOffset = 0);
 178
 179   void printSectionsAsString(const object::ObjectFile &Obj,
 180                              ArrayRef<std::string> Sections);
 181   void printSectionsAsHex(const object::ObjectFile &Obj,
 182                           ArrayRef<std::string> Sections);
 183
 184   std::function<Error(const Twine &Msg)> WarningHandler;
 185   void reportUniqueWarning(Error Err) const;
 186   void reportUniqueWarning(const Twine &Msg) const;
 187
 188 protected:
 189   ScopedPrinter &W;
 190
 191 private:
 192   virtual void printSymbols(bool ExtraSymInfo) {}
 193   virtual void printSymbols(std::optional<SymbolComparator> Comp) {}
 194   virtual void printDynamicSymbols() {}
 195   virtual void printDynamicSymbols(std::optional<SymbolComparator> Comp) {}
 196   virtual void printProgramHeaders() {}
 197   virtual void printSectionMapping() {}
 198
 199   std::unordered_set<std::string> Warnings;
 200 };
 201
 202 std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
 203                                             ScopedPrinter &Writer);
 204
 205 std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
 206                                            ScopedPrinter &Writer);
 207
 208 std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
 209                                              ScopedPrinter &Writer);
 210
 211 std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
 212                                             ScopedPrinter &Writer);
 213
 214 std::unique_ptr<ObjDumper> createXCOFFDumper(const object::XCOFFObjectFile &Obj,
 215                                              ScopedPrinter &Writer);
 216
 217 void dumpCOFFImportFile(const object::COFFImportFile *File,
 218                         ScopedPrinter &Writer);
 219
 220 void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
 221                              ArrayRef<ArrayRef<uint8_t>> IpiRecords,
 222                              ArrayRef<ArrayRef<uint8_t>> TpiRecords);
 223
 224 } // namespace llvm
 225
 226 #endif