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

@@ -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)
 }

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"`
 

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",

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
 }

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, " "),
 	}
 }

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 {

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, " "))

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"
 }

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"
 }

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

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}"
 }

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}"
 }

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}"
 }

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

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}"
 }

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"
 }

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())

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")
 		}

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"))

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
 	}