replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
hanchenye-llvm-project/lld/test/COFF/include2.test

15 lines
585 B
Plaintext
Raw Normal View History

COFF: Continue reading object files until converge. In this linker model, adding an undefined symbol may trigger chain reactions. It may trigger a Lazy symbol to read a new file. A new file may contain a directive section, which may contain various command line options. Previously, we didn't handle chain reactions well. We visited /include'd symbols only once, so newly-added /include symbols were ignored. This patch fixes that bug. Now, the symbol table is versioned; every time the symbol table is updated, the version number is incremented. We repeat adding undefined symbols until the version number does not change. It is guaranteed to converge -- the number of undefined symbol in the system is finite, and adding the same undefined symbol more than once is basically no-op. llvm-svn: 240177
2015-06-20 05:12:48 +08:00
# RUN: yaml2obj < %p/Inputs/include1a.yaml > %t1.obj
# RUN: yaml2obj < %p/Inputs/include1b.yaml > %t2.obj
# RUN: yaml2obj < %p/Inputs/include1c.yaml > %t3.obj
# RUN: rm -f %t2.lib %t3.lib
# RUN: llvm-ar cru %t2.lib %t2.obj
# RUN: llvm-ar cru %t3.lib %t3.obj
COFF: Make test commands shorter. NFC. llvm-svn: 244227
2015-08-07 00:47:46 +08:00
# RUN: lld-link /out:%t.exe /entry:main %t1.obj %t2.lib %t3.lib /verbose >& %t.log
COFF: Continue reading object files until converge. In this linker model, adding an undefined symbol may trigger chain reactions. It may trigger a Lazy symbol to read a new file. A new file may contain a directive section, which may contain various command line options. Previously, we didn't handle chain reactions well. We visited /include'd symbols only once, so newly-added /include symbols were ignored. This patch fixes that bug. Now, the symbol table is versioned; every time the symbol table is updated, the version number is incremented. We repeat adding undefined symbols until the version number does not change. It is guaranteed to converge -- the number of undefined symbol in the system is finite, and adding the same undefined symbol more than once is basically no-op. llvm-svn: 240177
2015-06-20 05:12:48 +08:00
# RUN: FileCheck %s < %t.log
CHECK: include2.test.tmp1.obj
CHECK: include2.test.tmp2.lib
COFF: Change symbol resolution order for entry and /include. We were resolving entry symbols and /include'd symbols after all other symbols are resolved. But looks like it's too late. I found that it causes some program to fail to link. Let's say we have an object file A which defines symbols X and Y in an archive. We also have another file B after A which defines X, Y and _DLLMainCRTStartup in another archive. They conflict each other, so either A or B can be linked. If we have _DLLMainCRTStartup as an undefined symbol, file B is always chosen. If not, there's a chance that A is chosen. If the linker find it needs _DllMainCRTStartup after that, it's too late. This patch adds undefined symbols to the symbol table as soon as possible to fix the issue. llvm-svn: 240757
2015-06-26 11:44:00 +08:00
CHECK: include2.test.tmp3.lib
COFF: Change the order of adding symbols to the symbol table. Previously, the order of adding symbols to the symbol table was simple. We have a list of all input files. We read each file from beginning of the list and add all symbols in it to the symbol table. This patch changes that order. Now all archive files are added to the symbol table first, and then all the other object files are added. This shouldn't change the behavior in single-threading, and make room to parallelize in multi-threading. In the first step, only lazy symbols are added to the symbol table because archives contain only Lazy symbols. Member object files found to be necessary are queued. In the second step, defined and undefined symbols are added from object files. Adding an undefined symbol to the symbol table may cause more member files to be added to the queue. We simply continue reading all object files until the queue is empty. Finally, new archive or object files may be added to the queues by object files' directive sections (which contain new command line options). The above process is repeated until we get no new files. Symbols defined both in object files and in archives can make results undeterministic. If an archive is read before an object, a new member file gets linked, while in the other way, no new file would be added. That is the most popular cause of an undeterministic result or linking failure as I observed. Separating phases of adding lazy symbols and undefined symbols makes that deterministic. Adding symbols in each phase should be parallelizable. llvm-svn: 241107
2015-07-01 03:35:21 +08:00
CHECK: include2.test.tmp2.lib(include2.test.tmp2.obj) for foo
COFF: Continue reading object files until converge. In this linker model, adding an undefined symbol may trigger chain reactions. It may trigger a Lazy symbol to read a new file. A new file may contain a directive section, which may contain various command line options. Previously, we didn't handle chain reactions well. We visited /include'd symbols only once, so newly-added /include symbols were ignored. This patch fixes that bug. Now, the symbol table is versioned; every time the symbol table is updated, the version number is incremented. We repeat adding undefined symbols until the version number does not change. It is guaranteed to converge -- the number of undefined symbol in the system is finite, and adding the same undefined symbol more than once is basically no-op. llvm-svn: 240177
2015-06-20 05:12:48 +08:00
CHECK: include2.test.tmp3.lib(include2.test.tmp3.obj) for bar