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/Support/Casting.h"
21 #include "llvm/Support/CommandLine.h"
22 #include "llvm/Support/Compiler.h"
23 #include "llvm/Support/Error.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/ErrorOr.h"
26 #include "llvm/Support/FileOutputBuffer.h"
27 #include "llvm/Support/ManagedStatic.h"
28 #include "llvm/Support/PrettyStackTrace.h"
29 #include "llvm/Support/Signals.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include <algorithm>
32 #include <cassert>
33 #include <cstdlib>
34 #include <functional>
35 #include <iterator>
36 #include <memory>
37 #include <string>
38 #include <system_error>
39 #include <utility>
40 
41 using namespace llvm;
42 using namespace object;
43 using namespace ELF;
44 
45 // The name this program was invoked as.
46 static StringRef ToolName;
47 
48 namespace llvm {
49 
50 LLVM_ATTRIBUTE_NORETURN void error(Twine Message) {
51   errs() << ToolName << ": " << Message << ".\n";
52   errs().flush();
53   exit(1);
54 }
55 
56 LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, std::error_code EC) {
57   assert(EC);
58   errs() << ToolName << ": '" << File << "': " << EC.message() << ".\n";
59   exit(1);
60 }
61 
62 LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, Error E) {
63   assert(E);
64   std::string Buf;
65   raw_string_ostream OS(Buf);
66   logAllUnhandledErrors(std::move(E), OS, "");
67   OS.flush();
68   errs() << ToolName << ": '" << File << "': " << Buf;
69   exit(1);
70 }
71 
72 } // end namespace llvm
73 
74 static cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input>"));
75 static cl::opt<std::string> OutputFilename(cl::Positional, cl::desc("<output>"),
76                                            cl::init("-"));
77 static cl::opt<std::string>
78     OutputFormat("O", cl::desc("Set output format to one of the following:"
79                                "\n\tbinary"));
80 static cl::list<std::string> ToRemove("remove-section",
81                                       cl::desc("Remove <section>"),
82                                       cl::value_desc("section"));
83 static cl::alias ToRemoveA("R", cl::desc("Alias for remove-section"),
84                            cl::aliasopt(ToRemove));
85 static cl::opt<bool> StripAll(
86     "strip-all",
87     cl::desc(
88         "Removes non-allocated sections other than .gnu.warning* sections"));
89 static cl::opt<bool>
90     StripAllGNU("strip-all-gnu",
91                 cl::desc("Removes symbol, relocation, and debug information"));
92 static cl::list<std::string> Keep("keep", cl::desc("Keep <section>"),
93                                   cl::value_desc("section"));
94 static cl::list<std::string> OnlyKeep("only-keep",
95                                       cl::desc("Remove all but <section>"),
96                                       cl::value_desc("section"));
97 static cl::alias OnlyKeepA("j", cl::desc("Alias for only-keep"),
98                            cl::aliasopt(OnlyKeep));
99 static cl::opt<bool> StripDebug("strip-debug",
100                                 cl::desc("Removes all debug information"));
101 static cl::opt<bool> StripSections("strip-sections",
102                                    cl::desc("Remove all section headers"));
103 static cl::opt<bool>
104     StripNonAlloc("strip-non-alloc",
105                   cl::desc("Remove all non-allocated sections"));
106 static cl::opt<bool>
107     StripDWO("strip-dwo", cl::desc("Remove all DWARF .dwo sections from file"));
108 static cl::opt<bool> ExtractDWO(
109     "extract-dwo",
110     cl::desc("Remove all sections that are not DWARF .dwo sections from file"));
111 static cl::opt<std::string>
112     SplitDWO("split-dwo",
113              cl::desc("Equivalent to extract-dwo on the input file to "
114                       "<dwo-file>, then strip-dwo on the input file"),
115              cl::value_desc("dwo-file"));
116 
117 using SectionPred = std::function<bool(const SectionBase &Sec)>;
118 
119 bool IsDWOSection(const SectionBase &Sec) { return Sec.Name.endswith(".dwo"); }
120 
121 template <class ELFT>
122 bool OnlyKeepDWOPred(const Object<ELFT> &Obj, const SectionBase &Sec) {
123   // We can't remove the section header string table.
124   if (&Sec == Obj.getSectionHeaderStrTab())
125     return false;
126   // Short of keeping the string table we want to keep everything that is a DWO
127   // section and remove everything else.
128   return !IsDWOSection(Sec);
129 }
130 
131 template <class ELFT>
132 void WriteObjectFile(const Object<ELFT> &Obj, StringRef File) {
133   std::unique_ptr<FileOutputBuffer> Buffer;
134   Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
135       FileOutputBuffer::create(File, Obj.totalSize(),
136                                FileOutputBuffer::F_executable);
137   handleAllErrors(BufferOrErr.takeError(), [](const ErrorInfoBase &) {
138     error("failed to open " + OutputFilename);
139   });
140   Buffer = std::move(*BufferOrErr);
141 
142   Obj.write(*Buffer);
143   if (auto E = Buffer->commit())
144     reportError(File, errorToErrorCode(std::move(E)));
145 }
146 
147 template <class ELFT>
148 void SplitDWOToFile(const ELFObjectFile<ELFT> &ObjFile, StringRef File) {
149   // Construct a second output file for the DWO sections.
150   ELFObject<ELFT> DWOFile(ObjFile);
151 
152   DWOFile.removeSections([&](const SectionBase &Sec) {
153     return OnlyKeepDWOPred<ELFT>(DWOFile, Sec);
154   });
155   DWOFile.finalize();
156   WriteObjectFile(DWOFile, File);
157 }
158 
159 // This function handles the high level operations of GNU objcopy including
160 // handling command line options. It's important to outline certain properties
161 // we expect to hold of the command line operations. Any operation that "keeps"
162 // should keep regardless of a remove. Additionally any removal should respect
163 // any previous removals. Lastly whether or not something is removed shouldn't
164 // depend a) on the order the options occur in or b) on some opaque priority
165 // system. The only priority is that keeps/copies overrule removes.
166 template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
167   std::unique_ptr<Object<ELFT>> Obj;
168 
169   if (!OutputFormat.empty() && OutputFormat != "binary")
170     error("invalid output format '" + OutputFormat + "'");
171   if (!OutputFormat.empty() && OutputFormat == "binary")
172     Obj = llvm::make_unique<BinaryObject<ELFT>>(ObjFile);
173   else
174     Obj = llvm::make_unique<ELFObject<ELFT>>(ObjFile);
175 
176   if (!SplitDWO.empty())
177     SplitDWOToFile<ELFT>(ObjFile, SplitDWO.getValue());
178 
179   SectionPred RemovePred = [](const SectionBase &) { return false; };
180 
181   // Removes:
182 
183   if (!ToRemove.empty()) {
184     RemovePred = [&](const SectionBase &Sec) {
185       return std::find(std::begin(ToRemove), std::end(ToRemove), Sec.Name) !=
186              std::end(ToRemove);
187     };
188   }
189 
190   if (StripDWO || !SplitDWO.empty())
191     RemovePred = [RemovePred](const SectionBase &Sec) {
192       return IsDWOSection(Sec) || RemovePred(Sec);
193     };
194 
195   if (ExtractDWO)
196     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
197       return OnlyKeepDWOPred(*Obj, Sec) || RemovePred(Sec);
198     };
199 
200   if (StripAllGNU)
201     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
202       if (RemovePred(Sec))
203         return true;
204       if ((Sec.Flags & SHF_ALLOC) != 0)
205         return false;
206       if (&Sec == Obj->getSectionHeaderStrTab())
207         return false;
208       switch (Sec.Type) {
209       case SHT_SYMTAB:
210       case SHT_REL:
211       case SHT_RELA:
212       case SHT_STRTAB:
213         return true;
214       }
215       return Sec.Name.startswith(".debug");
216     };
217 
218   if (StripSections) {
219     RemovePred = [RemovePred](const SectionBase &Sec) {
220       return RemovePred(Sec) || (Sec.Flags & SHF_ALLOC) == 0;
221     };
222     Obj->WriteSectionHeaders = false;
223   }
224 
225   if (StripDebug) {
226     RemovePred = [RemovePred](const SectionBase &Sec) {
227       return RemovePred(Sec) || Sec.Name.startswith(".debug");
228     };
229   }
230 
231   if (StripNonAlloc)
232     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
233       if (RemovePred(Sec))
234         return true;
235       if (&Sec == Obj->getSectionHeaderStrTab())
236         return false;
237       return (Sec.Flags & SHF_ALLOC) == 0;
238     };
239 
240   if (StripAll)
241     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
242       if (RemovePred(Sec))
243         return true;
244       if (&Sec == Obj->getSectionHeaderStrTab())
245         return false;
246       if (Sec.Name.startswith(".gnu.warning"))
247         return false;
248       return (Sec.Flags & SHF_ALLOC) == 0;
249     };
250 
251   // Explicit copies:
252 
253   if (!OnlyKeep.empty()) {
254     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
255       // Explicitly keep these sections regardless of previous removes.
256       if (std::find(std::begin(OnlyKeep), std::end(OnlyKeep), Sec.Name) !=
257           std::end(OnlyKeep))
258         return false;
259 
260       // Allow all implicit removes.
261       if (RemovePred(Sec)) {
262         return true;
263       }
264 
265       // Keep special sections.
266       if (Obj->getSectionHeaderStrTab() == &Sec) {
267         return false;
268       }
269       if (Obj->getSymTab() == &Sec || Obj->getSymTab()->getStrTab() == &Sec) {
270         return false;
271       }
272       // Remove everything else.
273       return true;
274     };
275   }
276 
277   if (!Keep.empty()) {
278     RemovePred = [RemovePred](const SectionBase &Sec) {
279       // Explicitly keep these sections regardless of previous removes.
280       if (std::find(std::begin(Keep), std::end(Keep), Sec.Name) !=
281           std::end(Keep))
282         return false;
283       // Otherwise defer to RemovePred.
284       return RemovePred(Sec);
285     };
286   }
287 
288   Obj->removeSections(RemovePred);
289   Obj->finalize();
290   WriteObjectFile(*Obj, OutputFilename.getValue());
291 }
292 
293 int main(int argc, char **argv) {
294   // Print a stack trace if we signal out.
295   sys::PrintStackTraceOnErrorSignal(argv[0]);
296   PrettyStackTraceProgram X(argc, argv);
297   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
298   cl::ParseCommandLineOptions(argc, argv, "llvm objcopy utility\n");
299   ToolName = argv[0];
300   if (InputFilename.empty()) {
301     cl::PrintHelpMessage();
302     return 2;
303   }
304   Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(InputFilename);
305   if (!BinaryOrErr)
306     reportError(InputFilename, BinaryOrErr.takeError());
307   Binary &Binary = *BinaryOrErr.get().getBinary();
308   if (auto *o = dyn_cast<ELFObjectFile<ELF64LE>>(&Binary)) {
309     CopyBinary(*o);
310     return 0;
311   }
312   if (auto *o = dyn_cast<ELFObjectFile<ELF32LE>>(&Binary)) {
313     CopyBinary(*o);
314     return 0;
315   }
316   if (auto *o = dyn_cast<ELFObjectFile<ELF64BE>>(&Binary)) {
317     CopyBinary(*o);
318     return 0;
319   }
320   if (auto *o = dyn_cast<ELFObjectFile<ELF32BE>>(&Binary)) {
321     CopyBinary(*o);
322     return 0;
323   }
324   reportError(InputFilename, object_error::invalid_file_type);
325 }
326