Refactor cc dependencies to avoid duplication

CC module dependencies need to be handled in both AndroidDynamicDependencies
and GenerateAndroidBuildActions.  Replace handling them in both with
splitting out individual functions to list each type of dependency,
and then call them from both AndroidDynamicDependencies and collectDeps
in GenerateAndroidBuildActions.

Change-Id: If8104f6ec4846a389a41ab599b1167bcf47b45b7

cc/cc.go

@@ -227,12 +227,11 @@ type unusedProperties struct {
 type CCModuleType interface {
 	common.AndroidModule
 
-	// Modify the ccFlags that are specific to this _type_ of module
+	// Modify the ccFlags
-	ModuleTypeFlags(common.AndroidModuleContext, CCFlags) CCFlags
+	Flags(common.AndroidModuleContext, CCFlags) CCFlags
 
-	// Create a ccDeps struct that collects the module dependency info.  Can also
+	// Return list of dependency names for use in AndroidDynamicDependencies and in depsToPaths
-	// modify ccFlags in order to add dependency include directories, etc.
+	DepNames(common.AndroidBaseContext, CCDeps) CCDeps
-	collectDeps(common.AndroidModuleContext, CCFlags) (CCDeps, CCFlags)
 
 	// Compile objects into final module
 	compileModule(common.AndroidModuleContext, CCFlags, CCDeps, []string)
@@ -247,6 +246,8 @@ type CCModuleType interface {
 type CCDeps struct {
 	StaticLibs, SharedLibs, LateStaticLibs, WholeStaticLibs, ObjFiles, IncludeDirs []string
 
+	WholeStaticLibObjFiles []string
+
 	CrtBegin, CrtEnd string
 }
 
@@ -262,9 +263,6 @@ type CCFlags struct {
 	Nocrt       bool
 	Toolchain   Toolchain
 	Clang       bool
-
-	ExtraStaticLibs []string
-	ExtraSharedLibs []string
 }
 
 // ccBase contains the properties and members used by all C/C++ module types, and implements
@@ -296,17 +294,17 @@ func (c *ccBase) GenerateAndroidBuildActions(ctx common.AndroidModuleContext) {
 		return
 	}
 
-	flags := c.flags(ctx, toolchain)
+	flags := c.collectFlags(ctx, toolchain)
 	if ctx.Failed() {
 		return
 	}
 
-	flags = c.addStlFlags(ctx, flags)
+	depNames := c.module.DepNames(ctx, CCDeps{})
 	if ctx.Failed() {
 		return
 	}
 
-	deps, flags := c.ccModuleType().collectDeps(ctx, flags)
+	deps := c.depsToPaths(ctx, depNames)
 	if ctx.Failed() {
 		return
 	}
@@ -352,21 +350,54 @@ func (c *ccBase) findToolchain(ctx common.AndroidModuleContext) Toolchain {
 	return factory(arch.ArchVariant, arch.CpuVariant)
 }
 
-func (c *ccBase) ModuleTypeFlags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
+func (c *ccBase) DepNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
-	return flags
+	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...)
+
+	stl := c.stl(ctx)
+	if ctx.Failed() {
+		return depNames
+	}
+
+	switch stl {
+	case "libc++", "libstdc++":
+		depNames.SharedLibs = append(depNames.SharedLibs, stl)
+	case "libc++_static":
+		depNames.StaticLibs = append(depNames.StaticLibs, stl)
+	case "stlport":
+		depNames.SharedLibs = append(depNames.SharedLibs, "libstdc++", "libstlport")
+	case "stlport_static":
+		depNames.StaticLibs = append(depNames.StaticLibs, "libstdc++", "libstlport_static")
+	}
+
+	return depNames
 }
 
 func (c *ccBase) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
-	ctx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, c.properties.Whole_static_libs...)
+	depNames := CCDeps{}
-	ctx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, c.properties.Static_libs...)
+	depNames = c.module.DepNames(ctx, depNames)
-	ctx.AddVariationDependencies([]blueprint.Variation{{"link", "shared"}}, c.properties.Shared_libs...)
+	staticLibs := depNames.WholeStaticLibs
+	staticLibs = append(staticLibs, depNames.StaticLibs...)
+	staticLibs = append(staticLibs, depNames.LateStaticLibs...)
+	ctx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, staticLibs...)
 
-	return nil
+	ctx.AddVariationDependencies([]blueprint.Variation{{"link", "shared"}}, depNames.SharedLibs...)
+
+	ret := append([]string(nil), depNames.ObjFiles...)
+	if depNames.CrtBegin != "" {
+		ret = append(ret, depNames.CrtBegin)
+	}
+	if depNames.CrtEnd != "" {
+		ret = append(ret, depNames.CrtEnd)
+	}
+
+	return ret
 }
 
 // Create a ccFlags struct that collects the compile flags from global values,
 // per-target values, module type values, and per-module Blueprints properties
-func (c *ccBase) flags(ctx common.AndroidModuleContext, toolchain Toolchain) CCFlags {
+func (c *ccBase) collectFlags(ctx common.AndroidModuleContext, toolchain Toolchain) CCFlags {
 	flags := CCFlags{
 		CFlags:     c.properties.Cflags,
 		CppFlags:   c.properties.Cppflags,
@@ -487,7 +518,7 @@ func (c *ccBase) flags(ctx common.AndroidModuleContext, toolchain Toolchain) CCF
 		}
 	}
 
-	flags = c.ccModuleType().ModuleTypeFlags(ctx, flags)
+	flags = c.ccModuleType().Flags(ctx, flags)
 
 	// Optimization to reduce size of build.ninja
 	// Replace the long list of flags for each file with a module-local variable
@@ -501,17 +532,28 @@ func (c *ccBase) flags(ctx common.AndroidModuleContext, toolchain Toolchain) CCF
 	return flags
 }
 
-// Modify ccFlags structs with STL library info
+func (c *ccBase) stl(ctx common.AndroidBaseContext) string {
-func (c *ccBase) addStlFlags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
+	switch c.properties.Stl {
-	if !c.properties.No_default_compiler_flags {
+	case "libc++", "libc++_static",
-		stl := "libc++" // TODO: mingw needs libstdc++
+		"stlport", "stlport_static",
-		if c.properties.Stl != "" {
+		"libstdc++":
-			stl = c.properties.Stl
+		return c.properties.Stl
+	case "none":
+		return ""
+	case "":
+		return "libc++" // TODO: mingw needs libstdc++
+	case "ndk":
+		panic("TODO: stl: ndk")
+	default:
+		ctx.ModuleErrorf("stl: %q is not a supported STL", c.properties.Stl)
+		return ""
+	}
 }
 
-		stlStatic := false
+func (c *ccBase) Flags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
-		if strings.HasSuffix(stl, "_static") {
+	stl := c.stl(ctx)
-			stlStatic = true
+	if ctx.Failed() {
+		return flags
 	}
 
 	switch stl {
@@ -523,22 +565,12 @@ func (c *ccBase) addStlFlags(ctx common.AndroidModuleContext, flags CCFlags) CCF
 			flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
 			flags.LdLibs = append(flags.LdLibs, "-lc", "-lm", "-lpthread")
 		}
-			if stlStatic {
-				flags.ExtraStaticLibs = append(flags.ExtraStaticLibs, "libc++_static")
-			} else {
-				flags.ExtraSharedLibs = append(flags.ExtraSharedLibs, "libc++")
-			}
 	case "stlport", "stlport_static":
 		if ctx.Device() {
 			flags.IncludeDirs = append(flags.IncludeDirs,
 				"${SrcDir}/external/stlport/stlport",
 				"${SrcDir}/bionic/libstdc++/include",
 				"${SrcDir}/bionic")
-				if stlStatic {
-					flags.ExtraStaticLibs = append(flags.ExtraStaticLibs, "libstdc++", "libstlport_static")
-				} else {
-					flags.ExtraSharedLibs = append(flags.ExtraSharedLibs, "libstdc++", "libstlport")
-				}
 		}
 	case "ndk":
 		panic("TODO")
@@ -548,19 +580,17 @@ func (c *ccBase) addStlFlags(ctx common.AndroidModuleContext, flags CCFlags) CCF
 		// Host builds will use GNU libstdc++.
 		if ctx.Device() {
 			flags.IncludeDirs = append(flags.IncludeDirs, "${SrcDir}/bionic/libstdc++/include")
-				flags.ExtraSharedLibs = append(flags.ExtraSharedLibs, "libstdc++")
 		}
-		case "none":
+	case "":
 		if ctx.Host() {
 			flags.CppFlags = append(flags.CppFlags, "-nostdinc++")
 			flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
 			flags.LdLibs = append(flags.LdLibs, "-lc", "-lm")
 		}
 	default:
-			ctx.ModuleErrorf("stl: %q is not a supported STL", stl)
+		panic(fmt.Errorf("Unknown stl: %q", stl))
 	}
 
-	}
 	return flags
 }
 
@@ -611,7 +641,7 @@ func (c *ccBase) outputFile() string {
 	return ""
 }
 
-func (c *ccBase) collectDepsFromList(ctx common.AndroidModuleContext,
+func (c *ccBase) depsToPathsFromList(ctx common.AndroidModuleContext,
 	names []string) (modules []common.AndroidModule,
 	outputFiles []string, exportedIncludeDirs []string) {
 
@@ -665,21 +695,54 @@ func (c *ccBase) collectDepsFromList(ctx common.AndroidModuleContext,
 	return modules, outputFiles, exportedIncludeDirs
 }
 
-func (c *ccBase) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
+// Convert depenedency names to paths.  Takes a CCDeps containing names and returns a CCDeps
-	var deps CCDeps
+// containing paths
+func (c *ccBase) depsToPaths(ctx common.AndroidModuleContext, depNames CCDeps) CCDeps {
+	var depPaths CCDeps
 	var newIncludeDirs []string
 
-	wholeStaticLibNames := c.properties.Whole_static_libs
+	var wholeStaticLibModules []common.AndroidModule
-	_, deps.WholeStaticLibs, newIncludeDirs = c.collectDepsFromList(ctx, wholeStaticLibNames)
 
-	deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
+	wholeStaticLibModules, depPaths.WholeStaticLibs, newIncludeDirs =
+		c.depsToPathsFromList(ctx, depNames.WholeStaticLibs)
+	depPaths.IncludeDirs = append(depPaths.IncludeDirs, newIncludeDirs...)
 
-	staticLibNames := c.properties.Static_libs
+	for _, m := range wholeStaticLibModules {
-	staticLibNames = append(staticLibNames, flags.ExtraStaticLibs...)
+		if staticLib, ok := m.(ccLibraryInterface); ok && staticLib.static() {
-	_, deps.StaticLibs, newIncludeDirs = c.collectDepsFromList(ctx, staticLibNames)
+			depPaths.WholeStaticLibObjFiles =
-	deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
+				append(depPaths.WholeStaticLibObjFiles, staticLib.allObjFiles()...)
+		} else {
+			ctx.ModuleErrorf("module %q not a static library", ctx.OtherModuleName(m))
+		}
+	}
 
-	return deps, flags
+	_, depPaths.StaticLibs, newIncludeDirs = c.depsToPathsFromList(ctx, depNames.StaticLibs)
+	depPaths.IncludeDirs = append(depPaths.IncludeDirs, newIncludeDirs...)
+
+	_, depPaths.LateStaticLibs, newIncludeDirs = c.depsToPathsFromList(ctx, depNames.LateStaticLibs)
+	depPaths.IncludeDirs = append(depPaths.IncludeDirs, newIncludeDirs...)
+
+	_, depPaths.SharedLibs, newIncludeDirs = c.depsToPathsFromList(ctx, depNames.SharedLibs)
+	depPaths.IncludeDirs = append(depPaths.IncludeDirs, newIncludeDirs...)
+
+	ctx.VisitDirectDeps(func(m blueprint.Module) {
+		if obj, ok := m.(*ccObject); ok {
+			otherName := ctx.OtherModuleName(m)
+			if otherName == depNames.CrtBegin {
+				if !c.properties.Nocrt {
+					depPaths.CrtBegin = obj.outputFile()
+				}
+			} else if otherName == depNames.CrtEnd {
+				if !c.properties.Nocrt {
+					depPaths.CrtEnd = obj.outputFile()
+				}
+			} else {
+				depPaths.ObjFiles = append(depPaths.ObjFiles, obj.outputFile())
+			}
+		}
+	})
+
+	return depPaths
 }
 
 // ccDynamic contains the properties and members used by shared libraries and dynamic executables
@@ -710,85 +773,17 @@ func (c *ccDynamic) systemSharedLibs(ctx common.AndroidBaseContext) []string {
 	return c.properties.System_shared_libs
 }
 
-var (
+func (c *ccDynamic) DepNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
-	stlSharedLibs     = []string{"libc++", "libstlport", "libstdc++"}
+	depNames = c.ccBase.DepNames(ctx, depNames)
-	stlSharedHostLibs = []string{"libc++"}
-	stlStaticLibs     = []string{"libc++_static", "libstlport_static", "libstdc++"}
-	stlStaticHostLibs = []string{"libc++_static"}
-)
-
-func (c *ccDynamic) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
-	deps := c.ccBase.AndroidDynamicDependencies(ctx)
 
 	if ctx.Device() {
-		ctx.AddVariationDependencies([]blueprint.Variation{{"link", "shared"}}, c.systemSharedLibs(ctx)...)
+		depNames.StaticLibs = append(depNames.StaticLibs, "libcompiler_rt-extras")
-		ctx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}},
-			"libcompiler_rt-extras",
-			"libgcov",
-			"libatomic",
-			"libgcc")
-
-		if c.properties.Stl != "none" {
-			ctx.AddVariationDependencies([]blueprint.Variation{{"link", "shared"}}, stlSharedLibs...)
-			ctx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, stlStaticLibs...)
-		}
-	} else {
-		if c.properties.Stl != "none" {
-			ctx.AddVariationDependencies([]blueprint.Variation{{"link", "shared"}}, stlSharedHostLibs...)
-			ctx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, stlStaticHostLibs...)
-		}
-	}
-
-	return deps
-}
-
-func (c *ccDynamic) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
-	var newIncludeDirs []string
-
-	deps, flags := c.ccBase.collectDeps(ctx, flags)
-
-	systemSharedLibs := c.systemSharedLibs(ctx)
-	sharedLibNames := make([]string, 0, len(c.properties.Shared_libs)+len(systemSharedLibs)+
-		len(flags.ExtraSharedLibs))
-	sharedLibNames = append(sharedLibNames, c.properties.Shared_libs...)
-	sharedLibNames = append(sharedLibNames, systemSharedLibs...)
-	sharedLibNames = append(sharedLibNames, flags.ExtraSharedLibs...)
-	_, deps.SharedLibs, newIncludeDirs = c.collectDepsFromList(ctx, sharedLibNames)
-	deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
-
-	if ctx.Device() {
-		var staticLibs []string
-		staticLibNames := []string{"libcompiler_rt-extras"}
-		_, staticLibs, newIncludeDirs = c.collectDepsFromList(ctx, staticLibNames)
-		deps.StaticLibs = append(deps.StaticLibs, staticLibs...)
-		deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
-
 		// libgcc and libatomic have to be last on the command line
-		staticLibNames = []string{"libgcov", "libatomic", "libgcc"}
+		depNames.LateStaticLibs = append(depNames.LateStaticLibs, "libgcov", "libatomic", "libgcc")
-		_, staticLibs, newIncludeDirs = c.collectDepsFromList(ctx, staticLibNames)
+		depNames.SharedLibs = append(depNames.SharedLibs, c.systemSharedLibs(ctx)...)
-		deps.LateStaticLibs = append(deps.LateStaticLibs, staticLibs...)
-		deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
 	}
 
-	ctx.VisitDirectDeps(func(m blueprint.Module) {
+	return depNames
-		if obj, ok := m.(*ccObject); ok {
-			otherName := ctx.OtherModuleName(m)
-			if strings.HasPrefix(otherName, "crtbegin") {
-				if !c.properties.Nocrt {
-					deps.CrtBegin = obj.outputFile()
-				}
-			} else if strings.HasPrefix(otherName, "crtend") {
-				if !c.properties.Nocrt {
-					deps.CrtEnd = obj.outputFile()
-				}
-			} else {
-				ctx.ModuleErrorf("object module type only support for crtbegin and crtend, found %q",
-					ctx.OtherModuleName(m))
-			}
-		}
-	})
-
-	return deps, flags
 }
 
 type ccExportedIncludeDirsProducer interface {
@@ -860,43 +855,18 @@ func CCLibraryFactory() (blueprint.Module, []interface{}) {
 	return NewCCLibrary(module, module, common.HostAndDeviceSupported)
 }
 
-func (c *CCLibrary) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
+func (c *CCLibrary) DepNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
-	if c.LibraryProperties.IsShared {
+	if c.shared() {
-		deps := c.ccDynamic.AndroidDynamicDependencies(ctx)
+		depNames = c.ccDynamic.DepNames(ctx, depNames)
 		if ctx.Device() {
-			deps = append(deps, "crtbegin_so", "crtend_so")
+			depNames.CrtBegin = "crtbegin_so"
+			depNames.CrtEnd = "crtend_so"
 		}
-		return deps
 	} else {
-		return c.ccBase.AndroidDynamicDependencies(ctx)
+		depNames = c.ccBase.DepNames(ctx, depNames)
-	}
 	}
 
-func (c *CCLibrary) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
+	return depNames
-	if c.LibraryProperties.IsStatic {
-		deps, flags := c.ccBase.collectDeps(ctx, flags)
-		wholeStaticLibNames := c.properties.Whole_static_libs
-		wholeStaticLibs, _, _ := c.collectDepsFromList(ctx, wholeStaticLibNames)
-
-		for _, m := range wholeStaticLibs {
-			if staticLib, ok := m.(ccLibraryInterface); ok && staticLib.static() {
-				deps.ObjFiles = append(deps.ObjFiles, staticLib.allObjFiles()...)
-			} else {
-				ctx.ModuleErrorf("module %q not a static library", ctx.OtherModuleName(m))
-			}
-		}
-
-		// Collect exported includes from shared lib dependencies
-		sharedLibNames := c.properties.Shared_libs
-		_, _, newIncludeDirs := c.collectDepsFromList(ctx, sharedLibNames)
-		deps.IncludeDirs = append(deps.IncludeDirs, newIncludeDirs...)
-
-		return deps, flags
-	} else if c.LibraryProperties.IsShared {
-		return c.ccDynamic.collectDeps(ctx, flags)
-	} else {
-		panic("Not shared or static")
-	}
 }
 
 func (c *CCLibrary) outputFile() string {
@@ -911,7 +881,9 @@ func (c *CCLibrary) exportedIncludeDirs() []string {
 	return c.exportIncludeDirs
 }
 
-func (c *CCLibrary) ModuleTypeFlags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
+func (c *CCLibrary) Flags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
+	flags = c.ccDynamic.Flags(ctx, flags)
+
 	flags.CFlags = append(flags.CFlags, "-fPIC")
 
 	if c.LibraryProperties.IsShared {
@@ -944,33 +916,7 @@ func (c *CCLibrary) compileStaticLibrary(ctx common.AndroidModuleContext,
 		c.LibraryProperties.Static.Srcs)
 
 	objFiles = append(objFiles, objFilesStatic...)
-
+	objFiles = append(objFiles, deps.WholeStaticLibObjFiles...)
-	var includeDirs []string
-
-	wholeStaticLibNames := c.properties.Whole_static_libs
-	wholeStaticLibs, _, newIncludeDirs := c.collectDepsFromList(ctx, wholeStaticLibNames)
-	includeDirs = append(includeDirs, newIncludeDirs...)
-
-	for _, m := range wholeStaticLibs {
-		if staticLib, ok := m.(ccLibraryInterface); ok && staticLib.static() {
-			objFiles = append(objFiles, staticLib.allObjFiles()...)
-		} else {
-			ctx.ModuleErrorf("module %q not a static library", ctx.OtherModuleName(m))
-		}
-	}
-
-	staticLibNames := c.properties.Static_libs
-	_, _, newIncludeDirs = c.collectDepsFromList(ctx, staticLibNames)
-	includeDirs = append(includeDirs, newIncludeDirs...)
-
-	ctx.VisitDirectDeps(func(m blueprint.Module) {
-		if obj, ok := m.(*ccObject); ok {
-			otherName := ctx.OtherModuleName(m)
-			if !strings.HasPrefix(otherName, "crtbegin") && !strings.HasPrefix(otherName, "crtend") {
-				objFiles = append(objFiles, obj.outputFile())
-			}
-		}
-	})
 
 	outputFile := filepath.Join(common.ModuleOutDir(ctx), ctx.ModuleName()+staticLibraryExtension)
 
@@ -1063,17 +1009,9 @@ func (*ccObject) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerMod
 	return nil
 }
 
-func (c *ccObject) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
+func (*ccObject) DepNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
-	deps, flags := c.ccBase.collectDeps(ctx, flags)
+	// object files can't have any dynamic dependencies
-	ctx.VisitDirectDeps(func(m blueprint.Module) {
+	return CCDeps{}
-		if obj, ok := m.(*ccObject); ok {
-			deps.ObjFiles = append(deps.ObjFiles, obj.outputFile())
-		} else {
-			ctx.ModuleErrorf("Unknown module type for dependency %q", ctx.OtherModuleName(m))
-		}
-	})
-
-	return deps, flags
 }
 
 func (c *ccObject) compileModule(ctx common.AndroidModuleContext,
@@ -1128,16 +1066,17 @@ func (c *CCBinary) getStem(ctx common.AndroidModuleContext) string {
 	return ctx.ModuleName()
 }
 
-func (c *CCBinary) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
+func (c *CCBinary) DepNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
-	deps := c.ccDynamic.AndroidDynamicDependencies(ctx)
+	depNames = c.ccDynamic.DepNames(ctx, depNames)
 	if ctx.Device() {
 		if c.BinaryProperties.Static_executable {
-			deps = append(deps, "crtbegin_static", "crtend_android")
+			depNames.CrtBegin = "crtbegin_static"
 		} else {
-			deps = append(deps, "crtbegin_dynamic", "crtend_android")
+			depNames.CrtBegin = "crtbegin_dynamic"
 		}
+		depNames.CrtEnd = "crtend_android"
 	}
-	return deps
+	return depNames
 }
 
 func NewCCBinary(binary *CCBinary, module CCModuleType,
@@ -1153,7 +1092,9 @@ func CCBinaryFactory() (blueprint.Module, []interface{}) {
 	return NewCCBinary(module, module, common.HostAndDeviceSupported)
 }
 
-func (c *CCBinary) ModuleTypeFlags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
+func (c *CCBinary) Flags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
+	flags = c.ccDynamic.Flags(ctx, flags)
+
 	flags.CFlags = append(flags.CFlags, "-fpie")
 
 	if ctx.Device() {
@@ -1204,12 +1145,8 @@ type ccTest struct {
 	}
 }
 
-var (
+func (c *ccTest) Flags(ctx common.AndroidModuleContext, flags CCFlags) CCFlags {
-	gtestLibs = []string{"libgtest", "libgtest_main"}
+	flags = c.CCBinary.Flags(ctx, flags)
-)
-
-func (c *ccTest) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
-	deps, flags := c.CCBinary.collectDeps(ctx, flags)
 
 	flags.CFlags = append(flags.CFlags, "-DGTEST_HAS_STD_STRING")
 	if ctx.Host() {
@@ -1221,16 +1158,13 @@ func (c *ccTest) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CC
 	flags.IncludeDirs = append(flags.IncludeDirs,
 		filepath.Join(ctx.Config().(Config).SrcDir(), "external/gtest/include"))
 
-	_, staticLibs, _ := c.collectDepsFromList(ctx, gtestLibs)
+	return flags
-	deps.StaticLibs = append(deps.StaticLibs, staticLibs...)
-
-	return deps, flags
 }
 
-func (c *ccTest) AndroidDynamicDependencies(ctx common.AndroidDynamicDependerModuleContext) []string {
+func (c *ccTest) DepNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
-	ctx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, gtestLibs...)
+	depNames = c.CCBinary.DepNames(ctx, depNames)
-	deps := c.CCBinary.AndroidDynamicDependencies(ctx)
+	depNames.StaticLibs = append(depNames.StaticLibs, "libgtest", "libgtest_main")
-	return append(deps, gtestLibs...)
+	return depNames
 }
 
 func (c *ccTest) installModule(ctx common.AndroidModuleContext, flags CCFlags) {
@@ -1330,9 +1264,9 @@ func (*toolchainLibrary) AndroidDynamicDependencies(ctx common.AndroidDynamicDep
 	return nil
 }
 
-func (*toolchainLibrary) collectDeps(ctx common.AndroidModuleContext, flags CCFlags) (CCDeps, CCFlags) {
+func (*toolchainLibrary) DepNames(ctx common.AndroidBaseContext, depNames CCDeps) CCDeps {
 	// toolchain libraries can't have any dependencies
-	return CCDeps{}, flags
+	return CCDeps{}
 }
 
 func ToolchainLibraryFactory() (blueprint.Module, []interface{}) {
@@ -1340,7 +1274,8 @@ func ToolchainLibraryFactory() (blueprint.Module, []interface{}) {
 
 	module.LibraryProperties.BuildStatic = true
 
-	return newCCBase(&module.ccBase, module, common.DeviceSupported, common.MultilibBoth)
+	return newCCBase(&module.ccBase, module, common.DeviceSupported, common.MultilibBoth,
+		&module.LibraryProperties)
 }
 
 func (c *toolchainLibrary) compileModule(ctx common.AndroidModuleContext,