maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lld/COFF/Options.td

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

288 lines
13 KiB
TableGen
Raw Normal View History

COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
include "llvm/Option/OptParser.td"
// link.exe accepts options starting with either a dash or a slash.
// Flag that takes no arguments.
lld-link: Allow /? as option prefix, like -? is allowed link.exe seems to allow `/?foo` and `-?foo` in addition to `/foo` and `-foo`. Since lld-link already supports the `-?foo` spelling, support `/?foo` as well. Differential Revision: https://reviews.llvm.org/D61375 llvm-svn: 360150
2019-05-07 22:15:35 +08:00
class F<string name> : Flag<["/", "-", "/?", "-?"], name>;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
// Flag that takes one argument after ":".
class P<string name, string help> :
lld-link: Allow /? as option prefix, like -? is allowed link.exe seems to allow `/?foo` and `-?foo` in addition to `/foo` and `-foo`. Since lld-link already supports the `-?foo` spelling, support `/?foo` as well. Differential Revision: https://reviews.llvm.org/D61375 llvm-svn: 360150
2019-05-07 22:15:35 +08:00
Joined<["/", "-", "/?", "-?"], name#":">, HelpText<help>;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
[LLD] [COFF] Add a private option for setting the os version separately from subsystem version The MinGW driver has separate options for OS and subsystem version. Having this available in lld-link allows the MinGW driver to both match GNU ld better and simplifies the code for merging two (potentially mismatching) arguments into one. Differential Revision: https://reviews.llvm.org/D88802
2020-10-04 06:29:45 +08:00
// Same as P<> above, but without help texts, for private undocumented
// options.
class P_priv<string name> :
Joined<["/", "-", "/?", "-?"], name#":">;
[COFF] Clean up boolean flag handling LLD's handling of boolean flags is suboptimal: * All boolean flags have a corresponding `:no` flag to turn the flag off, and the linker should scan for both the non-suffixed and suffixed flags (and the last one should win), but right now it only scans for either the suffixed or non-suffixed flag (depending on the default flag value). * The `B` multiclass only allows specifying help text for the suffixed (`:no`) flag, but for some flags (e.g. `/appcontainer`) the help text should be associated with the non-suffixed flag instead. Extend the `B` multiclass to have help text for both non-suffixed and suffixed flag variants, and alter the existing help text accordingly in some cases. Scan for both the non-suffixed and suffixed variants in the driver and set config values accordingly. This should mostly have no behavior change, apart from the added help text and the modified argument scanning. Some flags are handled slightly differently now, however; for example, LLD would previously always treat 64-bit images as large address aware, whereas `/largeaddressaware:no` is now respected for 64-bit images (which is also how link.exe behaves). Differential Revision: https://reviews.llvm.org/D39216 llvm-svn: 316501
2017-10-25 05:17:16 +08:00
// Boolean flag which can be suffixed by ":no". Using it unsuffixed turns the
// flag on and using it suffixed by ":no" turns it off.
multiclass B<string name, string help_on, string help_off> {
def "" : F<name>, HelpText<help_on>;
def _no : F<name#":no">, HelpText<help_off>;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
}
[LLD] [COFF] Add options for disabling auto import and runtime pseudo relocs Allow disabling either the full auto import feature, or just forbidding the cases that require runtime fixups. As long as all auto imported variables are referenced from separate .refptr$<name> sections, we can alias them on top of the IAT entries and don't actually need any runtime fixups via pseudo relocations. LLVM generates references to variables in .refptr stubs, if it isn't known that the variable for sure is defined in the same object module. Runtime pseudo relocs are needed if the addresses of auto imported variables are used in constant initializers though. Fixing up runtime pseudo relocations requires the use of VirtualProtect (which is disallowed in WinStore/UWP apps) or VirtualProtectFromApp. To allow any risk of ambiguity, allow rejecting cases that would require this at the linker stage. This adds support for the --disable-runtime-pseudo-reloc and --disable-auto-import options in the MinGW driver (matching GNU ld.bfd) with corresponding lld private options in the COFF driver. Differential Revision: https://reviews.llvm.org/D78923
2020-04-26 05:49:44 +08:00
// Same as B<> above, but without help texts, for private undocumented
// options.
multiclass B_priv<string name> {
def "" : F<name>;
def _no : F<name#":no">;
}
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def align : P<"align", "Section alignment">;
[COFF] Add support for aligncomm directives These are emitted for comm symbols in object files, when targeting a GNU environment. Alternatively, just ignore them since we already align CommonChunk to the natural size of the content (up to 32 bytes). That would only trade away the possibility to overalign small symbols, which doesn't sound like something that might not need to be handled? Differential Revision: https://reviews.llvm.org/D36304 llvm-svn: 310871
2017-08-15 03:07:27 +08:00
def aligncomm : P<"aligncomm", "Set common symbol alignment">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def alternatename : P<"alternatename", "Define weak alias">;
def base : P<"base", "Base address of the program">;
lld-link: Add --color-diagnostics(={always,never,auto})?, --no-color-diagnostics flags. This is most useful when using lld-link on a non-Win host (but it might become useful on Windows too if lld also grows a fansi-escape-codes flag). Also make the help for --color-diagnostic mention the valid values in ELF and wasm, and print the flag name with two dashes in diags, since the one-dash form is seen as a list of many one-letter flags in some contexts. https://reviews.llvm.org/D46693 llvm-svn: 332012
2018-05-11 02:19:02 +08:00
def color_diagnostics: Flag<["--"], "color-diagnostics">,
lld: Add --color-diagnostic to MachO port, harmonize others This adds `--[no-]color-diagnostics[=auto,never,always]` to the MachO port and harmonizes the flag in the other ports: - Consistently use MetaVarName - Consistently document the non-eq version as alias of the eq version - Use B<> in the ports that have it (no-op, shorter) - Fix oversight in COFF port that made the --no flag have the wrong prefix Differential Revision: https://reviews.llvm.org/D91640
2020-11-18 01:15:42 +08:00
HelpText<"Alias for --color-diagnostics=always">;
def no_color_diagnostics: Flag<["--"], "no-color-diagnostics">,
HelpText<"Alias for --color-diagnostics=never">;
lld-link: Add --color-diagnostics(={always,never,auto})?, --no-color-diagnostics flags. This is most useful when using lld-link on a non-Win host (but it might become useful on Windows too if lld also grows a fansi-escape-codes flag). Also make the help for --color-diagnostic mention the valid values in ELF and wasm, and print the flag name with two dashes in diags, since the one-dash form is seen as a list of many one-letter flags in some contexts. https://reviews.llvm.org/D46693 llvm-svn: 332012
2018-05-11 02:19:02 +08:00
def color_diagnostics_eq: Joined<["--"], "color-diagnostics=">,
lld: Add --color-diagnostic to MachO port, harmonize others This adds `--[no-]color-diagnostics[=auto,never,always]` to the MachO port and harmonizes the flag in the other ports: - Consistently use MetaVarName - Consistently document the non-eq version as alias of the eq version - Use B<> in the ports that have it (no-op, shorter) - Fix oversight in COFF port that made the --no flag have the wrong prefix Differential Revision: https://reviews.llvm.org/D91640
2020-11-18 01:15:42 +08:00
HelpText<"Use colors in diagnostics (default: auto)">,
MetaVarName<"[auto,always,never]">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def defaultlib : P<"defaultlib", "Add the library to the list of input files">;
def delayload : P<"delayload", "Delay loaded DLL name">;
def entry : P<"entry", "Name of entry point symbol">;
[COFF] support /ERRORLIMIT option Summary: This adds support for reporting multiple errors in a single invocation of lld-link. The limit defaults to 20 and can be changed with the /ERRORLIMIT command line parameter, or set to unlimited by passing a value of 0. This is a new attempt after r295507, which was reverted because opening files raced with exiting early, causing the test to be flaky. This version avoids the race by exiting before calling enqueuePath. Reviewers: pcc, ruiu Reviewed By: ruiu Subscribers: llvm-commits, dblaikie Differential Revision: https://reviews.llvm.org/D31688 llvm-svn: 299496
2017-04-05 08:43:54 +08:00
def errorlimit : P<"errorlimit",
"Maximum number of errors to emit before stopping (0 = no limit)">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def export : P<"export", "Export a function">;
// No help text because /failifmismatch is not intended to be used by the user.
def failifmismatch : P<"failifmismatch", "">;
[LLD][COFF] Implement /filealign parameter Patch by Stefan Schmidt. This adds the /filealign parameter to lld, which allows to specify the section alignment in the output file (as it does on Microsoft's link.exe). This is required to be able to load dynamically linked libraries on the original Xbox, where the debugger monitor expects the section alignment in the file to be the same as in memory. llvm-svn: 361634
2019-05-24 20:42:36 +08:00
def filealign : P<"filealign", "Section alignment in the output file">;
[LLD][COFF] Add support for /FUNCTIONPADMIN command-line option Initial patch by Stefan Reinalter. Fixes PR36775 Differential Revision: https://reviews.llvm.org/D49366 llvm-svn: 354716
2019-02-23 09:46:18 +08:00
def functionpadmin : F<"functionpadmin">;
lld-link: Make Options.td formatting more self-consistent. Also tighten up help strings for /force, --start-lib, and --end-lib. Differential Revision: https://reviews.llvm.org/D67457 llvm-svn: 371927
2019-09-15 07:41:42 +08:00
def functionpadmin_opt : P<"functionpadmin",
"Prepares an image for hotpatching">;
[COFF] Add minimal support for /guard:cf Summary: This patch adds some initial support for Windows control flow guard. At the end of the day, the linker needs to synthesize a table of RVAs very similar to the structured exception handler table (/safeseh). Both /safeseh and /guard:cf take sections of symbol table indices (.sxdata and .gfids$y) and turn them into RVA tables referenced by the load config struct in the CRT through special symbols. Reviewers: ruiu, amccarth Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D42592 llvm-svn: 324306
2018-02-06 09:58:26 +08:00
def guard : P<"guard", "Control flow guard">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def heap : P<"heap", "Size of the heap">;
[COFF] support /ignore:4217 Summary: lld-link accepts link.exe's /ignore option, but used to ignore it. This can lead to semantic differences when warnings are treated as fatal errors. One such case is when we resolve an __imp_ symbol to a local definition. We emit a warning in that case, which /wx turns into a fatal. This change makes lld-link accept /ignore:4217 to suppress that warning, so that code that links with link.exe /wx /ignore:4217 links with lld-link, too. Fixes PR35762. Reviewers: rnk, ruiu Reviewed By: ruiu Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D41606 llvm-svn: 321512
2017-12-28 15:02:13 +08:00
def ignore : P<"ignore", "Specify warning codes to ignore">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def implib : P<"implib", "Import library name">;
lld-link: Add /lib to Options.td so that it appears in lld-link's help output. https://reviews.llvm.org/D49319 llvm-svn: 337086
2018-07-14 12:07:51 +08:00
def lib : F<"lib">,
HelpText<"Act like lib.exe; must be first argument if present">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def libpath : P<"libpath", "Additional library search path">;
lld-link: Let LLD_REPRODUCE control /reproduce:, like in ld.lld Also sync help texts for the option between elf and coff ports. Decisions: - Do this even if /lldignoreenv is passed. /reproduce: does not affect the main output, and this makes the env var more convenient to use. (On the other hand, it's now possible to set this env var and forget about it, and all future builds in the same shell will be much slower. That's true for ld.lld, but posix shells have an easy way to set an env var for a single command; in cmd.exe this is not possible without contortions. Then again, lld-link runs in posix shells too.) Original patch rebased across D68378 and D68381. Differential Revision: https://reviews.llvm.org/D67707
2020-11-28 02:33:55 +08:00
def linkrepro : Joined<["/", "-", "/?", "-?"], "linkrepro:">,
MetaVarName<"directory">,
HelpText<"Write repro.tar containing inputs and command to reproduce link">;
lld-link: Add a flag /lldignoreenv that makes lld-link ignore env vars. This is useful for enforcing that builds are independent of the environment; it can be used when all system library paths are added via /libpath: already. It's similar ot cl.exe's /X flag. Since it should also affect %LINK% (the other caller of `Process::GetEnv` in lld/COFF), the early-option-parsing needs to move around a bit. The options are: - Add a manual loop over the argv ArrayRef and look for "/lldignoreenv". This repeats the name of the flag in both Options.td and in DriverUtils.cpp. - Add yet another table.ParseArgs() call just for /lldignoreenv before adding %LINK%. - Use the existing early ParseArgs() that's there for --rsp-quoting and use it for /lldignoreenv for %LINK% as well. This means --rsp-quoting and /lldignoreenv can't be passed via %LINK%. I went with the third approach. Differential Revision: https://reviews.llvm.org/D67456 llvm-svn: 371852
2019-09-13 21:13:52 +08:00
def lldignoreenv : F<"lldignoreenv">,
HelpText<"Ignore environment variables like %LIB%">;
lld-link: Make Options.td formatting more self-consistent. Also tighten up help strings for /force, --start-lib, and --end-lib. Differential Revision: https://reviews.llvm.org/D67457 llvm-svn: 371927
2019-09-15 07:41:42 +08:00
def lldltocache : P<"lldltocache",
"Path to ThinLTO cached object file directory">;
def lldltocachepolicy : P<"lldltocachepolicy",
"Pruning policy for the ThinLTO cache">;
[COFF] added support for /lldsavetemps Summary: This adds an option to save temporary files generated during link-time optimization. This can be useful for debugging. Reviewers: ruiu, pcc Reviewed By: ruiu, pcc Subscribers: mehdi_amini Differential Revision: https://reviews.llvm.org/D29518 llvm-svn: 294498
2017-02-09 02:36:41 +08:00
def lldsavetemps : F<"lldsavetemps">,
HelpText<"Save temporary files instead of deleting them">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def machine : P<"machine", "Specify target platform">;
def merge : P<"merge", "Combine sections">;
def mllvm : P<"mllvm", "Options to pass to LLVM">;
def nodefaultlib : P<"nodefaultlib", "Remove a default library">;
def opt : P<"opt", "Control optimizations">;
Add the /order option. With the /order option, you can give an order file. An order file contains symbol names, one per line, and the linker places comdat sections in that given order. The option is used often to optimize an output binary for (in particular, startup) speed by improving locality. Differential Revision: https://reviews.llvm.org/D42598 llvm-svn: 323579
2018-01-27 08:34:46 +08:00
def order : P<"order", "Put functions in order">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def out : P<"out", "Path to file to write output">;
[PDB] Resubmit "Support embedding natvis files in PDBs." This was reverted several times due to what ultimately turned out to be incompatibilities in our serialized hash table format. Several changes went in prior to this to fix those issues since they were more fundamental and independent of supporting injected sources, so now that those are fixed this change should hopefully pass. llvm-svn: 328363
2018-03-24 03:57:25 +08:00
def natvis : P<"natvis", "Path to natvis file to embed in the PDB">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def pdb : P<"pdb", "PDB file path">;
[COFF] Warn that LLD does not support /PDBSTRIPPED: Doesn't really fix PR44491, but it avoids treating it as an input.
2020-01-16 07:09:25 +08:00
def pdbstripped : P<"pdbstripped", "Stripped PDB file path">;
COFF: Document /pdbaltpath. llvm-svn: 330488
2018-04-21 06:11:28 +08:00
def pdbaltpath : P<"pdbaltpath", "PDB file path to embed in the image">;
[ms] Add new /PDBSTREAM option to lld-link allowing injection of streams into PDB files. Summary: /PDBSTREAM:<name>=<file> adds the contents of <file> to stream <name> in the resulting PDB. This allows native uses with workflows that (for example) add srcsrv streams to PDB files to provide a location for the build's source files. Results should be equivalent to linking with lld-link, then running Microsoft's pdbstr tool with the command line: pdbstr.exe -w -p:<PDB LOCATION> -s:<name> -i:<file> except in cases where the named stream overlaps with a default named stream, such as "/names". In those cases, the added stream will be overridden, making the /pdbstream option a no-op. Reviewers: thakis, rnk Reviewed By: thakis Differential Revision: https://reviews.llvm.org/D77310
2020-04-08 04:16:22 +08:00
def pdbstream : Joined<["/", "-", "/?", "-?"], "pdbstream:">,
MetaVarName<"<name>=<file>">,
HelpText<"Embed the contents of <file> in the PDB as named stream <name>">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def section : P<"section", "Specify section attributes">;
def stack : P<"stack", "Size of the stack">;
def stub : P<"stub", "Specify DOS stub file">;
def subsystem : P<"subsystem", "Specify subsystem">;
[COFF] Add /Brepro and /TIMESTAMP options. Previously we would always write a hash of the binary into the PE file, for reproducible builds. This breaks AppCompat, which is a feature of Windows that relies on the timestamp in the PE header being set to a real value (or at the very least, a value that satisfies certain properties). To address this, we put the old behavior of writing the hash behind the /Brepro flag, which mimics MSVC linker behavior. We also match MSVC default behavior, which is to write an actual timestamp to the PE header. Finally, we add the /TIMESTAMP option (an lld extension) so that the user can specify the exact value to be used in case he/she manually constructs a value which is both reproducible and satisfies AppCompat. Differential Revision: https://reviews.llvm.org/D46966 llvm-svn: 332613
2018-05-17 23:11:01 +08:00
def timestamp : P<"timestamp", "Specify the PE header timestamp">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def version : P<"version", "Specify a version number in the PE header">;
lld-link: Make Options.td formatting more self-consistent. Also tighten up help strings for /force, --start-lib, and --end-lib. Differential Revision: https://reviews.llvm.org/D67457 llvm-svn: 371927
2019-09-15 07:41:42 +08:00
def wholearchive_file : P<"wholearchive",
"Include all object files from this library">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
lld-link: Allow /? as option prefix, like -? is allowed link.exe seems to allow `/?foo` and `-?foo` in addition to `/foo` and `-foo`. Since lld-link already supports the `-?foo` spelling, support `/?foo` as well. Differential Revision: https://reviews.llvm.org/D61375 llvm-svn: 360150
2019-05-07 22:15:35 +08:00
def disallowlib : Joined<["/", "-", "/?", "-?"], "disallowlib:">,
Alias<nodefaultlib>;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
lld-link: Add help strings for /manifest, /nodefaultlib, /noentry; tweak manifest help strings My main motivation is that I can never remember /nodefaultlib and `lld-link /? | grep no` didn't display it due to it not having a help string. Differential Revision: https://reviews.llvm.org/D56502 llvm-svn: 350750
2019-01-10 03:18:03 +08:00
def manifest : F<"manifest">, HelpText<"Create .manifest file">;
def manifest_colon : P<
"manifest",
"NO disables manifest output; EMBED[,ID=#] embeds manifest as resource in the image">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def manifestuac : P<"manifestuac", "User access control">;
lld-link: Add help strings for /manifest, /nodefaultlib, /noentry; tweak manifest help strings My main motivation is that I can never remember /nodefaultlib and `lld-link /? | grep no` didn't display it due to it not having a help string. Differential Revision: https://reviews.llvm.org/D56502 llvm-svn: 350750
2019-01-10 03:18:03 +08:00
def manifestfile : P<"manifestfile", "Manifest output path, with /manifest">;
def manifestdependency : P<
"manifestdependency",
"Attributes for <dependency> element in manifest file; implies /manifest">;
def manifestinput : P<
"manifestinput",
"Additional manifest inputs; only valid with /manifest:embed">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
// We cannot use multiclass P because class name "incl" is different
// from its command line option name. We do this because "include" is
// a reserved keyword in tablegen.
lld-link: Allow /? as option prefix, like -? is allowed link.exe seems to allow `/?foo` and `-?foo` in addition to `/foo` and `-foo`. Since lld-link already supports the `-?foo` spelling, support `/?foo` as well. Differential Revision: https://reviews.llvm.org/D61375 llvm-svn: 360150
2019-05-07 22:15:35 +08:00
def incl : Joined<["/", "-", "/?", "-?"], "include:">,
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
HelpText<"Force symbol to be added to symbol table as undefined one">;
// "def" is also a keyword.
lld-link: Allow /? as option prefix, like -? is allowed link.exe seems to allow `/?foo` and `-?foo` in addition to `/foo` and `-foo`. Since lld-link already supports the `-?foo` spelling, support `/?foo` as well. Differential Revision: https://reviews.llvm.org/D61375 llvm-svn: 360150
2019-05-07 22:15:35 +08:00
def deffile : Joined<["/", "-", "/?", "-?"], "def:">,
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
HelpText<"Use module-definition file">;
Add some help strings for /dll and /debug so they show up in /? llvm-svn: 243757
2015-08-01 00:40:38 +08:00
def debug : F<"debug">, HelpText<"Embed a symbol table in the image">;
[lld-link] Generalize handling of /debug and /debug:{none,full,fastlink,ghash,symtab} Implement final argument precedence if multiple /debug arguments are passed on the command-line to match expected link.exe behavior. Support /debug:none and emit warning for /debug:fastlink with automatic fallback to /debug:full. Emit error if last /debug:option is unknown. Emit warning if last /debugtype:option is unknown. https://reviews.llvm.org/D50404 llvm-svn: 342894
2018-09-24 23:28:03 +08:00
def debug_opt : P<"debug", "Embed a symbol table in the image with option">;
COFF: handle /debugtype option Add the support infrastructure for the /debugtype option which takes a comma delimited list of debug info to generate. The defaults are based on other options potentially (/driver or /profile). This sets up the infrastructure to allow us to emit RSDS records to get "build id" equivalents on COFF (similar to binutils). llvm-svn: 278056
2016-08-09 06:02:44 +08:00
def debugtype : P<"debugtype", "Debug Info Options">;
Add some help strings for /dll and /debug so they show up in /? llvm-svn: 243757
2015-08-01 00:40:38 +08:00
def dll : F<"dll">, HelpText<"Create a DLL">;
Implement /driver, /driver:wdm and /driver:uponly This patch implements /driver, /driver:wdm and /driver:uponly as described in https://docs.microsoft.com/en-us/cpp/build/reference/driver-windows-nt-kernel-mode-driver?view=vs-2019. Differential Revision: https://reviews.llvm.org/D70162
2019-11-13 12:53:15 +08:00
def driver : F<"driver">, HelpText<"Generate a Windows NT Kernel Mode Driver">;
def driver_wdm : F<"driver:wdm">,
HelpText<"Set IMAGE_FILE_UP_SYSTEM_ONLY bit in PE header">;
def driver_uponly : F<"driver:uponly">,
HelpText<"Set IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER bit in PE header">;
def driver_wdm_uponly : F<"driver:wdm,uponly">;
def driver_uponly_wdm : F<"driver:uponly,wdm">;
lld-link: Add help strings for /manifest, /nodefaultlib, /noentry; tweak manifest help strings My main motivation is that I can never remember /nodefaultlib and `lld-link /? | grep no` didn't display it due to it not having a help string. Differential Revision: https://reviews.llvm.org/D56502 llvm-svn: 350750
2019-01-10 03:18:03 +08:00
def nodefaultlib_all : F<"nodefaultlib">,
HelpText<"Remove all default libraries">;
def noentry : F<"noentry">,
HelpText<"Don't add reference to DllMainCRTStartup; only valid with /dll">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def profile : F<"profile">;
lld-link: Add help strings for /manifest, /nodefaultlib, /noentry; tweak manifest help strings My main motivation is that I can never remember /nodefaultlib and `lld-link /? | grep no` didn't display it due to it not having a help string. Differential Revision: https://reviews.llvm.org/D56502 llvm-svn: 350750
2019-01-10 03:18:03 +08:00
def repro : F<"Brepro">,
HelpText<"Use a hash of the executable as the PE header timestamp">;
lld-link: Let LLD_REPRODUCE control /reproduce:, like in ld.lld Also sync help texts for the option between elf and coff ports. Decisions: - Do this even if /lldignoreenv is passed. /reproduce: does not affect the main output, and this makes the env var more convenient to use. (On the other hand, it's now possible to set this env var and forget about it, and all future builds in the same shell will be much slower. That's true for ld.lld, but posix shells have an easy way to set an env var for a single command; in cmd.exe this is not possible without contortions. Then again, lld-link runs in posix shells too.) Original patch rebased across D68378 and D68381. Differential Revision: https://reviews.llvm.org/D67707
2020-11-28 02:33:55 +08:00
def reproduce : Joined<["/", "-", "/?", "-?"], "reproduce:">,
MetaVarName<"filename">,
HelpText<"Write tar file containing inputs and command to reproduce link">;
lld-link: Implement /swaprun: flag r191276 added this to old LLD, but it never made it to new LLD -- except that the flag was in Options.td, so it was silently ignored. I figured it should be easy to implement, so I did that instead of removing the flags from Options.td. I then discovered that link.exe also supports comma-separated lists of 'cd' and 'net', which made the parsing code a bit annoying. The Alias technique in Options.td is to get nice help output. Differential Revision: https://reviews.llvm.org/D61067 llvm-svn: 359192
2019-04-25 22:02:26 +08:00
def swaprun : P<"swaprun",
"Comma-separated list of 'cd' or 'net'">;
def swaprun_cd : F<"swaprun:cd">, Alias<swaprun>, AliasArgs<["cd"]>,
HelpText<"Make loader run output binary from swap instead of from CD">;
def swaprun_net : F<"swaprun:net">, Alias<swaprun>, AliasArgs<["net"]>,
HelpText<"Make loader run output binary from swap instead of from network">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def verbose : F<"verbose">;
lld-link: Make Options.td formatting more self-consistent. Also tighten up help strings for /force, --start-lib, and --end-lib. Differential Revision: https://reviews.llvm.org/D67457 llvm-svn: 371927
2019-09-15 07:41:42 +08:00
def wholearchive_flag : F<"wholearchive">,
HelpText<"Include all object files from all libraries">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def force : F<"force">,
lld-link: Make Options.td formatting more self-consistent. Also tighten up help strings for /force, --start-lib, and --end-lib. Differential Revision: https://reviews.llvm.org/D67457 llvm-svn: 371927
2019-09-15 07:41:42 +08:00
HelpText<"Allow undefined and multiply defined symbols">;
COFF: Add support for /force:multiple option Patch by Thomas Roughton. This patch adds support for linking with multiple definitions to LLD's COFF driver, in line with link.exe's /force:multiple option. Differential Revision: https://reviews.llvm.org/D50598 llvm-svn: 342191
2018-09-14 06:05:10 +08:00
def force_unresolved : F<"force:unresolved">,
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
HelpText<"Allow undefined symbols when creating executables">;
COFF: Add support for /force:multiple option Patch by Thomas Roughton. This patch adds support for linking with multiple definitions to LLD's COFF driver, in line with link.exe's /force:multiple option. Differential Revision: https://reviews.llvm.org/D50598 llvm-svn: 342191
2018-09-14 06:05:10 +08:00
def force_multiple : F<"force:multiple">,
HelpText<"Allow multiply defined symbols when creating executables">;
lld-link: Add /force:multipleres extension to make dupe resource diag non-fatal As a side benefit, lld-link now reports more than one duplicate resource entry before exiting with an error even if the new flag is not passed. llvm-svn: 359829
2019-05-03 05:21:55 +08:00
def force_multipleres : F<"force:multipleres">,
HelpText<"Allow multiply defined resources when creating executables">;
[COFF] Add support for /WX link.exe supports this option to convert warnings into errors, and it's useful to support in LLD as well. Differential Revision: https://reviews.llvm.org/D39148 llvm-svn: 316502
2017-10-25 05:19:22 +08:00
defm WX : B<"WX", "Treat warnings as errors", "Don't treat warnings as errors">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
[COFF] Clean up boolean flag handling LLD's handling of boolean flags is suboptimal: * All boolean flags have a corresponding `:no` flag to turn the flag off, and the linker should scan for both the non-suffixed and suffixed flags (and the last one should win), but right now it only scans for either the suffixed or non-suffixed flag (depending on the default flag value). * The `B` multiclass only allows specifying help text for the suffixed (`:no`) flag, but for some flags (e.g. `/appcontainer`) the help text should be associated with the non-suffixed flag instead. Extend the `B` multiclass to have help text for both non-suffixed and suffixed flag variants, and alter the existing help text accordingly in some cases. Scan for both the non-suffixed and suffixed variants in the driver and set config values accordingly. This should mostly have no behavior change, apart from the added help text and the modified argument scanning. Some flags are handled slightly differently now, however; for example, LLD would previously always treat 64-bit images as large address aware, whereas `/largeaddressaware:no` is now respected for 64-bit images (which is also how link.exe behaves). Differential Revision: https://reviews.llvm.org/D39216 llvm-svn: 316501
2017-10-25 05:17:16 +08:00
defm allowbind : B<"allowbind", "Enable DLL binding (default)",
"Disable DLL binding">;
defm allowisolation : B<"allowisolation", "Enable DLL isolation (default)",
"Disable DLL isolation">;
COFF: support the /appcontainer flag The /appcontainer flag indicates that the module may only be used inside an application container (for isolation). This has been supported by link.exe since Windows 8.0. It sets an additional bit in the PE DLL Characteristics flag to indicate the behavioural change. llvm-svn: 299728
2017-04-07 07:07:53 +08:00
defm appcontainer : B<"appcontainer",
[COFF] Clean up boolean flag handling LLD's handling of boolean flags is suboptimal: * All boolean flags have a corresponding `:no` flag to turn the flag off, and the linker should scan for both the non-suffixed and suffixed flags (and the last one should win), but right now it only scans for either the suffixed or non-suffixed flag (depending on the default flag value). * The `B` multiclass only allows specifying help text for the suffixed (`:no`) flag, but for some flags (e.g. `/appcontainer`) the help text should be associated with the non-suffixed flag instead. Extend the `B` multiclass to have help text for both non-suffixed and suffixed flag variants, and alter the existing help text accordingly in some cases. Scan for both the non-suffixed and suffixed variants in the driver and set config values accordingly. This should mostly have no behavior change, apart from the added help text and the modified argument scanning. Some flags are handled slightly differently now, however; for example, LLD would previously always treat 64-bit images as large address aware, whereas `/largeaddressaware:no` is now respected for 64-bit images (which is also how link.exe behaves). Differential Revision: https://reviews.llvm.org/D39216 llvm-svn: 316501
2017-10-25 05:17:16 +08:00
"Image can only be run in an app container",
"Image can run outside an app container (default)">;
Implement CET Shadow Stack (Intel Controlflow Enforcement Technology) support on Windows Patch by Petr Penzin. Windows support for CET is limited to shadow stack, which is enabled by setting a PE bit in the linker. Docs: MSVC linker flag: https://docs.microsoft.com/en-us/cpp/build/reference/cetcompat?view=vs-2019 IMAGE_DLLCHARACTERISTICS_EX_CET_COMPAT PE bit: https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#extended-dll-characteristics Differential Revision: https://reviews.llvm.org/D70606
2020-03-13 18:41:18 +08:00
defm cetcompat : B<"cetcompat", "Mark executable image as compatible with Control-flow Enforcement Technology (CET) Shadow Stack",
"Don't mark executable image as compatible with Control-flow Enforcement Technology (CET) Shadow Stack (default)">;
[COFF] Clean up boolean flag handling LLD's handling of boolean flags is suboptimal: * All boolean flags have a corresponding `:no` flag to turn the flag off, and the linker should scan for both the non-suffixed and suffixed flags (and the last one should win), but right now it only scans for either the suffixed or non-suffixed flag (depending on the default flag value). * The `B` multiclass only allows specifying help text for the suffixed (`:no`) flag, but for some flags (e.g. `/appcontainer`) the help text should be associated with the non-suffixed flag instead. Extend the `B` multiclass to have help text for both non-suffixed and suffixed flag variants, and alter the existing help text accordingly in some cases. Scan for both the non-suffixed and suffixed variants in the driver and set config values accordingly. This should mostly have no behavior change, apart from the added help text and the modified argument scanning. Some flags are handled slightly differently now, however; for example, LLD would previously always treat 64-bit images as large address aware, whereas `/largeaddressaware:no` is now respected for 64-bit images (which is also how link.exe behaves). Differential Revision: https://reviews.llvm.org/D39216 llvm-svn: 316501
2017-10-25 05:17:16 +08:00
defm dynamicbase : B<"dynamicbase", "Enable ASLR (default unless /fixed)",
"Disable ASLR (default when /fixed)">;
defm fixed : B<"fixed", "Disable base relocations",
"Enable base relocations (default)">;
defm highentropyva : B<"highentropyva",
"Enable 64-bit ASLR (default on 64-bit)",
"Disable 64-bit ASLR">;
[COFF] make /incremental control overwriting unchanged import libraries Summary: r323164 made lld-link not overwrite import libraries when their contents haven't changed. MSVC's link.exe does this only when performing incremental linking. This change makes lld-link's import library overwriting similarly dependent on whether or not incremental linking is being performed. This is controlled by the /incremental or /incremental:no options. In addition, /opt:icf, /opt:ref, and /order turn off /incremental and issue a warning if /incremental was specified on the command line. Reviewers: rnk, ruiu, zturner Reviewed By: ruiu Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D42716 llvm-svn: 323930
2018-02-01 07:44:00 +08:00
defm incremental : B<"incremental",
"Keep original import library if contents are unchanged",
lld-link: Implement /INTEGRITYCHECK flag /INTEGRITYCHECK has the effect of setting IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY. Fixes PR31066. https://reviews.llvm.org/D47472 llvm-svn: 333652
2018-05-31 21:43:02 +08:00
"Overwrite import library even if contents are unchanged">;
defm integritycheck : B<"integritycheck",
"Set FORCE_INTEGRITY bit in PE header",
"No effect (default)">;
[COFF] Clean up boolean flag handling LLD's handling of boolean flags is suboptimal: * All boolean flags have a corresponding `:no` flag to turn the flag off, and the linker should scan for both the non-suffixed and suffixed flags (and the last one should win), but right now it only scans for either the suffixed or non-suffixed flag (depending on the default flag value). * The `B` multiclass only allows specifying help text for the suffixed (`:no`) flag, but for some flags (e.g. `/appcontainer`) the help text should be associated with the non-suffixed flag instead. Extend the `B` multiclass to have help text for both non-suffixed and suffixed flag variants, and alter the existing help text accordingly in some cases. Scan for both the non-suffixed and suffixed variants in the driver and set config values accordingly. This should mostly have no behavior change, apart from the added help text and the modified argument scanning. Some flags are handled slightly differently now, however; for example, LLD would previously always treat 64-bit images as large address aware, whereas `/largeaddressaware:no` is now respected for 64-bit images (which is also how link.exe behaves). Differential Revision: https://reviews.llvm.org/D39216 llvm-svn: 316501
2017-10-25 05:17:16 +08:00
defm largeaddressaware : B<"largeaddressaware",
"Enable large addresses (default on 64-bit)",
"Disable large addresses (default on 32-bit)">;
defm nxcompat : B<"nxcompat", "Enable data execution prevention (default)",
"Disable data execution provention">;
defm safeseh : B<"safeseh",
"Produce an image with Safe Exception Handler (only for x86)",
"Don't produce an image with Safe Exception Handler">;
defm tsaware : B<"tsaware",
"Create Terminal Server aware executable (default)",
"Create non-Terminal Server aware executable">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def help : F<"help">;
lld-link: Allow /? as option prefix, like -? is allowed link.exe seems to allow `/?foo` and `-?foo` in addition to `/foo` and `-foo`. Since lld-link already supports the `-?foo` spelling, support `/?foo` as well. Differential Revision: https://reviews.llvm.org/D61375 llvm-svn: 360150
2019-05-07 22:15:35 +08:00
// /?? and -?? must be before /? and -? to not confuse lib/Options.
def help_q : Flag<["/??", "-??", "/?", "-?"], "">, Alias<help>;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
COFF: Add /nosymtab command line option. This is an LLD extension to MSVC link.exe command line. MSVC linker does not write symbol tables for executables. We do unless no /debug option is given. There's a situation that we want to enable debug info but don't want to emit the symbol table. One example is when we are comparing output file size. With this patch, you can tell the linker to not create a symbol table by just specifying /nosymtab. llvm-svn: 248225
2015-09-22 07:43:31 +08:00
// LLD extensions
[LLD] [COFF] Add options for disabling auto import and runtime pseudo relocs Allow disabling either the full auto import feature, or just forbidding the cases that require runtime fixups. As long as all auto imported variables are referenced from separate .refptr$<name> sections, we can alias them on top of the IAT entries and don't actually need any runtime fixups via pseudo relocations. LLVM generates references to variables in .refptr stubs, if it isn't known that the variable for sure is defined in the same object module. Runtime pseudo relocs are needed if the addresses of auto imported variables are used in constant initializers though. Fixing up runtime pseudo relocations requires the use of VirtualProtect (which is disallowed in WinStore/UWP apps) or VirtualProtectFromApp. To allow any risk of ambiguity, allow rejecting cases that would require this at the linker stage. This adds support for the --disable-runtime-pseudo-reloc and --disable-auto-import options in the MinGW driver (matching GNU ld.bfd) with corresponding lld private options in the COFF driver. Differential Revision: https://reviews.llvm.org/D78923
2020-04-26 05:49:44 +08:00
defm auto_import : B_priv<"auto-import">;
defm runtime_pseudo_reloc : B_priv<"runtime-pseudo-reloc">;
reland "[lld-link] implement -start-lib and -end-lib" Summary: This is a re-land of r370487 with a fix for the use-after-free bug that rev contained. This implements -start-lib and -end-lib flags for lld-link, analogous to the similarly named options in ld.lld. Object files after -start-lib are included in the link only when needed to resolve undefined symbols. The -end-lib flag goes back to the normal behavior of always including object files in the link. This mimics the semantics of static libraries, but without needing to actually create the archive file. Reviewers: ruiu, smeenai, MaskRay Reviewed By: ruiu, MaskRay Subscribers: akhuang, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D66848 llvm-svn: 370816
2019-09-04 04:32:16 +08:00
def end_lib : F<"end-lib">,
lld-link: Let LLD_REPRODUCE control /reproduce:, like in ld.lld Also sync help texts for the option between elf and coff ports. Decisions: - Do this even if /lldignoreenv is passed. /reproduce: does not affect the main output, and this makes the env var more convenient to use. (On the other hand, it's now possible to set this env var and forget about it, and all future builds in the same shell will be much slower. That's true for ld.lld, but posix shells have an easy way to set an env var for a single command; in cmd.exe this is not possible without contortions. Then again, lld-link runs in posix shells too.) Original patch rebased across D68378 and D68381. Differential Revision: https://reviews.llvm.org/D67707
2020-11-28 02:33:55 +08:00
HelpText<"End group of objects treated as if they were in a library">;
[COFF] Add -exclude-all-symbols for MinGW This is a private undocumented option, intended to be used by the MinGW driver frontend. Also restructure the condition to put if (Config->MinGW) first. This changes the behaviour for the tautological combination of -export-all-symbols without -lldmingw. Differential Revision: https://reviews.llvm.org/D58380 llvm-svn: 354386
2019-02-20 05:57:44 +08:00
def exclude_all_symbols : F<"exclude-all-symbols">;
[COFF] Add support for automatically exporting all symbols GNU ld automatically exports all symbols if no symbols have been chosen to export via either def files or dllexport attributes. The same behaviour can also be enabled via the GNU ld option --export-all-symbols, in case some symbols are marked for export via a def file or dllexport attribute. The list of excluded symbols is from GNU ld, minus the cygwin specific symbols. Also add support for outputting the actual list of exported symbols in a def file, as in the GNU ld option --output-def. These options in GNU ld are documented in https://sourceware.org/binutils/docs/ld/WIN32.html. This currently exports all symbols from object files pulled in from libmingw32 and libmingwex and other static libraries that are linked in. Differential Revision: https://reviews.llvm.org/D38760 llvm-svn: 315562
2017-10-12 13:37:13 +08:00
def export_all_symbols : F<"export-all-symbols">;
lld-link: Only print demangled symbol names by default This makes lld-link's output a bit more concise. Since most developers can't read mangled names, this should make the output a bit easier to understand as well. It also makes lld-link's output consistent with ld.lld's output. (link.exe prints both demangled and mangled names; lld-link used to match link.exe output but now no longer does.) For people working on toolchains, add a `/demangle:no` flag that makes lld-link print the mangled name instead of the demangled name. (If desired, people could pipe that through `demumble -b` to get the old behavior of both demangled and mangled output.) Differential Revision: https://reviews.llvm.org/D58132 llvm-svn: 355878
2019-03-12 07:02:18 +08:00
defm demangle : B<"demangle",
"Demangle symbols in output (default)",
"Do not demangle symbols in output">;
[COFF] Add an lld specific option /includeoptional This works like /include, but is not fatal if the requested symbol wasn't found. This allows implementing the GNU ld option -u. Differential Revision: https://reviews.llvm.org/D62976 llvm-svn: 362881
2019-06-09 02:26:18 +08:00
def include_optional : Joined<["/", "-", "/?", "-?"], "includeoptional:">,
HelpText<"Add symbol as undefined, but allow it to remain undefined">;
[COFF] Add support for the GNU ld flag --kill-at GNU ld has got a number of different flags for adjusting how to behave around stdcall functions. The --kill-at flag strips the trailing sdcall suffix from exported functions (which otherwise is included by default in MinGW setups). This also strips it from the corresponding import library though. That makes it hard to link to such an import library from code that calls the functions - but this matches what GNU ld does with this flag. Therefore, this flag is probably not sensibly used together with import libraries, but probably mostly when creating some sort of plugin, or if creating the import library separately with dlltool. Differential Revision: https://reviews.llvm.org/D44292 llvm-svn: 327561
2018-03-15 04:17:16 +08:00
def kill_at : F<"kill-at">;
[MinGW] Support dllexport on i386 In MinGW configurations (GCC, or clang with a *-windows-gnu target), the -export directives in the object file contains the undecorated symbol name, while it is decorated in MSVC configurations. (On the command line, link.exe takes an undecorated symbol name for the -export argument though.) Differential Revision: https://reviews.llvm.org/D37772 llvm-svn: 313174
2017-09-14 03:29:39 +08:00
def lldmingw : F<"lldmingw">;
[LLD] [MinGW] Implement the --no-seh flag Previously this flag was just ignored. If set, set the IMAGE_DLL_CHARACTERISTICS_NO_SEH bit, regardless of the normal safeSEH machinery. In mingw configurations, the safeSEH bit might not be set in e.g. object files built from handwritten assembly, making it impossible to use the normal safeseh flag. As mingw setups don't generally use SEH on 32 bit x86 at all, it should be fine to set that flag bit though - hook up the existing GNU ld flag for controlling that. Differential Revision: https://reviews.llvm.org/D84701
2020-07-28 04:44:41 +08:00
def noseh : F<"noseh">;
[LLD] [COFF] Add a private option for setting the os version separately from subsystem version The MinGW driver has separate options for OS and subsystem version. Having this available in lld-link allows the MinGW driver to both match GNU ld better and simplifies the code for merging two (potentially mismatching) arguments into one. Differential Revision: https://reviews.llvm.org/D88802
2020-10-04 06:29:45 +08:00
def osversion : P_priv<"osversion">;
lld-link: Allow /? as option prefix, like -? is allowed link.exe seems to allow `/?foo` and `-?foo` in addition to `/foo` and `-foo`. Since lld-link already supports the `-?foo` spelling, support `/?foo` as well. Differential Revision: https://reviews.llvm.org/D61375 llvm-svn: 360150
2019-05-07 22:15:35 +08:00
def output_def : Joined<["/", "-", "/?", "-?"], "output-def:">;
[PDB] Add PDBSourcePath flag to support absolutize source file path This patch changes relative path for source files in obj files to absolute path in PDB when linking with added flag. I will make obj file generated by clang-cl independent from build directory for chromium build. But I don't want to confuse visual studio debugger or require additional configuration. To attain this goal, I added flag to convert relative source file path in obj to absolute path when emitting PDB. By removing absolute path from obj files, we can share build cache between chromium developers even when they are doing debug build. That will make build time faster. More context: https://bugs.chromium.org/p/chromium/issues/detail?id=712796 https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/5HXSVX-7fPc llvm-svn: 337439
2018-07-19 12:56:22 +08:00
def pdb_source_path : P<"pdbsourcepath",
lld-link: Make Options.td formatting more self-consistent. Also tighten up help strings for /force, --start-lib, and --end-lib. Differential Revision: https://reviews.llvm.org/D67457 llvm-svn: 371927
2019-09-15 07:41:42 +08:00
"Base path used to make relative source file path absolute in PDB">;
lld-link: Add --rsp-quoting= flag. This ports https://reviews.llvm.org/D19425 from clang / https://reviews.llvm.org/D22015 from the ELF port to COFF lld. This can be useful when linking COFF files on a posix host. https://reviews.llvm.org/D37452 llvm-svn: 312594
2017-09-06 07:46:45 +08:00
def rsp_quoting : Joined<["--"], "rsp-quoting=">,
HelpText<"Quoting style for response files, 'windows' (default) or 'posix'">;
reland "[lld-link] implement -start-lib and -end-lib" Summary: This is a re-land of r370487 with a fix for the use-after-free bug that rev contained. This implements -start-lib and -end-lib flags for lld-link, analogous to the similarly named options in ld.lld. Object files after -start-lib are included in the link only when needed to resolve undefined symbols. The -end-lib flag goes back to the normal behavior of always including object files in the link. This mimics the semantics of static libraries, but without needing to actually create the archive file. Reviewers: ruiu, smeenai, MaskRay Reviewed By: ruiu, MaskRay Subscribers: akhuang, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D66848 llvm-svn: 370816
2019-09-04 04:32:16 +08:00
def start_lib : F<"start-lib">,
lld-link: Let LLD_REPRODUCE control /reproduce:, like in ld.lld Also sync help texts for the option between elf and coff ports. Decisions: - Do this even if /lldignoreenv is passed. /reproduce: does not affect the main output, and this makes the env var more convenient to use. (On the other hand, it's now possible to set this env var and forget about it, and all future builds in the same shell will be much slower. That's true for ld.lld, but posix shells have an easy way to set an env var for a single command; in cmd.exe this is not possible without contortions. Then again, lld-link runs in posix shells too.) Original patch rebased across D68378 and D68381. Differential Revision: https://reviews.llvm.org/D67707
2020-11-28 02:33:55 +08:00
HelpText<"Start group of objects treated as if they were in a library">;
[lld-link] implement -thinlto-index-only Summary: This implements -thinlto-index-only, -thinlto-index-only:, and -thinlto-emit-imports-files options in lld-link. They are analogous to their counterparts in ld.lld: -thinlto-index-only causes us to perform ThinLTO's thin link and write index files, but not perform code generation. -thinlto-index-only: does the same, but also writes a text file listing the native object files expected to be generated. -thinlto-emit-imports-files creates a text file next to each index file, listing the files to import from. Reviewers: ruiu, tejohnson, pcc, rnk Subscribers: mehdi_amini, steven_wu, dexonsmith, arphaman, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D64461 llvm-svn: 365800
2019-07-12 02:03:14 +08:00
def thinlto_emit_imports_files :
F<"thinlto-emit-imports-files">,
HelpText<"Emit .imports files with -thinlto-index-only">;
def thinlto_index_only :
F<"thinlto-index-only">,
HelpText<"Instead of linking, emit ThinLTO index files">;
def thinlto_index_only_arg : P<
"thinlto-index-only",
"-thinlto-index-only and also write native module names to file">;
[lld-link] implement -thinlto-{prefix,object-suffix}-replace Summary: Adds the following two options to lld-link: -thinlto-prefix-replace: allows replacing a prefix in paths generated for ThinLTO. This can be used to ensure index files and native object files are stored in unique directories, allowing multiple distributed ThinLTO links to proceed concurrently. -thinlto-object-suffix-replace: allows replacing a suffix in object file paths involved in ThinLTO. This allows minimized index files to be used for the thin link while storing the paths to the full bitcode files for subsequent steps (code generation and final linking). Reviewers: ruiu, tejohnson, pcc, rnk Subscribers: mehdi_amini, steven_wu, dexonsmith, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D64542 llvm-svn: 365807
2019-07-12 02:48:58 +08:00
def thinlto_object_suffix_replace : P<
"thinlto-object-suffix-replace",
"'old;new' replace old suffix with new suffix in ThinLTO index">;
def thinlto_prefix_replace: P<
"thinlto-prefix-replace",
"'old;new' replace old prefix with new prefix in ThinLTO outputs">;
[lld-link] implement -lto-obj-path Summary: This adds the -lto-obj-path option to lld-link. This can be used to specify a path at which to write a native object file for the full LTO part when using LTO unit splitting. Reviewers: ruiu, tejohnson, pcc, rnk Reviewed By: ruiu, rnk Subscribers: mehdi_amini, steven_wu, dexonsmith, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D65964 llvm-svn: 369559
2019-08-22 02:24:59 +08:00
def lto_obj_path : P<
"lto-obj-path",
"output native object for merged LTO unit to this path">;
Add the --version option. Differential Revision: https://reviews.llvm.org/D38972 llvm-svn: 316329
2017-10-23 22:57:53 +08:00
def dash_dash_version : Flag<["--"], "version">,
HelpText<"Print version information">;
[lld][COFF][ELF][WebAssembly] Replace --[no-]threads /threads[:no] with --threads={1,2,...} /threads:{1,2,...} --no-threads is a name copied from gold. gold has --no-thread, --thread-count and several other --thread-count-*. There are needs to customize the number of threads (running several lld processes concurrently or customizing the number of LTO threads). Having a single --threads=N is a straightforward replacement of gold's --no-threads + --thread-count. --no-threads is used rarely. So just delete --no-threads instead of keeping it for compatibility for a while. If --threads= is specified (ELF,wasm; COFF /threads: is similar), --thinlto-jobs= defaults to --threads=, otherwise all available hardware threads are used. There is currently no way to override a --threads={1,2,...}. It is still a debate whether we should use --threads=all. Reviewed By: rnk, aganea Differential Revision: https://reviews.llvm.org/D76885
2020-03-18 03:40:19 +08:00
def threads
: P<"threads", "Number of threads. '1' disables multi-threading. By "
"default all available hardware threads are used">;
[COFF] Port CallGraphSort to COFF from ELF
2020-07-22 04:46:11 +08:00
def call_graph_ordering_file: P<
"call-graph-ordering-file",
"Layout sections to optimize the given callgraph">;
defm call_graph_profile_sort: B<
"call-graph-profile-sort",
"Reorder sections with call graph profile (default)",
"Do not reorder sections with call graph profile">;
def print_symbol_order: P<
"print-symbol-order",
"Print a symbol order specified by /call-graph-ordering-file and "
"/call-graph-profile-sort into the specified file">;
Reapply [LLD] [COFF] Implement a GNU/ELF like -wrap option Add a simple forwarding option in the MinGW frontend, and implement the private -wrap option in the COFF linker. The feature in lld-link isn't gated by the -lldmingw option, but the option is left as a private, undocumented option primarily used by the MinGW driver. The implementation is significantly based on the support for --wrap in the ELF linker, but many small nuance details are different between the ELF and COFF linkers, ending up with more than a few implementation differences. This fixes https://bugs.llvm.org/show_bug.cgi?id=47384. Differential Revision: https://reviews.llvm.org/D89004 Reapplied with the bitfield member canInline fixed so it doesn't break builds targeting windows.
2020-10-06 18:54:49 +08:00
def wrap : P_priv<"wrap">;
COFF: Add /nosymtab command line option. This is an LLD extension to MSVC link.exe command line. MSVC linker does not write symbol tables for executables. We do unless no /debug option is given. There's a situation that we want to enable debug info but don't want to emit the symbol table. One example is when we are comparing output file size. With this patch, you can tell the linker to not create a symbol table by just specifying /nosymtab. llvm-svn: 248225
2015-09-22 07:43:31 +08:00
COFF: Implement /lldmap flag. This flag can be used to produce a map file, which is essentially a list of objects linked into the final output file together with the RVAs of their symbols. Because our format differs from MSVC's we expose it as a separate flag. Differential Revision: http://reviews.llvm.org/D10773 llvm-svn: 240812
2015-06-27 02:58:24 +08:00
// Flags for debugging
COFF: Support both /lldmap and /lldmap:<file> The former option bases the filename on the output name, e.g. if the link output is a.exe, the map will be written to a.map. This matches the behaviour of link.exe's /MAP option and is useful for creating a map file of each executable when building a large project. Differential Revision: https://reviews.llvm.org/D27595 llvm-svn: 289271
2016-12-10 04:54:44 +08:00
def lldmap : F<"lldmap">;
lld-link: Allow /? as option prefix, like -? is allowed link.exe seems to allow `/?foo` and `-?foo` in addition to `/foo` and `-foo`. Since lld-link already supports the `-?foo` spelling, support `/?foo` as well. Differential Revision: https://reviews.llvm.org/D61375 llvm-svn: 360150
2019-05-07 22:15:35 +08:00
def lldmap_file : Joined<["/", "-", "/?", "-?"], "lldmap:">;
[lld-link] Support /map option, matching link.exe 's /map output format Added support for /map and /map:[filepath]. The output was derived from Microsoft's Link.exe output when using that same option. Note that /MAPINFO support was not added. The previous implementation of MapFile.cpp/.h was meant for /lldmap, and was renamed to LLDMapFile.cpp/.h MapFile.cpp/.h is now for /MAP However, a small fix was added to lldmap, replacing a std::sort with std::stable_sort to enforce reproducibility. Differential Revision: https://reviews.llvm.org/D70557
2020-03-24 05:06:48 +08:00
def map : F<"map">;
def map_file : Joined<["/", "-", "/?", "-?"], "map:">;
[coff] Print detailed timing information with /TIME. The classes used to print and update time information are in common, so other linkers could use this as well if desired. Differential Revision: https://reviews.llvm.org/D41915 llvm-svn: 322736
2018-01-18 03:16:26 +08:00
def show_timing : F<"time">;
[LLD][COFF] Add /summary to print statistics /summary prints information about the data (OBJ/LIB/PDB) processed by LLD. The goal is have an estimate about the inputs and outputs, to better understand where the timings go. Differential Revision: https://reviews.llvm.org/D58599 llvm-svn: 356188
2019-03-15 02:45:08 +08:00
def summary : F<"summary">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
//==============================================================================
// The flags below do nothing. They are defined only for link.exe compatibility.
//==============================================================================
lld-link: Allow /? as option prefix, like -? is allowed link.exe seems to allow `/?foo` and `-?foo` in addition to `/foo` and `-foo`. Since lld-link already supports the `-?foo` spelling, support `/?foo` as well. Differential Revision: https://reviews.llvm.org/D61375 llvm-svn: 360150
2019-05-07 22:15:35 +08:00
class QF<string name> : Joined<["/", "-", "/?", "-?"], name#":">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def ignoreidl : F<"ignoreidl">;
def nologo : F<"nologo">;
COFF: Fix command line option spelling. llvm-svn: 243573
2015-07-30 05:01:15 +08:00
def throwingnew : F<"throwingnew">;
COFF: Ignore /editandcontinue option. llvm-svn: 244626
2015-08-12 00:46:08 +08:00
def editandcontinue : F<"editandcontinue">;
[coff] Accept and ignore another link.exe flag for compatibility This flag disables link.exe's crash handler so that normal windows error reporting and crash dumping occurs. For now it is reasonable for LLD to ignore the flag. Chromium is currently using this flag to collect minidumps of link.exe crashing, and it breaks the LLD build. llvm-svn: 264439
2016-03-26 02:09:29 +08:00
def fastfail : F<"fastfail">;
COFF: Add a new PE/COFF port. This is an initial patch for a section-based COFF linker. The patch has 2300 lines of code including comments and blank lines. Before diving into details, you want to start from reading README because it should give you an overview of the design. All important things are written in the README file, so I write summary here. - The linker is already able to self-link on Windows. - It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.) - It uses much less memory (250MB vs. 2GB virtual memory space to self-host). - IMHO the new code is much simpler and easier to read than the existing PE/COFF port. http://reviews.llvm.org/D10036 llvm-svn: 238458
2015-05-29 03:09:30 +08:00
def delay : QF<"delay">;
def errorreport : QF<"errorreport">;
def idlout : QF<"idlout">;
def maxilksize : QF<"maxilksize">;
def tlbid : QF<"tlbid">;
def tlbout : QF<"tlbout">;
def verbose_all : QF<"verbose">;
COFF: Ignore /GUARDSYM option. The option is added in MSVC 2015, and there's no documentation about what the option is. This patch is to ignore the option for now, so that at least LLD is usable with MSVC 2015. llvm-svn: 246780
2015-09-04 00:20:47 +08:00
def guardsym : QF<"guardsym">;