'-fuse-ld=lld' causes cc-option to fail #357
Labels
duplicate
This issue or pull request already exists
Comments
Closed
|
just checking that you have lld installed as lld, not as lld-8 or lld-9 or anything? |
|
Correct, how it is by default with a source build. |
so what adds the |
|
I thought |
Do you mean where it comes from? It's in the Line 67 in b23b0ea |
|
ah, sorry, ok, I've debugged issues with these kbuild macros a few times now via https://stackoverflow.com/a/16489377 ie cc-option ... \
+ $(info $$foo is [${foo}] \
...See what gets invoked (V=1 doesn't show this), then run that at the command line. Usually clang is failing for some other unrelated reason. |
dileks
changed the title
|
@nathanchance should we close this as a duplicate of #366? |
|
Sure. |
nathanchance
added
duplicate
mainey
pushed a commit
to mainey/dream
that referenced
this issue
Jun 3, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
subhajeetmuhuri
pushed a commit
to AOSiP-Devices/kernel_zuk_msm8996
that referenced
this issue
Jun 3, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
subhajeetmuhuri
pushed a commit
to AOSiP-Devices/kernel_zuk_msm8996
that referenced
this issue
Jun 19, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
subhajeetmuhuri
pushed a commit
to AOSiP-Devices/kernel_zuk_msm8996
that referenced
this issue
Jul 22, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
kdrag0n
pushed a commit
to kdrag0n/proton_zf6
that referenced
this issue
Aug 6, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used. There's no need to
guard with cc-option.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <natechancellor@gmail.com>
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
(am from https://lore.kernel.org/patchwork/patch/1057183/)
[kdrag0n: Backported to k4.14 with the following changes:
- Replaced full version check with ld-name call because we
added support for lld to ld-name
]
Signed-off-by: Danny Lin <danny@kdrag0n.dev>
kdrag0n
pushed a commit
to kdrag0n/proton_zf6
that referenced
this issue
Aug 6, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used. There's no need to
guard with cc-option.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <natechancellor@gmail.com>
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
(am from https://lore.kernel.org/patchwork/patch/1057183/)
[kdrag0n: Backported to k4.14 with the following changes:
- Replaced full version check with ld-name call because we
added support for lld to ld-name
]
Signed-off-by: Danny Lin <danny@kdrag0n.dev>
kdrag0n
pushed a commit
to kdrag0n/proton_zf6
that referenced
this issue
Aug 6, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used. There's no need to
guard with cc-option.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <natechancellor@gmail.com>
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
(am from https://lore.kernel.org/patchwork/patch/1057183/)
[kdrag0n: Backported to k4.14 with the following changes:
- Replaced full version check with ld-name call because we
added support for lld to ld-name
]
Signed-off-by: Danny Lin <danny@kdrag0n.dev>
kdrag0n
pushed a commit
to kdrag0n/proton_zf6
that referenced
this issue
Aug 6, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used. There's no need to
guard with cc-option.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <natechancellor@gmail.com>
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
(am from https://lore.kernel.org/patchwork/patch/1057183/)
[kdrag0n: Backported to k4.14 with the following changes:
- Replaced full version check with ld-name call because we
added support for lld to ld-name
]
Signed-off-by: Danny Lin <danny@kdrag0n.dev>
najahiiii
pushed a commit
to chips-project/kernel_asus_sdm660
that referenced
this issue
Aug 6, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
najahiiii
pushed a commit
to chips-project/kernel_asus_sdm660
that referenced
this issue
Aug 6, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
najahiiii
pushed a commit
to chips-project/kernel_asus_sdm660
that referenced
this issue
Sep 17, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
micky387
pushed a commit
to asus-development/android_kernel_asus_sm8150
that referenced
this issue
Oct 10, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used. There's no need to
guard with cc-option.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <natechancellor@gmail.com>
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
(am from https://lore.kernel.org/patchwork/patch/1057183/)
[kdrag0n: Backported to k4.14 with the following changes:
- Replaced full version check with ld-name call because we
added support for lld to ld-name
]
Signed-off-by: Danny Lin <danny@kdrag0n.dev>
kondors1995
pushed a commit
to SOVIET-ANDROID/kernel_xiaomi_raphael
that referenced
this issue
Oct 18, 2019
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used. There's no need to
guard with cc-option.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <natechancellor@gmail.com>
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
(am from https://lore.kernel.org/patchwork/patch/1057183/)
[kdrag0n: Backported to k4.14 with the following changes:
- Replaced full version check with ld-name call because we
added support for lld to ld-name
]
Signed-off-by: Danny Lin <danny@kdrag0n.dev>
mizdrake7
pushed a commit
to mizdrake7/Graveyard_r5x
that referenced
this issue
Jul 12, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used. There's no need to
guard with cc-option.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <natechancellor@gmail.com>
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
(am from https://lore.kernel.org/patchwork/patch/1057183/)
[kdrag0n: Backported to k4.14 with the following changes:
- Replaced full version check with ld-name call because we
added support for lld to ld-name
]
Signed-off-by: Danny Lin <danny@kdrag0n.dev>
Signed-off-by: Panchajanya1999 <panchajanya@azure-dev.live>
Change-Id: I3294ba544a0c204c6b3464a1d77a04bba442b0ad
Signed-off-by: Panchajanya1999 <panchajanya@azure-dev.live>
mizdrake7
pushed a commit
to mizdrake7/Graveyard_r5x
that referenced
this issue
Jul 12, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used. There's no need to
guard with cc-option.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <natechancellor@gmail.com>
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
(am from https://lore.kernel.org/patchwork/patch/1057183/)
[kdrag0n: Backported to k4.14 with the following changes:
- Replaced full version check with ld-name call because we
added support for lld to ld-name
]
Signed-off-by: Danny Lin <danny@kdrag0n.dev>
Signed-off-by: Panchajanya1999 <panchajanya@azure-dev.live>
Change-Id: I3294ba544a0c204c6b3464a1d77a04bba442b0ad
Signed-off-by: Panchajanya1999 <panchajanya@azure-dev.live>
mizdrake7
pushed a commit
to mizdrake7/Graveyard_r5x
that referenced
this issue
Jul 20, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used. There's no need to
guard with cc-option.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <natechancellor@gmail.com>
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
(am from https://lore.kernel.org/patchwork/patch/1057183/)
[kdrag0n: Backported to k4.14 with the following changes:
- Replaced full version check with ld-name call because we
added support for lld to ld-name
]
Signed-off-by: Danny Lin <danny@kdrag0n.dev>
Signed-off-by: Panchajanya1999 <panchajanya@azure-dev.live>
Change-Id: I3294ba544a0c204c6b3464a1d77a04bba442b0ad
Signed-off-by: Panchajanya1999 <panchajanya@azure-dev.live>
log1cs
pushed a commit
to nokia-msm8998/android_kernel_nokia_msm8998
that referenced
this issue
Sep 29, 2023
kbuild: Allow forcing the alternative LLD linker via Kconfig LLD is a relatively new linker from the LLVM Project that aims to be a faster and more modern alternative to the GNU gold and bfd linkers from binutils: https://lld.llvm.org/ I've also found that it offers more insightful diagnostics when something goes wrong, e.g. when there are undefined references. It does also appear to speed up the overall build time by 4-10s as compared to ld.bfd. These new config options will only allow fully-working configurations: - gold/lld when Clang LTO is enabled - bfd/lld otherwise Signed-off-by: Danny Lin <danny@kdrag0n.dev> Signed-off-by: Adam W. Willis <return.of.octobot@gmail.com> Signed-off-by: Yaroslav Furman <yaro330@gmail.com> BACKPORT: FROMLIST: Makefile: lld: set -O2 linker flag when linking w… …ith LLD For arm64: 0.34% size improvement with lld -O2 over lld for vmlinux. 3.3% size improvement with lld -O2 over lld for Image.lz4-dtb. Link: ClangBuiltLinux/linux#343 Suggested-by: Rui Ueyama <ruiu@google.com> Suggested-by: Nathan Chancellor <natechancellor@gmail.com> Reviewed-by: Nathan Chancellor <natechancellor@gmail.com> Tested-by: Nathan Chancellor <natechancellor@gmail.com> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com> (am from https://patchwork.kernel.org/patch/10806729/) Signed-off-by: Adam W. Willis <return.of.octobot@gmail.com> Signed-off-by: Yaroslav Furman <yaro330@gmail.com> BACKPORT: FROMLIST: Makefile: lld: tell clang to use lld This is needed because clang doesn't select which linker to use based on $LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This is problematic especially for cc-ldoption, which checks for linker flag support via invoking the compiler, rather than the BACKPORT: FROMLIST: Makefile: lld: tell clang to use lld This is needed because clang doesn't select which linker to use based on $LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This is problematic especially for cc-ldoption, which checks for linker flag support via invoking the compiler, rather than the linker. Select the linker via absolute path from $PATH via `which`. This allows you to build with: $ make LD=ld.lld $ make LD=ld.lld-8 $ make LD=/path/to/ld.lld Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise Clang likes to complain about -fuse-lld= being unused when compiling but not linking (-c) such as when cc-option is used. There's no need to guard with cc-option. Link: ClangBuiltLinux/linux#342 Link: ClangBuiltLinux/linux#366 Link: ClangBuiltLinux/linux#357 Suggested-by: Nathan Chancellor <natechancellor@gmail.com> Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com> Reviewed-by: Nathan Chancellor <natechancellor@gmail Signed-off-by: Divyanshu-Modi <divyan.m05@gmail.com> Signed-off-by: Kunmun <kunmun.devroms@gmail.com>
log1cs
pushed a commit
to nokia-msm8998/android_kernel_nokia_msm8998
that referenced
this issue
Sep 29, 2023
kbuild: Allow forcing the alternative LLD linker via Kconfig LLD is a relatively new linker from the LLVM Project that aims to be a faster and more modern alternative to the GNU gold and bfd linkers from binutils: https://lld.llvm.org/ I've also found that it offers more insightful diagnostics when something goes wrong, e.g. when there are undefined references. It does also appear to speed up the overall build time by 4-10s as compared to ld.bfd. These new config options will only allow fully-working configurations: - gold/lld when Clang LTO is enabled - bfd/lld otherwise Signed-off-by: Danny Lin <danny@kdrag0n.dev> Signed-off-by: Adam W. Willis <return.of.octobot@gmail.com> Signed-off-by: Yaroslav Furman <yaro330@gmail.com> BACKPORT: FROMLIST: Makefile: lld: set -O2 linker flag when linking w… …ith LLD For arm64: 0.34% size improvement with lld -O2 over lld for vmlinux. 3.3% size improvement with lld -O2 over lld for Image.lz4-dtb. Link: ClangBuiltLinux/linux#343 Suggested-by: Rui Ueyama <ruiu@google.com> Suggested-by: Nathan Chancellor <natechancellor@gmail.com> Reviewed-by: Nathan Chancellor <natechancellor@gmail.com> Tested-by: Nathan Chancellor <natechancellor@gmail.com> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com> (am from https://patchwork.kernel.org/patch/10806729/) Signed-off-by: Adam W. Willis <return.of.octobot@gmail.com> Signed-off-by: Yaroslav Furman <yaro330@gmail.com> BACKPORT: FROMLIST: Makefile: lld: tell clang to use lld This is needed because clang doesn't select which linker to use based on $LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This is problematic especially for cc-ldoption, which checks for linker flag support via invoking the compiler, rather than the BACKPORT: FROMLIST: Makefile: lld: tell clang to use lld This is needed because clang doesn't select which linker to use based on $LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This is problematic especially for cc-ldoption, which checks for linker flag support via invoking the compiler, rather than the linker. Select the linker via absolute path from $PATH via `which`. This allows you to build with: $ make LD=ld.lld $ make LD=ld.lld-8 $ make LD=/path/to/ld.lld Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise Clang likes to complain about -fuse-lld= being unused when compiling but not linking (-c) such as when cc-option is used. There's no need to guard with cc-option. Link: ClangBuiltLinux/linux#342 Link: ClangBuiltLinux/linux#366 Link: ClangBuiltLinux/linux#357 Suggested-by: Nathan Chancellor <natechancellor@gmail.com> Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com> Reviewed-by: Nathan Chancellor <natechancellor@gmail Signed-off-by: Divyanshu-Modi <divyan.m05@gmail.com> Signed-off-by: Kunmun <kunmun.devroms@gmail.com>
Rohail33
pushed a commit
to Rohail33/Realking_kernel_sm8250
that referenced
this issue
Nov 1, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
candyceline
pushed a commit
to Danda420/kernel_xiaomi_sm8250
that referenced
this issue
Nov 2, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
diphons
pushed a commit
to diphons/D8G_Kernel_oxygen
that referenced
this issue
Nov 2, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
diphons
pushed a commit
to diphons/D8G_Kernel_oxygen
that referenced
this issue
Nov 2, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Rohail33
pushed a commit
to Rohail33/Realking_kernel_sm8250
that referenced
this issue
Nov 2, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Danda420
pushed a commit
to Danda420/kernel_xiaomi_sm8250
that referenced
this issue
Nov 3, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Little-W
pushed a commit
to Little-W/android_kernel_xiaomi_alioth
that referenced
this issue
Nov 14, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Rohail33
pushed a commit
to Rohail33/Realking_kernel_sm8250
that referenced
this issue
Dec 3, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Rohail33
pushed a commit
to Rohail33/Realking_kernel_sm8250
that referenced
this issue
Dec 4, 2023
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Huexxx
pushed a commit
to Huexxx/kernel_xiaomi_msm8998_old
that referenced
this issue
Jan 22, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Marco Zanin <mrczn.bb@gmail.com>
amackpro
pushed a commit
to amackpro/android_kernel_xiaomi_sm8250
that referenced
this issue
Jan 26, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
wulan17
pushed a commit
to Mayuri-Chan/android_kernel_xiaomi_mt6765
that referenced
this issue
Feb 5, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Signed-off-by: wulan17 <wulan17@nusantararom.org>
diphons
pushed a commit
to diphons/sdm845-419
that referenced
this issue
Feb 26, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
diphons
pushed a commit
to diphons/sdm845-419
that referenced
this issue
Feb 26, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
diphons
pushed a commit
to diphons/sdm845-419
that referenced
this issue
Mar 2, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
diphons
pushed a commit
to diphons/sdm845-419
that referenced
this issue
Mar 2, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Tomoms
pushed a commit
to Tomoms/android_kernel_qcom_msm8998
that referenced
this issue
Mar 14, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
diphons
pushed a commit
to diphons/sdm845-419
that referenced
this issue
Mar 23, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
diphons
pushed a commit
to diphons/sdm845-419
that referenced
this issue
Mar 23, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Rohail33
pushed a commit
to Rohail33/Realking_kernel_sm8250
that referenced
this issue
Apr 13, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Rohail33
pushed a commit
to Rohail33/Realking_kernel_sm8250
that referenced
this issue
Apr 13, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
diphons
pushed a commit
to diphons/sdm845-419
that referenced
this issue
May 23, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Rohail33
pushed a commit
to Rohail33/Realking_kernel_sm8250
that referenced
this issue
Jul 6, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
Rohail33
pushed a commit
to Rohail33/Realking_kernel_sm8250
that referenced
this issue
Aug 16, 2024
This is needed because clang doesn't select which linker to use based on
$LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This
is problematic especially for cc-ldoption, which checks for linker flag
support via invoking the compiler, rather than the linker.
Select the linker via absolute path from $PATH via `which`. This allows
you to build with:
$ make LD=ld.lld
$ make LD=ld.lld-8
$ make LD=/path/to/ld.lld
Add -Qunused-arguments to KBUILD_CPPFLAGS when using LLD, as otherwise
Clang likes to complain about -fuse-lld= being unused when compiling but
not linking (-c) such as when cc-option is used.
Link: ClangBuiltLinux/linux#342
Link: ClangBuiltLinux/linux#366
Link: ClangBuiltLinux/linux#357
Suggested-by: Nathan Chancellor <natechancellor@gmail.com>
Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Carlos Ayrton Lopez Arroyo <15030201@itcelaya.edu.mx>
Signed-off-by: Little-W <1405481963@qq.com>
ghost
pushed a commit
to Kurumi-Tokito/lineage_kernel_nokia_sdm660
that referenced
this issue
Oct 11, 2024
kbuild: Allow forcing the alternative LLD linker via Kconfig LLD is a relatively new linker from the LLVM Project that aims to be a faster and more modern alternative to the GNU gold and bfd linkers from binutils: https://lld.llvm.org/ I've also found that it offers more insightful diagnostics when something goes wrong, e.g. when there are undefined references. It does also appear to speed up the overall build time by 4-10s as compared to ld.bfd. These new config options will only allow fully-working configurations: - gold/lld when Clang LTO is enabled - bfd/lld otherwise Signed-off-by: Danny Lin <danny@kdrag0n.dev> Signed-off-by: Adam W. Willis <return.of.octobot@gmail.com> Signed-off-by: Yaroslav Furman <yaro330@gmail.com> BACKPORT: FROMLIST: Makefile: lld: set -O2 linker flag when linking w… …ith LLD For arm64: 0.34% size improvement with lld -O2 over lld for vmlinux. 3.3% size improvement with lld -O2 over lld for Image.lz4-dtb. Link: ClangBuiltLinux/linux#343 Suggested-by: Rui Ueyama <ruiu@google.com> Suggested-by: Nathan Chancellor <natechancellor@gmail.com> Reviewed-by: Nathan Chancellor <natechancellor@gmail.com> Tested-by: Nathan Chancellor <natechancellor@gmail.com> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com> (am from https://patchwork.kernel.org/patch/10806729/) Signed-off-by: Adam W. Willis <return.of.octobot@gmail.com> Signed-off-by: Yaroslav Furman <yaro330@gmail.com> BACKPORT: FROMLIST: Makefile: lld: tell clang to use lld This is needed because clang doesn't select which linker to use based on $LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This is problematic especially for cc-ldoption, which checks for linker flag support via invoking the compiler, rather than the BACKPORT: FROMLIST: Makefile: lld: tell clang to use lld This is needed because clang doesn't select which linker to use based on $LD but rather -fuse-ld={bfd,gold,lld,<absolute path to linker>}. This is problematic especially for cc-ldoption, which checks for linker flag support via invoking the compiler, rather than the linker. Select the linker via absolute path from $PATH via `which`. This allows you to build with: $ make LD=ld.lld $ make LD=ld.lld-8 $ make LD=/path/to/ld.lld Add -Qunused-arguments to KBUILD_CPPFLAGS sooner, as otherwise Clang likes to complain about -fuse-lld= being unused when compiling but not linking (-c) such as when cc-option is used. There's no need to guard with cc-option. Link: ClangBuiltLinux/linux#342 Link: ClangBuiltLinux/linux#366 Link: ClangBuiltLinux/linux#357 Suggested-by: Nathan Chancellor <natechancellor@gmail.com> Suggested-by: Masahiro Yamada <yamada.masahiro@socionext.com> Signed-off-by: Nick Desaulniers <ndesaulniers@google.com> Reviewed-by: Nathan Chancellor <natechancellor@gmail Signed-off-by: Divyanshu-Modi <divyan.m05@gmail.com> Signed-off-by: Kunmun <kunmun.devroms@gmail.com>
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Forked from #342 (comment).
compiles and links successfully on
next-20190207. After applying https://lore.kernel.org/lkml/20190207220155.81351-3-ndesaulniers@google.com/, it fails with a bunch of assembler errors (log).Building with
V=1shows the flags passed along to Clang are different, the major difference being the-marchflag.Without that patch:
With that patch:
The
-marchflags come fromlinux/arch/arm/Makefile
Line 67 in b23b0ea
cc-optionis clearly failing. If I force-march=armv7-a, the kernel compiles and links fine.The text was updated successfully, but these errors were encountered: