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/SmallVector.h"
17#include "llvm/ADT/StringRef.h"
18#include "llvm/Object/ObjectFile.h"
19#include "llvm/Support/CommandLine.h"
20
21#include <unordered_set>
22
23namespace llvm {
24namespace object {
25class Archive;
26class COFFImportFile;
27class ObjectFile;
28class XCOFFObjectFile;
29class ELFObjectFileBase;
30} // namespace object
31namespace codeview {
32class GlobalTypeTableBuilder;
33class MergingTypeTableBuilder;
34} // namespace codeview
35
36class ScopedPrinter;
37
38// Comparator to compare symbols.
39// Usage: the caller registers predicates (i.e., how to compare the symbols) by
40// calling addPredicate(). The order in which predicates are registered is also
41// their priority.
42class SymbolComparator {
43public:
44 using CompPredicate =
45 std::function<bool(object::SymbolRef, object::SymbolRef)>;
46
47 // Each Obj format has a slightly different way of retrieving a symbol's info
48 // So we defer the predicate's impl to each format.
49 void addPredicate(CompPredicate Pred) { Predicates.push_back(Elt: Pred); }
50
51 bool operator()(object::SymbolRef LHS, object::SymbolRef RHS) {
52 for (CompPredicate Pred : Predicates) {
53 if (Pred(LHS, RHS))
54 return true;
55 if (Pred(RHS, LHS))
56 return false;
57 }
58 return false;
59 }
60
61private:
62 SmallVector<CompPredicate, 2> Predicates;
63};
64
65class ObjDumper {
66public:
67 ObjDumper(ScopedPrinter &Writer, StringRef ObjName);
68 virtual ~ObjDumper();
69
70 virtual bool canDumpContent() { return true; }
71
72 virtual void printFileSummary(StringRef FileStr, object::ObjectFile &Obj,
73 ArrayRef<std::string> InputFilenames,
74 const object::Archive *A);
75 virtual void printFileHeaders() = 0;
76 virtual void printSectionHeaders() = 0;
77 virtual void printRelocations() = 0;
78 virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols,
79 bool ExtraSymInfo) {
80 if (PrintSymbols)
81 printSymbols(ExtraSymInfo);
82 if (PrintDynamicSymbols)
83 printDynamicSymbols();
84 }
85 virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols,
86 bool ExtraSymInfo,
87 std::optional<SymbolComparator> SymComp) {
88 if (SymComp) {
89 if (PrintSymbols)
90 printSymbols(Comp: SymComp);
91 if (PrintDynamicSymbols)
92 printDynamicSymbols(Comp: SymComp);
93 } else {
94 printSymbols(PrintSymbols, PrintDynamicSymbols, ExtraSymInfo);
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 // If PrettyPGOAnalysis is true, prints BFI as relative frequency and BPI as
133 // percentage. Otherwise raw values are displayed.
134 virtual void printBBAddrMaps(bool PrettyPGOAnalysis) {}
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/COFF.
161 virtual void printStringTable() {}
162
163 // Only implemented for XCOFF.
164 virtual void printAuxiliaryHeader() {}
165 virtual void printExceptionSection() {}
166 virtual void printLoaderSection(bool PrintHeader, bool PrintSymbols,
167 bool PrintRelocations) {}
168
169 // Only implemented for MachO.
170 virtual void printMachODataInCode() { }
171 virtual void printMachOVersionMin() { }
172 virtual void printMachODysymtab() { }
173 virtual void printMachOSegment() { }
174 virtual void printMachOIndirectSymbols() { }
175 virtual void printMachOLinkerOptions() { }
176
177 virtual void printStackMap() const = 0;
178
179 void printAsStringList(StringRef StringContent, size_t StringDataOffset = 0);
180
181 void printSectionsAsString(const object::ObjectFile &Obj,
182 ArrayRef<std::string> Sections, bool Decompress);
183 void printSectionsAsHex(const object::ObjectFile &Obj,
184 ArrayRef<std::string> Sections, bool Decompress);
185
186 std::function<Error(const Twine &Msg)> WarningHandler;
187 void reportUniqueWarning(Error Err) const;
188 void reportUniqueWarning(const Twine &Msg) const;
189
190protected:
191 ScopedPrinter &W;
192
193private:
194 virtual void printSymbols(bool ExtraSymInfo) {}
195 virtual void printSymbols(std::optional<SymbolComparator> Comp) {}
196 virtual void printDynamicSymbols() {}
197 virtual void printDynamicSymbols(std::optional<SymbolComparator> Comp) {}
198 virtual void printProgramHeaders() {}
199 virtual void printSectionMapping() {}
200
201 std::unordered_set<std::string> Warnings;
202};
203
204std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
205 ScopedPrinter &Writer);
206
207std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
208 ScopedPrinter &Writer);
209
210std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
211 ScopedPrinter &Writer);
212
213std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
214 ScopedPrinter &Writer);
215
216std::unique_ptr<ObjDumper> createXCOFFDumper(const object::XCOFFObjectFile &Obj,
217 ScopedPrinter &Writer);
218
219void dumpCOFFImportFile(const object::COFFImportFile *File,
220 ScopedPrinter &Writer);
221
222void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
223 ArrayRef<ArrayRef<uint8_t>> IpiRecords,
224 ArrayRef<ArrayRef<uint8_t>> TpiRecords);
225
226} // namespace llvm
227
228#endif
229