CopyConfig.cpp revision 360784 
1//===- CopyConfig.cpp -----------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "CopyConfig.h"
10
11#include "llvm/ADT/Optional.h"
12#include "llvm/ADT/SmallVector.h"
13#include "llvm/ADT/StringRef.h"
14#include "llvm/ADT/StringSet.h"
15#include "llvm/Option/Arg.h"
16#include "llvm/Option/ArgList.h"
17#include "llvm/Support/CRC.h"
18#include "llvm/Support/CommandLine.h"
19#include "llvm/Support/Compression.h"
20#include "llvm/Support/Errc.h"
21#include "llvm/Support/MemoryBuffer.h"
22#include "llvm/Support/StringSaver.h"
23#include <memory>
24
25namespace llvm {
26namespace objcopy {
27
28namespace {
29enum ObjcopyID {
30  OBJCOPY_INVALID = 0, // This is not an option ID.
31#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
32               HELPTEXT, METAVAR, VALUES)                                      \
33  OBJCOPY_##ID,
34#include "ObjcopyOpts.inc"
35#undef OPTION
36};
37
38#define PREFIX(NAME, VALUE) const char *const OBJCOPY_##NAME[] = VALUE;
39#include "ObjcopyOpts.inc"
40#undef PREFIX
41
42static const opt::OptTable::Info ObjcopyInfoTable[] = {
43#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
44               HELPTEXT, METAVAR, VALUES)                                      \
45  {OBJCOPY_##PREFIX,                                                           \
46   NAME,                                                                       \
47   HELPTEXT,                                                                   \
48   METAVAR,                                                                    \
49   OBJCOPY_##ID,                                                               \
50   opt::Option::KIND##Class,                                                   \
51   PARAM,                                                                      \
52   FLAGS,                                                                      \
53   OBJCOPY_##GROUP,                                                            \
54   OBJCOPY_##ALIAS,                                                            \
55   ALIASARGS,                                                                  \
56   VALUES},
57#include "ObjcopyOpts.inc"
58#undef OPTION
59};
60
61class ObjcopyOptTable : public opt::OptTable {
62public:
63  ObjcopyOptTable() : OptTable(ObjcopyInfoTable) {}
64};
65
66enum InstallNameToolID {
67  INSTALL_NAME_TOOL_INVALID = 0, // This is not an option ID.
68#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
69               HELPTEXT, METAVAR, VALUES)                                      \
70  INSTALL_NAME_TOOL_##ID,
71#include "InstallNameToolOpts.inc"
72#undef OPTION
73};
74
75#define PREFIX(NAME, VALUE)                                                    \
76  const char *const INSTALL_NAME_TOOL_##NAME[] = VALUE;
77#include "InstallNameToolOpts.inc"
78#undef PREFIX
79
80static const opt::OptTable::Info InstallNameToolInfoTable[] = {
81#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
82               HELPTEXT, METAVAR, VALUES)                                      \
83  {INSTALL_NAME_TOOL_##PREFIX,                                                 \
84   NAME,                                                                       \
85   HELPTEXT,                                                                   \
86   METAVAR,                                                                    \
87   INSTALL_NAME_TOOL_##ID,                                                     \
88   opt::Option::KIND##Class,                                                   \
89   PARAM,                                                                      \
90   FLAGS,                                                                      \
91   INSTALL_NAME_TOOL_##GROUP,                                                  \
92   INSTALL_NAME_TOOL_##ALIAS,                                                  \
93   ALIASARGS,                                                                  \
94   VALUES},
95#include "InstallNameToolOpts.inc"
96#undef OPTION
97};
98
99class InstallNameToolOptTable : public opt::OptTable {
100public:
101  InstallNameToolOptTable() : OptTable(InstallNameToolInfoTable) {}
102};
103
104enum StripID {
105  STRIP_INVALID = 0, // This is not an option ID.
106#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
107               HELPTEXT, METAVAR, VALUES)                                      \
108  STRIP_##ID,
109#include "StripOpts.inc"
110#undef OPTION
111};
112
113#define PREFIX(NAME, VALUE) const char *const STRIP_##NAME[] = VALUE;
114#include "StripOpts.inc"
115#undef PREFIX
116
117static const opt::OptTable::Info StripInfoTable[] = {
118#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
119               HELPTEXT, METAVAR, VALUES)                                      \
120  {STRIP_##PREFIX, NAME,       HELPTEXT,                                       \
121   METAVAR,        STRIP_##ID, opt::Option::KIND##Class,                       \
122   PARAM,          FLAGS,      STRIP_##GROUP,                                  \
123   STRIP_##ALIAS,  ALIASARGS,  VALUES},
124#include "StripOpts.inc"
125#undef OPTION
126};
127
128class StripOptTable : public opt::OptTable {
129public:
130  StripOptTable() : OptTable(StripInfoTable) {}
131};
132
133} // namespace
134
135static SectionFlag parseSectionRenameFlag(StringRef SectionName) {
136  return llvm::StringSwitch<SectionFlag>(SectionName)
137      .CaseLower("alloc", SectionFlag::SecAlloc)
138      .CaseLower("load", SectionFlag::SecLoad)
139      .CaseLower("noload", SectionFlag::SecNoload)
140      .CaseLower("readonly", SectionFlag::SecReadonly)
141      .CaseLower("debug", SectionFlag::SecDebug)
142      .CaseLower("code", SectionFlag::SecCode)
143      .CaseLower("data", SectionFlag::SecData)
144      .CaseLower("rom", SectionFlag::SecRom)
145      .CaseLower("merge", SectionFlag::SecMerge)
146      .CaseLower("strings", SectionFlag::SecStrings)
147      .CaseLower("contents", SectionFlag::SecContents)
148      .CaseLower("share", SectionFlag::SecShare)
149      .Default(SectionFlag::SecNone);
150}
151
152static Expected<SectionFlag>
153parseSectionFlagSet(ArrayRef<StringRef> SectionFlags) {
154  SectionFlag ParsedFlags = SectionFlag::SecNone;
155  for (StringRef Flag : SectionFlags) {
156    SectionFlag ParsedFlag = parseSectionRenameFlag(Flag);
157    if (ParsedFlag == SectionFlag::SecNone)
158      return createStringError(
159          errc::invalid_argument,
160          "unrecognized section flag '%s'. Flags supported for GNU "
161          "compatibility: alloc, load, noload, readonly, debug, code, data, "
162          "rom, share, contents, merge, strings",
163          Flag.str().c_str());
164    ParsedFlags |= ParsedFlag;
165  }
166
167  return ParsedFlags;
168}
169
170static Expected<SectionRename> parseRenameSectionValue(StringRef FlagValue) {
171  if (!FlagValue.contains('='))
172    return createStringError(errc::invalid_argument,
173                             "bad format for --rename-section: missing '='");
174
175  // Initial split: ".foo" = ".bar,f1,f2,..."
176  auto Old2New = FlagValue.split('=');
177  SectionRename SR;
178  SR.OriginalName = Old2New.first;
179
180  // Flags split: ".bar" "f1" "f2" ...
181  SmallVector<StringRef, 6> NameAndFlags;
182  Old2New.second.split(NameAndFlags, ',');
183  SR.NewName = NameAndFlags[0];
184
185  if (NameAndFlags.size() > 1) {
186    Expected<SectionFlag> ParsedFlagSet =
187        parseSectionFlagSet(makeArrayRef(NameAndFlags).drop_front());
188    if (!ParsedFlagSet)
189      return ParsedFlagSet.takeError();
190    SR.NewFlags = *ParsedFlagSet;
191  }
192
193  return SR;
194}
195
196static Expected<std::pair<StringRef, uint64_t>>
197parseSetSectionAlignment(StringRef FlagValue) {
198  if (!FlagValue.contains('='))
199    return createStringError(
200        errc::invalid_argument,
201        "bad format for --set-section-alignment: missing '='");
202  auto Split = StringRef(FlagValue).split('=');
203  if (Split.first.empty())
204    return createStringError(
205        errc::invalid_argument,
206        "bad format for --set-section-alignment: missing section name");
207  uint64_t NewAlign;
208  if (Split.second.getAsInteger(0, NewAlign))
209    return createStringError(errc::invalid_argument,
210                             "invalid alignment for --set-section-alignment: '%s'",
211                             Split.second.str().c_str());
212  return std::make_pair(Split.first, NewAlign);
213}
214
215static Expected<SectionFlagsUpdate>
216parseSetSectionFlagValue(StringRef FlagValue) {
217  if (!StringRef(FlagValue).contains('='))
218    return createStringError(errc::invalid_argument,
219                             "bad format for --set-section-flags: missing '='");
220
221  // Initial split: ".foo" = "f1,f2,..."
222  auto Section2Flags = StringRef(FlagValue).split('=');
223  SectionFlagsUpdate SFU;
224  SFU.Name = Section2Flags.first;
225
226  // Flags split: "f1" "f2" ...
227  SmallVector<StringRef, 6> SectionFlags;
228  Section2Flags.second.split(SectionFlags, ',');
229  Expected<SectionFlag> ParsedFlagSet = parseSectionFlagSet(SectionFlags);
230  if (!ParsedFlagSet)
231    return ParsedFlagSet.takeError();
232  SFU.NewFlags = *ParsedFlagSet;
233
234  return SFU;
235}
236
237struct TargetInfo {
238  FileFormat Format;
239  MachineInfo Machine;
240};
241
242// FIXME: consolidate with the bfd parsing used by lld.
243static const StringMap<MachineInfo> TargetMap{
244    // Name, {EMachine, 64bit, LittleEndian}
245    // x86
246    {"elf32-i386", {ELF::EM_386, false, true}},
247    {"elf32-x86-64", {ELF::EM_X86_64, false, true}},
248    {"elf64-x86-64", {ELF::EM_X86_64, true, true}},
249    // Intel MCU
250    {"elf32-iamcu", {ELF::EM_IAMCU, false, true}},
251    // ARM
252    {"elf32-littlearm", {ELF::EM_ARM, false, true}},
253    // ARM AArch64
254    {"elf64-aarch64", {ELF::EM_AARCH64, true, true}},
255    {"elf64-littleaarch64", {ELF::EM_AARCH64, true, true}},
256    // RISC-V
257    {"elf32-littleriscv", {ELF::EM_RISCV, false, true}},
258    {"elf64-littleriscv", {ELF::EM_RISCV, true, true}},
259    // PowerPC
260    {"elf32-powerpc", {ELF::EM_PPC, false, false}},
261    {"elf32-powerpcle", {ELF::EM_PPC, false, true}},
262    {"elf64-powerpc", {ELF::EM_PPC64, true, false}},
263    {"elf64-powerpcle", {ELF::EM_PPC64, true, true}},
264    // MIPS
265    {"elf32-bigmips", {ELF::EM_MIPS, false, false}},
266    {"elf32-ntradbigmips", {ELF::EM_MIPS, false, false}},
267    {"elf32-ntradlittlemips", {ELF::EM_MIPS, false, true}},
268    {"elf32-tradbigmips", {ELF::EM_MIPS, false, false}},
269    {"elf32-tradlittlemips", {ELF::EM_MIPS, false, true}},
270    {"elf64-tradbigmips", {ELF::EM_MIPS, true, false}},
271    {"elf64-tradlittlemips", {ELF::EM_MIPS, true, true}},
272    // SPARC
273    {"elf32-sparc", {ELF::EM_SPARC, false, false}},
274    {"elf32-sparcel", {ELF::EM_SPARC, false, true}},
275};
276
277static Expected<TargetInfo>
278getOutputTargetInfoByTargetName(StringRef TargetName) {
279  StringRef OriginalTargetName = TargetName;
280  bool IsFreeBSD = TargetName.consume_back("-freebsd");
281  auto Iter = TargetMap.find(TargetName);
282  if (Iter == std::end(TargetMap))
283    return createStringError(errc::invalid_argument,
284                             "invalid output format: '%s'",
285                             OriginalTargetName.str().c_str());
286  MachineInfo MI = Iter->getValue();
287  if (IsFreeBSD)
288    MI.OSABI = ELF::ELFOSABI_FREEBSD;
289
290  FileFormat Format;
291  if (TargetName.startswith("elf"))
292    Format = FileFormat::ELF;
293  else
294    // This should never happen because `TargetName` is valid (it certainly
295    // exists in the TargetMap).
296    llvm_unreachable("unknown target prefix");
297
298  return {TargetInfo{Format, MI}};
299}
300
301static Error
302addSymbolsFromFile(NameMatcher &Symbols, BumpPtrAllocator &Alloc,
303                   StringRef Filename, MatchStyle MS,
304                   llvm::function_ref<Error(Error)> ErrorCallback) {
305  StringSaver Saver(Alloc);
306  SmallVector<StringRef, 16> Lines;
307  auto BufOrErr = MemoryBuffer::getFile(Filename);
308  if (!BufOrErr)
309    return createFileError(Filename, BufOrErr.getError());
310
311  BufOrErr.get()->getBuffer().split(Lines, '\n');
312  for (StringRef Line : Lines) {
313    // Ignore everything after '#', trim whitespace, and only add the symbol if
314    // it's not empty.
315    auto TrimmedLine = Line.split('#').first.trim();
316    if (!TrimmedLine.empty())
317      if (Error E = Symbols.addMatcher(NameOrPattern::create(
318              Saver.save(TrimmedLine), MS, ErrorCallback)))
319        return E;
320  }
321
322  return Error::success();
323}
324
325Expected<NameOrPattern>
326NameOrPattern::create(StringRef Pattern, MatchStyle MS,
327                      llvm::function_ref<Error(Error)> ErrorCallback) {
328  switch (MS) {
329  case MatchStyle::Literal:
330    return NameOrPattern(Pattern);
331  case MatchStyle::Wildcard: {
332    SmallVector<char, 32> Data;
333    bool IsPositiveMatch = true;
334    if (Pattern[0] == '!') {
335      IsPositiveMatch = false;
336      Pattern = Pattern.drop_front();
337    }
338    Expected<GlobPattern> GlobOrErr = GlobPattern::create(Pattern);
339
340    // If we couldn't create it as a glob, report the error, but try again with
341    // a literal if the error reporting is non-fatal.
342    if (!GlobOrErr) {
343      if (Error E = ErrorCallback(GlobOrErr.takeError()))
344        return std::move(E);
345      return create(Pattern, MatchStyle::Literal, ErrorCallback);
346    }
347
348    return NameOrPattern(std::make_shared<GlobPattern>(*GlobOrErr),
349                         IsPositiveMatch);
350  }
351  case MatchStyle::Regex: {
352    SmallVector<char, 32> Data;
353    return NameOrPattern(std::make_shared<Regex>(
354        ("^" + Pattern.ltrim('^').rtrim('$') + "$").toStringRef(Data)));
355  }
356  }
357  llvm_unreachable("Unhandled llvm.objcopy.MatchStyle enum");
358}
359
360static Error addSymbolsToRenameFromFile(StringMap<StringRef> &SymbolsToRename,
361                                        BumpPtrAllocator &Alloc,
362                                        StringRef Filename) {
363  StringSaver Saver(Alloc);
364  SmallVector<StringRef, 16> Lines;
365  auto BufOrErr = MemoryBuffer::getFile(Filename);
366  if (!BufOrErr)
367    return createFileError(Filename, BufOrErr.getError());
368
369  BufOrErr.get()->getBuffer().split(Lines, '\n');
370  size_t NumLines = Lines.size();
371  for (size_t LineNo = 0; LineNo < NumLines; ++LineNo) {
372    StringRef TrimmedLine = Lines[LineNo].split('#').first.trim();
373    if (TrimmedLine.empty())
374      continue;
375
376    std::pair<StringRef, StringRef> Pair = Saver.save(TrimmedLine).split(' ');
377    StringRef NewName = Pair.second.trim();
378    if (NewName.empty())
379      return createStringError(errc::invalid_argument,
380                               "%s:%zu: missing new symbol name",
381                               Filename.str().c_str(), LineNo + 1);
382    SymbolsToRename.insert({Pair.first, NewName});
383  }
384  return Error::success();
385}
386
387template <class T> static ErrorOr<T> getAsInteger(StringRef Val) {
388  T Result;
389  if (Val.getAsInteger(0, Result))
390    return errc::invalid_argument;
391  return Result;
392}
393
394static void printHelp(const opt::OptTable &OptTable, raw_ostream &OS,
395                      StringRef ToolName) {
396  OptTable.PrintHelp(OS, (ToolName + " input [output]").str().c_str(),
397                     (ToolName + " tool").str().c_str());
398  // TODO: Replace this with libOption call once it adds extrahelp support.
399  // The CommandLine library has a cl::extrahelp class to support this,
400  // but libOption does not have that yet.
401  OS << "\nPass @FILE as argument to read options from FILE.\n";
402}
403
404// ParseObjcopyOptions returns the config and sets the input arguments. If a
405// help flag is set then ParseObjcopyOptions will print the help messege and
406// exit.
407Expected<DriverConfig>
408parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
409                    llvm::function_ref<Error(Error)> ErrorCallback) {
410  DriverConfig DC;
411  ObjcopyOptTable T;
412  unsigned MissingArgumentIndex, MissingArgumentCount;
413  llvm::opt::InputArgList InputArgs =
414      T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
415
416  if (InputArgs.size() == 0) {
417    printHelp(T, errs(), "llvm-objcopy");
418    exit(1);
419  }
420
421  if (InputArgs.hasArg(OBJCOPY_help)) {
422    printHelp(T, outs(), "llvm-objcopy");
423    exit(0);
424  }
425
426  if (InputArgs.hasArg(OBJCOPY_version)) {
427    outs() << "llvm-objcopy, compatible with GNU objcopy\n";
428    cl::PrintVersionMessage();
429    exit(0);
430  }
431
432  SmallVector<const char *, 2> Positional;
433
434  for (auto Arg : InputArgs.filtered(OBJCOPY_UNKNOWN))
435    return createStringError(errc::invalid_argument, "unknown argument '%s'",
436                             Arg->getAsString(InputArgs).c_str());
437
438  for (auto Arg : InputArgs.filtered(OBJCOPY_INPUT))
439    Positional.push_back(Arg->getValue());
440
441  if (Positional.empty())
442    return createStringError(errc::invalid_argument, "no input file specified");
443
444  if (Positional.size() > 2)
445    return createStringError(errc::invalid_argument,
446                             "too many positional arguments");
447
448  CopyConfig Config;
449  Config.InputFilename = Positional[0];
450  Config.OutputFilename = Positional[Positional.size() == 1 ? 0 : 1];
451  if (InputArgs.hasArg(OBJCOPY_target) &&
452      (InputArgs.hasArg(OBJCOPY_input_target) ||
453       InputArgs.hasArg(OBJCOPY_output_target)))
454    return createStringError(
455        errc::invalid_argument,
456        "--target cannot be used with --input-target or --output-target");
457
458  if (InputArgs.hasArg(OBJCOPY_regex) && InputArgs.hasArg(OBJCOPY_wildcard))
459    return createStringError(errc::invalid_argument,
460                             "--regex and --wildcard are incompatible");
461
462  MatchStyle SectionMatchStyle = InputArgs.hasArg(OBJCOPY_regex)
463                                     ? MatchStyle::Regex
464                                     : MatchStyle::Wildcard;
465  MatchStyle SymbolMatchStyle = InputArgs.hasArg(OBJCOPY_regex)
466                                    ? MatchStyle::Regex
467                                    : InputArgs.hasArg(OBJCOPY_wildcard)
468                                          ? MatchStyle::Wildcard
469                                          : MatchStyle::Literal;
470  StringRef InputFormat, OutputFormat;
471  if (InputArgs.hasArg(OBJCOPY_target)) {
472    InputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
473    OutputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
474  } else {
475    InputFormat = InputArgs.getLastArgValue(OBJCOPY_input_target);
476    OutputFormat = InputArgs.getLastArgValue(OBJCOPY_output_target);
477  }
478
479  // FIXME:  Currently, we ignore the target for non-binary/ihex formats
480  // explicitly specified by -I option (e.g. -Ielf32-x86-64) and guess the
481  // format by llvm::object::createBinary regardless of the option value.
482  Config.InputFormat = StringSwitch<FileFormat>(InputFormat)
483                           .Case("binary", FileFormat::Binary)
484                           .Case("ihex", FileFormat::IHex)
485                           .Default(FileFormat::Unspecified);
486
487  if (InputArgs.hasArg(OBJCOPY_new_symbol_visibility))
488    Config.NewSymbolVisibility =
489        InputArgs.getLastArgValue(OBJCOPY_new_symbol_visibility);
490
491  Config.OutputFormat = StringSwitch<FileFormat>(OutputFormat)
492                            .Case("binary", FileFormat::Binary)
493                            .Case("ihex", FileFormat::IHex)
494                            .Default(FileFormat::Unspecified);
495  if (Config.OutputFormat == FileFormat::Unspecified) {
496    if (OutputFormat.empty()) {
497      Config.OutputFormat = Config.InputFormat;
498    } else {
499      Expected<TargetInfo> Target =
500          getOutputTargetInfoByTargetName(OutputFormat);
501      if (!Target)
502        return Target.takeError();
503      Config.OutputFormat = Target->Format;
504      Config.OutputArch = Target->Machine;
505    }
506  }
507
508  if (auto Arg = InputArgs.getLastArg(OBJCOPY_compress_debug_sections,
509                                      OBJCOPY_compress_debug_sections_eq)) {
510    Config.CompressionType = DebugCompressionType::Z;
511
512    if (Arg->getOption().getID() == OBJCOPY_compress_debug_sections_eq) {
513      Config.CompressionType =
514          StringSwitch<DebugCompressionType>(
515              InputArgs.getLastArgValue(OBJCOPY_compress_debug_sections_eq))
516              .Case("zlib-gnu", DebugCompressionType::GNU)
517              .Case("zlib", DebugCompressionType::Z)
518              .Default(DebugCompressionType::None);
519      if (Config.CompressionType == DebugCompressionType::None)
520        return createStringError(
521            errc::invalid_argument,
522            "invalid or unsupported --compress-debug-sections format: %s",
523            InputArgs.getLastArgValue(OBJCOPY_compress_debug_sections_eq)
524                .str()
525                .c_str());
526    }
527    if (!zlib::isAvailable())
528      return createStringError(
529          errc::invalid_argument,
530          "LLVM was not compiled with LLVM_ENABLE_ZLIB: can not compress");
531  }
532
533  Config.AddGnuDebugLink = InputArgs.getLastArgValue(OBJCOPY_add_gnu_debuglink);
534  // The gnu_debuglink's target is expected to not change or else its CRC would
535  // become invalidated and get rejected. We can avoid recalculating the
536  // checksum for every target file inside an archive by precomputing the CRC
537  // here. This prevents a significant amount of I/O.
538  if (!Config.AddGnuDebugLink.empty()) {
539    auto DebugOrErr = MemoryBuffer::getFile(Config.AddGnuDebugLink);
540    if (!DebugOrErr)
541      return createFileError(Config.AddGnuDebugLink, DebugOrErr.getError());
542    auto Debug = std::move(*DebugOrErr);
543    Config.GnuDebugLinkCRC32 =
544        llvm::crc32(arrayRefFromStringRef(Debug->getBuffer()));
545  }
546  Config.BuildIdLinkDir = InputArgs.getLastArgValue(OBJCOPY_build_id_link_dir);
547  if (InputArgs.hasArg(OBJCOPY_build_id_link_input))
548    Config.BuildIdLinkInput =
549        InputArgs.getLastArgValue(OBJCOPY_build_id_link_input);
550  if (InputArgs.hasArg(OBJCOPY_build_id_link_output))
551    Config.BuildIdLinkOutput =
552        InputArgs.getLastArgValue(OBJCOPY_build_id_link_output);
553  Config.SplitDWO = InputArgs.getLastArgValue(OBJCOPY_split_dwo);
554  Config.SymbolsPrefix = InputArgs.getLastArgValue(OBJCOPY_prefix_symbols);
555  Config.AllocSectionsPrefix =
556      InputArgs.getLastArgValue(OBJCOPY_prefix_alloc_sections);
557  if (auto Arg = InputArgs.getLastArg(OBJCOPY_extract_partition))
558    Config.ExtractPartition = Arg->getValue();
559
560  for (auto Arg : InputArgs.filtered(OBJCOPY_redefine_symbol)) {
561    if (!StringRef(Arg->getValue()).contains('='))
562      return createStringError(errc::invalid_argument,
563                               "bad format for --redefine-sym");
564    auto Old2New = StringRef(Arg->getValue()).split('=');
565    if (!Config.SymbolsToRename.insert(Old2New).second)
566      return createStringError(errc::invalid_argument,
567                               "multiple redefinition of symbol '%s'",
568                               Old2New.first.str().c_str());
569  }
570
571  for (auto Arg : InputArgs.filtered(OBJCOPY_redefine_symbols))
572    if (Error E = addSymbolsToRenameFromFile(Config.SymbolsToRename, DC.Alloc,
573                                             Arg->getValue()))
574      return std::move(E);
575
576  for (auto Arg : InputArgs.filtered(OBJCOPY_rename_section)) {
577    Expected<SectionRename> SR =
578        parseRenameSectionValue(StringRef(Arg->getValue()));
579    if (!SR)
580      return SR.takeError();
581    if (!Config.SectionsToRename.try_emplace(SR->OriginalName, *SR).second)
582      return createStringError(errc::invalid_argument,
583                               "multiple renames of section '%s'",
584                               SR->OriginalName.str().c_str());
585  }
586  for (auto Arg : InputArgs.filtered(OBJCOPY_set_section_alignment)) {
587    Expected<std::pair<StringRef, uint64_t>> NameAndAlign =
588        parseSetSectionAlignment(Arg->getValue());
589    if (!NameAndAlign)
590      return NameAndAlign.takeError();
591    Config.SetSectionAlignment[NameAndAlign->first] = NameAndAlign->second;
592  }
593  for (auto Arg : InputArgs.filtered(OBJCOPY_set_section_flags)) {
594    Expected<SectionFlagsUpdate> SFU =
595        parseSetSectionFlagValue(Arg->getValue());
596    if (!SFU)
597      return SFU.takeError();
598    if (!Config.SetSectionFlags.try_emplace(SFU->Name, *SFU).second)
599      return createStringError(
600          errc::invalid_argument,
601          "--set-section-flags set multiple times for section '%s'",
602          SFU->Name.str().c_str());
603  }
604  // Prohibit combinations of --set-section-flags when the section name is used
605  // by --rename-section, either as a source or a destination.
606  for (const auto &E : Config.SectionsToRename) {
607    const SectionRename &SR = E.second;
608    if (Config.SetSectionFlags.count(SR.OriginalName))
609      return createStringError(
610          errc::invalid_argument,
611          "--set-section-flags=%s conflicts with --rename-section=%s=%s",
612          SR.OriginalName.str().c_str(), SR.OriginalName.str().c_str(),
613          SR.NewName.str().c_str());
614    if (Config.SetSectionFlags.count(SR.NewName))
615      return createStringError(
616          errc::invalid_argument,
617          "--set-section-flags=%s conflicts with --rename-section=%s=%s",
618          SR.NewName.str().c_str(), SR.OriginalName.str().c_str(),
619          SR.NewName.str().c_str());
620  }
621
622  for (auto Arg : InputArgs.filtered(OBJCOPY_remove_section))
623    if (Error E = Config.ToRemove.addMatcher(NameOrPattern::create(
624            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
625      return std::move(E);
626  for (auto Arg : InputArgs.filtered(OBJCOPY_keep_section))
627    if (Error E = Config.KeepSection.addMatcher(NameOrPattern::create(
628            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
629      return std::move(E);
630  for (auto Arg : InputArgs.filtered(OBJCOPY_only_section))
631    if (Error E = Config.OnlySection.addMatcher(NameOrPattern::create(
632            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
633      return std::move(E);
634  for (auto Arg : InputArgs.filtered(OBJCOPY_add_section)) {
635    StringRef ArgValue(Arg->getValue());
636    if (!ArgValue.contains('='))
637      return createStringError(errc::invalid_argument,
638                               "bad format for --add-section: missing '='");
639    if (ArgValue.split("=").second.empty())
640      return createStringError(
641          errc::invalid_argument,
642          "bad format for --add-section: missing file name");
643    Config.AddSection.push_back(ArgValue);
644  }
645  for (auto Arg : InputArgs.filtered(OBJCOPY_dump_section))
646    Config.DumpSection.push_back(Arg->getValue());
647  Config.StripAll = InputArgs.hasArg(OBJCOPY_strip_all);
648  Config.StripAllGNU = InputArgs.hasArg(OBJCOPY_strip_all_gnu);
649  Config.StripDebug = InputArgs.hasArg(OBJCOPY_strip_debug);
650  Config.StripDWO = InputArgs.hasArg(OBJCOPY_strip_dwo);
651  Config.StripSections = InputArgs.hasArg(OBJCOPY_strip_sections);
652  Config.StripNonAlloc = InputArgs.hasArg(OBJCOPY_strip_non_alloc);
653  Config.StripUnneeded = InputArgs.hasArg(OBJCOPY_strip_unneeded);
654  Config.ExtractDWO = InputArgs.hasArg(OBJCOPY_extract_dwo);
655  Config.ExtractMainPartition =
656      InputArgs.hasArg(OBJCOPY_extract_main_partition);
657  Config.LocalizeHidden = InputArgs.hasArg(OBJCOPY_localize_hidden);
658  Config.Weaken = InputArgs.hasArg(OBJCOPY_weaken);
659  if (InputArgs.hasArg(OBJCOPY_discard_all, OBJCOPY_discard_locals))
660    Config.DiscardMode =
661        InputArgs.hasFlag(OBJCOPY_discard_all, OBJCOPY_discard_locals)
662            ? DiscardType::All
663            : DiscardType::Locals;
664  Config.OnlyKeepDebug = InputArgs.hasArg(OBJCOPY_only_keep_debug);
665  Config.KeepFileSymbols = InputArgs.hasArg(OBJCOPY_keep_file_symbols);
666  Config.DecompressDebugSections =
667      InputArgs.hasArg(OBJCOPY_decompress_debug_sections);
668  if (Config.DiscardMode == DiscardType::All)
669    Config.StripDebug = true;
670  for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbol))
671    if (Error E = Config.SymbolsToLocalize.addMatcher(NameOrPattern::create(
672            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
673      return std::move(E);
674  for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbols))
675    if (Error E = addSymbolsFromFile(Config.SymbolsToLocalize, DC.Alloc,
676                                     Arg->getValue(), SymbolMatchStyle,
677                                     ErrorCallback))
678      return std::move(E);
679  for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbol))
680    if (Error E = Config.SymbolsToKeepGlobal.addMatcher(NameOrPattern::create(
681            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
682      return std::move(E);
683  for (auto Arg : InputArgs.filtered(OBJCOPY_keep_global_symbols))
684    if (Error E = addSymbolsFromFile(Config.SymbolsToKeepGlobal, DC.Alloc,
685                                     Arg->getValue(), SymbolMatchStyle,
686                                     ErrorCallback))
687      return std::move(E);
688  for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbol))
689    if (Error E = Config.SymbolsToGlobalize.addMatcher(NameOrPattern::create(
690            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
691      return std::move(E);
692  for (auto Arg : InputArgs.filtered(OBJCOPY_globalize_symbols))
693    if (Error E = addSymbolsFromFile(Config.SymbolsToGlobalize, DC.Alloc,
694                                     Arg->getValue(), SymbolMatchStyle,
695                                     ErrorCallback))
696      return std::move(E);
697  for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbol))
698    if (Error E = Config.SymbolsToWeaken.addMatcher(NameOrPattern::create(
699            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
700      return std::move(E);
701  for (auto Arg : InputArgs.filtered(OBJCOPY_weaken_symbols))
702    if (Error E = addSymbolsFromFile(Config.SymbolsToWeaken, DC.Alloc,
703                                     Arg->getValue(), SymbolMatchStyle,
704                                     ErrorCallback))
705      return std::move(E);
706  for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbol))
707    if (Error E = Config.SymbolsToRemove.addMatcher(NameOrPattern::create(
708            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
709      return std::move(E);
710  for (auto Arg : InputArgs.filtered(OBJCOPY_strip_symbols))
711    if (Error E = addSymbolsFromFile(Config.SymbolsToRemove, DC.Alloc,
712                                     Arg->getValue(), SymbolMatchStyle,
713                                     ErrorCallback))
714      return std::move(E);
715  for (auto Arg : InputArgs.filtered(OBJCOPY_strip_unneeded_symbol))
716    if (Error E =
717            Config.UnneededSymbolsToRemove.addMatcher(NameOrPattern::create(
718                Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
719      return std::move(E);
720  for (auto Arg : InputArgs.filtered(OBJCOPY_strip_unneeded_symbols))
721    if (Error E = addSymbolsFromFile(Config.UnneededSymbolsToRemove, DC.Alloc,
722                                     Arg->getValue(), SymbolMatchStyle,
723                                     ErrorCallback))
724      return std::move(E);
725  for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbol))
726    if (Error E = Config.SymbolsToKeep.addMatcher(NameOrPattern::create(
727            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
728      return std::move(E);
729  for (auto Arg : InputArgs.filtered(OBJCOPY_keep_symbols))
730    if (Error E =
731            addSymbolsFromFile(Config.SymbolsToKeep, DC.Alloc, Arg->getValue(),
732                               SymbolMatchStyle, ErrorCallback))
733      return std::move(E);
734  for (auto Arg : InputArgs.filtered(OBJCOPY_add_symbol))
735    Config.SymbolsToAdd.push_back(Arg->getValue());
736
737  Config.AllowBrokenLinks = InputArgs.hasArg(OBJCOPY_allow_broken_links);
738
739  Config.DeterministicArchives = InputArgs.hasFlag(
740      OBJCOPY_enable_deterministic_archives,
741      OBJCOPY_disable_deterministic_archives, /*default=*/true);
742
743  Config.PreserveDates = InputArgs.hasArg(OBJCOPY_preserve_dates);
744
745  if (Config.PreserveDates &&
746      (Config.OutputFilename == "-" || Config.InputFilename == "-"))
747    return createStringError(errc::invalid_argument,
748                             "--preserve-dates requires a file");
749
750  for (auto Arg : InputArgs)
751    if (Arg->getOption().matches(OBJCOPY_set_start)) {
752      auto EAddr = getAsInteger<uint64_t>(Arg->getValue());
753      if (!EAddr)
754        return createStringError(
755            EAddr.getError(), "bad entry point address: '%s'", Arg->getValue());
756
757      Config.EntryExpr = [EAddr](uint64_t) { return *EAddr; };
758    } else if (Arg->getOption().matches(OBJCOPY_change_start)) {
759      auto EIncr = getAsInteger<int64_t>(Arg->getValue());
760      if (!EIncr)
761        return createStringError(EIncr.getError(),
762                                 "bad entry point increment: '%s'",
763                                 Arg->getValue());
764      auto Expr = Config.EntryExpr ? std::move(Config.EntryExpr)
765                                   : [](uint64_t A) { return A; };
766      Config.EntryExpr = [Expr, EIncr](uint64_t EAddr) {
767        return Expr(EAddr) + *EIncr;
768      };
769    }
770
771  if (Config.DecompressDebugSections &&
772      Config.CompressionType != DebugCompressionType::None) {
773    return createStringError(
774        errc::invalid_argument,
775        "cannot specify both --compress-debug-sections and "
776        "--decompress-debug-sections");
777  }
778
779  if (Config.DecompressDebugSections && !zlib::isAvailable())
780    return createStringError(
781        errc::invalid_argument,
782        "LLVM was not compiled with LLVM_ENABLE_ZLIB: cannot decompress");
783
784  if (Config.ExtractPartition && Config.ExtractMainPartition)
785    return createStringError(errc::invalid_argument,
786                             "cannot specify --extract-partition together with "
787                             "--extract-main-partition");
788
789  DC.CopyConfigs.push_back(std::move(Config));
790  return std::move(DC);
791}
792
793// ParseInstallNameToolOptions returns the config and sets the input arguments.
794// If a help flag is set then ParseInstallNameToolOptions will print the help
795// messege and exit.
796Expected<DriverConfig>
797parseInstallNameToolOptions(ArrayRef<const char *> ArgsArr) {
798  DriverConfig DC;
799  CopyConfig Config;
800  InstallNameToolOptTable T;
801  unsigned MissingArgumentIndex, MissingArgumentCount;
802  llvm::opt::InputArgList InputArgs =
803      T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
804
805  if (InputArgs.size() == 0) {
806    printHelp(T, errs(), "llvm-install-name-tool");
807    exit(1);
808  }
809
810  if (InputArgs.hasArg(INSTALL_NAME_TOOL_help)) {
811    printHelp(T, outs(), "llvm-install-name-tool");
812    exit(0);
813  }
814
815  if (InputArgs.hasArg(INSTALL_NAME_TOOL_version)) {
816    outs() << "llvm-install-name-tool, compatible with cctools "
817              "install_name_tool\n";
818    cl::PrintVersionMessage();
819    exit(0);
820  }
821
822  for (auto Arg : InputArgs.filtered(INSTALL_NAME_TOOL_add_rpath))
823    Config.RPathToAdd.push_back(Arg->getValue());
824
825  SmallVector<StringRef, 2> Positional;
826  for (auto Arg : InputArgs.filtered(INSTALL_NAME_TOOL_UNKNOWN))
827    return createStringError(errc::invalid_argument, "unknown argument '%s'",
828                             Arg->getAsString(InputArgs).c_str());
829  for (auto Arg : InputArgs.filtered(INSTALL_NAME_TOOL_INPUT))
830    Positional.push_back(Arg->getValue());
831  if (Positional.empty())
832    return createStringError(errc::invalid_argument, "no input file specified");
833  if (Positional.size() > 1)
834    return createStringError(
835        errc::invalid_argument,
836        "llvm-install-name-tool expects a single input file");
837  Config.InputFilename = Positional[0];
838  Config.OutputFilename = Positional[0];
839
840  DC.CopyConfigs.push_back(std::move(Config));
841  return std::move(DC);
842}
843
844// ParseStripOptions returns the config and sets the input arguments. If a
845// help flag is set then ParseStripOptions will print the help messege and
846// exit.
847Expected<DriverConfig>
848parseStripOptions(ArrayRef<const char *> ArgsArr,
849                  llvm::function_ref<Error(Error)> ErrorCallback) {
850  StripOptTable T;
851  unsigned MissingArgumentIndex, MissingArgumentCount;
852  llvm::opt::InputArgList InputArgs =
853      T.ParseArgs(ArgsArr, MissingArgumentIndex, MissingArgumentCount);
854
855  if (InputArgs.size() == 0) {
856    printHelp(T, errs(), "llvm-strip");
857    exit(1);
858  }
859
860  if (InputArgs.hasArg(STRIP_help)) {
861    printHelp(T, outs(), "llvm-strip");
862    exit(0);
863  }
864
865  if (InputArgs.hasArg(STRIP_version)) {
866    outs() << "llvm-strip, compatible with GNU strip\n";
867    cl::PrintVersionMessage();
868    exit(0);
869  }
870
871  SmallVector<StringRef, 2> Positional;
872  for (auto Arg : InputArgs.filtered(STRIP_UNKNOWN))
873    return createStringError(errc::invalid_argument, "unknown argument '%s'",
874                             Arg->getAsString(InputArgs).c_str());
875  for (auto Arg : InputArgs.filtered(STRIP_INPUT))
876    Positional.push_back(Arg->getValue());
877
878  if (Positional.empty())
879    return createStringError(errc::invalid_argument, "no input file specified");
880
881  if (Positional.size() > 1 && InputArgs.hasArg(STRIP_output))
882    return createStringError(
883        errc::invalid_argument,
884        "multiple input files cannot be used in combination with -o");
885
886  CopyConfig Config;
887
888  if (InputArgs.hasArg(STRIP_regex) && InputArgs.hasArg(STRIP_wildcard))
889    return createStringError(errc::invalid_argument,
890                             "--regex and --wildcard are incompatible");
891  MatchStyle SectionMatchStyle =
892      InputArgs.hasArg(STRIP_regex) ? MatchStyle::Regex : MatchStyle::Wildcard;
893  MatchStyle SymbolMatchStyle = InputArgs.hasArg(STRIP_regex)
894                                    ? MatchStyle::Regex
895                                    : InputArgs.hasArg(STRIP_wildcard)
896                                          ? MatchStyle::Wildcard
897                                          : MatchStyle::Literal;
898  Config.AllowBrokenLinks = InputArgs.hasArg(STRIP_allow_broken_links);
899  Config.StripDebug = InputArgs.hasArg(STRIP_strip_debug);
900
901  if (InputArgs.hasArg(STRIP_discard_all, STRIP_discard_locals))
902    Config.DiscardMode =
903        InputArgs.hasFlag(STRIP_discard_all, STRIP_discard_locals)
904            ? DiscardType::All
905            : DiscardType::Locals;
906  Config.StripSections = InputArgs.hasArg(STRIP_strip_sections);
907  Config.StripUnneeded = InputArgs.hasArg(STRIP_strip_unneeded);
908  if (auto Arg = InputArgs.getLastArg(STRIP_strip_all, STRIP_no_strip_all))
909    Config.StripAll = Arg->getOption().getID() == STRIP_strip_all;
910  Config.StripAllGNU = InputArgs.hasArg(STRIP_strip_all_gnu);
911  Config.OnlyKeepDebug = InputArgs.hasArg(STRIP_only_keep_debug);
912  Config.KeepFileSymbols = InputArgs.hasArg(STRIP_keep_file_symbols);
913
914  for (auto Arg : InputArgs.filtered(STRIP_keep_section))
915    if (Error E = Config.KeepSection.addMatcher(NameOrPattern::create(
916            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
917      return std::move(E);
918
919  for (auto Arg : InputArgs.filtered(STRIP_remove_section))
920    if (Error E = Config.ToRemove.addMatcher(NameOrPattern::create(
921            Arg->getValue(), SectionMatchStyle, ErrorCallback)))
922      return std::move(E);
923
924  for (auto Arg : InputArgs.filtered(STRIP_strip_symbol))
925    if (Error E = Config.SymbolsToRemove.addMatcher(NameOrPattern::create(
926            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
927      return std::move(E);
928
929  for (auto Arg : InputArgs.filtered(STRIP_keep_symbol))
930    if (Error E = Config.SymbolsToKeep.addMatcher(NameOrPattern::create(
931            Arg->getValue(), SymbolMatchStyle, ErrorCallback)))
932      return std::move(E);
933
934  if (!InputArgs.hasArg(STRIP_no_strip_all) && !Config.StripDebug &&
935      !Config.StripUnneeded && Config.DiscardMode == DiscardType::None &&
936      !Config.StripAllGNU && Config.SymbolsToRemove.empty())
937    Config.StripAll = true;
938
939  if (Config.DiscardMode == DiscardType::All)
940    Config.StripDebug = true;
941
942  Config.DeterministicArchives =
943      InputArgs.hasFlag(STRIP_enable_deterministic_archives,
944                        STRIP_disable_deterministic_archives, /*default=*/true);
945
946  Config.PreserveDates = InputArgs.hasArg(STRIP_preserve_dates);
947  Config.InputFormat = FileFormat::Unspecified;
948  Config.OutputFormat = FileFormat::Unspecified;
949
950  DriverConfig DC;
951  if (Positional.size() == 1) {
952    Config.InputFilename = Positional[0];
953    Config.OutputFilename =
954        InputArgs.getLastArgValue(STRIP_output, Positional[0]);
955    DC.CopyConfigs.push_back(std::move(Config));
956  } else {
957    StringMap<unsigned> InputFiles;
958    for (StringRef Filename : Positional) {
959      if (InputFiles[Filename]++ == 1) {
960        if (Filename == "-")
961          return createStringError(
962              errc::invalid_argument,
963              "cannot specify '-' as an input file more than once");
964        if (Error E = ErrorCallback(createStringError(
965                errc::invalid_argument, "'%s' was already specified",
966                Filename.str().c_str())))
967          return std::move(E);
968      }
969      Config.InputFilename = Filename;
970      Config.OutputFilename = Filename;
971      DC.CopyConfigs.push_back(Config);
972    }
973  }
974
975  if (Config.PreserveDates && (is_contained(Positional, "-") ||
976                               InputArgs.getLastArgValue(STRIP_output) == "-"))
977    return createStringError(errc::invalid_argument,
978                             "--preserve-dates requires a file");
979
980  return std::move(DC);
981}
982
983} // namespace objcopy
984} // namespace llvm
985