From 02b4da53a76b4ba18e3e14588826d7af45ccd6b5 Mon Sep 17 00:00:00 2001 From: Chih-Hung Hsieh Date: Tue, 3 Apr 2018 11:33:34 -0700 Subject: Add USE_CLANG_LLD and use_clang_lld. * USE_CLANG_LLD is unedefined in current builds. * When USE_CLANG_LLD is defined to 'true' or '1', use clang's lld instead of ld or ld.gold. * When lld is enabled: * ld-only flags are not passed to 'lld'. * location_packer is disabled. * Use new lld's --pack-dyn-relocs=android. * When lld does not work: * In Android.mk files use LOCAL_USE_CLANG_LLD := false. * In Android.bp files use use_clang_lld: false. * Only arm, arm64, x86, and x86_64_devices have LLD flags; all other hosts and targets do not call lld yet. Bug: 73768157 Test: make checkbuild and boot Change-Id: I06b8a1e868a600997a7e70fe05c299d751d23d5f --- android/config.go | 4 ++++ android/variable.go | 2 ++ androidmk/cmd/androidmk/android.go | 1 + cc/config/arm64_device.go | 9 +++++++++ cc/config/arm_device.go | 10 ++++++++++ cc/config/clang.go | 20 ++++++++++++++++++++ cc/config/global.go | 10 ++++++++++ cc/config/mips64_device.go | 5 +++++ cc/config/mips_device.go | 5 +++++ cc/config/toolchain.go | 1 + cc/config/x86_64_device.go | 8 ++++++++ cc/config/x86_darwin_host.go | 10 ++++++++++ cc/config/x86_device.go | 8 ++++++++ cc/config/x86_linux_bionic_host.go | 5 +++++ cc/config/x86_linux_host.go | 10 ++++++++++ cc/config/x86_windows_host.go | 10 ++++++++++ cc/linker.go | 22 ++++++++++++++++++++-- cc/lto.go | 14 ++++++++++++-- cc/makevars.go | 13 +++++++++++++ cc/relocation_packer.go | 15 +++++++++++++++ 20 files changed, 178 insertions(+), 4 deletions(-) diff --git a/android/config.go b/android/config.go index b89ae488b..7122f489e 100644 --- a/android/config.go +++ b/android/config.go @@ -629,6 +629,10 @@ func (c *config) TargetOpenJDK9() bool { return c.targetOpenJDK9 } +func (c *config) UseClangLld() bool { + return Bool(c.productVariables.UseClangLld) +} + func (c *config) ClangTidy() bool { return Bool(c.productVariables.ClangTidy) } diff --git a/android/variable.go b/android/variable.go index ef7d37bb8..3eee9887e 100644 --- a/android/variable.go +++ b/android/variable.go @@ -176,6 +176,8 @@ type productVariables struct { OdmPath *string `json:",omitempty"` ProductPath *string `json:",omitempty"` + UseClangLld *bool `json:",omitempty"` + ClangTidy *bool `json:",omitempty"` TidyChecks *string `json:",omitempty"` diff --git a/androidmk/cmd/androidmk/android.go b/androidmk/cmd/androidmk/android.go index a578bcfdc..8cf93e9a5 100644 --- a/androidmk/cmd/androidmk/android.go +++ b/androidmk/cmd/androidmk/android.go @@ -157,6 +157,7 @@ func init() { "LOCAL_NO_STANDARD_LIBRARIES": "no_standard_libs", "LOCAL_PACK_MODULE_RELOCATIONS": "pack_relocations", "LOCAL_TIDY": "tidy", + "LOCAL_USE_CLANG_LLD": "use_clang_lld", "LOCAL_PROPRIETARY_MODULE": "proprietary", "LOCAL_VENDOR_MODULE": "vendor", "LOCAL_ODM_MODULE": "device_specific", diff --git a/cc/config/arm64_device.go b/cc/config/arm64_device.go index 5bb7749a8..74c936f2c 100644 --- a/cc/config/arm64_device.go +++ b/cc/config/arm64_device.go @@ -35,6 +35,9 @@ var ( "-Wl,--icf=safe", } + arm64Lldflags = append(ClangFilterUnknownLldflags(arm64Ldflags), + "-Wl,-z,max-page-size=4096") + arm64Cppflags = []string{} arm64CpuVariantCflags = map[string][]string{ @@ -81,11 +84,13 @@ func init() { pctx.StaticVariable("Arm64Cflags", strings.Join(arm64Cflags, " ")) pctx.StaticVariable("Arm64Ldflags", strings.Join(arm64Ldflags, " ")) + pctx.StaticVariable("Arm64Lldflags", strings.Join(arm64Lldflags, " ")) pctx.StaticVariable("Arm64Cppflags", strings.Join(arm64Cppflags, " ")) pctx.StaticVariable("Arm64IncludeFlags", bionicHeaders("arm64")) pctx.StaticVariable("Arm64ClangCflags", strings.Join(ClangFilterUnknownCflags(arm64Cflags), " ")) pctx.StaticVariable("Arm64ClangLdflags", strings.Join(ClangFilterUnknownCflags(arm64Ldflags), " ")) + pctx.StaticVariable("Arm64ClangLldflags", strings.Join(ClangFilterUnknownCflags(arm64Lldflags), " ")) pctx.StaticVariable("Arm64ClangCppflags", strings.Join(ClangFilterUnknownCflags(arm64Cppflags), " ")) pctx.StaticVariable("Arm64CortexA53Cflags", @@ -188,6 +193,10 @@ func (t *toolchainArm64) ClangLdflags() string { return "${config.Arm64Ldflags}" } +func (t *toolchainArm64) ClangLldflags() string { + return "${config.Arm64Lldflags}" +} + func (t *toolchainArm64) ToolchainClangCflags() string { return t.toolchainClangCflags } diff --git a/cc/config/arm_device.go b/cc/config/arm_device.go index 66b3b3829..02bd9ebf7 100644 --- a/cc/config/arm_device.go +++ b/cc/config/arm_device.go @@ -39,6 +39,8 @@ var ( "-Wl,-m,armelf", } + armLldflags = ClangFilterUnknownLldflags(armLdflags) + armArmCflags = []string{ "-fstrict-aliasing", } @@ -169,6 +171,7 @@ func init() { pctx.StaticVariable("ArmToolchainCflags", strings.Join(armToolchainCflags, " ")) pctx.StaticVariable("ArmCflags", strings.Join(armCflags, " ")) pctx.StaticVariable("ArmLdflags", strings.Join(armLdflags, " ")) + pctx.StaticVariable("ArmLldflags", strings.Join(armLldflags, " ")) pctx.StaticVariable("ArmCppflags", strings.Join(armCppflags, " ")) pctx.StaticVariable("ArmIncludeFlags", bionicHeaders("arm")) @@ -196,6 +199,7 @@ func init() { pctx.StaticVariable("ArmToolchainClangCflags", strings.Join(ClangFilterUnknownCflags(armToolchainCflags), " ")) pctx.StaticVariable("ArmClangCflags", strings.Join(ClangFilterUnknownCflags(armCflags), " ")) pctx.StaticVariable("ArmClangLdflags", strings.Join(ClangFilterUnknownCflags(armLdflags), " ")) + pctx.StaticVariable("ArmClangLldflags", strings.Join(ClangFilterUnknownCflags(armLldflags), " ")) pctx.StaticVariable("ArmClangCppflags", strings.Join(ClangFilterUnknownCflags(armCppflags), " ")) // Clang ARM vs. Thumb instruction set cflags @@ -274,6 +278,7 @@ var ( type toolchainArm struct { toolchain32Bit ldflags string + lldflags string toolchainCflags, toolchainClangCflags string } @@ -350,6 +355,10 @@ func (t *toolchainArm) ClangLdflags() string { return t.ldflags } +func (t *toolchainArm) ClangLldflags() string { + return t.lldflags // TODO: handle V8 cases +} + func (t *toolchainArm) ClangInstructionSetFlags(isa string) (string, error) { switch isa { case "arm": @@ -403,6 +412,7 @@ func armToolchainFactory(arch android.Arch) Toolchain { "${config.ArmLdflags}", fixCortexA8, }, " "), + lldflags: "${config.ArmLldflags}", toolchainClangCflags: strings.Join(toolchainClangCflags, " "), } } diff --git a/cc/config/clang.go b/cc/config/clang.go index 46d6fe227..132384950 100644 --- a/cc/config/clang.go +++ b/cc/config/clang.go @@ -83,6 +83,15 @@ var ClangUnknownCflags = sorted([]string{ "--enable-stdcall-fixup", }) +// Ldflags that should be filtered out when linking with clang lld +var ClangUnknownLldflags = sorted([]string{ + "-fuse-ld=gold", + "-Wl,--icf=safe", + "-Wl,--fix-cortex-a8", + "-Wl,--no-fix-cortex-a8", + "-Wl,-m,aarch64_elf64_le_vec", +}) + var ClangLibToolingUnknownCflags = []string{ "-flto*", "-fsanitize*", @@ -182,6 +191,17 @@ func ClangFilterUnknownCflags(cflags []string) []string { return ret } +func ClangFilterUnknownLldflags(lldflags []string) []string { + ret := make([]string, 0, len(lldflags)) + for _, f := range lldflags { + if !inListSorted(f, ClangUnknownLldflags) { + ret = append(ret, f) + } + } + + return ret +} + func inListSorted(s string, list []string) bool { for _, l := range list { if s == l { diff --git a/cc/config/global.go b/cc/config/global.go index 989c7ee08..051eba546 100644 --- a/cc/config/global.go +++ b/cc/config/global.go @@ -87,12 +87,20 @@ var ( "-Wl,--no-undefined-version", } + deviceGlobalLldflags = append(ClangFilterUnknownLldflags(deviceGlobalLdflags), + []string{ + "-Wl,--pack-dyn-relocs=android", + "-fuse-ld=lld", + }...) + hostGlobalCflags = []string{} hostGlobalCppflags = []string{} hostGlobalLdflags = []string{} + hostGlobalLldflags = []string{} + commonGlobalCppflags = []string{ "-Wsign-promo", } @@ -141,9 +149,11 @@ func init() { pctx.StaticVariable("DeviceGlobalCflags", strings.Join(deviceGlobalCflags, " ")) pctx.StaticVariable("DeviceGlobalCppflags", strings.Join(deviceGlobalCppflags, " ")) pctx.StaticVariable("DeviceGlobalLdflags", strings.Join(deviceGlobalLdflags, " ")) + pctx.StaticVariable("DeviceGlobalLldflags", strings.Join(deviceGlobalLldflags, " ")) pctx.StaticVariable("HostGlobalCflags", strings.Join(hostGlobalCflags, " ")) pctx.StaticVariable("HostGlobalCppflags", strings.Join(hostGlobalCppflags, " ")) pctx.StaticVariable("HostGlobalLdflags", strings.Join(hostGlobalLdflags, " ")) + pctx.StaticVariable("HostGlobalLldflags", strings.Join(hostGlobalLldflags, " ")) pctx.StaticVariable("NoOverrideGlobalCflags", strings.Join(noOverrideGlobalCflags, " ")) pctx.StaticVariable("CommonGlobalCppflags", strings.Join(commonGlobalCppflags, " ")) diff --git a/cc/config/mips64_device.go b/cc/config/mips64_device.go index a6191b653..6fa25714b 100644 --- a/cc/config/mips64_device.go +++ b/cc/config/mips64_device.go @@ -155,6 +155,11 @@ func (t *toolchainMips64) ClangLdflags() string { return "${config.Mips64ClangLdflags}" } +func (t *toolchainMips64) ClangLldflags() string { + // TODO: define and use Mips64ClangLldflags + return "${config.Mips64ClangLdflags}" +} + func (toolchainMips64) SanitizerRuntimeLibraryArch() string { return "mips64" } diff --git a/cc/config/mips_device.go b/cc/config/mips_device.go index 9709ada47..b815fc663 100644 --- a/cc/config/mips_device.go +++ b/cc/config/mips_device.go @@ -205,6 +205,11 @@ func (t *toolchainMips) ClangLdflags() string { return "${config.MipsClangLdflags}" } +func (t *toolchainMips) ClangLldflags() string { + // TODO: define and use MipsClangLldflags + return "${config.MipsClangLdflags}" +} + func (toolchainMips) SanitizerRuntimeLibraryArch() string { return "mips" } diff --git a/cc/config/toolchain.go b/cc/config/toolchain.go index 7961575fc..ca863a7d7 100644 --- a/cc/config/toolchain.go +++ b/cc/config/toolchain.go @@ -66,6 +66,7 @@ type Toolchain interface { ClangCflags() string ClangCppflags() string ClangLdflags() string + ClangLldflags() string ClangInstructionSetFlags(string) (string, error) ndkTriple() string diff --git a/cc/config/x86_64_device.go b/cc/config/x86_64_device.go index 12f3e6fa2..ba0309450 100644 --- a/cc/config/x86_64_device.go +++ b/cc/config/x86_64_device.go @@ -32,6 +32,8 @@ var ( "-Wl,--hash-style=gnu", } + x86_64Lldflags = ClangFilterUnknownLldflags(x86_64Ldflags) + x86_64ArchVariantCflags = map[string][]string{ "": []string{ "-march=x86-64", @@ -125,12 +127,14 @@ func init() { pctx.StaticVariable("X86_64Cflags", strings.Join(x86_64Cflags, " ")) pctx.StaticVariable("X86_64Ldflags", strings.Join(x86_64Ldflags, " ")) + pctx.StaticVariable("X86_64Lldflags", strings.Join(x86_64Lldflags, " ")) pctx.StaticVariable("X86_64Cppflags", strings.Join(x86_64Cppflags, " ")) pctx.StaticVariable("X86_64IncludeFlags", bionicHeaders("x86")) // Clang cflags pctx.StaticVariable("X86_64ClangCflags", strings.Join(ClangFilterUnknownCflags(x86_64Cflags), " ")) pctx.StaticVariable("X86_64ClangLdflags", strings.Join(ClangFilterUnknownCflags(x86_64Ldflags), " ")) + pctx.StaticVariable("X86_64ClangLldflags", strings.Join(ClangFilterUnknownCflags(x86_64Lldflags), " ")) pctx.StaticVariable("X86_64ClangCppflags", strings.Join(ClangFilterUnknownCflags(x86_64Cppflags), " ")) // Yasm flags @@ -215,6 +219,10 @@ func (t *toolchainX86_64) ClangLdflags() string { return "${config.X86_64Ldflags}" } +func (t *toolchainX86_64) ClangLldflags() string { + return "${config.X86_64Lldflags}" +} + func (t *toolchainX86_64) YasmFlags() string { return "${config.X86_64YasmFlags}" } diff --git a/cc/config/x86_darwin_host.go b/cc/config/x86_darwin_host.go index cae9757fa..4aa8242d8 100644 --- a/cc/config/x86_darwin_host.go +++ b/cc/config/x86_darwin_host.go @@ -273,10 +273,20 @@ func (t *toolchainDarwinX86) ClangLdflags() string { return "${config.DarwinClangLdflags} ${config.DarwinX86ClangLdflags}" } +func (t *toolchainDarwinX86) ClangLldflags() string { + // TODO: define and use Darwin*ClangLldflags + return "${config.DarwinClangLdflags} ${config.DarwinX86ClangLdflags}" +} + func (t *toolchainDarwinX8664) ClangLdflags() string { return "${config.DarwinClangLdflags} ${config.DarwinX8664ClangLdflags}" } +func (t *toolchainDarwinX8664) ClangLldflags() string { + // TODO: define and use Darwin*ClangLldflags + return "${config.DarwinClangLdflags} ${config.DarwinX8664ClangLdflags}" +} + func (t *toolchainDarwinX86) YasmFlags() string { return "${config.DarwinX86YasmFlags}" } diff --git a/cc/config/x86_device.go b/cc/config/x86_device.go index b9ce4af3e..15188cf33 100644 --- a/cc/config/x86_device.go +++ b/cc/config/x86_device.go @@ -38,6 +38,8 @@ var ( "-Wl,--hash-style=gnu", } + x86Lldflags = ClangFilterUnknownLldflags(x86Ldflags) + x86ArchVariantCflags = map[string][]string{ "": []string{ "-march=prescott", @@ -149,12 +151,14 @@ func init() { pctx.StaticVariable("X86Cflags", strings.Join(x86Cflags, " ")) pctx.StaticVariable("X86Ldflags", strings.Join(x86Ldflags, " ")) + pctx.StaticVariable("X86Lldflags", strings.Join(x86Lldflags, " ")) pctx.StaticVariable("X86Cppflags", strings.Join(x86Cppflags, " ")) pctx.StaticVariable("X86IncludeFlags", bionicHeaders("x86")) // Clang cflags pctx.StaticVariable("X86ClangCflags", strings.Join(ClangFilterUnknownCflags(x86ClangCflags), " ")) pctx.StaticVariable("X86ClangLdflags", strings.Join(ClangFilterUnknownCflags(x86Ldflags), " ")) + pctx.StaticVariable("X86ClangLldflags", strings.Join(ClangFilterUnknownCflags(x86Lldflags), " ")) pctx.StaticVariable("X86ClangCppflags", strings.Join(ClangFilterUnknownCflags(x86Cppflags), " ")) // Yasm flags @@ -239,6 +243,10 @@ func (t *toolchainX86) ClangLdflags() string { return "${config.X86Ldflags}" } +func (t *toolchainX86) ClangLldflags() string { + return "${config.X86Lldflags}" +} + func (t *toolchainX86) YasmFlags() string { return "${config.X86YasmFlags}" } diff --git a/cc/config/x86_linux_bionic_host.go b/cc/config/x86_linux_bionic_host.go index 9f0bbbdf1..057e905d9 100644 --- a/cc/config/x86_linux_bionic_host.go +++ b/cc/config/x86_linux_bionic_host.go @@ -126,6 +126,11 @@ func (t *toolchainLinuxBionic) ClangLdflags() string { return "${config.LinuxBionicLdflags}" } +func (t *toolchainLinuxBionic) ClangLldflags() string { + // TODO: define and use LinuxBionicLldflags + return "${config.LinuxBionicLdflags}" +} + func (t *toolchainLinuxBionic) ToolchainClangCflags() string { return "-m64 -march=x86-64" + // TODO: We're not really android, but we don't have a triple yet b/31393676 diff --git a/cc/config/x86_linux_host.go b/cc/config/x86_linux_host.go index 4f0506804..6144fc2ae 100644 --- a/cc/config/x86_linux_host.go +++ b/cc/config/x86_linux_host.go @@ -241,10 +241,20 @@ func (t *toolchainLinuxX86) ClangLdflags() string { return "${config.LinuxClangLdflags} ${config.LinuxX86ClangLdflags}" } +func (t *toolchainLinuxX86) ClangLldflags() string { + // TODO: define and use Linux*ClangLldflags + return "${config.LinuxClangLdflags} ${config.LinuxX86ClangLdflags}" +} + func (t *toolchainLinuxX8664) ClangLdflags() string { return "${config.LinuxClangLdflags} ${config.LinuxX8664ClangLdflags}" } +func (t *toolchainLinuxX8664) ClangLldflags() string { + // TODO: define and use Linux*ClangLldflags + return "${config.LinuxClangLdflags} ${config.LinuxX8664ClangLdflags}" +} + func (t *toolchainLinuxX86) YasmFlags() string { return "${config.LinuxX86YasmFlags}" } diff --git a/cc/config/x86_windows_host.go b/cc/config/x86_windows_host.go index 016e71126..fea629109 100644 --- a/cc/config/x86_windows_host.go +++ b/cc/config/x86_windows_host.go @@ -245,10 +245,20 @@ func (t *toolchainWindowsX86) ClangLdflags() string { return "${config.WindowsClangLdflags} ${config.WindowsX86ClangLdflags}" } +func (t *toolchainWindowsX86) ClangLldflags() string { + // TODO: define and use Windows*ClangLldflags + return "${config.WindowsClangLdflags} ${config.WindowsX86ClangLdflags}" +} + func (t *toolchainWindowsX8664) ClangLdflags() string { return "${config.WindowsClangLdflags} ${config.WindowsX8664ClangLdflags}" } +func (t *toolchainWindowsX8664) ClangLldflags() string { + // TODO: define and use Windows*ClangLldflags + return "${config.WindowsClangLdflags} ${config.WindowsX8664ClangLdflags}" +} + func (t *toolchainWindows) ShlibSuffix() string { return ".dll" } diff --git a/cc/linker.go b/cc/linker.go index bcedc8da1..217630633 100644 --- a/cc/linker.go +++ b/cc/linker.go @@ -58,6 +58,9 @@ type BaseLinkerProperties struct { // don't link in libgcc.a No_libgcc *bool + // Use clang lld instead of gnu ld. + Use_clang_lld *bool + // -l arguments to pass to linker for host-provided shared libraries Host_ldlibs []string `android:"arch_variant"` @@ -201,6 +204,15 @@ func (linker *baseLinker) linkerDeps(ctx BaseModuleContext, deps Deps) Deps { return deps } +func (linker *baseLinker) useClangLld(ctx ModuleContext) bool { + if linker.Properties.Use_clang_lld != nil { + return Bool(linker.Properties.Use_clang_lld) + } + return ctx.Config().UseClangLld() +} + +// ModuleContext extends BaseModuleContext +// BaseModuleContext should know if LLD is used? func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { toolchain := ctx.toolchain() @@ -209,7 +221,11 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { hod = "Device" } - flags.LdFlags = append(flags.LdFlags, fmt.Sprintf("${config.%sGlobalLdflags}", hod)) + if flags.Clang && linker.useClangLld(ctx) { + flags.LdFlags = append(flags.LdFlags, fmt.Sprintf("${config.%sGlobalLldflags}", hod)) + } else { + flags.LdFlags = append(flags.LdFlags, fmt.Sprintf("${config.%sGlobalLdflags}", hod)) + } if Bool(linker.Properties.Allow_undefined_symbols) { if ctx.Darwin() { // darwin defaults to treating undefined symbols as errors @@ -219,7 +235,9 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { flags.LdFlags = append(flags.LdFlags, "-Wl,--no-undefined") } - if flags.Clang { + if flags.Clang && linker.useClangLld(ctx) { + flags.LdFlags = append(flags.LdFlags, toolchain.ClangLldflags()) + } else if flags.Clang { flags.LdFlags = append(flags.LdFlags, toolchain.ClangLdflags()) } else { flags.LdFlags = append(flags.LdFlags, toolchain.Ldflags()) diff --git a/cc/lto.go b/cc/lto.go index 85057cf48..fd2a86945 100644 --- a/cc/lto.go +++ b/cc/lto.go @@ -49,6 +49,9 @@ type LTOProperties struct { // since it is an object dependency of an LTO module. FullDep bool `blueprint:"mutated"` ThinDep bool `blueprint:"mutated"` + + // Use clang lld instead of gnu ld. + Use_clang_lld *bool } type lto struct { @@ -69,6 +72,13 @@ func (lto *lto) deps(ctx BaseModuleContext, deps Deps) Deps { return deps } +func (lto *lto) useClangLld(ctx BaseModuleContext) bool { + if lto.Properties.Use_clang_lld != nil { + return Bool(lto.Properties.Use_clang_lld) + } + return ctx.Config().UseClangLld() +} + func (lto *lto) flags(ctx BaseModuleContext, flags Flags) Flags { if lto.LTO() { var ltoFlag string @@ -82,7 +92,7 @@ func (lto *lto) flags(ctx BaseModuleContext, flags Flags) Flags { flags.CFlags = append(flags.CFlags, ltoFlag) flags.LdFlags = append(flags.LdFlags, ltoFlag) - if ctx.Config().IsEnvTrue("USE_THINLTO_CACHE") && Bool(lto.Properties.Lto.Thin) { + if ctx.Config().IsEnvTrue("USE_THINLTO_CACHE") && Bool(lto.Properties.Lto.Thin) && !lto.useClangLld(ctx) { // Set appropriate ThinLTO cache policy cacheDirFormat := "-Wl,-plugin-opt,cache-dir=" cacheDir := android.PathForOutput(ctx, "thinlto-cache").String() @@ -99,7 +109,7 @@ func (lto *lto) flags(ctx BaseModuleContext, flags Flags) Flags { // If the module does not have a profile, be conservative and do not inline // or unroll loops during LTO, in order to prevent significant size bloat. - if !ctx.isPgoCompile() { + if !ctx.isPgoCompile() && !lto.useClangLld(ctx) { flags.LdFlags = append(flags.LdFlags, "-Wl,-plugin-opt,-inline-threshold=0") flags.LdFlags = append(flags.LdFlags, "-Wl,-plugin-opt,-unroll-threshold=0") } diff --git a/cc/makevars.go b/cc/makevars.go index 83a662f71..bb81dcb9f 100644 --- a/cc/makevars.go +++ b/cc/makevars.go @@ -232,6 +232,12 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string, toolchain.ToolchainLdflags(), productExtraLdflags, }, " ")) + ctx.Strict(makePrefix+"GLOBAL_LLDFLAGS", strings.Join([]string{ + fmt.Sprintf("${config.%sGlobalLldflags}", hod), + toolchain.Ldflags(), + toolchain.ToolchainLdflags(), + productExtraLdflags, + }, " ")) includeFlags, err := ctx.Eval(toolchain.IncludeFlags()) if err != nil { @@ -280,6 +286,13 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string, productExtraLdflags, clangExtras, }, " ")) + ctx.Strict(clangPrefix+"GLOBAL_LLDFLAGS", strings.Join([]string{ + fmt.Sprintf("${config.%sGlobalLldflags}", hod), + toolchain.ClangLldflags(), + toolchain.ToolchainClangLdflags(), + productExtraLdflags, + clangExtras, + }, " ")) if target.Os.Class == android.Device { ctx.Strict(secondPrefix+"ADDRESS_SANITIZER_RUNTIME_LIBRARY", strings.TrimSuffix(config.AddressSanitizerRuntimeLibrary(toolchain), ".so")) diff --git a/cc/relocation_packer.go b/cc/relocation_packer.go index 500662365..f6a1fe482 100644 --- a/cc/relocation_packer.go +++ b/cc/relocation_packer.go @@ -38,12 +38,22 @@ type RelocationPackerProperties struct { // This will be true even if we're embedded in Make, in which case // we'll defer to make to actually do the packing. PackingRelocations bool `blueprint:"mutated"` + + // Use clang lld instead of gnu ld. + Use_clang_lld *bool } type relocationPacker struct { Properties RelocationPackerProperties } +func (p *relocationPacker) useClangLld(ctx BaseModuleContext) bool { + if p.Properties.Use_clang_lld != nil { + return Bool(p.Properties.Use_clang_lld) + } + return ctx.Config().UseClangLld() +} + func (p *relocationPacker) packingInit(ctx BaseModuleContext) { enabled := true // Relocation packer isn't available on Darwin yet @@ -56,6 +66,11 @@ func (p *relocationPacker) packingInit(ctx BaseModuleContext) { if ctx.Config().Getenv("DISABLE_RELOCATION_PACKER") == "true" { enabled = false } + // Relocation packer does not work with lld output files. + // Packed files won't load. + if p.useClangLld(ctx) { + enabled = false + } if ctx.useSdk() { enabled = false } -- cgit v1.2.3