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

50 lines
734 B
CMake
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
set(LLVM_TARGET_DEFINITIONS Options.td)
tablegen(LLVM Options.inc -gen-opt-parser-defs)
add_public_tablegen_target(COFFOptionsTableGen)
build: add support for standalone lld build Enable building lld as a standalone project. This is motivated by the desire to package lld for inclusion in a linux distribution. This allows building lld against an existing paired llvm installation. Now that lld is usable on x86_64, it makes sense to revive this configuration to allow distributions to package it. llvm-svn: 289421
2016-12-12 13:47:40 +08:00
if(NOT LLD_BUILT_STANDALONE)
set(tablegen_deps intrinsics_gen)
endif()
Set the folder for libraries to 'lld libraries'. NFC. In a UI such as XCode, LLVM source files are in 'libraries' while clang files are in 'clang libraries'. This change moves the lld source to 'lld libraries' to make code browsing easier. It should be NFC as the build itself is still the same, just the structure in a UI differs. llvm-svn: 257001
2016-01-07 08:14:04 +08:00
add_lld_library(lldCOFF
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
Chunks.cpp
COFF: Move Windows-specific code from Chunk.{cpp,h} to DLL.{cpp,h}. llvm-svn: 239239
2015-06-07 09:15:04 +08:00
DLL.cpp
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
Driver.cpp
COFF: Split Driver.cpp to Driver.cpp and DriverUtils.cpp. NFC. The previous implementation's driver file is cluttered by lots of small functions, and it was hard to find important functions. Make a separate file to prevent that issue. llvm-svn: 238482
2015-05-29 04:30:06 +08:00
DriverUtils.cpp
Port the error functions from ELF to COFF. This has a few advantages * Less C++ code (about 300 lines less). * Less machine code (about 14 KB of text on a linux x86_64 build). * It is more debugger friendly. Just set a breakpoint on the exit function and you get the complete lld stack trace of when the error was found. * It is a more robust API. The errors are handled early and we don't get a std::error_code hot potato being passed around. * In most cases the error function in a better position to print diagnostics (it has more context). llvm-svn: 244215
2015-08-06 22:58:50 +08:00
Error.cpp
COFF: Move code for ICF from Writer.cpp to ICF.cpp. llvm-svn: 240590
2015-06-25 04:40:03 +08:00
ICF.cpp
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
InputFiles.cpp
COFF: drop the dependency on LIB.EXE for implibs lld currently relies on lib.exe in order to generate an empty import library. The "empty" import library consists of 5 members: - first linker member - second linker member - Import Descriptor - NULL Import Descriptor - NULl Thunk The first two entries (first and second linker members) are string tables which are never updated. Therefore, they may as well as not be present. A subsequent change to add that is probably warranted. However, this does not prevent the use of the linker. The Import Descriptor is the content which is most important. It provides an Import Name Table entry for the library (as specified by the LIBRARY directive in the DEF file). Additionally, it contains undefined references to the NULL Import Descriptor and the library NULL Thunk Data. This ensures that the linker will pull in the subsequent objects from the import library for the link. The Import Descriptor has a single symbol (__IMPORT_DESCRIPTOR_<Library>) which contains 3 relocations, one to the INT (Import Name Table) entry, one to the ILT (Import Lookup Table) entry, and one to the IAT (Import Address Table) entry. The NULL Import Descriptor is the last import descriptor and terminates the import descriptor array. It contains a single symbol (__NULL_IMPORT_DESCRIPTOR). The NULL Thunk contains a single symbol (\x7f<Library>_NULL_THUNK_DATA) and provides the terminator for the ILT and IAT. These files are currently constructed manually following the example of the Short Import Library format. This is arguably less than ideal, and it may be possible to use MCAssembler and feed it the fragments to construct the object. The major difference between the LIB (LINK) generated objects and the ones generated here is that they are all one section shorter (.debug$S) as they do not contain the debug information and one symbol shorter (@comp.id) as they do not contain the RICH signature. Move the logic related to the librarian into a new source file (Librarian.cpp). llvm-svn: 275242
2016-07-13 11:19:27 +08:00
Librarian.cpp
COFF: Change the /lldmap output format to be more like the ELF linker. Differential Revision: https://reviews.llvm.org/D28717 llvm-svn: 291990
2017-01-14 11:14:46 +08:00
MapFile.cpp
COFF: Move markLive() from Writer.cpp to its own file. Conceptually, garbage collection is not part of Writer, so move the function out of the file. llvm-svn: 248099
2015-09-20 05:36:28 +08:00
MarkLive.cpp
COFF: Support module-definition files. Module-definition files (.def files) are yet another way to specify parameters to the linker. You can write a list of dllexported symbols in module-definition files instead of using /export command line option. It also supports a few more directives. The parser code is taken from lib/Driver/WinLinkModuleDef.cpp with the following modifications. - variable names are updated to comply with the LLVM coding style. - Instead of returning parsing results as "directive" objects, it updates Config object directly. llvm-svn: 239929
2015-06-18 03:19:25 +08:00
ModuleDef.cpp
COFF: Create a PDB file with the correct file signature. Before this patch, we created an empty PDB file if /debug option is specified. For MSVC linker, such PDB file is completely broken, and linker exits without doing anything as soon as it finds an empty PDB file. A PDB file created in this patch has the correct file signature. MSVC linker still thinks that the file is broken, but it then removes and replaces with its output. This is an initial patch to support PDB in LLD. We aim to support PDB in order to make it 100% compatible with MSVC linker. PDB support is the last missing piece. llvm-svn: 254796
2015-12-05 07:11:05 +08:00
PDB.cpp
COFF: Define overloaded toString functions. Previously, we had different way to stringize SymbolBody and InputFile to construct error messages. This patch defines overloaded function toString() so that we don't need to memorize all these different function names. With that change, it is now easy to include demangled names in error messages. Now, if there is a symbol name conflict, we'll print out both mangled and demangled names. llvm-svn: 288992
2016-12-08 07:17:02 +08:00
Strings.cpp
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
SymbolTable.cpp
Symbols.cpp
Writer.cpp
COFF: Initial implementation of link-time optimization. This implementation is known to work in very simple cases (see new test case). Differential Revision: http://reviews.llvm.org/D10115 llvm-svn: 238777
2015-06-02 04:10:10 +08:00
LINK_COMPONENTS
${LLVM_TARGETS_TO_BUILD}
Core
[COFF] Add DebugInfoCodeView dependency rL287555 introduces a link error when building with BUILD_SHARED_LIBS: undefined reference to llvm::codeview::CVSymbolDumper::dump(), and more... The functions are available in libDebugInfoCodeView, from LLVM. Patch by Visoiu Mistrih Francis! llvm-svn: 287837
2016-11-24 06:58:25 +08:00
DebugInfoCodeView
Fix shared library build llvm-svn: 281728
2016-09-16 22:10:23 +08:00
DebugInfoMSF
Use functions in DebugInfoPDB to create dummy PDB file. I don't think we are creating valid PDB file here, but it is okay because we have never created valid PDBs before. llvm-svn: 281704
2016-09-16 12:32:33 +08:00
DebugInfoPDB
COFF: Initial implementation of link-time optimization. This implementation is known to work in very simple cases (see new test case). Differential Revision: http://reviews.llvm.org/D10115 llvm-svn: 238777
2015-06-02 04:10:10 +08:00
LTO
COFF: Implement /lib using LibDriver. Differential Revision: http://reviews.llvm.org/D10347 llvm-svn: 239436
2015-06-10 05:52:48 +08:00
LibDriver
Add missing dependencies for the CMake shared lld build. llvm-svn: 240445
2015-06-24 03:54:57 +08:00
Object
COFF: Initial implementation of link-time optimization. This implementation is known to work in very simple cases (see new test case). Differential Revision: http://reviews.llvm.org/D10115 llvm-svn: 238777
2015-06-02 04:10:10 +08:00
MC
MCDisassembler
Add missing dependencies for the CMake shared lld build. llvm-svn: 240445
2015-06-24 03:54:57 +08:00
Target
Option
COFF: Initial implementation of link-time optimization. This implementation is known to work in very simple cases (see new test case). Differential Revision: http://reviews.llvm.org/D10115 llvm-svn: 238777
2015-06-02 04:10:10 +08:00
Support
Fix BUILD_SHARED_LIBS build. llvm-svn: 262345
2016-03-01 23:56:53 +08:00
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
LINK_LIBS
lldCore
${PTHREAD_LIB}
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
[CMake] NFC. Updating CMake dependency specifications This patch updates a couple places where add_dependencies was being explicitly called to add dependencies on intrinsics_gen to instead use the DEPENDS named parameter. This cleanup is needed for a patch I'm working on to add a dependency debugging mode to the build system. llvm-svn: 287205
2016-11-17 12:36:35 +08:00
DEPENDS
COFFOptionsTableGen
build: add support for standalone lld build Enable building lld as a standalone project. This is motivated by the desire to package lld for inclusion in a linux distribution. This allows building lld against an existing paired llvm installation. Now that lld is usable on x86_64, it makes sense to revive this configuration to allow distributions to package it. llvm-svn: 289421
2016-12-12 13:47:40 +08:00
${tablegen_deps}
[CMake] NFC. Updating CMake dependency specifications This patch updates a couple places where add_dependencies was being explicitly called to add dependencies on intrinsics_gen to instead use the DEPENDS named parameter. This cleanup is needed for a patch I'm working on to add a dependency debugging mode to the build system. llvm-svn: 287205
2016-11-17 12:36:35 +08:00
)