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

Commit 908fbe20 authored by Colin Cross's avatar Colin Cross Committed by Gerrit Code Review
Browse files

Merge changes I29bf144b,Id2879453 

* changes:
  Remove more clang indirection without affecting command lines
  Remove clang indirection without affecting build.ninja
parents c07b16f4 c8bed31f

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

	}

}