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 static cl::list<std::string> AddSection(
117     "add-section",
118     cl::desc("Make a section named <section> with the contents of <file>."),
119     cl::value_desc("section=file"));
120 
121 using SectionPred = std::function<bool(const SectionBase &Sec)>;
122 
123 bool IsDWOSection(const SectionBase &Sec) { return Sec.Name.endswith(".dwo"); }
124 
125 template <class ELFT>
126 bool OnlyKeepDWOPred(const Object<ELFT> &Obj, const SectionBase &Sec) {
127   // We can't remove the section header string table.
128   if (&Sec == Obj.getSectionHeaderStrTab())
129     return false;
130   // Short of keeping the string table we want to keep everything that is a DWO
131   // section and remove everything else.
132   return !IsDWOSection(Sec);
133 }
134 
135 template <class ELFT>
136 void WriteObjectFile(const Object<ELFT> &Obj, StringRef File) {
137   std::unique_ptr<FileOutputBuffer> Buffer;
138   Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
139       FileOutputBuffer::create(File, Obj.totalSize(),
140                                FileOutputBuffer::F_executable);
141   handleAllErrors(BufferOrErr.takeError(), [](const ErrorInfoBase &) {
142     error("failed to open " + OutputFilename);
143   });
144   Buffer = std::move(*BufferOrErr);
145 
146   Obj.write(*Buffer);
147   if (auto E = Buffer->commit())
148     reportError(File, errorToErrorCode(std::move(E)));
149 }
150 
151 template <class ELFT>
152 void SplitDWOToFile(const ELFObjectFile<ELFT> &ObjFile, StringRef File) {
153   // Construct a second output file for the DWO sections.
154   ELFObject<ELFT> DWOFile(ObjFile);
155 
156   DWOFile.removeSections([&](const SectionBase &Sec) {
157     return OnlyKeepDWOPred<ELFT>(DWOFile, Sec);
158   });
159   DWOFile.finalize();
160   WriteObjectFile(DWOFile, File);
161 }
162 
163 // This function handles the high level operations of GNU objcopy including
164 // handling command line options. It's important to outline certain properties
165 // we expect to hold of the command line operations. Any operation that "keeps"
166 // should keep regardless of a remove. Additionally any removal should respect
167 // any previous removals. Lastly whether or not something is removed shouldn't
168 // depend a) on the order the options occur in or b) on some opaque priority
169 // system. The only priority is that keeps/copies overrule removes.
170 template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
171   std::unique_ptr<Object<ELFT>> Obj;
172 
173   if (!OutputFormat.empty() && OutputFormat != "binary")
174     error("invalid output format '" + OutputFormat + "'");
175   if (!OutputFormat.empty() && OutputFormat == "binary")
176     Obj = llvm::make_unique<BinaryObject<ELFT>>(ObjFile);
177   else
178     Obj = llvm::make_unique<ELFObject<ELFT>>(ObjFile);
179 
180   if (!SplitDWO.empty())
181     SplitDWOToFile<ELFT>(ObjFile, SplitDWO.getValue());
182 
183   SectionPred RemovePred = [](const SectionBase &) { return false; };
184 
185   // Removes:
186 
187   if (!ToRemove.empty()) {
188     RemovePred = [&](const SectionBase &Sec) {
189       return std::find(std::begin(ToRemove), std::end(ToRemove), Sec.Name) !=
190              std::end(ToRemove);
191     };
192   }
193 
194   if (StripDWO || !SplitDWO.empty())
195     RemovePred = [RemovePred](const SectionBase &Sec) {
196       return IsDWOSection(Sec) || RemovePred(Sec);
197     };
198 
199   if (ExtractDWO)
200     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
201       return OnlyKeepDWOPred(*Obj, Sec) || RemovePred(Sec);
202     };
203 
204   if (StripAllGNU)
205     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
206       if (RemovePred(Sec))
207         return true;
208       if ((Sec.Flags & SHF_ALLOC) != 0)
209         return false;
210       if (&Sec == Obj->getSectionHeaderStrTab())
211         return false;
212       switch (Sec.Type) {
213       case SHT_SYMTAB:
214       case SHT_REL:
215       case SHT_RELA:
216       case SHT_STRTAB:
217         return true;
218       }
219       return Sec.Name.startswith(".debug");
220     };
221 
222   if (StripSections) {
223     RemovePred = [RemovePred](const SectionBase &Sec) {
224       return RemovePred(Sec) || (Sec.Flags & SHF_ALLOC) == 0;
225     };
226     Obj->WriteSectionHeaders = false;
227   }
228 
229   if (StripDebug) {
230     RemovePred = [RemovePred](const SectionBase &Sec) {
231       return RemovePred(Sec) || Sec.Name.startswith(".debug");
232     };
233   }
234 
235   if (StripNonAlloc)
236     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
237       if (RemovePred(Sec))
238         return true;
239       if (&Sec == Obj->getSectionHeaderStrTab())
240         return false;
241       return (Sec.Flags & SHF_ALLOC) == 0;
242     };
243 
244   if (StripAll)
245     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
246       if (RemovePred(Sec))
247         return true;
248       if (&Sec == Obj->getSectionHeaderStrTab())
249         return false;
250       if (Sec.Name.startswith(".gnu.warning"))
251         return false;
252       return (Sec.Flags & SHF_ALLOC) == 0;
253     };
254 
255   // Explicit copies:
256 
257   if (!OnlyKeep.empty()) {
258     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
259       // Explicitly keep these sections regardless of previous removes.
260       if (std::find(std::begin(OnlyKeep), std::end(OnlyKeep), Sec.Name) !=
261           std::end(OnlyKeep))
262         return false;
263 
264       // Allow all implicit removes.
265       if (RemovePred(Sec)) {
266         return true;
267       }
268 
269       // Keep special sections.
270       if (Obj->getSectionHeaderStrTab() == &Sec) {
271         return false;
272       }
273       if (Obj->getSymTab() == &Sec || Obj->getSymTab()->getStrTab() == &Sec) {
274         return false;
275       }
276       // Remove everything else.
277       return true;
278     };
279   }
280 
281   if (!Keep.empty()) {
282     RemovePred = [RemovePred](const SectionBase &Sec) {
283       // Explicitly keep these sections regardless of previous removes.
284       if (std::find(std::begin(Keep), std::end(Keep), Sec.Name) !=
285           std::end(Keep))
286         return false;
287       // Otherwise defer to RemovePred.
288       return RemovePred(Sec);
289     };
290   }
291 
292   Obj->removeSections(RemovePred);
293 
294   if (!AddSection.empty()) {
295     for (const auto &Flag : AddSection) {
296       auto SecPair = StringRef(Flag).split("=");
297       auto SecName = SecPair.first;
298       auto File = SecPair.second;
299       auto BufOrErr = MemoryBuffer::getFile(File);
300       if (!BufOrErr)
301         reportError(File, BufOrErr.getError());
302       auto Buf = std::move(*BufOrErr);
303       auto BufPtr = reinterpret_cast<const uint8_t *>(Buf->getBufferStart());
304       auto BufSize = Buf->getBufferSize();
305       Obj->addSection(SecName, ArrayRef<uint8_t>(BufPtr, BufSize));
306     }
307   }
308 
309   Obj->finalize();
310   WriteObjectFile(*Obj, OutputFilename.getValue());
311 }
312 
313 int main(int argc, char **argv) {
314   // Print a stack trace if we signal out.
315   sys::PrintStackTraceOnErrorSignal(argv[0]);
316   PrettyStackTraceProgram X(argc, argv);
317   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
318   cl::ParseCommandLineOptions(argc, argv, "llvm objcopy utility\n");
319   ToolName = argv[0];
320   if (InputFilename.empty()) {
321     cl::PrintHelpMessage();
322     return 2;
323   }
324   Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(InputFilename);
325   if (!BinaryOrErr)
326     reportError(InputFilename, BinaryOrErr.takeError());
327   Binary &Binary = *BinaryOrErr.get().getBinary();
328   if (auto *o = dyn_cast<ELFObjectFile<ELF64LE>>(&Binary)) {
329     CopyBinary(*o);
330     return 0;
331   }
332   if (auto *o = dyn_cast<ELFObjectFile<ELF32LE>>(&Binary)) {
333     CopyBinary(*o);
334     return 0;
335   }
336   if (auto *o = dyn_cast<ELFObjectFile<ELF64BE>>(&Binary)) {
337     CopyBinary(*o);
338     return 0;
339   }
340   if (auto *o = dyn_cast<ELFObjectFile<ELF32BE>>(&Binary)) {
341     CopyBinary(*o);
342     return 0;
343   }
344   reportError(InputFilename, object_error::invalid_file_type);
345 }
346