diff --git a/cc/cc.go b/cc/cc.go index 9383e390b..ccd03aeb9 100644 --- a/cc/cc.go +++ b/cc/cc.go @@ -79,7 +79,6 @@ func RegisterCCBuildComponents(ctx android.RegistrationContext) { ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel() ctx.BottomUp("coverage", coverageMutator).Parallel() - ctx.TopDown("vndk_deps", sabiDepsMutator) ctx.TopDown("lto_deps", ltoDepsMutator) ctx.BottomUp("lto", ltoMutator).Parallel() @@ -88,6 +87,11 @@ func RegisterCCBuildComponents(ctx android.RegistrationContext) { ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel() }) + ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) { + // sabi mutator needs to be run after apex mutator finishes. + ctx.TopDown("sabi_deps", sabiDepsMutator) + }) + ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory) } diff --git a/cc/config/clang.go b/cc/config/clang.go index 441bff2a5..519a9e2d2 100644 --- a/cc/config/clang.go +++ b/cc/config/clang.go @@ -249,6 +249,10 @@ func ClangFilterUnknownLldflags(lldflags []string) []string { return result } +func ClangLibToolingFilterUnknownCflags(libToolingFlags []string) []string { + return android.RemoveListFromList(libToolingFlags, ClangLibToolingUnknownCflags) +} + func inListSorted(s string, list []string) bool { for _, l := range list { if s == l { diff --git a/cc/library.go b/cc/library.go index 06b99054f..a7ac43dc4 100644 --- a/cc/library.go +++ b/cc/library.go @@ -596,7 +596,7 @@ func (library *libraryDecorator) compilerFlags(ctx ModuleContext, flags Flags, d // Returns a string that represents the class of the ABI dump. // Returns an empty string if ABI check is disabled for this library. -func (library *libraryDecorator) classifySourceAbiDump(ctx ModuleContext) string { +func (library *libraryDecorator) classifySourceAbiDump(ctx BaseModuleContext) string { enabled := library.Properties.Header_abi_checker.Enabled if enabled != nil && !Bool(enabled) { return "" @@ -629,7 +629,7 @@ func (library *libraryDecorator) classifySourceAbiDump(ctx ModuleContext) string return "" } -func (library *libraryDecorator) shouldCreateSourceAbiDump(ctx ModuleContext) bool { +func (library *libraryDecorator) shouldCreateSourceAbiDump(ctx BaseModuleContext) bool { if !ctx.shouldCreateSourceAbiDump() { return false } diff --git a/cc/sabi.go b/cc/sabi.go index ef6beada6..b4c31e5e1 100644 --- a/cc/sabi.go +++ b/cc/sabi.go @@ -15,7 +15,6 @@ package cc import ( - "strings" "sync" "android/soong/android" @@ -23,12 +22,16 @@ import ( ) var ( - lsdumpPaths []string - sabiLock sync.Mutex + lsdumpPaths []string + lsdumpPathsLock sync.Mutex ) type SAbiProperties struct { - CreateSAbiDumps bool `blueprint:"mutated"` + // True if need to generate ABI dump. + CreateSAbiDumps bool `blueprint:"mutated"` + + // Include directories that may contain ABI information exported by a library. + // These directories are passed to the header-abi-dumper. ReexportedIncludes []string `blueprint:"mutated"` } @@ -46,56 +49,55 @@ func (sabimod *sabi) deps(ctx BaseModuleContext, deps Deps) Deps { return deps } -func inListWithPrefixSearch(flag string, filter []string) bool { - // Assuming the filter is small enough. - // If the suffix of a filter element is *, try matching prefixes as well. - for _, f := range filter { - if (f == flag) || (strings.HasSuffix(f, "*") && strings.HasPrefix(flag, strings.TrimSuffix(f, "*"))) { - return true - } - } - return false -} - -func filterOutWithPrefix(list []string, filter []string) (remainder []string) { - // Go through the filter, matching and optionally doing a prefix search for list elements. - for _, l := range list { - if !inListWithPrefixSearch(l, filter) { - remainder = append(remainder, l) - } - } - return -} - func (sabimod *sabi) flags(ctx ModuleContext, flags Flags) Flags { - // Assuming that the cflags which clang LibTooling tools cannot - // understand have not been converted to ninja variables yet. - flags.Local.ToolingCFlags = filterOutWithPrefix(flags.Local.CFlags, config.ClangLibToolingUnknownCflags) - flags.Global.ToolingCFlags = filterOutWithPrefix(flags.Global.CFlags, config.ClangLibToolingUnknownCflags) - flags.Local.ToolingCppFlags = filterOutWithPrefix(flags.Local.CppFlags, config.ClangLibToolingUnknownCflags) - flags.Global.ToolingCppFlags = filterOutWithPrefix(flags.Global.CppFlags, config.ClangLibToolingUnknownCflags) - + // Filter out flags which libTooling don't understand. + // This is here for legacy reasons and future-proof, in case the version of libTooling and clang + // diverge. + flags.Local.ToolingCFlags = config.ClangLibToolingFilterUnknownCflags(flags.Local.CFlags) + flags.Global.ToolingCFlags = config.ClangLibToolingFilterUnknownCflags(flags.Global.CFlags) + flags.Local.ToolingCppFlags = config.ClangLibToolingFilterUnknownCflags(flags.Local.CppFlags) + flags.Global.ToolingCppFlags = config.ClangLibToolingFilterUnknownCflags(flags.Global.CppFlags) return flags } +func shouldSkipSabiDepsMutator(mctx android.TopDownMutatorContext, m *Module) bool { + if m.sabi != nil && m.sabi.Properties.CreateSAbiDumps { + return false + } + if library, ok := m.linker.(*libraryDecorator); ok { + ctx := &baseModuleContext{ + BaseModuleContext: mctx, + moduleContextImpl: moduleContextImpl{ + mod: m, + }, + } + ctx.ctx = ctx + return !library.shouldCreateSourceAbiDump(ctx) + } + return true +} + +// Mark the direct and transitive dependencies of libraries that need ABI check, so that ABI dumps +// of their dependencies would be generated. func sabiDepsMutator(mctx android.TopDownMutatorContext) { - if c, ok := mctx.Module().(*Module); ok && - ((c.IsVndk() && c.UseVndk()) || c.isLlndk(mctx.Config()) || - (c.sabi != nil && c.sabi.Properties.CreateSAbiDumps)) { + if c, ok := mctx.Module().(*Module); ok { + if shouldSkipSabiDepsMutator(mctx, c) { + return + } mctx.VisitDirectDeps(func(m android.Module) { if tag, ok := mctx.OtherModuleDependencyTag(m).(libraryDependencyTag); ok && tag.static() { - cc, _ := m.(*Module) - if cc == nil { - return + if cc, ok := m.(*Module); ok { + cc.sabi.Properties.CreateSAbiDumps = true } - cc.sabi.Properties.CreateSAbiDumps = true } }) } } +// Add an entry to the global list of lsdump. The list is exported to a Make variable by +// `cc.makeVarsProvider`. func addLsdumpPath(lsdumpPath string) { - sabiLock.Lock() + lsdumpPathsLock.Lock() + defer lsdumpPathsLock.Unlock() lsdumpPaths = append(lsdumpPaths, lsdumpPath) - sabiLock.Unlock() }