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     if (PrintSymbols)
  82       printSymbols();
  83     if (PrintDynamicSymbols)
  84       printDynamicSymbols();
  85   }
  86   virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols,
  87                             std::optional<SymbolComparator> SymComp) {
  88     if (SymComp) {
  89       if (PrintSymbols)
  90         printSymbols(SymComp);
  91       if (PrintDynamicSymbols)
  92         printDynamicSymbols(SymComp);
  93     } else {
  94       printSymbols(PrintSymbols, PrintDynamicSymbols);
  95     }
  96   }
  97   virtual void printProgramHeaders(bool PrintProgramHeaders,
  98                                    cl::boolOrDefault PrintSectionMapping) {
  99     if (PrintProgramHeaders)
 100       printProgramHeaders();
 101     if (PrintSectionMapping == cl::BOU_TRUE)
 102       printSectionMapping();
 103   }
 104
 105   virtual void printUnwindInfo() = 0;
 106
 107   // Symbol comparison functions.
 108   virtual bool canCompareSymbols() const { return false; }
 109   virtual bool compareSymbolsByName(object::SymbolRef LHS,
 110                                     object::SymbolRef RHS) const {
 111     return true;
 112   }
 113   virtual bool compareSymbolsByType(object::SymbolRef LHS,
 114                                     object::SymbolRef RHS) const {
 115     return true;
 116   }
 117
 118   // Only implemented for ELF at this time.
 119   virtual void printDependentLibs() {}
 120   virtual void printDynamicRelocations() { }
 121   virtual void printDynamicTable() { }
 122   virtual void printNeededLibraries() { }
 123   virtual void printSectionAsHex(StringRef SectionName) {}
 124   virtual void printHashTable() { }
 125   virtual void printGnuHashTable() {}
 126   virtual void printHashSymbols() {}
 127   virtual void printLoadName() {}
 128   virtual void printVersionInfo() {}
 129   virtual void printGroupSections() {}
 130   virtual void printHashHistograms() {}
 131   virtual void printCGProfile() {}
 132   virtual void printBBAddrMaps() {}
 133   virtual void printAddrsig() {}
 134   virtual void printNotes() {}
 135   virtual void printELFLinkerOptions() {}
 136   virtual void printStackSizes() {}
 137   virtual void printSectionDetails() {}
 138   virtual void printArchSpecificInfo() {}
 139   virtual void printMemtag() {}
 140
 141   // Only implemented for PE/COFF.
 142   virtual void printCOFFImports() { }
 143   virtual void printCOFFExports() { }
 144   virtual void printCOFFDirectives() { }
 145   virtual void printCOFFBaseReloc() { }
 146   virtual void printCOFFDebugDirectory() { }
 147   virtual void printCOFFTLSDirectory() {}
 148   virtual void printCOFFResources() {}
 149   virtual void printCOFFLoadConfig() { }
 150   virtual void printCodeViewDebugInfo() { }
 151   virtual void
 152   mergeCodeViewTypes(llvm::codeview::MergingTypeTableBuilder &CVIDs,
 153                      llvm::codeview::MergingTypeTableBuilder &CVTypes,
 154                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVIDs,
 155                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVTypes,
 156                      bool GHash) {}
 157
 158   // Only implemented for XCOFF.
 159   virtual void printStringTable() {}
 160   virtual void printAuxiliaryHeader() {}
 161   virtual void printExceptionSection() {}
 162   virtual void printLoaderSection(bool PrintHeader, bool PrintSymbols,
 163                                   bool PrintRelocations) {}
 164
 165   // Only implemented for MachO.
 166   virtual void printMachODataInCode() { }
 167   virtual void printMachOVersionMin() { }
 168   virtual void printMachODysymtab() { }
 169   virtual void printMachOSegment() { }
 170   virtual void printMachOIndirectSymbols() { }
 171   virtual void printMachOLinkerOptions() { }
 172
 173   virtual void printStackMap() const = 0;
 174
 175   void printAsStringList(StringRef StringContent, size_t StringDataOffset = 0);
 176
 177   void printSectionsAsString(const object::ObjectFile &Obj,
 178                              ArrayRef<std::string> Sections);
 179   void printSectionsAsHex(const object::ObjectFile &Obj,
 180                           ArrayRef<std::string> Sections);
 181
 182   std::function<Error(const Twine &Msg)> WarningHandler;
 183   void reportUniqueWarning(Error Err) const;
 184   void reportUniqueWarning(const Twine &Msg) const;
 185
 186 protected:
 187   ScopedPrinter &W;
 188
 189 private:
 190   virtual void printSymbols() {}
 191   virtual void printSymbols(std::optional<SymbolComparator> Comp) {}
 192   virtual void printDynamicSymbols() {}
 193   virtual void printDynamicSymbols(std::optional<SymbolComparator> Comp) {}
 194   virtual void printProgramHeaders() {}
 195   virtual void printSectionMapping() {}
 196
 197   std::unordered_set<std::string> Warnings;
 198 };
 199
 200 std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
 201                                             ScopedPrinter &Writer);
 202
 203 std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
 204                                            ScopedPrinter &Writer);
 205
 206 std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
 207                                              ScopedPrinter &Writer);
 208
 209 std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
 210                                             ScopedPrinter &Writer);
 211
 212 std::unique_ptr<ObjDumper> createXCOFFDumper(const object::XCOFFObjectFile &Obj,
 213                                              ScopedPrinter &Writer);
 214
 215 void dumpCOFFImportFile(const object::COFFImportFile *File,
 216                         ScopedPrinter &Writer);
 217
 218 void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
 219                              ArrayRef<ArrayRef<uint8_t>> IpiRecords,
 220                              ArrayRef<ArrayRef<uint8_t>> TpiRecords);
 221
 222 } // namespace llvm
 223
 224 #endif