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/ADT/StringSet.h"
19#include "llvm/Object/ObjectFile.h"
20#include "llvm/Object/OffloadBinary.h"
21#include "llvm/Support/CommandLine.h"
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::boolOrDefault::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 printCallGraphInfo() {}
133 // If PrettyPGOAnalysis is true, prints BFI as relative frequency and BPI as
134 // percentage. Otherwise raw values are displayed.
135 virtual void printBBAddrMaps(bool PrettyPGOAnalysis) {}
136 virtual void printAddrsig() {}
137 virtual void printNotes() {}
138 virtual void printELFLinkerOptions() {}
139 virtual void printStackSizes() {}
140 virtual void printSectionDetails() {}
141 virtual void printArchSpecificInfo() {}
142 virtual void printMemtag() {}
143 virtual void printSectionsAsSFrame(ArrayRef<std::string> Sections) {}
144
145 // Only implemented for PE/COFF.
146 virtual void printCOFFImports() { }
147 virtual void printCOFFExports() { }
148 virtual void printCOFFDirectives() { }
149 virtual void printCOFFBaseReloc() { }
150 virtual void printCOFFPseudoReloc() {}
151 virtual void printCOFFDebugDirectory() { }
152 virtual void printCOFFTLSDirectory() {}
153 virtual void printCOFFResources() {}
154 virtual void printCOFFLoadConfig() { }
155 virtual void printCodeViewDebugInfo() { }
156 virtual void
157 mergeCodeViewTypes(llvm::codeview::MergingTypeTableBuilder &CVIDs,
158 llvm::codeview::MergingTypeTableBuilder &CVTypes,
159 llvm::codeview::GlobalTypeTableBuilder &GlobalCVIDs,
160 llvm::codeview::GlobalTypeTableBuilder &GlobalCVTypes,
161 bool GHash) {}
162
163 // Only implemented for XCOFF/COFF.
164 virtual void printStringTable() {}
165
166 // Only implemented for XCOFF.
167 virtual void printAuxiliaryHeader() {}
168 virtual void printExceptionSection() {}
169 virtual void printLoaderSection(bool PrintHeader, bool PrintSymbols,
170 bool PrintRelocations) {}
171
172 // Only implemented for MachO.
173 virtual void printMachODataInCode() { }
174 virtual void printMachOVersionMin() { }
175 virtual void printMachODysymtab() { }
176 virtual void printMachOSegment() { }
177 virtual void printMachOIndirectSymbols() { }
178 virtual void printMachOLinkerOptions() { }
179
180 virtual void printStackMap() const = 0;
181
182 void printAsStringList(StringRef StringContent, size_t StringDataOffset = 0);
183
184 void printSectionsAsString(const object::ObjectFile &Obj,
185 ArrayRef<std::string> Sections, bool Decompress);
186 void printSectionsAsHex(const object::ObjectFile &Obj,
187 ArrayRef<std::string> Sections, bool Decompress);
188
189 std::function<Error(const Twine &Msg)> WarningHandler;
190 void reportUniqueWarning(Error Err) const;
191 void reportUniqueWarning(const Twine &Msg) const;
192 void printOffloading(const object::ObjectFile &Obj);
193
194protected:
195 ScopedPrinter &W;
196
197 static std::vector<object::SectionRef>
198 getSectionRefsByNameOrIndex(const object::ObjectFile &Obj,
199 ArrayRef<std::string> Sections);
200
201private:
202 virtual void printSymbols(bool ExtraSymInfo) {}
203 virtual void printSymbols(std::optional<SymbolComparator> Comp) {}
204 virtual void printDynamicSymbols() {}
205 virtual void printDynamicSymbols(std::optional<SymbolComparator> Comp) {}
206 virtual void printProgramHeaders() {}
207 virtual void printSectionMapping() {}
208
209 StringSet<> Warnings;
210};
211
212std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
213 ScopedPrinter &Writer);
214
215std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
216 ScopedPrinter &Writer);
217
218std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
219 ScopedPrinter &Writer);
220
221std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
222 ScopedPrinter &Writer);
223
224std::unique_ptr<ObjDumper> createXCOFFDumper(const object::XCOFFObjectFile &Obj,
225 ScopedPrinter &Writer);
226
227void dumpCOFFImportFile(const object::COFFImportFile *File,
228 ScopedPrinter &Writer);
229
230void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
231 ArrayRef<ArrayRef<uint8_t>> IpiRecords,
232 ArrayRef<ArrayRef<uint8_t>> TpiRecords);
233
234} // namespace llvm
235
236#endif
237