Merge "Improve BUILDDIR handling with symlinks"
diff --git a/Android.bp b/Android.bp
index b6f6a63..b4928f8 100644
--- a/Android.bp
+++ b/Android.bp
@@ -124,6 +124,7 @@
"cc/cc.go",
"cc/clang.go",
"cc/gen.go",
+ "cc/stl.go",
"cc/toolchain.go",
"cc/util.go",
diff --git a/cc/androidmk.go b/cc/androidmk.go
index 08cdbdc..aa5c4dc 100644
--- a/cc/androidmk.go
+++ b/cc/androidmk.go
@@ -22,16 +22,50 @@
"android/soong/common"
)
-func (c *CCLibrary) AndroidMk() (ret common.AndroidMkData, err error) {
- if c.static() {
+func (c *Module) AndroidMk() (ret common.AndroidMkData, err error) {
+ ret.OutputFile = c.outputFile
+ ret.Extra = append(ret.Extra, func(w io.Writer, outputFile common.Path) (err error) {
+ if len(c.deps.SharedLibs) > 0 {
+ fmt.Fprintln(w, "LOCAL_SHARED_LIBRARIES := "+strings.Join(c.deps.SharedLibs, " "))
+ }
+ return nil
+ })
+
+ callSubAndroidMk := func(obj interface{}) {
+ if obj != nil {
+ if androidmk, ok := obj.(interface {
+ AndroidMk(*common.AndroidMkData)
+ }); ok {
+ androidmk.AndroidMk(&ret)
+ }
+ }
+ }
+
+ for _, feature := range c.features {
+ callSubAndroidMk(feature)
+ }
+
+ callSubAndroidMk(c.compiler)
+ callSubAndroidMk(c.linker)
+ callSubAndroidMk(c.installer)
+
+ return ret, nil
+}
+
+func (library *baseLinker) AndroidMk(ret *common.AndroidMkData) {
+ if library.static() {
ret.Class = "STATIC_LIBRARIES"
} else {
ret.Class = "SHARED_LIBRARIES"
}
- ret.OutputFile = c.outputFile()
- ret.Extra = func(w io.Writer, outputFile common.Path) error {
- exportedIncludes := []string{}
- for _, flag := range c.exportedFlags() {
+}
+
+func (library *libraryLinker) AndroidMk(ret *common.AndroidMkData) {
+ library.baseLinker.AndroidMk(ret)
+
+ ret.Extra = append(ret.Extra, func(w io.Writer, outputFile common.Path) error {
+ exportedIncludes := library.exportedFlags()
+ for _, flag := range library.exportedFlags() {
if flag != "" {
exportedIncludes = append(exportedIncludes, strings.TrimPrefix(flag, "-I"))
}
@@ -40,49 +74,36 @@
fmt.Fprintln(w, "LOCAL_EXPORT_C_INCLUDE_DIRS :=", strings.Join(exportedIncludes, " "))
}
- fmt.Fprintln(w, "LOCAL_MODULE_SUFFIX :=", outputFile.Ext())
- if len(c.savedDepNames.SharedLibs) > 0 {
- fmt.Fprintln(w, "LOCAL_SHARED_LIBRARIES :=", strings.Join(c.savedDepNames.SharedLibs, " "))
- }
-
- if c.Properties.Relative_install_path != "" {
- fmt.Fprintln(w, "LOCAL_MODULE_RELATIVE_PATH :=", c.Properties.Relative_install_path)
- }
+ fmt.Fprintln(w, "LOCAL_MODULE_SUFFIX := "+outputFile.Ext())
// These are already included in LOCAL_SHARED_LIBRARIES
fmt.Fprintln(w, "LOCAL_CXX_STL := none")
fmt.Fprintln(w, "LOCAL_SYSTEM_SHARED_LIBRARIES :=")
return nil
- }
- return
+ })
}
-func (c *ccObject) AndroidMk() (ret common.AndroidMkData, err error) {
- ret.OutputFile = c.outputFile()
+func (object *objectLinker) AndroidMk(ret *common.AndroidMkData) {
ret.Custom = func(w io.Writer, name, prefix string) error {
- out := c.outputFile().Path()
+ out := ret.OutputFile.Path()
fmt.Fprintln(w, "\n$("+prefix+"OUT_INTERMEDIATE_LIBRARIES)/"+name+objectExtension+":", out.String(), "| $(ACP)")
fmt.Fprintln(w, "\t$(copy-file-to-target)")
return nil
}
- return
}
-func (c *CCBinary) AndroidMk() (ret common.AndroidMkData, err error) {
+func (binary *binaryLinker) AndroidMk(ret *common.AndroidMkData) {
ret.Class = "EXECUTABLES"
- ret.Extra = func(w io.Writer, outputFile common.Path) error {
+ ret.Extra = append(ret.Extra, func(w io.Writer, outputFile common.Path) error {
fmt.Fprintln(w, "LOCAL_CXX_STL := none")
fmt.Fprintln(w, "LOCAL_SYSTEM_SHARED_LIBRARIES :=")
- fmt.Fprintln(w, "LOCAL_SHARED_LIBRARIES :=", strings.Join(c.savedDepNames.SharedLibs, " "))
- if c.Properties.Relative_install_path != "" {
- fmt.Fprintln(w, "LOCAL_MODULE_RELATIVE_PATH :=", c.Properties.Relative_install_path)
- }
-
return nil
- }
- ret.OutputFile = c.outputFile()
- return
+ })
+}
+
+func (test *testLinker) AndroidMk(ret *common.AndroidMkData) {
+ ret.Disabled = true
}
diff --git a/cc/cc.go b/cc/cc.go
index 33fc01e..d20a197 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -32,26 +32,26 @@
)
func init() {
- soong.RegisterModuleType("cc_library_static", CCLibraryStaticFactory)
- soong.RegisterModuleType("cc_library_shared", CCLibrarySharedFactory)
- soong.RegisterModuleType("cc_library", CCLibraryFactory)
- soong.RegisterModuleType("cc_object", CCObjectFactory)
- soong.RegisterModuleType("cc_binary", CCBinaryFactory)
- soong.RegisterModuleType("cc_test", CCTestFactory)
- soong.RegisterModuleType("cc_benchmark", CCBenchmarkFactory)
- soong.RegisterModuleType("cc_defaults", CCDefaultsFactory)
+ soong.RegisterModuleType("cc_library_static", libraryStaticFactory)
+ soong.RegisterModuleType("cc_library_shared", librarySharedFactory)
+ soong.RegisterModuleType("cc_library", libraryFactory)
+ soong.RegisterModuleType("cc_object", objectFactory)
+ soong.RegisterModuleType("cc_binary", binaryFactory)
+ soong.RegisterModuleType("cc_test", testFactory)
+ soong.RegisterModuleType("cc_benchmark", benchmarkFactory)
+ soong.RegisterModuleType("cc_defaults", defaultsFactory)
- soong.RegisterModuleType("toolchain_library", ToolchainLibraryFactory)
- soong.RegisterModuleType("ndk_prebuilt_library", NdkPrebuiltLibraryFactory)
- soong.RegisterModuleType("ndk_prebuilt_object", NdkPrebuiltObjectFactory)
- soong.RegisterModuleType("ndk_prebuilt_static_stl", NdkPrebuiltStaticStlFactory)
- soong.RegisterModuleType("ndk_prebuilt_shared_stl", NdkPrebuiltSharedStlFactory)
+ soong.RegisterModuleType("toolchain_library", toolchainLibraryFactory)
+ soong.RegisterModuleType("ndk_prebuilt_library", ndkPrebuiltLibraryFactory)
+ soong.RegisterModuleType("ndk_prebuilt_object", ndkPrebuiltObjectFactory)
+ soong.RegisterModuleType("ndk_prebuilt_static_stl", ndkPrebuiltStaticStlFactory)
+ soong.RegisterModuleType("ndk_prebuilt_shared_stl", ndkPrebuiltSharedStlFactory)
- soong.RegisterModuleType("cc_library_host_static", CCLibraryHostStaticFactory)
- soong.RegisterModuleType("cc_library_host_shared", CCLibraryHostSharedFactory)
- soong.RegisterModuleType("cc_binary_host", CCBinaryHostFactory)
- soong.RegisterModuleType("cc_test_host", CCTestHostFactory)
- soong.RegisterModuleType("cc_benchmark_host", CCBenchmarkHostFactory)
+ soong.RegisterModuleType("cc_library_host_static", libraryHostStaticFactory)
+ soong.RegisterModuleType("cc_library_host_shared", libraryHostSharedFactory)
+ soong.RegisterModuleType("cc_binary_host", binaryHostFactory)
+ soong.RegisterModuleType("cc_test_host", testHostFactory)
+ soong.RegisterModuleType("cc_benchmark_host", benchmarkHostFactory)
// LinkageMutator must be registered after common.ArchMutator, but that is guaranteed by
// the Go initialization order because this package depends on common, so common's init
@@ -169,37 +169,9 @@
pctx.StaticVariable("clangPath", "${clangBase}/${HostPrebuiltTag}/${clangVersion}/bin")
}
-type CCModuleContext common.AndroidBaseContext
-
-// Building C/C++ code is handled by objects that satisfy this interface via composition
-type CCModuleType interface {
- common.AndroidModule
-
- // Modify property values after parsing Blueprints file but before starting dependency
- // resolution or build rule generation
- ModifyProperties(CCModuleContext)
-
- // Modify the ccFlags
- flags(common.AndroidModuleContext, CCFlags) CCFlags
-
- // Return list of dependency names for use in depsMutator
- depNames(common.AndroidBaseContext, CCDeps) CCDeps
-
- // Add dynamic dependencies
- depsMutator(common.AndroidBottomUpMutatorContext)
-
- // Compile objects into final module
- compileModule(common.AndroidModuleContext, CCFlags, CCPathDeps, common.Paths)
-
- // Install the built module.
- installModule(common.AndroidModuleContext, CCFlags)
-
- // Return the output file (.o, .a or .so) for use by other modules
- outputFile() common.OptionalPath
-}
-
-type CCDeps struct {
- StaticLibs, SharedLibs, LateStaticLibs, WholeStaticLibs []string
+type Deps struct {
+ SharedLibs, LateSharedLibs []string
+ StaticLibs, LateStaticLibs, WholeStaticLibs []string
ObjFiles common.Paths
@@ -208,8 +180,9 @@
CrtBegin, CrtEnd string
}
-type CCPathDeps struct {
- StaticLibs, SharedLibs, LateStaticLibs, WholeStaticLibs common.Paths
+type PathDeps struct {
+ SharedLibs, LateSharedLibs common.Paths
+ StaticLibs, LateStaticLibs, WholeStaticLibs common.Paths
ObjFiles common.Paths
WholeStaticLibObjFiles common.Paths
@@ -219,7 +192,7 @@
CrtBegin, CrtEnd common.OptionalPath
}
-type CCFlags struct {
+type Flags struct {
GlobalFlags []string // Flags that apply to C, C++, and assembly source files
AsFlags []string // Flags that apply to assembly source files
CFlags []string // Flags that apply to C and C++ source files
@@ -231,10 +204,11 @@
Nocrt bool
Toolchain Toolchain
Clang bool
+
+ RequiredInstructionSet string
}
-// Properties used to compile all C or C++ modules
-type CCBaseProperties struct {
+type BaseCompilerProperties struct {
// list of source files used to compile the C/C++ module. May be .c, .cpp, or .S files.
Srcs []string `android:"arch_variant"`
@@ -254,12 +228,17 @@
// list of module-specific flags that will be used for .S compiles
Asflags []string `android:"arch_variant"`
+ // list of module-specific flags that will be used for C and C++ compiles when
+ // compiling with clang
+ Clang_cflags []string `android:"arch_variant"`
+
+ // list of module-specific flags that will be used for .S compiles when
+ // compiling with clang
+ Clang_asflags []string `android:"arch_variant"`
+
// list of module-specific flags that will be used for .y and .yy compiles
Yaccflags []string
- // list of module-specific flags that will be used for all link steps
- Ldflags []string `android:"arch_variant"`
-
// the instruction set architecture to use to compile the C/C++
// module.
Instruction_set string `android:"arch_variant"`
@@ -285,23 +264,17 @@
// If possible, don't use this.
Local_include_files []string `android:"arch_variant"`
- // list of directories relative to the Blueprints file that will
- // be added to the include path using -I for any module that links against this module
- Export_include_dirs []string `android:"arch_variant"`
+ // pass -frtti instead of -fno-rtti
+ Rtti *bool
- // list of module-specific flags that will be used for C and C++ compiles when
- // compiling with clang
- Clang_cflags []string `android:"arch_variant"`
+ Debug, Release struct {
+ // list of module-specific flags that will be used for C and C++ compiles in debug or
+ // release builds
+ Cflags []string `android:"arch_variant"`
+ } `android:"arch_variant"`
+}
- // list of module-specific flags that will be used for .S compiles when
- // compiling with clang
- Clang_asflags []string `android:"arch_variant"`
-
- // list of system libraries that will be dynamically linked to
- // shared library and executable modules. If unset, generally defaults to libc
- // and libm. Set to [] to prevent linking against libc and libm.
- System_shared_libs []string
-
+type BaseLinkerProperties struct {
// list of modules whose object files should be linked into this module
// in their entirety. For static library modules, all of the .o files from the intermediate
// directory of the dependency will be linked into this modules .a file. For a shared library,
@@ -314,54 +287,116 @@
// list of modules that should be dynamically linked into this module.
Shared_libs []string `android:"arch_variant"`
+ // list of module-specific flags that will be used for all link steps
+ Ldflags []string `android:"arch_variant"`
+
+ // don't insert default compiler flags into asflags, cflags,
+ // cppflags, conlyflags, ldflags, or include_dirs
+ No_default_compiler_flags *bool
+
+ // list of system libraries that will be dynamically linked to
+ // shared library and executable modules. If unset, generally defaults to libc
+ // and libm. Set to [] to prevent linking against libc and libm.
+ System_shared_libs []string
+
// allow the module to contain undefined symbols. By default,
// modules cannot contain undefined symbols that are not satisified by their immediate
// dependencies. Set this flag to true to remove --no-undefined from the linker flags.
// This flag should only be necessary for compiling low-level libraries like libc.
Allow_undefined_symbols *bool
- // don't link in crt_begin and crt_end. This flag should only be necessary for
- // compiling crt or libc.
- Nocrt *bool `android:"arch_variant"`
-
// don't link in libgcc.a
No_libgcc *bool
- // don't insert default compiler flags into asflags, cflags,
- // cppflags, conlyflags, ldflags, or include_dirs
- No_default_compiler_flags *bool
-
- // compile module with clang instead of gcc
- Clang *bool `android:"arch_variant"`
-
- // pass -frtti instead of -fno-rtti
- Rtti *bool
-
// -l arguments to pass to linker for host-provided shared libraries
Host_ldlibs []string `android:"arch_variant"`
+}
- // select the STL library to use. Possible values are "libc++", "libc++_static",
- // "stlport", "stlport_static", "ndk", "libstdc++", or "none". Leave blank to select the
- // default
- Stl string
-
- // Set for combined shared/static libraries to prevent compiling object files a second time
- SkipCompileObjs bool `blueprint:"mutated"`
-
- Debug, Release struct {
- // list of module-specific flags that will be used for C and C++ compiles in debug or
- // release builds
- Cflags []string `android:"arch_variant"`
+type LibraryCompilerProperties struct {
+ Static struct {
+ Srcs []string `android:"arch_variant"`
+ Exclude_srcs []string `android:"arch_variant"`
+ Cflags []string `android:"arch_variant"`
} `android:"arch_variant"`
+ Shared struct {
+ Srcs []string `android:"arch_variant"`
+ Exclude_srcs []string `android:"arch_variant"`
+ Cflags []string `android:"arch_variant"`
+ } `android:"arch_variant"`
+}
+
+type LibraryLinkerProperties struct {
+ Static struct {
+ Whole_static_libs []string `android:"arch_variant"`
+ Static_libs []string `android:"arch_variant"`
+ Shared_libs []string `android:"arch_variant"`
+ } `android:"arch_variant"`
+ Shared struct {
+ Whole_static_libs []string `android:"arch_variant"`
+ Static_libs []string `android:"arch_variant"`
+ Shared_libs []string `android:"arch_variant"`
+ } `android:"arch_variant"`
+
+ // local file name to pass to the linker as --version_script
+ Version_script *string `android:"arch_variant"`
+ // local file name to pass to the linker as -unexported_symbols_list
+ Unexported_symbols_list *string `android:"arch_variant"`
+ // local file name to pass to the linker as -force_symbols_not_weak_list
+ Force_symbols_not_weak_list *string `android:"arch_variant"`
+ // local file name to pass to the linker as -force_symbols_weak_list
+ Force_symbols_weak_list *string `android:"arch_variant"`
+
+ // list of directories relative to the Blueprints file that will
+ // be added to the include path using -I for any module that links against this module
+ Export_include_dirs []string `android:"arch_variant"`
+
+ // don't link in crt_begin and crt_end. This flag should only be necessary for
+ // compiling crt or libc.
+ Nocrt *bool `android:"arch_variant"`
+}
+
+type BinaryLinkerProperties struct {
+ // compile executable with -static
+ Static_executable *bool
+
+ // set the name of the output
+ Stem string `android:"arch_variant"`
+
+ // append to the name of the output
+ Suffix string `android:"arch_variant"`
+
+ // if set, add an extra objcopy --prefix-symbols= step
+ Prefix_symbols string
+}
+
+type TestLinkerProperties struct {
+ // if set, build against the gtest library. Defaults to true.
+ Gtest bool
+
+ // Create a separate binary for each source file. Useful when there is
+ // global state that can not be torn down and reset between each test suite.
+ Test_per_src *bool
+}
+
+// Properties used to compile all C or C++ modules
+type BaseProperties struct {
+ // compile module with clang instead of gcc
+ Clang *bool `android:"arch_variant"`
// Minimum sdk version supported when compiling against the ndk
Sdk_version string
+ // don't insert default compiler flags into asflags, cflags,
+ // cppflags, conlyflags, ldflags, or include_dirs
+ No_default_compiler_flags *bool
+}
+
+type InstallerProperties struct {
// install to a subdirectory of the default install path for the module
Relative_install_path string
}
-type CCUnusedProperties struct {
+type UnusedProperties struct {
Native_coverage *bool
Required []string
Sanitize []string `android:"arch_variant"`
@@ -370,163 +405,522 @@
Tags []string
}
-// CCBase contains the properties and members used by all C/C++ module types, and implements
-// the blueprint.Module interface. It expects to be embedded into an outer specialization struct,
-// and uses a ccModuleType interface to that struct to create the build steps.
-type CCBase struct {
+type ModuleContextIntf interface {
+ module() *Module
+ static() bool
+ staticBinary() bool
+ clang() bool
+ toolchain() Toolchain
+ noDefaultCompilerFlags() bool
+ sdk() bool
+ sdkVersion() string
+}
+
+type ModuleContext interface {
+ common.AndroidModuleContext
+ ModuleContextIntf
+}
+
+type BaseModuleContext interface {
+ common.AndroidBaseContext
+ ModuleContextIntf
+}
+
+type Customizer interface {
+ CustomizeProperties(BaseModuleContext)
+ Properties() []interface{}
+}
+
+type feature interface {
+ begin(ctx BaseModuleContext)
+ deps(ctx BaseModuleContext, deps Deps) Deps
+ flags(ctx ModuleContext, flags Flags) Flags
+ props() []interface{}
+}
+
+type compiler interface {
+ feature
+ compile(ctx ModuleContext, flags Flags) common.Paths
+}
+
+type linker interface {
+ feature
+ link(ctx ModuleContext, flags Flags, deps PathDeps, objFiles common.Paths) common.Path
+}
+
+type installer interface {
+ props() []interface{}
+ install(ctx ModuleContext, path common.Path)
+ inData() bool
+}
+
+// Module contains the properties and members used by all C/C++ module types, and implements
+// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
+// to construct the output file. Behavior can be customized with a Customizer interface
+type Module struct {
common.AndroidModuleBase
common.DefaultableModule
- module CCModuleType
- Properties CCBaseProperties
+ Properties BaseProperties
+ unused UnusedProperties
- unused CCUnusedProperties
+ // initialize before calling Init
+ hod common.HostOrDeviceSupported
+ multilib common.Multilib
- installPath string
+ // delegates, initialize before calling Init
+ customizer Customizer
+ features []feature
+ compiler compiler
+ linker linker
+ installer installer
- savedDepNames CCDeps
+ deps Deps
+ outputFile common.OptionalPath
+
+ cachedToolchain Toolchain
}
-func newCCBase(base *CCBase, module CCModuleType, hod common.HostOrDeviceSupported,
- multilib common.Multilib, props ...interface{}) (blueprint.Module, []interface{}) {
+func (c *Module) Init() (blueprint.Module, []interface{}) {
+ props := []interface{}{&c.Properties, &c.unused}
+ if c.customizer != nil {
+ props = append(props, c.customizer.Properties()...)
+ }
+ if c.compiler != nil {
+ props = append(props, c.compiler.props()...)
+ }
+ if c.linker != nil {
+ props = append(props, c.linker.props()...)
+ }
+ if c.installer != nil {
+ props = append(props, c.installer.props()...)
+ }
+ for _, feature := range c.features {
+ props = append(props, feature.props()...)
+ }
- base.module = module
+ _, props = common.InitAndroidArchModule(c, c.hod, c.multilib, props...)
- props = append(props, &base.Properties, &base.unused)
-
- _, props = common.InitAndroidArchModule(module, hod, multilib, props...)
-
- return common.InitDefaultableModule(module, base, props...)
+ return common.InitDefaultableModule(c, c, props...)
}
-func (c *CCBase) GenerateAndroidBuildActions(ctx common.AndroidModuleContext) {
- toolchain := c.findToolchain(ctx)
+type baseModuleContext struct {
+ common.AndroidBaseContext
+ moduleContextImpl
+}
+
+type moduleContext struct {
+ common.AndroidModuleContext
+ moduleContextImpl
+}
+
+type moduleContextImpl struct {
+ mod *Module
+ ctx BaseModuleContext
+}
+
+func (ctx *moduleContextImpl) module() *Module {
+ return ctx.mod
+}
+
+func (ctx *moduleContextImpl) clang() bool {
+ return ctx.mod.clang(ctx.ctx)
+}
+
+func (ctx *moduleContextImpl) toolchain() Toolchain {
+ return ctx.mod.toolchain(ctx.ctx)
+}
+
+func (ctx *moduleContextImpl) static() bool {
+ if ctx.mod.linker == nil {
+ panic(fmt.Errorf("static called on module %q with no linker", ctx.ctx.ModuleName()))
+ }
+ if linker, ok := ctx.mod.linker.(baseLinkerInterface); ok {
+ return linker.static()
+ } else {
+ panic(fmt.Errorf("static called on module %q that doesn't use base linker", ctx.ctx.ModuleName()))
+ }
+}
+
+func (ctx *moduleContextImpl) staticBinary() bool {
+ if ctx.mod.linker == nil {
+ panic(fmt.Errorf("staticBinary called on module %q with no linker", ctx.ctx.ModuleName()))
+ }
+ if linker, ok := ctx.mod.linker.(baseLinkerInterface); ok {
+ return linker.staticBinary()
+ } else {
+ panic(fmt.Errorf("staticBinary called on module %q that doesn't use base linker", ctx.ctx.ModuleName()))
+ }
+}
+
+func (ctx *moduleContextImpl) noDefaultCompilerFlags() bool {
+ return Bool(ctx.mod.Properties.No_default_compiler_flags)
+}
+
+func (ctx *moduleContextImpl) sdk() bool {
+ return ctx.mod.Properties.Sdk_version != ""
+}
+
+func (ctx *moduleContextImpl) sdkVersion() string {
+ return ctx.mod.Properties.Sdk_version
+}
+
+func newBaseModule(hod common.HostOrDeviceSupported, multilib common.Multilib) *Module {
+ return &Module{
+ hod: hod,
+ multilib: multilib,
+ }
+}
+
+func newModule(hod common.HostOrDeviceSupported, multilib common.Multilib) *Module {
+ module := newBaseModule(hod, multilib)
+ module.features = []feature{
+ &stlFeature{},
+ }
+ return module
+}
+
+func (c *Module) GenerateAndroidBuildActions(actx common.AndroidModuleContext) {
+ ctx := &moduleContext{
+ AndroidModuleContext: actx,
+ moduleContextImpl: moduleContextImpl{
+ mod: c,
+ },
+ }
+ ctx.ctx = ctx
+
+ flags := Flags{
+ Toolchain: c.toolchain(ctx),
+ Clang: c.clang(ctx),
+ }
+
+ if c.compiler != nil {
+ flags = c.compiler.flags(ctx, flags)
+ }
+ if c.linker != nil {
+ flags = c.linker.flags(ctx, flags)
+ }
+ for _, feature := range c.features {
+ flags = feature.flags(ctx, flags)
+ }
if ctx.Failed() {
return
}
- flags := c.collectFlags(ctx, toolchain)
- if ctx.Failed() {
- return
- }
+ flags.CFlags, _ = filterList(flags.CFlags, illegalFlags)
+ flags.CppFlags, _ = filterList(flags.CppFlags, illegalFlags)
+ flags.ConlyFlags, _ = filterList(flags.ConlyFlags, illegalFlags)
- deps := c.depsToPaths(ctx, c.savedDepNames)
+ // 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"}
+
+ deps := c.depsToPaths(actx, c.deps)
if ctx.Failed() {
return
}
flags.CFlags = append(flags.CFlags, deps.Cflags...)
- objFiles := c.compileObjs(ctx, flags)
- if ctx.Failed() {
- return
+ var objFiles common.Paths
+ if c.compiler != nil {
+ objFiles = c.compiler.compile(ctx, flags)
+ if ctx.Failed() {
+ return
+ }
}
- generatedObjFiles := c.compileGeneratedObjs(ctx, flags)
- if ctx.Failed() {
- return
- }
+ if c.linker != nil {
+ outputFile := c.linker.link(ctx, flags, deps, objFiles)
+ if ctx.Failed() {
+ return
+ }
+ c.outputFile = common.OptionalPathForPath(outputFile)
- objFiles = append(objFiles, generatedObjFiles...)
-
- c.ccModuleType().compileModule(ctx, flags, deps, objFiles)
- if ctx.Failed() {
- return
- }
-
- c.ccModuleType().installModule(ctx, flags)
- if ctx.Failed() {
- return
+ if c.installer != nil {
+ c.installer.install(ctx, outputFile)
+ if ctx.Failed() {
+ return
+ }
+ }
}
}
-func (c *CCBase) ccModuleType() CCModuleType {
- return c.module
-}
-
-func (c *CCBase) findToolchain(ctx common.AndroidModuleContext) Toolchain {
- arch := ctx.Arch()
- hod := ctx.HostOrDevice()
- ht := ctx.HostType()
- factory := toolchainFactories[hod][ht][arch.ArchType]
- if factory == nil {
- ctx.ModuleErrorf("Toolchain not found for %s %s arch %q", hod.String(), ht.String(), arch.String())
- return nil
+func (c *Module) toolchain(ctx BaseModuleContext) Toolchain {
+ if c.cachedToolchain == nil {
+ arch := ctx.Arch()
+ hod := ctx.HostOrDevice()
+ ht := ctx.HostType()
+ factory := toolchainFactories[hod][ht][arch.ArchType]
+ if factory == nil {
+ ctx.ModuleErrorf("Toolchain not found for %s %s arch %q", hod.String(), ht.String(), arch.String())
+ return nil
+ }
+ c.cachedToolchain = factory(arch)
}
- return factory(arch)
+ return c.cachedToolchain
}
-func (c *CCBase) ModifyProperties(ctx CCModuleContext) {
-}
-
-func (c *CCBase) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
- depNames.WholeStaticLibs = append(depNames.WholeStaticLibs, c.Properties.Whole_static_libs...)
- depNames.StaticLibs = append(depNames.StaticLibs, c.Properties.Static_libs...)
- depNames.SharedLibs = append(depNames.SharedLibs, c.Properties.Shared_libs...)
-
- return depNames
-}
-
-func (c *CCBase) depsMutator(ctx common.AndroidBottomUpMutatorContext) {
- c.savedDepNames = c.module.depNames(ctx, CCDeps{})
- c.savedDepNames.WholeStaticLibs = lastUniqueElements(c.savedDepNames.WholeStaticLibs)
- c.savedDepNames.StaticLibs = lastUniqueElements(c.savedDepNames.StaticLibs)
- c.savedDepNames.SharedLibs = lastUniqueElements(c.savedDepNames.SharedLibs)
-
- staticLibs := c.savedDepNames.WholeStaticLibs
- staticLibs = append(staticLibs, c.savedDepNames.StaticLibs...)
- staticLibs = append(staticLibs, c.savedDepNames.LateStaticLibs...)
- ctx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, staticLibs...)
-
- ctx.AddVariationDependencies([]blueprint.Variation{{"link", "shared"}}, c.savedDepNames.SharedLibs...)
-
- ctx.AddDependency(ctx.Module(), c.savedDepNames.ObjFiles.Strings()...)
- if c.savedDepNames.CrtBegin != "" {
- ctx.AddDependency(ctx.Module(), c.savedDepNames.CrtBegin)
+func (c *Module) begin(ctx BaseModuleContext) {
+ if c.compiler != nil {
+ c.compiler.begin(ctx)
}
- if c.savedDepNames.CrtEnd != "" {
- ctx.AddDependency(ctx.Module(), c.savedDepNames.CrtEnd)
+ if c.linker != nil {
+ c.linker.begin(ctx)
+ }
+ for _, feature := range c.features {
+ feature.begin(ctx)
+ }
+}
+
+func (c *Module) depsMutator(actx common.AndroidBottomUpMutatorContext) {
+ ctx := &baseModuleContext{
+ AndroidBaseContext: actx,
+ moduleContextImpl: moduleContextImpl{
+ mod: c,
+ },
+ }
+ ctx.ctx = ctx
+
+ if c.customizer != nil {
+ c.customizer.CustomizeProperties(ctx)
+ }
+
+ c.begin(ctx)
+
+ c.deps = Deps{}
+
+ if c.compiler != nil {
+ c.deps = c.compiler.deps(ctx, c.deps)
+ }
+ if c.linker != nil {
+ c.deps = c.linker.deps(ctx, c.deps)
+ }
+ for _, feature := range c.features {
+ c.deps = feature.deps(ctx, c.deps)
+ }
+
+ c.deps.WholeStaticLibs = lastUniqueElements(c.deps.WholeStaticLibs)
+ c.deps.StaticLibs = lastUniqueElements(c.deps.StaticLibs)
+ c.deps.LateStaticLibs = lastUniqueElements(c.deps.LateStaticLibs)
+ c.deps.SharedLibs = lastUniqueElements(c.deps.SharedLibs)
+ c.deps.LateSharedLibs = lastUniqueElements(c.deps.LateSharedLibs)
+
+ staticLibs := c.deps.WholeStaticLibs
+ staticLibs = append(staticLibs, c.deps.StaticLibs...)
+ staticLibs = append(staticLibs, c.deps.LateStaticLibs...)
+ actx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, staticLibs...)
+
+ sharedLibs := c.deps.SharedLibs
+ sharedLibs = append(sharedLibs, c.deps.LateSharedLibs...)
+ actx.AddVariationDependencies([]blueprint.Variation{{"link", "shared"}}, sharedLibs...)
+
+ actx.AddDependency(ctx.module(), c.deps.ObjFiles.Strings()...)
+ if c.deps.CrtBegin != "" {
+ actx.AddDependency(ctx.module(), c.deps.CrtBegin)
+ }
+ if c.deps.CrtEnd != "" {
+ actx.AddDependency(ctx.module(), c.deps.CrtEnd)
}
}
func depsMutator(ctx common.AndroidBottomUpMutatorContext) {
- if c, ok := ctx.Module().(CCModuleType); ok {
- c.ModifyProperties(ctx)
+ if c, ok := ctx.Module().(*Module); ok {
c.depsMutator(ctx)
}
}
-// 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) collectFlags(ctx common.AndroidModuleContext, toolchain Toolchain) CCFlags {
- flags := CCFlags{
- CFlags: c.Properties.Cflags,
- CppFlags: c.Properties.Cppflags,
- ConlyFlags: c.Properties.Conlyflags,
- LdFlags: c.Properties.Ldflags,
- AsFlags: c.Properties.Asflags,
- YaccFlags: c.Properties.Yaccflags,
- Nocrt: Bool(c.Properties.Nocrt),
- Toolchain: toolchain,
- Clang: Bool(c.Properties.Clang),
+func (c *Module) clang(ctx BaseModuleContext) bool {
+ clang := Bool(c.Properties.Clang)
+
+ if c.Properties.Clang == nil {
+ if ctx.Host() {
+ clang = true
+ }
+
+ if ctx.Device() && ctx.AConfig().DeviceUsesClang() {
+ clang = true
+ }
}
+ if !c.toolchain(ctx).ClangSupported() {
+ clang = false
+ }
+
+ return clang
+}
+
+func (c *Module) depsToPathsFromList(ctx common.AndroidModuleContext,
+ names []string) (modules []common.AndroidModule,
+ outputFiles common.Paths, exportedFlags []string) {
+
+ for _, n := range names {
+ found := false
+ ctx.VisitDirectDeps(func(m blueprint.Module) {
+ otherName := ctx.OtherModuleName(m)
+ if otherName != n {
+ return
+ }
+
+ if a, ok := m.(*Module); ok {
+ if !a.Enabled() {
+ ctx.ModuleErrorf("depends on disabled module %q", otherName)
+ return
+ }
+ if a.HostOrDevice() != ctx.HostOrDevice() {
+ ctx.ModuleErrorf("host/device mismatch between %q and %q", ctx.ModuleName(),
+ otherName)
+ return
+ }
+
+ if outputFile := a.outputFile; outputFile.Valid() {
+ if found {
+ ctx.ModuleErrorf("multiple modules satisified dependency on %q", otherName)
+ return
+ }
+ outputFiles = append(outputFiles, outputFile.Path())
+ modules = append(modules, a)
+ if i, ok := a.linker.(exportedFlagsProducer); ok {
+ exportedFlags = append(exportedFlags, i.exportedFlags()...)
+ }
+ found = true
+ } else {
+ ctx.ModuleErrorf("module %q missing output file", otherName)
+ return
+ }
+ } else {
+ ctx.ModuleErrorf("module %q not an android module", otherName)
+ return
+ }
+ })
+ if !found && !inList(n, ctx.GetMissingDependencies()) {
+ ctx.ModuleErrorf("unsatisified dependency on %q", n)
+ }
+ }
+
+ return modules, outputFiles, exportedFlags
+}
+
+// Convert dependency names to paths. Takes a Deps containing names and returns a PathDeps
+// containing paths
+func (c *Module) depsToPaths(ctx common.AndroidModuleContext, deps Deps) PathDeps {
+ var depPaths PathDeps
+ var newCflags []string
+
+ var wholeStaticLibModules []common.AndroidModule
+
+ wholeStaticLibModules, depPaths.WholeStaticLibs, newCflags =
+ c.depsToPathsFromList(ctx, deps.WholeStaticLibs)
+ depPaths.Cflags = append(depPaths.Cflags, newCflags...)
+ depPaths.ReexportedCflags = append(depPaths.ReexportedCflags, newCflags...)
+
+ for _, am := range wholeStaticLibModules {
+ if m, ok := am.(*Module); ok {
+ if staticLib, ok := m.linker.(*libraryLinker); ok && staticLib.static() {
+ if missingDeps := staticLib.getWholeStaticMissingDeps(); missingDeps != nil {
+ postfix := " (required by " + ctx.OtherModuleName(m) + ")"
+ for i := range missingDeps {
+ missingDeps[i] += postfix
+ }
+ ctx.AddMissingDependencies(missingDeps)
+ }
+ depPaths.WholeStaticLibObjFiles =
+ append(depPaths.WholeStaticLibObjFiles, staticLib.objFiles...)
+ } else {
+ ctx.ModuleErrorf("module %q not a static library", ctx.OtherModuleName(m))
+ }
+ } else {
+ ctx.ModuleErrorf("module %q not an android module", ctx.OtherModuleName(m))
+ }
+ }
+
+ _, depPaths.StaticLibs, newCflags = c.depsToPathsFromList(ctx, deps.StaticLibs)
+ depPaths.Cflags = append(depPaths.Cflags, newCflags...)
+
+ _, depPaths.LateStaticLibs, newCflags = c.depsToPathsFromList(ctx, deps.LateStaticLibs)
+ depPaths.Cflags = append(depPaths.Cflags, newCflags...)
+
+ _, depPaths.SharedLibs, newCflags = c.depsToPathsFromList(ctx, deps.SharedLibs)
+ depPaths.Cflags = append(depPaths.Cflags, newCflags...)
+
+ _, depPaths.LateSharedLibs, newCflags = c.depsToPathsFromList(ctx, deps.LateSharedLibs)
+ depPaths.Cflags = append(depPaths.Cflags, newCflags...)
+
+ ctx.VisitDirectDeps(func(bm blueprint.Module) {
+ if m, ok := bm.(*Module); ok {
+ otherName := ctx.OtherModuleName(m)
+ if otherName == deps.CrtBegin {
+ depPaths.CrtBegin = m.outputFile
+ } else if otherName == deps.CrtEnd {
+ depPaths.CrtEnd = m.outputFile
+ } else {
+ output := m.outputFile
+ if output.Valid() {
+ depPaths.ObjFiles = append(depPaths.ObjFiles, output.Path())
+ } else {
+ ctx.ModuleErrorf("module %s did not provide an output file", otherName)
+ }
+ }
+ }
+ })
+
+ return depPaths
+}
+
+func (c *Module) InstallInData() bool {
+ if c.installer == nil {
+ return false
+ }
+ return c.installer.inData()
+}
+
+// Compiler
+
+type baseCompiler struct {
+ Properties BaseCompilerProperties
+}
+
+var _ compiler = (*baseCompiler)(nil)
+
+func (compiler *baseCompiler) props() []interface{} {
+ return []interface{}{&compiler.Properties}
+}
+
+func (compiler *baseCompiler) begin(ctx BaseModuleContext) {}
+func (compiler *baseCompiler) deps(ctx BaseModuleContext, deps Deps) Deps { return deps }
+
+// Create a Flags struct that collects the compile flags from global values,
+// per-target values, module type values, and per-module Blueprints properties
+func (compiler *baseCompiler) flags(ctx ModuleContext, flags Flags) Flags {
+ toolchain := ctx.toolchain()
+
+ flags.CFlags = append(flags.CFlags, compiler.Properties.Cflags...)
+ flags.CppFlags = append(flags.CppFlags, compiler.Properties.Cppflags...)
+ flags.ConlyFlags = append(flags.ConlyFlags, compiler.Properties.Conlyflags...)
+ flags.AsFlags = append(flags.AsFlags, compiler.Properties.Asflags...)
+ flags.YaccFlags = append(flags.YaccFlags, compiler.Properties.Yaccflags...)
+
// Include dir cflags
- rootIncludeDirs := common.PathsForSource(ctx, c.Properties.Include_dirs)
- localIncludeDirs := common.PathsForModuleSrc(ctx, c.Properties.Local_include_dirs)
+ rootIncludeDirs := common.PathsForSource(ctx, compiler.Properties.Include_dirs)
+ localIncludeDirs := common.PathsForModuleSrc(ctx, compiler.Properties.Local_include_dirs)
flags.GlobalFlags = append(flags.GlobalFlags,
includeDirsToFlags(localIncludeDirs),
includeDirsToFlags(rootIncludeDirs))
- rootIncludeFiles := common.PathsForSource(ctx, c.Properties.Include_files)
- localIncludeFiles := common.PathsForModuleSrc(ctx, c.Properties.Local_include_files)
+ rootIncludeFiles := common.PathsForSource(ctx, compiler.Properties.Include_files)
+ localIncludeFiles := common.PathsForModuleSrc(ctx, compiler.Properties.Local_include_files)
flags.GlobalFlags = append(flags.GlobalFlags,
includeFilesToFlags(rootIncludeFiles),
includeFilesToFlags(localIncludeFiles))
- if !Bool(c.Properties.No_default_compiler_flags) {
- if c.Properties.Sdk_version == "" || ctx.Host() {
+ if !ctx.noDefaultCompilerFlags() {
+ if !ctx.sdk() || ctx.Host() {
flags.GlobalFlags = append(flags.GlobalFlags,
"${commonGlobalIncludes}",
toolchain.IncludeFlags(),
@@ -540,21 +934,10 @@
}...)
}
- if c.Properties.Clang == nil {
- if ctx.Host() {
- flags.Clang = true
- }
-
- if ctx.Device() && ctx.AConfig().DeviceUsesClang() {
- flags.Clang = true
- }
+ instructionSet := compiler.Properties.Instruction_set
+ if flags.RequiredInstructionSet != "" {
+ instructionSet = flags.RequiredInstructionSet
}
-
- if !toolchain.ClangSupported() {
- flags.Clang = false
- }
-
- instructionSet := c.Properties.Instruction_set
instructionSetFlags, err := toolchain.InstructionSetFlags(instructionSet)
if flags.Clang {
instructionSetFlags, err = toolchain.ClangInstructionSetFlags(instructionSet)
@@ -564,12 +947,12 @@
}
// TODO: debug
- flags.CFlags = append(flags.CFlags, c.Properties.Release.Cflags...)
+ flags.CFlags = append(flags.CFlags, compiler.Properties.Release.Cflags...)
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.CFlags = append(flags.CFlags, compiler.Properties.Clang_cflags...)
+ flags.AsFlags = append(flags.AsFlags, compiler.Properties.Clang_asflags...)
flags.CppFlags = clangFilterUnknownCflags(flags.CppFlags)
flags.ConlyFlags = clangFilterUnknownCflags(flags.ConlyFlags)
flags.LdFlags = clangFilterUnknownCflags(flags.LdFlags)
@@ -582,11 +965,7 @@
flags.LdFlags = append(flags.LdFlags, target, gccPrefix)
}
- if !Bool(c.Properties.No_default_compiler_flags) {
- if ctx.Device() && !Bool(c.Properties.Allow_undefined_symbols) {
- flags.LdFlags = append(flags.LdFlags, "-Wl,--no-undefined")
- }
-
+ if !ctx.noDefaultCompilerFlags() {
flags.GlobalFlags = append(flags.GlobalFlags, instructionSetFlags)
if flags.Clang {
@@ -611,7 +990,7 @@
}
if ctx.Device() {
- if Bool(c.Properties.Rtti) {
+ if Bool(compiler.Properties.Rtti) {
flags.CppFlags = append(flags.CppFlags, "-frtti")
} else {
flags.CppFlags = append(flags.CppFlags, "-fno-rtti")
@@ -622,14 +1001,8 @@
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())
- }
-
- if ctx.Host() {
- flags.LdFlags = append(flags.LdFlags, c.Properties.Host_ldlibs...)
}
}
@@ -640,9 +1013,7 @@
}
flags.LdFlags = append(flags.LdFlags, toolchain.ToolchainLdflags())
- flags = c.ccModuleType().flags(ctx, flags)
-
- if c.Properties.Sdk_version == "" {
+ if !ctx.sdk() {
if ctx.Host() && !flags.Clang {
// The host GCC doesn't support C++14 (and is deprecated, so likely
// never will). Build these modules with C++11.
@@ -652,10 +1023,6 @@
}
}
- flags.CFlags, _ = filterList(flags.CFlags, illegalFlags)
- flags.CppFlags, _ = filterList(flags.CppFlags, illegalFlags)
- flags.ConlyFlags, _ = filterList(flags.ConlyFlags, illegalFlags)
-
// We can enforce some rules more strictly in the code we own. strict
// indicates if this is code that we can be stricter with. If we have
// rules that we want to apply to *our* code (but maybe can't for
@@ -672,27 +1039,36 @@
flags.CFlags = append(flags.CFlags, "-DANDROID_STRICT")
}
- // 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"}
-
return flags
}
-func (c *CCBase) flags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
- return flags
+func (compiler *baseCompiler) compile(ctx ModuleContext, flags Flags) common.Paths {
+ // Compile files listed in c.Properties.Srcs into objects
+ objFiles := compiler.compileObjs(ctx, flags, "", compiler.Properties.Srcs, compiler.Properties.Exclude_srcs)
+ if ctx.Failed() {
+ return nil
+ }
+
+ var genSrcs common.Paths
+ ctx.VisitDirectDeps(func(module blueprint.Module) {
+ if gen, ok := module.(genrule.SourceFileGenerator); ok {
+ genSrcs = append(genSrcs, gen.GeneratedSourceFiles()...)
+ }
+ })
+
+ if len(genSrcs) != 0 {
+ genObjs := TransformSourceToObj(ctx, "", genSrcs, flagsToBuilderFlags(flags), nil)
+ objFiles = append(objFiles, genObjs...)
+ }
+
+ return objFiles
}
// Compile a list of source files into objects a specified subdirectory
-func (c *CCBase) customCompileObjs(ctx common.AndroidModuleContext, flags CCFlags,
+func (compiler *baseCompiler) compileObjs(ctx common.AndroidModuleContext, flags Flags,
subdir string, srcFiles, excludes []string) common.Paths {
- buildFlags := ccFlagsToBuilderFlags(flags)
+ buildFlags := flagsToBuilderFlags(flags)
inputFiles := ctx.ExpandSources(srcFiles, excludes)
srcPaths, deps := genSources(ctx, inputFiles, buildFlags)
@@ -700,385 +1076,100 @@
return TransformSourceToObj(ctx, subdir, srcPaths, buildFlags, deps)
}
-// Compile files listed in c.Properties.Srcs into objects
-func (c *CCBase) compileObjs(ctx common.AndroidModuleContext, flags CCFlags) common.Paths {
-
- if c.Properties.SkipCompileObjs {
- return nil
- }
-
- return c.customCompileObjs(ctx, flags, "", c.Properties.Srcs, c.Properties.Exclude_srcs)
-}
-
-// Compile generated source files from dependencies
-func (c *CCBase) compileGeneratedObjs(ctx common.AndroidModuleContext, flags CCFlags) common.Paths {
- var srcs common.Paths
-
- if c.Properties.SkipCompileObjs {
- return nil
- }
-
- ctx.VisitDirectDeps(func(module blueprint.Module) {
- if gen, ok := module.(genrule.SourceFileGenerator); ok {
- srcs = append(srcs, gen.GeneratedSourceFiles()...)
- }
- })
-
- if len(srcs) == 0 {
- return nil
- }
-
- return TransformSourceToObj(ctx, "", srcs, ccFlagsToBuilderFlags(flags), nil)
-}
-
-func (c *CCBase) outputFile() common.OptionalPath {
- return common.OptionalPath{}
-}
-
-func (c *CCBase) depsToPathsFromList(ctx common.AndroidModuleContext,
- names []string) (modules []common.AndroidModule,
- outputFiles common.Paths, exportedFlags []string) {
-
- for _, n := range names {
- found := false
- ctx.VisitDirectDeps(func(m blueprint.Module) {
- otherName := ctx.OtherModuleName(m)
- if otherName != n {
- return
- }
-
- if a, ok := m.(CCModuleType); ok {
- if !a.Enabled() {
- // 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
- // dependencies with the same name, one of which is marked disabled for each
- // of host and device. Ignore the disabled one.
- return
- }
- if a.HostOrDevice() != ctx.HostOrDevice() {
- ctx.ModuleErrorf("host/device mismatch between %q and %q", ctx.ModuleName(),
- otherName)
- return
- }
-
- if outputFile := a.outputFile(); outputFile.Valid() {
- if found {
- ctx.ModuleErrorf("multiple modules satisified dependency on %q", otherName)
- return
- }
- outputFiles = append(outputFiles, outputFile.Path())
- modules = append(modules, a)
- if i, ok := a.(ccExportedFlagsProducer); ok {
- exportedFlags = append(exportedFlags, i.exportedFlags()...)
- }
- found = true
- } else {
- ctx.ModuleErrorf("module %q missing output file", otherName)
- return
- }
- } else {
- ctx.ModuleErrorf("module %q not an android module", otherName)
- return
- }
- })
- if !found && !inList(n, ctx.GetMissingDependencies()) {
- ctx.ModuleErrorf("unsatisified dependency on %q", n)
- }
- }
-
- return modules, outputFiles, exportedFlags
-}
-
-// Convert dependency names to paths. Takes a CCDeps containing names and returns a CCPathDeps
-// containing paths
-func (c *CCBase) depsToPaths(ctx common.AndroidModuleContext, depNames CCDeps) CCPathDeps {
- var depPaths CCPathDeps
- var newCflags []string
-
- var wholeStaticLibModules []common.AndroidModule
-
- wholeStaticLibModules, depPaths.WholeStaticLibs, newCflags =
- c.depsToPathsFromList(ctx, depNames.WholeStaticLibs)
- depPaths.Cflags = append(depPaths.Cflags, newCflags...)
- depPaths.ReexportedCflags = append(depPaths.ReexportedCflags, newCflags...)
-
- for _, m := range wholeStaticLibModules {
- if staticLib, ok := m.(ccLibraryInterface); ok && staticLib.static() {
- if missingDeps := staticLib.getWholeStaticMissingDeps(); missingDeps != nil {
- postfix := " (required by " + ctx.OtherModuleName(m) + ")"
- for i := range missingDeps {
- missingDeps[i] += postfix
- }
- ctx.AddMissingDependencies(missingDeps)
- }
- depPaths.WholeStaticLibObjFiles =
- append(depPaths.WholeStaticLibObjFiles, staticLib.allObjFiles()...)
- } else {
- ctx.ModuleErrorf("module %q not a static library", ctx.OtherModuleName(m))
- }
- }
-
- _, depPaths.StaticLibs, newCflags = c.depsToPathsFromList(ctx, depNames.StaticLibs)
- depPaths.Cflags = append(depPaths.Cflags, newCflags...)
-
- _, depPaths.LateStaticLibs, newCflags = c.depsToPathsFromList(ctx, depNames.LateStaticLibs)
- depPaths.Cflags = append(depPaths.Cflags, newCflags...)
-
- _, depPaths.SharedLibs, newCflags = c.depsToPathsFromList(ctx, depNames.SharedLibs)
- depPaths.Cflags = append(depPaths.Cflags, newCflags...)
-
- ctx.VisitDirectDeps(func(m blueprint.Module) {
- if obj, ok := m.(ccObjectProvider); ok {
- otherName := ctx.OtherModuleName(m)
- if otherName == depNames.CrtBegin {
- if !Bool(c.Properties.Nocrt) {
- depPaths.CrtBegin = obj.object().outputFile()
- }
- } else if otherName == depNames.CrtEnd {
- if !Bool(c.Properties.Nocrt) {
- depPaths.CrtEnd = obj.object().outputFile()
- }
- } else {
- output := obj.object().outputFile()
- if output.Valid() {
- depPaths.ObjFiles = append(depPaths.ObjFiles, output.Path())
- } else {
- ctx.ModuleErrorf("module %s did not provide an output file", otherName)
- }
- }
- }
- })
-
- return depPaths
-}
-
-type ccLinkedProperties struct {
- VariantIsShared bool `blueprint:"mutated"`
- VariantIsStatic bool `blueprint:"mutated"`
- VariantIsStaticBinary bool `blueprint:"mutated"`
-}
-
-// CCLinked contains the properties and members used by libraries and executables
-type CCLinked struct {
- CCBase
- dynamicProperties ccLinkedProperties
-}
-
-func newCCDynamic(dynamic *CCLinked, module CCModuleType, hod common.HostOrDeviceSupported,
- multilib common.Multilib, props ...interface{}) (blueprint.Module, []interface{}) {
-
- props = append(props, &dynamic.dynamicProperties)
-
- return newCCBase(&dynamic.CCBase, module, hod, multilib, props...)
-}
-
-func (c *CCLinked) systemSharedLibs(ctx common.AndroidBaseContext) []string {
- if c.Properties.System_shared_libs != nil {
- return c.Properties.System_shared_libs
- } else if ctx.Device() && c.Properties.Sdk_version == "" {
- return []string{"libc", "libm"}
- } else {
- return nil
+// baseLinker provides support for shared_libs, static_libs, and whole_static_libs properties
+type baseLinker struct {
+ Properties BaseLinkerProperties
+ dynamicProperties struct {
+ VariantIsShared bool `blueprint:"mutated"`
+ VariantIsStatic bool `blueprint:"mutated"`
+ VariantIsStaticBinary bool `blueprint:"mutated"`
}
}
-func (c *CCLinked) stl(ctx common.AndroidBaseContext) string {
- if c.Properties.Sdk_version != "" && ctx.Device() {
- switch c.Properties.Stl {
- case "":
- return "ndk_system"
- case "c++_shared", "c++_static",
- "stlport_shared", "stlport_static",
- "gnustl_static":
- return "ndk_lib" + c.Properties.Stl
- default:
- ctx.ModuleErrorf("stl: %q is not a supported STL with sdk_version set", c.Properties.Stl)
- return ""
- }
- }
+func (linker *baseLinker) begin(ctx BaseModuleContext) {}
- if ctx.HostType() == common.Windows {
- switch c.Properties.Stl {
- case "libc++", "libc++_static", "libstdc++", "":
- // libc++ is not supported on mingw
- return "libstdc++"
- case "none":
- return ""
- default:
- ctx.ModuleErrorf("stl: %q is not a supported STL", c.Properties.Stl)
- return ""
- }
- } else {
- switch c.Properties.Stl {
- case "libc++", "libc++_static",
- "libstdc++":
- return c.Properties.Stl
- case "none":
- return ""
- case "":
- if c.static() {
- return "libc++_static"
- } else {
- return "libc++"
- }
- default:
- ctx.ModuleErrorf("stl: %q is not a supported STL", c.Properties.Stl)
- return ""
- }
- }
+func (linker *baseLinker) props() []interface{} {
+ return []interface{}{&linker.Properties, &linker.dynamicProperties}
}
-var hostDynamicGccLibs, hostStaticGccLibs map[common.HostType][]string
-
-func init() {
- hostDynamicGccLibs = map[common.HostType][]string{
- common.Linux: []string{"-lgcc_s", "-lgcc", "-lc", "-lgcc_s", "-lgcc"},
- common.Darwin: []string{"-lc", "-lSystem"},
- common.Windows: []string{"-lmsvcr110", "-lmingw32", "-lgcc", "-lmoldname",
- "-lmingwex", "-lmsvcrt", "-ladvapi32", "-lshell32", "-luser32",
- "-lkernel32", "-lmingw32", "-lgcc", "-lmoldname", "-lmingwex",
- "-lmsvcrt"},
- }
- hostStaticGccLibs = map[common.HostType][]string{
- common.Linux: []string{"-Wl,--start-group", "-lgcc", "-lgcc_eh", "-lc", "-Wl,--end-group"},
- common.Darwin: []string{"NO_STATIC_HOST_BINARIES_ON_DARWIN"},
- common.Windows: []string{"NO_STATIC_HOST_BINARIES_ON_WINDOWS"},
- }
-}
-
-func (c *CCLinked) flags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
- stl := c.stl(ctx)
- if ctx.Failed() {
- return flags
- }
-
- switch stl {
- case "libc++", "libc++_static":
- flags.CFlags = append(flags.CFlags, "-D_USING_LIBCXX")
- if ctx.Host() {
- flags.CppFlags = append(flags.CppFlags, "-nostdinc++")
- flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
- flags.LdFlags = append(flags.LdFlags, "-lpthread", "-lm")
- if c.staticBinary() {
- flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.HostType()]...)
- } else {
- flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.HostType()]...)
- }
- } else {
- if ctx.Arch().ArchType == common.Arm {
- flags.LdFlags = append(flags.LdFlags, "-Wl,--exclude-libs,libunwind_llvm.a")
- }
- }
- case "libstdc++":
- // Using bionic's basic libstdc++. Not actually an STL. Only around until the
- // tree is in good enough shape to not need it.
- // Host builds will use GNU libstdc++.
- if ctx.Device() {
- flags.CFlags = append(flags.CFlags, "-I"+common.PathForSource(ctx, "bionic/libstdc++/include").String())
- } else {
- // Host builds will use the system C++. libc++ on Darwin, GNU libstdc++ everywhere else
- flags.CppFlags = append(flags.CppFlags, flags.Toolchain.SystemCppCppflags())
- flags.LdFlags = append(flags.LdFlags, flags.Toolchain.SystemCppLdflags())
- }
- case "ndk_system":
- ndkSrcRoot := common.PathForSource(ctx, "prebuilts/ndk/current/sources/cxx-stl/system/include")
- flags.CFlags = append(flags.CFlags, "-isystem "+ndkSrcRoot.String())
- case "ndk_libc++_shared", "ndk_libc++_static":
- // TODO(danalbert): This really shouldn't be here...
- flags.CppFlags = append(flags.CppFlags, "-std=c++11")
- case "ndk_libstlport_shared", "ndk_libstlport_static", "ndk_libgnustl_static":
- // Nothing
- case "":
- // None or error.
- if ctx.Host() {
- flags.CppFlags = append(flags.CppFlags, "-nostdinc++")
- flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
- if c.staticBinary() {
- flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.HostType()]...)
- } else {
- flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.HostType()]...)
- }
- }
- default:
- panic(fmt.Errorf("Unknown stl in CCLinked.Flags: %q", stl))
- }
-
- return flags
-}
-
-func (c *CCLinked) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
- depNames = c.CCBase.depNames(ctx, depNames)
-
- stl := c.stl(ctx)
- if ctx.Failed() {
- return depNames
- }
-
- switch stl {
- case "libstdc++":
- if ctx.Device() {
- depNames.SharedLibs = append(depNames.SharedLibs, stl)
- }
- case "libc++", "libc++_static":
- if stl == "libc++" {
- depNames.SharedLibs = append(depNames.SharedLibs, stl)
- } else {
- depNames.StaticLibs = append(depNames.StaticLibs, stl)
- }
- if ctx.Device() {
- if ctx.Arch().ArchType == common.Arm {
- depNames.StaticLibs = append(depNames.StaticLibs, "libunwind_llvm")
- }
- if c.staticBinary() {
- depNames.StaticLibs = append(depNames.StaticLibs, "libdl")
- } else {
- depNames.SharedLibs = append(depNames.SharedLibs, "libdl")
- }
- }
- case "":
- // None or error.
- case "ndk_system":
- // TODO: Make a system STL prebuilt for the NDK.
- // The system STL doesn't have a prebuilt (it uses the system's libstdc++), but it does have
- // its own includes. The includes are handled in CCBase.Flags().
- depNames.SharedLibs = append([]string{"libstdc++"}, depNames.SharedLibs...)
- case "ndk_libc++_shared", "ndk_libstlport_shared":
- depNames.SharedLibs = append(depNames.SharedLibs, stl)
- case "ndk_libc++_static", "ndk_libstlport_static", "ndk_libgnustl_static":
- depNames.StaticLibs = append(depNames.StaticLibs, stl)
- default:
- panic(fmt.Errorf("Unknown stl in CCLinked.depNames: %q", stl))
- }
+func (linker *baseLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
+ deps.WholeStaticLibs = append(deps.WholeStaticLibs, linker.Properties.Whole_static_libs...)
+ deps.StaticLibs = append(deps.StaticLibs, linker.Properties.Static_libs...)
+ deps.SharedLibs = append(deps.SharedLibs, linker.Properties.Shared_libs...)
if ctx.ModuleName() != "libcompiler_rt-extras" {
- depNames.StaticLibs = append(depNames.StaticLibs, "libcompiler_rt-extras")
+ deps.StaticLibs = append(deps.StaticLibs, "libcompiler_rt-extras")
}
if ctx.Device() {
// libgcc and libatomic have to be last on the command line
- depNames.LateStaticLibs = append(depNames.LateStaticLibs, "libatomic")
- if !Bool(c.Properties.No_libgcc) {
- depNames.LateStaticLibs = append(depNames.LateStaticLibs, "libgcc")
+ deps.LateStaticLibs = append(deps.LateStaticLibs, "libatomic")
+ if !Bool(linker.Properties.No_libgcc) {
+ deps.LateStaticLibs = append(deps.LateStaticLibs, "libgcc")
}
- if !c.static() {
- depNames.SharedLibs = append(depNames.SharedLibs, c.systemSharedLibs(ctx)...)
+ if !linker.static() {
+ if linker.Properties.System_shared_libs != nil {
+ deps.LateSharedLibs = append(deps.LateSharedLibs,
+ linker.Properties.System_shared_libs...)
+ } else if !ctx.sdk() {
+ deps.LateSharedLibs = append(deps.LateSharedLibs, "libc", "libm")
+ }
}
- if c.Properties.Sdk_version != "" {
- version := c.Properties.Sdk_version
- depNames.SharedLibs = append(depNames.SharedLibs,
+ if ctx.sdk() {
+ version := ctx.sdkVersion()
+ deps.SharedLibs = append(deps.SharedLibs,
"ndk_libc."+version,
"ndk_libm."+version,
)
}
}
- return depNames
+ return deps
}
-// ccLinkedInterface interface is used on ccLinked to deal with static or shared variants
-type ccLinkedInterface interface {
+func (linker *baseLinker) flags(ctx ModuleContext, flags Flags) Flags {
+ toolchain := ctx.toolchain()
+
+ flags.LdFlags = append(flags.LdFlags, linker.Properties.Ldflags...)
+
+ if !ctx.noDefaultCompilerFlags() {
+ if ctx.Device() && !Bool(linker.Properties.Allow_undefined_symbols) {
+ flags.LdFlags = append(flags.LdFlags, "-Wl,--no-undefined")
+ }
+
+ if flags.Clang {
+ flags.LdFlags = append(flags.LdFlags, toolchain.ClangLdflags())
+ } else {
+ flags.LdFlags = append(flags.LdFlags, toolchain.Ldflags())
+ }
+
+ if ctx.Host() {
+ flags.LdFlags = append(flags.LdFlags, linker.Properties.Host_ldlibs...)
+ }
+ }
+
+ if !flags.Clang {
+ flags.LdFlags = append(flags.LdFlags, toolchain.ToolchainLdflags())
+ }
+
+ return flags
+}
+
+func (linker *baseLinker) static() bool {
+ return linker.dynamicProperties.VariantIsStatic
+}
+
+func (linker *baseLinker) staticBinary() bool {
+ return linker.dynamicProperties.VariantIsStaticBinary
+}
+
+func (linker *baseLinker) setStatic(static bool) {
+ linker.dynamicProperties.VariantIsStatic = static
+}
+
+type baseLinkerInterface interface {
// Returns true if the build options for the module have selected a static or shared build
buildStatic() bool
buildShared() bool
@@ -1093,172 +1184,63 @@
staticBinary() bool
}
-var _ ccLinkedInterface = (*CCLibrary)(nil)
-var _ ccLinkedInterface = (*CCBinary)(nil)
-
-func (c *CCLinked) static() bool {
- return c.dynamicProperties.VariantIsStatic
-}
-
-func (c *CCLinked) staticBinary() bool {
- return c.dynamicProperties.VariantIsStaticBinary
-}
-
-func (c *CCLinked) setStatic(static bool) {
- c.dynamicProperties.VariantIsStatic = static
-}
-
-type ccExportedFlagsProducer interface {
+type exportedFlagsProducer interface {
exportedFlags() []string
}
+type baseInstaller struct {
+ Properties InstallerProperties
+
+ dir string
+ dir64 string
+ data bool
+
+ path common.Path
+}
+
+var _ installer = (*baseInstaller)(nil)
+
+func (installer *baseInstaller) props() []interface{} {
+ return []interface{}{&installer.Properties}
+}
+
+func (installer *baseInstaller) install(ctx ModuleContext, file common.Path) {
+ subDir := installer.dir
+ if ctx.toolchain().Is64Bit() && installer.dir64 != "" {
+ subDir = installer.dir64
+ }
+ dir := common.PathForModuleInstall(ctx, subDir, installer.Properties.Relative_install_path)
+ installer.path = ctx.InstallFile(dir, file)
+}
+
+func (installer *baseInstaller) inData() bool {
+ return installer.data
+}
+
//
// Combined static+shared libraries
//
-type CCLibraryProperties struct {
- BuildStatic bool `blueprint:"mutated"`
- BuildShared bool `blueprint:"mutated"`
- Static struct {
- Srcs []string `android:"arch_variant"`
- Exclude_srcs []string `android:"arch_variant"`
- Cflags []string `android:"arch_variant"`
- Whole_static_libs []string `android:"arch_variant"`
- Static_libs []string `android:"arch_variant"`
- Shared_libs []string `android:"arch_variant"`
- } `android:"arch_variant"`
- Shared struct {
- Srcs []string `android:"arch_variant"`
- Exclude_srcs []string `android:"arch_variant"`
- Cflags []string `android:"arch_variant"`
- Whole_static_libs []string `android:"arch_variant"`
- Static_libs []string `android:"arch_variant"`
- Shared_libs []string `android:"arch_variant"`
- } `android:"arch_variant"`
+type libraryCompiler struct {
+ baseCompiler
- // local file name to pass to the linker as --version_script
- Version_script *string `android:"arch_variant"`
- // local file name to pass to the linker as -unexported_symbols_list
- Unexported_symbols_list *string `android:"arch_variant"`
- // local file name to pass to the linker as -force_symbols_not_weak_list
- Force_symbols_not_weak_list *string `android:"arch_variant"`
- // local file name to pass to the linker as -force_symbols_weak_list
- Force_symbols_weak_list *string `android:"arch_variant"`
-}
+ linker *libraryLinker
+ Properties LibraryCompilerProperties
-type CCLibrary struct {
- CCLinked
-
- reuseFrom ccLibraryInterface
+ // For reusing static library objects for shared library
+ reuseFrom *libraryCompiler
reuseObjFiles common.Paths
- objFiles common.Paths
- exportFlags []string
- out common.Path
- systemLibs []string
-
- // If we're used as a whole_static_lib, our missing dependencies need
- // to be given
- wholeStaticMissingDeps []string
-
- LibraryProperties CCLibraryProperties
}
-func (c *CCLibrary) buildStatic() bool {
- return c.LibraryProperties.BuildStatic
+var _ compiler = (*libraryCompiler)(nil)
+
+func (library *libraryCompiler) props() []interface{} {
+ props := library.baseCompiler.props()
+ return append(props, &library.Properties)
}
-func (c *CCLibrary) buildShared() bool {
- return c.LibraryProperties.BuildShared
-}
-
-type ccLibraryInterface interface {
- ccLinkedInterface
- ccLibrary() *CCLibrary
- setReuseFrom(ccLibraryInterface)
- getReuseFrom() ccLibraryInterface
- getReuseObjFiles() common.Paths
- allObjFiles() common.Paths
- getWholeStaticMissingDeps() []string
-}
-
-var _ ccLibraryInterface = (*CCLibrary)(nil)
-
-func (c *CCLibrary) ccLibrary() *CCLibrary {
- return c
-}
-
-func NewCCLibrary(library *CCLibrary, module CCModuleType,
- hod common.HostOrDeviceSupported) (blueprint.Module, []interface{}) {
-
- return newCCDynamic(&library.CCLinked, 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) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
- depNames = c.CCLinked.depNames(ctx, depNames)
- if c.static() {
- depNames.WholeStaticLibs = append(depNames.WholeStaticLibs, c.LibraryProperties.Static.Whole_static_libs...)
- depNames.StaticLibs = append(depNames.StaticLibs, c.LibraryProperties.Static.Static_libs...)
- depNames.SharedLibs = append(depNames.SharedLibs, c.LibraryProperties.Static.Shared_libs...)
- } else {
- if ctx.Device() {
- if c.Properties.Sdk_version == "" {
- depNames.CrtBegin = "crtbegin_so"
- depNames.CrtEnd = "crtend_so"
- } else {
- depNames.CrtBegin = "ndk_crtbegin_so." + c.Properties.Sdk_version
- depNames.CrtEnd = "ndk_crtend_so." + c.Properties.Sdk_version
- }
- }
- depNames.WholeStaticLibs = append(depNames.WholeStaticLibs, c.LibraryProperties.Shared.Whole_static_libs...)
- depNames.StaticLibs = append(depNames.StaticLibs, c.LibraryProperties.Shared.Static_libs...)
- depNames.SharedLibs = append(depNames.SharedLibs, c.LibraryProperties.Shared.Shared_libs...)
- }
-
- c.systemLibs = c.systemSharedLibs(ctx)
-
- return depNames
-}
-
-func (c *CCLibrary) outputFile() common.OptionalPath {
- return common.OptionalPathForPath(c.out)
-}
-
-func (c *CCLibrary) getReuseObjFiles() common.Paths {
- return c.reuseObjFiles
-}
-
-func (c *CCLibrary) setReuseFrom(reuseFrom ccLibraryInterface) {
- c.reuseFrom = reuseFrom
-}
-
-func (c *CCLibrary) getReuseFrom() ccLibraryInterface {
- return c.reuseFrom
-}
-
-func (c *CCLibrary) allObjFiles() common.Paths {
- return c.objFiles
-}
-
-func (c *CCLibrary) getWholeStaticMissingDeps() []string {
- return c.wholeStaticMissingDeps
-}
-
-func (c *CCLibrary) exportedFlags() []string {
- return c.exportFlags
-}
-
-func (c *CCLibrary) flags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
- flags = c.CCLinked.flags(ctx, flags)
+func (library *libraryCompiler) flags(ctx ModuleContext, flags Flags) Flags {
+ flags = library.baseCompiler.flags(ctx, flags)
// MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
// all code is position independent, and then those warnings get promoted to
@@ -1267,13 +1249,71 @@
flags.CFlags = append(flags.CFlags, "-fPIC")
}
- if c.static() {
- flags.CFlags = append(flags.CFlags, c.LibraryProperties.Static.Cflags...)
+ if library.linker.static() {
+ flags.CFlags = append(flags.CFlags, library.Properties.Static.Cflags...)
} else {
- flags.CFlags = append(flags.CFlags, c.LibraryProperties.Shared.Cflags...)
+ flags.CFlags = append(flags.CFlags, library.Properties.Shared.Cflags...)
}
- if !c.static() {
+ return flags
+}
+
+func (library *libraryCompiler) compile(ctx ModuleContext, flags Flags) common.Paths {
+ var objFiles common.Paths
+
+ if library.reuseFrom != library && library.reuseFrom.Properties.Static.Cflags == nil &&
+ library.Properties.Shared.Cflags == nil {
+ objFiles = append(common.Paths(nil), library.reuseFrom.reuseObjFiles...)
+ } else {
+ objFiles = library.baseCompiler.compile(ctx, flags)
+ library.reuseObjFiles = objFiles
+ }
+
+ if library.linker.static() {
+ objFiles = append(objFiles, library.compileObjs(ctx, flags, common.DeviceStaticLibrary,
+ library.Properties.Static.Srcs, library.Properties.Static.Exclude_srcs)...)
+ } else {
+ objFiles = append(objFiles, library.compileObjs(ctx, flags, common.DeviceSharedLibrary,
+ library.Properties.Shared.Srcs, library.Properties.Shared.Exclude_srcs)...)
+ }
+
+ return objFiles
+}
+
+type libraryLinker struct {
+ baseLinker
+
+ Properties LibraryLinkerProperties
+
+ dynamicProperties struct {
+ BuildStatic bool `blueprint:"mutated"`
+ BuildShared bool `blueprint:"mutated"`
+ }
+
+ exportFlags []string
+
+ // If we're used as a whole_static_lib, our missing dependencies need
+ // to be given
+ wholeStaticMissingDeps []string
+
+ // For whole_static_libs
+ objFiles common.Paths
+}
+
+var _ linker = (*libraryLinker)(nil)
+var _ exportedFlagsProducer = (*libraryLinker)(nil)
+
+func (library *libraryLinker) props() []interface{} {
+ props := library.baseLinker.props()
+ return append(props, &library.Properties, &library.dynamicProperties)
+}
+
+func (library *libraryLinker) flags(ctx ModuleContext, flags Flags) Flags {
+ flags = library.baseLinker.flags(ctx, flags)
+
+ flags.Nocrt = Bool(library.Properties.Nocrt)
+
+ if !library.static() {
libName := ctx.ModuleName()
// GCC for Android assumes that -shared means -Bsymbolic, use -Wl,-shared instead
sharedFlag := "-Wl,-shared"
@@ -1305,56 +1345,69 @@
return flags
}
-func (c *CCLibrary) compileStaticLibrary(ctx common.AndroidModuleContext,
- flags CCFlags, deps CCPathDeps, objFiles common.Paths) {
+func (library *libraryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
+ deps = library.baseLinker.deps(ctx, deps)
+ if library.static() {
+ deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.Properties.Static.Whole_static_libs...)
+ deps.StaticLibs = append(deps.StaticLibs, library.Properties.Static.Static_libs...)
+ deps.SharedLibs = append(deps.SharedLibs, library.Properties.Static.Shared_libs...)
+ } else {
+ if ctx.Device() && !Bool(library.Properties.Nocrt) {
+ if !ctx.sdk() {
+ deps.CrtBegin = "crtbegin_so"
+ deps.CrtEnd = "crtend_so"
+ } else {
+ deps.CrtBegin = "ndk_crtbegin_so." + ctx.sdkVersion()
+ deps.CrtEnd = "ndk_crtend_so." + ctx.sdkVersion()
+ }
+ }
+ deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.Properties.Shared.Whole_static_libs...)
+ deps.StaticLibs = append(deps.StaticLibs, library.Properties.Shared.Static_libs...)
+ deps.SharedLibs = append(deps.SharedLibs, library.Properties.Shared.Shared_libs...)
+ }
- staticFlags := flags
- objFilesStatic := c.customCompileObjs(ctx, staticFlags, common.DeviceStaticLibrary,
- c.LibraryProperties.Static.Srcs, c.LibraryProperties.Static.Exclude_srcs)
+ return deps
+}
- objFiles = append(objFiles, objFilesStatic...)
+func (library *libraryLinker) exportedFlags() []string {
+ return library.exportFlags
+}
+
+func (library *libraryLinker) linkStatic(ctx ModuleContext,
+ flags Flags, deps PathDeps, objFiles common.Paths) common.Path {
+
objFiles = append(objFiles, deps.WholeStaticLibObjFiles...)
+ library.objFiles = objFiles
outputFile := common.PathForModuleOut(ctx, ctx.ModuleName()+staticLibraryExtension)
if ctx.Darwin() {
- TransformDarwinObjToStaticLib(ctx, objFiles, ccFlagsToBuilderFlags(flags), outputFile)
+ TransformDarwinObjToStaticLib(ctx, objFiles, flagsToBuilderFlags(flags), outputFile)
} else {
- TransformObjToStaticLib(ctx, objFiles, ccFlagsToBuilderFlags(flags), outputFile)
+ TransformObjToStaticLib(ctx, objFiles, flagsToBuilderFlags(flags), outputFile)
}
- c.wholeStaticMissingDeps = ctx.GetMissingDependencies()
-
- c.objFiles = objFiles
- c.out = outputFile
-
- includeDirs := common.PathsForModuleSrc(ctx, c.Properties.Export_include_dirs)
- c.exportFlags = []string{includeDirsToFlags(includeDirs)}
- c.exportFlags = append(c.exportFlags, deps.ReexportedCflags...)
+ library.wholeStaticMissingDeps = ctx.GetMissingDependencies()
ctx.CheckbuildFile(outputFile)
+
+ return outputFile
}
-func (c *CCLibrary) compileSharedLibrary(ctx common.AndroidModuleContext,
- flags CCFlags, deps CCPathDeps, objFiles common.Paths) {
-
- sharedFlags := flags
- objFilesShared := c.customCompileObjs(ctx, sharedFlags, common.DeviceSharedLibrary,
- c.LibraryProperties.Shared.Srcs, c.LibraryProperties.Shared.Exclude_srcs)
-
- objFiles = append(objFiles, objFilesShared...)
+func (library *libraryLinker) linkShared(ctx ModuleContext,
+ flags Flags, deps PathDeps, objFiles common.Paths) common.Path {
outputFile := common.PathForModuleOut(ctx, ctx.ModuleName()+flags.Toolchain.ShlibSuffix())
var linkerDeps common.Paths
- versionScript := common.OptionalPathForModuleSrc(ctx, c.LibraryProperties.Version_script)
- unexportedSymbols := common.OptionalPathForModuleSrc(ctx, c.LibraryProperties.Unexported_symbols_list)
- forceNotWeakSymbols := common.OptionalPathForModuleSrc(ctx, c.LibraryProperties.Force_symbols_not_weak_list)
- forceWeakSymbols := common.OptionalPathForModuleSrc(ctx, c.LibraryProperties.Force_symbols_weak_list)
+ versionScript := common.OptionalPathForModuleSrc(ctx, library.Properties.Version_script)
+ unexportedSymbols := common.OptionalPathForModuleSrc(ctx, library.Properties.Unexported_symbols_list)
+ forceNotWeakSymbols := common.OptionalPathForModuleSrc(ctx, library.Properties.Force_symbols_not_weak_list)
+ forceWeakSymbols := common.OptionalPathForModuleSrc(ctx, library.Properties.Force_symbols_weak_list)
if !ctx.Darwin() {
if versionScript.Valid() {
- sharedFlags.LdFlags = append(sharedFlags.LdFlags, "-Wl,--version-script,"+versionScript.String())
+ flags.LdFlags = append(flags.LdFlags, "-Wl,--version-script,"+versionScript.String())
linkerDeps = append(linkerDeps, versionScript.Path())
}
if unexportedSymbols.Valid() {
@@ -1371,100 +1424,128 @@
ctx.PropertyErrorf("version_script", "Not supported on Darwin")
}
if unexportedSymbols.Valid() {
- sharedFlags.LdFlags = append(sharedFlags.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
+ flags.LdFlags = append(flags.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
linkerDeps = append(linkerDeps, unexportedSymbols.Path())
}
if forceNotWeakSymbols.Valid() {
- sharedFlags.LdFlags = append(sharedFlags.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
+ flags.LdFlags = append(flags.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
linkerDeps = append(linkerDeps, forceNotWeakSymbols.Path())
}
if forceWeakSymbols.Valid() {
- sharedFlags.LdFlags = append(sharedFlags.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
+ flags.LdFlags = append(flags.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
linkerDeps = append(linkerDeps, forceWeakSymbols.Path())
}
}
- TransformObjToDynamicBinary(ctx, objFiles, deps.SharedLibs, deps.StaticLibs,
- deps.LateStaticLibs, deps.WholeStaticLibs, linkerDeps, deps.CrtBegin, deps.CrtEnd, false,
- ccFlagsToBuilderFlags(sharedFlags), outputFile)
+ sharedLibs := deps.SharedLibs
+ sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
- c.out = outputFile
- includeDirs := common.PathsForModuleSrc(ctx, c.Properties.Export_include_dirs)
- c.exportFlags = []string{includeDirsToFlags(includeDirs)}
- c.exportFlags = append(c.exportFlags, deps.ReexportedCflags...)
+ TransformObjToDynamicBinary(ctx, objFiles, sharedLibs,
+ deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
+ linkerDeps, deps.CrtBegin, deps.CrtEnd, false, flagsToBuilderFlags(flags), outputFile)
+
+ return outputFile
}
-func (c *CCLibrary) compileModule(ctx common.AndroidModuleContext,
- flags CCFlags, deps CCPathDeps, objFiles common.Paths) {
+func (library *libraryLinker) link(ctx ModuleContext,
+ flags Flags, deps PathDeps, objFiles common.Paths) common.Path {
- // Reuse the object files from the matching static library if it exists
- if c.getReuseFrom().ccLibrary() == c {
- c.reuseObjFiles = objFiles
+ var out common.Path
+ if library.static() {
+ out = library.linkStatic(ctx, flags, deps, objFiles)
} else {
- if c.getReuseFrom().ccLibrary().LibraryProperties.Static.Cflags == nil &&
- c.LibraryProperties.Shared.Cflags == nil {
- objFiles = append(common.Paths(nil), c.getReuseFrom().getReuseObjFiles()...)
- }
+ out = library.linkShared(ctx, flags, deps, objFiles)
}
- if c.static() {
- c.compileStaticLibrary(ctx, flags, deps, objFiles)
- } else {
- c.compileSharedLibrary(ctx, flags, deps, objFiles)
+ includeDirs := common.PathsForModuleSrc(ctx, library.Properties.Export_include_dirs)
+ library.exportFlags = []string{includeDirsToFlags(includeDirs)}
+ library.exportFlags = append(library.exportFlags, deps.ReexportedCflags...)
+
+ return out
+}
+
+func (library *libraryLinker) buildStatic() bool {
+ return library.dynamicProperties.BuildStatic
+}
+
+func (library *libraryLinker) buildShared() bool {
+ return library.dynamicProperties.BuildShared
+}
+
+func (library *libraryLinker) getWholeStaticMissingDeps() []string {
+ return library.wholeStaticMissingDeps
+}
+
+type libraryInstaller struct {
+ baseInstaller
+
+ linker *libraryLinker
+}
+
+func (library *libraryInstaller) install(ctx ModuleContext, file common.Path) {
+ if !library.linker.static() {
+ library.baseInstaller.install(ctx, file)
}
}
-func (c *CCLibrary) installStaticLibrary(ctx common.AndroidModuleContext, flags CCFlags) {
- // Static libraries do not get installed.
-}
+func NewLibrary(hod common.HostOrDeviceSupported, shared, static bool) *Module {
+ module := newModule(hod, common.MultilibBoth)
-func (c *CCLibrary) installSharedLibrary(ctx common.AndroidModuleContext, flags CCFlags) {
- installDir := "lib"
- if flags.Toolchain.Is64Bit() {
- installDir = "lib64"
+ linker := &libraryLinker{}
+ linker.dynamicProperties.BuildShared = shared
+ linker.dynamicProperties.BuildStatic = static
+ module.linker = linker
+
+ module.compiler = &libraryCompiler{
+ linker: linker,
+ }
+ module.installer = &libraryInstaller{
+ baseInstaller: baseInstaller{
+ dir: "lib",
+ dir64: "lib64",
+ },
+ linker: linker,
}
- ctx.InstallFile(common.PathForModuleInstall(ctx, installDir, c.Properties.Relative_install_path), c.out)
+ return module
}
-func (c *CCLibrary) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
- if c.static() {
- c.installStaticLibrary(ctx, flags)
- } else {
- c.installSharedLibrary(ctx, flags)
- }
+func libraryFactory() (blueprint.Module, []interface{}) {
+ module := NewLibrary(common.HostAndDeviceSupported, true, true)
+ return module.Init()
}
//
// Objects (for crt*.o)
//
-type ccObjectProvider interface {
- object() *ccObject
+type objectLinker struct {
}
-type ccObject struct {
- CCBase
- out common.OptionalPath
+func objectFactory() (blueprint.Module, []interface{}) {
+ module := newBaseModule(common.DeviceSupported, common.MultilibBoth)
+ module.compiler = &baseCompiler{}
+ module.linker = &objectLinker{}
+ return module.Init()
}
-func (c *ccObject) object() *ccObject {
- return c
+func (*objectLinker) props() []interface{} {
+ return nil
}
-func CCObjectFactory() (blueprint.Module, []interface{}) {
- module := &ccObject{}
+func (*objectLinker) begin(ctx BaseModuleContext) {}
- return newCCBase(&module.CCBase, module, common.DeviceSupported, common.MultilibBoth)
-}
-
-func (*ccObject) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
+func (*objectLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
// object files can't have any dynamic dependencies
- return CCDeps{}
+ return deps
}
-func (c *ccObject) compileModule(ctx common.AndroidModuleContext,
- flags CCFlags, deps CCPathDeps, objFiles common.Paths) {
+func (*objectLinker) flags(ctx ModuleContext, flags Flags) Flags {
+ return flags
+}
+
+func (object *objectLinker) link(ctx ModuleContext,
+ flags Flags, deps PathDeps, objFiles common.Paths) common.Path {
objFiles = append(objFiles, deps.ObjFiles...)
@@ -1473,128 +1554,115 @@
outputFile = objFiles[0]
} else {
output := common.PathForModuleOut(ctx, ctx.ModuleName()+objectExtension)
- TransformObjsToObj(ctx, objFiles, ccFlagsToBuilderFlags(flags), output)
+ TransformObjsToObj(ctx, objFiles, flagsToBuilderFlags(flags), output)
outputFile = output
}
- c.out = common.OptionalPathForPath(outputFile)
-
ctx.CheckbuildFile(outputFile)
+ return outputFile
}
-func (c *ccObject) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
- // Object files do not get installed.
-}
-
-func (c *ccObject) outputFile() common.OptionalPath {
- return c.out
-}
-
-var _ ccObjectProvider = (*ccObject)(nil)
-
//
// Executables
//
-type CCBinaryProperties struct {
- // compile executable with -static
- Static_executable *bool
+type binaryLinker struct {
+ baseLinker
- // set the name of the output
- Stem string `android:"arch_variant"`
+ Properties BinaryLinkerProperties
- // append to the name of the output
- Suffix string `android:"arch_variant"`
-
- // if set, add an extra objcopy --prefix-symbols= step
- Prefix_symbols string
+ hostToolPath common.OptionalPath
}
-type CCBinary struct {
- CCLinked
- out common.Path
- installFile common.Path
- BinaryProperties CCBinaryProperties
+var _ linker = (*binaryLinker)(nil)
+
+func (binary *binaryLinker) props() []interface{} {
+ return append(binary.baseLinker.props(), &binary.Properties)
}
-func (c *CCBinary) buildStatic() bool {
- return Bool(c.BinaryProperties.Static_executable)
+func (binary *binaryLinker) buildStatic() bool {
+ return Bool(binary.Properties.Static_executable)
}
-func (c *CCBinary) buildShared() bool {
- return !Bool(c.BinaryProperties.Static_executable)
+func (binary *binaryLinker) buildShared() bool {
+ return !Bool(binary.Properties.Static_executable)
}
-func (c *CCBinary) getStem(ctx common.AndroidModuleContext) string {
+func (binary *binaryLinker) getStem(ctx BaseModuleContext) string {
stem := ctx.ModuleName()
- if c.BinaryProperties.Stem != "" {
- stem = c.BinaryProperties.Stem
+ if binary.Properties.Stem != "" {
+ stem = binary.Properties.Stem
}
- return stem + c.BinaryProperties.Suffix
+ return stem + binary.Properties.Suffix
}
-func (c *CCBinary) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
- depNames = c.CCLinked.depNames(ctx, depNames)
+func (binary *binaryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
+ deps = binary.baseLinker.deps(ctx, deps)
if ctx.Device() {
- if c.Properties.Sdk_version == "" {
- if Bool(c.BinaryProperties.Static_executable) {
- depNames.CrtBegin = "crtbegin_static"
+ if !ctx.sdk() {
+ if Bool(binary.Properties.Static_executable) {
+ deps.CrtBegin = "crtbegin_static"
} else {
- depNames.CrtBegin = "crtbegin_dynamic"
+ deps.CrtBegin = "crtbegin_dynamic"
}
- depNames.CrtEnd = "crtend_android"
+ deps.CrtEnd = "crtend_android"
} else {
- if Bool(c.BinaryProperties.Static_executable) {
- depNames.CrtBegin = "ndk_crtbegin_static." + c.Properties.Sdk_version
+ if Bool(binary.Properties.Static_executable) {
+ deps.CrtBegin = "ndk_crtbegin_static." + ctx.sdkVersion()
} else {
- depNames.CrtBegin = "ndk_crtbegin_dynamic." + c.Properties.Sdk_version
+ deps.CrtBegin = "ndk_crtbegin_dynamic." + ctx.sdkVersion()
}
- depNames.CrtEnd = "ndk_crtend_android." + c.Properties.Sdk_version
+ deps.CrtEnd = "ndk_crtend_android." + ctx.sdkVersion()
}
- if Bool(c.BinaryProperties.Static_executable) {
- if c.stl(ctx) == "libc++_static" {
- depNames.StaticLibs = append(depNames.StaticLibs, "libm", "libc", "libdl")
+ if Bool(binary.Properties.Static_executable) {
+ if inList("libc++_static", deps.StaticLibs) {
+ deps.StaticLibs = append(deps.StaticLibs, "libm", "libc", "libdl")
}
// static libraries libcompiler_rt, libc and libc_nomalloc need to be linked with
// --start-group/--end-group along with libgcc. If they are in deps.StaticLibs,
// move them to the beginning of deps.LateStaticLibs
var groupLibs []string
- depNames.StaticLibs, groupLibs = filterList(depNames.StaticLibs,
+ deps.StaticLibs, groupLibs = filterList(deps.StaticLibs,
[]string{"libc", "libc_nomalloc", "libcompiler_rt"})
- depNames.LateStaticLibs = append(groupLibs, depNames.LateStaticLibs...)
+ deps.LateStaticLibs = append(groupLibs, deps.LateStaticLibs...)
}
}
- return depNames
+
+ if !Bool(binary.Properties.Static_executable) && inList("libc", deps.StaticLibs) {
+ ctx.ModuleErrorf("statically linking libc to dynamic executable, please remove libc\n" +
+ "from static libs or set static_executable: true")
+ }
+ return deps
}
-func NewCCBinary(binary *CCBinary, module CCModuleType,
- hod common.HostOrDeviceSupported, multilib common.Multilib,
- props ...interface{}) (blueprint.Module, []interface{}) {
-
- props = append(props, &binary.BinaryProperties)
-
- return newCCDynamic(&binary.CCLinked, module, hod, multilib, props...)
+func NewBinary(hod common.HostOrDeviceSupported) *Module {
+ module := newModule(hod, common.MultilibFirst)
+ module.compiler = &baseCompiler{}
+ module.linker = &binaryLinker{}
+ module.installer = &baseInstaller{
+ dir: "bin",
+ }
+ return module
}
-func CCBinaryFactory() (blueprint.Module, []interface{}) {
- module := &CCBinary{}
-
- return NewCCBinary(module, module, common.HostAndDeviceSupported, common.MultilibFirst)
+func binaryFactory() (blueprint.Module, []interface{}) {
+ module := NewBinary(common.HostAndDeviceSupported)
+ return module.Init()
}
-func (c *CCBinary) ModifyProperties(ctx CCModuleContext) {
+func (binary *binaryLinker) ModifyProperties(ctx ModuleContext) {
if ctx.Darwin() {
- c.BinaryProperties.Static_executable = proptools.BoolPtr(false)
+ binary.Properties.Static_executable = proptools.BoolPtr(false)
}
- if Bool(c.BinaryProperties.Static_executable) {
- c.dynamicProperties.VariantIsStaticBinary = true
+ if Bool(binary.Properties.Static_executable) {
+ binary.dynamicProperties.VariantIsStaticBinary = true
}
}
-func (c *CCBinary) flags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
- flags = c.CCLinked.flags(ctx, flags)
+func (binary *binaryLinker) flags(ctx ModuleContext, flags Flags) Flags {
+ flags = binary.baseLinker.flags(ctx, flags)
if ctx.Host() {
flags.LdFlags = append(flags.LdFlags, "-pie")
@@ -1611,7 +1679,7 @@
}
if ctx.Device() {
- if Bool(c.BinaryProperties.Static_executable) {
+ if Bool(binary.Properties.Static_executable) {
// Clang driver needs -static to create static executable.
// However, bionic/linker uses -shared to overwrite.
// Linker for x86 targets does not allow coexistance of -static and -shared,
@@ -1629,7 +1697,7 @@
} else {
linker := "/system/bin/linker"
if flags.Toolchain.Is64Bit() {
- linker = "/system/bin/linker64"
+ linker += "64"
}
flags.LdFlags = append(flags.LdFlags,
@@ -1648,86 +1716,69 @@
return flags
}
-func (c *CCBinary) compileModule(ctx common.AndroidModuleContext,
- flags CCFlags, deps CCPathDeps, objFiles common.Paths) {
+func (binary *binaryLinker) link(ctx ModuleContext,
+ flags Flags, deps PathDeps, objFiles common.Paths) common.Path {
- if !Bool(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")
+ outputFile := common.PathForModuleOut(ctx, binary.getStem(ctx)+flags.Toolchain.ExecutableSuffix())
+ if ctx.HostOrDevice().Host() {
+ binary.hostToolPath = common.OptionalPathForPath(outputFile)
}
+ ret := outputFile
- outputFile := common.PathForModuleOut(ctx, c.getStem(ctx)+flags.Toolchain.ExecutableSuffix())
- c.out = outputFile
- if c.BinaryProperties.Prefix_symbols != "" {
+ if binary.Properties.Prefix_symbols != "" {
afterPrefixSymbols := outputFile
- outputFile = common.PathForModuleOut(ctx, c.getStem(ctx)+".intermediate")
- TransformBinaryPrefixSymbols(ctx, c.BinaryProperties.Prefix_symbols, outputFile,
- ccFlagsToBuilderFlags(flags), afterPrefixSymbols)
+ outputFile = common.PathForModuleOut(ctx, binary.getStem(ctx)+".intermediate")
+ TransformBinaryPrefixSymbols(ctx, binary.Properties.Prefix_symbols, outputFile,
+ flagsToBuilderFlags(flags), afterPrefixSymbols)
}
var linkerDeps common.Paths
- TransformObjToDynamicBinary(ctx, objFiles, deps.SharedLibs, deps.StaticLibs,
+ sharedLibs := deps.SharedLibs
+ sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
+
+ TransformObjToDynamicBinary(ctx, objFiles, sharedLibs, deps.StaticLibs,
deps.LateStaticLibs, deps.WholeStaticLibs, linkerDeps, deps.CrtBegin, deps.CrtEnd, true,
- ccFlagsToBuilderFlags(flags), outputFile)
+ flagsToBuilderFlags(flags), outputFile)
+
+ return ret
}
-func (c *CCBinary) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
- c.installFile = ctx.InstallFile(common.PathForModuleInstall(ctx, "bin", c.Properties.Relative_install_path), c.out)
+func (binary *binaryLinker) HostToolPath() common.OptionalPath {
+ return binary.hostToolPath
}
-func (c *CCBinary) HostToolPath() common.OptionalPath {
- if c.HostOrDevice().Host() {
- return common.OptionalPathForPath(c.installFile)
- }
- return common.OptionalPath{}
-}
-
-func (c *CCBinary) binary() *CCBinary {
- return c
-}
-
-type testPerSrc interface {
- binary() *CCBinary
- testPerSrc() bool
-}
-
-var _ testPerSrc = (*CCTest)(nil)
-
func testPerSrcMutator(mctx common.AndroidBottomUpMutatorContext) {
- if test, ok := mctx.Module().(testPerSrc); ok {
- if test.testPerSrc() {
- testNames := make([]string, len(test.binary().Properties.Srcs))
- for i, src := range test.binary().Properties.Srcs {
- testNames[i] = strings.TrimSuffix(filepath.Base(src), filepath.Ext(src))
- }
- tests := mctx.CreateLocalVariations(testNames...)
- for i, src := range test.binary().Properties.Srcs {
- tests[i].(testPerSrc).binary().Properties.Srcs = []string{src}
- tests[i].(testPerSrc).binary().BinaryProperties.Stem = testNames[i]
+ if m, ok := mctx.Module().(*Module); ok {
+ if test, ok := m.linker.(*testLinker); ok {
+ if Bool(test.Properties.Test_per_src) {
+ testNames := make([]string, len(m.compiler.(*baseCompiler).Properties.Srcs))
+ for i, src := range m.compiler.(*baseCompiler).Properties.Srcs {
+ testNames[i] = strings.TrimSuffix(filepath.Base(src), filepath.Ext(src))
+ }
+ tests := mctx.CreateLocalVariations(testNames...)
+ for i, src := range m.compiler.(*baseCompiler).Properties.Srcs {
+ tests[i].(*Module).compiler.(*baseCompiler).Properties.Srcs = []string{src}
+ tests[i].(*Module).linker.(*testLinker).binaryLinker.Properties.Stem = testNames[i]
+ }
}
}
}
}
-type CCTestProperties struct {
- // if set, build against the gtest library. Defaults to true.
- Gtest bool
-
- // Create a separate binary for each source file. Useful when there is
- // global state that can not be torn down and reset between each test suite.
- Test_per_src *bool
+type testLinker struct {
+ binaryLinker
+ Properties TestLinkerProperties
}
-type CCTest struct {
- CCBinary
-
- TestProperties CCTestProperties
+func (test *testLinker) props() []interface{} {
+ return append(test.binaryLinker.props(), &test.Properties)
}
-func (c *CCTest) flags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
- flags = c.CCBinary.flags(ctx, flags)
- if !c.TestProperties.Gtest {
+func (test *testLinker) flags(ctx ModuleContext, flags Flags) Flags {
+ flags = test.binaryLinker.flags(ctx, flags)
+
+ if !test.Properties.Gtest {
return flags
}
@@ -1752,175 +1803,159 @@
return flags
}
-func (c *CCTest) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
- if c.TestProperties.Gtest {
- depNames.StaticLibs = append(depNames.StaticLibs, "libgtest_main", "libgtest")
+func (test *testLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
+ if test.Properties.Gtest {
+ deps.StaticLibs = append(deps.StaticLibs, "libgtest_main", "libgtest")
}
- depNames = c.CCBinary.depNames(ctx, depNames)
- return depNames
+ deps = test.binaryLinker.deps(ctx, deps)
+ return deps
}
-func (c *CCTest) InstallInData() bool {
- return true
+type testInstaller struct {
+ baseInstaller
}
-func (c *CCTest) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
- installDir := "nativetest"
- if flags.Toolchain.Is64Bit() {
- installDir = "nativetest64"
+func (installer *testInstaller) install(ctx ModuleContext, file common.Path) {
+ installer.dir = filepath.Join(installer.dir, ctx.ModuleName())
+ installer.dir64 = filepath.Join(installer.dir64, ctx.ModuleName())
+ installer.baseInstaller.install(ctx, file)
+}
+
+func NewTest(hod common.HostOrDeviceSupported) *Module {
+ module := newModule(hod, common.MultilibBoth)
+ module.compiler = &baseCompiler{}
+ linker := &testLinker{}
+ linker.Properties.Gtest = true
+ module.linker = linker
+ module.installer = &testInstaller{
+ baseInstaller: baseInstaller{
+ dir: "nativetest",
+ dir64: "nativetest64",
+ data: true,
+ },
}
- ctx.InstallFile(common.PathForModuleInstall(ctx, installDir, ctx.ModuleName()), c.out)
+ return module
}
-func (c *CCTest) testPerSrc() bool {
- return Bool(c.TestProperties.Test_per_src)
+func testFactory() (blueprint.Module, []interface{}) {
+ module := NewTest(common.HostAndDeviceSupported)
+ return module.Init()
}
-func NewCCTest(test *CCTest, module CCModuleType,
- hod common.HostOrDeviceSupported, props ...interface{}) (blueprint.Module, []interface{}) {
-
- props = append(props, &test.TestProperties)
-
- return NewCCBinary(&test.CCBinary, module, hod, common.MultilibBoth, props...)
+type benchmarkLinker struct {
+ binaryLinker
}
-func CCTestFactory() (blueprint.Module, []interface{}) {
- module := &CCTest{}
- module.TestProperties.Gtest = true
-
- return NewCCTest(module, module, common.HostAndDeviceSupported)
+func (benchmark *benchmarkLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
+ deps = benchmark.binaryLinker.deps(ctx, deps)
+ deps.StaticLibs = append(deps.StaticLibs, "libbenchmark", "libbase")
+ return deps
}
-type CCBenchmark struct {
- CCBinary
-}
-
-func (c *CCBenchmark) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
- depNames = c.CCBinary.depNames(ctx, depNames)
- depNames.StaticLibs = append(depNames.StaticLibs, "libbenchmark", "libbase")
- return depNames
-}
-
-func (c *CCBenchmark) InstallInData() bool {
- return true
-}
-
-func (c *CCBenchmark) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
- if ctx.Device() {
- installDir := "nativetest"
- if flags.Toolchain.Is64Bit() {
- installDir = "nativetest64"
- }
- ctx.InstallFile(common.PathForModuleInstall(ctx, installDir, ctx.ModuleName()), c.out)
- } else {
- c.CCBinary.installModule(ctx, flags)
+func NewBenchmark(hod common.HostOrDeviceSupported) *Module {
+ module := newModule(hod, common.MultilibFirst)
+ module.compiler = &baseCompiler{}
+ module.linker = &benchmarkLinker{}
+ module.installer = &baseInstaller{
+ dir: "nativetest",
+ dir64: "nativetest64",
+ data: true,
}
+ return module
}
-func NewCCBenchmark(test *CCBenchmark, module CCModuleType,
- hod common.HostOrDeviceSupported, props ...interface{}) (blueprint.Module, []interface{}) {
-
- return NewCCBinary(&test.CCBinary, module, hod, common.MultilibFirst, props...)
-}
-
-func CCBenchmarkFactory() (blueprint.Module, []interface{}) {
- module := &CCBenchmark{}
-
- return NewCCBenchmark(module, module, common.HostAndDeviceSupported)
+func benchmarkFactory() (blueprint.Module, []interface{}) {
+ module := NewBenchmark(common.HostAndDeviceSupported)
+ return module.Init()
}
//
// Static library
//
-func CCLibraryStaticFactory() (blueprint.Module, []interface{}) {
- module := &CCLibrary{}
- module.LibraryProperties.BuildStatic = true
-
- return NewCCLibrary(module, module, common.HostAndDeviceSupported)
+func libraryStaticFactory() (blueprint.Module, []interface{}) {
+ module := NewLibrary(common.HostAndDeviceSupported, false, true)
+ return module.Init()
}
//
// Shared libraries
//
-func CCLibrarySharedFactory() (blueprint.Module, []interface{}) {
- module := &CCLibrary{}
- module.LibraryProperties.BuildShared = true
-
- return NewCCLibrary(module, module, common.HostAndDeviceSupported)
+func librarySharedFactory() (blueprint.Module, []interface{}) {
+ module := NewLibrary(common.HostAndDeviceSupported, true, false)
+ return module.Init()
}
//
// Host static library
//
-func CCLibraryHostStaticFactory() (blueprint.Module, []interface{}) {
- module := &CCLibrary{}
- module.LibraryProperties.BuildStatic = true
-
- return NewCCLibrary(module, module, common.HostSupported)
+func libraryHostStaticFactory() (blueprint.Module, []interface{}) {
+ module := NewLibrary(common.HostSupported, false, true)
+ return module.Init()
}
//
// Host Shared libraries
//
-func CCLibraryHostSharedFactory() (blueprint.Module, []interface{}) {
- module := &CCLibrary{}
- module.LibraryProperties.BuildShared = true
-
- return NewCCLibrary(module, module, common.HostSupported)
+func libraryHostSharedFactory() (blueprint.Module, []interface{}) {
+ module := NewLibrary(common.HostSupported, true, false)
+ return module.Init()
}
//
// Host Binaries
//
-func CCBinaryHostFactory() (blueprint.Module, []interface{}) {
- module := &CCBinary{}
-
- return NewCCBinary(module, module, common.HostSupported, common.MultilibFirst)
+func binaryHostFactory() (blueprint.Module, []interface{}) {
+ module := NewBinary(common.HostSupported)
+ return module.Init()
}
//
// Host Tests
//
-func CCTestHostFactory() (blueprint.Module, []interface{}) {
- module := &CCTest{}
- return NewCCTest(module, module, common.HostSupported)
+func testHostFactory() (blueprint.Module, []interface{}) {
+ module := NewTest(common.HostSupported)
+ return module.Init()
}
//
// Host Benchmarks
//
-func CCBenchmarkHostFactory() (blueprint.Module, []interface{}) {
- module := &CCBenchmark{}
- return NewCCBinary(&module.CCBinary, module, common.HostSupported, common.MultilibFirst)
+func benchmarkHostFactory() (blueprint.Module, []interface{}) {
+ module := NewBenchmark(common.HostSupported)
+ return module.Init()
}
//
// Defaults
//
-type CCDefaults struct {
+type Defaults struct {
common.AndroidModuleBase
common.DefaultsModule
}
-func (*CCDefaults) GenerateAndroidBuildActions(ctx common.AndroidModuleContext) {
+func (*Defaults) GenerateAndroidBuildActions(ctx common.AndroidModuleContext) {
}
-func CCDefaultsFactory() (blueprint.Module, []interface{}) {
- module := &CCDefaults{}
+func defaultsFactory() (blueprint.Module, []interface{}) {
+ module := &Defaults{}
propertyStructs := []interface{}{
- &CCBaseProperties{},
- &CCLibraryProperties{},
- &CCBinaryProperties{},
- &CCTestProperties{},
- &CCUnusedProperties{},
+ &BaseProperties{},
+ &BaseCompilerProperties{},
+ &BaseLinkerProperties{},
+ &LibraryCompilerProperties{},
+ &LibraryLinkerProperties{},
+ &BinaryLinkerProperties{},
+ &TestLinkerProperties{},
+ &UnusedProperties{},
+ &StlProperties{},
}
_, propertyStructs = common.InitAndroidArchModule(module, common.HostAndDeviceDefault,
@@ -1933,27 +1968,35 @@
// Device libraries shipped with gcc
//
-type toolchainLibrary struct {
- CCLibrary
+type toolchainLibraryLinker struct {
+ baseLinker
}
-func (*toolchainLibrary) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
+var _ baseLinkerInterface = (*toolchainLibraryLinker)(nil)
+
+func (*toolchainLibraryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
// toolchain libraries can't have any dependencies
- return CCDeps{}
+ return deps
}
-func ToolchainLibraryFactory() (blueprint.Module, []interface{}) {
- module := &toolchainLibrary{}
+func (*toolchainLibraryLinker) buildStatic() bool {
+ return true
+}
- module.LibraryProperties.BuildStatic = true
+func (*toolchainLibraryLinker) buildShared() bool {
+ return false
+}
+
+func toolchainLibraryFactory() (blueprint.Module, []interface{}) {
+ module := newBaseModule(common.DeviceSupported, common.MultilibBoth)
+ module.compiler = &baseCompiler{}
+ module.linker = &toolchainLibraryLinker{}
module.Properties.Clang = proptools.BoolPtr(false)
-
- return newCCBase(&module.CCBase, module, common.DeviceSupported, common.MultilibBoth,
- &module.LibraryProperties)
+ return module.Init()
}
-func (c *toolchainLibrary) compileModule(ctx common.AndroidModuleContext,
- flags CCFlags, deps CCPathDeps, objFiles common.Paths) {
+func (library *toolchainLibraryLinker) link(ctx ModuleContext,
+ flags Flags, deps PathDeps, objFiles common.Paths) common.Path {
libName := ctx.ModuleName() + staticLibraryExtension
outputFile := common.PathForModuleOut(ctx, libName)
@@ -1962,15 +2005,11 @@
ctx.ModuleErrorf("toolchain_library must use GCC, not Clang")
}
- CopyGccLib(ctx, libName, ccFlagsToBuilderFlags(flags), outputFile)
-
- c.out = outputFile
+ CopyGccLib(ctx, libName, flagsToBuilderFlags(flags), outputFile)
ctx.CheckbuildFile(outputFile)
-}
-func (c *toolchainLibrary) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
- // Toolchain libraries do not get installed.
+ return outputFile
}
// NDK prebuilt libraries.
@@ -1994,95 +2033,94 @@
return dir.Join(ctx, name+ext)
}
-type ndkPrebuiltObject struct {
- ccObject
+type ndkPrebuiltObjectLinker struct {
+ objectLinker
}
-func (*ndkPrebuiltObject) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
+func (*ndkPrebuiltObjectLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
// NDK objects can't have any dependencies
- return CCDeps{}
+ return deps
}
-func NdkPrebuiltObjectFactory() (blueprint.Module, []interface{}) {
- module := &ndkPrebuiltObject{}
- return newCCBase(&module.CCBase, module, common.DeviceSupported, common.MultilibBoth)
+func ndkPrebuiltObjectFactory() (blueprint.Module, []interface{}) {
+ module := newBaseModule(common.DeviceSupported, common.MultilibBoth)
+ module.linker = &ndkPrebuiltObjectLinker{}
+ return module.Init()
}
-func (c *ndkPrebuiltObject) compileModule(ctx common.AndroidModuleContext, flags CCFlags,
- deps CCPathDeps, objFiles common.Paths) {
+func (c *ndkPrebuiltObjectLinker) link(ctx ModuleContext, flags Flags,
+ deps PathDeps, objFiles common.Paths) common.Path {
// A null build step, but it sets up the output path.
if !strings.HasPrefix(ctx.ModuleName(), "ndk_crt") {
ctx.ModuleErrorf("NDK prebuilts must have an ndk_crt prefixed name")
}
- c.out = common.OptionalPathForPath(ndkPrebuiltModuleToPath(ctx, flags.Toolchain, objectExtension, c.Properties.Sdk_version))
+ return ndkPrebuiltModuleToPath(ctx, flags.Toolchain, objectExtension, ctx.sdkVersion())
}
-func (c *ndkPrebuiltObject) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
- // Objects do not get installed.
+type ndkPrebuiltLibraryLinker struct {
+ libraryLinker
+ Properties struct {
+ Export_include_dirs []string `android:"arch_variant"`
+ }
}
-var _ ccObjectProvider = (*ndkPrebuiltObject)(nil)
+var _ baseLinkerInterface = (*ndkPrebuiltLibraryLinker)(nil)
+var _ exportedFlagsProducer = (*libraryLinker)(nil)
-type ndkPrebuiltLibrary struct {
- CCLibrary
+func (ndk *ndkPrebuiltLibraryLinker) props() []interface{} {
+ return []interface{}{&ndk.Properties}
}
-func (*ndkPrebuiltLibrary) depNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
+func (*ndkPrebuiltLibraryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
// NDK libraries can't have any dependencies
- return CCDeps{}
+ return deps
}
-func NdkPrebuiltLibraryFactory() (blueprint.Module, []interface{}) {
- module := &ndkPrebuiltLibrary{}
- module.LibraryProperties.BuildShared = true
- return NewCCLibrary(&module.CCLibrary, module, common.DeviceSupported)
+func ndkPrebuiltLibraryFactory() (blueprint.Module, []interface{}) {
+ module := newBaseModule(common.DeviceSupported, common.MultilibBoth)
+ linker := &ndkPrebuiltLibraryLinker{}
+ linker.dynamicProperties.BuildShared = true
+ module.linker = linker
+ return module.Init()
}
-func (c *ndkPrebuiltLibrary) compileModule(ctx common.AndroidModuleContext, flags CCFlags,
- deps CCPathDeps, objFiles common.Paths) {
+func (ndk *ndkPrebuiltLibraryLinker) link(ctx ModuleContext, flags Flags,
+ deps PathDeps, objFiles common.Paths) common.Path {
// A null build step, but it sets up the output path.
if !strings.HasPrefix(ctx.ModuleName(), "ndk_lib") {
ctx.ModuleErrorf("NDK prebuilts must have an ndk_lib prefixed name")
}
- includeDirs := common.PathsForModuleSrc(ctx, c.Properties.Export_include_dirs)
- c.exportFlags = []string{common.JoinWithPrefix(includeDirs.Strings(), "-isystem ")}
+ includeDirs := common.PathsForModuleSrc(ctx, ndk.Properties.Export_include_dirs)
+ ndk.exportFlags = []string{common.JoinWithPrefix(includeDirs.Strings(), "-isystem ")}
- c.out = ndkPrebuiltModuleToPath(ctx, flags.Toolchain, flags.Toolchain.ShlibSuffix(),
- c.Properties.Sdk_version)
-}
-
-func (c *ndkPrebuiltLibrary) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
- // NDK prebuilt libraries do not get installed.
+ return ndkPrebuiltModuleToPath(ctx, flags.Toolchain, flags.Toolchain.ShlibSuffix(),
+ ctx.sdkVersion())
}
// The NDK STLs are slightly different from the prebuilt system libraries:
// * Are not specific to each platform version.
// * The libraries are not in a predictable location for each STL.
-type ndkPrebuiltStl struct {
- ndkPrebuiltLibrary
+type ndkPrebuiltStlLinker struct {
+ ndkPrebuiltLibraryLinker
}
-type ndkPrebuiltStaticStl struct {
- ndkPrebuiltStl
+func ndkPrebuiltSharedStlFactory() (blueprint.Module, []interface{}) {
+ module := newBaseModule(common.DeviceSupported, common.MultilibBoth)
+ linker := &ndkPrebuiltStlLinker{}
+ linker.dynamicProperties.BuildShared = true
+ module.linker = linker
+ return module.Init()
}
-type ndkPrebuiltSharedStl struct {
- ndkPrebuiltStl
-}
-
-func NdkPrebuiltSharedStlFactory() (blueprint.Module, []interface{}) {
- module := &ndkPrebuiltSharedStl{}
- module.LibraryProperties.BuildShared = true
- return NewCCLibrary(&module.CCLibrary, module, common.DeviceSupported)
-}
-
-func NdkPrebuiltStaticStlFactory() (blueprint.Module, []interface{}) {
- module := &ndkPrebuiltStaticStl{}
- module.LibraryProperties.BuildStatic = true
- return NewCCLibrary(&module.CCLibrary, module, common.DeviceSupported)
+func ndkPrebuiltStaticStlFactory() (blueprint.Module, []interface{}) {
+ module := newBaseModule(common.DeviceSupported, common.MultilibBoth)
+ linker := &ndkPrebuiltStlLinker{}
+ linker.dynamicProperties.BuildStatic = true
+ module.linker = linker
+ return module.Init()
}
func getNdkStlLibDir(ctx common.AndroidModuleContext, toolchain Toolchain, stl string) common.SourcePath {
@@ -2106,49 +2144,53 @@
return common.PathForSource(ctx, "")
}
-func (c *ndkPrebuiltStl) compileModule(ctx common.AndroidModuleContext, flags CCFlags,
- deps CCPathDeps, objFiles common.Paths) {
+func (ndk *ndkPrebuiltStlLinker) link(ctx ModuleContext, flags Flags,
+ deps PathDeps, objFiles common.Paths) common.Path {
// A null build step, but it sets up the output path.
if !strings.HasPrefix(ctx.ModuleName(), "ndk_lib") {
ctx.ModuleErrorf("NDK prebuilts must have an ndk_lib prefixed name")
}
- includeDirs := common.PathsForModuleSrc(ctx, c.Properties.Export_include_dirs)
- c.exportFlags = []string{includeDirsToFlags(includeDirs)}
+ includeDirs := common.PathsForModuleSrc(ctx, ndk.Properties.Export_include_dirs)
+ ndk.exportFlags = []string{includeDirsToFlags(includeDirs)}
libName := strings.TrimPrefix(ctx.ModuleName(), "ndk_")
libExt := flags.Toolchain.ShlibSuffix()
- if c.LibraryProperties.BuildStatic {
+ if ndk.dynamicProperties.BuildStatic {
libExt = staticLibraryExtension
}
stlName := strings.TrimSuffix(libName, "_shared")
stlName = strings.TrimSuffix(stlName, "_static")
libDir := getNdkStlLibDir(ctx, flags.Toolchain, stlName)
- c.out = libDir.Join(ctx, libName+libExt)
+ return libDir.Join(ctx, libName+libExt)
}
func linkageMutator(mctx common.AndroidBottomUpMutatorContext) {
- if c, ok := mctx.Module().(ccLinkedInterface); ok {
- var modules []blueprint.Module
- if c.buildStatic() && c.buildShared() {
- modules = mctx.CreateLocalVariations("static", "shared")
- modules[0].(ccLinkedInterface).setStatic(true)
- modules[1].(ccLinkedInterface).setStatic(false)
- } else if c.buildStatic() {
- modules = mctx.CreateLocalVariations("static")
- modules[0].(ccLinkedInterface).setStatic(true)
- } else if c.buildShared() {
- modules = mctx.CreateLocalVariations("shared")
- modules[0].(ccLinkedInterface).setStatic(false)
- } else {
- panic(fmt.Errorf("ccLibrary %q not static or shared", mctx.ModuleName()))
- }
+ if m, ok := mctx.Module().(*Module); ok {
+ if m.linker != nil {
+ if linker, ok := m.linker.(baseLinkerInterface); ok {
+ var modules []blueprint.Module
+ if linker.buildStatic() && linker.buildShared() {
+ modules = mctx.CreateLocalVariations("static", "shared")
+ modules[0].(*Module).linker.(baseLinkerInterface).setStatic(true)
+ modules[1].(*Module).linker.(baseLinkerInterface).setStatic(false)
+ } else if linker.buildStatic() {
+ modules = mctx.CreateLocalVariations("static")
+ modules[0].(*Module).linker.(baseLinkerInterface).setStatic(true)
+ } else if linker.buildShared() {
+ modules = mctx.CreateLocalVariations("shared")
+ modules[0].(*Module).linker.(baseLinkerInterface).setStatic(false)
+ } else {
+ panic(fmt.Errorf("library %q not static or shared", mctx.ModuleName()))
+ }
- if _, ok := c.(ccLibraryInterface); ok {
- reuseFrom := modules[0].(ccLibraryInterface)
- for _, m := range modules {
- m.(ccLibraryInterface).setReuseFrom(reuseFrom)
+ if _, ok := m.compiler.(*libraryCompiler); ok {
+ reuseFrom := modules[0].(*Module).compiler.(*libraryCompiler)
+ for _, m := range modules {
+ m.(*Module).compiler.(*libraryCompiler).reuseFrom = reuseFrom
+ }
+ }
}
}
}
diff --git a/cc/stl.go b/cc/stl.go
new file mode 100644
index 0000000..580570d
--- /dev/null
+++ b/cc/stl.go
@@ -0,0 +1,198 @@
+// Copyright 2016 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cc
+
+import (
+ "android/soong/common"
+ "fmt"
+)
+
+type StlProperties struct {
+ // select the STL library to use. Possible values are "libc++", "libc++_static",
+ // "stlport", "stlport_static", "ndk", "libstdc++", or "none". Leave blank to select the
+ // default
+ Stl string
+
+ SelectedStl string `blueprint:"mutated"`
+}
+
+type stlFeature struct {
+ Properties StlProperties
+}
+
+var _ feature = (*stlFeature)(nil)
+
+func (stl *stlFeature) props() []interface{} {
+ return []interface{}{&stl.Properties}
+}
+
+func (stl *stlFeature) begin(ctx BaseModuleContext) {
+ stl.Properties.SelectedStl = func() string {
+ if ctx.sdk() && ctx.Device() {
+ switch stl.Properties.Stl {
+ case "":
+ return "ndk_system"
+ case "c++_shared", "c++_static",
+ "stlport_shared", "stlport_static",
+ "gnustl_static":
+ return "ndk_lib" + stl.Properties.Stl
+ default:
+ ctx.ModuleErrorf("stl: %q is not a supported STL with sdk_version set", stl.Properties.Stl)
+ return ""
+ }
+ } else if ctx.HostType() == common.Windows {
+ switch stl.Properties.Stl {
+ case "libc++", "libc++_static", "libstdc++", "":
+ // libc++ is not supported on mingw
+ return "libstdc++"
+ case "none":
+ return ""
+ default:
+ ctx.ModuleErrorf("stl: %q is not a supported STL", stl.Properties.Stl)
+ return ""
+ }
+ } else {
+ switch stl.Properties.Stl {
+ case "libc++", "libc++_static",
+ "libstdc++":
+ return stl.Properties.Stl
+ case "none":
+ return ""
+ case "":
+ if ctx.static() {
+ return "libc++_static"
+ } else {
+ return "libc++"
+ }
+ default:
+ ctx.ModuleErrorf("stl: %q is not a supported STL", stl.Properties.Stl)
+ return ""
+ }
+ }
+ }()
+}
+
+func (stl *stlFeature) deps(ctx BaseModuleContext, deps Deps) Deps {
+ switch stl.Properties.SelectedStl {
+ case "libstdc++":
+ if ctx.Device() {
+ deps.SharedLibs = append(deps.SharedLibs, stl.Properties.SelectedStl)
+ }
+ case "libc++", "libc++_static":
+ if stl.Properties.SelectedStl == "libc++" {
+ deps.SharedLibs = append(deps.SharedLibs, stl.Properties.SelectedStl)
+ } else {
+ deps.StaticLibs = append(deps.StaticLibs, stl.Properties.SelectedStl)
+ }
+ if ctx.Device() {
+ if ctx.Arch().ArchType == common.Arm {
+ deps.StaticLibs = append(deps.StaticLibs, "libunwind_llvm")
+ }
+ if ctx.staticBinary() {
+ deps.StaticLibs = append(deps.StaticLibs, "libdl")
+ } else {
+ deps.SharedLibs = append(deps.SharedLibs, "libdl")
+ }
+ }
+ case "":
+ // None or error.
+ case "ndk_system":
+ // TODO: Make a system STL prebuilt for the NDK.
+ // The system STL doesn't have a prebuilt (it uses the system's libstdc++), but it does have
+ // its own includes. The includes are handled in CCBase.Flags().
+ deps.SharedLibs = append([]string{"libstdc++"}, deps.SharedLibs...)
+ case "ndk_libc++_shared", "ndk_libstlport_shared":
+ deps.SharedLibs = append(deps.SharedLibs, stl.Properties.SelectedStl)
+ case "ndk_libc++_static", "ndk_libstlport_static", "ndk_libgnustl_static":
+ deps.StaticLibs = append(deps.StaticLibs, stl.Properties.SelectedStl)
+ default:
+ panic(fmt.Errorf("Unknown stl: %q", stl.Properties.SelectedStl))
+ }
+
+ return deps
+}
+
+func (stl *stlFeature) flags(ctx ModuleContext, flags Flags) Flags {
+ switch stl.Properties.SelectedStl {
+ case "libc++", "libc++_static":
+ flags.CFlags = append(flags.CFlags, "-D_USING_LIBCXX")
+ if ctx.Host() {
+ flags.CppFlags = append(flags.CppFlags, "-nostdinc++")
+ flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
+ flags.LdFlags = append(flags.LdFlags, "-lpthread", "-lm")
+ if ctx.staticBinary() {
+ flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.HostType()]...)
+ } else {
+ flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.HostType()]...)
+ }
+ } else {
+ if ctx.Arch().ArchType == common.Arm {
+ flags.LdFlags = append(flags.LdFlags, "-Wl,--exclude-libs,libunwind_llvm.a")
+ }
+ }
+ case "libstdc++":
+ // Using bionic's basic libstdc++. Not actually an STL. Only around until the
+ // tree is in good enough shape to not need it.
+ // Host builds will use GNU libstdc++.
+ if ctx.Device() {
+ flags.CFlags = append(flags.CFlags, "-I"+common.PathForSource(ctx, "bionic/libstdc++/include").String())
+ } else {
+ // Host builds will use the system C++. libc++ on Darwin, GNU libstdc++ everywhere else
+ flags.CppFlags = append(flags.CppFlags, flags.Toolchain.SystemCppCppflags())
+ flags.LdFlags = append(flags.LdFlags, flags.Toolchain.SystemCppLdflags())
+ }
+ case "ndk_system":
+ ndkSrcRoot := common.PathForSource(ctx, "prebuilts/ndk/current/sources/cxx-stl/system/include")
+ flags.CFlags = append(flags.CFlags, "-isystem "+ndkSrcRoot.String())
+ case "ndk_libc++_shared", "ndk_libc++_static":
+ // TODO(danalbert): This really shouldn't be here...
+ flags.CppFlags = append(flags.CppFlags, "-std=c++11")
+ case "ndk_libstlport_shared", "ndk_libstlport_static", "ndk_libgnustl_static":
+ // Nothing
+ case "":
+ // None or error.
+ if ctx.Host() {
+ flags.CppFlags = append(flags.CppFlags, "-nostdinc++")
+ flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
+ if ctx.staticBinary() {
+ flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.HostType()]...)
+ } else {
+ flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.HostType()]...)
+ }
+ }
+ default:
+ panic(fmt.Errorf("Unknown stl: %q", stl.Properties.SelectedStl))
+ }
+
+ return flags
+}
+
+var hostDynamicGccLibs, hostStaticGccLibs map[common.HostType][]string
+
+func init() {
+ hostDynamicGccLibs = map[common.HostType][]string{
+ common.Linux: []string{"-lgcc_s", "-lgcc", "-lc", "-lgcc_s", "-lgcc"},
+ common.Darwin: []string{"-lc", "-lSystem"},
+ common.Windows: []string{"-lmsvcr110", "-lmingw32", "-lgcc", "-lmoldname",
+ "-lmingwex", "-lmsvcrt", "-ladvapi32", "-lshell32", "-luser32",
+ "-lkernel32", "-lmingw32", "-lgcc", "-lmoldname", "-lmingwex",
+ "-lmsvcrt"},
+ }
+ hostStaticGccLibs = map[common.HostType][]string{
+ common.Linux: []string{"-Wl,--start-group", "-lgcc", "-lgcc_eh", "-lc", "-Wl,--end-group"},
+ common.Darwin: []string{"NO_STATIC_HOST_BINARIES_ON_DARWIN"},
+ common.Windows: []string{"NO_STATIC_HOST_BINARIES_ON_WINDOWS"},
+ }
+}
diff --git a/cc/util.go b/cc/util.go
index 2fc717b..c083744 100644
--- a/cc/util.go
+++ b/cc/util.go
@@ -72,7 +72,7 @@
return matches[1], nil
}
-func ccFlagsToBuilderFlags(in CCFlags) builderFlags {
+func flagsToBuilderFlags(in Flags) builderFlags {
return builderFlags{
globalFlags: strings.Join(in.GlobalFlags, " "),
asFlags: strings.Join(in.AsFlags, " "),
diff --git a/common/androidmk.go b/common/androidmk.go
index 9628a10..49380e0 100644
--- a/common/androidmk.go
+++ b/common/androidmk.go
@@ -39,10 +39,11 @@
type AndroidMkData struct {
Class string
OutputFile OptionalPath
+ Disabled bool
Custom func(w io.Writer, name, prefix string) error
- Extra func(w io.Writer, outputFile Path) error
+ Extra []func(w io.Writer, outputFile Path) error
}
func AndroidMkSingleton() blueprint.Singleton {
@@ -166,6 +167,10 @@
return data.Custom(w, name, prefix)
}
+ if data.Disabled {
+ return nil
+ }
+
if !data.OutputFile.Valid() {
return err
}
@@ -189,8 +194,8 @@
fmt.Fprintln(w, "LOCAL_MODULE_TARGET_ARCH :=", archStr)
}
- if data.Extra != nil {
- err = data.Extra(w, data.OutputFile.Path())
+ for _, extra := range data.Extra {
+ err = extra(w, data.OutputFile.Path())
if err != nil {
return err
}
diff --git a/common/arch.go b/common/arch.go
index ee1cfae..0e9c7fe 100644
--- a/common/arch.go
+++ b/common/arch.go
@@ -557,12 +557,14 @@
for _, properties := range base.generalProperties {
propertiesValue := reflect.ValueOf(properties)
if propertiesValue.Kind() != reflect.Ptr {
- panic("properties must be a pointer to a struct")
+ panic(fmt.Errorf("properties must be a pointer to a struct, got %T",
+ propertiesValue.Interface()))
}
propertiesValue = propertiesValue.Elem()
if propertiesValue.Kind() != reflect.Struct {
- panic("properties must be a pointer to a struct")
+ panic(fmt.Errorf("properties must be a pointer to a struct, got %T",
+ propertiesValue.Interface()))
}
archProperties := &archProperties{}