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

187 lines
8.4 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.
class F<string name> : Flag<["/", "-", "-?"], name>;
// Flag that takes one argument after ":".
class P<string name, string help> :
Joined<["/", "-", "-?"], name#":">, HelpText<help>;
[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
}
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">,
HelpText<"Use colors in diagnostics">;
def color_diagnostics_eq: Joined<["--"], "color-diagnostics=">,
HelpText<"Use colors in diagnostics; one of 'always', 'never', 'auto'">;
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", "">;
[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">;
COFF: Implement /linkrepro flag. This flag is implemented similarly to --reproduce in the ELF linker. This patch implements /linkrepro by moving the cpio writer and associated utility functions to lldCore, and using that implementation in both linkers. One COFF-specific detail is that we store the object file from which the resource files were created in our reproducer, rather than the resource files themselves. This allows the reproducer to be used on non-Windows systems for example. Differential Revision: https://reviews.llvm.org/D22418 llvm-svn: 276719
2016-07-26 10:00:42 +08:00
def linkrepro : P<"linkrepro", "Dump linker invocation and input files for debugging">;
COFF: Implement ThinLTO cache and cache pruning support. Differential Revision: https://reviews.llvm.org/D37607 llvm-svn: 312770
2017-09-08 08:50:50 +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">;
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 no_color_diagnostics: F<"no-color-diagnostics">,
HelpText<"Do not use colors in diagnostics">;
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: 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">;
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">;
[COFF] Add support for the -wholearchive option This fixes PR31824. Differential Revision: https://reviews.llvm.org/D37709 llvm-svn: 313123
2017-09-13 15:28:03 +08:00
def wholearchive_file : P<"wholearchive", "Include all object files from this archive">;
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 disallowlib : Joined<["/", "-", "-?"], "disallowlib:">, Alias<nodefaultlib>;
def manifest : F<"manifest">;
def manifest_colon : P<"manifest", "Create manifest file">;
def manifestuac : P<"manifestuac", "User access control">;
def manifestfile : P<"manifestfile", "Manifest file path">;
def manifestdependency : P<"manifestdependency",
"Attributes for <dependency> in manifest file">;
COFF: Support /manifestinput command line option. Manifest file is a separate or embedded XML file having metadata of an executable. As it is XML, it can contain various types of information. Probably the most popular one is to request escalated priviledges. Usually the linker creates an XML file and embed that file into an executable. However, there's a way to supply an XML file from command line. /manifestniput is it. Apparently it is over-designed here, but if you supply two or more manifest files, then the linker needs to merge the files into a single XML file. A good news is that we don't need to do that ourselves. MT.exe command can do that, so we call the command from the linker in this patch. llvm-svn: 266704
2016-04-19 09:21:58 +08:00
def manifestinput : P<"manifestinput", "Specify manifest file">;
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.
def incl : Joined<["/", "-"], "include:">,
HelpText<"Force symbol to be added to symbol table as undefined one">;
// "def" is also a keyword.
def deffile : Joined<["/", "-"], "def:">,
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">;
[COFF] Alias /DEBUG:FULL to /DEBUG With MSVC linker, /DEBUG is an alias of /DEBUG:FASTLINK, and if you don't want /DEBUG:FASTLINK you have to explicitly specify /DEBUG:FULL. LLD doesn't support /DEBUG:FASTLINK, and so our standard /DEBUG option is what MSVC calls /DEBUG:FULL. To provide command line compatibility with MSVC, we should also support /DEBUG:FULL, and since it's the same as what LLD already does for /DEBUG, just alias it. llvm-svn: 330647
2018-04-24 04:54:08 +08:00
def debug_full : F<"debug:full">, Alias<debug>;
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">;
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 driver : P<"driver", "Generate a Windows NT Kernel Mode Driver">;
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 nodefaultlib_all : F<"nodefaultlib">;
def noentry : F<"noentry">;
def profile : F<"profile">;
[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 repro : F<"Brepro">, HelpText<"Use a hash of the executable as 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 swaprun_cd : F<"swaprun:cd">;
def swaprun_net : F<"swaprun:net">;
def verbose : F<"verbose">;
[COFF] Add support for the -wholearchive option This fixes PR31824. Differential Revision: https://reviews.llvm.org/D37709 llvm-svn: 313123
2017-09-13 15:28:03 +08:00
def wholearchive_flag : F<"wholearchive">;
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">,
HelpText<"Allow undefined symbols when creating executables">;
def force_unresolved : F<"force:unresolved">;
[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)">;
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">;
def help_q : Flag<["/?", "-?"], "">, Alias<help>;
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
[COFF] Teach LLD to use the COFF .debug$H section. This adds the /DEBUG:GHASH option to LLD which will look for the existence of .debug$H sections in linker inputs and use them to accelerate type merging. The clang-cl side has already been added, so this completes the work necessary to begin experimenting with this feature. Differential Revision: https://reviews.llvm.org/D40980 llvm-svn: 320719
2017-12-15 02:07:04 +08:00
def debug_ghash : F<"debug:ghash">;
[MinGW] Output debug info by default, unless the -s parameter is passed Differential Revision: https://reviews.llvm.org/D39541 llvm-svn: 317376
2017-11-04 06:10:37 +08:00
def debug_dwarf : F<"debug:dwarf">;
[COFF] Add an LLD specific option -debug:symbtab With this set, we retain the symbol table, but skip the actual debug information. This is meant to be used by the MinGW frontend. Differential Revision: https://reviews.llvm.org/D48745 llvm-svn: 335946
2018-06-29 14:08:25 +08:00
def debug_symtab : F<"debug:symtab">;
[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">;
[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">;
[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 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",
"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'">;
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">;
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">;
def lldmap_file : Joined<["/", "-"], "lldmap:">;
[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">;
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.
//==============================================================================
class QF<string name> : Joined<["/", "-", "-?"], name#":">;
multiclass QB<string name> {
def "" : F<name>;
def _no : F<name#":no">;
}
def functionpadmin : F<"functionpadmin">;
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">;