winnow-args 0.1.1

//! mold's command line, as its `winnow-args-cmdline` branch parses GNU ld's
//! options: every option is one variant of [`Item`], kept in order, and this
//! prints them. Generated by `just gen examples` from mold's parser.
//! Do not edit: regenerate with `just gen examples BRUSH_DIR MOLD_DIR`.
//!
//! ```text
//! cargo run --example ld -- -shared -o out.so --as-needed -lc a.o -z now -zrelro
//! cargo run --example ld -- -sS --build-id --build-id=sha1 -L=usr/lib --lto-O2
//! cargo run --example ld -- @link.rsp
//! cargo run --example ld -- --help
//! ```
//!
//! With `PARSE_N=n` in the environment the line is parsed `n` times and
//! nothing is printed, to measure the parse alone.

use std::ffi::{OsStr, OsString};

use winnow_args::response::{ResponseFiles, expand};
use winnow_args::value::Spanned;
use winnow_args::{Args, Occurrence};

/// Print a GNU ld command line as mold reads it.
#[derive(Debug, Args)]
#[arg(
    name = "ld",
    long_only,
    disable_help_short,
    after_help = "Long options take one dash or two (`-shared`), except those listed with two only \
                  where one dash would read as a short option's value. `-z KEYWORD` is printed as \
                  the option it stands for; `@FILE` is replaced by the words in the file. A word \
                  that is no option is an input; an unknown option is kept as `Unknown`, and \
                  several short options in one word (`-sS`) as `Grouped` before them."
)]
struct Cli {
    #[arg(sequence, unknown)]
    items: Vec<Item>,
}

#[allow(dead_code, reason = "the `-z` variants' values are only printed")]
#[derive(Occurrence, Debug)]
#[arg(allow_hyphen_values, keep_equals)]
enum Item {
    /// Set output filename
    #[arg(short = 'o')]
    OutputShort(OsString),
    /// Set output filename
    #[arg(long = "output", two_dashes)]
    Output(OsString),
    /// Set dynamic linker path
    #[arg(long = "dynamic-linker")]
    DynamicLinker(OsString),
    /// Set dynamic linker path
    #[arg(short = 'I')]
    DynamicLinkerShort(OsString),
    /// `-no-dynamic-linker`
    #[arg(long = "no-dynamic-linker")]
    NoDynamicLinker,
    /// Report version information
    #[arg(short = 'v')]
    ShortVLower,
    /// Report version information
    #[arg(long = "version")]
    Version,
    /// Report version and target information
    #[arg(short = 'V')]
    ShortV,
    /// `-mllvm`
    #[arg(long = "mllvm")]
    Mllvm(OsString),
    /// `-end-lib`
    #[arg(long = "end-lib")]
    EndLib,
    /// Put symbols in the dynamic symbol table
    #[arg(long = "export-dynamic")]
    ExportDynamic,
    /// Put symbols in the dynamic symbol table
    #[arg(short = 'E')]
    ExportDynamicShort,
    /// `-no-export-dynamic`
    #[arg(long = "no-export-dynamic")]
    NoExportDynamic,
    /// Bind all symbols locally
    #[arg(long = "Bsymbolic")]
    Bsymbolic,
    /// Bind function symbols locally
    #[arg(long = "Bsymbolic-functions")]
    BsymbolicFunctions,
    /// Bind all but weak symbols locally
    #[arg(long = "Bsymbolic-non-weak")]
    BsymbolicNonWeak,
    /// Bind all but weak function symbols locally
    #[arg(long = "Bsymbolic-non-weak-functions")]
    BsymbolicNonWeakFunctions,
    /// Cancel --Bsymbolic options
    #[arg(long = "Bno-symbolic")]
    BnoSymbolic,
    /// Mark all symbols in given libraries as hidden
    #[arg(long = "exclude-libs")]
    ExcludeLibs(OsString),
    /// Leaves relocation sections in the output
    #[arg(short = 'q')]
    EmitRelocsShort,
    /// Leaves relocation sections in the output
    #[arg(long = "emit-relocs")]
    EmitRelocs,
    /// Write map file to a given file
    #[arg(long = "Map")]
    Map(OsString),
    /// `-print-dependencies`
    #[arg(long = "print-dependencies")]
    PrintDependencies,
    /// Write map file to stdout
    #[arg(long = "print-map")]
    PrintMap,
    /// Write map file to stdout
    #[arg(short = 'M')]
    PrintMapShort,
    /// Do not link against shared libraries
    #[arg(long = "Bstatic")]
    Bstatic,
    /// Do not link against shared libraries
    #[arg(long = "dn")]
    Dn,
    /// Do not link against shared libraries
    #[arg(long = "static")]
    Static,
    /// Link against shared libraries (default)
    #[arg(long = "Bdynamic")]
    Bdynamic,
    /// Link against shared libraries (default)
    #[arg(long = "dy")]
    Dy,
    /// Create a shared library
    #[arg(long = "shared")]
    Shared,
    /// Create a shared library
    #[arg(long = "Bshareable")]
    Bshareable,
    /// `-spare-dynamic-tags`
    #[arg(long = "spare-dynamic-tags")]
    SpareDynamicTags(OsString),
    /// Reserve the given number of slots in the program header
    #[arg(long = "spare-program-headers")]
    SpareProgramHeaders(OsString),
    /// Give following object files in-archive-file semantics
    #[arg(long = "start-lib")]
    StartLib,
    /// `-start-stop`
    #[arg(long = "start-stop")]
    StartStop,
    /// Write Makefile-style dependency rules to FILE
    #[arg(long = "dependency-file")]
    DependencyFile(OsString),
    /// Define a symbol alias
    #[arg(long = "defsym")]
    Defsym(OsString),
    /// `-:lto-pass2`
    #[arg(long = ":lto-pass2")]
    InternalLtoPass2,
    /// `-:ignore-ir-file`
    #[arg(long = ":ignore-ir-file")]
    InternalIgnoreIrFile(OsString),
    /// Demangle C++ symbols in log messages (default)
    #[arg(long = "demangle")]
    Demangle,
    /// `-no-demangle`
    #[arg(long = "no-demangle")]
    NoDemangle,
    /// Create separate debug info file in the background (default)
    #[arg(long = "detach")]
    Detach,
    /// `-no-detach`
    #[arg(long = "no-detach")]
    NoDetach,
    /// `-default-symver`
    #[arg(long = "default-symver")]
    DefaultSymver,
    /// Create an output file even if errors occur
    #[arg(long = "noinhibit-exec")]
    NoinhibitExec,
    /// Randomize the output by shuffling input sections
    #[arg(long = "shuffle-sections", require_equals, default_missing = "\0")]
    ShuffleSections(OsString),
    /// Reverse input sections in the output file
    #[arg(long = "reverse-sections")]
    ReverseSections,
    /// Put read-only non-executable sections in their own segment (default)
    #[arg(long = "rosegment")]
    Rosegment,
    /// `-no-rosegment`
    #[arg(long = "no-rosegment")]
    NoRosegment,
    /// Trace references to SYMBOL
    #[arg(short = 'y')]
    TraceSymbolShort(OsString),
    /// Trace references to SYMBOL
    #[arg(long = "trace-symbol")]
    TraceSymbol(OsString),
    /// `-filler`
    #[arg(long = "filler")]
    Filler(OsString),
    /// Add DIR to library search path
    #[arg(short = 'L')]
    LibraryPathShort(OsString),
    /// Add DIR to library search path
    #[arg(long = "library-path")]
    LibraryPath(OsString),
    /// Set the target system root directory
    #[arg(long = "sysroot")]
    Sysroot(OsString),
    /// Don't merge input sections that match a given pattern
    #[arg(long = "unique")]
    Unique(OsString),
    /// Handle unresolved symbols
    #[arg(long = "unresolved-symbols")]
    UnresolvedSymbols(OsString),
    /// Force to resolve all symbols that match a given pattern
    #[arg(long = "undefined-glob", two_dashes)]
    UndefinedGlob(OsString),
    /// Require SYMBOL be defined in the final output
    #[arg(long = "require-defined")]
    RequireDefined(OsString),
    /// Call SYMBOL at load-time
    #[arg(long = "init")]
    Init(OsString),
    /// Call SYMBOL at unload-time
    #[arg(long = "fini")]
    Fini(OsString),
    /// Set hash style
    #[arg(long = "hash-style")]
    HashStyle(OsString),
    /// Set shared library name
    #[arg(long = "soname")]
    Soname(OsString),
    /// Set shared library name
    #[arg(short = 'h')]
    SonameShort(OsString),
    /// Set DT_AUDIT to the specified value
    #[arg(long = "audit")]
    Audit(OsString),
    /// Set DT_DEPAUDIT to the specified value
    #[arg(long = "depaudit")]
    Depaudit(OsString),
    /// Set DT_DEPAUDIT to the specified value
    #[arg(short = 'P')]
    DepauditShort(OsString),
    /// `-allow-multiple-definition`
    #[arg(long = "allow-multiple-definition")]
    AllowMultipleDefinition,
    /// Apply link-time values for dynamic relocations (default)
    #[arg(long = "apply-dynamic-relocs")]
    ApplyDynamicRelocs,
    /// `-no-apply-dynamic-relocs`
    #[arg(long = "no-apply-dynamic-relocs")]
    NoApplyDynamicRelocs,
    /// Print the name of each input file
    #[arg(long = "trace")]
    Trace,
    /// Create .eh_frame_hdr section
    #[arg(long = "eh-frame-hdr")]
    EhFrameHdr,
    /// `-no-eh-frame-hdr`
    #[arg(long = "no-eh-frame-hdr")]
    NoEhFrameHdr,
    /// Create a position-independent executable
    #[arg(long = "pie")]
    Pie,
    /// Create a position-independent executable
    #[arg(long = "pic-executable")]
    PicExecutable,
    /// `-no-pie`
    #[arg(long = "no-pie")]
    NoPie,
    /// `-no-pic-executable`
    #[arg(long = "no-pic-executable")]
    NoPicExecutable,
    /// `-nopie`
    #[arg(long = "nopie")]
    Nopie,
    /// Optimize instructions (default)
    #[arg(long = "relax")]
    Relax,
    /// `-no-relax`
    #[arg(long = "no-relax")]
    NoRelax,
    /// Create .gdb_index for faster gdb startup
    #[arg(long = "gdb-index")]
    GdbIndex,
    /// `-no-gdb-index`
    #[arg(long = "no-gdb-index")]
    NoGdbIndex,
    /// Generate relocatable output
    #[arg(short = 'r')]
    RelocatableShort,
    /// Generate relocatable output
    #[arg(long = "relocatable")]
    Relocatable,
    /// `-relocatable-merge-sections`
    #[arg(long = "relocatable-merge-sections")]
    RelocatableMergeSections,
    /// Print performance statistics
    #[arg(long = "perf")]
    Perf,
    /// Pack dynamic relocations
    #[arg(long = "pack-dyn-relocs", require_equals)]
    PackDynRelocs(OsString),
    /// `--use-android-relr-tags`
    #[arg(long = "use-android-relr-tags", two_dashes)]
    UseAndroidRelrTags,
    /// `-no-use-android-relr-tags`
    #[arg(long = "no-use-android-relr-tags")]
    NoUseAndroidRelrTags,
    /// Set a given string to .note.package
    #[arg(long = "package-metadata", require_equals)]
    PackageMetadata(OsString),
    /// Print input statistics
    #[arg(long = "stats")]
    Stats,
    /// Change to DIR before doing anything
    #[arg(short = 'C')]
    DirectoryShort(OsString),
    /// Change to DIR before doing anything
    #[arg(long = "directory")]
    Directory(OsString),
    /// Set a given path to the root directory
    #[arg(long = "chroot")]
    Chroot(OsString),
    /// Alias for --color-diagnostics=auto
    #[arg(long = "color-diagnostics", require_equals, default_missing = "\0")]
    ColorDiagnostics(OsString),
    /// `-no-color-diagnostics`
    #[arg(long = "no-color-diagnostics")]
    NoColorDiagnostics,
    /// Warn about common symbols
    #[arg(long = "warn-common")]
    WarnCommon,
    /// `-no-warn-common`
    #[arg(long = "no-warn-common")]
    NoWarnCommon,
    /// Only warn once for each undefined symbol
    #[arg(long = "warn-once")]
    IgnoredWarnOnce,
    /// Warn if the output .so needs text relocations
    #[arg(long = "warn-shared-textrel")]
    WarnSharedTextrel,
    /// Warn if the output file needs text relocations
    #[arg(long = "warn-textrel")]
    WarnTextrel,
    /// Emit DT_RUNPATH for --rpath (default)
    #[arg(long = "enable-new-dtags")]
    EnableNewDtags,
    /// `-disable-new-dtags`
    #[arg(long = "disable-new-dtags")]
    DisableNewDtags,
    /// Make executable segments unreadable
    #[arg(long = "execute-only", two_dashes)]
    ExecuteOnly,
    /// Convert all-zero data sections into BSS
    #[arg(long = "zero-to-bss")]
    ZeroToBss,
    /// Compress .debug_* sections
    #[arg(long = "compress-debug-sections")]
    CompressDebugSections(OsString),
    /// Use a wrapper function for a given symbol
    #[arg(long = "wrap")]
    Wrap(OsString),
    /// Do not page align data; do not make text readonly
    #[arg(long = "omagic", two_dashes)]
    Omagic,
    /// Do not page align data; do not make text readonly
    #[arg(short = 'N')]
    OmagicShort,
    /// `--no-omagic`
    #[arg(long = "no-omagic", two_dashes)]
    NoOmagic,
    /// Omit ELF, section, and program headers
    #[arg(long = "oformat", two_dashes)]
    Oformat(OsString),
    /// Keep only symbols listed in FILE
    #[arg(long = "retain-symbols-file")]
    RetainSymbolsFile(OsString),
    /// `-section-align`
    #[arg(long = "section-align")]
    SectionAlign(OsString),
    /// `-section-start`
    #[arg(long = "section-start")]
    SectionStart(OsString),
    /// `-section-order`
    #[arg(long = "section-order")]
    SectionOrder(OsString),
    /// Set address to .bss
    #[arg(long = "Tbss")]
    Tbss(OsString),
    /// Set address to .data
    #[arg(long = "Tdata")]
    Tdata(OsString),
    /// Set address to .text
    #[arg(long = "Ttext")]
    Ttext(OsString),
    /// Set address of text segment
    #[arg(long = "Ttext-segment")]
    TtextSegment(OsString),
    /// Embed input files in .repro section
    #[arg(long = "repro")]
    Repro,
    /// Report undefined symbols (even with --shared)
    #[arg(long = "no-undefined")]
    NoUndefined,
    /// `-separate-debug-file`
    #[arg(long = "separate-debug-file", require_equals, default_missing = "\0")]
    SeparateDebugFile(OsString),
    /// `-no-separate-debug-file`
    #[arg(long = "no-separate-debug-file")]
    NoSeparateDebugFile,
    /// Do not page align sections
    #[arg(long = "nmagic")]
    Nmagic,
    /// `-no-nmagic`
    #[arg(long = "no-nmagic")]
    NoNmagic,
    /// Treat warnings as errors
    #[arg(long = "fatal-warnings")]
    FatalWarnings,
    /// `-no-fatal-warnings`
    #[arg(long = "no-fatal-warnings")]
    NoFatalWarnings,
    /// Suppress warnings
    #[arg(short = 'w')]
    NoWarningsShort,
    /// Suppress warnings
    #[arg(long = "no-warnings")]
    NoWarnings,
    /// Spawn a child process (default)
    #[arg(long = "fork")]
    Fork,
    /// `-no-fork`
    #[arg(long = "no-fork")]
    NoFork,
    /// Remove unreferenced sections
    #[arg(long = "gc-sections")]
    GcSections,
    /// `-no-gc-sections`
    #[arg(long = "no-gc-sections")]
    NoGcSections,
    /// Print, or save in FILE, removed unreferenced sections
    #[arg(long = "print-gc-sections", require_equals, default_missing = "\0")]
    PrintGcSections(OsString),
    /// `-no-print-gc-sections`
    #[arg(long = "no-print-gc-sections")]
    NoPrintGcSections,
    /// `-discard-section`
    #[arg(long = "discard-section")]
    DiscardSection(OsString),
    /// `-no-discard-section`
    #[arg(long = "no-discard-section")]
    NoDiscardSection(OsString),
    /// Fold identical code
    #[arg(long = "icf")]
    Icf(OsString),
    /// `-no-icf`
    #[arg(long = "no-icf")]
    NoIcf,
    /// Allow merging non-executable sections with --icf
    #[arg(long = "ignore-data-address-equality")]
    IgnoreDataAddressEquality,
    /// Set the base address to a given value
    #[arg(long = "image-base")]
    ImageBase(OsString),
    /// `-physical-image-base`
    #[arg(long = "physical-image-base")]
    PhysicalImageBase(OsString),
    /// `-print-icf-sections`
    #[arg(long = "print-icf-sections", require_equals, default_missing = "\0")]
    PrintIcfSections(OsString),
    /// `-no-print-icf-sections`
    #[arg(long = "no-print-icf-sections")]
    NoPrintIcfSections,
    /// Use quick_exit to exit (default)
    #[arg(long = "quick-exit")]
    QuickExit,
    /// `-no-quick-exit`
    #[arg(long = "no-quick-exit")]
    NoQuickExit,
    /// `-plugin`
    #[arg(long = "plugin")]
    Plugin(OsString),
    /// `-plugin-opt`
    #[arg(long = "plugin-opt")]
    PluginOpt(OsString),
    /// `--lto-cs-profile-generate`
    #[arg(long = "lto-cs-profile-generate", two_dashes)]
    LtoCsProfileGenerate,
    /// `--lto-debug-pass-manager`
    #[arg(long = "lto-debug-pass-manager", two_dashes)]
    LtoDebugPassManager,
    /// `-disable-verify`
    #[arg(long = "disable-verify")]
    DisableVerify,
    /// `--lto-emit-asm`
    #[arg(long = "lto-emit-asm", two_dashes)]
    LtoEmitAsm,
    /// `-no-legacy-pass-manager`
    #[arg(long = "no-legacy-pass-manager")]
    NoLegacyPassManager,
    /// `-no-lto-legacy-pass-manager`
    #[arg(long = "no-lto-legacy-pass-manager")]
    NoLtoLegacyPassManager,
    /// `--opt-remarks-with-hotness`
    #[arg(long = "opt-remarks-with-hotness", two_dashes)]
    OptRemarksWithHotness,
    /// `-lto-pseudo-probe-for-profiling`
    #[arg(long = "lto-pseudo-probe-for-profiling")]
    LtoPseudoProbeForProfiling,
    /// `-save-temps`
    #[arg(long = "save-temps")]
    SaveTemps,
    /// `-thinlto-emit-imports-files`
    #[arg(long = "thinlto-emit-imports-files")]
    ThinltoEmitImportsFiles,
    /// `-thinlto-index-only`
    #[arg(long = "thinlto-index-only", require_equals, default_missing = "\0")]
    ThinltoIndexOnly(OsString),
    /// `--lto-cs-profile-file`
    #[arg(long = "lto-cs-profile-file", two_dashes)]
    LtoCsProfileFile(OsString),
    /// `--lto-partitions`
    #[arg(long = "lto-partitions", two_dashes)]
    LtoPartitions(OsString),
    /// `--lto-obj-path`
    #[arg(long = "lto-obj-path", two_dashes)]
    LtoObjPath(OsString),
    /// `--opt-remarks-filename`
    #[arg(long = "opt-remarks-filename", two_dashes)]
    OptRemarksFilename(OsString),
    /// `--opt-remarks-format`
    #[arg(long = "opt-remarks-format", two_dashes)]
    OptRemarksFormat(OsString),
    /// `--opt-remarks-hotness-threshold`
    #[arg(long = "opt-remarks-hotness-threshold", two_dashes)]
    OptRemarksHotnessThreshold(OsString),
    /// `--opt-remarks-passes`
    #[arg(long = "opt-remarks-passes", two_dashes)]
    OptRemarksPasses(OsString),
    /// `--lto-sample-profile`
    #[arg(long = "lto-sample-profile", two_dashes)]
    LtoSampleProfile(OsString),
    /// `-thinlto-object-suffix-replace`
    #[arg(long = "thinlto-object-suffix-replace")]
    ThinltoObjectSuffixReplace(OsString),
    /// `-thinlto-prefix-replace`
    #[arg(long = "thinlto-prefix-replace")]
    ThinltoPrefixReplace(OsString),
    /// `-thinlto-cache-dir`
    #[arg(long = "thinlto-cache-dir")]
    ThinltoCacheDir(OsString),
    /// `-thinlto-cache-policy`
    #[arg(long = "thinlto-cache-policy")]
    ThinltoCachePolicy(OsString),
    /// `-thinlto-jobs`
    #[arg(long = "thinlto-jobs")]
    ThinltoJobs(OsString),
    /// Use COUNT number of threads
    #[arg(long = "thread-count")]
    ThreadCount(OsString),
    /// Use multiple threads (default)
    #[arg(long = "threads", require_equals, default_missing = "\0")]
    Threads(OsString),
    /// `-no-threads`
    #[arg(long = "no-threads")]
    NoThreads,
    /// `-discard-all`
    #[arg(long = "discard-all")]
    DiscardAll,
    /// `-x`
    #[arg(short = 'x')]
    DiscardAllShort,
    /// Discard temporary local symbols (default)
    #[arg(long = "discard-locals")]
    DiscardLocals,
    /// Discard temporary local symbols (default)
    #[arg(short = 'X')]
    DiscardLocalsShort,
    /// Keep all local symbols in the symbol table
    #[arg(long = "discard-none")]
    DiscardNone,
    /// Strip .symtab section
    #[arg(long = "strip-all")]
    StripAll,
    /// Strip .symtab section
    #[arg(short = 's')]
    StripAllShort,
    /// Strip .debug_* sections
    #[arg(long = "strip-debug")]
    StripDebug,
    /// Strip .debug_* sections
    #[arg(short = 'S')]
    StripDebugShort,
    /// Report unresolved symbols as warnings
    #[arg(long = "warn-unresolved-symbols")]
    WarnUnresolvedSymbols,
    /// `-error-unresolved-symbols`
    #[arg(long = "error-unresolved-symbols")]
    ErrorUnresolvedSymbols,
    /// Add DIR to the runtime search path
    #[arg(long = "rpath")]
    Rpath(OsString),
    /// `-R`
    #[arg(short = 'R')]
    ShortR(OsString),
    /// Do not report version scripts that refer to undefined symbols
    #[arg(long = "undefined-version", two_dashes)]
    UndefinedVersion,
    /// `-no-undefined-version`
    #[arg(long = "no-undefined-version")]
    NoUndefinedVersion,
    /// Force to resolve SYMBOL
    #[arg(long = "undefined")]
    Undefined(OsString),
    /// Force to resolve SYMBOL
    #[arg(short = 'u')]
    UndefinedShort(OsString),
    /// Generate build ID
    #[arg(long = "build-id", require_equals, default_missing = "\0")]
    BuildId(OsString),
    /// `-no-build-id`
    #[arg(long = "no-build-id")]
    NoBuildId,
    /// `-be8`
    #[arg(long = "be8")]
    Be8,
    /// `-be32`
    #[arg(long = "be32")]
    Be32,
    /// `--format`
    #[arg(long = "format", two_dashes)]
    Format(OsString),
    /// `-b`
    #[arg(short = 'b')]
    FormatShort(OsString),
    /// `-fuse-ld`
    #[arg(long = "fuse-ld")]
    IgnoredFuseLd(OsString),
    /// `-allow-shlib-undefined`
    #[arg(long = "allow-shlib-undefined")]
    AllowShlibUndefined,
    /// `-no-allow-shlib-undefined`
    #[arg(long = "no-allow-shlib-undefined")]
    NoAllowShlibUndefined,
    /// Ignored
    #[arg(short = 'O')]
    IgnoredShortO(OsString),
    /// `-EB`
    #[arg(long = "EB")]
    IgnoredEB,
    /// `-EL`
    #[arg(long = "EL")]
    IgnoredEL,
    /// `-O0`
    #[arg(long = "O0")]
    IgnoredO0,
    /// `-O1`
    #[arg(long = "O1")]
    IgnoredO1,
    /// `-O2`
    #[arg(long = "O2")]
    IgnoredO2,
    /// `-verbose`
    #[arg(long = "verbose")]
    IgnoredVerbose,
    /// Ignored
    #[arg(long = "start-group")]
    IgnoredStartGroup,
    /// Ignored
    #[arg(long = "end-group")]
    IgnoredEndGroup,
    /// Ignored
    #[arg(short = '(')]
    IgnoredOpenParen,
    /// Ignored
    #[arg(short = ')')]
    IgnoredCloseParen,
    /// `-nostdlib`
    #[arg(long = "nostdlib")]
    IgnoredNostdlib,
    /// `-no-add-needed`
    #[arg(long = "no-add-needed")]
    IgnoredNoAddNeeded,
    /// `-no-call-graph-profile-sort`
    #[arg(long = "no-call-graph-profile-sort")]
    IgnoredNoCallGraphProfileSort,
    /// `-no-copy-dt-needed-entries`
    #[arg(long = "no-copy-dt-needed-entries")]
    IgnoredNoCopyDtNeededEntries,
    /// Ignored
    #[arg(long = "sort-section")]
    IgnoredSortSection(OsString),
    /// Ignored
    #[arg(long = "sort-common")]
    IgnoredSortCommon,
    /// Ignored
    #[arg(long = "dc")]
    IgnoredDc,
    /// Ignored
    #[arg(long = "dp")]
    IgnoredDp,
    /// `-fix-cortex-a53-835769`
    #[arg(long = "fix-cortex-a53-835769")]
    IgnoredFixCortexA53835769,
    /// `-fix-cortex-a53-843419`
    #[arg(long = "fix-cortex-a53-843419")]
    IgnoredFixCortexA53843419,
    /// `-nodefaultlibs`
    #[arg(long = "nodefaultlibs")]
    IgnoredNodefaultlibs,
    /// `-warn-constructors`
    #[arg(long = "warn-constructors")]
    IgnoredWarnConstructors,
    /// `-warn-execstack`
    #[arg(long = "warn-execstack")]
    IgnoredWarnExecstack,
    /// `-no-warn-execstack`
    #[arg(long = "no-warn-execstack")]
    IgnoredNoWarnExecstack,
    /// `-long-plt`
    #[arg(long = "long-plt")]
    IgnoredLongPlt,
    /// `-secure-plt`
    #[arg(long = "secure-plt")]
    IgnoredSecurePlt,
    /// Ignored
    #[arg(long = "rpath-link")]
    IgnoredRpathLink(OsString),
    /// `-no-keep-memory`
    #[arg(long = "no-keep-memory")]
    IgnoredNoKeepMemory,
    /// `-max-cache-size`
    #[arg(long = "max-cache-size")]
    IgnoredMaxCacheSize(OsString),
    /// `--mmap-output-file`
    #[arg(long = "mmap-output-file", two_dashes)]
    IgnoredMmapOutputFile,
    /// `-no-mmap-output-file`
    #[arg(long = "no-mmap-output-file")]
    IgnoredNoMmapOutputFile,
    /// Set target
    #[arg(short = 'm')]
    ShortMLower(OsString),
    /// Set DT_FILTER to the specified value
    #[arg(long = "filter")]
    Filter(OsString),
    /// Set DT_FILTER to the specified value
    #[arg(short = 'F')]
    FilterShort(OsString),
    /// `-auxiliary`
    #[arg(long = "auxiliary")]
    Auxiliary(OsString),
    /// `-f`
    #[arg(short = 'f')]
    AuxiliaryShort(OsString),
    /// Read version script
    #[arg(long = "version-script")]
    VersionScript(OsString),
    /// Read a list of dynamic symbols (implies -Bsymbolic)
    #[arg(long = "dynamic-list")]
    DynamicList(OsString),
    /// Add data symbols to dynamic symbols
    #[arg(long = "dynamic-list-data")]
    DynamicListData,
    /// Put symbols matching glob in the dynamic symbol table
    #[arg(long = "export-dynamic-symbol", two_dashes)]
    ExportDynamicSymbol(OsString),
    /// Read a list of dynamic symbols
    #[arg(long = "export-dynamic-symbol-list", two_dashes)]
    ExportDynamicSymbolList(OsString),
    /// Set program entry point
    #[arg(long = "entry")]
    Entry(OsString),
    /// Set program entry point
    #[arg(short = 'e')]
    EntryShort(OsString),
    /// Only set DT_NEEDED if used
    #[arg(long = "as-needed")]
    AsNeeded,
    /// `-no-as-needed`
    #[arg(long = "no-as-needed")]
    NoAsNeeded,
    /// Include all objects from static archives
    #[arg(long = "whole-archive")]
    WholeArchive,
    /// `-no-whole-archive`
    #[arg(long = "no-whole-archive")]
    NoWholeArchive,
    /// Search for a given library
    #[arg(long = "library", two_dashes)]
    Library(OsString),
    /// Search for a given library
    #[arg(short = 'l', prefix)]
    LibraryShort(OsString),
    /// Read linker script
    #[arg(long = "script")]
    Script(OsString),
    /// Read linker script
    #[arg(short = 'T')]
    ScriptShort(OsString),
    /// Save the state of flags governing input file handling
    #[arg(long = "push-state")]
    PushState,
    /// Restore the state of flags governing input file handling
    #[arg(long = "pop-state")]
    PopState,
    /// `-z KEYWORD`, `-zKEYWORD`: mapped by [`z_opt`] as it is handled;
    /// one that stays is unknown.
    #[arg(short = 'z')]
    Z(Spanned<OsString>),
    /// `-z now`.
    #[arg(skip)]
    ZNow,
    /// `-z lazy`.
    #[arg(skip)]
    ZLazy,
    /// `-z cet-report=none`.
    #[arg(skip)]
    ZCetReportNone,
    /// `-z cet-report=warning`.
    #[arg(skip)]
    ZCetReportWarning,
    /// `-z cet-report=error`.
    #[arg(skip)]
    ZCetReportError,
    /// `-z bti-report=none`.
    #[arg(skip)]
    ZBtiReportNone,
    /// `-z bti-report=warning`.
    #[arg(skip)]
    ZBtiReportWarning,
    /// `-z bti-report=error`.
    #[arg(skip)]
    ZBtiReportError,
    /// `-z gcs-report=none`.
    #[arg(skip)]
    ZGcsReportNone,
    /// `-z gcs-report=warning`.
    #[arg(skip)]
    ZGcsReportWarning,
    /// `-z gcs-report=error`.
    #[arg(skip)]
    ZGcsReportError,
    /// `-z execstack`.
    #[arg(skip)]
    ZExecstack,
    /// `-z execstack-if-needed`.
    #[arg(skip)]
    ZExecstackIfNeeded,
    /// `-z max-page-size=VALUE`.
    #[arg(skip)]
    ZMaxPageSize(OsString),
    /// `-z start-stop-visibility=protected`.
    #[arg(skip)]
    ZStartStopVisibilityProtected,
    /// `-z start-stop-visibility=hidden`.
    #[arg(skip)]
    ZStartStopVisibilityHidden,
    /// `-z noexecstack`.
    #[arg(skip)]
    ZNoexecstack,
    /// `-z relro`.
    #[arg(skip)]
    ZRelro,
    /// `-z norelro`.
    #[arg(skip)]
    ZNorelro,
    /// `-z undefs`.
    #[arg(skip)]
    ZUndefs,
    /// `-z nodlopen`.
    #[arg(skip)]
    ZNodlopen,
    /// `-z nodelete`.
    #[arg(skip)]
    ZNodelete,
    /// `-z nocopyreloc`.
    #[arg(skip)]
    ZNocopyreloc,
    /// `-z nodump`.
    #[arg(skip)]
    ZNodump,
    /// `-z initfirst`.
    #[arg(skip)]
    ZInitfirst,
    /// `-z interpose`.
    #[arg(skip)]
    ZInterpose,
    /// `-z ibt`.
    #[arg(skip)]
    ZIbt,
    /// `-z ibtplt`.
    #[arg(skip)]
    ZIbtplt,
    /// `-z force-bti`.
    #[arg(skip)]
    ZForceBti,
    /// `-z pac-plt`.
    #[arg(skip)]
    ZPacPlt,
    /// `-z gcs=implicit`.
    #[arg(skip)]
    ZGcsImplicit,
    /// `-z gcs=never`.
    #[arg(skip)]
    ZGcsNever,
    /// `-z gcs=always`.
    #[arg(skip)]
    ZGcsAlways,
    /// `-z muldefs`.
    #[arg(skip)]
    ZMuldefs,
    /// `-z keep-text-section-prefix`.
    #[arg(skip)]
    ZKeepTextSectionPrefix,
    /// `-z nokeep-text-section-prefix`.
    #[arg(skip)]
    ZNokeepTextSectionPrefix,
    /// `-z shstk`.
    #[arg(skip)]
    ZShstk,
    /// `-z text`.
    #[arg(skip)]
    ZText,
    /// `-z notext`.
    #[arg(skip)]
    ZNotext,
    /// `-z textoff`.
    #[arg(skip)]
    ZTextoff,
    /// `-z origin`.
    #[arg(skip)]
    ZOrigin,
    /// `-z nodefaultlib`.
    #[arg(skip)]
    ZNodefaultlib,
    /// `-z separate-loadable-segments`.
    #[arg(skip)]
    ZSeparateLoadableSegments,
    /// `-z separate-code`.
    #[arg(skip)]
    ZSeparateCode,
    /// `-z noseparate-code`.
    #[arg(skip)]
    ZNoseparateCode,
    /// `-z stack-size=VALUE`.
    #[arg(skip)]
    ZStackSize(OsString),
    /// `-z dynamic-undefined-weak`.
    #[arg(skip)]
    ZDynamicUndefinedWeak,
    /// `-z nodynamic-undefined-weak`.
    #[arg(skip)]
    ZNodynamicUndefinedWeak,
    /// `-z sectionheader`.
    #[arg(skip)]
    ZSectionheader,
    /// `-z nosectionheader`.
    #[arg(skip)]
    ZNosectionheader,
    /// `-z rodynamic`.
    #[arg(skip)]
    ZRodynamic,
    /// `-z x86-64-v2`.
    #[arg(skip)]
    ZX8664V2,
    /// `-z x86-64-v3`.
    #[arg(skip)]
    ZX8664V3,
    /// `-z x86-64-v4`.
    #[arg(skip)]
    ZX8664V4,
    /// `-z rewrite-endbr`.
    #[arg(skip)]
    ZRewriteEndbr,
    /// `-z norewrite-endbr`.
    #[arg(skip)]
    ZNorewriteEndbr,
    /// A flag nothing above names, whole: `--lto-O3`, or an error.
    #[arg(unknown)]
    Unknown(OsString),
    /// Several short options in one word (`-sS`): accepted, with a warning,
    /// as GNU ld does.
    #[arg(bundle)]
    Grouped(OsString),
    /// An input file.
    #[arg(positional)]
    Input(OsString),
}

/// The option a `-z` keyword stands for, as mold reads `-z` (the exact
/// keyword, or `name=value`); `None` for an unknown one.
fn z_opt(word: &OsStr) -> Option<Item> {
    let word = word.to_str()?;
    Some(match word {
        "pack-relative-relocs" => Item::PackDynRelocs(OsString::from("relr")),
        "nopack-relative-relocs" => Item::PackDynRelocs(OsString::from("none")),
        "now" => Item::ZNow,
        "lazy" => Item::ZLazy,
        "cet-report=none" => Item::ZCetReportNone,
        "cet-report=warning" => Item::ZCetReportWarning,
        "cet-report=error" => Item::ZCetReportError,
        "bti-report=none" => Item::ZBtiReportNone,
        "bti-report=warning" => Item::ZBtiReportWarning,
        "bti-report=error" => Item::ZBtiReportError,
        "gcs-report=none" => Item::ZGcsReportNone,
        "gcs-report=warning" => Item::ZGcsReportWarning,
        "gcs-report=error" => Item::ZGcsReportError,
        "execstack" => Item::ZExecstack,
        "execstack-if-needed" => Item::ZExecstackIfNeeded,
        "start-stop-visibility=protected" => Item::ZStartStopVisibilityProtected,
        "start-stop-visibility=hidden" => Item::ZStartStopVisibilityHidden,
        "noexecstack" => Item::ZNoexecstack,
        "relro" => Item::ZRelro,
        "norelro" => Item::ZNorelro,
        "defs" => Item::NoUndefined,
        "undefs" => Item::ZUndefs,
        "nodlopen" => Item::ZNodlopen,
        "nodelete" => Item::ZNodelete,
        "nocopyreloc" => Item::ZNocopyreloc,
        "nodump" => Item::ZNodump,
        "initfirst" => Item::ZInitfirst,
        "interpose" => Item::ZInterpose,
        "ibt" => Item::ZIbt,
        "ibtplt" => Item::ZIbtplt,
        "force-bti" => Item::ZForceBti,
        "pac-plt" => Item::ZPacPlt,
        "gcs=implicit" => Item::ZGcsImplicit,
        "gcs=never" => Item::ZGcsNever,
        "gcs=always" => Item::ZGcsAlways,
        "muldefs" => Item::ZMuldefs,
        "keep-text-section-prefix" => Item::ZKeepTextSectionPrefix,
        "nokeep-text-section-prefix" => Item::ZNokeepTextSectionPrefix,
        "shstk" => Item::ZShstk,
        "text" => Item::ZText,
        "notext" => Item::ZNotext,
        "textoff" => Item::ZTextoff,
        "origin" => Item::ZOrigin,
        "nodefaultlib" => Item::ZNodefaultlib,
        "separate-loadable-segments" => Item::ZSeparateLoadableSegments,
        "separate-code" => Item::ZSeparateCode,
        "noseparate-code" => Item::ZNoseparateCode,
        "dynamic-undefined-weak" => Item::ZDynamicUndefinedWeak,
        "nodynamic-undefined-weak" => Item::ZNodynamicUndefinedWeak,
        "sectionheader" => Item::ZSectionheader,
        "nosectionheader" => Item::ZNosectionheader,
        "rodynamic" => Item::ZRodynamic,
        "x86-64-v2" => Item::ZX8664V2,
        "x86-64-v3" => Item::ZX8664V3,
        "x86-64-v4" => Item::ZX8664V4,
        "rewrite-endbr" => Item::ZRewriteEndbr,
        "norewrite-endbr" => Item::ZNorewriteEndbr,
        "combreloc" => Item::IgnoredShortO(OsString::new()),
        "nocombreloc" => Item::IgnoredShortO(OsString::new()),
        _ => {
            if let Some(value) = word.strip_prefix("max-page-size=") {
                return Some(Item::ZMaxPageSize(OsString::from(value)));
            }
            if let Some(value) = word.strip_prefix("stack-size=") {
                return Some(Item::ZStackSize(OsString::from(value)));
            }
            if let Some(value) = word.strip_prefix("common-page-size=") {
                let _ = value;
                return Some(Item::IgnoredShortO(OsString::new()));
            }
            return None;
        }
    })
}

fn main() {
    let args: Vec<OsString> = std::env::args_os().skip(1).collect();
    let mut files = ResponseFiles::default();
    let words = match expand(&args, &mut files) {
        Ok(words) => words,
        Err(error) => {
            eprintln!("error: {error}");
            std::process::exit(2);
        }
    };
    if let Some(n) = std::env::var("PARSE_N")
        .ok()
        .and_then(|n| n.parse::<usize>().ok())
    {
        for _ in 0..n {
            let _ = std::hint::black_box(Cli::parse_words(std::hint::black_box(&words)));
        }
        return;
    }
    match Cli::parse_words(&words) {
        Ok(cli) => {
            for item in cli.items {
                let item = match item {
                    Item::Z(z) => z_opt(&z.value).unwrap_or(Item::Z(z)),
                    item => item,
                };
                println!("{item:?}");
            }
        }
        Err(error) => std::process::exit(winnow_args::report(&error, "ld")),
    }
}