[lld-macho] Specify the complete set of command-line options for ld64

[gkm]

Summary

This is a complete Options.td compiled from ld(1) dated 2018-03-07 and cross checked with ld64 source code version 512.4 dated 2018-03-18.

This is the first in a series of diffs for argument handling. Follow-ups will include switch cases for all the new instances of OPT_foo, and parsing/validation of arguments attached to options, e.g., more code akin to OPT_platform_version and associated parsePlatformVersion().

Test Plan: check-lld

[gkm]

lld/MachO/Options.td

5

I notice that the --help output sorts option groups alphabetically by the group's HelpText. That's not so great. I would rather see the groups presented in the order listed here in Options.td.

Two remedies:

1. hack the help generator to preserve source order--as new behavior? as an option?--or
2. prefix each HelpText with a sequence number or letter so the sorting preserves desired order.

Preference?

[smeenai]

Will review this in detail later, but quick question: how is this handling erroring for options which are in the .td but aren't implemented yet?

[gkm]

Issue a variety of warnings about unhandled options

[gkm]

add usageError() to report any option's expected args

[gkm]

• check that an option group is valid before getting its ID
• always warn about deprecated options, even when handled

[gkm]

• fix clang-tidy warnings, mostly pertaining to pushing camelCase over snake_case

[gkm]

• fix another clang-tidy warning for camelCase over snake_case

[gkm]

• add current-version.test
• use StringRef::split() instead of llvm::SplitString() for better handling of empty fields between '.' separators
• reject empty and excess version# components
• fix calculation of bit width for the first version component

[gkm]

• s/platform/platformNum/ for clarity

[gkm]

rebase

[smeenai]

This is a complete Options.td compiled from ld(1) dated 2018-03-07 and cross checked with ld64 source code version 512.4 dated 2018-03-18.

Out of curiosity, where are you getting these dates from? I'd imagine 512.4 to be much more recent than that.

Follow-ups will include switch cases for all the new instances of OPT_foo

Could you elaborate on what you mean by this?

Gathering all the options and producing the TableGen is a pretty huge effort. Thanks for doing this!

Can you add a test for some of the deprecated, obsolete, unimplemented, etc. options to ensure we give the right messages for them?

lld/MachO/Driver.cpp

80

Nit: for boolean arguments, it's conventional to include the name of the argument as a comment, i.e. /*ShowHidden=*/false in this case.

247–353

I think something like components or parts or numComponents or numParts would be clearer than capacity.

248

This should return an llvm::Expected instead of a boolean, which would also allow you to have different error messages for the various parse failures.

My understanding is that the packing is needed because that's how the corresponding load commands are written out. In that case, I'd argue that there's multiple concerns going on in this function. Ideally this would only parse the version out into a tuple, and then the packing would be a separate function in the writer that's called when you're writing out the load command. The other advantage of that would be that if we need to make decisions based on these values, a tuple is a lot easier to process than a packed value. (E.g. ld64 emits either an LC_BUILD_VERSION or an LC_VERSION_MIN_MACOSX depending on your minimum version.)

250

Nit: why the + 1? Is it just to account for potentially erroneous input?

252

LLD isn't a big fan of auto. I'd just use an explicit size_t (or if you get rid of the < 1 check below, you can inline the call to size and avoid the variable entirely :D).

253

Is it ever possible for the count to be less than 1? Wouldn't that just be an error in split?

293

The error message output here isn't particularly helpful right now. llvm::Expected should let us address that.

294

I would imagine the semantics would be storing the result in the Config and then outputting the appropriate load command in the writer?

298

Super nit: use a DenseMap of StringRef instead. See https://llvm.org/docs/ProgrammersManual.html#other-map-like-container-options.

318

We should give a specific error message.

327

I'm torn about referencing ld64 in these messages. On the one hand, it is the motivation for our behavior. On the other hand, all our users might not know what ld64 is (or at least know it by that name), or they might be confused why LLD is giving error messages that reference ld64.

I'm leaning towards just making these say "is deprecated" instead of "is deprecated in ld64". What do you think?

341

Typo: lld

393–403

Nit: not that it should matter at all, but can this be const?

401

Nit: have the default at the end.

lld/MachO/Options.td

5

I'm not well versed enough with OptTable to say. @MaskRay, do you have thoughts on this?

156

This is really neat! Today I learned about MultiArg.

lld/test/MachO/platform-version.test

47

I wouldn't add this check, since it's not the main point of the test, and it won't be produced if we bail out early on input argument errors.

[thakis]

Taking a step back: Maybe it makes sense to only add flags that people ask for? For example, I'm guessing nobody needs Xcode 3 and earlier flags any more. That's also the strategy that the elf and coff ports went for, and I feel it's worked fairly well there.

[smeenai]

In D80582#2068604, @thakis wrote:

Taking a step back: Maybe it makes sense to only add flags that people ask for? For example, I'm guessing nobody needs Xcode 3 and earlier flags any more. That's also the strategy that the elf and coff ports went for, and I feel it's worked fairly well there.

@gkm can chime in here as well, but my understanding was that we were only planning to add the actual support for flags once there was a use case. There's some nice things we get from having the entirety of ld64's interface expressed in our tablegen though:

• It gives a crude sense of our completeness, in terms of how many ld64 options we support.
• We can emit nicer diagnostics that distinguish between options we don't support yet, options that are deprecated and we're therefore unlikely to ever support, and options that are just completely invalid.
• It sets up the scaffolding to easily add support for more options later (since they'll already be in the tablegen).

There's some downsides though:

• Our --help output might become overwhelming, especially when most of it is currently unsupported options. We could hide unsupported options from the help output, or else group the help output in a way that makes the supported/unsupported status clear.
• For some options, we're likely never going to support them (e.g. the Xcode 3 and earlier flags, like you said). There's also some options that we're realistically not planning to support any time soon (although contributions are most welcome, of course). The only purpose the TableGen entries for those are serving is to get nicer diagnostics.
• Options.td gets a bit cluttered, though we can e.g. organize it along supported/unsupported categories to make it easier to read.

Does that make sense to you?

[aaron.ballman]

lld/MachO/Options.td

524

How about: Lists which dylibs and frameworks by <name> that are allowed to link to this dylib or something along those lines?

[gkm]

• Unimplemented options get Flags<[HelpHidden]> in lld/MachO/Options.td
• Retain only core changes to Options.td + diagnostic infra - future diffs will implement particular options

[gkm]

lld/MachO/Driver.cpp

248

I am deferring to @compnerd's D81413 for -platform-version improvements , so am removing my changes from this diff.

250

Yes: if there are excess components, this will allow split to detect them.

294

Yes

327

How about saying "... is deprecated by Apple"?

lld/test/MachO/platform-version.test

47

The complaint about undefined _main happens after the arg-parsing phase, by expecting it, we are asserting that no unexpected diagnostic appears during arg parsing.
What do you recommend as an alternative method?

[smeenai]

HelpHidden assuages my primary user-facing concern about the help text :)

There's a bunch of options we're in all probability going to *never* support, e.g. the Obj-C GC ones, since Obj-C GC is completely unsupported now. I don't know if it's better to remove them entirely or have a different category of "options that LLD will never support", but we can figure that out later.

lld/MachO/Driver.cpp

250

Makes sense, although to be clear, the template argument for a SmallVector is the number of elements that can be inlined. The SmallVector can still grow beyond that; its storage will just need to be heap allocated.

327

That's technically true, but I also feel a bit uncomfortable speaking on behalf of another company :/

369

Nit: indicate the name of the boolean parameter as a comment, as in /*helpHidden=*/true

372

Same here.

lld/MachO/Options.td

7

You should double check this date ... I'm pretty sure 512.4 is more recent than that.

lld/test/MachO/platform-version.test

47

I misunderstood what you were testing here. This makes sense.

[gkm]

• Incorporate review feedback. Approved & ready to land!

[gkm]

lld/MachO/Options.td

7

Perhaps the release date was later, but the date on the git tag 512.4 is as stated.

From the ld64 source tree at https://github.com/apple-opensource/ld64:

$ git show 512.4 |head
tag 512.4
Tagger: Apple Open Source <[e-mail]>
Date:   Wed Mar 18 21:18:04 2020 +0000

512.4
-----BEGIN PGP SIGNATURE-----
. . .

[tschuett]

https://opensource.apple.com/source/ld64/ld64-530/doc/man/man1/ld.1.auto.html
https://opensource.apple.com/source/ld64/ld64-530/

The latest open source version is at 530 and the date of the man page is also March 7, 2018.
My ld64 is version 556.6 and the man page did not change since March 7, 2018.

lld/MachO/Driver.h

 
 namespace lld {
 namespace macho {
 
 class MachOOptTable : public llvm::opt::OptTable {
 public:
   MachOOptTable();
   llvm::opt::InputArgList parse(ArrayRef<const char *> argv);
+  void printHelp(const char *argv0);
 };
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Driver.cpp

 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 
+#include <unordered_map>
+
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::sys;
 using namespace lld;
 using namespace lld::macho;
 
 Configuration *lld::macho::config;
 
opt::InputArgList MachOOptTable::parse(ArrayRef<const char *> argv) {
   if (missingCount)
     error(Twine(args.getArgString(missingIndex)) + ": missing argument");
 
   for (opt::Arg *arg : args.filtered(OPT_UNKNOWN))
     error("unknown argument: " + arg->getSpelling());
   return args;
 }
 
+void MachOOptTable::printHelp(const char *argv0) {
+  PrintHelp(lld::outs(), (std::string(argv0) + " [options] file...").c_str(),
+            "LLVM Linker", false);
+  lld::outs() << "\n";
+}
+
 // This is for -lfoo. We'll look for libfoo.dylib from search paths.
 static Optional<std::string> findDylib(StringRef name) {
   for (StringRef dir : config->searchPaths) {
     std::string path = (dir + "/lib" + name + ".dylib").str();
     if (fs::exists(path))
       return path;
   }
   error("library not found for -l" + name);

 //
 // <arch> and <object file> are optional. If not specified, then that entry
 // matches any symbol of that name.
 //
 // If a symbol is matched by multiple entries, then it takes the lowest-ordered
 // entry (the one nearest to the front of the list.)
 //
 // The file can also have line comments that start with '#'.
-void parseOrderFile(StringRef path) {
+static void parseOrderFile(StringRef path) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer) {
     error("Could not read order file at " + path);
     return;
   }
 
   MemoryBufferRef mbref = *buffer;
   size_t priority = std::numeric_limits<size_t>::max();
if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
         dylibFile->reexport = true;
         return true;
       }
     }
   }
   return false;
 }
 
-static void handlePlatformVersion(opt::ArgList::iterator &it,
-                                  const opt::ArgList::iterator &end) {
-  // -platform_version takes 3 args, which LLVM's option library doesn't
-  // support directly.  So this explicitly handles that.
-  // FIXME: stash skipped args for later use.
-  for (int i = 0; i < 3; ++i) {
-    ++it;
-    if (it == end || (*it)->getOption().getID() != OPT_INPUT)
-      fatal("usage: -platform_version platform min_version sdk_version");
+template <typename UI, int capacity, int width>
+static bool parsePackedVersion(StringRef str, UI &result) {
+  result = 0;
+  SmallVector<StringRef, capacity + 1> parts;
+  str.split(parts, '.', capacity, true);
+  auto count = parts.size();
+  if (count < 1 || capacity < count)
+    return true;
+
+  // The first version-number component uses all of the highest-order
+  // bits remaining after bits have been allocated for the lower-order
+  // version components.
+  unsigned long long maxNum =
+      (1 << (std::numeric_limits<UI>::digits - ((capacity - 1) * width)));
+  for (StringRef str : parts) {
+    unsigned long long num;
+    if (llvm::getAsUnsignedInteger(str, 10, num))
+      return true;
+    if (num >= maxNum)
+      return true;
+    maxNum = (1 << width); // max for the lower-order components
+    result |= num;
+    result <<= width;
+  }
+  result <<= (width * (capacity - count));
+
+  return false;
+}
+
+static bool parsePackedVersion32(StringRef str, uint32_t &result) {
+  return parsePackedVersion<uint32_t, 3, 8>(str, result);
+}
+
+static bool parsePackedVersion64(StringRef str, uint64_t &result) {
+  return parsePackedVersion<uint64_t, 5, 10>(str, result);
+}
+
+static void usageError(const opt::Arg *arg) {
+  const auto &opt = arg->getOption();
+  error("usage: " + opt.getPrefixedName() + " " + opt.getMetaVar());
+}
+
+static void parseCurrentVersion(const opt::Arg *arg) {
+  const char *sourceVersionStr = arg->getValue(0);
+  uint64_t sourceVersion;
+  if (parsePackedVersion64(sourceVersionStr, sourceVersion))
+    usageError(arg);
+  // FIXME: add semantics
+}
+
+static void parsePlatformVersion(const opt::Arg *arg) {
+  static const std::unordered_map<std::string, int> platforms = {
+      {"macos", 1},       {"ios", 2},          {"tvos", 3},    {"watchos", 4},
+      {"bridgeos", 5},    {"mac-catalyst", 6}, {"ios-sim", 7}, {"tvos-sim", 8},
+      {"watchos-sim", 9}, {"driverkit", 10},
+  };
+
+  const char *platformStr = arg->getValue(0);
+  const char *minVersionStr = arg->getValue(1);
+  const char *sdkVersionStr = arg->getValue(2);
+  unsigned long long platformNum;
+  uint32_t minVersion;
+  uint32_t sdkVersion;
+
+  if (!llvm::getAsUnsignedInteger(platformStr, 10, platformNum)) {
+    const auto &p = platforms.find(platformStr);
+    platformNum = (p == platforms.end() ? 0 : p->second);
+  }
+  if (parsePackedVersion32(minVersionStr, minVersion) ||
+      parsePackedVersion32(sdkVersionStr, sdkVersion) || platformNum < 1 ||
+      platformNum > 10) {
+    usageError(arg);
+  }
+  // FIXME: add semantics
+}
+
+static void warnIfDeprecatedOption(const opt::Option &opt) {
+  if (!opt.getGroup().isValid())
+    return;
+  if (opt.getGroup().getID() == OPT_grp_deprecated) {
+    warn("Option `" + opt.getPrefixedName() + "' is deprecated in ld64:");
+    warn(opt.getHelpText());
+  }
+}
+
+static void warnIfUnimplementedOption(const opt::Option &opt) {
+  if (!opt.getGroup().isValid())
+    return;
+  switch (opt.getGroup().getID()) {
+  case OPT_grp_deprecated:
+    // warn about deprecated options elsewhere
+    break;
+  case OPT_grp_undocumented:
+    warn("Option `" + opt.getPrefixedName() +
+         "' is undocumented for ld64. Should ldd implement it?");
+    break;
+  case OPT_grp_obsolete:
+    warn("Option `" + opt.getPrefixedName() +
+         "' is obsolete in ld64. Please modernize your usage");
+    break;
+  case OPT_grp_ignored:
+    warn("Option `" + opt.getPrefixedName() + "' is ignored in ld64");
+    break;
+  default:
+    warn("Option `" + opt.getPrefixedName() +
+         "' is not yet implemented. Stay tuned...");
+    break;
   }
 }
 
 bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
                  raw_ostream &stdoutOS, raw_ostream &stderrOS) {
   lld::stdoutOS = &stdoutOS;
   lld::stderrOS = &stderrOS;
 
   stderrOS.enable_colors(stderrOS.has_colors());
   // TODO: Set up error handler properly, e.g. the errorLimitExceededMsg
 
   MachOOptTable parser;
   opt::InputArgList args = parser.parse(argsArr.slice(1));
 
+  if (args.hasArg(OPT_help)) {
+    parser.printHelp(argsArr[0]);
+    return 0;
+  }
+
   config = make<Configuration>();
   symtab = make<SymbolTable>();
   target = createTargetInfo(args);
 
   config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"));
   config->outputFile = args.getLastArgValue(OPT_o, "a.out");
   config->installName =
       args.getLastArgValue(OPT_install_name, config->outputFile);
   config->searchPaths = getSearchPaths(args);
   config->outputType = args.hasArg(OPT_dylib) ? MH_DYLIB : MH_EXECUTE;
 
   if (args.hasArg(OPT_v)) {
     message(getLLDVersion());
     std::vector<StringRef> &searchPaths = config->searchPaths;
     message("Library search paths:\n" +
             llvm::join(searchPaths.begin(), searchPaths.end(), "\n"));
     freeArena();
     return !errorCount();
   }
 
-  for (opt::ArgList::iterator it = args.begin(), end = args.end(); it != end;
-       ++it) {
-    const opt::Arg *arg = *it;
-    switch (arg->getOption().getID()) {
+  for (auto &arg : args) {
+    const auto &opt = arg->getOption();
+    warnIfDeprecatedOption(opt);
+    switch (opt.getID()) {
+    case OPT_o:
+    case OPT_dylib:
+      // handled elsewhere ...
+      break;
+    default:
+      warnIfUnimplementedOption(opt);
+      break;
     case OPT_INPUT:
       addFile(arg->getValue());
       break;
     case OPT_l:
       if (Optional<std::string> path = findDylib(arg->getValue()))
         addFile(*path);
       break;
-    case OPT_platform_version: {
-      handlePlatformVersion(it, end); // Can advance "it".
+    case OPT_current_version:
+      parseCurrentVersion(arg);
+      break;
+    case OPT_platform_version:
+      parsePlatformVersion(arg);
       break;
-    }
     }
   }
 
   // Now that all dylibs have been loaded, search for those that should be
   // re-exported.
   for (opt::Arg *arg : args.filtered(OPT_sub_library)) {
     config->hasReexports = true;
     StringRef searchName = arg->getValue();

lld/MachO/Options.td

 include "llvm/Option/OptParser.td"
 
-def L: JoinedOrSeparate<["-"], "L">, MetaVarName<"<dir>">,
-  HelpText<"Add directory to library search path">;
+def help : Flag<["-", "--"], "help">;
 
-def Z: Flag<["-"], "Z">,
-  HelpText<"Do not add standard directories to library search path">;
-
-def arch: Separate<["-"], "arch">, MetaVarName<"<arch-name>">,
-  HelpText<"Architecture to link">;
-
-def dylib: Flag<["-"], "dylib">, HelpText<"Emit a shared library">;
-
-def e: Separate<["-"], "e">, HelpText<"Name of entry point symbol">;
-
-def install_name: Separate<["-"], "install_name">,
-  MetaVarName<"<install-name>">,
-  HelpText<"Set the install path of the dynamic library.">;
-
-def l: Joined<["-"], "l">, MetaVarName<"<libname>">,
-  HelpText<"Base name of library searched for in -L directories">;
-
-def o: Separate<["-"], "o">, MetaVarName<"<path>">,
-  HelpText<"Path to file to write output">;
+def grp_kind : OptionGroup<"kind">, HelpText<"OUTPUT KIND">;
 
-def order_file: Separate<["-"], "order_file">,
-  HelpText<"Lay out symbols within each section in the order specified by the "
-           "order file">;
+def execute : Flag<["-"], "execute">,
+     HelpText<"Produce a main executable (default)">,
+     Group<grp_kind>;
+def dylib : Flag<["-"], "dylib">,
+     HelpText<"Produce a shared library">,
+     Group<grp_kind>;
+def bundle : Flag<["-"], "bundle">,
+     HelpText<"Produce a bundle">,
+     Group<grp_kind>;
+def r : Flag<["-"], "r">,
+     HelpText<"Merge multiple object files into one, retaining relocations">,
+     Group<grp_kind>;
+def dylinker : Flag<["-"], "dylinker">,
+     HelpText<"Produce a dylinker only used when building dyld">,
+     Group<grp_kind>;
+def dynamic : Flag<["-"], "dynamic">,
+     HelpText<"Link dynamically (default)">,
+     Group<grp_kind>;
+def static : Flag<["-"], "static">,
+     HelpText<"Link statically">,
+     Group<grp_kind>;
+def preload : Flag<["-"], "preload">,
+     HelpText<"Produce an unsegmented binary for embedded systems">,
+     Group<grp_kind>;
+def arch : Separate<["-"], "arch">,
+     MetaVarName<"<arch_name>">,
+     HelpText<"The architecture (e.g. ppc, ppc64, i386, x86_64)">,
+     Group<grp_kind>;
+def o : Separate<["-"], "o">,
+     MetaVarName<"<path>">,
+     HelpText<"The name of the output file (default: `a.out')">,
+     Group<grp_kind>;
+
+def grp_libs : OptionGroup<"libs">, HelpText<"LIBRARIES">;
+
+def l : Joined<["-"], "l">,
+     MetaVarName<"<name>">,
+     HelpText<"Search for lib<name>.dylib or lib<name>.a on the library search path">,
+     Group<grp_libs>;
+def weak_l : Joined<["-"], "weak-l">,
+     MetaVarName<"<name>">,
+     HelpText<"Like -l<name>, but mark library and its references as weak imports">,
+     Group<grp_libs>;
+def weak_library : Separate<["-"], "weak_library">,
+     MetaVarName<"<path>">,
+     HelpText<"Like bare <path>, but mark library and its references as weak imports">,
+     Group<grp_libs>;
+def reexport_l : Joined<["-"], "reexport-l">,
+     MetaVarName<"<name>">,
+     HelpText<"Like -l<name>, but export all symbols of <name> from newly created library">,
+     Group<grp_libs>;
+def reexport_library : Separate<["-"], "reexport_library">,
+     MetaVarName<"<path>">,
+     HelpText<"Like bare <path>, but export all symbols of <path> from newly created library">,
+     Group<grp_libs>;
+def upward_l : Joined<["-"], "upward-l">,
+     MetaVarName<"<name>">,
+     HelpText<"Like -l<name>, but specify dylib as an upward dependency">,
+     Group<grp_libs>;
+def upward_library : Separate<["-"], "upward_library">,
+     MetaVarName<"<path>">,
+     HelpText<"Like bare <path>, but specify dylib as an upward dependency">,
+     Group<grp_libs>;
+def L : JoinedOrSeparate<["-"], "L">,
+     MetaVarName<"<dir>">,
+     HelpText<"Add dir to the library search path">,
+     Group<grp_libs>;
+def Z : Flag<["-"], "Z">,
+     HelpText<"Remove standard directories from the library and framework search paths">,
+     Group<grp_libs>;
+def syslibroot : Separate<["-"], "syslibroot">,
+     MetaVarName<"<rootdir>">,
+     HelpText<"Prepend <rootdir> to all library and framework search paths">,
+     Group<grp_libs>;
+def search_paths_first : Flag<["-"], "search_paths_first">,
+     HelpText<"Search for lib<name>.dylib and lib<name>.a at each step in traversing search path (default for Xcode 4 and later)">,
+     Group<grp_libs>;
+def search_dylibs_first : Flag<["-"], "search_dylibs_first">,
+     HelpText<"Search for lib<name>.dylib on first pass, then for lib<name>.a on second pass through search path (default for Xcode 3 and earlier)">,
+     Group<grp_libs>;
+def framework : Separate<["-"], "framework">,
+     MetaVarName<"<name>">,
+     HelpText<"Search for <name>.framework/<name> on the framework search path">,
+     Group<grp_libs>;
+def weak_framework : Separate<["-"], "weak_framework">,
+     MetaVarName<"<name>">,
+     HelpText<"Like -framework <name>, but mark framework and its references as weak imports">,
+     Group<grp_libs>;
+def reexport_framework : Separate<["-"], "reexport_framework">,
+     MetaVarName<"<name>">,
+     HelpText<"Like -framework <name>, but export all symbols of <name> from the newly created library">,
+     Group<grp_libs>;
+def upward_framework : Separate<["-"], "upward_framework">,
+     MetaVarName<"<name>">,
+     HelpText<"Like -framework <name>, but specify the framework as an upward dependency">,
+     Group<grp_libs>;
+def F : JoinedOrSeparate<["-"], "F">,
+     MetaVarName<"<dir>">,
+     HelpText<"Add dir to the framework search path">,
+     Group<grp_libs>;
+def all_load : Flag<["-"], "all_load">,
+     HelpText<"Load all members of all static archive libraries">,
+     Group<grp_libs>;
+def ObjC : Flag<["-"], "ObjC">,
+     HelpText<"Load all members of static archives that are an Objective-C class or category.">,
+     Group<grp_libs>;
+def force_load : Separate<["-"], "force_load">,
+     MetaVarName<"<path>">,
+     HelpText<"Load all members static archive library at <path>">,
+     Group<grp_libs>;
+
+def grp_content : OptionGroup<"content">, HelpText<"ADDITIONAL CONTENT">;
+
+def sectcreate : MultiArg<["-"], "sectcreate", 3>,
+     MetaVarName<"<segment> <section> <file>">,
+     HelpText<"Create <section> in <segment> from the contents of <file>">,
+     Group<grp_content>;
+def segcreate : MultiArg<["-"], "segcreate", 3>,
+     MetaVarName<"<segment> <section> <file>">,
+     Alias<sectcreate>,
+     HelpText<"Alias for -sectcreate">;
+def filelist : Separate<["-"], "filelist">,
+     MetaVarName<"<file>">,
+     HelpText<"Read names of files to link from <file>">,
+     Group<grp_content>;
+def dtrace : Separate<["-"], "dtrace">,
+     MetaVarName<"<script>">,
+     HelpText<"Enable DTrace static probes according to declarations in <script>">,
+     Group<grp_content>;
+
+def grp_opts : OptionGroup<"opts">, HelpText<"OPTIMIZATIONS">;
+
+def dead_strip : Flag<["-"], "dead_strip">,
+     HelpText<"Remove unreachable functions and data">,
+     Group<grp_opts>;
+def order_file : Separate<["-"], "order_file">,
+     MetaVarName<"<file>">,
+     HelpText<"Layout functions and data according to specification in <file>">,
+     Group<grp_opts>;
+def sectorder : MultiArg<["-"], "sectorder", 3>,
+     MetaVarName<"<segname> <sectname> <orderfile>">,
+     HelpText<"Replaced by more general -order_file option">,
+     Group<grp_opts>;
+def no_order_inits : Flag<["-"], "no_order_inits">,
+     HelpText<"Disable default reordering of initializer and terminator functions">,
+     Group<grp_opts>;
+def no_order_data : Flag<["-"], "no_order_data">,
+     HelpText<"Disable default reordering of global data accessed at launch time">,
+     Group<grp_opts>;
+def platform_version : MultiArg<["-"], "platform_version", 3>,
+     MetaVarName<"<platform> <min_version> <sdk_version>">,
+     HelpText<"Platform (e.g., macos, ios, tvos, watchos, bridgeos, mac-catalyst, ios-sim, tvos-sim, watchos-sim, driverkit) and version numbers">,
+     Group<grp_opts>;
+def macos_version_min : Separate<["-"], "macos_version_min">,
+     MetaVarName<"<version>">,
+     HelpText<"Oldest macOS version for which linked output is useable">,
+     Group<grp_opts>;
+def macosx_version_min : Separate<["-"], "macosx_version_min">,
+     MetaVarName<"<version>">,
+     Alias<macos_version_min>,
+     HelpText<"Alias for -macos_version_min">;
+def ios_version_min : Separate<["-"], "ios_version_min">,
+     MetaVarName<"<version>">,
+     HelpText<"Oldest iOS version for which linked output is useable">,
+     Group<grp_opts>;
+def iphoneos_version_min : Separate<["-"], "iphoneos_version_min">,
+     MetaVarName<"<version>">,
+     Alias<ios_version_min>,
+     HelpText<"Alias for -ios_version_min">;
+def image_base : Separate<["-"], "image_base">,
+     MetaVarName<"<address>">,
+     HelpText<"Preferred hex load address for a dylib or bundle.">,
+     Group<grp_opts>;
+def seg1addr : Separate<["-"], "seg1addr">,
+     MetaVarName<"<address>">,
+     Alias<image_base>,
+     HelpText<"Alias for -image_base">;
+def no_implicit_dylibs : Flag<["-"], "no_implicit_dylibs">,
+     HelpText<"Do not optimize public dylib transitive symbol references">,
+     Group<grp_opts>;
+def exported_symbols_order : Separate<["-"], "exported_symbols_order">,
+     MetaVarName<"<file>">,
+     HelpText<"Specify frequently-used symbols in <file> to optimize symbol exports">,
+     Group<grp_opts>;
+def no_zero_fill_sections : Flag<["-"], "no_zero_fill_sections">,
+     HelpText<"Explicitly store zeroed data in the final image">,
+     Group<grp_opts>;
+def merge_zero_fill_sections : Flag<["-"], "merge_zero_fill_sections">,
+     HelpText<"Merge all zeroed data into the __zerofill section">,
+     Group<grp_opts>;
+def no_branch_islands : Flag<["-"], "no_branch_islands">,
+     HelpText<"Disable infra for branches beyond the maximum branch distance.">,
+     Group<grp_opts>;
 
-def sub_library: Separate<["-"], "sub_library">, MetaVarName<"<libname>">,
-  HelpText<"Re-export the specified dylib">;
+def grp_dylib : OptionGroup<"dylib">, HelpText<"DYNAMIC LIBRARIES (DYLIB)">;
 
-def v: Flag<["-"], "v">, HelpText<"Display the version number and exit">;
-
-// Ignored options
-def: Flag<["-"], "demangle">;
-def: Flag<["-"], "dynamic">;
-def: Flag<["-"], "no_deduplicate">;
-def platform_version: Flag<["-"], "platform_version">;
-def: Separate<["-"], "lto_library">;
-def: Separate<["-"], "macosx_version_min">;
-def: Separate<["-"], "syslibroot">;
+def install_name : Separate<["-"], "install_name">,
+     MetaVarName<"<name>">,
+     HelpText<"Set an internal install path in a dylib">,
+     Group<grp_dylib>;
+def dylib_install_name : Separate<["-"], "dylib_install_name">,
+     MetaVarName<"<name>">,
+     Alias<install_name>,
+     HelpText<"Alias for -install_name">;
+def dylinker_install_name : Separate<["-"], "dylinker_install_name">,
+     MetaVarName<"<name>">,
+     Alias<install_name>,
+     HelpText<"Alias for -install_name">;
+def mark_dead_strippable_dylib : Flag<["-"], "mark_dead_strippable_dylib">,
+     HelpText<"Clients can discard this dylib if it is unreferenced">,
+     Group<grp_dylib>;
+def compatibility_version : Separate<["-"], "compatibility_version">,
+     MetaVarName<"<version>">,
+     HelpText<"Compatibility <version> of this library">,
+     Group<grp_dylib>;
+def dylib_compatibility_version : Separate<["-"], "dylib_compatibility_version">,
+     MetaVarName<"<version>">,
+     Alias<compatibility_version>,
+     HelpText<"Alias for -compatibility_version">;
+def current_version : Separate<["-"], "current_version">,
+     MetaVarName<"<version>">,
+     HelpText<"Current <version> of this library">,
+     Group<grp_dylib>;
+def dylib_current_version : Separate<["-"], "dylib_current_version">,
+     MetaVarName<"<version>">,
+     Alias<current_version>,
+     HelpText<"Alias for -current_version">;
+
+def grp_main : OptionGroup<"main">, HelpText<"MAIN EXECUTABLE">;
+
+def pie : Flag<["-"], "pie">,
+     HelpText<"Build a position independent executable (default for macOS 10.7 and later)">,
+     Group<grp_main>;
+def no_pie : Flag<["-"], "no_pie">,
+     HelpText<"Do not build a position independent executable (default for macOS 10.6 and earlier)">,
+     Group<grp_main>;
+def pagezero_size : Separate<["-"], "pagezero_size">,
+     MetaVarName<"<size>">,
+     HelpText<"Size of unreadable segment at address zero is hex <size> (default is 4KB on 32-bit and 4GB on 64-bit)">,
+     Group<grp_main>;
+def stack_size : Separate<["-"], "stack_size">,
+     MetaVarName<"<size>">,
+     HelpText<"Maximum hex stack size for the main thread in a program. (default is 8MB)">,
+     Group<grp_main>;
+def allow_stack_execute : Flag<["-"], "allow_stack_execute">,
+     HelpText<"Mark stack segment as executable">,
+     Group<grp_main>;
+def export_dynamic : Flag<["-"], "export_dynamic">,
+     HelpText<"Preserve all global symbols during LTO">,
+     Group<grp_main>;
+
+def grp_bundle : OptionGroup<"bundle">, HelpText<"CREATING A BUNDLE">;
+
+def bundle_loader : Separate<["-"], "bundle_loader">,
+     MetaVarName<"<executable>">,
+     HelpText<"Resolve undefined symbols from <executable>">,
+     Group<grp_bundle>;
+
+def grp_object : OptionGroup<"object">, HelpText<"CREATING AN OBJECT FILE">;
+
+def keep_private_externs : Flag<["-"], "keep_private_externs">,
+     HelpText<"Do not convert private external symbols to static symbols">,
+     Group<grp_object>;
+def d : Flag<["-"], "d">,
+     HelpText<"Force tentative into real definitions for common symbols">,
+     Group<grp_object>;
+
+def grp_resolve : OptionGroup<"resolve">, HelpText<"SYMBOL RESOLUTION">;
+
+def exported_symbols_list : Separate<["-"], "exported_symbols_list">,
+     MetaVarName<"<file>">,
+     HelpText<"Symbols specified in <file> remain global, while others become private externs">,
+     Group<grp_resolve>;
+def exported_symbol : Separate<["-"], "exported_symbol">,
+     MetaVarName<"<symbol>">,
+     HelpText<"<symbol> remains global, while others become private externs">,
+     Group<grp_resolve>;
+def unexported_symbols_list : Separate<["-"], "unexported_symbols_list">,
+     MetaVarName<"<file>">,
+     HelpText<"Global symbols specified in <file> become private externs">,
+     Group<grp_resolve>;
+def unexported_symbol : Separate<["-"], "unexported_symbol">,
+     MetaVarName<"<symbol>">,
+     HelpText<"Global <symbol> becomes private extern">,
+     Group<grp_resolve>;
+def reexported_symbols_list : Separate<["-"], "reexported_symbols_list">,
+     MetaVarName<"<file>">,
+     HelpText<"Symbols from dependent dylibs specified in <file> are reexported by this dylib">,
+     Group<grp_resolve>;
+def alias : MultiArg<["-"], "alias", 2>,
+     MetaVarName<"<symbol_name> <alternate_name>">,
+     HelpText<"Create a symbol alias with default global visibility">,
+     Group<grp_resolve>;
+def alias_list : Separate<["-"], "alias_list">,
+     MetaVarName<"<file>">,
+     HelpText<"Create symbol aliases specified in <file>">,
+     Group<grp_resolve>;
+def flat_namespace : Flag<["-"], "flat_namespace">,
+     HelpText<"Resolve symbols from all dylibs, both direct & transitive. Do not record source libraries: dyld must re-search at runtime and use the first definition found">,
+     Group<grp_resolve>;
+def u : Separate<["-"], "u">,
+     MetaVarName<"<symbol>">,
+     HelpText<"Require that <symbol> be defined for the link to succeed">,
+     Group<grp_resolve>;
+def U : Separate<["-"], "U">,
+     MetaVarName<"<symbol>">,
+     HelpText<"Allow <symbol> to have no definition">,
+     Group<grp_resolve>;
+def undefined : Separate<["-"], "undefined">,
+     MetaVarName<"<treatment>">,
+     HelpText<"Handle undefined symbols according to <treatment>: error, warning, suppress, or dynamic_lookup (default is error)">,
+     Group<grp_resolve>;
+def rpath : Separate<["-"], "rpath">,
+     MetaVarName<"<path>">,
+     HelpText<"Add <path> to dyld search list for dylibs with load path prefix `@rpath/'">,
+     Group<grp_resolve>;
+def commons : Separate<["-"], "commons">,
+     MetaVarName<"<treatment>">,
+     HelpText<"Resolve tentative definitions in dylibs according to <treatment>: ignore_dylibs, use_dylibs, error (default is ignore_dylibs)">,
+     Group<grp_resolve>;
+
+def grp_introspect : OptionGroup<"introspect">, HelpText<"INTROSPECTING THE LINKER">;
+
+def why_load : Flag<["-"], "why_load">,
+     HelpText<"Log the symbol that compels loading of each object file from a static library">,
+     Group<grp_introspect>;
+def whyload : Flag<["-"], "whyload">,
+     Alias<why_load>,
+     HelpText<"Alias for -why_load">;
+def why_live : Separate<["-"], "why_live">,
+     MetaVarName<"<symbol>">,
+     HelpText<"Log a chain of references to <symbol>, for use with -dead_strip">,
+     Group<grp_introspect>;
+def print_statistics : Flag<["-"], "print_statistics">,
+     HelpText<"Log the linker's memory and CPU usage">,
+     Group<grp_introspect>;
+def t : Flag<["-"], "t">,
+     HelpText<"Log every file the linker loads: object, archive, and dylib">,
+     Group<grp_introspect>;
+def whatsloaded : Flag<["-"], "whatsloaded">,
+     HelpText<"Logs only the object files the linker loads">,
+     Group<grp_introspect>;
+def order_file_statistics : Flag<["-"], "order_file_statistics">,
+     HelpText<"Logs information about -order_file">,
+     Group<grp_introspect>;
+def map : Separate<["-"], "map">,
+     MetaVarName<"<path>">,
+     HelpText<"Writes all symbols and their addresses to <path>">,
+     Group<grp_introspect>;
+
+def grp_symtab : OptionGroup<"symtab">, HelpText<"SYMBOL TABLE OPTIMIZATIONS">;
+
+def S : Flag<["-"], "S">,
+     HelpText<"Strip debug information (STABS or DWARF) from the output">,
+     Group<grp_symtab>;
+def x : Flag<["-"], "x">,
+     HelpText<"Exclude non-global symbols from the output symbol table">,
+     Group<grp_symtab>;
+def non_global_symbols_strip_list : Separate<["-"], "non_global_symbols_strip_list">,
+     MetaVarName<"<path>">,
+     HelpText<"Specify in <path> the non-global symbols that should be removed from the output symbol table">,
+     Group<grp_symtab>;
+def non_global_symbols_no_strip_list : Separate<["-"], "non_global_symbols_no_strip_list">,
+     MetaVarName<"<path>">,
+     HelpText<"Specify in <path> the non-global symbols that should remain in the output symbol table">,
+     Group<grp_symtab>;
+def oso_prefix : Separate<["-"], "oso_prefix">,
+     MetaVarName<"<path>">,
+     HelpText<"Remove the prefix <path> from OSO symbols in the debug map">,
+     Group<grp_symtab>;
+
+def grp_bitcode : OptionGroup<"bitcode">, HelpText<"BITCODE BUILD FLOW">;
+
+def bitcode_bundle : Flag<["-"], "bitcode_bundle">,
+     HelpText<"Generate an embedded bitcode bundle in the __LLVM,__bundle section of the output">,
+     Group<grp_bitcode>;
+def bitcode_hide_symbols : Flag<["-"], "bitcode_hide_symbols">,
+     HelpText<"With -bitcode_bundle, hide all non-exported symbols from output bitcode bundle.">,
+     Group<grp_bitcode>;
+def bitcode_symbol_map : Separate<["-"], "bitcode_symbol_map">,
+     MetaVarName<"<path>">,
+     HelpText<"Write the bitcode symbol reverse mapping to file <path>, or if a directory, to <path>/UUID.bcsymbolmap">,
+     Group<grp_bitcode>;
+
+def grp_rare : OptionGroup<"rare">, HelpText<"RARELY USED">;
+
+def v : Flag<["-"], "v">,
+     HelpText<"Print the linker version">,
+     Group<grp_rare>;
+def version_details : Flag<["-"], "version_details">,
+     HelpText<"Print the linker version in JSON form">,
+     Group<grp_rare>;
+def no_weak_imports : Flag<["-"], "no_weak_imports">,
+     HelpText<"Fail if any symbols are weak imports, allowed to be NULL at runtime">,
+     Group<grp_rare>;
+def no_deduplicate : Flag<["-"], "no_deduplicate">,
+     HelpText<"Omit the deduplication pass">,
+     Group<grp_rare>;
+def verbose_deduplicate : Flag<["-"], "verbose_deduplicate">,
+     HelpText<"Print function names eliminated by deduplication and the total size of code savings">,
+     Group<grp_rare>;
+def no_inits : Flag<["-"], "no_inits">,
+     HelpText<"Fail if the output contains static initializers">,
+     Group<grp_rare>;
+def no_warn_inits : Flag<["-"], "no_warn_inits">,
+     HelpText<"Suppress warnings for static initializers in the output">,
+     Group<grp_rare>;
+def debug_variant : Flag<["-"], "debug_variant">,
+     HelpText<"Suppress warnings germane to binaries shipping to customers">,
+     Group<grp_rare>;
+def unaligned_pointers : Separate<["-"], "unaligned_pointers">,
+     MetaVarName<"<treatment>">,
+     HelpText<"Handle unaligned pointers in __DATA segments according to <treatment>: warning, error, or suppress (default for arm64e is error, otherwise suppress)">,
+     Group<grp_rare>;
+def dirty_data_list : Separate<["-"], "dirty_data_list">,
+     MetaVarName<"<path>">,
+     HelpText<"Specify data symbols in <path> destined for the __DATA_DIRTY segment">,
+     Group<grp_rare>;
+def max_default_common_align : Separate<["-"], "max_default_common_align">,
+     MetaVarName<"<boundary>">,
+     HelpText<"Reduce maximum alignment for common symbols to a hex power-of-2 <boundary>">,
+     Group<grp_rare>;
+def move_to_rw_segment : MultiArg<["-"], "move_to_rw_segment", 2>,
+     MetaVarName<"<segment> <path>">,
+     HelpText<"Move data symbols listed in <path> to another <segment>">,
+     Group<grp_rare>;
+def move_to_ro_segment : MultiArg<["-"], "move_to_ro_segment", 2>,
+     MetaVarName<"<segment> <path>">,
+     HelpText<"Move code symbols listed in <path> to another <segment>">,
+     Group<grp_rare>;
+def rename_section : MultiArg<["-"], "rename_section", 4>,
+     MetaVarName<"<from_segment> <from_section> <to_segment> <to_section>">,
+     HelpText<"Rename <from_segment>/<from_section> as <to_segment>/<to_section>">,
+     Group<grp_rare>;
+def rename_segment : MultiArg<["-"], "rename_segment", 2>,
+     MetaVarName<"<from_segment> <to_segment>">,
+     HelpText<"Rename <from_segment> as <to_segment>">,
+     Group<grp_rare>;
+def trace_symbol_layout : Flag<["-"], "trace_symbol_layout">,
+     HelpText<"Show where and why symbols move, as specified by -move_to_ro_segment, -move_to_rw_segment, -rename_section, and -rename_segment">,
+     Group<grp_rare>;
+def section_order : MultiArg<["-"], "section_order", 2>,
+     MetaVarName<"<segment> <sections>">,
+     HelpText<"With -preload, specify layout sequence of colon-separated <sections> in <segment>">,
+     Group<grp_rare>;
+def segment_order : Separate<["-"], "segment_order">,
+     MetaVarName<"<colon_separated_segment_list>">,
+     HelpText<"With -preload, specify layout sequence of colon-separated <segments>">,
+     Group<grp_rare>;
+def allow_heap_execute : Flag<["-"], "allow_heap_execute">,
+     HelpText<"On i386, allow any page to execute code">,
+     Group<grp_rare>;
+def application_extension : Flag<["-"], "application_extension">,
+     HelpText<"Designate the linker output as safe for use in an application extension">,
+     Group<grp_rare>;
+def no_application_extension : Flag<["-"], "no_application_extension">,
+     HelpText<"Designate the linker output as unsafe for use in an application extension">,
+     Group<grp_rare>;
+def fatal_warnings : Flag<["-"], "fatal_warnings">,
+     HelpText<"Escalate warnings as errors">,
+     Group<grp_rare>;
+def no_eh_labels : Flag<["-"], "no_eh_labels">,
+     HelpText<"In -r mode, suppress .eh lables in the __eh_frame section">,
+     Group<grp_rare>;
+def warn_compact_unwind : Flag<["-"], "warn_compact_unwind">,
+     HelpText<"Warn for each FDE that cannot compact into the __unwind_info section and must remain in the __eh_frame section">,
+     Group<grp_rare>;
+def warn_weak_exports : Flag<["-"], "warn_weak_exports">,
+     HelpText<"Warn if the linked image contains weak external symbols">,
+     Group<grp_rare>;
+def no_weak_exports : Flag<["-"], "no_weak_exports">,
+     HelpText<"Fail if the linked image contains weak external symbols">,
+     Group<grp_rare>;
+def objc_gc_compaction : Flag<["-"], "objc_gc_compaction">,
+     HelpText<"Mark the Objective-C image as compatible with compacting garbage collection">,
+     Group<grp_rare>;
+def objc_gc : Flag<["-"], "objc_gc">,
+     HelpText<"Verify that all code was compiled with -fobjc-gc or -fobjc-gc-only">,
+     Group<grp_rare>;
+def objc_gc_only : Flag<["-"], "objc_gc_only">,
+     HelpText<"Verify that all code was compiled with -fobjc-gc-only">,
+     Group<grp_rare>;
+def dead_strip_dylibs : Flag<["-"], "dead_strip_dylibs">,
+     HelpText<"Remove dylibs that are unreachable by the entry point or exported symbols">,
+     Group<grp_rare>;
+def allow_sub_type_mismatches : Flag<["-"], "allow_sub_type_mismatches">,
+     HelpText<"Permit mixing objects compiled for different ARM CPU subtypes">,
+     Group<grp_rare>;
+def no_uuid : Flag<["-"], "no_uuid">,
+     HelpText<"Do not generate the LC_UUID load command">,
+     Group<grp_rare>;
+def root_safe : Flag<["-"], "root_safe">,
+     HelpText<"Set the MH_ROOT_SAFE bit in the mach-o header">,
+     Group<grp_rare>;
+def setuid_safe : Flag<["-"], "setuid_safe">,
+     HelpText<"Set the MH_SETUID_SAFE bit in the mach-o header">,
+     Group<grp_rare>;
+def interposable : Flag<["-"], "interposable">,
+     HelpText<"Indirects access to all to exported symbols in a dylib">,
+     Group<grp_rare>;
+def multi_module : Flag<["-"], "multi_module">,
+     Alias<interposable>,
+     HelpText<"Alias for -interposable">;
+def init : Separate<["-"], "init">,
+     MetaVarName<"<symbol>">,
+     HelpText<"Run <symbol> as the first initializer in a dylib">,
+     Group<grp_rare>;
+def sub_library : Separate<["-"], "sub_library">,
+     MetaVarName<"<name>">,
+     HelpText<"Re-export the dylib as <name>">,
+     Group<grp_rare>;
+def sub_umbrella : Separate<["-"], "sub_umbrella">,
+     MetaVarName<"<name>">,
+     HelpText<"Re-export the framework as <name>">,
+     Group<grp_rare>;
+def allowable_client : Separate<["-"], "allowable_client">,
+     MetaVarName<"<name>">,
+     HelpText<"Whitelists dylibs and frameworks by <name> that can link to this dylib">,
+     Group<grp_rare>;
+def client_name : Separate<["-"], "client_name">,
+     MetaVarName<"<name>">,
+     HelpText<"Specifies a <name> this client should match with the -allowable_client <name> in a dependent dylib">,
+     Group<grp_rare>;
+def umbrella : Separate<["-"], "umbrella">,
+     MetaVarName<"<<name>>">,
+     HelpText<"Re-export this dylib through the umbrella framework <name>a">,
+     Group<grp_rare>;
+def headerpad : Separate<["-"], "headerpad">,
+     MetaVarName<"<size>">,
+     HelpText<"Allocate hex <size> extra space for future expansion of the load commands via install_name_tool">,
+     Group<grp_rare>;
+def headerpad_max_install_names : Flag<["-"], "headerpad_max_install_names">,
+     HelpText<"Allocate extra space so all load-command paths can expand to MAXPATHLEN via install_name_tool">,
+     Group<grp_rare>;
+def bind_at_load : Flag<["-"], "bind_at_load">,
+     HelpText<"Tell dyld to bind all symbols at load time, rather than lazily">,
+     Group<grp_rare>;
+def force_flat_namespace : Flag<["-"], "force_flat_namespace">,
+     HelpText<"Tell dyld to use a flat namespace on this executable and all its dependent dylibs & bundles">,
+     Group<grp_rare>;
+def segalign : Separate<["-"], "segalign">,
+     MetaVarName<"<boundary>">,
+     HelpText<"Align all segments to hex power-of-2 <boundary>">,
+     Group<grp_rare>;
+def sectalign : MultiArg<["-"], "sectalign", 3>,
+     MetaVarName<"<segment> <section> <boundary>">,
+     HelpText<"Align <section> within <segment> to hex power-of-2 <boundary>">,
+     Group<grp_rare>;
+def stack_addr : Separate<["-"], "stack_addr">,
+     MetaVarName<"<address>">,
+     HelpText<"Initialize stack pointer to hex <address> rounded to a page boundary">,
+     Group<grp_rare>;
+def segprot : MultiArg<["-"], "segprot", 3>,
+     MetaVarName<"<segment> <max> <init>">,
+     HelpText<"Specifies the <max> and <init> virtual memory protection of <segment> as r/w/x/-seg_addr_table path Specify hex base addresses and dylib install names on successive lines in <path>. This option is obsolete">,
+     Group<grp_rare>;
+def segs_read_write_addr : Separate<["-"], "segs_read_write_addr">,
+     MetaVarName<"<address>">,
+     HelpText<"This option is obsolete">,
+     Group<grp_rare>;
+def segs_read_only_addr : Separate<["-"], "segs_read_only_addr">,
+     MetaVarName<"<address>">,
+     HelpText<"This option is obsolete">,
+     Group<grp_rare>;
+def segaddr : MultiArg<["-"], "segaddr", 2>,
+     MetaVarName<"<segment> <address>">,
+     HelpText<"Specify the starting hex <address> at a 4KiB page boundary for <segment>">,
+     Group<grp_rare>;
+def seg_page_size : MultiArg<["-"], "seg_page_size", 2>,
+     MetaVarName<"<segment> <size>">,
+     HelpText<"Specifies the page <size> for <segment>. Segment size will be a multiple of its page size">,
+     Group<grp_rare>;
+def dylib_file : Separate<["-"], "dylib_file">,
+     MetaVarName<"<install_path:current_path>">,
+     HelpText<"Specify <current_path> as different from where a dylib normally resides at <install_path>">,
+     Group<grp_rare>;
+def prebind : Flag<["-"], "prebind">,
+     HelpText<"This option is obsolete">,
+     Group<grp_rare>;
+def weak_reference_mismatches : Separate<["-"], "weak_reference_mismatches">,
+     MetaVarName<"<treatment>">,
+     HelpText<"Resolve symbol imports of conflicting weakness according to <treatment> as weak, non-weak, or error (default is non-weak)">,
+     Group<grp_rare>;
+def read_only_relocs : Separate<["-"], "read_only_relocs">,
+     MetaVarName<"<treatment>">,
+     HelpText<"Handle relocations that modify read-only pages according to <treatment> of warning, error, or suppress (i.e., allow)">,
+     Group<grp_rare>;
+def force_cpusubtype_ALL : Flag<["-"], "force_cpusubtype_ALL">,
+     HelpText<"Mark binary as runnable on any PowerPC, ignoring any PowerPC cpu requirements encoded in the object files">,
+     Group<grp_rare>;
+def no_arch_warnings : Flag<["-"], "no_arch_warnings">,
+     HelpText<"Suppresses warnings about inputs whose architecture does not match the -arch option">,
+     Group<grp_rare>;
+def arch_errors_fatal : Flag<["-"], "arch_errors_fatal">,
+     HelpText<"Escalate to errors any warnings about inputs whose architecture does not match the -arch option">,
+     Group<grp_rare>;
+def e : Separate<["-"], "e">,
+     MetaVarName<"<symbol>">,
+     HelpText<"Make <symbol> the entry point of an executable (default is \"start\" from crt1.o)">,
+     Group<grp_rare>;
+def w : Flag<["-"], "w">,
+     HelpText<"Suppress all warnings">,
+     Group<grp_rare>;
+def final_output : Separate<["-"], "final_output">,
+     MetaVarName<"<name>">,
+     HelpText<"Specify the dylib install name if -install_name is not used--used by compiler driver for multiple -arch arguments">,
+     Group<grp_rare>;
+def arch_multiple : Flag<["-"], "arch_multiple">,
+     HelpText<"Augment error and warning messages with the architecture name">,
+     Group<grp_rare>;
+def twolevel_namespace_hints : Flag<["-"], "twolevel_namespace_hints">,
+     HelpText<"This option is obsolete">,
+     Group<grp_rare>;
+def dot : Separate<["-"], "dot">,
+     MetaVarName<"<path>">,
+     HelpText<"Write a graph of symbol dependencies to <path> as a .dot file viewable with GraphViz">,
+     Group<grp_rare>;
+def keep_relocs : Flag<["-"], "keep_relocs">,
+     HelpText<"Retain section-based relocation records in the output, which are ignored at runtime by dyld">,
+     Group<grp_rare>;
+def warn_stabs : Flag<["-"], "warn_stabs">,
+     HelpText<"Warn when bad stab symbols inside a BINCL/EINCL prevent optimization">,
+     Group<grp_rare>;
+def warn_commons : Flag<["-"], "warn_commons">,
+     HelpText<"Warn when a tentative definition in an object file matches an external symbol in a dylib, which often means \"extern\" is missing from a variable declaration in a header file">,
+     Group<grp_rare>;
+def read_only_stubs : Flag<["-"], "read_only_stubs">,
+     HelpText<"On i386, make the __IMPORT segment of a final linked image read-only">,
+     Group<grp_rare>;
+def slow_stubs : Flag<["-"], "slow_stubs">,
+     HelpText<"This option is obsolete">,
+     Group<grp_rare>;
+def interposable_list : Separate<["-"], "interposable_list">,
+     MetaVarName<"<path>">,
+     HelpText<"Access global symbols listed in <path> indirectly">,
+     Group<grp_rare>;
+def no_function_starts : Flag<["-"], "no_function_starts">,
+     HelpText<"Do not creates a compressed table of function start addresses">,
+     Group<grp_rare>;
+def no_objc_category_merging : Flag<["-"], "no_objc_category_merging">,
+     HelpText<"Do not merge Objective-C categories into their classes">,
+     Group<grp_rare>;
+def object_path_lto : Separate<["-"], "object_path_lto">,
+     MetaVarName<"<path>">,
+     HelpText<"Retain any temporary mach-o file in <path> that would otherwise be deleted during LTO">,
+     Group<grp_rare>;
+def lto_library : Separate<["-"], "lto_library">,
+     MetaVarName<"<path>">,
+     HelpText<"Override the default ../lib/libLTO.dylib as <path>">,
+     Group<grp_rare>;
+def cache_path_lto : Separate<["-"], "cache_path_lto">,
+     MetaVarName<"<path>">,
+     HelpText<"Use <path> as a directory for the incremental LTO cache">,
+     Group<grp_rare>;
+def prune_interval_lto : Separate<["-"], "prune_interval_lto">,
+     MetaVarName<"<seconds>">,
+     HelpText<"Prune the incremental LTO cache after <seconds> (-1 disables pruning)">,
+     Group<grp_rare>;
+def prune_after_lto : Separate<["-"], "prune_after_lto">,
+     MetaVarName<"<seconds>">,
+     HelpText<"Remove LTO cache entries after <seconds>">,
+     Group<grp_rare>;
+def max_relative_cache_size_lto : Separate<["-"], "max_relative_cache_size_lto">,
+     MetaVarName<"<percent>">,
+     HelpText<"Limit the incremental LTO cache growth to <percent> of free disk, space">,
+     Group<grp_rare>;
+def page_align_data_atoms : Flag<["-"], "page_align_data_atoms">,
+     HelpText<"Distribute global variables on separate pages so page used/dirty status can guide creation of an order file to cluster commonly used/dirty globals">,
+     Group<grp_rare>;
+def not_for_dyld_shared_cache : Flag<["-"], "not_for_dyld_shared_cache">,
+     HelpText<"Prevent system dylibs from being placed into the dylib shared cache">,
+     Group<grp_rare>;
+
+def grp_deprecated : OptionGroup<"deprecated">, HelpText<"DEPRECATED">;
+
+def lazy_framework : Separate<["-"], "lazy_framework">,
+     MetaVarName<"<name>">,
+     HelpText<"This option is deprecated and is now an alias for -framework.">,
+     Group<grp_deprecated>;
+def lazy_library : Separate<["-"], "lazy_library">,
+     MetaVarName<"<path>">,
+     HelpText<"This option is deprecated and is now an alias for regular linking">,
+     Group<grp_deprecated>;
+def lazy_l : Joined<["-"], "lazy-l">,
+     MetaVarName<"<name>">,
+     HelpText<"This option is deprecated and is now an alias for -l<path>.">,
+     Group<grp_deprecated>;
+def single_module : Flag<["-"], "single_module">,
+     HelpText<"Unnecessary option: this is already the default">,
+     Group<grp_deprecated>;
+def no_dead_strip_inits_and_terms : Flag<["-"], "no_dead_strip_inits_and_terms">,
+     HelpText<"Unnecessary option: initialization and termination are roots of the dead strip graph, so never dead stripped">,
+     Group<grp_deprecated>;
+def noall_load : Flag<["-"], "noall_load">,
+     HelpText<"Unnecessary option: this is already the default">,
+     Group<grp_deprecated>;
+
+def grp_obsolete : OptionGroup<"obsolete">, HelpText<"OBSOLETE">;
+
+def y : Joined<["-"], "y">,
+     MetaVarName<"<symbol>">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def sectobjectsymbols : MultiArg<["-"], "sectobjectsymbols", 2>,
+     MetaVarName<"<segname> <sectname>">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def nofixprebinding : Flag<["-"], "nofixprebinding">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def noprebind_all_twolevel_modules : Flag<["-"], "noprebind_all_twolevel_modules">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def prebind_all_twolevel_modules : Flag<["-"], "prebind_all_twolevel_modules">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def prebind_allow_overlap : Flag<["-"], "prebind_allow_overlap">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def noprebind : Flag<["-"], "noprebind">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def sect_diff_relocs : Separate<["-"], "sect_diff_relocs">,
+     MetaVarName<"<treatment>">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def A : Separate<["-"], "A">,
+     MetaVarName<"<basefile>">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def b : Flag<["-"], "b">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def Sn : Flag<["-"], "Sn">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def Si : Flag<["-"], "Si">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def Sp : Flag<["-"], "Sp">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def X : Flag<["-"], "X">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def s : Flag<["-"], "s">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def m : Flag<["-"], "m">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def Y : Separate<["-"], "Y">,
+     MetaVarName<"<number>">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def nomultidefs : Flag<["-"], "nomultidefs">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def multiply_defined_unused : Separate<["-"], "multiply_defined_unused">,
+     MetaVarName<"<treatment>">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def multiply_defined : Separate<["-"], "multiply_defined">,
+     MetaVarName<"<treatment>">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def private_bundle : Flag<["-"], "private_bundle">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def seg_addr_table_filename : Separate<["-"], "seg_addr_table_filename">,
+     MetaVarName<"<path>">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def sectorder_detail : Flag<["-"], "sectorder_detail">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def no_compact_linkedit : Flag<["-"], "no_compact_linkedit">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def dependent_dr_info : Flag<["-"], "dependent_dr_info">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def no_dependent_dr_info : Flag<["-"], "no_dependent_dr_info">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def seglinkedit : Flag<["-"], "seglinkedit">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def noseglinkedit : Flag<["-"], "noseglinkedit">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def fvmlib : Flag<["-"], "fvmlib">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+def run_init_lazily : Flag<["-"], "run_init_lazily">,
+     HelpText<"This option is obsolete in ld64">,
+     Group<grp_obsolete>;
+
+def grp_undocumented : OptionGroup<"undocumented">, HelpText<"UNDOCUMENTED">;
+
+def add_ast_path : Flag<["-"], "add_ast_path">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def add_linker_option : Flag<["-"], "add_linker_option">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def add_source_version : Flag<["-"], "add_source_version">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def no_source_version : Flag<["-"], "no_source_version">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def add_split_seg_info : Flag<["-"], "add_split_seg_info">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def allow_dead_duplicates : Flag<["-"], "allow_dead_duplicates">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def allow_simulator_linking_to_macosx_dylibs : Flag<["-"], "allow_simulator_linking_to_macosx_dylibs">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def bitcode_process_mode : Flag<["-"], "bitcode_process_mode">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def bitcode_verify : Flag<["-"], "bitcode_verify">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def classic_linker : Flag<["-"], "classic_linker">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def data_const : Flag<["-"], "data_const">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def no_data_const : Flag<["-"], "no_data_const">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def data_in_code_info : Flag<["-"], "data_in_code_info">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def no_data_in_code_info : Flag<["-"], "no_data_in_code_info">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def debug_snapshot : Flag<["-"], "debug_snapshot">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def demangle : Flag<["-"], "demangle">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def dependency_info : Flag<["-"], "dependency_info">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def dyld_env : Flag<["-"], "dyld_env">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def encryptable : Flag<["-"], "encryptable">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def executable_path : Flag<["-"], "executable_path">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def fixup_chains : Flag<["-"], "fixup_chains">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def fixup_chains_section : Flag<["-"], "fixup_chains_section">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def flto_codegen_only : Flag<["-"], "flto-codegen-only">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def force_load_swift_libs : Flag<["-"], "force_load_swift_libs">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def force_symbol_not_weak : Flag<["-"], "force_symbol_not_weak">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def force_symbols_coalesce_list : Flag<["-"], "force_symbols_coalesce_list">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def force_symbols_not_weak_list : Flag<["-"], "force_symbols_not_weak_list">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def force_symbols_weak_list : Flag<["-"], "force_symbols_weak_list">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def force_symbol_weak : Flag<["-"], "force_symbol_weak">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def function_starts : Flag<["-"], "function_starts">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def i : Flag<["-"], "i">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def ignore_auto_link : Flag<["-"], "ignore_auto_link">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def ignore_optimization_hints : Flag<["-"], "ignore_optimization_hints">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def init_offsets : Flag<["-"], "init_offsets">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def keep_dwarf_unwind : Flag<["-"], "keep_dwarf_unwind">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def no_keep_dwarf_unwind : Flag<["-"], "no_keep_dwarf_unwind">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def kext : Flag<["-"], "kext">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def kext_objects_dir : Flag<["-"], "kext_objects_dir">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def no_kext_objects : Flag<["-"], "no_kext_objects">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def kexts_use_stubs : Flag<["-"], "kexts_use_stubs">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def maccatalyst_version_min : Flag<["-"], "maccatalyst_version_min">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def iosmac_version_min : Flag<["-"], "iosmac_version_min">,
+     Alias<maccatalyst_version_min>,
+     HelpText<"Alias for -maccatalyst_version_min">;
+def uikitformac_version_min : Flag<["-"], "uikitformac_version_min">,
+     Alias<maccatalyst_version_min>,
+     HelpText<"Alias for -maccatalyst_version_min">;
+def mcpu : Flag<["-"], "mcpu">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def mllvm : Flag<["-"], "mllvm">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def no_compact_unwind : Flag<["-"], "no_compact_unwind">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def no_dtrace_dof : Flag<["-"], "no_dtrace_dof">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def no_encryption : Flag<["-"], "no_encryption">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def no_new_main : Flag<["-"], "no_new_main">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def objc_abi_version : Flag<["-"], "objc_abi_version">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def pause : Flag<["-"], "pause">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def random_uuid : Flag<["-"], "random_uuid">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def save_temps : Flag<["-"], "save-temps">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def sdk_version : Flag<["-"], "sdk_version">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def simulator_support : Flag<["-"], "simulator_support">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def snapshot_dir : Flag<["-"], "snapshot_dir">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def source_version : Flag<["-"], "source_version">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def text_exec : Flag<["-"], "text_exec">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def threaded_starts_section : Flag<["-"], "threaded_starts_section">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def twolevel_namespace : Flag<["-"], "twolevel_namespace">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def verbose_optimization_hints : Flag<["-"], "verbose_optimization_hints">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+def version_load_command : Flag<["-"], "version_load_command">,
+     HelpText<"This option is undocumented in ld64">,
+     Group<grp_undocumented>;
+
+def grp_ignored : OptionGroup<"ignored">, HelpText<"IGNORED">;
+
+def M : Flag<["-"], "M">,
+     HelpText<"This option is ignored in ld64">,
+     Group<grp_ignored>;
+def new_linker : Flag<["-"], "new_linker">,
+     HelpText<"This option is ignored in ld64">,
+     Group<grp_ignored>;

lld/test/MachO/current-version.test

+# RUN: not lld -flavor darwinnew -current_version 2>&1 \
+# RUN:     | FileCheck --check-prefix=MISSING %s
+# RUN: not lld -flavor darwinnew -current_version 1.2.3.4.5 foobar 2>&1 \
+# RUN:     | FileCheck --check-prefix=FAIL_FILE %s
+# RUN: not lld -flavor darwinnew -current_version 1 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -current_version 1.2 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -current_version 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -current_version 1.2.3.4 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -current_version 1.2.3.4.5 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -current_version 1.2.3.4.5.6 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
+# RUN: not lld -flavor darwinnew -current_version '' 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
+# RUN: not lld -flavor darwinnew -current_version . 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
+
+USAGE: usage: -current_version <version>
+USAGE: undefined symbol: _main
+MISSING: -current_version: missing argument
+MISSING: undefined symbol: _main
+GOOD: undefined symbol: _main
+FAIL_FILE: cannot open foobar

lld/test/MachO/platform-version.test

 # RUN: not lld -flavor darwinnew -platform_version 2>&1 \
-# RUN:     | FileCheck --check-prefix=FAIL %s
+# RUN:     | FileCheck --check-prefix=MISSING %s
 # RUN: not lld -flavor darwinnew -platform_version macos 2>&1 \
-# RUN:     | FileCheck --check-prefix=FAIL %s
+# RUN:     | FileCheck --check-prefix=MISSING %s
 # RUN: not lld -flavor darwinnew -platform_version macos 10.15 2>&1 \
-# RUN:     | FileCheck --check-prefix=FAIL %s
-# RUN: not lld -flavor darwinnew -platform_version macos -lfoo 10.15 2>&1 \
-# RUN:     | FileCheck --check-prefix=FAIL %s
-# RUN: not lld -flavor darwinnew -platform_version macos 10.15 10.15.4 2>&1 \
-# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN:     | FileCheck --check-prefix=MISSING %s
 # RUN: not lld -flavor darwinnew -platform_version macos 10.15 10.15.4 foobar 2>&1 \
 # RUN:     | FileCheck --check-prefix=FAIL_FILE %s
+# RUN: not lld -flavor darwinnew -platform_version macos 10.15 10.15.4 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version ios 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version tvos 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version watchos 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version bridgeos 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version mac-catalyst 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version ios-sim 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version tvos-sim 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version watchos-sim 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version driverkit 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version 5 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=GOOD %s
+# RUN: not lld -flavor darwinnew -platform_version 5 1.2 '' 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
+# RUN: not lld -flavor darwinnew -platform_version 5 1.2 . 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
+# RUN: not lld -flavor darwinnew -platform_version 5 1.2 1.2.3.4 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
+# RUN: not lld -flavor darwinnew -platform_version 0 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
+# RUN: not lld -flavor darwinnew -platform_version 11 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
+# RUN: not lld -flavor darwinnew -platform_version nachos 1.2 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
+# RUN: not lld -flavor darwinnew -platform_version macos -lfoo 1.2.3 2>&1 \
+# RUN:     | FileCheck --check-prefix=USAGE %s
 
-FAIL: usage: -platform_version platform min_version sdk_version
+USAGE: usage: -platform_version <platform> <min_version> <sdk_version>
+USAGE: undefined symbol: _main
+MISSING: -platform_version: missing argument
+MISSING: undefined symbol: _main
 GOOD: undefined symbol: _main
 FAIL_FILE: cannot open foobar

llvm/include/llvm/Option/Option.h

public:
 
   /// Get the name of this option with the default prefix.
   std::string getPrefixedName() const {
     std::string Ret(getPrefix());
     Ret += getName();
     return Ret;
   }
 
+  /// Get the help text for this option.
+  StringRef getHelpText() const {
+    assert(Info && "Must have a valid info!");
+    return Info->HelpText;
+  }
+
+  /// Get the meta-variable list for this option.
+  StringRef getMetaVar() const {
+    assert(Info && "Must have a valid info!");
+    return Info->MetaVar;
+  }
+
   unsigned getNumArgs() const { return Info->Param; }
 
   bool hasNoOptAsInput() const { return Info->Flags & RenderAsInput;}
 
   RenderStyleKind getRenderStyle() const {
     if (Info->Flags & RenderJoined)
       return RenderJoinedStyle;
     if (Info->Flags & RenderSeparate)