Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 33bac24b authored by Colin Cross's avatar Colin Cross
Browse files

Remove clang indirection without affecting build.ninja 

Remove cflags that are not handled by clang from the global defaults,
and remove calls to ClangFilterUnknownCflags.

Squash lists of clang-specific default flags into the main default
flags lists.

Rename Toolchain.Clang*flags to Toolchain.*flags.

Rename Go variables with Clang in the name that have no non-Clang
equivalent.

Remove unused ninja variables.

Bug: 68947919
Test: no change to build.ninja for aosp_cf_x86_64_phone-userdebug or aosp_crosshatch-userdebug
Change-Id: Id287945315d53e5eaef197adbbb4f1302f2e3680
parent 1c19b81e

cc/compiler.go

+5 −5
Original line number Diff line number Diff line
@@ -392,7 +392,7 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps 
	if flags.RequiredInstructionSet != "" {

		instructionSet = flags.RequiredInstructionSet

	}

	instructionSetFlags, err := tc.ClangInstructionSetFlags(instructionSet)

	instructionSetFlags, err := tc.InstructionSetFlags(instructionSet)

	if err != nil {

		ctx.ModuleErrorf("%s", err)

	}
@@ -437,10 +437,10 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps 
	flags.Global.ConlyFlags = append([]string{"${config.CommonGlobalConlyflags}"}, flags.Global.ConlyFlags...)

	flags.Global.CppFlags = append([]string{fmt.Sprintf("${config.%sGlobalCppflags}", hod)}, flags.Global.CppFlags...)



	flags.Global.AsFlags = append(flags.Global.AsFlags, tc.ClangAsflags())

	flags.Global.AsFlags = append(flags.Global.AsFlags, tc.Asflags())

	flags.Global.CppFlags = append([]string{"${config.CommonClangGlobalCppflags}"}, flags.Global.CppFlags...)

	flags.Global.CommonFlags = append(flags.Global.CommonFlags,

		tc.ClangCflags(),

		tc.Cflags(),

		"${config.CommonClangGlobalCflags}",

		fmt.Sprintf("${config.%sClangGlobalCflags}", hod))
@@ -458,11 +458,11 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps 


	flags.Global.AsFlags = append(flags.Global.AsFlags, "-D__ASSEMBLY__")



	flags.Global.CppFlags = append(flags.Global.CppFlags, tc.ClangCppflags())

	flags.Global.CppFlags = append(flags.Global.CppFlags, tc.Cppflags())



	flags.Global.YasmFlags = append(flags.Global.YasmFlags, tc.YasmFlags())



	flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainClangCflags())

	flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainCflags())



	cStd := config.CStdVersion

	if String(compiler.Properties.C_std) == "experimental" {

cc/config/arm64_device.go

+24 −26
Original line number Diff line number Diff line
@@ -48,12 +48,12 @@ var ( 
		"-Wl,-z,separate-code",

	}



	arm64Lldflags = append(ClangFilterUnknownLldflags(arm64Ldflags),

	arm64Lldflags = append(arm64Ldflags,

		"-Wl,-z,max-page-size=4096")



	arm64Cppflags = []string{}



	arm64ClangCpuVariantCflags = map[string][]string{

	arm64CpuVariantCflags = map[string][]string{

		"cortex-a53": []string{

			"-mcpu=cortex-a53",

		},
@@ -99,10 +99,8 @@ func init() { 
	pctx.StaticVariable("Arm64Ldflags", strings.Join(arm64Ldflags, " "))

	pctx.StaticVariable("Arm64Lldflags", strings.Join(arm64Lldflags, " "))



	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("Arm64ClangCflags", strings.Join(arm64Cflags, " "))

	pctx.StaticVariable("Arm64ClangCppflags", strings.Join(arm64Cppflags, " "))



	pctx.StaticVariable("Arm64ClangArmv8ACflags", strings.Join(arm64ArchVariantCflags["armv8-a"], " "))

	pctx.StaticVariable("Arm64ClangArmv8ABranchProtCflags", strings.Join(arm64ArchVariantCflags["armv8-a-branchprot"], " "))
@@ -110,30 +108,30 @@ func init() { 
	pctx.StaticVariable("Arm64ClangArmv82ADotprodCflags", strings.Join(arm64ArchVariantCflags["armv8-2a-dotprod"], " "))



	pctx.StaticVariable("Arm64ClangCortexA53Cflags",

		strings.Join(arm64ClangCpuVariantCflags["cortex-a53"], " "))

		strings.Join(arm64CpuVariantCflags["cortex-a53"], " "))



	pctx.StaticVariable("Arm64ClangCortexA55Cflags",

		strings.Join(arm64ClangCpuVariantCflags["cortex-a55"], " "))

		strings.Join(arm64CpuVariantCflags["cortex-a55"], " "))



	pctx.StaticVariable("Arm64ClangKryoCflags",

		strings.Join(arm64ClangCpuVariantCflags["kryo"], " "))

		strings.Join(arm64CpuVariantCflags["kryo"], " "))



	pctx.StaticVariable("Arm64ClangExynosM1Cflags",

		strings.Join(arm64ClangCpuVariantCflags["exynos-m1"], " "))

		strings.Join(arm64CpuVariantCflags["exynos-m1"], " "))



	pctx.StaticVariable("Arm64ClangExynosM2Cflags",

		strings.Join(arm64ClangCpuVariantCflags["exynos-m2"], " "))

		strings.Join(arm64CpuVariantCflags["exynos-m2"], " "))

}



var (

	arm64ClangArchVariantCflagsVar = map[string]string{

	arm64ArchVariantCflagsVar = map[string]string{

		"armv8-a":            "${config.Arm64ClangArmv8ACflags}",

		"armv8-a-branchprot": "${config.Arm64ClangArmv8ABranchProtCflags}",

		"armv8-2a":           "${config.Arm64ClangArmv82ACflags}",

		"armv8-2a-dotprod":   "${config.Arm64ClangArmv82ADotprodCflags}",

	}



	arm64ClangCpuVariantCflagsVar = map[string]string{

	arm64CpuVariantCflagsVar = map[string]string{

		"":           "",

		"cortex-a53": "${config.Arm64ClangCortexA53Cflags}",

		"cortex-a55": "${config.Arm64ClangCortexA55Cflags}",
@@ -154,7 +152,7 @@ type toolchainArm64 struct { 


	ldflags         string

	lldflags        string

	toolchainClangCflags string

	toolchainCflags string

}



func (t *toolchainArm64) Name() string {
@@ -181,24 +179,24 @@ func (t *toolchainArm64) ClangTriple() string { 
	return t.GccTriple()

}



func (t *toolchainArm64) ClangCflags() string {

func (t *toolchainArm64) Cflags() string {

	return "${config.Arm64ClangCflags}"

}



func (t *toolchainArm64) ClangCppflags() string {

func (t *toolchainArm64) Cppflags() string {

	return "${config.Arm64ClangCppflags}"

}



func (t *toolchainArm64) ClangLdflags() string {

func (t *toolchainArm64) Ldflags() string {

	return t.ldflags

}



func (t *toolchainArm64) ClangLldflags() string {

func (t *toolchainArm64) Lldflags() string {

	return t.lldflags

}



func (t *toolchainArm64) ToolchainClangCflags() string {

	return t.toolchainClangCflags

func (t *toolchainArm64) ToolchainCflags() string {

	return t.toolchainCflags

}



func (toolchainArm64) LibclangRuntimeLibraryArch() string {
@@ -216,9 +214,9 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain { 
		panic(fmt.Sprintf("Unknown ARM architecture version: %q", arch.ArchVariant))

	}



	toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[arch.ArchVariant]}

	toolchainClangCflags = append(toolchainClangCflags,

		variantOrDefault(arm64ClangCpuVariantCflagsVar, arch.CpuVariant))

	toolchainCflags := []string{arm64ArchVariantCflagsVar[arch.ArchVariant]}

	toolchainCflags = append(toolchainCflags,

		variantOrDefault(arm64CpuVariantCflagsVar, arch.CpuVariant))



	var extraLdflags string

	switch arch.CpuVariant {
@@ -235,7 +233,7 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain { 
			"${config.Arm64Lldflags}",

			extraLdflags,

		}, " "),

		toolchainClangCflags: strings.Join(toolchainClangCflags, " "),

		toolchainCflags: strings.Join(toolchainCflags, " "),

	}

}

cc/config/arm64_fuchsia_device.go

+5 −21
Original line number Diff line number Diff line
@@ -42,47 +42,31 @@ func (t *toolchainFuchsiaArm64) GccVersion() string { 
	return arm64GccVersion

}



func (t *toolchainFuchsiaArm64) Cflags() string {

	return ""

}



func (t *toolchainFuchsiaArm64) Cppflags() string {

	return ""

}



func (t *toolchainFuchsiaArm64) Ldflags() string {

	return "-Wl,--fix-cortex-a53-843419"

}



func (t *toolchainFuchsiaArm64) IncludeFlags() string {

	return ""

}



func (t *toolchainFuchsiaArm64) ToolchainCflags() string {

	return "-mcpu=cortex-a53"

}



func (t *toolchainFuchsiaArm64) ClangTriple() string {

	return "arm64-fuchsia-android"

}



func (t *toolchainFuchsiaArm64) ClangCppflags() string {

func (t *toolchainFuchsiaArm64) Cppflags() string {

	return "-Wno-error=deprecated-declarations"

}



func (t *toolchainFuchsiaArm64) ClangLdflags() string {

func (t *toolchainFuchsiaArm64) Ldflags() string {

	return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/"

}



func (t *toolchainFuchsiaArm64) ClangLldflags() string {

func (t *toolchainFuchsiaArm64) Lldflags() string {

	return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/"

}



func (t *toolchainFuchsiaArm64) ClangCflags() string {

func (t *toolchainFuchsiaArm64) Cflags() string {

	return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -I" + fuchsiaArm64SysRoot + "/include"

}



func (t *toolchainFuchsiaArm64) ToolchainClangCflags() string {

func (t *toolchainFuchsiaArm64) ToolchainCflags() string {

	return "-march=armv8-a"

}

cc/config/arm64_linux_host.go

+9 −8
Original line number Diff line number Diff line
@@ -15,14 +15,15 @@ 
package config



import (

	"android/soong/android"

	"strings"



	"android/soong/android"

)



var (

	// This is a host toolchain but flags for device toolchain are required

	// as the flags are actually for Bionic-based builds.

	linuxCrossCflags = ClangFilterUnknownCflags(append(deviceGlobalCflags,

	linuxCrossCflags = append(deviceGlobalCflags,

		// clang by default enables PIC when the clang triple is set to *-android.

		// See toolchain/llvm-project/clang/lib/Driver/ToolChains/CommonArgs.cpp#920.

		// However, for this host target, we don't set "-android" to avoid __ANDROID__ macro
@@ -33,9 +34,9 @@ var ( 
		// This is normally in ClangExtraTargetCflags, but that's for device and we need

		// the same for host

		"-nostdlibinc",

	))

	)



	linuxCrossLdflags = ClangFilterUnknownCflags([]string{

	linuxCrossLdflags = []string{

		"-Wl,-z,noexecstack",

		"-Wl,-z,relro",

		"-Wl,-z,now",
@@ -44,7 +45,7 @@ var ( 
		"-Wl,--fatal-warnings",

		"-Wl,--hash-style=gnu",

		"-Wl,--no-undefined-version",

	})

	}



	// Embed the linker into host bionic binaries. This is needed to support host bionic,

	// as the linux kernel requires that the ELF interpreter referenced by PT_INTERP be
@@ -73,7 +74,7 @@ func (toolchainLinuxArm64) ClangTriple() string { 
	return "aarch64-linux"

}



func (toolchainLinuxArm64) ClangCflags() string {

func (toolchainLinuxArm64) Cflags() string {

	// The inherited flags + extra flags

	return "${config.Arm64ClangCflags} ${config.LinuxBionicArm64Cflags}"

}
@@ -84,7 +85,7 @@ func (toolchainLinuxArm64) CrtBeginSharedBinary() []string { 


func linuxArm64ToolchainFactory(arch android.Arch) Toolchain {

	archVariant := "armv8-a" // for host, default to armv8-a

	toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[archVariant]}

	toolchainCflags := []string{arm64ArchVariantCflagsVar[archVariant]}



	// We don't specify CPU architecture for host. Conservatively assume

	// the host CPU needs the fix
@@ -103,7 +104,7 @@ func linuxArm64ToolchainFactory(arch android.Arch) Toolchain { 
		"${config.LinuxBionicArm64Ldflags}",

		extraLdflags,

	}, " ")

	ret.toolchainArm64.toolchainClangCflags = strings.Join(toolchainClangCflags, " ")

	ret.toolchainArm64.toolchainCflags = strings.Join(toolchainCflags, " ")

	return &ret

}

cc/config/arm_device.go

+40 −43
Original line number Diff line number Diff line
@@ -23,7 +23,6 @@ import ( 


var (

	armToolchainCflags = []string{

		"-mthumb-interwork",

		"-msoft-float",

	}
@@ -38,7 +37,7 @@ var ( 
		"-Wl,-m,armelf",

	}



	armLldflags = ClangFilterUnknownLldflags(armLdflags)

	armLldflags = armLdflags



	armArmCflags = []string{

		"-fstrict-aliasing",
@@ -49,7 +48,7 @@ var ( 
		"-Os",

	}



	armClangArchVariantCflags = map[string][]string{

	armArchVariantCflags = map[string][]string{

		"armv7-a": []string{

			"-march=armv7-a",

			"-mfloat-abi=softfp",
@@ -72,7 +71,7 @@ var ( 
		},

	}



	armClangCpuVariantCflags = map[string][]string{

	armCpuVariantCflags = map[string][]string{

		"cortex-a7": []string{

			"-mcpu=cortex-a7",

			"-mfpu=neon-vfpv4",
@@ -181,42 +180,40 @@ func init() { 
	exportStringListStaticVariable("ArmLldflags", armLldflags)



	// Clang cflags

	exportStringListStaticVariable("ArmToolchainClangCflags", ClangFilterUnknownCflags(armToolchainCflags))

	exportStringListStaticVariable("ArmClangCflags", ClangFilterUnknownCflags(armCflags))

	exportStringListStaticVariable("ArmClangLdflags", ClangFilterUnknownCflags(armLdflags))

	exportStringListStaticVariable("ArmClangLldflags", ClangFilterUnknownCflags(armLldflags))

	exportStringListStaticVariable("ArmClangCppflags", ClangFilterUnknownCflags(armCppflags))

	exportStringListStaticVariable("ArmToolchainClangCflags", armToolchainCflags)

	exportStringListStaticVariable("ArmClangCflags", armCflags)

	exportStringListStaticVariable("ArmClangCppflags", armCppflags)



	// Clang ARM vs. Thumb instruction set cflags

	exportStringListStaticVariable("ArmClangArmCflags", ClangFilterUnknownCflags(armArmCflags))

	exportStringListStaticVariable("ArmClangThumbCflags", ClangFilterUnknownCflags(armThumbCflags))

	exportStringListStaticVariable("ArmClangArmCflags", armArmCflags)

	exportStringListStaticVariable("ArmClangThumbCflags", armThumbCflags)



	// Clang arch variant cflags

	exportStringListStaticVariable("ArmClangArmv7ACflags", armClangArchVariantCflags["armv7-a"])

	exportStringListStaticVariable("ArmClangArmv7ANeonCflags", armClangArchVariantCflags["armv7-a-neon"])

	exportStringListStaticVariable("ArmClangArmv8ACflags", armClangArchVariantCflags["armv8-a"])

	exportStringListStaticVariable("ArmClangArmv82ACflags", armClangArchVariantCflags["armv8-2a"])

	exportStringListStaticVariable("ArmClangArmv7ACflags", armArchVariantCflags["armv7-a"])

	exportStringListStaticVariable("ArmClangArmv7ANeonCflags", armArchVariantCflags["armv7-a-neon"])

	exportStringListStaticVariable("ArmClangArmv8ACflags", armArchVariantCflags["armv8-a"])

	exportStringListStaticVariable("ArmClangArmv82ACflags", armArchVariantCflags["armv8-2a"])



	// Clang cpu variant cflags

	exportStringListStaticVariable("ArmClangGenericCflags", armClangCpuVariantCflags[""])

	exportStringListStaticVariable("ArmClangCortexA7Cflags", armClangCpuVariantCflags["cortex-a7"])

	exportStringListStaticVariable("ArmClangCortexA8Cflags", armClangCpuVariantCflags["cortex-a8"])

	exportStringListStaticVariable("ArmClangCortexA15Cflags", armClangCpuVariantCflags["cortex-a15"])

	exportStringListStaticVariable("ArmClangCortexA53Cflags", armClangCpuVariantCflags["cortex-a53"])

	exportStringListStaticVariable("ArmClangCortexA55Cflags", armClangCpuVariantCflags["cortex-a55"])

	exportStringListStaticVariable("ArmClangKraitCflags", armClangCpuVariantCflags["krait"])

	exportStringListStaticVariable("ArmClangKryoCflags", armClangCpuVariantCflags["kryo"])

	exportStringListStaticVariable("ArmClangGenericCflags", armCpuVariantCflags[""])

	exportStringListStaticVariable("ArmClangCortexA7Cflags", armCpuVariantCflags["cortex-a7"])

	exportStringListStaticVariable("ArmClangCortexA8Cflags", armCpuVariantCflags["cortex-a8"])

	exportStringListStaticVariable("ArmClangCortexA15Cflags", armCpuVariantCflags["cortex-a15"])

	exportStringListStaticVariable("ArmClangCortexA53Cflags", armCpuVariantCflags["cortex-a53"])

	exportStringListStaticVariable("ArmClangCortexA55Cflags", armCpuVariantCflags["cortex-a55"])

	exportStringListStaticVariable("ArmClangKraitCflags", armCpuVariantCflags["krait"])

	exportStringListStaticVariable("ArmClangKryoCflags", armCpuVariantCflags["kryo"])

}



var (

	armClangArchVariantCflagsVar = map[string]string{

	armArchVariantCflagsVar = map[string]string{

		"armv7-a":      "${config.ArmClangArmv7ACflags}",

		"armv7-a-neon": "${config.ArmClangArmv7ANeonCflags}",

		"armv8-a":      "${config.ArmClangArmv8ACflags}",

		"armv8-2a":     "${config.ArmClangArmv82ACflags}",

	}



	armClangCpuVariantCflagsVar = map[string]string{

	armCpuVariantCflagsVar = map[string]string{

		"":               "${config.ArmClangGenericCflags}",

		"cortex-a7":      "${config.ArmClangCortexA7Cflags}",

		"cortex-a8":      "${config.ArmClangCortexA8Cflags}",
@@ -241,7 +238,7 @@ type toolchainArm struct { 
	toolchain32Bit

	ldflags         string

	lldflags        string

	toolchainClangCflags string

	toolchainCflags string

}



func (t *toolchainArm) Name() string {
@@ -274,34 +271,34 @@ func (t *toolchainArm) ndkTriple() string { 
	return t.GccTriple()

}



func (t *toolchainArm) ToolchainClangCflags() string {

	return t.toolchainClangCflags

func (t *toolchainArm) ToolchainCflags() string {

	return t.toolchainCflags

}



func (t *toolchainArm) ClangCflags() string {

func (t *toolchainArm) Cflags() string {

	return "${config.ArmClangCflags}"

}



func (t *toolchainArm) ClangCppflags() string {

func (t *toolchainArm) Cppflags() string {

	return "${config.ArmClangCppflags}"

}



func (t *toolchainArm) ClangLdflags() string {

func (t *toolchainArm) Ldflags() string {

	return t.ldflags

}



func (t *toolchainArm) ClangLldflags() string {

func (t *toolchainArm) Lldflags() string {

	return t.lldflags // TODO: handle V8 cases

}



func (t *toolchainArm) ClangInstructionSetFlags(isa string) (string, error) {

func (t *toolchainArm) InstructionSetFlags(isa string) (string, error) {

	switch isa {

	case "arm":

		return "${config.ArmClangArmCflags}", nil

	case "thumb", "":

		return "${config.ArmClangThumbCflags}", nil

	default:

		return t.toolchainBase.ClangInstructionSetFlags(isa)

		return t.toolchainBase.InstructionSetFlags(isa)

	}

}
@@ -311,13 +308,13 @@ func (toolchainArm) LibclangRuntimeLibraryArch() string { 


func armToolchainFactory(arch android.Arch) Toolchain {

	var fixCortexA8 string

	toolchainClangCflags := make([]string, 2, 3)

	toolchainCflags := make([]string, 2, 3)



	toolchainClangCflags[0] = "${config.ArmToolchainClangCflags}"

	toolchainClangCflags[1] = armClangArchVariantCflagsVar[arch.ArchVariant]

	toolchainCflags[0] = "${config.ArmToolchainClangCflags}"

	toolchainCflags[1] = armArchVariantCflagsVar[arch.ArchVariant]



	toolchainClangCflags = append(toolchainClangCflags,

		variantOrDefault(armClangCpuVariantCflagsVar, arch.CpuVariant))

	toolchainCflags = append(toolchainCflags,

		variantOrDefault(armCpuVariantCflagsVar, arch.CpuVariant))



	switch arch.ArchVariant {

	case "armv7-a-neon":
@@ -342,7 +339,7 @@ func armToolchainFactory(arch android.Arch) Toolchain { 
			fixCortexA8,

		}, " "),

		lldflags:        "${config.ArmLldflags}",

		toolchainClangCflags: strings.Join(toolchainClangCflags, " "),

		toolchainCflags: strings.Join(toolchainCflags, " "),

	}

}