1 //===-- llvm-dwp.cpp - Split DWARF merging tool for llvm ------------------===//
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 // A utility for merging DWARF 5 Split DWARF .dwo files into .dwp (DWARF
10 // package files).
11 //
12 //===----------------------------------------------------------------------===//
13 #include "llvm/DWP/DWP.h"
14 #include "llvm/DWP/DWPError.h"
15 #include "llvm/DWP/DWPStringPool.h"
16 #include "llvm/MC/MCAsmBackend.h"
17 #include "llvm/MC/MCAsmInfo.h"
18 #include "llvm/MC/MCCodeEmitter.h"
19 #include "llvm/MC/MCContext.h"
20 #include "llvm/MC/MCInstrInfo.h"
21 #include "llvm/MC/MCObjectWriter.h"
22 #include "llvm/MC/MCRegisterInfo.h"
23 #include "llvm/MC/MCSubtargetInfo.h"
24 #include "llvm/MC/MCTargetOptionsCommandFlags.h"
25 #include "llvm/MC/TargetRegistry.h"
26 #include "llvm/Option/ArgList.h"
27 #include "llvm/Option/Option.h"
28 #include "llvm/Support/CommandLine.h"
29 #include "llvm/Support/FileSystem.h"
30 #include "llvm/Support/LLVMDriver.h"
31 #include "llvm/Support/MemoryBuffer.h"
32 #include "llvm/Support/TargetSelect.h"
33 #include "llvm/Support/ToolOutputFile.h"
34 #include <optional>
35
36 using namespace llvm;
37 using namespace llvm::object;
38
39 static mc::RegisterMCTargetOptionsFlags MCTargetOptionsFlags;
40
41 // Command-line option boilerplate.
42 namespace {
43 enum ID {
44 OPT_INVALID = 0, // This is not an option ID.
45 #define OPTION(...) LLVM_MAKE_OPT_ID(__VA_ARGS__),
46 #include "Opts.inc"
47 #undef OPTION
48 };
49
50 #define PREFIX(NAME, VALUE) \
51 static constexpr StringLiteral NAME##_init[] = VALUE; \
52 static constexpr ArrayRef<StringLiteral> NAME(NAME##_init, \
53 std::size(NAME##_init) - 1);
54 #include "Opts.inc"
55 #undef PREFIX
56
57 using namespace llvm::opt;
58 static constexpr opt::OptTable::Info InfoTable[] = {
59 #define OPTION(...) LLVM_CONSTRUCT_OPT_INFO(__VA_ARGS__),
60 #include "Opts.inc"
61 #undef OPTION
62 };
63
64 class DwpOptTable : public opt::GenericOptTable {
65 public:
DwpOptTable()66 DwpOptTable() : GenericOptTable(InfoTable) {}
67 };
68 } // end anonymous namespace
69
70 // Options
71 static std::vector<std::string> ExecFilenames;
72 static std::string OutputFilename;
73 static std::string ContinueOption;
74
75 static Expected<SmallVector<std::string, 16>>
getDWOFilenames(StringRef ExecFilename)76 getDWOFilenames(StringRef ExecFilename) {
77 auto ErrOrObj = object::ObjectFile::createObjectFile(ExecFilename);
78 if (!ErrOrObj)
79 return ErrOrObj.takeError();
80
81 const ObjectFile &Obj = *ErrOrObj.get().getBinary();
82 std::unique_ptr<DWARFContext> DWARFCtx = DWARFContext::create(Obj);
83
84 SmallVector<std::string, 16> DWOPaths;
85 for (const auto &CU : DWARFCtx->compile_units()) {
86 const DWARFDie &Die = CU->getUnitDIE();
87 std::string DWOName = dwarf::toString(
88 Die.find({dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}), "");
89 if (DWOName.empty())
90 continue;
91 std::string DWOCompDir =
92 dwarf::toString(Die.find(dwarf::DW_AT_comp_dir), "");
93 if (!DWOCompDir.empty()) {
94 SmallString<16> DWOPath(DWOName);
95 sys::fs::make_absolute(DWOCompDir, DWOPath);
96 if (!sys::fs::exists(DWOPath) && sys::fs::exists(DWOName))
97 DWOPaths.push_back(std::move(DWOName));
98 else
99 DWOPaths.emplace_back(DWOPath.data(), DWOPath.size());
100 } else {
101 DWOPaths.push_back(std::move(DWOName));
102 }
103 }
104 return std::move(DWOPaths);
105 }
106
error(const Twine & Error,const Twine & Context)107 static int error(const Twine &Error, const Twine &Context) {
108 errs() << Twine("while processing ") + Context + ":\n";
109 errs() << Twine("error: ") + Error + "\n";
110 return 1;
111 }
112
readTargetTriple(StringRef FileName)113 static Expected<Triple> readTargetTriple(StringRef FileName) {
114 auto ErrOrObj = object::ObjectFile::createObjectFile(FileName);
115 if (!ErrOrObj)
116 return ErrOrObj.takeError();
117
118 return ErrOrObj->getBinary()->makeTriple();
119 }
120
llvm_dwp_main(int argc,char ** argv,const llvm::ToolContext &)121 int llvm_dwp_main(int argc, char **argv, const llvm::ToolContext &) {
122 DwpOptTable Tbl;
123 llvm::BumpPtrAllocator A;
124 llvm::StringSaver Saver{A};
125 OnCuIndexOverflow OverflowOptValue = OnCuIndexOverflow::HardStop;
126 opt::InputArgList Args =
127 Tbl.parseArgs(argc, argv, OPT_UNKNOWN, Saver, [&](StringRef Msg) {
128 llvm::errs() << Msg << '\n';
129 std::exit(1);
130 });
131
132 if (Args.hasArg(OPT_help)) {
133 Tbl.printHelp(llvm::outs(), "llvm-dwp [options] <input files>",
134 "merge split dwarf (.dwo) files");
135 std::exit(0);
136 }
137
138 if (Args.hasArg(OPT_version)) {
139 llvm::cl::PrintVersionMessage();
140 std::exit(0);
141 }
142
143 OutputFilename = Args.getLastArgValue(OPT_outputFileName, "");
144 if (Arg *Arg = Args.getLastArg(OPT_continueOnCuIndexOverflow,
145 OPT_continueOnCuIndexOverflow_EQ)) {
146 if (Arg->getOption().matches(OPT_continueOnCuIndexOverflow)) {
147 OverflowOptValue = OnCuIndexOverflow::Continue;
148 } else {
149 ContinueOption = Arg->getValue();
150 if (ContinueOption == "soft-stop") {
151 OverflowOptValue = OnCuIndexOverflow::SoftStop;
152 } else if (ContinueOption == "continue") {
153 OverflowOptValue = OnCuIndexOverflow::Continue;
154 } else {
155 llvm::errs() << "invalid value for --continue-on-cu-index-overflow"
156 << ContinueOption << '\n';
157 exit(1);
158 }
159 }
160 }
161
162 for (const llvm::opt::Arg *A : Args.filtered(OPT_execFileNames))
163 ExecFilenames.emplace_back(A->getValue());
164
165 std::vector<std::string> DWOFilenames;
166 for (const llvm::opt::Arg *A : Args.filtered(OPT_INPUT))
167 DWOFilenames.emplace_back(A->getValue());
168
169 llvm::InitializeAllTargetInfos();
170 llvm::InitializeAllTargetMCs();
171 llvm::InitializeAllTargets();
172 llvm::InitializeAllAsmPrinters();
173
174 for (const auto &ExecFilename : ExecFilenames) {
175 auto DWOs = getDWOFilenames(ExecFilename);
176 if (!DWOs) {
177 logAllUnhandledErrors(
178 handleErrors(DWOs.takeError(),
179 [&](std::unique_ptr<ECError> EC) -> Error {
180 return createFileError(ExecFilename,
181 Error(std::move(EC)));
182 }),
183 WithColor::error());
184 return 1;
185 }
186 DWOFilenames.insert(DWOFilenames.end(),
187 std::make_move_iterator(DWOs->begin()),
188 std::make_move_iterator(DWOs->end()));
189 }
190
191 if (DWOFilenames.empty()) {
192 WithColor::defaultWarningHandler(make_error<DWPError>(
193 "executable file does not contain any references to dwo files"));
194 return 0;
195 }
196
197 std::string ErrorStr;
198 StringRef Context = "dwarf streamer init";
199
200 auto ErrOrTriple = readTargetTriple(DWOFilenames.front());
201 if (!ErrOrTriple) {
202 logAllUnhandledErrors(
203 handleErrors(ErrOrTriple.takeError(),
204 [&](std::unique_ptr<ECError> EC) -> Error {
205 return createFileError(DWOFilenames.front(),
206 Error(std::move(EC)));
207 }),
208 WithColor::error());
209 return 1;
210 }
211
212 // Get the target.
213 const Target *TheTarget =
214 TargetRegistry::lookupTarget("", *ErrOrTriple, ErrorStr);
215 if (!TheTarget)
216 return error(ErrorStr, Context);
217 std::string TripleName = ErrOrTriple->getTriple();
218
219 // Create all the MC Objects.
220 std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
221 if (!MRI)
222 return error(Twine("no register info for target ") + TripleName, Context);
223
224 MCTargetOptions MCOptions = llvm::mc::InitMCTargetOptionsFromFlags();
225 std::unique_ptr<MCAsmInfo> MAI(
226 TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
227 if (!MAI)
228 return error("no asm info for target " + TripleName, Context);
229
230 std::unique_ptr<MCSubtargetInfo> MSTI(
231 TheTarget->createMCSubtargetInfo(TripleName, "", ""));
232 if (!MSTI)
233 return error("no subtarget info for target " + TripleName, Context);
234
235 MCContext MC(*ErrOrTriple, MAI.get(), MRI.get(), MSTI.get());
236 std::unique_ptr<MCObjectFileInfo> MOFI(
237 TheTarget->createMCObjectFileInfo(MC, /*PIC=*/false));
238 MC.setObjectFileInfo(MOFI.get());
239
240 MCTargetOptions Options;
241 auto MAB = TheTarget->createMCAsmBackend(*MSTI, *MRI, Options);
242 if (!MAB)
243 return error("no asm backend for target " + TripleName, Context);
244
245 std::unique_ptr<MCInstrInfo> MII(TheTarget->createMCInstrInfo());
246 if (!MII)
247 return error("no instr info info for target " + TripleName, Context);
248
249 MCCodeEmitter *MCE = TheTarget->createMCCodeEmitter(*MII, MC);
250 if (!MCE)
251 return error("no code emitter for target " + TripleName, Context);
252
253 // Create the output file.
254 std::error_code EC;
255 ToolOutputFile OutFile(OutputFilename, EC, sys::fs::OF_None);
256 std::optional<buffer_ostream> BOS;
257 raw_pwrite_stream *OS;
258 if (EC)
259 return error(Twine(OutputFilename) + ": " + EC.message(), Context);
260 if (OutFile.os().supportsSeeking()) {
261 OS = &OutFile.os();
262 } else {
263 BOS.emplace(OutFile.os());
264 OS = &*BOS;
265 }
266
267 std::unique_ptr<MCStreamer> MS(TheTarget->createMCObjectStreamer(
268 *ErrOrTriple, MC, std::unique_ptr<MCAsmBackend>(MAB),
269 MAB->createObjectWriter(*OS), std::unique_ptr<MCCodeEmitter>(MCE),
270 *MSTI));
271 if (!MS)
272 return error("no object streamer for target " + TripleName, Context);
273
274 if (auto Err = write(*MS, DWOFilenames, OverflowOptValue)) {
275 logAllUnhandledErrors(std::move(Err), WithColor::error());
276 return 1;
277 }
278
279 MS->finish();
280 OutFile.keep();
281 return 0;
282 }
283