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

167 lines
7.2 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">;
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", "">;
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">;
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">;
def out : P<"out", "Path to file to write output">;
def pdb : P<"pdb", "PDB file path">;
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">;
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: 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">;
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">;
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 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">;
[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">;
Add an option to use the MSVC linker to link LTO-generated object files. This patch defines a new command line option, /MSVCLTO, to LLD. If that option is given, LLD invokes link.exe to link LTO-generated object files. This is hacky but useful because link.exe can create PDB files. Differential Revision: https://reviews.llvm.org/D29526 llvm-svn: 294234
2017-02-07 04:47:55 +08:00
def msvclto : F<"msvclto">;
[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:">;
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 incremental : F<"incremental">;
def no_incremental : F<"incremental:no">;
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">;
Ignore /natvis option for now. /natvis is a new command line option introduced by MSVC 2017. We eventually have to support it, but for now, let's ignore it so that we can at least link stuff instead of printing out an error. Patch by Michael Rickert. llvm-svn: 312966
2017-09-12 06:24:13 +08:00
def natvis : QF<"natvis">;
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 pdbaltpath : QF<"pdbaltpath">;
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">;