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

Commit 4af21ed2 authored by Colin Cross's avatar Colin Cross
Browse files

Split local and global cflags 

Native compiler flags are currently applied in approximately:
global cflags
local cflags
local include dirs
global include dirs
global conlyflags
local conlyflags
global cppflags
local cppflags

This means that a flag that is enabled in the global cppflags
cannot be disabled in the local cflags, and an Android.bp author
must know to disable it in the local cppflags.  A better order
would be:
global cflags
global conlyflags
global cppflags
local cflags
local conlyflags
local cppflags
local include dirs
global include dirs

We are mixing both the global and local cflags into a single
variable, and similar for conlyflags and cppflags, which
prevents reordering them.  This CL prepares to reorder them
by splitting the global and local cflags into separate variables.

Bug: 143713277
Test: m native
Change-Id: Ic55a8c3516c331dc5f2af9d00e59ceca9d3e6c15
parent 1f056cd6

cc/binary.go

+12 −12
Original line number Diff line number Diff line
@@ -227,7 +227,7 @@ func (binary *binaryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags 


	if ctx.Host() && !ctx.Windows() && !binary.static() {

		if !ctx.Config().IsEnvTrue("DISABLE_HOST_PIE") {

			flags.LdFlags = append(flags.LdFlags, "-pie")

			flags.Global.LdFlags = append(flags.Global.LdFlags, "-pie")

		}

	}
@@ -235,7 +235,7 @@ func (binary *binaryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags 
	// all code is position independent, and then those warnings get promoted to

	// errors.

	if !ctx.Windows() {

		flags.CFlags = append(flags.CFlags, "-fPIE")

		flags.Global.CFlags = append(flags.Global.CFlags, "-fPIE")

	}



	if ctx.toolchain().Bionic() {
@@ -244,11 +244,11 @@ func (binary *binaryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags 
			// However, bionic/linker uses -shared to overwrite.

			// Linker for x86 targets does not allow coexistance of -static and -shared,

			// so we add -static only if -shared is not used.

			if !inList("-shared", flags.LdFlags) {

				flags.LdFlags = append(flags.LdFlags, "-static")

			if !inList("-shared", flags.Local.LdFlags) {

				flags.Global.LdFlags = append(flags.Global.LdFlags, "-static")

			}



			flags.LdFlags = append(flags.LdFlags,

			flags.Global.LdFlags = append(flags.Global.LdFlags,

				"-nostdlib",

				"-Bstatic",

				"-Wl,--gc-sections",
@@ -278,14 +278,14 @@ func (binary *binaryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags 
				if ctx.Os() == android.LinuxBionic {

					// Use the dlwrap entry point, but keep _start around so

					// that it can be used by host_bionic_inject

					flags.LdFlags = append(flags.LdFlags,

					flags.Global.LdFlags = append(flags.Global.LdFlags,

						"-Wl,--entry=__dlwrap__start",

						"-Wl,--undefined=_start",

					)

				}

			}



			flags.LdFlags = append(flags.LdFlags,

			flags.Global.LdFlags = append(flags.Global.LdFlags,

				"-pie",

				"-nostdlib",

				"-Bdynamic",
@@ -295,10 +295,10 @@ func (binary *binaryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags 
		}

	} else {

		if binary.static() {

			flags.LdFlags = append(flags.LdFlags, "-static")

			flags.Global.LdFlags = append(flags.Global.LdFlags, "-static")

		}

		if ctx.Darwin() {

			flags.LdFlags = append(flags.LdFlags, "-Wl,-headerpad_max_install_names")

			flags.Global.LdFlags = append(flags.Global.LdFlags, "-Wl,-headerpad_max_install_names")

		}

	}
@@ -315,14 +315,14 @@ func (binary *binaryDecorator) link(ctx ModuleContext, 
	var linkerDeps android.Paths



	if deps.LinkerFlagsFile.Valid() {

		flags.LdFlags = append(flags.LdFlags, "$$(cat "+deps.LinkerFlagsFile.String()+")")

		flags.Local.LdFlags = append(flags.Local.LdFlags, "$$(cat "+deps.LinkerFlagsFile.String()+")")

		linkerDeps = append(linkerDeps, deps.LinkerFlagsFile.Path())

	}



	if flags.DynamicLinker != "" {

		flags.LdFlags = append(flags.LdFlags, "-Wl,-dynamic-linker,"+flags.DynamicLinker)

		flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-dynamic-linker,"+flags.DynamicLinker)

	} else if ctx.toolchain().Bionic() && !binary.static() {

		flags.LdFlags = append(flags.LdFlags, "-Wl,--no-dynamic-linker")

		flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--no-dynamic-linker")

	}



	builderFlags := flagsToBuilderFlags(flags)

cc/builder.go

+2 −6
Original line number Diff line number Diff line
@@ -261,8 +261,7 @@ func init() { 
}



type builderFlags struct {

	globalFlags     string

	arFlags         string

	commonFlags     string

	asFlags         string

	cFlags          string

	toolingCFlags   string // A separate set of cFlags for clang LibTooling tools
@@ -350,7 +349,7 @@ func TransformSourceToObj(ctx android.ModuleContext, subdir string, srcFiles and 
	}



	commonFlags := strings.Join([]string{

		flags.globalFlags,

		flags.commonFlags,

		flags.systemIncludeFlags,

	}, " ")
@@ -567,9 +566,6 @@ func TransformObjToStaticLib(ctx android.ModuleContext, objFiles android.Paths, 
	if !ctx.Darwin() {

		arFlags += " -format=gnu"

	}

	if flags.arFlags != "" {

		arFlags += " " + flags.arFlags

	}



	ctx.Build(pctx, android.BuildParams{

		Rule:        ar,

cc/cc.go

+32 −24
Original line number Diff line number Diff line
@@ -140,26 +140,34 @@ type PathDeps struct { 
	DynamicLinker android.OptionalPath

}



type Flags struct {

	GlobalFlags     []string // Flags that apply to C, C++, and assembly source files

	ArFlags         []string // Flags that apply to ar

// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module

// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the

// command line so they can be overridden by the local module flags).

type LocalOrGlobalFlags struct {

	CommonFlags     []string // Flags that apply to C, C++, and assembly source files

	AsFlags         []string // Flags that apply to assembly source files

	YasmFlags       []string // Flags that apply to yasm assembly source files

	CFlags          []string // Flags that apply to C and C++ source files

	ToolingCFlags   []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools

	ConlyFlags      []string // Flags that apply to C source files

	CppFlags        []string // Flags that apply to C++ source files

	ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools

	LdFlags         []string // Flags that apply to linker command lines

}



type Flags struct {

	Local  LocalOrGlobalFlags

	Global LocalOrGlobalFlags



	aidlFlags     []string // Flags that apply to aidl source files

	rsFlags       []string // Flags that apply to renderscript source files

	LdFlags         []string // Flags that apply to linker command lines

	libFlags      []string // Flags to add libraries early to the link order

	extraLibFlags []string // Flags to add libraries late in the link order after LdFlags

	TidyFlags     []string // Flags that apply to clang-tidy

	SAbiFlags     []string // Flags that apply to header-abi-dumper

	YasmFlags       []string // Flags that apply to yasm assembly source files



	// Global include flags that apply to C, C++, and assembly source files

	// These must be after any module include flags, which will be in GlobalFlags.

	// These must be after any module include flags, which will be in CommonFlags.

	SystemIncludeFlags []string



	Toolchain config.Toolchain
@@ -1277,17 +1285,17 @@ func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) { 
		return

	}



	flags.CFlags, _ = filterList(flags.CFlags, config.IllegalFlags)

	flags.CppFlags, _ = filterList(flags.CppFlags, config.IllegalFlags)

	flags.ConlyFlags, _ = filterList(flags.ConlyFlags, config.IllegalFlags)

	flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)

	flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)

	flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)



	flags.GlobalFlags = append(flags.GlobalFlags, deps.Flags...)

	flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)



	for _, dir := range deps.IncludeDirs {

		flags.GlobalFlags = append(flags.GlobalFlags, "-I"+dir.String())

		flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())

	}

	for _, dir := range deps.SystemIncludeDirs {

		flags.GlobalFlags = append(flags.GlobalFlags, "-isystem "+dir.String())

		flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())

	}



	c.flags = flags
@@ -1296,16 +1304,16 @@ func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) { 
		flags = c.sabi.flags(ctx, flags)

	}



	flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.AsFlags)

	flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)



	// Optimization to reduce size of build.ninja

	// Replace the long list of flags for each file with a module-local variable

	ctx.Variable(pctx, "cflags", strings.Join(flags.CFlags, " "))

	ctx.Variable(pctx, "cppflags", strings.Join(flags.CppFlags, " "))

	ctx.Variable(pctx, "asflags", strings.Join(flags.AsFlags, " "))

	flags.CFlags = []string{"$cflags"}

	flags.CppFlags = []string{"$cppflags"}

	flags.AsFlags = []string{"$asflags"}

	ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))

	ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))

	ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))

	flags.Local.CFlags = []string{"$cflags"}

	flags.Local.CppFlags = []string{"$cppflags"}

	flags.Local.AsFlags = []string{"$asflags"}



	var objs Objects

	if c.compiler != nil {

cc/cflag_artifacts.go

+2 −2
Original line number Diff line number Diff line
@@ -147,8 +147,8 @@ func (s *cflagArtifactsText) GenerateBuildActions(ctx android.SingletonContext) 
	ctx.VisitAllModules(func(module android.Module) {

		if ccModule, ok := module.(*Module); ok {

			if allowedDir(ctx.ModuleDir(ccModule)) {

				cflags := ccModule.flags.CFlags

				cppflags := ccModule.flags.CppFlags

				cflags := ccModule.flags.Local.CFlags

				cppflags := ccModule.flags.Local.CppFlags

				module := fmt.Sprintf("%s:%s (%s)",

					ctx.BlueprintFile(ccModule),

					ctx.ModuleName(ccModule),

cc/cmakelists.go

+31 −15
Original line number Diff line number Diff line
@@ -162,25 +162,41 @@ func generateCLionProject(compiledModule CompiledInterface, ctx android.Singleto 
	f.WriteString(")\n")



	// Add all header search path and compiler parameters (-D, -W, -f, -XXXX)

	f.WriteString("\n# GLOBAL FLAGS:\n")

	globalParameters := parseCompilerParameters(ccModule.flags.GlobalFlags, ctx, f)

	translateToCMake(globalParameters, f, true, true)

	f.WriteString("\n# GLOBAL ALL FLAGS:\n")

	globalAllParameters := parseCompilerParameters(ccModule.flags.Global.CommonFlags, ctx, f)

	translateToCMake(globalAllParameters, f, true, true)



	f.WriteString("\n# CFLAGS:\n")

	cParameters := parseCompilerParameters(ccModule.flags.CFlags, ctx, f)

	translateToCMake(cParameters, f, true, true)

	f.WriteString("\n# LOCAL ALL FLAGS:\n")

	localAllParameters := parseCompilerParameters(ccModule.flags.Local.CommonFlags, ctx, f)

	translateToCMake(localAllParameters, f, true, true)



	f.WriteString("\n# C ONLY FLAGS:\n")

	cOnlyParameters := parseCompilerParameters(ccModule.flags.ConlyFlags, ctx, f)

	translateToCMake(cOnlyParameters, f, true, false)

	f.WriteString("\n# GLOBAL CFLAGS:\n")

	globalCParameters := parseCompilerParameters(ccModule.flags.Global.CFlags, ctx, f)

	translateToCMake(globalCParameters, f, true, true)



	f.WriteString("\n# CPP FLAGS:\n")

	cppParameters := parseCompilerParameters(ccModule.flags.CppFlags, ctx, f)

	translateToCMake(cppParameters, f, false, true)

	f.WriteString("\n# LOCAL CFLAGS:\n")

	localCParameters := parseCompilerParameters(ccModule.flags.Local.CFlags, ctx, f)

	translateToCMake(localCParameters, f, true, true)



	f.WriteString("\n# SYSTEM INCLUDE FLAGS:\n")

	includeParameters := parseCompilerParameters(ccModule.flags.SystemIncludeFlags, ctx, f)

	translateToCMake(includeParameters, f, true, true)

	f.WriteString("\n# GLOBAL C ONLY FLAGS:\n")

	globalConlyParameters := parseCompilerParameters(ccModule.flags.Global.ConlyFlags, ctx, f)

	translateToCMake(globalConlyParameters, f, true, false)



	f.WriteString("\n# LOCAL C ONLY FLAGS:\n")

	localConlyParameters := parseCompilerParameters(ccModule.flags.Local.ConlyFlags, ctx, f)

	translateToCMake(localConlyParameters, f, true, false)



	f.WriteString("\n# GLOBAL CPP FLAGS:\n")

	globalCppParameters := parseCompilerParameters(ccModule.flags.Global.CppFlags, ctx, f)

	translateToCMake(globalCppParameters, f, false, true)



	f.WriteString("\n# LOCAL CPP FLAGS:\n")

	localCppParameters := parseCompilerParameters(ccModule.flags.Local.CppFlags, ctx, f)

	translateToCMake(localCppParameters, f, false, true)



	f.WriteString("\n# GLOBAL SYSTEM INCLUDE FLAGS:\n")

	globalIncludeParameters := parseCompilerParameters(ccModule.flags.SystemIncludeFlags, ctx, f)

	translateToCMake(globalIncludeParameters, f, true, true)



	// Add project executable.

	f.WriteString(fmt.Sprintf("\nadd_executable(%s ${SOURCE_FILES})\n",