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

Commit bd4abf5d authored by Dan Willemsen's avatar Dan Willemsen
Browse files

Remove GCC-specific toolchain methods 

Test: m
Change-Id: I06442347ade2d60bc42131b3126ecc17840c9e31
parent 6afcd9aa

cc/config/arm64_device.go

+2 −51
Original line number Diff line number Diff line
@@ -48,7 +48,7 @@ var ( 


	arm64Cppflags = []string{}



	arm64CpuVariantCflags = map[string][]string{

	arm64ClangCpuVariantCflags = map[string][]string{

		"cortex-a53": []string{

			"-mcpu=cortex-a53",

		},
@@ -61,9 +61,7 @@ var ( 
			"-mcpu=cortex-a55",

		},

		"kryo": []string{

			// Use the cortex-a57 cpu since some compilers

			// don't support a Kryo specific target yet.

			"-mcpu=cortex-a57",

			"-mcpu=kryo",

		},

		"exynos-m1": []string{

			"-mcpu=exynos-m1",
@@ -72,8 +70,6 @@ var ( 
			"-mcpu=exynos-m2",

		},

	}



	arm64ClangCpuVariantCflags = copyVariantFlags(arm64CpuVariantCflags)

)



const (
@@ -94,18 +90,13 @@ func init() { 
		"exynos-m2",

		"denver64")



	// Clang supports specific Kryo targeting

	replaceFirst(arm64ClangCpuVariantCflags["kryo"], "-mcpu=cortex-a57", "-mcpu=kryo")



	pctx.StaticVariable("arm64GccVersion", arm64GccVersion)



	pctx.SourcePathVariable("Arm64GccRoot",

		"prebuilts/gcc/${HostPrebuiltTag}/aarch64/aarch64-linux-android-${arm64GccVersion}")



	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), " "))
@@ -116,45 +107,23 @@ func init() { 
	pctx.StaticVariable("Arm64ClangArmv8ACflags", strings.Join(arm64ArchVariantCflags["armv8-a"], " "))

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



	pctx.StaticVariable("Arm64CortexA53Cflags",

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

	pctx.StaticVariable("Arm64ClangCortexA53Cflags",

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



	pctx.StaticVariable("Arm64CortexA55Cflags",

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

	pctx.StaticVariable("Arm64ClangCortexA55Cflags",

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



	pctx.StaticVariable("Arm64KryoCflags",

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

	pctx.StaticVariable("Arm64ClangKryoCflags",

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



	pctx.StaticVariable("Arm64ExynosM1Cflags",

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

	pctx.StaticVariable("Arm64ClangExynosM1Cflags",

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



	pctx.StaticVariable("Arm64ExynosM2Cflags",

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

	pctx.StaticVariable("Arm64ClangExynosM2Cflags",

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

}



var (

	arm64CpuVariantCflagsVar = map[string]string{

		"":           "",

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

		"cortex-a55": "${config.Arm64CortexA55Cflags}",

		"cortex-a72": "${config.Arm64CortexA53Cflags}",

		"cortex-a73": "${config.Arm64CortexA53Cflags}",

		"cortex-a75": "${config.Arm64CortexA55Cflags}",

		"kryo":       "${config.Arm64KryoCflags}",

		"exynos-m1":  "${config.Arm64ExynosM1Cflags}",

		"exynos-m2":  "${config.Arm64ExynosM2Cflags}",

	}



	arm64ClangArchVariantCflagsVar = map[string]string{

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

		"armv8-2a": "${config.Arm64ClangArmv82ACflags}",
@@ -178,7 +147,6 @@ type toolchainArm64 struct { 


	ldflags              string

	lldflags             string

	toolchainCflags      string

	toolchainClangCflags string

}
@@ -198,22 +166,6 @@ func (t *toolchainArm64) GccVersion() string { 
	return arm64GccVersion

}



func (t *toolchainArm64) ToolchainCflags() string {

	return t.toolchainCflags

}



func (t *toolchainArm64) Cflags() string {

	return "${config.Arm64Cflags}"

}



func (t *toolchainArm64) Cppflags() string {

	return "${config.Arm64Cppflags}"

}



func (t *toolchainArm64) Ldflags() string {

	return t.ldflags

}



func (t *toolchainArm64) IncludeFlags() string {

	return "${config.Arm64IncludeFlags}"

}
@@ -277,7 +229,6 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain { 
			"${config.Arm64Lldflags}",

			extraLdflags,

		}, " "),

		toolchainCflags:      variantOrDefault(arm64CpuVariantCflagsVar, arch.CpuVariant),

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

	}

}

cc/config/arm_device.go

+6 −89
Original line number Diff line number Diff line
@@ -50,7 +50,7 @@ var ( 
		"-Os",

	}



	armArchVariantCflags = map[string][]string{

	armClangArchVariantCflags = map[string][]string{

		"armv7-a": []string{

			"-march=armv7-a",

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

	}



	armCpuVariantCflags = map[string][]string{

	armClangCpuVariantCflags = map[string][]string{

		"cortex-a7": []string{

			"-mcpu=cortex-a7",

			"-mfpu=neon-vfpv4",
@@ -118,7 +118,7 @@ var ( 
			"-D__ARM_FEATURE_LPAE=1",

		},

		"krait": []string{

			"-mcpu=cortex-a15",

			"-mcpu=krait",

			"-mfpu=neon-vfpv4",

			// Fake an ARM compiler flag as these processors support LPAE which GCC/clang

			// don't advertise.
@@ -138,9 +138,6 @@ var ( 
			"-D__ARM_FEATURE_LPAE=1",

		},

	}



	armClangCpuVariantCflags  = copyVariantFlags(armCpuVariantCflags)

	armClangArchVariantCflags = copyVariantFlags(armArchVariantCflags)

)



const (
@@ -174,49 +171,15 @@ func init() { 
	android.RegisterArchVariantFeatures(android.Arm, "armv7-a-neon", "neon")

	android.RegisterArchVariantFeatures(android.Arm, "armv8-a", "neon")



	// Krait is not supported by GCC, but is supported by Clang, so

	// override the definitions when building modules with Clang.

	replaceFirst(armClangCpuVariantCflags["krait"], "-mcpu=cortex-a15", "-mcpu=krait")



	// The reason we use "-march=armv8-a+crc", instead of "-march=armv8-a", for

	// gcc is the latter would conflict with any specified/supported -mcpu!

	// All armv8-a cores supported by gcc 4.9 support crc, so it's safe

	// to add +crc. Besides, the use of gcc is only for legacy code.

	replaceFirst(armArchVariantCflags["armv8-a"], "-march=armv8-a", "-march=armv8-a+crc")



	pctx.StaticVariable("armGccVersion", armGccVersion)



	pctx.SourcePathVariable("ArmGccRoot",

		"prebuilts/gcc/${HostPrebuiltTag}/arm/arm-linux-androideabi-${armGccVersion}")



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



	// Extended cflags



	// ARM vs. Thumb instruction set flags

	pctx.StaticVariable("ArmArmCflags", strings.Join(armArmCflags, " "))

	pctx.StaticVariable("ArmThumbCflags", strings.Join(armThumbCflags, " "))



	// Architecture variant cflags

	pctx.StaticVariable("ArmArmv7ACflags", strings.Join(armArchVariantCflags["armv7-a"], " "))

	pctx.StaticVariable("ArmArmv7ANeonCflags", strings.Join(armArchVariantCflags["armv7-a-neon"], " "))

	pctx.StaticVariable("ArmArmv8ACflags", strings.Join(armArchVariantCflags["armv8-a"], " "))



	// Cpu variant cflags

	pctx.StaticVariable("ArmGenericCflags", strings.Join(armCpuVariantCflags[""], " "))

	pctx.StaticVariable("ArmCortexA7Cflags", strings.Join(armCpuVariantCflags["cortex-a7"], " "))

	pctx.StaticVariable("ArmCortexA8Cflags", strings.Join(armCpuVariantCflags["cortex-a8"], " "))

	pctx.StaticVariable("ArmCortexA15Cflags", strings.Join(armCpuVariantCflags["cortex-a15"], " "))

	pctx.StaticVariable("ArmCortexA53Cflags", strings.Join(armCpuVariantCflags["cortex-a53"], " "))

	pctx.StaticVariable("ArmCortexA55Cflags", strings.Join(armCpuVariantCflags["cortex-a55"], " "))

	pctx.StaticVariable("ArmKraitCflags", strings.Join(armCpuVariantCflags["krait"], " "))

	pctx.StaticVariable("ArmKryoCflags", strings.Join(armCpuVariantCflags["kryo"], " "))



	// Clang cflags

	pctx.StaticVariable("ArmToolchainClangCflags", strings.Join(ClangFilterUnknownCflags(armToolchainCflags), " "))

	pctx.StaticVariable("ArmClangCflags", strings.Join(ClangFilterUnknownCflags(armCflags), " "))
@@ -256,30 +219,6 @@ func init() { 
}



var (

	armArchVariantCflagsVar = map[string]string{

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

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

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

	}



	armCpuVariantCflagsVar = map[string]string{

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

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

		"cortex-a8":      "${config.ArmCortexA8Cflags}",

		"cortex-a15":     "${config.ArmCortexA15Cflags}",

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

		"cortex-a53.a57": "${config.ArmCortexA53Cflags}",

		"cortex-a55":     "${config.ArmCortexA55Cflags}",

		"cortex-a72":     "${config.ArmCortexA53Cflags}",

		"cortex-a73":     "${config.ArmCortexA53Cflags}",

		"cortex-a75":     "${config.ArmCortexA55Cflags}",

		"krait":          "${config.ArmKraitCflags}",

		"kryo":           "${config.ArmKryoCflags}",

		"exynos-m1":      "${config.ArmCortexA53Cflags}",

		"exynos-m2":      "${config.ArmCortexA53Cflags}",

		"denver":         "${config.ArmCortexA15Cflags}",

	}



	armClangArchVariantCflagsVar = map[string]string{

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

		"armv7-a-neon": "${config.ArmClangArmv7ANeonCflags}",
@@ -309,7 +248,7 @@ type toolchainArm struct { 
	toolchain32Bit

	ldflags              string

	lldflags             string

	toolchainCflags, toolchainClangCflags string

	toolchainClangCflags string

}



func (t *toolchainArm) Name() string {
@@ -328,22 +267,6 @@ func (t *toolchainArm) GccVersion() string { 
	return armGccVersion

}



func (t *toolchainArm) ToolchainCflags() string {

	return t.toolchainCflags

}



func (t *toolchainArm) Cflags() string {

	return "${config.ArmCflags}"

}



func (t *toolchainArm) Cppflags() string {

	return "${config.ArmCppflags}"

}



func (t *toolchainArm) Ldflags() string {

	return t.ldflags

}



func (t *toolchainArm) IncludeFlags() string {

	return "${config.ArmIncludeFlags}"

}
@@ -395,16 +318,11 @@ func (toolchainArm) LibclangRuntimeLibraryArch() string { 


func armToolchainFactory(arch android.Arch) Toolchain {

	var fixCortexA8 string

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

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



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

	toolchainCflags[1] = armArchVariantCflagsVar[arch.ArchVariant]

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

	toolchainClangCflags[1] = armClangArchVariantCflagsVar[arch.ArchVariant]



	toolchainCflags = append(toolchainCflags,

		variantOrDefault(armCpuVariantCflagsVar, arch.CpuVariant))

	toolchainClangCflags = append(toolchainClangCflags,

		variantOrDefault(armClangCpuVariantCflagsVar, arch.CpuVariant))
@@ -426,7 +344,6 @@ func armToolchainFactory(arch android.Arch) Toolchain { 
	}



	return &toolchainArm{

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

		ldflags: strings.Join([]string{

			"${config.ArmLdflags}",

			fixCortexA8,

cc/config/global.go

+0 −8
Original line number Diff line number Diff line
@@ -15,7 +15,6 @@ 
package config



import (

	"fmt"

	"runtime"

	"strings"
@@ -250,10 +249,3 @@ func bionicHeaders(kernelArch string) string { 
		"-isystem bionic/libc/kernel/android/uapi",

	}, " ")

}
 


func replaceFirst(slice []string, from, to string) {

	if slice[0] != from {

		panic(fmt.Errorf("Expected %q, found %q", from, to))

	}

	slice[0] = to

}

cc/config/mips64_device.go

+2 −24
Original line number Diff line number Diff line
@@ -69,9 +69,6 @@ func init() { 
	pctx.SourcePathVariable("Mips64GccRoot",

		"prebuilts/gcc/${HostPrebuiltTag}/mips/mips64el-linux-android-${mips64GccVersion}")



	pctx.StaticVariable("Mips64Cflags", strings.Join(mips64Cflags, " "))

	pctx.StaticVariable("Mips64Ldflags", strings.Join(mips64Ldflags, " "))

	pctx.StaticVariable("Mips64Cppflags", strings.Join(mips64Cppflags, " "))

	pctx.StaticVariable("Mips64IncludeFlags", bionicHeaders("mips"))



	// Clang cflags
@@ -83,7 +80,6 @@ func init() { 


	// Architecture variant cflags

	for variant, cflags := range mips64ArchVariantCflags {

		pctx.StaticVariable("Mips64"+variant+"VariantCflags", strings.Join(cflags, " "))

		pctx.StaticVariable("Mips64"+variant+"VariantClangCflags",

			strings.Join(ClangFilterUnknownCflags(cflags), " "))

	}
@@ -91,8 +87,8 @@ func init() { 


type toolchainMips64 struct {

	toolchain64Bit

	cflags, clangCflags                   string

	toolchainCflags, toolchainClangCflags string

	clangCflags          string

	toolchainClangCflags string

}



func (t *toolchainMips64) Name() string {
@@ -111,22 +107,6 @@ func (t *toolchainMips64) GccVersion() string { 
	return mips64GccVersion

}



func (t *toolchainMips64) ToolchainCflags() string {

	return t.toolchainCflags

}



func (t *toolchainMips64) Cflags() string {

	return t.cflags

}



func (t *toolchainMips64) Cppflags() string {

	return "${config.Mips64Cppflags}"

}



func (t *toolchainMips64) Ldflags() string {

	return "${config.Mips64Ldflags}"

}



func (t *toolchainMips64) IncludeFlags() string {

	return "${config.Mips64IncludeFlags}"

}
@@ -166,9 +146,7 @@ func (toolchainMips64) LibclangRuntimeLibraryArch() string { 


func mips64ToolchainFactory(arch android.Arch) Toolchain {

	return &toolchainMips64{

		cflags:               "${config.Mips64Cflags}",

		clangCflags:          "${config.Mips64ClangCflags}",

		toolchainCflags:      "${config.Mips64" + arch.ArchVariant + "VariantCflags}",

		toolchainClangCflags: "${config.Mips64" + arch.ArchVariant + "VariantClangCflags}",

	}

}

cc/config/mips_device.go

+2 −28
Original line number Diff line number Diff line
@@ -111,9 +111,6 @@ func init() { 
		"prebuilts/gcc/${HostPrebuiltTag}/mips/mips64el-linux-android-${mipsGccVersion}")



	pctx.StaticVariable("MipsToolchainLdflags", strings.Join(mipsToolchainLdflags, " "))

	pctx.StaticVariable("MipsCflags", strings.Join(mipsCflags, " "))

	pctx.StaticVariable("MipsLdflags", strings.Join(mipsLdflags, " "))

	pctx.StaticVariable("MipsCppflags", strings.Join(mipsCppflags, " "))

	pctx.StaticVariable("MipsIncludeFlags", bionicHeaders("mips"))



	// Clang cflags
@@ -125,7 +122,6 @@ func init() { 


	// Architecture variant cflags

	for variant, cflags := range mipsArchVariantCflags {

		pctx.StaticVariable("Mips"+variant+"VariantCflags", strings.Join(cflags, " "))

		pctx.StaticVariable("Mips"+variant+"VariantClangCflags",

			strings.Join(ClangFilterUnknownCflags(cflags), " "))

	}
@@ -133,8 +129,8 @@ func init() { 


type toolchainMips struct {

	toolchain32Bit

	cflags, clangCflags                   string

	toolchainCflags, toolchainClangCflags string

	clangCflags          string

	toolchainClangCflags string

}



func (t *toolchainMips) Name() string {
@@ -153,26 +149,6 @@ func (t *toolchainMips) GccVersion() string { 
	return mipsGccVersion

}



func (t *toolchainMips) ToolchainLdflags() string {

	return "${config.MipsToolchainLdflags}"

}



func (t *toolchainMips) ToolchainCflags() string {

	return t.toolchainCflags

}



func (t *toolchainMips) Cflags() string {

	return t.cflags

}



func (t *toolchainMips) Cppflags() string {

	return "${config.MipsCppflags}"

}



func (t *toolchainMips) Ldflags() string {

	return "${config.MipsLdflags}"

}



func (t *toolchainMips) IncludeFlags() string {

	return "${config.MipsIncludeFlags}"

}
@@ -216,9 +192,7 @@ func (toolchainMips) LibclangRuntimeLibraryArch() string { 


func mipsToolchainFactory(arch android.Arch) Toolchain {

	return &toolchainMips{

		cflags:               "${config.MipsCflags}",

		clangCflags:          "${config.MipsClangCflags}",

		toolchainCflags:      "${config.Mips" + arch.ArchVariant + "VariantCflags}",

		toolchainClangCflags: "${config.Mips" + arch.ArchVariant + "VariantClangCflags}",

	}

}