xref: /llvm-project/llvm/tools/llvm-objcopy/llvm-objcopy.cpp (revision ee5be798dae30d5f9414b01f76ff807edbc881aa) 
1 //===- llvm-objcopy.cpp ---------------------------------------------------===//
2 //
3 //                      The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm-objcopy.h"
11 #include "Object.h"
12 #include "llvm/ADT/STLExtras.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/ADT/Twine.h"
15 #include "llvm/BinaryFormat/ELF.h"
16 #include "llvm/Object/Binary.h"
17 #include "llvm/Object/ELFObjectFile.h"
18 #include "llvm/Object/ELFTypes.h"
19 #include "llvm/Object/Error.h"
20 #include "llvm/Option/Arg.h"
21 #include "llvm/Option/ArgList.h"
22 #include "llvm/Option/Option.h"
23 #include "llvm/Support/Casting.h"
24 #include "llvm/Support/CommandLine.h"
25 #include "llvm/Support/Compiler.h"
26 #include "llvm/Support/Error.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/ErrorOr.h"
29 #include "llvm/Support/FileOutputBuffer.h"
30 #include "llvm/Support/InitLLVM.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include <algorithm>
33 #include <cassert>
34 #include <cstdlib>
35 #include <functional>
36 #include <iterator>
37 #include <memory>
38 #include <string>
39 #include <system_error>
40 #include <utility>
41 
42 using namespace llvm;
43 using namespace object;
44 using namespace ELF;
45 
46 namespace {
47 
48 enum ID {
49   OBJCOPY_INVALID = 0, // This is not an option ID.
50 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
51                HELPTEXT, METAVAR, VALUES)                                      \
52   OBJCOPY_##ID,
53 #include "Opts.inc"
54 #undef OPTION
55 };
56 
57 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
58 #include "Opts.inc"
59 #undef PREFIX
60 
61 static const opt::OptTable::Info ObjcopyInfoTable[] = {
62 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
63                HELPTEXT, METAVAR, VALUES)                                      \
64   {PREFIX,          NAME,         HELPTEXT,                                    \
65    METAVAR,         OBJCOPY_##ID, opt::Option::KIND##Class,                    \
66    PARAM,           FLAGS,        OBJCOPY_##GROUP,                             \
67    OBJCOPY_##ALIAS, ALIASARGS,    VALUES},
68 #include "Opts.inc"
69 #undef OPTION
70 };
71 
72 class ObjcopyOptTable : public opt::OptTable {
73 public:
74   ObjcopyOptTable() : OptTable(ObjcopyInfoTable, true) {}
75 };
76 
77 } // namespace
78 
79 // The name this program was invoked as.
80 static StringRef ToolName;
81 
82 namespace llvm {
83 
84 LLVM_ATTRIBUTE_NORETURN void error(Twine Message) {
85   errs() << ToolName << ": " << Message << ".\n";
86   errs().flush();
87   exit(1);
88 }
89 
90 LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, std::error_code EC) {
91   assert(EC);
92   errs() << ToolName << ": '" << File << "': " << EC.message() << ".\n";
93   exit(1);
94 }
95 
96 LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, Error E) {
97   assert(E);
98   std::string Buf;
99   raw_string_ostream OS(Buf);
100   logAllUnhandledErrors(std::move(E), OS, "");
101   OS.flush();
102   errs() << ToolName << ": '" << File << "': " << Buf;
103   exit(1);
104 }
105 
106 } // end namespace llvm
107 
108 struct CopyConfig {
109   StringRef OutputFilename;
110   StringRef InputFilename;
111   StringRef OutputFormat;
112   StringRef InputFormat;
113   StringRef BinaryArch;
114 
115   StringRef SplitDWO;
116   StringRef AddGnuDebugLink;
117   std::vector<StringRef> ToRemove;
118   std::vector<StringRef> Keep;
119   std::vector<StringRef> OnlyKeep;
120   std::vector<StringRef> AddSection;
121   std::vector<StringRef> SymbolsToLocalize;
122   std::vector<StringRef> SymbolsToGlobalize;
123   StringMap<StringRef> SymbolsToRename;
124   bool StripAll;
125   bool StripAllGNU;
126   bool StripDebug;
127   bool StripSections;
128   bool StripNonAlloc;
129   bool StripDWO;
130   bool ExtractDWO;
131   bool LocalizeHidden;
132 };
133 
134 using SectionPred = std::function<bool(const SectionBase &Sec)>;
135 
136 bool IsDWOSection(const SectionBase &Sec) { return Sec.Name.endswith(".dwo"); }
137 
138 bool OnlyKeepDWOPred(const Object &Obj, const SectionBase &Sec) {
139   // We can't remove the section header string table.
140   if (&Sec == Obj.SectionNames)
141     return false;
142   // Short of keeping the string table we want to keep everything that is a DWO
143   // section and remove everything else.
144   return !IsDWOSection(Sec);
145 }
146 
147 std::unique_ptr<Writer> CreateWriter(const CopyConfig &Config, Object &Obj,
148                                      StringRef File, ElfType OutputElfType) {
149   if (Config.OutputFormat == "binary") {
150     return llvm::make_unique<BinaryWriter>(File, Obj);
151   }
152   // Depending on the initial ELFT and OutputFormat we need a different Writer.
153   switch (OutputElfType) {
154   case ELFT_ELF32LE:
155     return llvm::make_unique<ELFWriter<ELF32LE>>(File, Obj,
156                                                  !Config.StripSections);
157   case ELFT_ELF64LE:
158     return llvm::make_unique<ELFWriter<ELF64LE>>(File, Obj,
159                                                  !Config.StripSections);
160   case ELFT_ELF32BE:
161     return llvm::make_unique<ELFWriter<ELF32BE>>(File, Obj,
162                                                  !Config.StripSections);
163   case ELFT_ELF64BE:
164     return llvm::make_unique<ELFWriter<ELF64BE>>(File, Obj,
165                                                  !Config.StripSections);
166   }
167   llvm_unreachable("Invalid output format");
168 }
169 
170 void SplitDWOToFile(const CopyConfig &Config, const Reader &Reader,
171                     StringRef File, ElfType OutputElfType) {
172   auto DWOFile = Reader.create();
173   DWOFile->removeSections(
174       [&](const SectionBase &Sec) { return OnlyKeepDWOPred(*DWOFile, Sec); });
175   auto Writer = CreateWriter(Config, *DWOFile, File, OutputElfType);
176   Writer->finalize();
177   Writer->write();
178 }
179 
180 // This function handles the high level operations of GNU objcopy including
181 // handling command line options. It's important to outline certain properties
182 // we expect to hold of the command line operations. Any operation that "keeps"
183 // should keep regardless of a remove. Additionally any removal should respect
184 // any previous removals. Lastly whether or not something is removed shouldn't
185 // depend a) on the order the options occur in or b) on some opaque priority
186 // system. The only priority is that keeps/copies overrule removes.
187 void HandleArgs(const CopyConfig &Config, Object &Obj, const Reader &Reader,
188                 ElfType OutputElfType) {
189 
190   if (!Config.SplitDWO.empty()) {
191     SplitDWOToFile(Config, Reader, Config.SplitDWO, OutputElfType);
192   }
193 
194   SectionPred RemovePred = [](const SectionBase &) { return false; };
195 
196   // Removes:
197   if (!Config.ToRemove.empty()) {
198     RemovePred = [&Config](const SectionBase &Sec) {
199       return std::find(std::begin(Config.ToRemove), std::end(Config.ToRemove),
200                        Sec.Name) != std::end(Config.ToRemove);
201     };
202   }
203 
204   if (Config.StripDWO || !Config.SplitDWO.empty())
205     RemovePred = [RemovePred](const SectionBase &Sec) {
206       return IsDWOSection(Sec) || RemovePred(Sec);
207     };
208 
209   if (Config.ExtractDWO)
210     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
211       return OnlyKeepDWOPred(Obj, Sec) || RemovePred(Sec);
212     };
213 
214   if (Config.StripAllGNU)
215     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
216       if (RemovePred(Sec))
217         return true;
218       if ((Sec.Flags & SHF_ALLOC) != 0)
219         return false;
220       if (&Sec == Obj.SectionNames)
221         return false;
222       switch (Sec.Type) {
223       case SHT_SYMTAB:
224       case SHT_REL:
225       case SHT_RELA:
226       case SHT_STRTAB:
227         return true;
228       }
229       return Sec.Name.startswith(".debug");
230     };
231 
232   if (Config.StripSections) {
233     RemovePred = [RemovePred](const SectionBase &Sec) {
234       return RemovePred(Sec) || (Sec.Flags & SHF_ALLOC) == 0;
235     };
236   }
237 
238   if (Config.StripDebug) {
239     RemovePred = [RemovePred](const SectionBase &Sec) {
240       return RemovePred(Sec) || Sec.Name.startswith(".debug");
241     };
242   }
243 
244   if (Config.StripNonAlloc)
245     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
246       if (RemovePred(Sec))
247         return true;
248       if (&Sec == Obj.SectionNames)
249         return false;
250       return (Sec.Flags & SHF_ALLOC) == 0;
251     };
252 
253   if (Config.StripAll)
254     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
255       if (RemovePred(Sec))
256         return true;
257       if (&Sec == Obj.SectionNames)
258         return false;
259       if (Sec.Name.startswith(".gnu.warning"))
260         return false;
261       return (Sec.Flags & SHF_ALLOC) == 0;
262     };
263 
264   // Explicit copies:
265   if (!Config.OnlyKeep.empty()) {
266     RemovePred = [&Config, RemovePred, &Obj](const SectionBase &Sec) {
267       // Explicitly keep these sections regardless of previous removes.
268       if (std::find(std::begin(Config.OnlyKeep), std::end(Config.OnlyKeep),
269                     Sec.Name) != std::end(Config.OnlyKeep))
270         return false;
271 
272       // Allow all implicit removes.
273       if (RemovePred(Sec))
274         return true;
275 
276       // Keep special sections.
277       if (Obj.SectionNames == &Sec)
278         return false;
279       if (Obj.SymbolTable == &Sec || Obj.SymbolTable->getStrTab() == &Sec)
280         return false;
281 
282       // Remove everything else.
283       return true;
284     };
285   }
286 
287   if (!Config.Keep.empty()) {
288     RemovePred = [Config, RemovePred](const SectionBase &Sec) {
289       // Explicitly keep these sections regardless of previous removes.
290       if (std::find(std::begin(Config.Keep), std::end(Config.Keep), Sec.Name) !=
291           std::end(Config.Keep))
292         return false;
293       // Otherwise defer to RemovePred.
294       return RemovePred(Sec);
295     };
296   }
297 
298   Obj.removeSections(RemovePred);
299 
300   if (!Config.AddSection.empty()) {
301     for (const auto &Flag : Config.AddSection) {
302       auto SecPair = Flag.split("=");
303       auto SecName = SecPair.first;
304       auto File = SecPair.second;
305       auto BufOrErr = MemoryBuffer::getFile(File);
306       if (!BufOrErr)
307         reportError(File, BufOrErr.getError());
308       auto Buf = std::move(*BufOrErr);
309       auto BufPtr = reinterpret_cast<const uint8_t *>(Buf->getBufferStart());
310       auto BufSize = Buf->getBufferSize();
311       Obj.addSection<OwnedDataSection>(SecName,
312                                        ArrayRef<uint8_t>(BufPtr, BufSize));
313     }
314   }
315 
316   if (!Config.AddGnuDebugLink.empty())
317     Obj.addSection<GnuDebugLinkSection>(Config.AddGnuDebugLink);
318 
319   if (Obj.SymbolTable) {
320     Obj.SymbolTable->updateSymbols([&](Symbol &Sym) {
321       if ((Config.LocalizeHidden &&
322            (Sym.Visibility == STV_HIDDEN || Sym.Visibility == STV_INTERNAL)) ||
323           (!Config.SymbolsToLocalize.empty() &&
324            is_contained(Config.SymbolsToLocalize, Sym.Name)))
325         Sym.Binding = STB_LOCAL;
326 
327       if (!Config.SymbolsToGlobalize.empty() &&
328           is_contained(Config.SymbolsToGlobalize, Sym.Name))
329         Sym.Binding = STB_GLOBAL;
330 
331       const auto I = Config.SymbolsToRename.find(Sym.Name);
332       if (I != Config.SymbolsToRename.end())
333         Sym.Name = I->getValue();
334     });
335   }
336 }
337 
338 std::unique_ptr<Reader> CreateReader(StringRef InputFilename,
339                                      ElfType &OutputElfType) {
340   // Right now we can only read ELF files so there's only one reader;
341   auto Out = llvm::make_unique<ELFReader>(InputFilename);
342   // We need to set the default ElfType for output.
343   OutputElfType = Out->getElfType();
344   return std::move(Out);
345 }
346 
347 void ExecuteElfObjcopy(const CopyConfig &Config) {
348   ElfType OutputElfType;
349   auto Reader = CreateReader(Config.InputFilename, OutputElfType);
350   auto Obj = Reader->create();
351   auto Writer =
352       CreateWriter(Config, *Obj, Config.OutputFilename, OutputElfType);
353   HandleArgs(Config, *Obj, *Reader, OutputElfType);
354   Writer->finalize();
355   Writer->write();
356 }
357 
358 // ParseObjcopyOptions returns the config and sets the input arguments. If a
359 // help flag is set then ParseObjcopyOptions will print the help messege and
360 // exit.
361 CopyConfig ParseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
362   ObjcopyOptTable T;
363   unsigned MissingArgumentIndex, MissingArgumentCount;
364   llvm::opt::InputArgList InputArgs =
365       T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
366 
367   if (InputArgs.size() == 0 || InputArgs.hasArg(OBJCOPY_help)) {
368     T.PrintHelp(outs(), "llvm-objcopy <input> [ <output> ]", "objcopy tool");
369     exit(0);
370   }
371 
372   SmallVector<const char *, 2> Positional;
373 
374   for (auto Arg : InputArgs.filtered(OBJCOPY_UNKNOWN))
375     error("unknown argument '" + Arg->getAsString(InputArgs) + "'");
376 
377   for (auto Arg : InputArgs.filtered(OBJCOPY_INPUT))
378     Positional.push_back(Arg->getValue());
379 
380   if (Positional.empty())
381     error("No input file specified");
382 
383   if (Positional.size() > 2)
384     error("Too many positional arguments");
385 
386   CopyConfig Config;
387   Config.InputFilename = Positional[0];
388   Config.OutputFilename = Positional[Positional.size() == 1 ? 0 : 1];
389   Config.InputFormat = InputArgs.getLastArgValue(OBJCOPY_input_target);
390   Config.OutputFormat = InputArgs.getLastArgValue(OBJCOPY_output_target);
391   Config.BinaryArch = InputArgs.getLastArgValue(OBJCOPY_binary_architecture);
392 
393   Config.SplitDWO = InputArgs.getLastArgValue(OBJCOPY_split_dwo);
394   Config.AddGnuDebugLink = InputArgs.getLastArgValue(OBJCOPY_add_gnu_debuglink);
395 
396   for (auto Arg : InputArgs.filtered(OBJCOPY_redefine_symbol)) {
397     if (!StringRef(Arg->getValue()).contains('='))
398       error("Bad format for --redefine-sym");
399     auto Old2New = StringRef(Arg->getValue()).split('=');
400     if (!Config.SymbolsToRename.insert(Old2New).second)
401       error("Multiple redefinition of symbol " + Old2New.first);
402   }
403 
404   for (auto Arg : InputArgs.filtered(OBJCOPY_remove_section))
405     Config.ToRemove.push_back(Arg->getValue());
406   for (auto Arg : InputArgs.filtered(OBJCOPY_keep))
407     Config.Keep.push_back(Arg->getValue());
408   for (auto Arg : InputArgs.filtered(OBJCOPY_only_keep))
409     Config.OnlyKeep.push_back(Arg->getValue());
410   for (auto Arg : InputArgs.filtered(OBJCOPY_add_section))
411     Config.AddSection.push_back(Arg->getValue());
412   Config.StripAll = InputArgs.hasArg(OBJCOPY_strip_all);
413   Config.StripAllGNU = InputArgs.hasArg(OBJCOPY_strip_all_gnu);
414   Config.StripDebug = InputArgs.hasArg(OBJCOPY_strip_debug);
415   Config.StripDWO = InputArgs.hasArg(OBJCOPY_strip_dwo);
416   Config.StripSections = InputArgs.hasArg(OBJCOPY_strip_sections);
417   Config.StripNonAlloc = InputArgs.hasArg(OBJCOPY_strip_non_alloc);
418   Config.ExtractDWO = InputArgs.hasArg(OBJCOPY_extract_dwo);
419   Config.LocalizeHidden = InputArgs.hasArg(OBJCOPY_localize_hidden);
420   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbol))
421     Config.SymbolsToLocalize.push_back(Arg->getValue());
422   for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbol))
423     Config.SymbolsToGlobalize.push_back(Arg->getValue());
424 
425   return Config;
426 }
427 
428 int main(int argc, char **argv) {
429   InitLLVM X(argc, argv);
430   ToolName = argv[0];
431 
432   CopyConfig Config = ParseObjcopyOptions(makeArrayRef(argv + 1, argc));
433   ExecuteElfObjcopy(Config);
434 }
435