| // Copyright 2019 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 ( |
| "encoding/json" |
| "fmt" |
| "path" |
| "sort" |
| "strings" |
| |
| "android/soong/android" |
| ) |
| |
| // This singleton collects cc modules' source and flags into to a json file. |
| // It does so for generating CMakeLists.txt project files needed data when |
| // either make, mm, mma, mmm or mmma is called. |
| // The info file is generated in $OUT/module_bp_cc_depend.json. |
| |
| func init() { |
| android.RegisterParallelSingletonType("ccdeps_generator", ccDepsGeneratorSingleton) |
| } |
| |
| func ccDepsGeneratorSingleton() android.Singleton { |
| return &ccdepsGeneratorSingleton{} |
| } |
| |
| type ccdepsGeneratorSingleton struct { |
| outputPath android.Path |
| } |
| |
| var _ android.SingletonMakeVarsProvider = (*ccdepsGeneratorSingleton)(nil) |
| |
| const ( |
| ccdepsJsonFileName = "module_bp_cc_deps.json" |
| cClang = "clang" |
| cppClang = "clang++" |
| ) |
| |
| type ccIdeInfo struct { |
| Path []string `json:"path,omitempty"` |
| Srcs []string `json:"srcs,omitempty"` |
| Global_Common_Flags ccParameters `json:"global_common_flags,omitempty"` |
| Local_Common_Flags ccParameters `json:"local_common_flags,omitempty"` |
| Global_C_flags ccParameters `json:"global_c_flags,omitempty"` |
| Local_C_flags ccParameters `json:"local_c_flags,omitempty"` |
| Global_C_only_flags ccParameters `json:"global_c_only_flags,omitempty"` |
| Local_C_only_flags ccParameters `json:"local_c_only_flags,omitempty"` |
| Global_Cpp_flags ccParameters `json:"global_cpp_flags,omitempty"` |
| Local_Cpp_flags ccParameters `json:"local_cpp_flags,omitempty"` |
| System_include_flags ccParameters `json:"system_include_flags,omitempty"` |
| Module_name string `json:"module_name,omitempty"` |
| } |
| |
| type ccParameters struct { |
| HeaderSearchPath []string `json:"header_search_path,omitempty"` |
| SystemHeaderSearchPath []string `json:"system_search_path,omitempty"` |
| FlagParameters []string `json:"flag,omitempty"` |
| SysRoot string `json:"system_root,omitempty"` |
| RelativeFilePathFlags map[string]string `json:"relative_file_path,omitempty"` |
| } |
| |
| type ccMapIdeInfos map[string]ccIdeInfo |
| |
| type ccDeps struct { |
| C_clang string `json:"clang,omitempty"` |
| Cpp_clang string `json:"clang++,omitempty"` |
| Modules ccMapIdeInfos `json:"modules,omitempty"` |
| } |
| |
| func (c *ccdepsGeneratorSingleton) GenerateBuildActions(ctx android.SingletonContext) { |
| // (b/204397180) Generate module_bp_cc_deps.json by default. |
| moduleDeps := ccDeps{} |
| moduleInfos := map[string]ccIdeInfo{} |
| |
| // Track if best variant (device arch match) has been found. |
| bestVariantFound := map[string]bool{} |
| |
| pathToCC, _ := evalVariable(ctx, "${config.ClangBin}/") |
| moduleDeps.C_clang = fmt.Sprintf("%s%s", buildCMakePath(pathToCC), cClang) |
| moduleDeps.Cpp_clang = fmt.Sprintf("%s%s", buildCMakePath(pathToCC), cppClang) |
| |
| ctx.VisitAllModules(func(module android.Module) { |
| if ccModule, ok := module.(*Module); ok { |
| if compiledModule, ok := ccModule.compiler.(CompiledInterface); ok { |
| generateCLionProjectData(ctx, compiledModule, ccModule, bestVariantFound, moduleInfos) |
| } |
| } |
| }) |
| |
| moduleDeps.Modules = moduleInfos |
| |
| ccfpath := android.PathForOutput(ctx, ccdepsJsonFileName) |
| err := createJsonFile(moduleDeps, ccfpath) |
| if err != nil { |
| ctx.Errorf(err.Error()) |
| } |
| c.outputPath = ccfpath |
| |
| // This is necessary to satisfy the dangling rules check as this file is written by Soong rather than a rule. |
| ctx.Build(pctx, android.BuildParams{ |
| Rule: android.Touch, |
| Output: ccfpath, |
| }) |
| } |
| |
| func (c *ccdepsGeneratorSingleton) MakeVars(ctx android.MakeVarsContext) { |
| if c.outputPath == nil { |
| return |
| } |
| |
| ctx.DistForGoal("general-tests", c.outputPath) |
| } |
| |
| func parseCompilerCCParameters(ctx android.SingletonContext, params []string) ccParameters { |
| compilerParams := ccParameters{} |
| |
| cparams := []string{} |
| for _, param := range params { |
| param, _ = evalVariable(ctx, param) |
| cparams = append(cparams, param) |
| } |
| |
| // Soong does not guarantee that each flag will be in an individual string. e.g: The |
| // input received could be: |
| // params = {"-isystem", "path/to/system"} |
| // or it could be |
| // params = {"-isystem path/to/system"} |
| // To normalize the input, we split all strings with the "space" character and consolidate |
| // all tokens into a flattened parameters list |
| cparams = normalizeParameters(cparams) |
| |
| for i := 0; i < len(cparams); i++ { |
| param := cparams[i] |
| if param == "" { |
| continue |
| } |
| |
| switch categorizeParameter(param) { |
| case headerSearchPath: |
| compilerParams.HeaderSearchPath = |
| append(compilerParams.HeaderSearchPath, strings.TrimPrefix(param, "-I")) |
| case systemHeaderSearchPath: |
| if i < len(cparams)-1 { |
| compilerParams.SystemHeaderSearchPath = append(compilerParams.SystemHeaderSearchPath, cparams[i+1]) |
| } |
| i = i + 1 |
| case flag: |
| c := cleanupParameter(param) |
| compilerParams.FlagParameters = append(compilerParams.FlagParameters, c) |
| case systemRoot: |
| if i < len(cparams)-1 { |
| compilerParams.SysRoot = cparams[i+1] |
| } |
| i = i + 1 |
| case relativeFilePathFlag: |
| flagComponents := strings.Split(param, "=") |
| if len(flagComponents) == 2 { |
| if compilerParams.RelativeFilePathFlags == nil { |
| compilerParams.RelativeFilePathFlags = map[string]string{} |
| } |
| compilerParams.RelativeFilePathFlags[flagComponents[0]] = flagComponents[1] |
| } |
| } |
| } |
| return compilerParams |
| } |
| |
| func generateCLionProjectData(ctx android.SingletonContext, compiledModule CompiledInterface, |
| ccModule *Module, bestVariantFound map[string]bool, moduleInfos map[string]ccIdeInfo) { |
| moduleName := ccModule.ModuleBase.Name() |
| srcs := compiledModule.Srcs() |
| |
| // Skip if best variant has already been found. |
| if bestVariantFound[moduleName] { |
| return |
| } |
| |
| // Skip if sources are empty. |
| if len(srcs) == 0 { |
| return |
| } |
| |
| // Check if device arch matches, in which case this is the best variant and takes precedence. |
| if ccModule.Device() && ccModule.ModuleBase.Arch().ArchType.Name == ctx.DeviceConfig().DeviceArch() { |
| bestVariantFound[moduleName] = true |
| } else if _, ok := moduleInfos[moduleName]; ok { |
| // Skip because this isn't the best variant and a previous one has already been added. |
| // Heuristically, ones that appear first are likely to be more relevant. |
| return |
| } |
| |
| dpInfo := ccIdeInfo{} |
| |
| dpInfo.Path = append(dpInfo.Path, path.Dir(ctx.BlueprintFile(ccModule))) |
| dpInfo.Srcs = append(dpInfo.Srcs, srcs.Strings()...) |
| dpInfo.Path = android.FirstUniqueStrings(dpInfo.Path) |
| dpInfo.Srcs = android.FirstUniqueStrings(dpInfo.Srcs) |
| |
| dpInfo.Global_Common_Flags = parseCompilerCCParameters(ctx, ccModule.flags.Global.CommonFlags) |
| dpInfo.Local_Common_Flags = parseCompilerCCParameters(ctx, ccModule.flags.Local.CommonFlags) |
| dpInfo.Global_C_flags = parseCompilerCCParameters(ctx, ccModule.flags.Global.CFlags) |
| dpInfo.Local_C_flags = parseCompilerCCParameters(ctx, ccModule.flags.Local.CFlags) |
| dpInfo.Global_C_only_flags = parseCompilerCCParameters(ctx, ccModule.flags.Global.ConlyFlags) |
| dpInfo.Local_C_only_flags = parseCompilerCCParameters(ctx, ccModule.flags.Local.ConlyFlags) |
| dpInfo.Global_Cpp_flags = parseCompilerCCParameters(ctx, ccModule.flags.Global.CppFlags) |
| dpInfo.Local_Cpp_flags = parseCompilerCCParameters(ctx, ccModule.flags.Local.CppFlags) |
| dpInfo.System_include_flags = parseCompilerCCParameters(ctx, ccModule.flags.SystemIncludeFlags) |
| |
| dpInfo.Module_name = moduleName |
| |
| moduleInfos[moduleName] = dpInfo |
| } |
| |
| type Deal struct { |
| Name string |
| ideInfo ccIdeInfo |
| } |
| |
| type Deals []Deal |
| |
| // Ensure it satisfies sort.Interface |
| func (d Deals) Len() int { return len(d) } |
| func (d Deals) Less(i, j int) bool { return d[i].Name < d[j].Name } |
| func (d Deals) Swap(i, j int) { d[i], d[j] = d[j], d[i] } |
| |
| func sortMap(moduleInfos map[string]ccIdeInfo) map[string]ccIdeInfo { |
| var deals Deals |
| for k, v := range moduleInfos { |
| deals = append(deals, Deal{k, v}) |
| } |
| |
| sort.Sort(deals) |
| |
| m := map[string]ccIdeInfo{} |
| for _, d := range deals { |
| m[d.Name] = d.ideInfo |
| } |
| return m |
| } |
| |
| func createJsonFile(moduleDeps ccDeps, ccfpath android.WritablePath) error { |
| buf, err := json.MarshalIndent(moduleDeps, "", "\t") |
| if err != nil { |
| return fmt.Errorf("JSON marshal of cc deps failed: %s", err) |
| } |
| err = android.WriteFileToOutputDir(ccfpath, buf, 0666) |
| if err != nil { |
| return fmt.Errorf("Writing cc deps to %s failed: %s", ccfpath.String(), err) |
| } |
| return nil |
| } |