contrib/llvm/tools/llvm-objcopy/llvm-objcopy.cpp

   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 }