tools/llvm-objcopy/CopyConfig.cpp

   1 //===- CopyConfig.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 "CopyConfig.h"
  11 #include "llvm-objcopy.h"
  12
  13 #include "llvm/ADT/BitmaskEnum.h"
  14 #include "llvm/ADT/Optional.h"
  15 #include "llvm/ADT/SmallVector.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/Object/ELFTypes.h"
  18 #include "llvm/Option/Arg.h"
  19 #include "llvm/Option/ArgList.h"
  20 #include "llvm/Support/CommandLine.h"
  21 #include "llvm/Support/Compression.h"
  22 #include "llvm/Support/MemoryBuffer.h"
  23 #include <memory>
  24 #include <string>
  25
  26 namespace llvm {
  27 namespace objcopy {
  28
  29 namespace {
  30 enum ObjcopyID {
  31   OBJCOPY_INVALID = 0, // This is not an option ID.
  32 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
  33                HELPTEXT, METAVAR, VALUES)                                      \
  34   OBJCOPY_##ID,
  35 #include "ObjcopyOpts.inc"
  36 #undef OPTION
  37 };
  38
  39 #define PREFIX(NAME, VALUE) const char *const OBJCOPY_##NAME[] = VALUE;
  40 #include "ObjcopyOpts.inc"
  41 #undef PREFIX
  42
  43 static const opt::OptTable::Info ObjcopyInfoTable[] = {
  44 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
  45                HELPTEXT, METAVAR, VALUES)                                      \
  46   {OBJCOPY_##PREFIX,                                                           \
  47    NAME,                                                                       \
  48    HELPTEXT,                                                                   \
  49    METAVAR,                                                                    \
  50    OBJCOPY_##ID,                                                               \
  51    opt::Option::KIND##Class,                                                   \
  52    PARAM,                                                                      \
  53    FLAGS,                                                                      \
  54    OBJCOPY_##GROUP,                                                            \
  55    OBJCOPY_##ALIAS,                                                            \
  56    ALIASARGS,                                                                  \
  57    VALUES},
  58 #include "ObjcopyOpts.inc"
  59 #undef OPTION
  60 };
  61
  62 class ObjcopyOptTable : public opt::OptTable {
  63 public:
  64   ObjcopyOptTable() : OptTable(ObjcopyInfoTable) {}
  65 };
  66
  67 enum StripID {
  68   STRIP_INVALID = 0, // This is not an option ID.
  69 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
  70                HELPTEXT, METAVAR, VALUES)                                      \
  71   STRIP_##ID,
  72 #include "StripOpts.inc"
  73 #undef OPTION
  74 };
  75
  76 #define PREFIX(NAME, VALUE) const char *const STRIP_##NAME[] = VALUE;
  77 #include "StripOpts.inc"
  78 #undef PREFIX
  79
  80 static const opt::OptTable::Info StripInfoTable[] = {
  81 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
  82                HELPTEXT, METAVAR, VALUES)                                      \
  83   {STRIP_##PREFIX, NAME,       HELPTEXT,                                       \
  84    METAVAR,        STRIP_##ID, opt::Option::KIND##Class,                       \
  85    PARAM,          FLAGS,      STRIP_##GROUP,                                  \
  86    STRIP_##ALIAS,  ALIASARGS,  VALUES},
  87 #include "StripOpts.inc"
  88 #undef OPTION
  89 };
  90
  91 class StripOptTable : public opt::OptTable {
  92 public:
  93   StripOptTable() : OptTable(StripInfoTable) {}
  94 };
  95
  96 enum SectionFlag {
  97   SecNone = 0,
  98   SecAlloc = 1 << 0,
  99   SecLoad = 1 << 1,
 100   SecNoload = 1 << 2,
 101   SecReadonly = 1 << 3,
 102   SecDebug = 1 << 4,
 103   SecCode = 1 << 5,
 104   SecData = 1 << 6,
 105   SecRom = 1 << 7,
 106   SecMerge = 1 << 8,
 107   SecStrings = 1 << 9,
 108   SecContents = 1 << 10,
 109   SecShare = 1 << 11,
 110   LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ SecShare)
 111 };
 112
 113 } // namespace
 114
 115 static SectionFlag parseSectionRenameFlag(StringRef SectionName) {
 116   return llvm::StringSwitch<SectionFlag>(SectionName)
 117       .Case("alloc", SectionFlag::SecAlloc)
 118       .Case("load", SectionFlag::SecLoad)
 119       .Case("noload", SectionFlag::SecNoload)
 120       .Case("readonly", SectionFlag::SecReadonly)
 121       .Case("debug", SectionFlag::SecDebug)
 122       .Case("code", SectionFlag::SecCode)
 123       .Case("data", SectionFlag::SecData)
 124       .Case("rom", SectionFlag::SecRom)
 125       .Case("merge", SectionFlag::SecMerge)
 126       .Case("strings", SectionFlag::SecStrings)
 127       .Case("contents", SectionFlag::SecContents)
 128       .Case("share", SectionFlag::SecShare)
 129       .Default(SectionFlag::SecNone);
 130 }
 131
 132 static SectionRename parseRenameSectionValue(StringRef FlagValue) {
 133   if (!FlagValue.contains('='))
 134     error("Bad format for --rename-section: missing '='");
 135
 136   // Initial split: ".foo" = ".bar,f1,f2,..."
 137   auto Old2New = FlagValue.split('=');
 138   SectionRename SR;
 139   SR.OriginalName = Old2New.first;
 140
 141   // Flags split: ".bar" "f1" "f2" ...
 142   SmallVector<StringRef, 6> NameAndFlags;
 143   Old2New.second.split(NameAndFlags, ',');
 144   SR.NewName = NameAndFlags[0];
 145
 146   if (NameAndFlags.size() > 1) {
 147     SectionFlag Flags = SectionFlag::SecNone;
 148     for (size_t I = 1, Size = NameAndFlags.size(); I < Size; ++I) {
 149       SectionFlag Flag = parseSectionRenameFlag(NameAndFlags[I]);
 150       if (Flag == SectionFlag::SecNone)
 151         error("Unrecognized section flag '" + NameAndFlags[I] +
 152               "'. Flags supported for GNU compatibility: alloc, load, noload, "
 153               "readonly, debug, code, data, rom, share, contents, merge, "
 154               "strings.");
 155       Flags |= Flag;
 156     }
 157
 158     SR.NewFlags = 0;
 159     if (Flags & SectionFlag::SecAlloc)
 160       *SR.NewFlags |= ELF::SHF_ALLOC;
 161     if (!(Flags & SectionFlag::SecReadonly))
 162       *SR.NewFlags |= ELF::SHF_WRITE;
 163     if (Flags & SectionFlag::SecCode)
 164       *SR.NewFlags |= ELF::SHF_EXECINSTR;
 165     if (Flags & SectionFlag::SecMerge)
 166       *SR.NewFlags |= ELF::SHF_MERGE;
 167     if (Flags & SectionFlag::SecStrings)
 168       *SR.NewFlags |= ELF::SHF_STRINGS;
 169   }
 170
 171   return SR;
 172 }
 173
 174 static const StringMap<MachineInfo> ArchMap{
 175     // Name, {EMachine, 64bit, LittleEndian}
 176     {"aarch64", {ELF::EM_AARCH64, true, true}},
 177     {"arm", {ELF::EM_ARM, false, true}},
 178     {"i386", {ELF::EM_386, false, true}},
 179     {"i386:x86-64", {ELF::EM_X86_64, true, true}},
 180     {"powerpc:common64", {ELF::EM_PPC64, true, true}},
 181     {"sparc", {ELF::EM_SPARC, false, true}},
 182     {"x86-64", {ELF::EM_X86_64, true, true}},
 183 };
 184
 185 static const MachineInfo &getMachineInfo(StringRef Arch) {
 186   auto Iter = ArchMap.find(Arch);
 187   if (Iter == std::end(ArchMap))
 188     error("Invalid architecture: '" + Arch + "'");
 189   return Iter->getValue();
 190 }
 191
 192 static void addGlobalSymbolsFromFile(std::vector<std::string> &Symbols,
 193                                      StringRef Filename) {
 194   SmallVector<StringRef, 16> Lines;
 195   auto BufOrErr = MemoryBuffer::getFile(Filename);
 196   if (!BufOrErr)
 197     reportError(Filename, BufOrErr.getError());
 198
 199   BufOrErr.get()->getBuffer().split(Lines, '\n');
 200   for (StringRef Line : Lines) {
 201     // Ignore everything after '#', trim whitespace, and only add the symbol if
 202     // it's not empty.
 203     auto TrimmedLine = Line.split('#').first.trim();
 204     if (!TrimmedLine.empty())
 205       Symbols.push_back(TrimmedLine.str());
 206   }
 207 }
 208
 209 // ParseObjcopyOptions returns the config and sets the input arguments. If a
 210 // help flag is set then ParseObjcopyOptions will print the help messege and
 211 // exit.
 212 DriverConfig parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
 213   ObjcopyOptTable T;
 214   unsigned MissingArgumentIndex, MissingArgumentCount;
 215   llvm::opt::InputArgList InputArgs =
 216       T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
 217
 218   if (InputArgs.size() == 0) {
 219     T.PrintHelp(errs(), "llvm-objcopy input [output]", "objcopy tool");
 220     exit(1);
 221   }
 222
 223   if (InputArgs.hasArg(OBJCOPY_help)) {
 224     T.PrintHelp(outs(), "llvm-objcopy input [output]", "objcopy tool");
 225     exit(0);
 226   }
 227
 228   if (InputArgs.hasArg(OBJCOPY_version)) {
 229     outs() << "llvm-objcopy, compatible with GNU objcopy\n";
 230     cl::PrintVersionMessage();
 231     exit(0);
 232   }
 233
 234   SmallVector<const char *, 2> Positional;
 235
 236   for (auto Arg : InputArgs.filtered(OBJCOPY_UNKNOWN))
 237     error("unknown argument '" + Arg->getAsString(InputArgs) + "'");
 238
 239   for (auto Arg : InputArgs.filtered(OBJCOPY_INPUT))
 240     Positional.push_back(Arg->getValue());
 241
 242   if (Positional.empty())
 243     error("No input file specified");
 244
 245   if (Positional.size() > 2)
 246     error("Too many positional arguments");
 247
 248   CopyConfig Config;
 249   Config.InputFilename = Positional[0];
 250   Config.OutputFilename = Positional[Positional.size() == 1 ? 0 : 1];
 251   if (InputArgs.hasArg(OBJCOPY_target) &&
 252       (InputArgs.hasArg(OBJCOPY_input_target) ||
 253        InputArgs.hasArg(OBJCOPY_output_target)))
 254     error("--target cannot be used with --input-target or --output-target");
 255
 256   if (InputArgs.hasArg(OBJCOPY_target)) {
 257     Config.InputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
 258     Config.OutputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
 259   } else {
 260     Config.InputFormat = InputArgs.getLastArgValue(OBJCOPY_input_target);
 261     Config.OutputFormat = InputArgs.getLastArgValue(OBJCOPY_output_target);
 262   }
 263   if (Config.InputFormat == "binary") {
 264     auto BinaryArch = InputArgs.getLastArgValue(OBJCOPY_binary_architecture);
 265     if (BinaryArch.empty())
 266       error("Specified binary input without specifiying an architecture");
 267     Config.BinaryArch = getMachineInfo(BinaryArch);
 268   }
 269
 270   if (auto Arg = InputArgs.getLastArg(OBJCOPY_compress_debug_sections,
 271                                       OBJCOPY_compress_debug_sections_eq)) {
 272     Config.CompressionType = DebugCompressionType::Z;
 273
 274     if (Arg->getOption().getID() == OBJCOPY_compress_debug_sections_eq) {
 275       Config.CompressionType =
 276           StringSwitch<DebugCompressionType>(
 277               InputArgs.getLastArgValue(OBJCOPY_compress_debug_sections_eq))
 278               .Case("zlib-gnu", DebugCompressionType::GNU)
 279               .Case("zlib", DebugCompressionType::Z)
 280               .Default(DebugCompressionType::None);
 281       if (Config.CompressionType == DebugCompressionType::None)
 282         error("Invalid or unsupported --compress-debug-sections format: " +
 283               InputArgs.getLastArgValue(OBJCOPY_compress_debug_sections_eq));
 284       if (!zlib::isAvailable())
 285         error("LLVM was not compiled with LLVM_ENABLE_ZLIB: can not compress.");
 286     }
 287   }
 288
 289   Config.SplitDWO = InputArgs.getLastArgValue(OBJCOPY_split_dwo);
 290   Config.AddGnuDebugLink = InputArgs.getLastArgValue(OBJCOPY_add_gnu_debuglink);
 291   Config.SymbolsPrefix = InputArgs.getLastArgValue(OBJCOPY_prefix_symbols);
 292
 293   for (auto Arg : InputArgs.filtered(OBJCOPY_redefine_symbol)) {
 294     if (!StringRef(Arg->getValue()).contains('='))
 295       error("Bad format for --redefine-sym");
 296     auto Old2New = StringRef(Arg->getValue()).split('=');
 297     if (!Config.SymbolsToRename.insert(Old2New).second)
 298       error("Multiple redefinition of symbol " + Old2New.first);
 299   }
 300
 301   for (auto Arg : InputArgs.filtered(OBJCOPY_rename_section)) {
 302     SectionRename SR = parseRenameSectionValue(StringRef(Arg->getValue()));
 303     if (!Config.SectionsToRename.try_emplace(SR.OriginalName, SR).second)
 304       error("Multiple renames of section " + SR.OriginalName);
 305   }
 306
 307   for (auto Arg : InputArgs.filtered(OBJCOPY_remove_section))
 308     Config.ToRemove.push_back(Arg->getValue());
 309   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_section))
 310     Config.KeepSection.push_back(Arg->getValue());
 311   for (auto Arg : InputArgs.filtered(OBJCOPY_only_keep))
 312     Config.OnlyKeep.push_back(Arg->getValue());
 313   for (auto Arg : InputArgs.filtered(OBJCOPY_add_section))
 314     Config.AddSection.push_back(Arg->getValue());
 315   for (auto Arg : InputArgs.filtered(OBJCOPY_dump_section))
 316     Config.DumpSection.push_back(Arg->getValue());
 317   Config.StripAll = InputArgs.hasArg(OBJCOPY_strip_all);
 318   Config.StripAllGNU = InputArgs.hasArg(OBJCOPY_strip_all_gnu);
 319   Config.StripDebug = InputArgs.hasArg(OBJCOPY_strip_debug);
 320   Config.StripDWO = InputArgs.hasArg(OBJCOPY_strip_dwo);
 321   Config.StripSections = InputArgs.hasArg(OBJCOPY_strip_sections);
 322   Config.StripNonAlloc = InputArgs.hasArg(OBJCOPY_strip_non_alloc);
 323   Config.StripUnneeded = InputArgs.hasArg(OBJCOPY_strip_unneeded);
 324   Config.ExtractDWO = InputArgs.hasArg(OBJCOPY_extract_dwo);
 325   Config.LocalizeHidden = InputArgs.hasArg(OBJCOPY_localize_hidden);
 326   Config.Weaken = InputArgs.hasArg(OBJCOPY_weaken);
 327   Config.DiscardAll = InputArgs.hasArg(OBJCOPY_discard_all);
 328   Config.OnlyKeepDebug = InputArgs.hasArg(OBJCOPY_only_keep_debug);
 329   Config.KeepFileSymbols = InputArgs.hasArg(OBJCOPY_keep_file_symbols);
 330   Config.DecompressDebugSections =
 331       InputArgs.hasArg(OBJCOPY_decompress_debug_sections);
 332   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbol))
 333     Config.SymbolsToLocalize.push_back(Arg->getValue());
 334   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbol))
 335     Config.SymbolsToKeepGlobal.push_back(Arg->getValue());
 336   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbols))
 337     addGlobalSymbolsFromFile(Config.SymbolsToKeepGlobal, Arg->getValue());
 338   for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbol))
 339     Config.SymbolsToGlobalize.push_back(Arg->getValue());
 340   for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbol))
 341     Config.SymbolsToWeaken.push_back(Arg->getValue());
 342   for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbol))
 343     Config.SymbolsToRemove.push_back(Arg->getValue());
 344   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbol))
 345     Config.SymbolsToKeep.push_back(Arg->getValue());
 346
 347   Config.DeterministicArchives = InputArgs.hasFlag(
 348       OBJCOPY_enable_deterministic_archives,
 349       OBJCOPY_disable_deterministic_archives, /*default=*/true);
 350
 351   Config.PreserveDates = InputArgs.hasArg(OBJCOPY_preserve_dates);
 352
 353   if (Config.DecompressDebugSections &&
 354       Config.CompressionType != DebugCompressionType::None) {
 355     error("Cannot specify --compress-debug-sections at the same time as "
 356           "--decompress-debug-sections at the same time");
 357   }
 358
 359   if (Config.DecompressDebugSections && !zlib::isAvailable())
 360     error("LLVM was not compiled with LLVM_ENABLE_ZLIB: cannot decompress.");
 361
 362   DriverConfig DC;
 363   DC.CopyConfigs.push_back(std::move(Config));
 364   return DC;
 365 }
 366
 367 // ParseStripOptions returns the config and sets the input arguments. If a
 368 // help flag is set then ParseStripOptions will print the help messege and
 369 // exit.
 370 DriverConfig parseStripOptions(ArrayRef<const char *> ArgsArr) {
 371   StripOptTable T;
 372   unsigned MissingArgumentIndex, MissingArgumentCount;
 373   llvm::opt::InputArgList InputArgs =
 374       T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
 375
 376   if (InputArgs.size() == 0) {
 377     T.PrintHelp(errs(), "llvm-strip [options] file...", "strip tool");
 378     exit(1);
 379   }
 380
 381   if (InputArgs.hasArg(STRIP_help)) {
 382     T.PrintHelp(outs(), "llvm-strip [options] file...", "strip tool");
 383     exit(0);
 384   }
 385
 386   if (InputArgs.hasArg(STRIP_version)) {
 387     outs() << "llvm-strip, compatible with GNU strip\n";
 388     cl::PrintVersionMessage();
 389     exit(0);
 390   }
 391
 392   SmallVector<const char *, 2> Positional;
 393   for (auto Arg : InputArgs.filtered(STRIP_UNKNOWN))
 394     error("unknown argument '" + Arg->getAsString(InputArgs) + "'");
 395   for (auto Arg : InputArgs.filtered(STRIP_INPUT))
 396     Positional.push_back(Arg->getValue());
 397
 398   if (Positional.empty())
 399     error("No input file specified");
 400
 401   if (Positional.size() > 1 && InputArgs.hasArg(STRIP_output))
 402     error("Multiple input files cannot be used in combination with -o");
 403
 404   CopyConfig Config;
 405   Config.StripDebug = InputArgs.hasArg(STRIP_strip_debug);
 406
 407   Config.DiscardAll = InputArgs.hasArg(STRIP_discard_all);
 408   Config.StripUnneeded = InputArgs.hasArg(STRIP_strip_unneeded);
 409   Config.StripAll = InputArgs.hasArg(STRIP_strip_all);
 410   Config.StripAllGNU = InputArgs.hasArg(STRIP_strip_all_gnu);
 411
 412   if (!Config.StripDebug && !Config.StripUnneeded && !Config.DiscardAll &&
 413       !Config.StripAllGNU)
 414     Config.StripAll = true;
 415
 416   for (auto Arg : InputArgs.filtered(STRIP_keep_section))
 417     Config.KeepSection.push_back(Arg->getValue());
 418
 419   for (auto Arg : InputArgs.filtered(STRIP_remove_section))
 420     Config.ToRemove.push_back(Arg->getValue());
 421
 422   for (auto Arg : InputArgs.filtered(STRIP_keep_symbol))
 423     Config.SymbolsToKeep.push_back(Arg->getValue());
 424
 425   Config.DeterministicArchives =
 426       InputArgs.hasFlag(STRIP_enable_deterministic_archives,
 427                         STRIP_disable_deterministic_archives, /*default=*/true);
 428
 429   Config.PreserveDates = InputArgs.hasArg(STRIP_preserve_dates);
 430
 431   DriverConfig DC;
 432   if (Positional.size() == 1) {
 433     Config.InputFilename = Positional[0];
 434     Config.OutputFilename =
 435         InputArgs.getLastArgValue(STRIP_output, Positional[0]);
 436     DC.CopyConfigs.push_back(std::move(Config));
 437   } else {
 438     for (const char *Filename : Positional) {
 439       Config.InputFilename = Filename;
 440       Config.OutputFilename = Filename;
 441       DC.CopyConfigs.push_back(Config);
 442     }
 443   }
 444
 445   return DC;
 446 }
 447
 448 } // namespace objcopy
 449 } // namespace llvm