Export cc types for art to inherit from
Art needs a custom module type in order to perform complicated
build logic like depending on environment variables and varying
cflags based on cpu variant. Export enough of the types and
functions from cc for art_cc_library to inherit from cc_library.
While I'm touching every line, also rename the New* methods
to *Factory.
Change-Id: I7123aa47019c4ced7a1ab57c394225bc7844b5ea
diff --git a/cc/arm64_device.go b/cc/arm64_device.go
index 4b1598f..ac0d94a 100644
--- a/cc/arm64_device.go
+++ b/cc/arm64_device.go
@@ -128,7 +128,7 @@
return "${arm64Ldflags}"
}
-func arm64ToolchainFactory(archVariant string, cpuVariant string) toolchain {
+func arm64ToolchainFactory(archVariant string, cpuVariant string) Toolchain {
return toolchainArm64Singleton
}
diff --git a/cc/arm_device.go b/cc/arm_device.go
index 8cd33e3..e736509 100644
--- a/cc/arm_device.go
+++ b/cc/arm_device.go
@@ -283,7 +283,7 @@
return t.ldflags
}
-func armToolchainFactory(archVariant string, cpuVariant string) toolchain {
+func armToolchainFactory(archVariant string, cpuVariant string) Toolchain {
return &toolchainArm{
cflags: strings.Join([]string{
"${armCflags}",
diff --git a/cc/builder.go b/cc/builder.go
index 04a2e8d..e7ea73d 100644
--- a/cc/builder.go
+++ b/cc/builder.go
@@ -88,7 +88,7 @@
ldLibs string
incFlags string
nocrt bool
- toolchain toolchain
+ toolchain Toolchain
clang bool
}
@@ -283,6 +283,6 @@
})
}
-func gccCmd(toolchain toolchain, cmd string) string {
+func gccCmd(toolchain Toolchain, cmd string) string {
return filepath.Join(toolchain.GccRoot(), "bin", toolchain.GccTriple()+"-"+cmd)
}
diff --git a/cc/cc.go b/cc/cc.go
index dd1a9a6..30319a8 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -19,12 +19,13 @@
// is handled in builder.go
import (
- "github.com/google/blueprint"
- "github.com/google/blueprint/pathtools"
"fmt"
"path/filepath"
"strings"
+ "github.com/google/blueprint"
+ "github.com/google/blueprint/pathtools"
+
"android/soong/common"
"android/soong/genrule"
)
@@ -108,7 +109,7 @@
pctx.StaticVariable("clangPath", "${SrcDir}/prebuilts/clang/${HostPrebuiltTag}/host/3.6/bin/")
}
-// CcProperties describes properties used to compile all C or C++ modules
+// ccProperties describes properties used to compile all C or C++ modules
type ccProperties struct {
// srcs: list of source files used to compile the C/C++ module. May be .c, .cpp, or .S files.
Srcs []string `android:"arch_variant,arch_subtract"`
@@ -223,50 +224,47 @@
}
// Building C/C++ code is handled by objects that satisfy this interface via composition
-type ccModuleType interface {
+type CCModuleType interface {
common.AndroidModule
- // Return the cflags that are specific to this _type_ of module
- moduleTypeCflags(common.AndroidModuleContext, toolchain) []string
-
- // Return the ldflags that are specific to this _type_ of module
- moduleTypeLdflags(common.AndroidModuleContext, toolchain) []string
+ // Modify the ccFlags that are specific to this _type_ of module
+ ModuleTypeFlags(common.AndroidModuleContext, CCFlags) CCFlags
// Create a ccDeps struct that collects the module dependency info. Can also
// modify ccFlags in order to add dependency include directories, etc.
- collectDeps(common.AndroidModuleContext, ccFlags) (ccDeps, ccFlags)
+ collectDeps(common.AndroidModuleContext, CCFlags) (CCDeps, CCFlags)
// Compile objects into final module
- compileModule(common.AndroidModuleContext, ccFlags, ccDeps, []string)
+ compileModule(common.AndroidModuleContext, CCFlags, CCDeps, []string)
// Install the built module.
- installModule(common.AndroidModuleContext, ccFlags)
+ installModule(common.AndroidModuleContext, CCFlags)
// Return the output file (.o, .a or .so) for use by other modules
outputFile() string
}
-type ccDeps struct {
- staticLibs, sharedLibs, lateStaticLibs, wholeStaticLibs, objFiles, includeDirs []string
+type CCDeps struct {
+ StaticLibs, SharedLibs, LateStaticLibs, WholeStaticLibs, ObjFiles, IncludeDirs []string
- crtBegin, crtEnd string
+ CrtBegin, CrtEnd string
}
-type ccFlags struct {
- globalFlags []string
- asFlags []string
- cFlags []string
- conlyFlags []string
- cppFlags []string
- ldFlags []string
- ldLibs []string
- includeDirs []string
- nocrt bool
- toolchain toolchain
- clang bool
+type CCFlags struct {
+ GlobalFlags []string
+ AsFlags []string
+ CFlags []string
+ ConlyFlags []string
+ CppFlags []string
+ LdFlags []string
+ LdLibs []string
+ IncludeDirs []string
+ Nocrt bool
+ Toolchain Toolchain
+ Clang bool
- extraStaticLibs []string
- extraSharedLibs []string
+ ExtraStaticLibs []string
+ ExtraSharedLibs []string
}
// ccBase contains the properties and members used by all C/C++ module types, and implements
@@ -274,7 +272,7 @@
// and uses a ccModuleType interface to that struct to create the build steps.
type ccBase struct {
common.AndroidModuleBase
- module ccModuleType
+ module CCModuleType
properties ccProperties
unused unusedProperties
@@ -282,7 +280,7 @@
installPath string
}
-func newCCBase(base *ccBase, module ccModuleType, hod common.HostOrDeviceSupported,
+func newCCBase(base *ccBase, module CCModuleType, hod common.HostOrDeviceSupported,
multilib common.Multilib, props ...interface{}) (blueprint.Module, []interface{}) {
base.module = module
@@ -313,7 +311,7 @@
return
}
- flags.includeDirs = append(flags.includeDirs, deps.includeDirs...)
+ flags.IncludeDirs = append(flags.IncludeDirs, deps.IncludeDirs...)
objFiles := c.compileObjs(ctx, flags, deps)
if ctx.Failed() {
@@ -338,13 +336,13 @@
}
}
-func (c *ccBase) ccModuleType() ccModuleType {
+func (c *ccBase) ccModuleType() CCModuleType {
return c.module
}
var _ common.AndroidDynamicDepender = (*ccBase)(nil)
-func (c *ccBase) findToolchain(ctx common.AndroidModuleContext) toolchain {
+func (c *ccBase) findToolchain(ctx common.AndroidModuleContext) Toolchain {
arch := ctx.Arch()
factory := toolchainFactories[arch.HostOrDevice][arch.ArchType]
if factory == nil {
@@ -354,12 +352,8 @@
return factory(arch.ArchVariant, arch.CpuVariant)
}
-func (c *ccBase) moduleTypeCflags(ctx common.AndroidModuleContext, toolchain toolchain) []string {
- return nil
-}
-
-func (c *ccBase) moduleTypeLdflags(ctx common.AndroidModuleContext, toolchain toolchain) []string {
- return nil
+func (c *ccBase) ModuleTypeFlags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
+ return flags
}
func (c *ccBase) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
@@ -372,19 +366,19 @@
// Create a ccFlags struct that collects the compile flags from global values,
// per-target values, module type values, and per-module Blueprints properties
-func (c *ccBase) flags(ctx common.AndroidModuleContext, toolchain toolchain) ccFlags {
+func (c *ccBase) flags(ctx common.AndroidModuleContext, toolchain Toolchain) CCFlags {
arch := ctx.Arch()
- flags := ccFlags{
- cFlags: c.properties.Cflags,
- cppFlags: c.properties.Cppflags,
- conlyFlags: c.properties.Conlyflags,
- ldFlags: c.properties.Ldflags,
- asFlags: c.properties.Asflags,
- nocrt: c.properties.Nocrt,
- toolchain: toolchain,
- clang: c.properties.Clang,
+ flags := CCFlags{
+ CFlags: c.properties.Cflags,
+ CppFlags: c.properties.Cppflags,
+ ConlyFlags: c.properties.Conlyflags,
+ LdFlags: c.properties.Ldflags,
+ AsFlags: c.properties.Asflags,
+ Nocrt: c.properties.Nocrt,
+ Toolchain: toolchain,
+ Clang: c.properties.Clang,
}
instructionSet := c.properties.Instruction_set
instructionSetFlags, err := toolchain.InstructionSetFlags(instructionSet)
@@ -393,67 +387,67 @@
}
// TODO: debug
- flags.cFlags = append(flags.cFlags, c.properties.Release.Cflags...)
+ flags.CFlags = append(flags.CFlags, c.properties.Release.Cflags...)
if arch.HostOrDevice.Host() {
// TODO: allow per-module clang disable for host
- flags.clang = true
+ flags.Clang = true
}
- if flags.clang {
- flags.cFlags = clangFilterUnknownCflags(flags.cFlags)
- flags.cFlags = append(flags.cFlags, c.properties.Clang_cflags...)
- flags.asFlags = append(flags.asFlags, c.properties.Clang_asflags...)
- flags.cppFlags = clangFilterUnknownCflags(flags.cppFlags)
- flags.conlyFlags = clangFilterUnknownCflags(flags.conlyFlags)
- flags.ldFlags = clangFilterUnknownCflags(flags.ldFlags)
+ if flags.Clang {
+ flags.CFlags = clangFilterUnknownCflags(flags.CFlags)
+ flags.CFlags = append(flags.CFlags, c.properties.Clang_cflags...)
+ flags.AsFlags = append(flags.AsFlags, c.properties.Clang_asflags...)
+ flags.CppFlags = clangFilterUnknownCflags(flags.CppFlags)
+ flags.ConlyFlags = clangFilterUnknownCflags(flags.ConlyFlags)
+ flags.LdFlags = clangFilterUnknownCflags(flags.LdFlags)
- flags.cFlags = append(flags.cFlags, "${clangExtraCflags}")
- flags.conlyFlags = append(flags.conlyFlags, "${clangExtraConlyflags}")
+ flags.CFlags = append(flags.CFlags, "${clangExtraCflags}")
+ flags.ConlyFlags = append(flags.ConlyFlags, "${clangExtraConlyflags}")
if arch.HostOrDevice.Device() {
- flags.cFlags = append(flags.cFlags, "${clangExtraTargetCflags}")
+ flags.CFlags = append(flags.CFlags, "${clangExtraTargetCflags}")
}
target := "-target " + toolchain.ClangTriple()
gccPrefix := "-B" + filepath.Join(toolchain.GccRoot(), toolchain.GccTriple(), "bin")
- flags.cFlags = append(flags.cFlags, target, gccPrefix)
- flags.asFlags = append(flags.asFlags, target, gccPrefix)
- flags.ldFlags = append(flags.ldFlags, target, gccPrefix)
+ flags.CFlags = append(flags.CFlags, target, gccPrefix)
+ flags.AsFlags = append(flags.AsFlags, target, gccPrefix)
+ flags.LdFlags = append(flags.LdFlags, target, gccPrefix)
if arch.HostOrDevice.Host() {
gccToolchain := "--gcc-toolchain=" + toolchain.GccRoot()
sysroot := "--sysroot=" + filepath.Join(toolchain.GccRoot(), "sysroot")
// TODO: also need more -B, -L flags to make host builds hermetic
- flags.cFlags = append(flags.cFlags, gccToolchain, sysroot)
- flags.asFlags = append(flags.asFlags, gccToolchain, sysroot)
- flags.ldFlags = append(flags.ldFlags, gccToolchain, sysroot)
+ flags.CFlags = append(flags.CFlags, gccToolchain, sysroot)
+ flags.AsFlags = append(flags.AsFlags, gccToolchain, sysroot)
+ flags.LdFlags = append(flags.LdFlags, gccToolchain, sysroot)
}
}
- flags.includeDirs = pathtools.PrefixPaths(c.properties.Include_dirs, ctx.Config().(Config).SrcDir())
+ flags.IncludeDirs = pathtools.PrefixPaths(c.properties.Include_dirs, ctx.Config().(Config).SrcDir())
localIncludeDirs := pathtools.PrefixPaths(c.properties.Local_include_dirs, common.ModuleSrcDir(ctx))
- flags.includeDirs = append(flags.includeDirs, localIncludeDirs...)
+ flags.IncludeDirs = append(flags.IncludeDirs, localIncludeDirs...)
if !c.properties.No_default_compiler_flags {
- flags.includeDirs = append(flags.includeDirs, []string{
+ flags.IncludeDirs = append(flags.IncludeDirs, []string{
common.ModuleSrcDir(ctx),
common.ModuleOutDir(ctx),
common.ModuleGenDir(ctx),
}...)
if c.properties.Sdk_version == "" {
- flags.includeDirs = append(flags.includeDirs, "${SrcDir}/libnativehelper/include/nativehelper")
+ flags.IncludeDirs = append(flags.IncludeDirs, "${SrcDir}/libnativehelper/include/nativehelper")
}
if arch.HostOrDevice.Device() && !c.properties.Allow_undefined_symbols {
- flags.ldFlags = append(flags.ldFlags, "-Wl,--no-undefined")
+ flags.LdFlags = append(flags.LdFlags, "-Wl,--no-undefined")
}
- if flags.clang {
- flags.cppFlags = append(flags.cppFlags, "${commonClangGlobalCppflags}")
- flags.globalFlags = []string{
+ if flags.Clang {
+ flags.CppFlags = append(flags.CppFlags, "${commonClangGlobalCppflags}")
+ flags.GlobalFlags = []string{
"${commonGlobalIncludes}",
toolchain.IncludeFlags(),
instructionSetFlags,
@@ -462,8 +456,8 @@
fmt.Sprintf("${%sClangGlobalCflags}", arch.HostOrDevice),
}
} else {
- flags.cppFlags = append(flags.cppFlags, "${commonGlobalCppflags}")
- flags.globalFlags = []string{
+ flags.CppFlags = append(flags.CppFlags, "${commonGlobalCppflags}")
+ flags.GlobalFlags = []string{
"${commonGlobalIncludes}",
toolchain.IncludeFlags(),
instructionSetFlags,
@@ -474,45 +468,44 @@
}
if arch.HostOrDevice.Host() {
- flags.ldFlags = append(flags.ldFlags, c.properties.Host_ldlibs...)
+ flags.LdFlags = append(flags.LdFlags, c.properties.Host_ldlibs...)
}
if arch.HostOrDevice.Device() {
if c.properties.Rtti {
- flags.cppFlags = append(flags.cppFlags, "-frtti")
+ flags.CppFlags = append(flags.CppFlags, "-frtti")
} else {
- flags.cppFlags = append(flags.cppFlags, "-fno-rtti")
+ flags.CppFlags = append(flags.CppFlags, "-fno-rtti")
}
}
- flags.asFlags = append(flags.asFlags, "-D__ASSEMBLY__")
+ flags.AsFlags = append(flags.AsFlags, "-D__ASSEMBLY__")
- if flags.clang {
- flags.cppFlags = append(flags.cppFlags, toolchain.ClangCppflags())
- flags.ldFlags = append(flags.ldFlags, toolchain.ClangLdflags())
+ if flags.Clang {
+ flags.CppFlags = append(flags.CppFlags, toolchain.ClangCppflags())
+ flags.LdFlags = append(flags.LdFlags, toolchain.ClangLdflags())
} else {
- flags.cppFlags = append(flags.cppFlags, toolchain.Cppflags())
- flags.ldFlags = append(flags.ldFlags, toolchain.Ldflags())
+ flags.CppFlags = append(flags.CppFlags, toolchain.Cppflags())
+ flags.LdFlags = append(flags.LdFlags, toolchain.Ldflags())
}
}
- flags.cFlags = append(flags.cFlags, c.ccModuleType().moduleTypeCflags(ctx, toolchain)...)
- flags.ldFlags = append(flags.ldFlags, c.ccModuleType().moduleTypeLdflags(ctx, toolchain)...)
+ flags = c.ccModuleType().ModuleTypeFlags(ctx, flags)
// 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.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"}
return flags
}
// Modify ccFlags structs with STL library info
-func (c *ccBase) addStlFlags(ctx common.AndroidModuleContext, flags ccFlags) ccFlags {
+func (c *ccBase) addStlFlags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
if !c.properties.No_default_compiler_flags {
arch := ctx.Arch()
stl := "libc++" // TODO: mingw needs libstdc++
@@ -527,28 +520,28 @@
switch stl {
case "libc++", "libc++_static":
- flags.cFlags = append(flags.cFlags, "-D_USING_LIBCXX")
- flags.includeDirs = append(flags.includeDirs, "${SrcDir}/external/libcxx/include")
+ flags.CFlags = append(flags.CFlags, "-D_USING_LIBCXX")
+ flags.IncludeDirs = append(flags.IncludeDirs, "${SrcDir}/external/libcxx/include")
if arch.HostOrDevice.Host() {
- flags.cppFlags = append(flags.cppFlags, "-nostdinc++")
- flags.ldFlags = append(flags.ldFlags, "-nodefaultlibs")
- flags.ldLibs = append(flags.ldLibs, "-lc", "-lm", "-lpthread")
+ flags.CppFlags = append(flags.CppFlags, "-nostdinc++")
+ flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
+ flags.LdLibs = append(flags.LdLibs, "-lc", "-lm", "-lpthread")
}
if stlStatic {
- flags.extraStaticLibs = append(flags.extraStaticLibs, "libc++_static")
+ flags.ExtraStaticLibs = append(flags.ExtraStaticLibs, "libc++_static")
} else {
- flags.extraSharedLibs = append(flags.extraSharedLibs, "libc++")
+ flags.ExtraSharedLibs = append(flags.ExtraSharedLibs, "libc++")
}
case "stlport", "stlport_static":
if arch.HostOrDevice.Device() {
- flags.includeDirs = append(flags.includeDirs,
+ flags.IncludeDirs = append(flags.IncludeDirs,
"${SrcDir}/external/stlport/stlport",
"${SrcDir}/bionic/libstdc++/include",
"${SrcDir}/bionic")
if stlStatic {
- flags.extraStaticLibs = append(flags.extraStaticLibs, "libstdc++", "libstlport_static")
+ flags.ExtraStaticLibs = append(flags.ExtraStaticLibs, "libstdc++", "libstlport_static")
} else {
- flags.extraSharedLibs = append(flags.extraSharedLibs, "libstdc++", "libstlport")
+ flags.ExtraSharedLibs = append(flags.ExtraSharedLibs, "libstdc++", "libstlport")
}
}
case "ndk":
@@ -558,14 +551,14 @@
// tree is in good enough shape to not need it.
// Host builds will use GNU libstdc++.
if arch.HostOrDevice.Device() {
- flags.includeDirs = append(flags.includeDirs, "${SrcDir}/bionic/libstdc++/include")
- flags.extraSharedLibs = append(flags.extraSharedLibs, "libstdc++")
+ flags.IncludeDirs = append(flags.IncludeDirs, "${SrcDir}/bionic/libstdc++/include")
+ flags.ExtraSharedLibs = append(flags.ExtraSharedLibs, "libstdc++")
}
case "none":
if arch.HostOrDevice.Host() {
- flags.cppFlags = append(flags.cppFlags, "-nostdinc++")
- flags.ldFlags = append(flags.ldFlags, "-nodefaultlibs")
- flags.ldLibs = append(flags.ldLibs, "-lc", "-lm")
+ flags.CppFlags = append(flags.CppFlags, "-nostdinc++")
+ flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
+ flags.LdLibs = append(flags.LdLibs, "-lc", "-lm")
}
default:
ctx.ModuleErrorf("stl: %q is not a supported STL", stl)
@@ -576,8 +569,8 @@
}
// Compile a list of source files into objects a specified subdirectory
-func (c *ccBase) customCompileObjs(ctx common.AndroidModuleContext, flags ccFlags,
- deps ccDeps, subdir string, srcFiles []string) []string {
+func (c *ccBase) customCompileObjs(ctx common.AndroidModuleContext, flags CCFlags,
+ deps CCDeps, subdir string, srcFiles []string) []string {
srcFiles = pathtools.PrefixPaths(srcFiles, common.ModuleSrcDir(ctx))
srcFiles = common.ExpandGlobs(ctx, srcFiles)
@@ -586,8 +579,8 @@
}
// Compile files listed in c.properties.Srcs into objects
-func (c *ccBase) compileObjs(ctx common.AndroidModuleContext, flags ccFlags,
- deps ccDeps) []string {
+func (c *ccBase) compileObjs(ctx common.AndroidModuleContext, flags CCFlags,
+ deps CCDeps) []string {
if c.properties.SkipCompileObjs {
return nil
@@ -597,8 +590,8 @@
}
// Compile generated source files from dependencies
-func (c *ccBase) compileGeneratedObjs(ctx common.AndroidModuleContext, flags ccFlags,
- deps ccDeps) []string {
+func (c *ccBase) compileGeneratedObjs(ctx common.AndroidModuleContext, flags CCFlags,
+ deps CCDeps) []string {
var srcs []string
if c.properties.SkipCompileObjs {
@@ -634,7 +627,7 @@
return
}
- if a, ok := m.(ccModuleType); ok {
+ if a, ok := m.(CCModuleType); ok {
if a.Disabled() {
// If a cc_library host+device module depends on a library that exists as both
// cc_library_shared and cc_library_host_shared, it will end up with two
@@ -676,19 +669,19 @@
return modules, outputFiles, exportedIncludeDirs
}
-func (c *ccBase) collectDeps(ctx common.AndroidModuleContext, flags ccFlags) (ccDeps, ccFlags) {
- var deps ccDeps
+func (c *ccBase) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
+ var deps CCDeps
var newIncludeDirs []string
wholeStaticLibNames := c.properties.Whole_static_libs
- _, deps.wholeStaticLibs, newIncludeDirs = c.collectDepsFromList(ctx, wholeStaticLibNames)
+ _, deps.WholeStaticLibs, newIncludeDirs = c.collectDepsFromList(ctx, wholeStaticLibNames)
- deps.includeDirs = append(deps.includeDirs, newIncludeDirs...)
+ deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
staticLibNames := c.properties.Static_libs
- staticLibNames = append(staticLibNames, flags.extraStaticLibs...)
- _, deps.staticLibs, newIncludeDirs = c.collectDepsFromList(ctx, staticLibNames)
- deps.includeDirs = append(deps.includeDirs, newIncludeDirs...)
+ staticLibNames = append(staticLibNames, flags.ExtraStaticLibs...)
+ _, deps.StaticLibs, newIncludeDirs = c.collectDepsFromList(ctx, staticLibNames)
+ deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
return deps, flags
}
@@ -698,7 +691,7 @@
ccBase
}
-func newCCDynamic(dynamic *ccDynamic, module ccModuleType, hod common.HostOrDeviceSupported,
+func newCCDynamic(dynamic *ccDynamic, module CCModuleType, hod common.HostOrDeviceSupported,
multilib common.Multilib, props ...interface{}) (blueprint.Module, []interface{}) {
dynamic.properties.System_shared_libs = []string{defaultSystemSharedLibraries}
@@ -754,32 +747,32 @@
return deps
}
-func (c *ccDynamic) collectDeps(ctx common.AndroidModuleContext, flags ccFlags) (ccDeps, ccFlags) {
+func (c *ccDynamic) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
var newIncludeDirs []string
deps, flags := c.ccBase.collectDeps(ctx, flags)
systemSharedLibs := c.systemSharedLibs()
sharedLibNames := make([]string, 0, len(c.properties.Shared_libs)+len(systemSharedLibs)+
- len(flags.extraSharedLibs))
+ len(flags.ExtraSharedLibs))
sharedLibNames = append(sharedLibNames, c.properties.Shared_libs...)
sharedLibNames = append(sharedLibNames, systemSharedLibs...)
- sharedLibNames = append(sharedLibNames, flags.extraSharedLibs...)
- _, deps.sharedLibs, newIncludeDirs = c.collectDepsFromList(ctx, sharedLibNames)
- deps.includeDirs = append(deps.includeDirs, newIncludeDirs...)
+ sharedLibNames = append(sharedLibNames, flags.ExtraSharedLibs...)
+ _, deps.SharedLibs, newIncludeDirs = c.collectDepsFromList(ctx, sharedLibNames)
+ deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
if ctx.Arch().HostOrDevice.Device() {
var staticLibs []string
staticLibNames := []string{"libcompiler_rt-extras"}
_, staticLibs, newIncludeDirs = c.collectDepsFromList(ctx, staticLibNames)
- deps.staticLibs = append(deps.staticLibs, staticLibs...)
- deps.includeDirs = append(deps.includeDirs, newIncludeDirs...)
+ deps.StaticLibs = append(deps.StaticLibs, staticLibs...)
+ deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
// libgcc and libatomic have to be last on the command line
staticLibNames = []string{"libgcov", "libatomic", "libgcc"}
_, staticLibs, newIncludeDirs = c.collectDepsFromList(ctx, staticLibNames)
- deps.lateStaticLibs = append(deps.lateStaticLibs, staticLibs...)
- deps.includeDirs = append(deps.includeDirs, newIncludeDirs...)
+ deps.LateStaticLibs = append(deps.LateStaticLibs, staticLibs...)
+ deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
}
ctx.VisitDirectDeps(func(m blueprint.Module) {
@@ -787,11 +780,11 @@
otherName := ctx.OtherModuleName(m)
if strings.HasPrefix(otherName, "crtbegin") {
if !c.properties.Nocrt {
- deps.crtBegin = obj.outputFile()
+ deps.CrtBegin = obj.outputFile()
}
} else if strings.HasPrefix(otherName, "crtend") {
if !c.properties.Nocrt {
- deps.crtEnd = obj.outputFile()
+ deps.CrtEnd = obj.outputFile()
}
} else {
ctx.ModuleErrorf("object module type only support for crtbegin and crtend, found %q",
@@ -811,16 +804,16 @@
// Combined static+shared libraries
//
-type ccLibrary struct {
+type CCLibrary struct {
ccDynamic
- primary *ccLibrary
+ primary *CCLibrary
primaryObjFiles []string
objFiles []string
exportIncludeDirs []string
out string
- libraryProperties struct {
+ LibraryProperties struct {
BuildStatic bool `blueprint:"mutated"`
BuildShared bool `blueprint:"mutated"`
IsShared bool `blueprint:"mutated"`
@@ -837,22 +830,43 @@
}
}
-func newCCLibrary(library *ccLibrary, hod common.HostOrDeviceSupported) (blueprint.Module, []interface{}) {
- return newCCDynamic(&library.ccDynamic, library, hod, common.MultilibBoth,
- &library.libraryProperties)
+type ccLibraryInterface interface {
+ ccLibrary() *CCLibrary
+ static() bool
+ shared() bool
+ allObjFiles() []string
}
-func NewCCLibrary() (blueprint.Module, []interface{}) {
- module := &ccLibrary{}
-
- module.libraryProperties.BuildShared = true
- module.libraryProperties.BuildStatic = true
-
- return newCCLibrary(module, common.HostAndDeviceSupported)
+func (c *CCLibrary) ccLibrary() *CCLibrary {
+ return c
}
-func (c *ccLibrary) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
- if c.libraryProperties.IsShared {
+func (c *CCLibrary) static() bool {
+ return c.LibraryProperties.IsStatic
+}
+
+func (c *CCLibrary) shared() bool {
+ return c.LibraryProperties.IsShared
+}
+
+func NewCCLibrary(library *CCLibrary, module CCModuleType,
+ hod common.HostOrDeviceSupported) (blueprint.Module, []interface{}) {
+
+ return newCCDynamic(&library.ccDynamic, module, hod, common.MultilibBoth,
+ &library.LibraryProperties)
+}
+
+func CCLibraryFactory() (blueprint.Module, []interface{}) {
+ module := &CCLibrary{}
+
+ module.LibraryProperties.BuildShared = true
+ module.LibraryProperties.BuildStatic = true
+
+ return NewCCLibrary(module, module, common.HostAndDeviceSupported)
+}
+
+func (c *CCLibrary) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
+ if c.LibraryProperties.IsShared {
deps := c.ccDynamic.AndroidDynamicDependencies(ctx)
if c.HostOrDevice().Device() {
deps = append(deps, "crtbegin_so", "crtend_so")
@@ -863,15 +877,15 @@
}
}
-func (c *ccLibrary) collectDeps(ctx common.AndroidModuleContext, flags ccFlags) (ccDeps, ccFlags) {
- if c.libraryProperties.IsStatic {
+func (c *CCLibrary) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
+ if c.LibraryProperties.IsStatic {
deps, flags := c.ccBase.collectDeps(ctx, flags)
wholeStaticLibNames := c.properties.Whole_static_libs
wholeStaticLibs, _, _ := c.collectDepsFromList(ctx, wholeStaticLibNames)
for _, m := range wholeStaticLibs {
- if staticLib, ok := m.(*ccLibrary); ok && staticLib.libraryProperties.IsStatic {
- deps.objFiles = append(deps.objFiles, staticLib.allObjFiles()...)
+ if staticLib, ok := m.(ccLibraryInterface); ok && staticLib.static() {
+ deps.ObjFiles = append(deps.ObjFiles, staticLib.allObjFiles()...)
} else {
ctx.ModuleErrorf("module %q not a static library", ctx.OtherModuleName(m))
}
@@ -880,34 +894,32 @@
// Collect exported includes from shared lib dependencies
sharedLibNames := c.properties.Shared_libs
_, _, newIncludeDirs := c.collectDepsFromList(ctx, sharedLibNames)
- deps.includeDirs = append(deps.includeDirs, newIncludeDirs...)
+ deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
return deps, flags
- } else if c.libraryProperties.IsShared {
+ } else if c.LibraryProperties.IsShared {
return c.ccDynamic.collectDeps(ctx, flags)
} else {
panic("Not shared or static")
}
}
-func (c *ccLibrary) outputFile() string {
+func (c *CCLibrary) outputFile() string {
return c.out
}
-func (c *ccLibrary) allObjFiles() []string {
+func (c *CCLibrary) allObjFiles() []string {
return c.objFiles
}
-func (c *ccLibrary) exportedIncludeDirs() []string {
+func (c *CCLibrary) exportedIncludeDirs() []string {
return c.exportIncludeDirs
}
-func (c *ccLibrary) moduleTypeCflags(ctx common.AndroidModuleContext, toolchain toolchain) []string {
- return []string{"-fPIC"}
-}
+func (c *CCLibrary) ModuleTypeFlags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
+ flags.CFlags = append(flags.CFlags, "-fPIC")
-func (c *ccLibrary) moduleTypeLdflags(ctx common.AndroidModuleContext, toolchain toolchain) []string {
- if c.libraryProperties.IsShared {
+ if c.LibraryProperties.IsShared {
libName := ctx.ModuleName()
// GCC for Android assumes that -shared means -Bsymbolic, use -Wl,-shared instead
sharedFlag := "-Wl,-shared"
@@ -915,31 +927,26 @@
sharedFlag = "-shared"
}
if ctx.Arch().HostOrDevice.Device() {
- return []string{
- "-nostdlib",
- "-Wl,--gc-sections",
- sharedFlag,
- "-Wl,-soname," + libName + sharedLibraryExtension,
- }
- } else {
- return []string{
- "-Wl,--gc-sections",
- sharedFlag,
- "-Wl,-soname," + libName + sharedLibraryExtension,
- }
+ flags.LdFlags = append(flags.LdFlags, "-nostdlib")
}
- } else {
- return nil
+
+ flags.LdFlags = append(flags.LdFlags,
+ "-Wl,--gc-sections",
+ sharedFlag,
+ "-Wl,-soname,"+libName+sharedLibraryExtension,
+ )
}
+
+ return flags
}
-func (c *ccLibrary) compileStaticLibrary(ctx common.AndroidModuleContext,
- flags ccFlags, deps ccDeps, objFiles []string) {
+func (c *CCLibrary) compileStaticLibrary(ctx common.AndroidModuleContext,
+ flags CCFlags, deps CCDeps, objFiles []string) {
staticFlags := flags
- staticFlags.cFlags = append(staticFlags.cFlags, c.libraryProperties.Static.Cflags...)
+ staticFlags.CFlags = append(staticFlags.CFlags, c.LibraryProperties.Static.Cflags...)
objFilesStatic := c.customCompileObjs(ctx, staticFlags, deps, common.DeviceStaticLibrary,
- c.libraryProperties.Static.Srcs)
+ c.LibraryProperties.Static.Srcs)
objFiles = append(objFiles, objFilesStatic...)
@@ -950,7 +957,7 @@
includeDirs = append(includeDirs, newIncludeDirs...)
for _, m := range wholeStaticLibs {
- if staticLib, ok := m.(*ccLibrary); ok && staticLib.libraryProperties.IsStatic {
+ if staticLib, ok := m.(ccLibraryInterface); ok && staticLib.static() {
objFiles = append(objFiles, staticLib.allObjFiles()...)
} else {
ctx.ModuleErrorf("module %q not a static library", ctx.OtherModuleName(m))
@@ -982,20 +989,20 @@
ctx.CheckbuildFile(outputFile)
}
-func (c *ccLibrary) compileSharedLibrary(ctx common.AndroidModuleContext,
- flags ccFlags, deps ccDeps, objFiles []string) {
+func (c *CCLibrary) compileSharedLibrary(ctx common.AndroidModuleContext,
+ flags CCFlags, deps CCDeps, objFiles []string) {
sharedFlags := flags
- sharedFlags.cFlags = append(sharedFlags.cFlags, c.libraryProperties.Shared.Cflags...)
+ sharedFlags.CFlags = append(sharedFlags.CFlags, c.LibraryProperties.Shared.Cflags...)
objFilesShared := c.customCompileObjs(ctx, sharedFlags, deps, common.DeviceSharedLibrary,
- c.libraryProperties.Shared.Srcs)
+ c.LibraryProperties.Shared.Srcs)
objFiles = append(objFiles, objFilesShared...)
outputFile := filepath.Join(common.ModuleOutDir(ctx), ctx.ModuleName()+sharedLibraryExtension)
- TransformObjToDynamicBinary(ctx, objFiles, deps.sharedLibs, deps.staticLibs,
- deps.lateStaticLibs, deps.wholeStaticLibs, deps.crtBegin, deps.crtEnd,
+ TransformObjToDynamicBinary(ctx, objFiles, deps.SharedLibs, deps.StaticLibs,
+ deps.LateStaticLibs, deps.WholeStaticLibs, deps.CrtBegin, deps.CrtEnd,
ccFlagsToBuilderFlags(flags), outputFile)
c.out = outputFile
@@ -1003,8 +1010,8 @@
common.ModuleSrcDir(ctx))
}
-func (c *ccLibrary) compileModule(ctx common.AndroidModuleContext,
- flags ccFlags, deps ccDeps, objFiles []string) {
+func (c *CCLibrary) compileModule(ctx common.AndroidModuleContext,
+ flags CCFlags, deps CCDeps, objFiles []string) {
// Reuse the object files from the matching static library if it exists
if c.primary == c {
@@ -1013,28 +1020,28 @@
objFiles = append([]string(nil), c.primary.primaryObjFiles...)
}
- if c.libraryProperties.IsStatic {
+ if c.LibraryProperties.IsStatic {
c.compileStaticLibrary(ctx, flags, deps, objFiles)
} else {
c.compileSharedLibrary(ctx, flags, deps, objFiles)
}
}
-func (c *ccLibrary) installStaticLibrary(ctx common.AndroidModuleContext, flags ccFlags) {
+func (c *CCLibrary) installStaticLibrary(ctx common.AndroidModuleContext, flags CCFlags) {
// Static libraries do not get installed.
}
-func (c *ccLibrary) installSharedLibrary(ctx common.AndroidModuleContext, flags ccFlags) {
+func (c *CCLibrary) installSharedLibrary(ctx common.AndroidModuleContext, flags CCFlags) {
installDir := "lib"
- if flags.toolchain.Is64Bit() {
+ if flags.Toolchain.Is64Bit() {
installDir = "lib64"
}
ctx.InstallFile(installDir, c.out)
}
-func (c *ccLibrary) installModule(ctx common.AndroidModuleContext, flags ccFlags) {
- if c.libraryProperties.IsStatic {
+func (c *CCLibrary) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
+ if c.LibraryProperties.IsStatic {
c.installStaticLibrary(ctx, flags)
} else {
c.installSharedLibrary(ctx, flags)
@@ -1050,7 +1057,7 @@
out string
}
-func NewCCObject() (blueprint.Module, []interface{}) {
+func CCObjectFactory() (blueprint.Module, []interface{}) {
module := &ccObject{}
return newCCBase(&module.ccBase, module, common.DeviceSupported, common.MultilibBoth)
@@ -1061,11 +1068,11 @@
return nil
}
-func (c *ccObject) collectDeps(ctx common.AndroidModuleContext, flags ccFlags) (ccDeps, ccFlags) {
+func (c *ccObject) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
deps, flags := c.ccBase.collectDeps(ctx, flags)
ctx.VisitDirectDeps(func(m blueprint.Module) {
if obj, ok := m.(*ccObject); ok {
- deps.objFiles = append(deps.objFiles, obj.outputFile())
+ deps.ObjFiles = append(deps.ObjFiles, obj.outputFile())
} else {
ctx.ModuleErrorf("Unknown module type for dependency %q", ctx.OtherModuleName(m))
}
@@ -1075,9 +1082,9 @@
}
func (c *ccObject) compileModule(ctx common.AndroidModuleContext,
- flags ccFlags, deps ccDeps, objFiles []string) {
+ flags CCFlags, deps CCDeps, objFiles []string) {
- objFiles = append(objFiles, deps.objFiles...)
+ objFiles = append(objFiles, deps.ObjFiles...)
var outputFile string
if len(objFiles) == 1 {
@@ -1092,7 +1099,7 @@
ctx.CheckbuildFile(outputFile)
}
-func (c *ccObject) installModule(ctx common.AndroidModuleContext, flags ccFlags) {
+func (c *ccObject) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
// Object files do not get installed.
}
@@ -1104,34 +1111,32 @@
// Executables
//
-type ccBinary struct {
+type CCBinary struct {
ccDynamic
out string
- binaryProperties binaryProperties
+ BinaryProperties struct {
+ // static_executable: compile executable with -static
+ Static_executable bool
+
+ // stem: set the name of the output
+ Stem string `android:"arch_variant"`
+
+ // prefix_symbols: if set, add an extra objcopy --prefix-symbols= step
+ Prefix_symbols string
+ }
}
-type binaryProperties struct {
- // static_executable: compile executable with -static
- Static_executable bool
-
- // stem: set the name of the output
- Stem string `android:"arch_variant"`
-
- // prefix_symbols: if set, add an extra objcopy --prefix-symbols= step
- Prefix_symbols string
-}
-
-func (c *ccBinary) getStem(ctx common.AndroidModuleContext) string {
- if c.binaryProperties.Stem != "" {
- return c.binaryProperties.Stem
+func (c *CCBinary) getStem(ctx common.AndroidModuleContext) string {
+ if c.BinaryProperties.Stem != "" {
+ return c.BinaryProperties.Stem
}
return ctx.ModuleName()
}
-func (c *ccBinary) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
+func (c *CCBinary) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
deps := c.ccDynamic.AndroidDynamicDependencies(ctx)
if c.HostOrDevice().Device() {
- if c.binaryProperties.Static_executable {
+ if c.BinaryProperties.Static_executable {
deps = append(deps, "crtbegin_static", "crtend_android")
} else {
deps = append(deps, "crtbegin_dynamic", "crtend_android")
@@ -1140,40 +1145,44 @@
return deps
}
-func NewCCBinary() (blueprint.Module, []interface{}) {
- module := &ccBinary{}
+func NewCCBinary(binary *CCBinary, module CCModuleType,
+ hod common.HostOrDeviceSupported) (blueprint.Module, []interface{}) {
- return newCCDynamic(&module.ccDynamic, module, common.HostAndDeviceSupported, common.MultilibFirst,
- &module.binaryProperties)
+ return newCCDynamic(&binary.ccDynamic, module, hod, common.MultilibFirst,
+ &binary.BinaryProperties)
}
-func (c *ccBinary) moduleTypeCflags(ctx common.AndroidModuleContext, toolchain toolchain) []string {
- return []string{"-fpie"}
+func CCBinaryFactory() (blueprint.Module, []interface{}) {
+ module := &CCBinary{}
+
+ return NewCCBinary(module, module, common.HostAndDeviceSupported)
}
-func (c *ccBinary) moduleTypeLdflags(ctx common.AndroidModuleContext, toolchain toolchain) []string {
+func (c *CCBinary) ModuleTypeFlags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
+ flags.CFlags = append(flags.CFlags, "-fpie")
+
if ctx.Arch().HostOrDevice.Device() {
linker := "/system/bin/linker"
- if toolchain.Is64Bit() {
+ if flags.Toolchain.Is64Bit() {
linker = "/system/bin/linker64"
}
- return []string{
+ flags.LdFlags = append(flags.LdFlags,
"-nostdlib",
"-Bdynamic",
fmt.Sprintf("-Wl,-dynamic-linker,%s", linker),
"-Wl,--gc-sections",
"-Wl,-z,nocopyreloc",
- }
+ )
}
- return nil
+ return flags
}
-func (c *ccBinary) compileModule(ctx common.AndroidModuleContext,
- flags ccFlags, deps ccDeps, objFiles []string) {
+func (c *CCBinary) compileModule(ctx common.AndroidModuleContext,
+ flags CCFlags, deps CCDeps, objFiles []string) {
- if !c.binaryProperties.Static_executable && inList("libc", c.properties.Static_libs) {
+ if !c.BinaryProperties.Static_executable && inList("libc", c.properties.Static_libs) {
ctx.ModuleErrorf("statically linking libc to dynamic executable, please remove libc\n" +
"from static libs or set static_executable: true")
}
@@ -1181,17 +1190,17 @@
outputFile := filepath.Join(common.ModuleOutDir(ctx), c.getStem(ctx))
c.out = outputFile
- TransformObjToDynamicBinary(ctx, objFiles, deps.sharedLibs, deps.staticLibs,
- deps.lateStaticLibs, deps.wholeStaticLibs, deps.crtBegin, deps.crtEnd,
+ TransformObjToDynamicBinary(ctx, objFiles, deps.SharedLibs, deps.StaticLibs,
+ deps.LateStaticLibs, deps.WholeStaticLibs, deps.CrtBegin, deps.CrtEnd,
ccFlagsToBuilderFlags(flags), outputFile)
}
-func (c *ccBinary) installModule(ctx common.AndroidModuleContext, flags ccFlags) {
+func (c *CCBinary) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
ctx.InstallFile("bin", c.out)
}
type ccTest struct {
- ccBinary
+ CCBinary
testProperties struct {
// test_per_src: Create a separate test for each source file. Useful when there is
@@ -1204,43 +1213,43 @@
gtestLibs = []string{"libgtest", "libgtest_main"}
)
-func (c *ccTest) collectDeps(ctx common.AndroidModuleContext, flags ccFlags) (ccDeps, ccFlags) {
- deps, flags := c.ccBinary.collectDeps(ctx, flags)
+func (c *ccTest) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
+ deps, flags := c.CCBinary.collectDeps(ctx, flags)
- flags.cFlags = append(flags.cFlags, "-DGTEST_HAS_STD_STRING")
+ flags.CFlags = append(flags.CFlags, "-DGTEST_HAS_STD_STRING")
if c.HostOrDevice().Host() {
- flags.cFlags = append(flags.cFlags, "-O0", "-g")
- flags.ldLibs = append(flags.ldLibs, "-lpthread")
+ flags.CFlags = append(flags.CFlags, "-O0", "-g")
+ flags.LdLibs = append(flags.LdLibs, "-lpthread")
}
// TODO(danalbert): Make gtest export its dependencies.
- flags.includeDirs = append(flags.includeDirs,
+ flags.IncludeDirs = append(flags.IncludeDirs,
filepath.Join(ctx.Config().(Config).SrcDir(), "external/gtest/include"))
_, staticLibs, _ := c.collectDepsFromList(ctx, gtestLibs)
- deps.staticLibs = append(deps.staticLibs, staticLibs...)
+ deps.StaticLibs = append(deps.StaticLibs, staticLibs...)
return deps, flags
}
func (c *ccTest) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
ctx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, gtestLibs...)
- deps := c.ccBinary.AndroidDynamicDependencies(ctx)
+ deps := c.CCBinary.AndroidDynamicDependencies(ctx)
return append(deps, gtestLibs...)
}
-func (c *ccTest) installModule(ctx common.AndroidModuleContext, flags ccFlags) {
+func (c *ccTest) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
if c.HostOrDevice().Device() {
ctx.InstallFile("../data/nativetest/"+ctx.ModuleName(), c.out)
} else {
- c.ccBinary.installModule(ctx, flags)
+ c.CCBinary.installModule(ctx, flags)
}
}
-func NewCCTest() (blueprint.Module, []interface{}) {
+func CCTestFactory() (blueprint.Module, []interface{}) {
module := &ccTest{}
return newCCDynamic(&module.ccDynamic, module, common.HostAndDeviceSupported,
- common.MultilibFirst, &module.binaryProperties, &module.testProperties)
+ common.MultilibFirst, &module.BinaryProperties, &module.testProperties)
}
func TestPerSrcMutator(mctx blueprint.EarlyMutatorContext) {
@@ -1253,7 +1262,7 @@
tests := mctx.CreateLocalVariations(testNames...)
for i, src := range test.properties.Srcs {
tests[i].(*ccTest).properties.Srcs = []string{src}
- tests[i].(*ccTest).binaryProperties.Stem = testNames[i]
+ tests[i].(*ccTest).BinaryProperties.Stem = testNames[i]
}
}
}
@@ -1263,54 +1272,54 @@
// Static library
//
-func NewCCLibraryStatic() (blueprint.Module, []interface{}) {
- module := &ccLibrary{}
- module.libraryProperties.BuildStatic = true
+func CCLibraryStaticFactory() (blueprint.Module, []interface{}) {
+ module := &CCLibrary{}
+ module.LibraryProperties.BuildStatic = true
- return newCCLibrary(module, common.HostAndDeviceSupported)
+ return NewCCLibrary(module, module, common.HostAndDeviceSupported)
}
//
// Shared libraries
//
-func NewCCLibraryShared() (blueprint.Module, []interface{}) {
- module := &ccLibrary{}
- module.libraryProperties.BuildShared = true
+func CCLibrarySharedFactory() (blueprint.Module, []interface{}) {
+ module := &CCLibrary{}
+ module.LibraryProperties.BuildShared = true
- return newCCLibrary(module, common.HostAndDeviceSupported)
+ return NewCCLibrary(module, module, common.HostAndDeviceSupported)
}
//
// Host static library
//
-func NewCCLibraryHostStatic() (blueprint.Module, []interface{}) {
- module := &ccLibrary{}
- module.libraryProperties.BuildStatic = true
+func CCLibraryHostStaticFactory() (blueprint.Module, []interface{}) {
+ module := &CCLibrary{}
+ module.LibraryProperties.BuildStatic = true
- return newCCLibrary(module, common.HostSupported)
+ return NewCCLibrary(module, module, common.HostSupported)
}
//
// Host Shared libraries
//
-func NewCCLibraryHostShared() (blueprint.Module, []interface{}) {
- module := &ccLibrary{}
- module.libraryProperties.BuildShared = true
+func CCLibraryHostSharedFactory() (blueprint.Module, []interface{}) {
+ module := &CCLibrary{}
+ module.LibraryProperties.BuildShared = true
- return newCCLibrary(module, common.HostSupported)
+ return NewCCLibrary(module, module, common.HostSupported)
}
//
// Host Binaries
//
-func NewCCBinaryHost() (blueprint.Module, []interface{}) {
- module := &ccBinary{}
+func CCBinaryHostFactory() (blueprint.Module, []interface{}) {
+ module := &CCBinary{}
- return newCCDynamic(&module.ccDynamic, module, common.HostSupported, common.MultilibFirst)
+ return NewCCBinary(module, module, common.HostSupported)
}
//
@@ -1318,7 +1327,7 @@
//
type toolchainLibrary struct {
- ccLibrary
+ CCLibrary
}
func (*toolchainLibrary) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
@@ -1326,19 +1335,21 @@
return nil
}
-func (*toolchainLibrary) collectDeps(ctx common.AndroidModuleContext, flags ccFlags) (ccDeps, ccFlags) {
+func (*toolchainLibrary) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
// toolchain libraries can't have any dependencies
- return ccDeps{}, flags
+ return CCDeps{}, flags
}
-func NewToolchainLibrary() (blueprint.Module, []interface{}) {
+func ToolchainLibraryFactory() (blueprint.Module, []interface{}) {
module := &toolchainLibrary{}
+ module.LibraryProperties.BuildStatic = true
+
return newCCBase(&module.ccBase, module, common.DeviceSupported, common.MultilibBoth)
}
func (c *toolchainLibrary) compileModule(ctx common.AndroidModuleContext,
- flags ccFlags, deps ccDeps, objFiles []string) {
+ flags CCFlags, deps CCDeps, objFiles []string) {
libName := ctx.ModuleName() + staticLibraryExtension
outputFile := filepath.Join(common.ModuleOutDir(ctx), libName)
@@ -1350,34 +1361,32 @@
ctx.CheckbuildFile(outputFile)
}
-func (c *toolchainLibrary) installModule(ctx common.AndroidModuleContext, flags ccFlags) {
+func (c *toolchainLibrary) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
// Toolchain libraries do not get installed.
}
func LinkageMutator(mctx blueprint.EarlyMutatorContext) {
- if c, ok := mctx.Module().(*ccLibrary); ok {
+ if c, ok := mctx.Module().(ccLibraryInterface); ok {
var modules []blueprint.Module
- if c.libraryProperties.BuildStatic && c.libraryProperties.BuildShared {
+ if c.ccLibrary().LibraryProperties.BuildStatic && c.ccLibrary().LibraryProperties.BuildShared {
modules = mctx.CreateLocalVariations("static", "shared")
- modules[0].(*ccLibrary).libraryProperties.IsStatic = true
- modules[1].(*ccLibrary).libraryProperties.IsShared = true
- } else if c.libraryProperties.BuildStatic {
+ modules[0].(ccLibraryInterface).ccLibrary().LibraryProperties.IsStatic = true
+ modules[1].(ccLibraryInterface).ccLibrary().LibraryProperties.IsShared = true
+ } else if c.ccLibrary().LibraryProperties.BuildStatic {
modules = mctx.CreateLocalVariations("static")
- modules[0].(*ccLibrary).libraryProperties.IsStatic = true
- } else if c.libraryProperties.BuildShared {
+ modules[0].(ccLibraryInterface).ccLibrary().LibraryProperties.IsStatic = true
+ } else if c.ccLibrary().LibraryProperties.BuildShared {
modules = mctx.CreateLocalVariations("shared")
- modules[0].(*ccLibrary).libraryProperties.IsShared = true
+ modules[0].(ccLibraryInterface).ccLibrary().LibraryProperties.IsShared = true
} else {
- panic("ccLibrary not static or shared")
+ panic(fmt.Errorf("ccLibrary %q not static or shared", mctx.ModuleName()))
}
- primary := modules[0].(*ccLibrary)
+ primary := modules[0].(ccLibraryInterface).ccLibrary()
for _, m := range modules {
- m.(*ccLibrary).primary = primary
- if m != primary {
- m.(*ccLibrary).properties.SkipCompileObjs = true
+ m.(ccLibraryInterface).ccLibrary().primary = primary
+ if m.(ccLibraryInterface).ccLibrary() != primary {
+ m.(ccLibraryInterface).ccLibrary().properties.SkipCompileObjs = true
}
}
- } else if _, ok := mctx.Module().(*toolchainLibrary); ok {
- mctx.CreateLocalVariations("static")
}
}
diff --git a/cc/toolchain.go b/cc/toolchain.go
index 291821b..e4d23bd 100644
--- a/cc/toolchain.go
+++ b/cc/toolchain.go
@@ -20,7 +20,7 @@
"android/soong/common"
)
-type toolchainFactory func(archVariant string, cpuVariant string) toolchain
+type toolchainFactory func(archVariant string, cpuVariant string) Toolchain
var toolchainFactories = map[common.HostOrDevice]map[common.ArchType]toolchainFactory{
common.Host: make(map[common.ArchType]toolchainFactory),
@@ -33,7 +33,7 @@
toolchainFactories[hod][arch] = factory
}
-type toolchain interface {
+type Toolchain interface {
GccRoot() string
GccTriple() string
Cflags() string
diff --git a/cc/util.go b/cc/util.go
index 8703cfb..e0effeb 100644
--- a/cc/util.go
+++ b/cc/util.go
@@ -79,18 +79,18 @@
return matches[1], nil
}
-func ccFlagsToBuilderFlags(in ccFlags) builderFlags {
+func ccFlagsToBuilderFlags(in CCFlags) builderFlags {
return builderFlags{
- globalFlags: strings.Join(in.globalFlags, " "),
- asFlags: strings.Join(in.asFlags, " "),
- cFlags: strings.Join(in.cFlags, " "),
- conlyFlags: strings.Join(in.conlyFlags, " "),
- cppFlags: strings.Join(in.cppFlags, " "),
- ldFlags: strings.Join(in.ldFlags, " "),
- ldLibs: strings.Join(in.ldLibs, " "),
- incFlags: includeDirsToFlags(in.includeDirs),
- nocrt: in.nocrt,
- toolchain: in.toolchain,
- clang: in.clang,
+ globalFlags: strings.Join(in.GlobalFlags, " "),
+ asFlags: strings.Join(in.AsFlags, " "),
+ cFlags: strings.Join(in.CFlags, " "),
+ conlyFlags: strings.Join(in.ConlyFlags, " "),
+ cppFlags: strings.Join(in.CppFlags, " "),
+ ldFlags: strings.Join(in.LdFlags, " "),
+ ldLibs: strings.Join(in.LdLibs, " "),
+ incFlags: includeDirsToFlags(in.IncludeDirs),
+ nocrt: in.Nocrt,
+ toolchain: in.Toolchain,
+ clang: in.Clang,
}
}
diff --git a/cc/x86_linux_host.go b/cc/x86_linux_host.go
index 1097883..795620b 100644
--- a/cc/x86_linux_host.go
+++ b/cc/x86_linux_host.go
@@ -212,14 +212,14 @@
return "${linuxClangLdflags} ${linuxX8664ClangLdflags}"
}
-var toolchainLinuxX86Singleton toolchain = &toolchainLinuxX86{}
-var toolchainLinuxX8664Singleton toolchain = &toolchainLinuxX8664{}
+var toolchainLinuxX86Singleton Toolchain = &toolchainLinuxX86{}
+var toolchainLinuxX8664Singleton Toolchain = &toolchainLinuxX8664{}
-func linuxX86ToolchainFactory(archVariant string, cpuVariant string) toolchain {
+func linuxX86ToolchainFactory(archVariant string, cpuVariant string) Toolchain {
return toolchainLinuxX86Singleton
}
-func linuxX8664ToolchainFactory(archVariant string, cpuVariant string) toolchain {
+func linuxX8664ToolchainFactory(archVariant string, cpuVariant string) Toolchain {
return toolchainLinuxX8664Singleton
}
diff --git a/cmd/soong_build/main.go b/cmd/soong_build/main.go
index cea0fa6..6b7bcf1 100644
--- a/cmd/soong_build/main.go
+++ b/cmd/soong_build/main.go
@@ -38,20 +38,20 @@
ctx := blueprint.NewContext()
// Module types
- ctx.RegisterModuleType("cc_library_static", cc.NewCCLibraryStatic)
- ctx.RegisterModuleType("cc_library_shared", cc.NewCCLibraryShared)
- ctx.RegisterModuleType("cc_library", cc.NewCCLibrary)
- ctx.RegisterModuleType("cc_object", cc.NewCCObject)
- ctx.RegisterModuleType("cc_binary", cc.NewCCBinary)
- ctx.RegisterModuleType("cc_test", cc.NewCCTest)
+ ctx.RegisterModuleType("cc_library_static", cc.CCLibraryStaticFactory)
+ ctx.RegisterModuleType("cc_library_shared", cc.CCLibrarySharedFactory)
+ ctx.RegisterModuleType("cc_library", cc.CCLibraryFactory)
+ ctx.RegisterModuleType("cc_object", cc.CCObjectFactory)
+ ctx.RegisterModuleType("cc_binary", cc.CCBinaryFactory)
+ ctx.RegisterModuleType("cc_test", cc.CCTestFactory)
- ctx.RegisterModuleType("toolchain_library", cc.NewToolchainLibrary)
+ ctx.RegisterModuleType("toolchain_library", cc.ToolchainLibraryFactory)
- ctx.RegisterModuleType("cc_library_host_static", cc.NewCCLibraryHostStatic)
- ctx.RegisterModuleType("cc_library_host_shared", cc.NewCCLibraryHostShared)
- ctx.RegisterModuleType("cc_binary_host", cc.NewCCBinaryHost)
+ ctx.RegisterModuleType("cc_library_host_static", cc.CCLibraryHostStaticFactory)
+ ctx.RegisterModuleType("cc_library_host_shared", cc.CCLibraryHostSharedFactory)
+ ctx.RegisterModuleType("cc_binary_host", cc.CCBinaryHostFactory)
- ctx.RegisterModuleType("gensrcs", genrule.NewGenSrcs)
+ ctx.RegisterModuleType("gensrcs", genrule.GenSrcsFactory)
// Mutators
ctx.RegisterEarlyMutator("arch", common.ArchMutator)
diff --git a/genrule/genrule.go b/genrule/genrule.go
index 2a90e24..e2b6c7d 100644
--- a/genrule/genrule.go
+++ b/genrule/genrule.go
@@ -53,7 +53,7 @@
Output_extension string
}
-func NewGenSrcs() (blueprint.Module, []interface{}) {
+func GenSrcsFactory() (blueprint.Module, []interface{}) {
module := &genSrcs{}
return common.InitAndroidModule(module, &module.properties)
