blob: c3051149480148c36344694722fa36969af17b80 [file] [log] [blame]
Colin Cross3f40fa42015-01-30 17:27:36 -08001// Copyright 2015 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
Colin Cross635c3b02016-05-18 15:37:25 -070015package android
Colin Cross3f40fa42015-01-30 17:27:36 -080016
Jingwen Chenc711fec2020-11-22 23:52:50 -050017// This is the primary location to write and read all configuration values and
18// product variables necessary for soong_build's operation.
19
Colin Cross3f40fa42015-01-30 17:27:36 -080020import (
Cole Faust082c5f32022-08-04 15:49:20 -070021 "bytes"
Colin Cross3f40fa42015-01-30 17:27:36 -080022 "encoding/json"
23 "fmt"
24 "os"
Colin Cross35cec122015-04-02 14:37:16 -070025 "path/filepath"
Sam Delmerico5c32bbf2022-01-20 20:15:02 +000026 "reflect"
Colin Cross3f40fa42015-01-30 17:27:36 -080027 "runtime"
Inseob Kim60c32f02020-12-21 22:53:05 +090028 "strconv"
Dan Willemsen34cc69e2015-09-23 15:26:20 -070029 "strings"
Colin Crossc1e86a32015-04-15 12:33:28 -070030 "sync"
Colin Cross6ff51382015-12-17 16:39:19 -080031
Colin Cross98be1bb2019-12-13 20:41:13 -080032 "github.com/google/blueprint"
Colin Crosse87040b2017-12-11 15:52:26 -080033 "github.com/google/blueprint/bootstrap"
Colin Cross98be1bb2019-12-13 20:41:13 -080034 "github.com/google/blueprint/pathtools"
Colin Cross6ff51382015-12-17 16:39:19 -080035 "github.com/google/blueprint/proptools"
Colin Cross9d34f352019-11-22 16:03:51 -080036
37 "android/soong/android/soongconfig"
Liz Kammer09f947d2021-05-12 14:51:49 -040038 "android/soong/bazel"
Colin Cross77cdcfd2021-03-12 11:28:25 -080039 "android/soong/remoteexec"
Liz Kammer72beb342022-02-03 08:42:10 -050040 "android/soong/starlark_fmt"
Colin Cross3f40fa42015-01-30 17:27:36 -080041)
42
Jingwen Chenc711fec2020-11-22 23:52:50 -050043// Bool re-exports proptools.Bool for the android package.
Colin Cross6ff51382015-12-17 16:39:19 -080044var Bool = proptools.Bool
Jingwen Chenc711fec2020-11-22 23:52:50 -050045
46// String re-exports proptools.String for the android package.
Jack He8cc71432016-12-08 15:45:07 -080047var String = proptools.String
Jingwen Chenc711fec2020-11-22 23:52:50 -050048
49// StringDefault re-exports proptools.StringDefault for the android package.
Jeongik Cha219141c2020-08-06 23:00:37 +090050var StringDefault = proptools.StringDefault
Jiyong Park6a927c42020-01-21 02:03:43 +090051
Jingwen Chenc711fec2020-11-22 23:52:50 -050052// FutureApiLevelInt is a placeholder constant for unreleased API levels.
Dan Albert0b176c82020-07-23 16:43:25 -070053const FutureApiLevelInt = 10000
54
Jingwen Chenc711fec2020-11-22 23:52:50 -050055// FutureApiLevel represents unreleased API levels.
Dan Albert0b176c82020-07-23 16:43:25 -070056var FutureApiLevel = ApiLevel{
57 value: "current",
58 number: FutureApiLevelInt,
59 isPreview: true,
60}
Colin Cross6ff51382015-12-17 16:39:19 -080061
Jingwen Chenc4d91bc2020-11-24 22:59:26 -050062// The product variables file name, containing product config from Kati.
Dan Willemsen87b17d12015-07-14 00:39:06 -070063const productVariablesFileName = "soong.variables"
Colin Cross3f40fa42015-01-30 17:27:36 -080064
Colin Cross9272ade2016-08-17 15:24:12 -070065// A Config object represents the entire build configuration for Android.
Colin Crossc3c0a492015-04-10 15:43:55 -070066type Config struct {
67 *config
68}
69
Chris Parsonsad876012022-08-20 14:48:32 -040070type SoongBuildMode int
71
Sasha Smundakaf5ca922022-12-12 21:23:34 -080072type CmdArgs struct {
73 bootstrap.Args
74 RunGoTests bool
75 OutDir string
76 SoongOutDir string
77
78 SymlinkForestMarker string
79 Bp2buildMarker string
80 BazelQueryViewDir string
81 BazelApiBp2buildDir string
82 ModuleGraphFile string
83 ModuleActionsFile string
84 DocFile string
85
86 BazelMode bool
87 BazelModeDev bool
88 BazelModeStaging bool
89 BazelForceEnabledModules string
90}
91
Chris Parsonsad876012022-08-20 14:48:32 -040092// Build modes that soong_build can run as.
93const (
94 // Don't use bazel at all during module analysis.
95 AnalysisNoBazel SoongBuildMode = iota
96
Lukacs T. Berkic541cd22022-10-26 07:26:50 +000097 // Symlink fores mode: merge two directory trees into a symlink forest
98 SymlinkForest
99
Chris Parsonsad876012022-08-20 14:48:32 -0400100 // Bp2build mode: Generate BUILD files from blueprint files and exit.
101 Bp2build
102
103 // Generate BUILD files which faithfully represent the dependency graph of
104 // blueprint modules. Individual BUILD targets will not, however, faitfhully
105 // express build semantics.
106 GenerateQueryView
107
Spandan Das5af0bd32022-09-28 20:43:08 +0000108 // Generate BUILD files for API contributions to API surfaces
109 ApiBp2build
110
Chris Parsonsad876012022-08-20 14:48:32 -0400111 // Create a JSON representation of the module graph and exit.
112 GenerateModuleGraph
113
114 // Generate a documentation file for module type definitions and exit.
115 GenerateDocFile
116
117 // Use bazel during analysis of many allowlisted build modules. The allowlist
118 // is considered a "developer mode" allowlist, as some modules may be
119 // allowlisted on an experimental basis.
120 BazelDevMode
121
MarkDacekb78465d2022-10-18 20:10:16 +0000122 // Use bazel during analysis of a few allowlisted build modules. The allowlist
123 // is considered "staging, as these are modules being prepared to be released
124 // into prod mode shortly after.
125 BazelStagingMode
126
Chris Parsonsad876012022-08-20 14:48:32 -0400127 // Use bazel during analysis of build modules from an allowlist carefully
128 // curated by the build team to be proven stable.
Chris Parsonsad876012022-08-20 14:48:32 -0400129 BazelProdMode
130)
131
Lukacs T. Berkib078ade2021-08-31 10:42:08 +0200132// SoongOutDir returns the build output directory for the configuration.
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200133func (c Config) SoongOutDir() string {
134 return c.soongOutDir
Jeff Gastonefc1b412017-03-29 17:29:06 -0700135}
136
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200137func (c Config) OutDir() string {
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200138 return c.outDir
Lukacs T. Berki89e9a162021-03-12 08:31:32 +0100139}
140
Lukacs T. Berkiea1a31c2021-09-02 09:58:09 +0200141func (c Config) RunGoTests() bool {
142 return c.runGoTests
143}
144
Lukacs T. Berki5f6cb1d2021-03-17 15:03:14 +0100145func (c Config) DebugCompilation() bool {
146 return false // Never compile Go code in the main build for debugging
147}
148
Lukacs T. Berkiea1a31c2021-09-02 09:58:09 +0200149func (c Config) Subninjas() []string {
150 return []string{}
151}
152
153func (c Config) PrimaryBuilderInvocations() []bootstrap.PrimaryBuilderInvocation {
154 return []bootstrap.PrimaryBuilderInvocation{}
155}
156
Paul Duffin74135582022-10-06 11:01:59 +0100157// RunningInsideUnitTest returns true if this code is being run as part of a Soong unit test.
158func (c Config) RunningInsideUnitTest() bool {
159 return c.config.TestProductVariables != nil
160}
161
Jingwen Chenc711fec2020-11-22 23:52:50 -0500162// A DeviceConfig object represents the configuration for a particular device
163// being built. For now there will only be one of these, but in the future there
164// may be multiple devices being built.
Colin Cross9272ade2016-08-17 15:24:12 -0700165type DeviceConfig struct {
166 *deviceConfig
167}
168
Jingwen Chenc711fec2020-11-22 23:52:50 -0500169// VendorConfig represents the configuration for vendor-specific behavior.
Colin Cross9d34f352019-11-22 16:03:51 -0800170type VendorConfig soongconfig.SoongConfig
Dan Willemsen0fe78662018-03-26 12:41:18 -0700171
Jingwen Chenc711fec2020-11-22 23:52:50 -0500172// Definition of general build configuration for soong_build. Some of these
Jingwen Chenc4d91bc2020-11-24 22:59:26 -0500173// product configuration values are read from Kati-generated soong.variables.
Colin Cross1332b002015-04-07 17:11:30 -0700174type config struct {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500175 // Options configurable with soong.variables
Dan Willemsen45133ac2018-03-09 21:22:06 -0800176 productVariables productVariables
Colin Cross3f40fa42015-01-30 17:27:36 -0800177
Dan Willemsen674dc7f2018-03-12 18:06:05 -0700178 // Only available on configs created by TestConfig
179 TestProductVariables *productVariables
180
Jingwen Chenc711fec2020-11-22 23:52:50 -0500181 // A specialized context object for Bazel/Soong mixed builds and migration
182 // purposes.
Chris Parsonsf3c96ef2020-09-29 02:23:17 -0400183 BazelContext BazelContext
184
Dan Willemsen87b17d12015-07-14 00:39:06 -0700185 ProductVariablesFileName string
186
Colin Cross0c66bc62021-07-20 09:47:41 -0700187 // BuildOS stores the OsType for the OS that the build is running on.
188 BuildOS OsType
189
190 // BuildArch stores the ArchType for the CPU that the build is running on.
191 BuildArch ArchType
192
Jaewoong Jung642916f2020-10-09 17:25:15 -0700193 Targets map[OsType][]Target
194 BuildOSTarget Target // the Target for tools run on the build machine
195 BuildOSCommonTarget Target // the Target for common (java) tools run on the build machine
196 AndroidCommonTarget Target // the Target for common modules for the Android device
197 AndroidFirstDeviceTarget Target // the first Target for modules for the Android device
Dan Willemsen218f6562015-07-08 18:13:11 -0700198
Jingwen Chenc711fec2020-11-22 23:52:50 -0500199 // multilibConflicts for an ArchType is true if there is earlier configured
200 // device architecture with the same multilib value.
Colin Cross3b19f5d2019-09-17 14:45:31 -0700201 multilibConflicts map[ArchType]bool
202
Colin Cross9272ade2016-08-17 15:24:12 -0700203 deviceConfig *deviceConfig
204
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200205 outDir string // The output directory (usually out/)
206 soongOutDir string
Chris Parsons8f232a22020-06-23 17:37:05 -0400207 moduleListFile string // the path to the file which lists blueprint files to parse.
Colin Crossc1e86a32015-04-15 12:33:28 -0700208
Lukacs T. Berkie1df43f2021-09-08 15:31:14 +0200209 runGoTests bool
Lukacs T. Berkiea1a31c2021-09-02 09:58:09 +0200210
Colin Cross6ccbc912017-10-10 23:07:38 -0700211 env map[string]string
Dan Willemsene7680ba2015-09-11 17:06:19 -0700212 envLock sync.Mutex
213 envDeps map[string]string
214 envFrozen bool
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800215
Jingwen Chencda22c92020-11-23 00:22:30 -0500216 // Changes behavior based on whether Kati runs after soong_build, or if soong_build
217 // runs standalone.
218 katiEnabled bool
Colin Cross1e7d3702016-08-24 15:25:47 -0700219
Colin Cross32616ed2017-09-05 21:56:44 -0700220 captureBuild bool // true for tests, saves build parameters for each module
221 ignoreEnvironment bool // true for tests, returns empty from all Getenv calls
Colin Crosscec81712017-07-13 14:43:27 -0700222
Colin Cross98be1bb2019-12-13 20:41:13 -0800223 fs pathtools.FileSystem
224 mockBpList string
225
Chris Parsonsad876012022-08-20 14:48:32 -0400226 BuildMode SoongBuildMode
Cole Faust324a92e2022-08-23 15:29:05 -0700227 Bp2buildPackageConfig Bp2BuildConversionAllowlist
Jingwen Chen01812022021-11-19 14:29:43 +0000228 Bp2buildSoongConfigDefinitions soongconfig.Bp2BuildSoongConfigDefinitions
Jingwen Chen12b4c272021-03-10 02:05:59 -0500229
Colin Cross5e6a7972020-06-07 16:56:32 -0700230 // If testAllowNonExistentPaths is true then PathForSource and PathForModuleSrc won't error
231 // in tests when a path doesn't exist.
Pedro Loureiro5d190cc2021-02-15 15:41:33 +0000232 TestAllowNonExistentPaths bool
Colin Cross5e6a7972020-06-07 16:56:32 -0700233
Jingwen Chenc711fec2020-11-22 23:52:50 -0500234 // The list of files that when changed, must invalidate soong_build to
235 // regenerate build.ninja.
Colin Cross12129292020-10-29 18:23:58 -0700236 ninjaFileDepsSet sync.Map
237
Colin Cross9272ade2016-08-17 15:24:12 -0700238 OncePer
MarkDacekff851b82022-04-21 18:33:17 +0000239
Chris Parsonsad876012022-08-20 14:48:32 -0400240 // These fields are only used for metrics collection. A module should be added
241 // to these maps only if its implementation supports Bazel handling in mixed
242 // builds. A module being in the "enabled" list indicates that there is a
243 // variant of that module for which bazel-handling actually took place.
244 // A module being in the "disabled" list indicates that there is a variant of
245 // that module for which bazel-handling was denied.
MarkDacekff851b82022-04-21 18:33:17 +0000246 mixedBuildsLock sync.Mutex
247 mixedBuildEnabledModules map[string]struct{}
248 mixedBuildDisabledModules map[string]struct{}
MarkDacekd06db5d2022-11-29 00:47:59 +0000249
250 // These are modules to be built with Bazel beyond the allowlisted/build-mode
251 // specified modules. They are passed via the command-line flag
252 // "--bazel-force-enabled-modules"
253 bazelForceEnabledModules map[string]struct{}
Colin Cross9272ade2016-08-17 15:24:12 -0700254}
255
256type deviceConfig struct {
Dan Willemsen00269f22017-07-06 16:59:48 -0700257 config *config
Colin Cross9272ade2016-08-17 15:24:12 -0700258 OncePer
Colin Cross3f40fa42015-01-30 17:27:36 -0800259}
260
Colin Cross485e5722015-08-27 13:28:01 -0700261type jsonConfigurable interface {
Colin Cross27385972015-09-18 10:57:10 -0700262 SetDefaultConfig()
Colin Cross485e5722015-08-27 13:28:01 -0700263}
Colin Cross3f40fa42015-01-30 17:27:36 -0800264
Colin Cross485e5722015-08-27 13:28:01 -0700265func loadConfig(config *config) error {
Colin Cross988414c2020-01-11 01:11:46 +0000266 return loadFromConfigFile(&config.productVariables, absolutePath(config.ProductVariablesFileName))
Colin Cross485e5722015-08-27 13:28:01 -0700267}
268
Jingwen Chenc711fec2020-11-22 23:52:50 -0500269// loadFromConfigFile loads and decodes configuration options from a JSON file
270// in the current working directory.
Liz Kammer09f947d2021-05-12 14:51:49 -0400271func loadFromConfigFile(configurable *productVariables, filename string) error {
Colin Cross3f40fa42015-01-30 17:27:36 -0800272 // Try to open the file
Colin Cross485e5722015-08-27 13:28:01 -0700273 configFileReader, err := os.Open(filename)
Colin Cross3f40fa42015-01-30 17:27:36 -0800274 defer configFileReader.Close()
275 if os.IsNotExist(err) {
276 // Need to create a file, so that blueprint & ninja don't get in
277 // a dependency tracking loop.
278 // Make a file-configurable-options with defaults, write it out using
279 // a json writer.
Colin Cross27385972015-09-18 10:57:10 -0700280 configurable.SetDefaultConfig()
281 err = saveToConfigFile(configurable, filename)
Colin Cross3f40fa42015-01-30 17:27:36 -0800282 if err != nil {
283 return err
284 }
Colin Cross15cd21a2018-02-27 11:26:02 -0800285 } else if err != nil {
286 return fmt.Errorf("config file: could not open %s: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800287 } else {
288 // Make a decoder for it
289 jsonDecoder := json.NewDecoder(configFileReader)
Colin Cross485e5722015-08-27 13:28:01 -0700290 err = jsonDecoder.Decode(configurable)
Colin Cross3f40fa42015-01-30 17:27:36 -0800291 if err != nil {
Colin Cross15cd21a2018-02-27 11:26:02 -0800292 return fmt.Errorf("config file: %s did not parse correctly: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800293 }
294 }
295
Liz Kammer09f947d2021-05-12 14:51:49 -0400296 if Bool(configurable.GcovCoverage) && Bool(configurable.ClangCoverage) {
297 return fmt.Errorf("GcovCoverage and ClangCoverage cannot both be set")
298 }
299
300 configurable.Native_coverage = proptools.BoolPtr(
301 Bool(configurable.GcovCoverage) ||
302 Bool(configurable.ClangCoverage))
303
Yuntao Xu402e9b02021-08-09 15:44:44 -0700304 // when Platform_sdk_final is true (or PLATFORM_VERSION_CODENAME is REL), use Platform_sdk_version;
305 // if false (pre-released version, for example), use Platform_sdk_codename.
306 if Bool(configurable.Platform_sdk_final) {
307 if configurable.Platform_sdk_version != nil {
308 configurable.Platform_sdk_version_or_codename =
309 proptools.StringPtr(strconv.Itoa(*(configurable.Platform_sdk_version)))
310 } else {
311 return fmt.Errorf("Platform_sdk_version cannot be pointed by a NULL pointer")
312 }
313 } else {
314 configurable.Platform_sdk_version_or_codename =
315 proptools.StringPtr(String(configurable.Platform_sdk_codename))
316 }
317
Liz Kammer09f947d2021-05-12 14:51:49 -0400318 return saveToBazelConfigFile(configurable, filepath.Dir(filename))
Colin Cross3f40fa42015-01-30 17:27:36 -0800319}
320
Colin Crossd8f20142016-11-03 09:43:26 -0700321// atomically writes the config file in case two copies of soong_build are running simultaneously
322// (for example, docs generation and ninja manifest generation)
Liz Kammer09f947d2021-05-12 14:51:49 -0400323func saveToConfigFile(config *productVariables, filename string) error {
Colin Cross3f40fa42015-01-30 17:27:36 -0800324 data, err := json.MarshalIndent(&config, "", " ")
325 if err != nil {
326 return fmt.Errorf("cannot marshal config data: %s", err.Error())
327 }
328
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800329 f, err := os.CreateTemp(filepath.Dir(filename), "config")
Colin Cross3f40fa42015-01-30 17:27:36 -0800330 if err != nil {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500331 return fmt.Errorf("cannot create empty config file %s: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800332 }
Colin Crossd8f20142016-11-03 09:43:26 -0700333 defer os.Remove(f.Name())
334 defer f.Close()
Colin Cross3f40fa42015-01-30 17:27:36 -0800335
Colin Crossd8f20142016-11-03 09:43:26 -0700336 _, err = f.Write(data)
Colin Cross3f40fa42015-01-30 17:27:36 -0800337 if err != nil {
Colin Cross485e5722015-08-27 13:28:01 -0700338 return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error())
339 }
340
Colin Crossd8f20142016-11-03 09:43:26 -0700341 _, err = f.WriteString("\n")
Colin Cross485e5722015-08-27 13:28:01 -0700342 if err != nil {
343 return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800344 }
345
Colin Crossd8f20142016-11-03 09:43:26 -0700346 f.Close()
347 os.Rename(f.Name(), filename)
348
Colin Cross3f40fa42015-01-30 17:27:36 -0800349 return nil
350}
351
Liz Kammer09f947d2021-05-12 14:51:49 -0400352func saveToBazelConfigFile(config *productVariables, outDir string) error {
353 dir := filepath.Join(outDir, bazel.SoongInjectionDirName, "product_config")
354 err := createDirIfNonexistent(dir, os.ModePerm)
355 if err != nil {
356 return fmt.Errorf("Could not create dir %s: %s", dir, err)
357 }
358
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000359 nonArchVariantProductVariables := []string{}
360 archVariantProductVariables := []string{}
361 p := variableProperties{}
362 t := reflect.TypeOf(p.Product_variables)
363 for i := 0; i < t.NumField(); i++ {
364 f := t.Field(i)
365 nonArchVariantProductVariables = append(nonArchVariantProductVariables, strings.ToLower(f.Name))
366 if proptools.HasTag(f, "android", "arch_variant") {
367 archVariantProductVariables = append(archVariantProductVariables, strings.ToLower(f.Name))
368 }
369 }
370
Liz Kammer72beb342022-02-03 08:42:10 -0500371 nonArchVariantProductVariablesJson := starlark_fmt.PrintStringList(nonArchVariantProductVariables, 0)
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000372 if err != nil {
373 return fmt.Errorf("cannot marshal product variable data: %s", err.Error())
374 }
375
Liz Kammer72beb342022-02-03 08:42:10 -0500376 archVariantProductVariablesJson := starlark_fmt.PrintStringList(archVariantProductVariables, 0)
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000377 if err != nil {
378 return fmt.Errorf("cannot marshal arch variant product variable data: %s", err.Error())
379 }
380
381 configJson, err := json.MarshalIndent(&config, "", " ")
Liz Kammer09f947d2021-05-12 14:51:49 -0400382 if err != nil {
383 return fmt.Errorf("cannot marshal config data: %s", err.Error())
384 }
Cole Faust082c5f32022-08-04 15:49:20 -0700385 // The backslashes need to be escaped because this text is going to be put
386 // inside a Starlark string literal.
387 configJson = bytes.ReplaceAll(configJson, []byte("\\"), []byte("\\\\"))
Liz Kammer09f947d2021-05-12 14:51:49 -0400388
389 bzl := []string{
390 bazel.GeneratedBazelFileWarning,
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000391 fmt.Sprintf(`_product_vars = json.decode("""%s""")`, configJson),
392 fmt.Sprintf(`_product_var_constraints = %s`, nonArchVariantProductVariablesJson),
393 fmt.Sprintf(`_arch_variant_product_var_constraints = %s`, archVariantProductVariablesJson),
394 "\n", `
395product_vars = _product_vars
396product_var_constraints = _product_var_constraints
397arch_variant_product_var_constraints = _arch_variant_product_var_constraints
398`,
Liz Kammer09f947d2021-05-12 14:51:49 -0400399 }
Cole Faust082c5f32022-08-04 15:49:20 -0700400 err = os.WriteFile(filepath.Join(dir, "product_variables.bzl"), []byte(strings.Join(bzl, "\n")), 0644)
Liz Kammer09f947d2021-05-12 14:51:49 -0400401 if err != nil {
402 return fmt.Errorf("Could not write .bzl config file %s", err)
403 }
Cole Faust082c5f32022-08-04 15:49:20 -0700404 err = os.WriteFile(filepath.Join(dir, "BUILD"), []byte(bazel.GeneratedBazelFileWarning), 0644)
Liz Kammer09f947d2021-05-12 14:51:49 -0400405 if err != nil {
406 return fmt.Errorf("Could not write BUILD config file %s", err)
407 }
408
409 return nil
410}
411
Colin Cross988414c2020-01-11 01:11:46 +0000412// NullConfig returns a mostly empty Config for use by standalone tools like dexpreopt_gen that
413// use the android package.
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200414func NullConfig(outDir, soongOutDir string) Config {
Colin Cross988414c2020-01-11 01:11:46 +0000415 return Config{
416 config: &config{
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200417 outDir: outDir,
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200418 soongOutDir: soongOutDir,
419 fs: pathtools.OsFs,
Colin Cross988414c2020-01-11 01:11:46 +0000420 },
421 }
422}
423
Jingwen Chenc711fec2020-11-22 23:52:50 -0500424// NewConfig creates a new Config object. The srcDir argument specifies the path
425// to the root source directory. It also loads the config file, if found.
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800426func NewConfig(cmdArgs CmdArgs, availableEnv map[string]string) (Config, error) {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500427 // Make a config with default options.
Colin Cross9272ade2016-08-17 15:24:12 -0700428 config := &config{
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800429 ProductVariablesFileName: filepath.Join(cmdArgs.SoongOutDir, productVariablesFileName),
Dan Willemsen87b17d12015-07-14 00:39:06 -0700430
Lukacs T. Berki53b2f362021-04-12 14:04:24 +0200431 env: availableEnv,
Colin Cross6ccbc912017-10-10 23:07:38 -0700432
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800433 outDir: cmdArgs.OutDir,
434 soongOutDir: cmdArgs.SoongOutDir,
435 runGoTests: cmdArgs.RunGoTests,
Lukacs T. Berkie1df43f2021-09-08 15:31:14 +0200436 multilibConflicts: make(map[ArchType]bool),
Colin Cross98be1bb2019-12-13 20:41:13 -0800437
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800438 moduleListFile: cmdArgs.ModuleListFile,
MarkDacekff851b82022-04-21 18:33:17 +0000439 fs: pathtools.NewOsFs(absSrcDir),
440 mixedBuildDisabledModules: make(map[string]struct{}),
441 mixedBuildEnabledModules: make(map[string]struct{}),
MarkDacekd06db5d2022-11-29 00:47:59 +0000442 bazelForceEnabledModules: make(map[string]struct{}),
Colin Cross68f55102015-03-25 14:43:57 -0700443 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800444
Dan Willemsen00269f22017-07-06 16:59:48 -0700445 config.deviceConfig = &deviceConfig{
Colin Cross9272ade2016-08-17 15:24:12 -0700446 config: config,
447 }
448
Liz Kammer7941b302020-07-28 13:27:34 -0700449 // Soundness check of the build and source directories. This won't catch strange
450 // configurations with symlinks, but at least checks the obvious case.
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800451 absBuildDir, err := filepath.Abs(cmdArgs.SoongOutDir)
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700452 if err != nil {
453 return Config{}, err
454 }
455
Lukacs T. Berkif7e36d82021-08-16 17:05:09 +0200456 absSrcDir, err := filepath.Abs(".")
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700457 if err != nil {
458 return Config{}, err
459 }
460
461 if strings.HasPrefix(absSrcDir, absBuildDir) {
462 return Config{}, fmt.Errorf("Build dir must not contain source directory")
463 }
464
Colin Cross3f40fa42015-01-30 17:27:36 -0800465 // Load any configurable options from the configuration file
Colin Cross9272ade2016-08-17 15:24:12 -0700466 err = loadConfig(config)
Colin Cross3f40fa42015-01-30 17:27:36 -0800467 if err != nil {
Colin Crossc3c0a492015-04-10 15:43:55 -0700468 return Config{}, err
Colin Cross3f40fa42015-01-30 17:27:36 -0800469 }
470
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800471 KatiEnabledMarkerFile := filepath.Join(cmdArgs.SoongOutDir, ".soong.kati_enabled")
Jingwen Chencda22c92020-11-23 00:22:30 -0500472 if _, err := os.Stat(absolutePath(KatiEnabledMarkerFile)); err == nil {
473 config.katiEnabled = true
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800474 }
475
Colin Cross0c66bc62021-07-20 09:47:41 -0700476 determineBuildOS(config)
477
Jingwen Chenc711fec2020-11-22 23:52:50 -0500478 // Sets up the map of target OSes to the finer grained compilation targets
479 // that are configured from the product variables.
Colin Crossa1ad8d12016-06-01 17:09:44 -0700480 targets, err := decodeTargetProductVariables(config)
Dan Willemsen218f6562015-07-08 18:13:11 -0700481 if err != nil {
482 return Config{}, err
483 }
484
Paul Duffin1356d8c2020-02-25 19:26:33 +0000485 // Make the CommonOS OsType available for all products.
486 targets[CommonOS] = []Target{commonTargetMap[CommonOS.Name]}
487
Dan Albert4098deb2016-10-19 14:04:41 -0700488 var archConfig []archConfig
Jingwen Chenc4d91bc2020-11-24 22:59:26 -0500489 if config.NdkAbis() {
Dan Albert4098deb2016-10-19 14:04:41 -0700490 archConfig = getNdkAbisConfig()
Martin Stjernholmc1ecc432019-11-15 15:00:31 +0000491 } else if config.AmlAbis() {
492 archConfig = getAmlAbisConfig()
Dan Albert4098deb2016-10-19 14:04:41 -0700493 }
494
495 if archConfig != nil {
Liz Kammerb7f33662022-02-28 14:16:16 -0500496 androidTargets, err := decodeAndroidArchSettings(archConfig)
Dan Willemsen322acaf2016-01-12 23:07:05 -0800497 if err != nil {
498 return Config{}, err
499 }
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700500 targets[Android] = androidTargets
Dan Willemsen322acaf2016-01-12 23:07:05 -0800501 }
502
Colin Cross3b19f5d2019-09-17 14:45:31 -0700503 multilib := make(map[string]bool)
504 for _, target := range targets[Android] {
505 if seen := multilib[target.Arch.ArchType.Multilib]; seen {
506 config.multilibConflicts[target.Arch.ArchType] = true
507 }
508 multilib[target.Arch.ArchType.Multilib] = true
509 }
510
Jingwen Chenc711fec2020-11-22 23:52:50 -0500511 // Map of OS to compilation targets.
Colin Crossa1ad8d12016-06-01 17:09:44 -0700512 config.Targets = targets
Jingwen Chenc711fec2020-11-22 23:52:50 -0500513
514 // Compilation targets for host tools.
Colin Cross0c66bc62021-07-20 09:47:41 -0700515 config.BuildOSTarget = config.Targets[config.BuildOS][0]
516 config.BuildOSCommonTarget = getCommonTargets(config.Targets[config.BuildOS])[0]
Jingwen Chenc711fec2020-11-22 23:52:50 -0500517
518 // Compilation targets for Android.
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700519 if len(config.Targets[Android]) > 0 {
520 config.AndroidCommonTarget = getCommonTargets(config.Targets[Android])[0]
Sam Delmericocc271e22022-06-01 15:45:02 +0000521 config.AndroidFirstDeviceTarget = FirstTarget(config.Targets[Android], "lib64", "lib32")[0]
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700522 }
Dan Willemsen218f6562015-07-08 18:13:11 -0700523
Usta Shresthacae3bfa2022-12-21 11:44:26 -0500524 setBuildMode := func(arg string, mode SoongBuildMode) {
525 if arg != "" {
526 if config.BuildMode != AnalysisNoBazel {
527 fmt.Fprintf(os.Stderr, "buildMode is already set, illegal argument: %s", arg)
528 os.Exit(1)
529 }
530 config.BuildMode = mode
531 }
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800532 }
Usta Shresthacae3bfa2022-12-21 11:44:26 -0500533 setBazelMode := func(arg bool, argName string, mode SoongBuildMode) {
534 if arg {
535 if config.BuildMode != AnalysisNoBazel {
536 fmt.Fprintf(os.Stderr, "buildMode is already set, illegal argument: %s", argName)
537 os.Exit(1)
538 }
539 config.BuildMode = mode
540 }
541 }
542 setBuildMode(cmdArgs.SymlinkForestMarker, SymlinkForest)
543 setBuildMode(cmdArgs.Bp2buildMarker, Bp2build)
544 setBuildMode(cmdArgs.BazelQueryViewDir, GenerateQueryView)
545 setBuildMode(cmdArgs.BazelApiBp2buildDir, ApiBp2build)
546 setBuildMode(cmdArgs.ModuleGraphFile, GenerateModuleGraph)
547 setBuildMode(cmdArgs.DocFile, GenerateDocFile)
548 setBazelMode(cmdArgs.BazelModeDev, "--bazel-mode-dev", BazelDevMode)
549 setBazelMode(cmdArgs.BazelMode, "--bazel-mode", BazelProdMode)
550 setBazelMode(cmdArgs.BazelModeStaging, "--bazel-mode-staging", BazelStagingMode)
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800551
Chris Parsonsf3c96ef2020-09-29 02:23:17 -0400552 config.BazelContext, err = NewBazelContext(config)
Cole Faust324a92e2022-08-23 15:29:05 -0700553 config.Bp2buildPackageConfig = GetBp2BuildAllowList()
Colin Cross3f40fa42015-01-30 17:27:36 -0800554
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800555 for _, module := range strings.Split(cmdArgs.BazelForceEnabledModules, ",") {
MarkDacekd06db5d2022-11-29 00:47:59 +0000556 config.bazelForceEnabledModules[module] = struct{}{}
557 }
558
Jingwen Chenc711fec2020-11-22 23:52:50 -0500559 return Config{config}, err
560}
Colin Cross988414c2020-01-11 01:11:46 +0000561
Colin Cross98be1bb2019-12-13 20:41:13 -0800562// mockFileSystem replaces all reads with accesses to the provided map of
563// filenames to contents stored as a byte slice.
564func (c *config) mockFileSystem(bp string, fs map[string][]byte) {
565 mockFS := map[string][]byte{}
566
567 if _, exists := mockFS["Android.bp"]; !exists {
568 mockFS["Android.bp"] = []byte(bp)
569 }
570
571 for k, v := range fs {
572 mockFS[k] = v
573 }
574
575 // no module list file specified; find every file named Blueprints or Android.bp
576 pathsToParse := []string{}
577 for candidate := range mockFS {
578 base := filepath.Base(candidate)
Lukacs T. Berkib838b0a2021-09-02 11:46:24 +0200579 if base == "Android.bp" {
Colin Cross98be1bb2019-12-13 20:41:13 -0800580 pathsToParse = append(pathsToParse, candidate)
581 }
582 }
583 if len(pathsToParse) < 1 {
584 panic(fmt.Sprintf("No Blueprint or Android.bp files found in mock filesystem: %v\n", mockFS))
585 }
586 mockFS[blueprint.MockModuleListFile] = []byte(strings.Join(pathsToParse, "\n"))
587
588 c.fs = pathtools.MockFs(mockFS)
589 c.mockBpList = blueprint.MockModuleListFile
590}
591
Jason Wuff1bb312022-12-21 09:57:26 -0500592// TODO(b/265062549): Add a field to our collected (and uploaded) metrics which
593// describes a reason that we fell back to non-mixed builds.
Chris Parsonsad876012022-08-20 14:48:32 -0400594// Returns true if "Bazel builds" is enabled. In this mode, part of build
595// analysis is handled by Bazel.
596func (c *config) IsMixedBuildsEnabled() bool {
Chris Parsons428c30f2022-11-29 14:14:52 -0500597 globalMixedBuildsSupport := c.Once(OnceKey{"globalMixedBuildsSupport"}, func() interface{} {
598 if c.productVariables.DeviceArch != nil && *c.productVariables.DeviceArch == "riscv64" {
Chris Parsons428c30f2022-11-29 14:14:52 -0500599 return false
600 }
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500601 if c.IsEnvTrue("GLOBAL_THINLTO") {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500602 return false
603 }
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500604 if len(c.productVariables.SanitizeHost) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500605 return false
606 }
607 if len(c.productVariables.SanitizeDevice) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500608 return false
609 }
610 if len(c.productVariables.SanitizeDeviceDiag) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500611 return false
612 }
613 if len(c.productVariables.SanitizeDeviceArch) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500614 return false
615 }
Chris Parsons428c30f2022-11-29 14:14:52 -0500616 return true
617 }).(bool)
618
619 bazelModeEnabled := c.BuildMode == BazelProdMode || c.BuildMode == BazelDevMode || c.BuildMode == BazelStagingMode
620 return globalMixedBuildsSupport && bazelModeEnabled
Chris Parsonsad876012022-08-20 14:48:32 -0400621}
622
Lukacs T. Berkid1e3f1f2021-03-16 08:55:23 +0100623func (c *config) SetAllowMissingDependencies() {
624 c.productVariables.Allow_missing_dependencies = proptools.BoolPtr(true)
625}
626
Jingwen Chenc711fec2020-11-22 23:52:50 -0500627// BlueprintToolLocation returns the directory containing build system tools
628// from Blueprint, like soong_zip and merge_zips.
Lukacs T. Berkia806e412021-09-01 08:57:48 +0200629func (c *config) HostToolDir() string {
Colin Crossacfcc1f2021-10-25 15:40:32 -0700630 if c.KatiEnabled() {
631 return filepath.Join(c.outDir, "host", c.PrebuiltOS(), "bin")
632 } else {
633 return filepath.Join(c.soongOutDir, "host", c.PrebuiltOS(), "bin")
634 }
Dan Willemsenc2aa4a92016-05-26 15:13:03 -0700635}
636
Dan Willemsen60e62f02018-11-16 21:05:32 -0800637func (c *config) HostToolPath(ctx PathContext, tool string) Path {
Colin Cross790ef352021-10-25 19:15:55 -0700638 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "bin", false, tool)
639 return path
Dan Willemsen60e62f02018-11-16 21:05:32 -0800640}
641
Colin Cross790ef352021-10-25 19:15:55 -0700642func (c *config) HostJNIToolPath(ctx PathContext, lib string) Path {
Martin Stjernholm7260d062019-12-09 21:47:14 +0000643 ext := ".so"
644 if runtime.GOOS == "darwin" {
645 ext = ".dylib"
646 }
Colin Cross790ef352021-10-25 19:15:55 -0700647 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "lib64", false, lib+ext)
648 return path
Martin Stjernholm7260d062019-12-09 21:47:14 +0000649}
650
Colin Crossae5330a2021-11-03 13:31:22 -0700651func (c *config) HostJavaToolPath(ctx PathContext, tool string) Path {
652 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "framework", false, tool)
Colin Cross3e3eda62021-11-04 10:22:51 -0700653 return path
654}
655
Jingwen Chenc711fec2020-11-22 23:52:50 -0500656// PrebuiltOS returns the name of the host OS used in prebuilts directories.
Colin Cross1332b002015-04-07 17:11:30 -0700657func (c *config) PrebuiltOS() string {
Colin Cross3f40fa42015-01-30 17:27:36 -0800658 switch runtime.GOOS {
659 case "linux":
660 return "linux-x86"
661 case "darwin":
662 return "darwin-x86"
663 default:
664 panic("Unknown GOOS")
665 }
666}
667
668// GoRoot returns the path to the root directory of the Go toolchain.
Colin Cross1332b002015-04-07 17:11:30 -0700669func (c *config) GoRoot() string {
Lukacs T. Berkif7e36d82021-08-16 17:05:09 +0200670 return fmt.Sprintf("prebuilts/go/%s", c.PrebuiltOS())
Colin Cross3f40fa42015-01-30 17:27:36 -0800671}
672
Jingwen Chenc711fec2020-11-22 23:52:50 -0500673// PrebuiltBuildTool returns the path to a tool in the prebuilts directory containing
674// checked-in tools, like Kati, Ninja or Toybox, for the current host OS.
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700675func (c *config) PrebuiltBuildTool(ctx PathContext, tool string) Path {
676 return PathForSource(ctx, "prebuilts/build-tools", c.PrebuiltOS(), "bin", tool)
677}
678
Jingwen Chenc711fec2020-11-22 23:52:50 -0500679// CpPreserveSymlinksFlags returns the host-specific flag for the cp(1) command
680// to preserve symlinks.
Colin Cross1332b002015-04-07 17:11:30 -0700681func (c *config) CpPreserveSymlinksFlags() string {
Colin Cross485e5722015-08-27 13:28:01 -0700682 switch runtime.GOOS {
Colin Cross3f40fa42015-01-30 17:27:36 -0800683 case "darwin":
684 return "-R"
685 case "linux":
686 return "-d"
687 default:
688 return ""
689 }
690}
Colin Cross68f55102015-03-25 14:43:57 -0700691
Colin Cross1332b002015-04-07 17:11:30 -0700692func (c *config) Getenv(key string) string {
Colin Cross68f55102015-03-25 14:43:57 -0700693 var val string
694 var exists bool
Colin Crossc1e86a32015-04-15 12:33:28 -0700695 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800696 defer c.envLock.Unlock()
697 if c.envDeps == nil {
698 c.envDeps = make(map[string]string)
699 }
Colin Cross68f55102015-03-25 14:43:57 -0700700 if val, exists = c.envDeps[key]; !exists {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700701 if c.envFrozen {
702 panic("Cannot access new environment variables after envdeps are frozen")
703 }
Colin Cross6ccbc912017-10-10 23:07:38 -0700704 val, _ = c.env[key]
Colin Cross68f55102015-03-25 14:43:57 -0700705 c.envDeps[key] = val
706 }
707 return val
708}
709
Colin Cross99d7c232016-11-23 16:52:04 -0800710func (c *config) GetenvWithDefault(key string, defaultValue string) string {
711 ret := c.Getenv(key)
712 if ret == "" {
713 return defaultValue
714 }
715 return ret
716}
717
718func (c *config) IsEnvTrue(key string) bool {
719 value := c.Getenv(key)
720 return value == "1" || value == "y" || value == "yes" || value == "on" || value == "true"
721}
722
723func (c *config) IsEnvFalse(key string) bool {
724 value := c.Getenv(key)
725 return value == "0" || value == "n" || value == "no" || value == "off" || value == "false"
726}
727
Sorin Basca384250c2023-02-02 17:56:19 +0000728func (c *config) TargetsJava17() bool {
729 return c.IsEnvTrue("EXPERIMENTAL_TARGET_JAVA_VERSION_17")
730}
731
Jingwen Chenc711fec2020-11-22 23:52:50 -0500732// EnvDeps returns the environment variables this build depends on. The first
733// call to this function blocks future reads from the environment.
Colin Cross1332b002015-04-07 17:11:30 -0700734func (c *config) EnvDeps() map[string]string {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700735 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800736 defer c.envLock.Unlock()
Dan Willemsene7680ba2015-09-11 17:06:19 -0700737 c.envFrozen = true
Colin Cross68f55102015-03-25 14:43:57 -0700738 return c.envDeps
739}
Colin Cross35cec122015-04-02 14:37:16 -0700740
Jingwen Chencda22c92020-11-23 00:22:30 -0500741func (c *config) KatiEnabled() bool {
742 return c.katiEnabled
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800743}
744
Nan Zhang581fd212018-01-10 16:06:12 -0800745func (c *config) BuildId() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800746 return String(c.productVariables.BuildId)
Nan Zhang581fd212018-01-10 16:06:12 -0800747}
748
Jingwen Chenc711fec2020-11-22 23:52:50 -0500749// BuildNumberFile returns the path to a text file containing metadata
750// representing the current build's number.
751//
752// Rules that want to reference the build number should read from this file
753// without depending on it. They will run whenever their other dependencies
754// require them to run and get the current build number. This ensures they don't
755// rebuild on every incremental build when the build number changes.
Colin Cross2a2e0db2020-02-21 16:55:46 -0800756func (c *config) BuildNumberFile(ctx PathContext) Path {
757 return PathForOutput(ctx, String(c.productVariables.BuildNumberFile))
Nan Zhang581fd212018-01-10 16:06:12 -0800758}
759
Jingwen Chenc711fec2020-11-22 23:52:50 -0500760// DeviceName returns the name of the current device target.
Colin Cross35cec122015-04-02 14:37:16 -0700761// TODO: take an AndroidModuleContext to select the device name for multi-device builds
Colin Cross1332b002015-04-07 17:11:30 -0700762func (c *config) DeviceName() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800763 return *c.productVariables.DeviceName
Colin Cross35cec122015-04-02 14:37:16 -0700764}
765
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000766// DeviceProduct returns the current product target. There could be multiple of
767// these per device type.
768//
Chris Parsonsef615e52022-08-18 22:04:11 -0400769// NOTE: Do not base conditional logic on this value. It may break product inheritance.
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000770func (c *config) DeviceProduct() string {
771 return *c.productVariables.DeviceProduct
772}
773
Cole Faustb85d1a12022-11-08 18:14:01 -0800774// HasDeviceProduct returns if the build has a product. A build will not
775// necessarily have a product when --skip-config is passed to soong, like it is
776// in prebuilts/build-tools/build-prebuilts.sh
777func (c *config) HasDeviceProduct() bool {
778 return c.productVariables.DeviceProduct != nil
779}
780
Anton Hansson53c88442019-03-18 15:53:16 +0000781func (c *config) DeviceResourceOverlays() []string {
782 return c.productVariables.DeviceResourceOverlays
783}
784
785func (c *config) ProductResourceOverlays() []string {
786 return c.productVariables.ProductResourceOverlays
Colin Cross30e076a2015-04-13 13:58:27 -0700787}
788
Colin Crossbfd347d2018-05-09 11:11:35 -0700789func (c *config) PlatformVersionName() string {
790 return String(c.productVariables.Platform_version_name)
791}
792
Dan Albert4f378d72020-07-23 17:32:15 -0700793func (c *config) PlatformSdkVersion() ApiLevel {
794 return uncheckedFinalApiLevel(*c.productVariables.Platform_sdk_version)
Colin Cross30e076a2015-04-13 13:58:27 -0700795}
796
Mu-Le Lee5e047532022-07-27 02:32:03 +0000797func (c *config) PlatformSdkFinal() bool {
798 return Bool(c.productVariables.Platform_sdk_final)
799}
800
Colin Crossd09b0b62018-04-18 11:06:47 -0700801func (c *config) PlatformSdkCodename() string {
802 return String(c.productVariables.Platform_sdk_codename)
803}
804
Anton Hansson97d0bae2022-02-16 16:15:10 +0000805func (c *config) PlatformSdkExtensionVersion() int {
806 return *c.productVariables.Platform_sdk_extension_version
807}
808
809func (c *config) PlatformBaseSdkExtensionVersion() int {
810 return *c.productVariables.Platform_base_sdk_extension_version
811}
812
Colin Cross092c9da2019-04-02 22:56:43 -0700813func (c *config) PlatformSecurityPatch() string {
814 return String(c.productVariables.Platform_security_patch)
815}
816
817func (c *config) PlatformPreviewSdkVersion() string {
818 return String(c.productVariables.Platform_preview_sdk_version)
819}
820
821func (c *config) PlatformMinSupportedTargetSdkVersion() string {
822 return String(c.productVariables.Platform_min_supported_target_sdk_version)
823}
824
825func (c *config) PlatformBaseOS() string {
826 return String(c.productVariables.Platform_base_os)
827}
828
Inseob Kim4f1f3d92022-04-25 18:23:58 +0900829func (c *config) PlatformVersionLastStable() string {
830 return String(c.productVariables.Platform_version_last_stable)
831}
832
Jiyong Park37073842022-06-21 10:13:42 +0900833func (c *config) PlatformVersionKnownCodenames() string {
834 return String(c.productVariables.Platform_version_known_codenames)
835}
836
Dan Albert1a246272020-07-06 14:49:35 -0700837func (c *config) MinSupportedSdkVersion() ApiLevel {
Dan Albert6bfb6bb2022-08-17 20:11:57 +0000838 return uncheckedFinalApiLevel(21)
Dan Albert1a246272020-07-06 14:49:35 -0700839}
840
841func (c *config) FinalApiLevels() []ApiLevel {
842 var levels []ApiLevel
Dan Albert4f378d72020-07-23 17:32:15 -0700843 for i := 1; i <= c.PlatformSdkVersion().FinalOrFutureInt(); i++ {
Dan Albert1a246272020-07-06 14:49:35 -0700844 levels = append(levels, uncheckedFinalApiLevel(i))
845 }
846 return levels
847}
848
849func (c *config) PreviewApiLevels() []ApiLevel {
850 var levels []ApiLevel
851 for i, codename := range c.PlatformVersionActiveCodenames() {
852 levels = append(levels, ApiLevel{
853 value: codename,
854 number: i,
855 isPreview: true,
856 })
857 }
858 return levels
859}
860
satayevcca4ab72021-11-30 12:33:55 +0000861func (c *config) LatestPreviewApiLevel() ApiLevel {
862 level := NoneApiLevel
863 for _, l := range c.PreviewApiLevels() {
864 if l.GreaterThan(level) {
865 level = l
866 }
867 }
868 return level
869}
870
Dan Albert1a246272020-07-06 14:49:35 -0700871func (c *config) AllSupportedApiLevels() []ApiLevel {
872 var levels []ApiLevel
873 levels = append(levels, c.FinalApiLevels()...)
874 return append(levels, c.PreviewApiLevels()...)
Dan Albertf5415d72017-08-17 16:19:59 -0700875}
876
Jingwen Chenc711fec2020-11-22 23:52:50 -0500877// DefaultAppTargetSdk returns the API level that platform apps are targeting.
878// This converts a codename to the exact ApiLevel it represents.
Dan Albert4f378d72020-07-23 17:32:15 -0700879func (c *config) DefaultAppTargetSdk(ctx EarlyModuleContext) ApiLevel {
Colin Crossd09b0b62018-04-18 11:06:47 -0700880 if Bool(c.productVariables.Platform_sdk_final) {
881 return c.PlatformSdkVersion()
Colin Crossd09b0b62018-04-18 11:06:47 -0700882 }
Jingwen Chenc711fec2020-11-22 23:52:50 -0500883 codename := c.PlatformSdkCodename()
884 if codename == "" {
885 return NoneApiLevel
886 }
887 if codename == "REL" {
888 panic("Platform_sdk_codename should not be REL when Platform_sdk_final is true")
889 }
890 return ApiLevelOrPanic(ctx, codename)
Colin Crossd09b0b62018-04-18 11:06:47 -0700891}
892
Colin Cross3bc7ffa2017-11-22 16:19:37 -0800893func (c *config) AppsDefaultVersionName() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800894 return String(c.productVariables.AppsDefaultVersionName)
Colin Cross3bc7ffa2017-11-22 16:19:37 -0800895}
896
Dan Albert31384de2017-07-28 12:39:46 -0700897// Codenames that are active in the current lunch target.
898func (c *config) PlatformVersionActiveCodenames() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800899 return c.productVariables.Platform_version_active_codenames
Dan Albert31384de2017-07-28 12:39:46 -0700900}
901
Colin Crossface4e42017-10-30 17:32:15 -0700902func (c *config) ProductAAPTConfig() []string {
Colin Crossa74ca042019-01-31 14:31:51 -0800903 return c.productVariables.AAPTConfig
Colin Cross30e076a2015-04-13 13:58:27 -0700904}
905
Colin Crossface4e42017-10-30 17:32:15 -0700906func (c *config) ProductAAPTPreferredConfig() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800907 return String(c.productVariables.AAPTPreferredConfig)
Colin Cross30e076a2015-04-13 13:58:27 -0700908}
909
Colin Crossface4e42017-10-30 17:32:15 -0700910func (c *config) ProductAAPTCharacteristics() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800911 return String(c.productVariables.AAPTCharacteristics)
Colin Crossface4e42017-10-30 17:32:15 -0700912}
913
914func (c *config) ProductAAPTPrebuiltDPI() []string {
Colin Crossa74ca042019-01-31 14:31:51 -0800915 return c.productVariables.AAPTPrebuiltDPI
Colin Cross30e076a2015-04-13 13:58:27 -0700916}
917
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700918func (c *config) DefaultAppCertificateDir(ctx PathContext) SourcePath {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800919 defaultCert := String(c.productVariables.DefaultAppCertificate)
Colin Cross61ae0b72017-12-01 17:16:02 -0800920 if defaultCert != "" {
921 return PathForSource(ctx, filepath.Dir(defaultCert))
Colin Cross61ae0b72017-12-01 17:16:02 -0800922 }
Jingwen Chenc711fec2020-11-22 23:52:50 -0500923 return PathForSource(ctx, "build/make/target/product/security")
Colin Cross30e076a2015-04-13 13:58:27 -0700924}
925
Colin Crosse1731a52017-12-14 11:22:55 -0800926func (c *config) DefaultAppCertificate(ctx PathContext) (pem, key SourcePath) {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800927 defaultCert := String(c.productVariables.DefaultAppCertificate)
Colin Cross61ae0b72017-12-01 17:16:02 -0800928 if defaultCert != "" {
Colin Crosse1731a52017-12-14 11:22:55 -0800929 return PathForSource(ctx, defaultCert+".x509.pem"), PathForSource(ctx, defaultCert+".pk8")
Colin Cross61ae0b72017-12-01 17:16:02 -0800930 }
Jingwen Chenc711fec2020-11-22 23:52:50 -0500931 defaultDir := c.DefaultAppCertificateDir(ctx)
932 return defaultDir.Join(ctx, "testkey.x509.pem"), defaultDir.Join(ctx, "testkey.pk8")
Colin Cross30e076a2015-04-13 13:58:27 -0700933}
Colin Cross6ff51382015-12-17 16:39:19 -0800934
Jiyong Park9335a262018-12-24 11:31:58 +0900935func (c *config) ApexKeyDir(ctx ModuleContext) SourcePath {
936 // TODO(b/121224311): define another variable such as TARGET_APEX_KEY_OVERRIDE
937 defaultCert := String(c.productVariables.DefaultAppCertificate)
Dan Willemsen412160e2019-04-09 21:36:26 -0700938 if defaultCert == "" || filepath.Dir(defaultCert) == "build/make/target/product/security" {
Jiyong Park9335a262018-12-24 11:31:58 +0900939 // When defaultCert is unset or is set to the testkeys path, use the APEX keys
940 // that is under the module dir
Colin Cross07e51612019-03-05 12:46:40 -0800941 return pathForModuleSrc(ctx)
Jiyong Park9335a262018-12-24 11:31:58 +0900942 }
Jingwen Chenc711fec2020-11-22 23:52:50 -0500943 // If not, APEX keys are under the specified directory
944 return PathForSource(ctx, filepath.Dir(defaultCert))
Jiyong Park9335a262018-12-24 11:31:58 +0900945}
946
Inseob Kim80fa7982022-08-12 21:36:25 +0900947// Certificate for the NetworkStack sepolicy context
948func (c *config) MainlineSepolicyDevCertificatesDir(ctx ModuleContext) SourcePath {
949 cert := String(c.productVariables.MainlineSepolicyDevCertificates)
950 if cert != "" {
951 return PathForSource(ctx, cert)
952 }
953 return c.DefaultAppCertificateDir(ctx)
954}
955
Jingwen Chenc711fec2020-11-22 23:52:50 -0500956// AllowMissingDependencies configures Blueprint/Soong to not fail when modules
957// are configured to depend on non-existent modules. Note that this does not
958// affect missing input dependencies at the Ninja level.
Colin Cross6ff51382015-12-17 16:39:19 -0800959func (c *config) AllowMissingDependencies() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800960 return Bool(c.productVariables.Allow_missing_dependencies)
Colin Cross6ff51382015-12-17 16:39:19 -0800961}
Dan Willemsen322acaf2016-01-12 23:07:05 -0800962
Jeongik Cha816a23a2020-07-08 01:09:23 +0900963// Returns true if a full platform source tree cannot be assumed.
Colin Crossfc3674a2017-09-18 17:41:52 -0700964func (c *config) UnbundledBuild() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800965 return Bool(c.productVariables.Unbundled_build)
Colin Crossfc3674a2017-09-18 17:41:52 -0700966}
967
Martin Stjernholmfd9eb4b2020-06-17 01:13:15 +0100968// Returns true if building apps that aren't bundled with the platform.
969// UnbundledBuild() is always true when this is true.
970func (c *config) UnbundledBuildApps() bool {
Cole Faust701ca252021-11-23 19:02:08 -0800971 return len(c.productVariables.Unbundled_build_apps) > 0
Martin Stjernholmfd9eb4b2020-06-17 01:13:15 +0100972}
973
Jeongik Cha4b073cd2021-06-08 11:35:00 +0900974// Returns true if building image that aren't bundled with the platform.
975// UnbundledBuild() is always true when this is true.
976func (c *config) UnbundledBuildImage() bool {
977 return Bool(c.productVariables.Unbundled_build_image)
978}
979
Jeongik Cha816a23a2020-07-08 01:09:23 +0900980// Returns true if building modules against prebuilt SDKs.
981func (c *config) AlwaysUsePrebuiltSdks() bool {
982 return Bool(c.productVariables.Always_use_prebuilt_sdks)
Colin Cross1f367bf2018-12-18 22:46:24 -0800983}
984
Colin Cross126a25c2017-10-31 13:55:34 -0700985func (c *config) MinimizeJavaDebugInfo() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800986 return Bool(c.productVariables.MinimizeJavaDebugInfo) && !Bool(c.productVariables.Eng)
Colin Cross126a25c2017-10-31 13:55:34 -0700987}
988
Colin Crossed064c02018-09-05 16:28:13 -0700989func (c *config) Debuggable() bool {
990 return Bool(c.productVariables.Debuggable)
991}
992
Jaewoong Jung1d6eb682018-11-29 15:08:44 -0800993func (c *config) Eng() bool {
994 return Bool(c.productVariables.Eng)
995}
996
Colin Crossc53c37f2021-12-08 15:42:22 -0800997// DevicePrimaryArchType returns the ArchType for the first configured device architecture, or
998// Common if there are no device architectures.
Jiyong Park8d52f862018-07-07 18:02:07 +0900999func (c *config) DevicePrimaryArchType() ArchType {
Colin Crossc53c37f2021-12-08 15:42:22 -08001000 if androidTargets := c.Targets[Android]; len(androidTargets) > 0 {
1001 return androidTargets[0].Arch.ArchType
1002 }
1003 return Common
Jiyong Park8d52f862018-07-07 18:02:07 +09001004}
1005
Colin Cross16b23492016-01-06 14:41:07 -08001006func (c *config) SanitizeHost() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001007 return append([]string(nil), c.productVariables.SanitizeHost...)
Colin Cross16b23492016-01-06 14:41:07 -08001008}
1009
1010func (c *config) SanitizeDevice() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001011 return append([]string(nil), c.productVariables.SanitizeDevice...)
Colin Cross23ae82a2016-11-02 14:34:39 -07001012}
1013
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -07001014func (c *config) SanitizeDeviceDiag() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001015 return append([]string(nil), c.productVariables.SanitizeDeviceDiag...)
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -07001016}
1017
Colin Cross23ae82a2016-11-02 14:34:39 -07001018func (c *config) SanitizeDeviceArch() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001019 return append([]string(nil), c.productVariables.SanitizeDeviceArch...)
Colin Cross16b23492016-01-06 14:41:07 -08001020}
Colin Crossa1ad8d12016-06-01 17:09:44 -07001021
Vishwath Mohan1b017a72017-01-19 13:54:55 -08001022func (c *config) EnableCFI() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001023 if c.productVariables.EnableCFI == nil {
Vishwath Mohanc32c3eb2017-01-24 14:20:54 -08001024 return true
Vishwath Mohanc32c3eb2017-01-24 14:20:54 -08001025 }
Jingwen Chenc711fec2020-11-22 23:52:50 -05001026 return *c.productVariables.EnableCFI
Vishwath Mohan1b017a72017-01-19 13:54:55 -08001027}
1028
Kostya Kortchinskyd5275c82019-02-01 08:42:56 -08001029func (c *config) DisableScudo() bool {
1030 return Bool(c.productVariables.DisableScudo)
1031}
1032
Colin Crossa1ad8d12016-06-01 17:09:44 -07001033func (c *config) Android64() bool {
Dan Willemsen0ef639b2018-10-10 17:02:29 -07001034 for _, t := range c.Targets[Android] {
Colin Crossa1ad8d12016-06-01 17:09:44 -07001035 if t.Arch.ArchType.Multilib == "lib64" {
1036 return true
1037 }
1038 }
1039
1040 return false
1041}
Colin Cross9272ade2016-08-17 15:24:12 -07001042
Colin Cross9d45bb72016-08-29 16:14:13 -07001043func (c *config) UseGoma() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001044 return Bool(c.productVariables.UseGoma)
Colin Cross9d45bb72016-08-29 16:14:13 -07001045}
1046
Ramy Medhatbbf25672019-07-17 12:30:04 +00001047func (c *config) UseRBE() bool {
1048 return Bool(c.productVariables.UseRBE)
1049}
1050
Ramy Medhat8ea054a2020-01-27 14:19:44 -05001051func (c *config) UseRBEJAVAC() bool {
1052 return Bool(c.productVariables.UseRBEJAVAC)
1053}
1054
1055func (c *config) UseRBER8() bool {
1056 return Bool(c.productVariables.UseRBER8)
1057}
1058
1059func (c *config) UseRBED8() bool {
1060 return Bool(c.productVariables.UseRBED8)
1061}
1062
Colin Cross8b8bec32019-11-15 13:18:43 -08001063func (c *config) UseRemoteBuild() bool {
1064 return c.UseGoma() || c.UseRBE()
1065}
1066
Colin Cross66548102018-06-19 22:47:35 -07001067func (c *config) RunErrorProne() bool {
1068 return c.IsEnvTrue("RUN_ERROR_PRONE")
1069}
1070
Jingwen Chenc711fec2020-11-22 23:52:50 -05001071// XrefCorpusName returns the Kythe cross-reference corpus name.
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001072func (c *config) XrefCorpusName() string {
1073 return c.Getenv("XREF_CORPUS")
1074}
1075
Jingwen Chenc711fec2020-11-22 23:52:50 -05001076// XrefCuEncoding returns the compilation unit encoding to use for Kythe code
1077// xrefs. Can be 'json' (default), 'proto' or 'all'.
Sasha Smundak6c2d4f92020-01-09 17:34:23 -08001078func (c *config) XrefCuEncoding() string {
1079 if enc := c.Getenv("KYTHE_KZIP_ENCODING"); enc != "" {
1080 return enc
1081 }
1082 return "json"
1083}
1084
Sasha Smundakb0addaf2021-02-16 10:39:40 -08001085// XrefCuJavaSourceMax returns the maximum number of the Java source files
1086// in a single compilation unit
1087const xrefJavaSourceFileMaxDefault = "1000"
1088
1089func (c Config) XrefCuJavaSourceMax() string {
1090 v := c.Getenv("KYTHE_JAVA_SOURCE_BATCH_SIZE")
1091 if v == "" {
1092 return xrefJavaSourceFileMaxDefault
1093 }
1094 if _, err := strconv.ParseUint(v, 0, 0); err != nil {
1095 fmt.Fprintf(os.Stderr,
1096 "bad KYTHE_JAVA_SOURCE_BATCH_SIZE value: %s, will use %s",
1097 err, xrefJavaSourceFileMaxDefault)
1098 return xrefJavaSourceFileMaxDefault
1099 }
1100 return v
1101
1102}
1103
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001104func (c *config) EmitXrefRules() bool {
1105 return c.XrefCorpusName() != ""
1106}
1107
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001108func (c *config) ClangTidy() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001109 return Bool(c.productVariables.ClangTidy)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001110}
1111
1112func (c *config) TidyChecks() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001113 if c.productVariables.TidyChecks == nil {
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001114 return ""
1115 }
Dan Willemsen45133ac2018-03-09 21:22:06 -08001116 return *c.productVariables.TidyChecks
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001117}
1118
Colin Cross0f4e0d62016-07-27 10:56:55 -07001119func (c *config) LibartImgHostBaseAddress() string {
1120 return "0x60000000"
1121}
1122
1123func (c *config) LibartImgDeviceBaseAddress() string {
Elliott Hughesda3a0712020-03-06 16:55:28 -08001124 return "0x70000000"
Colin Cross0f4e0d62016-07-27 10:56:55 -07001125}
1126
Hiroshi Yamauchie2a10632016-12-19 13:44:41 -08001127func (c *config) ArtUseReadBarrier() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001128 return Bool(c.productVariables.ArtUseReadBarrier)
Hiroshi Yamauchie2a10632016-12-19 13:44:41 -08001129}
1130
Jingwen Chenc711fec2020-11-22 23:52:50 -05001131// Enforce Runtime Resource Overlays for a module. RROs supersede static RROs,
1132// but some modules still depend on it.
1133//
1134// More info: https://source.android.com/devices/architecture/rros
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001135func (c *config) EnforceRROForModule(name string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001136 enforceList := c.productVariables.EnforceRROTargets
Jeongik Chacee5ba92021-02-19 12:11:51 +09001137
Roland Levillainf6cc2612020-07-09 16:58:14 +01001138 if len(enforceList) > 0 {
Yo Chiang4ebd06a2019-10-01 13:13:41 +08001139 if InList("*", enforceList) {
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001140 return true
1141 }
Colin Crossa74ca042019-01-31 14:31:51 -08001142 return InList(name, enforceList)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001143 }
1144 return false
1145}
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001146func (c *config) EnforceRROExcludedOverlay(path string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001147 excluded := c.productVariables.EnforceRROExcludedOverlays
Roland Levillainf6cc2612020-07-09 16:58:14 +01001148 if len(excluded) > 0 {
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001149 return HasAnyPrefix(path, excluded)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001150 }
1151 return false
1152}
1153
1154func (c *config) ExportedNamespaces() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001155 return append([]string(nil), c.productVariables.NamespacesToExport...)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001156}
1157
Spandan Dasc5763832022-11-08 18:42:16 +00001158func (c *config) IncludeTags() []string {
1159 return c.productVariables.IncludeTags
1160}
1161
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001162func (c *config) HostStaticBinaries() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001163 return Bool(c.productVariables.HostStaticBinaries)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001164}
1165
Colin Cross5a0dcd52018-10-05 14:20:06 -07001166func (c *config) UncompressPrivAppDex() bool {
1167 return Bool(c.productVariables.UncompressPrivAppDex)
1168}
1169
1170func (c *config) ModulesLoadedByPrivilegedModules() []string {
1171 return c.productVariables.ModulesLoadedByPrivilegedModules
1172}
1173
Jingwen Chenc711fec2020-11-22 23:52:50 -05001174// DexpreoptGlobalConfigPath returns the path to the dexpreopt.config file in
1175// the output directory, if it was created during the product configuration
1176// phase by Kati.
Jingwen Chenebb0b572020-11-02 00:24:57 -05001177func (c *config) DexpreoptGlobalConfigPath(ctx PathContext) OptionalPath {
Colin Cross988414c2020-01-11 01:11:46 +00001178 if c.productVariables.DexpreoptGlobalConfig == nil {
Jingwen Chenebb0b572020-11-02 00:24:57 -05001179 return OptionalPathForPath(nil)
1180 }
1181 return OptionalPathForPath(
1182 pathForBuildToolDep(ctx, *c.productVariables.DexpreoptGlobalConfig))
1183}
1184
Jingwen Chenc711fec2020-11-22 23:52:50 -05001185// DexpreoptGlobalConfig returns the raw byte contents of the dexpreopt global
1186// configuration. Since the configuration file was created by Kati during
1187// product configuration (externally of soong_build), it's not tracked, so we
1188// also manually add a Ninja file dependency on the configuration file to the
1189// rule that creates the main build.ninja file. This ensures that build.ninja is
1190// regenerated correctly if dexpreopt.config changes.
Jingwen Chenebb0b572020-11-02 00:24:57 -05001191func (c *config) DexpreoptGlobalConfig(ctx PathContext) ([]byte, error) {
1192 path := c.DexpreoptGlobalConfigPath(ctx)
1193 if !path.Valid() {
Colin Cross988414c2020-01-11 01:11:46 +00001194 return nil, nil
1195 }
Jingwen Chenebb0b572020-11-02 00:24:57 -05001196 ctx.AddNinjaFileDeps(path.String())
Sasha Smundakaf5ca922022-12-12 21:23:34 -08001197 return os.ReadFile(absolutePath(path.String()))
Colin Cross43f08db2018-11-12 10:13:39 -08001198}
1199
Inseob Kim7b85eeb2021-03-23 20:52:24 +09001200func (c *deviceConfig) WithDexpreopt() bool {
1201 return c.config.productVariables.WithDexpreopt
1202}
1203
Colin Cross662d6142022-11-03 20:38:01 -07001204func (c *config) FrameworksBaseDirExists(ctx PathGlobContext) bool {
Colin Cross5a756a62021-03-16 16:34:46 -07001205 return ExistentPathForSource(ctx, "frameworks", "base", "Android.bp").Valid()
David Brazdil91b4e3e2019-01-23 21:04:05 +00001206}
1207
Inseob Kimae553032019-05-14 18:52:49 +09001208func (c *config) VndkSnapshotBuildArtifacts() bool {
1209 return Bool(c.productVariables.VndkSnapshotBuildArtifacts)
1210}
1211
Colin Cross3b19f5d2019-09-17 14:45:31 -07001212func (c *config) HasMultilibConflict(arch ArchType) bool {
1213 return c.multilibConflicts[arch]
1214}
1215
Sasha Smundakaf5ca922022-12-12 21:23:34 -08001216func (c *config) PrebuiltHiddenApiDir(_ PathContext) string {
Bill Peckhambae47492021-01-08 09:34:44 -08001217 return String(c.productVariables.PrebuiltHiddenApiDir)
1218}
1219
MarkDacekd06db5d2022-11-29 00:47:59 +00001220func (c *config) BazelModulesForceEnabledByFlag() map[string]struct{} {
1221 return c.bazelForceEnabledModules
1222}
1223
Colin Cross9272ade2016-08-17 15:24:12 -07001224func (c *deviceConfig) Arches() []Arch {
1225 var arches []Arch
Dan Willemsen0ef639b2018-10-10 17:02:29 -07001226 for _, target := range c.config.Targets[Android] {
Colin Cross9272ade2016-08-17 15:24:12 -07001227 arches = append(arches, target.Arch)
1228 }
1229 return arches
1230}
Dan Willemsend2ede872016-11-18 14:54:24 -08001231
Jayant Chowdhary34ce67d2018-03-08 11:00:50 -08001232func (c *deviceConfig) BinderBitness() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001233 is32BitBinder := c.config.productVariables.Binder32bit
Jayant Chowdhary34ce67d2018-03-08 11:00:50 -08001234 if is32BitBinder != nil && *is32BitBinder {
1235 return "32"
1236 }
1237 return "64"
1238}
1239
Dan Willemsen4353bc42016-12-05 17:16:02 -08001240func (c *deviceConfig) VendorPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001241 if c.config.productVariables.VendorPath != nil {
1242 return *c.config.productVariables.VendorPath
Dan Willemsen4353bc42016-12-05 17:16:02 -08001243 }
1244 return "vendor"
1245}
1246
Justin Yun71549282017-11-17 12:10:28 +09001247func (c *deviceConfig) VndkVersion() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001248 return String(c.config.productVariables.DeviceVndkVersion)
Justin Yun71549282017-11-17 12:10:28 +09001249}
1250
Jose Galmes6f843bc2020-12-11 13:36:29 -08001251func (c *deviceConfig) RecoverySnapshotVersion() string {
1252 return String(c.config.productVariables.RecoverySnapshotVersion)
1253}
1254
Jeongik Cha219141c2020-08-06 23:00:37 +09001255func (c *deviceConfig) CurrentApiLevelForVendorModules() string {
1256 return StringDefault(c.config.productVariables.DeviceCurrentApiLevelForVendorModules, "current")
1257}
1258
Justin Yun8fe12122017-12-07 17:18:15 +09001259func (c *deviceConfig) PlatformVndkVersion() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001260 return String(c.config.productVariables.Platform_vndk_version)
Justin Yun8fe12122017-12-07 17:18:15 +09001261}
1262
Justin Yun5f7f7e82019-11-18 19:52:14 +09001263func (c *deviceConfig) ProductVndkVersion() string {
1264 return String(c.config.productVariables.ProductVndkVersion)
1265}
1266
Justin Yun71549282017-11-17 12:10:28 +09001267func (c *deviceConfig) ExtraVndkVersions() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001268 return c.config.productVariables.ExtraVndkVersions
Dan Willemsend2ede872016-11-18 14:54:24 -08001269}
Jack He8cc71432016-12-08 15:45:07 -08001270
Vic Yangefd249e2018-11-12 20:19:56 -08001271func (c *deviceConfig) VndkUseCoreVariant() bool {
1272 return Bool(c.config.productVariables.VndkUseCoreVariant)
1273}
1274
Jiyong Park1a5d7b12018-01-15 15:05:10 +09001275func (c *deviceConfig) SystemSdkVersions() []string {
Colin Crossa74ca042019-01-31 14:31:51 -08001276 return c.config.productVariables.DeviceSystemSdkVersions
Jiyong Park1a5d7b12018-01-15 15:05:10 +09001277}
1278
1279func (c *deviceConfig) PlatformSystemSdkVersions() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001280 return c.config.productVariables.Platform_systemsdk_versions
Jiyong Park1a5d7b12018-01-15 15:05:10 +09001281}
1282
Jiyong Park2db76922017-11-08 16:03:48 +09001283func (c *deviceConfig) OdmPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001284 if c.config.productVariables.OdmPath != nil {
1285 return *c.config.productVariables.OdmPath
Jiyong Park2db76922017-11-08 16:03:48 +09001286 }
1287 return "odm"
1288}
1289
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +09001290func (c *deviceConfig) ProductPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001291 if c.config.productVariables.ProductPath != nil {
1292 return *c.config.productVariables.ProductPath
Jiyong Park2db76922017-11-08 16:03:48 +09001293 }
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +09001294 return "product"
Jiyong Park2db76922017-11-08 16:03:48 +09001295}
1296
Justin Yund5f6c822019-06-25 16:47:17 +09001297func (c *deviceConfig) SystemExtPath() string {
1298 if c.config.productVariables.SystemExtPath != nil {
1299 return *c.config.productVariables.SystemExtPath
Dario Frenifd05a742018-05-29 13:28:54 +01001300 }
Justin Yund5f6c822019-06-25 16:47:17 +09001301 return "system_ext"
Dario Frenifd05a742018-05-29 13:28:54 +01001302}
1303
Jack He8cc71432016-12-08 15:45:07 -08001304func (c *deviceConfig) BtConfigIncludeDir() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001305 return String(c.config.productVariables.BtConfigIncludeDir)
Jack He8cc71432016-12-08 15:45:07 -08001306}
Dan Willemsen581341d2017-02-09 16:16:31 -08001307
Jiyong Parkd773eb32017-07-03 13:18:12 +09001308func (c *deviceConfig) DeviceKernelHeaderDirs() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001309 return c.config.productVariables.DeviceKernelHeaders
Jiyong Parkd773eb32017-07-03 13:18:12 +09001310}
1311
Roland Levillainada12702020-06-09 13:07:36 +01001312// JavaCoverageEnabledForPath returns whether Java code coverage is enabled for
1313// path. Coverage is enabled by default when the product variable
1314// JavaCoveragePaths is empty. If JavaCoveragePaths is not empty, coverage is
1315// enabled for any path which is part of this variable (and not part of the
1316// JavaCoverageExcludePaths product variable). Value "*" in JavaCoveragePaths
1317// represents any path.
1318func (c *deviceConfig) JavaCoverageEnabledForPath(path string) bool {
1319 coverage := false
Chris Gross2f748692020-06-24 20:36:59 +00001320 if len(c.config.productVariables.JavaCoveragePaths) == 0 ||
Roland Levillainada12702020-06-09 13:07:36 +01001321 InList("*", c.config.productVariables.JavaCoveragePaths) ||
1322 HasAnyPrefix(path, c.config.productVariables.JavaCoveragePaths) {
1323 coverage = true
1324 }
Roland Levillainf6cc2612020-07-09 16:58:14 +01001325 if coverage && len(c.config.productVariables.JavaCoverageExcludePaths) > 0 {
Roland Levillainada12702020-06-09 13:07:36 +01001326 if HasAnyPrefix(path, c.config.productVariables.JavaCoverageExcludePaths) {
1327 coverage = false
1328 }
1329 }
1330 return coverage
1331}
1332
Colin Cross1a6acd42020-06-16 17:51:46 -07001333// Returns true if gcov or clang coverage is enabled.
Dan Willemsen581341d2017-02-09 16:16:31 -08001334func (c *deviceConfig) NativeCoverageEnabled() bool {
Colin Cross1a6acd42020-06-16 17:51:46 -07001335 return Bool(c.config.productVariables.GcovCoverage) ||
1336 Bool(c.config.productVariables.ClangCoverage)
Dan Willemsen581341d2017-02-09 16:16:31 -08001337}
1338
Oliver Nguyen1382ab62019-12-06 15:22:41 -08001339func (c *deviceConfig) ClangCoverageEnabled() bool {
1340 return Bool(c.config.productVariables.ClangCoverage)
1341}
1342
Pirama Arumuga Nainarb37ae582022-01-26 22:14:32 -08001343func (c *deviceConfig) ClangCoverageContinuousMode() bool {
1344 return Bool(c.config.productVariables.ClangCoverageContinuousMode)
1345}
1346
Colin Cross1a6acd42020-06-16 17:51:46 -07001347func (c *deviceConfig) GcovCoverageEnabled() bool {
1348 return Bool(c.config.productVariables.GcovCoverage)
1349}
1350
Roland Levillain4f5297b2020-06-09 12:44:06 +01001351// NativeCoverageEnabledForPath returns whether (GCOV- or Clang-based) native
1352// code coverage is enabled for path. By default, coverage is not enabled for a
1353// given path unless it is part of the NativeCoveragePaths product variable (and
1354// not part of the NativeCoverageExcludePaths product variable). Value "*" in
1355// NativeCoveragePaths represents any path.
1356func (c *deviceConfig) NativeCoverageEnabledForPath(path string) bool {
Ryan Campbell469a18a2017-02-27 09:01:54 -08001357 coverage := false
Roland Levillainf6cc2612020-07-09 16:58:14 +01001358 if len(c.config.productVariables.NativeCoveragePaths) > 0 {
Roland Levillain4f5297b2020-06-09 12:44:06 +01001359 if InList("*", c.config.productVariables.NativeCoveragePaths) || HasAnyPrefix(path, c.config.productVariables.NativeCoveragePaths) {
Ivan Lozano5f595532017-07-13 14:46:05 -07001360 coverage = true
Dan Willemsen581341d2017-02-09 16:16:31 -08001361 }
1362 }
Roland Levillainf6cc2612020-07-09 16:58:14 +01001363 if coverage && len(c.config.productVariables.NativeCoverageExcludePaths) > 0 {
Roland Levillain4f5297b2020-06-09 12:44:06 +01001364 if HasAnyPrefix(path, c.config.productVariables.NativeCoverageExcludePaths) {
Ivan Lozano5f595532017-07-13 14:46:05 -07001365 coverage = false
Ryan Campbell469a18a2017-02-27 09:01:54 -08001366 }
1367 }
1368 return coverage
Dan Willemsen581341d2017-02-09 16:16:31 -08001369}
Ivan Lozano5f595532017-07-13 14:46:05 -07001370
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -08001371func (c *deviceConfig) PgoAdditionalProfileDirs() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001372 return c.config.productVariables.PgoAdditionalProfileDirs
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -08001373}
1374
Tri Vo35a51432018-03-25 20:00:00 -07001375func (c *deviceConfig) VendorSepolicyDirs() []string {
1376 return c.config.productVariables.BoardVendorSepolicyDirs
1377}
1378
1379func (c *deviceConfig) OdmSepolicyDirs() []string {
1380 return c.config.productVariables.BoardOdmSepolicyDirs
1381}
1382
Felixa20a8752020-05-17 18:28:35 +02001383func (c *deviceConfig) SystemExtPublicSepolicyDirs() []string {
1384 return c.config.productVariables.SystemExtPublicSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -07001385}
1386
Felixa20a8752020-05-17 18:28:35 +02001387func (c *deviceConfig) SystemExtPrivateSepolicyDirs() []string {
1388 return c.config.productVariables.SystemExtPrivateSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -07001389}
1390
Inseob Kim0866b002019-04-15 20:21:29 +09001391func (c *deviceConfig) SepolicyM4Defs() []string {
1392 return c.config.productVariables.BoardSepolicyM4Defs
1393}
1394
Jiyong Park7f67f482019-01-05 12:57:48 +09001395func (c *deviceConfig) OverrideManifestPackageNameFor(name string) (manifestName string, overridden bool) {
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001396 return findOverrideValue(c.config.productVariables.ManifestPackageNameOverrides, name,
1397 "invalid override rule %q in PRODUCT_MANIFEST_PACKAGE_NAME_OVERRIDES should be <module_name>:<manifest_name>")
1398}
1399
1400func (c *deviceConfig) OverrideCertificateFor(name string) (certificatePath string, overridden bool) {
Jaewoong Jungacb6db32019-02-28 16:22:30 +00001401 return findOverrideValue(c.config.productVariables.CertificateOverrides, name,
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001402 "invalid override rule %q in PRODUCT_CERTIFICATE_OVERRIDES should be <module_name>:<certificate_module_name>")
1403}
1404
Jaewoong Jung9d22a912019-01-23 16:27:47 -08001405func (c *deviceConfig) OverridePackageNameFor(name string) string {
1406 newName, overridden := findOverrideValue(
1407 c.config.productVariables.PackageNameOverrides,
1408 name,
1409 "invalid override rule %q in PRODUCT_PACKAGE_NAME_OVERRIDES should be <module_name>:<package_name>")
1410 if overridden {
1411 return newName
1412 }
1413 return name
1414}
1415
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001416func findOverrideValue(overrides []string, name string, errorMsg string) (newValue string, overridden bool) {
Jiyong Park7f67f482019-01-05 12:57:48 +09001417 if overrides == nil || len(overrides) == 0 {
1418 return "", false
1419 }
1420 for _, o := range overrides {
1421 split := strings.Split(o, ":")
1422 if len(split) != 2 {
1423 // This shouldn't happen as this is first checked in make, but just in case.
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001424 panic(fmt.Errorf(errorMsg, o))
Jiyong Park7f67f482019-01-05 12:57:48 +09001425 }
1426 if matchPattern(split[0], name) {
1427 return substPattern(split[0], split[1], name), true
1428 }
1429 }
1430 return "", false
1431}
1432
Albert Martineefabcf2022-03-21 20:11:16 +00001433func (c *deviceConfig) ApexGlobalMinSdkVersionOverride() string {
1434 return String(c.config.productVariables.ApexGlobalMinSdkVersionOverride)
1435}
1436
Ivan Lozano5f595532017-07-13 14:46:05 -07001437func (c *config) IntegerOverflowDisabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001438 if len(c.productVariables.IntegerOverflowExcludePaths) == 0 {
Ivan Lozano5f595532017-07-13 14:46:05 -07001439 return false
1440 }
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001441 return HasAnyPrefix(path, c.productVariables.IntegerOverflowExcludePaths)
Ivan Lozano5f595532017-07-13 14:46:05 -07001442}
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001443
1444func (c *config) CFIDisabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001445 if len(c.productVariables.CFIExcludePaths) == 0 {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001446 return false
1447 }
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001448 return HasAnyPrefix(path, c.productVariables.CFIExcludePaths)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001449}
1450
1451func (c *config) CFIEnabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001452 if len(c.productVariables.CFIIncludePaths) == 0 {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001453 return false
1454 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001455 return HasAnyPrefix(path, c.productVariables.CFIIncludePaths) && !c.CFIDisabledForPath(path)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001456}
Colin Crosse15ddaf2017-12-04 11:24:31 -08001457
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001458func (c *config) MemtagHeapDisabledForPath(path string) bool {
1459 if len(c.productVariables.MemtagHeapExcludePaths) == 0 {
1460 return false
1461 }
1462 return HasAnyPrefix(path, c.productVariables.MemtagHeapExcludePaths)
1463}
1464
1465func (c *config) MemtagHeapAsyncEnabledForPath(path string) bool {
1466 if len(c.productVariables.MemtagHeapAsyncIncludePaths) == 0 {
1467 return false
1468 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001469 return HasAnyPrefix(path, c.productVariables.MemtagHeapAsyncIncludePaths) && !c.MemtagHeapDisabledForPath(path)
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001470}
1471
1472func (c *config) MemtagHeapSyncEnabledForPath(path string) bool {
1473 if len(c.productVariables.MemtagHeapSyncIncludePaths) == 0 {
1474 return false
1475 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001476 return HasAnyPrefix(path, c.productVariables.MemtagHeapSyncIncludePaths) && !c.MemtagHeapDisabledForPath(path)
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001477}
1478
Dan Willemsen0fe78662018-03-26 12:41:18 -07001479func (c *config) VendorConfig(name string) VendorConfig {
Colin Cross9d34f352019-11-22 16:03:51 -08001480 return soongconfig.Config(c.productVariables.VendorVars[name])
Dan Willemsen0fe78662018-03-26 12:41:18 -07001481}
1482
Colin Cross395f2cf2018-10-24 16:10:32 -07001483func (c *config) NdkAbis() bool {
1484 return Bool(c.productVariables.Ndk_abis)
1485}
1486
Martin Stjernholmc1ecc432019-11-15 15:00:31 +00001487func (c *config) AmlAbis() bool {
1488 return Bool(c.productVariables.Aml_abis)
1489}
1490
Jiyong Park8fd61922018-11-08 02:50:25 +09001491func (c *config) FlattenApex() bool {
Roland Levillaina3863212019-08-12 19:56:16 +01001492 return Bool(c.productVariables.Flatten_apex)
Jiyong Park8fd61922018-11-08 02:50:25 +09001493}
1494
Jiyong Park4da07972021-01-05 21:01:11 +09001495func (c *config) ForceApexSymlinkOptimization() bool {
1496 return Bool(c.productVariables.ForceApexSymlinkOptimization)
1497}
1498
Sasha Smundakfe9a5b82022-07-27 14:51:45 -07001499func (c *config) ApexCompressionEnabled() bool {
1500 return Bool(c.productVariables.CompressedApex) && !c.UnbundledBuildApps()
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +00001501}
1502
Dennis Shene2ed70c2023-01-11 14:15:43 +00001503func (c *config) ApexTrimEnabled() bool {
1504 return Bool(c.productVariables.TrimmedApex)
1505}
1506
Jeongik Chac9464142019-01-07 12:07:27 +09001507func (c *config) EnforceSystemCertificate() bool {
1508 return Bool(c.productVariables.EnforceSystemCertificate)
1509}
1510
Colin Cross440e0d02020-06-11 11:32:11 -07001511func (c *config) EnforceSystemCertificateAllowList() []string {
1512 return c.productVariables.EnforceSystemCertificateAllowList
Jeongik Chac9464142019-01-07 12:07:27 +09001513}
1514
Jeongik Cha2cc570d2019-10-29 15:44:45 +09001515func (c *config) EnforceProductPartitionInterface() bool {
1516 return Bool(c.productVariables.EnforceProductPartitionInterface)
1517}
1518
JaeMan Parkff715562020-10-19 17:25:58 +09001519func (c *config) EnforceInterPartitionJavaSdkLibrary() bool {
1520 return Bool(c.productVariables.EnforceInterPartitionJavaSdkLibrary)
1521}
1522
1523func (c *config) InterPartitionJavaLibraryAllowList() []string {
1524 return c.productVariables.InterPartitionJavaLibraryAllowList
1525}
1526
Jooyung Han3ab2c3e2019-12-05 16:27:44 +09001527func (c *config) InstallExtraFlattenedApexes() bool {
1528 return Bool(c.productVariables.InstallExtraFlattenedApexes)
1529}
1530
Colin Crossf24a22a2019-01-31 14:12:44 -08001531func (c *config) ProductHiddenAPIStubs() []string {
1532 return c.productVariables.ProductHiddenAPIStubs
Colin Cross8faf8fc2019-01-16 15:15:52 -08001533}
1534
Colin Crossf24a22a2019-01-31 14:12:44 -08001535func (c *config) ProductHiddenAPIStubsSystem() []string {
1536 return c.productVariables.ProductHiddenAPIStubsSystem
Colin Cross8faf8fc2019-01-16 15:15:52 -08001537}
1538
Colin Crossf24a22a2019-01-31 14:12:44 -08001539func (c *config) ProductHiddenAPIStubsTest() []string {
1540 return c.productVariables.ProductHiddenAPIStubsTest
Colin Cross8faf8fc2019-01-16 15:15:52 -08001541}
Dan Willemsen71c74602019-04-10 12:27:35 -07001542
Dan Willemsen54879d12019-04-18 10:08:46 -07001543func (c *deviceConfig) TargetFSConfigGen() []string {
Dan Willemsen71c74602019-04-10 12:27:35 -07001544 return c.config.productVariables.TargetFSConfigGen
1545}
Inseob Kim0866b002019-04-15 20:21:29 +09001546
1547func (c *config) ProductPublicSepolicyDirs() []string {
1548 return c.productVariables.ProductPublicSepolicyDirs
1549}
1550
1551func (c *config) ProductPrivateSepolicyDirs() []string {
1552 return c.productVariables.ProductPrivateSepolicyDirs
1553}
1554
Colin Cross50ddcc42019-05-16 12:28:22 -07001555func (c *config) MissingUsesLibraries() []string {
1556 return c.productVariables.MissingUsesLibraries
1557}
1558
Inseob Kim5eb7ee92022-04-27 10:30:34 +09001559func (c *config) TargetMultitreeUpdateMeta() bool {
1560 return c.productVariables.MultitreeUpdateMeta
1561}
1562
Inseob Kim1f086e22019-05-09 13:29:15 +09001563func (c *deviceConfig) DeviceArch() string {
1564 return String(c.config.productVariables.DeviceArch)
1565}
1566
1567func (c *deviceConfig) DeviceArchVariant() string {
1568 return String(c.config.productVariables.DeviceArchVariant)
1569}
1570
1571func (c *deviceConfig) DeviceSecondaryArch() string {
1572 return String(c.config.productVariables.DeviceSecondaryArch)
1573}
1574
1575func (c *deviceConfig) DeviceSecondaryArchVariant() string {
1576 return String(c.config.productVariables.DeviceSecondaryArchVariant)
1577}
Yifan Hong82db7352020-01-21 16:12:26 -08001578
1579func (c *deviceConfig) BoardUsesRecoveryAsBoot() bool {
1580 return Bool(c.config.productVariables.BoardUsesRecoveryAsBoot)
1581}
Yifan Hong97365ee2020-07-29 09:51:57 -07001582
1583func (c *deviceConfig) BoardKernelBinaries() []string {
1584 return c.config.productVariables.BoardKernelBinaries
1585}
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001586
Yifan Hong42bef8d2020-08-05 14:36:09 -07001587func (c *deviceConfig) BoardKernelModuleInterfaceVersions() []string {
1588 return c.config.productVariables.BoardKernelModuleInterfaceVersions
1589}
1590
Yifan Hongdd8dacc2020-10-21 15:40:17 -07001591func (c *deviceConfig) BoardMoveRecoveryResourcesToVendorBoot() bool {
1592 return Bool(c.config.productVariables.BoardMoveRecoveryResourcesToVendorBoot)
1593}
1594
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001595func (c *deviceConfig) PlatformSepolicyVersion() string {
1596 return String(c.config.productVariables.PlatformSepolicyVersion)
1597}
1598
Inseob Kima10ef272021-09-15 03:04:53 +00001599func (c *deviceConfig) TotSepolicyVersion() string {
1600 return String(c.config.productVariables.TotSepolicyVersion)
1601}
1602
Inseob Kim843f6642022-01-07 09:11:23 +09001603func (c *deviceConfig) PlatformSepolicyCompatVersions() []string {
1604 return c.config.productVariables.PlatformSepolicyCompatVersions
1605}
1606
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001607func (c *deviceConfig) BoardSepolicyVers() string {
Inseob Kim0c4eec82021-03-22 22:33:40 +09001608 if ver := String(c.config.productVariables.BoardSepolicyVers); ver != "" {
1609 return ver
1610 }
1611 return c.PlatformSepolicyVersion()
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001612}
1613
Inseob Kim14178802021-12-08 22:53:31 +09001614func (c *deviceConfig) BoardPlatVendorPolicy() []string {
1615 return c.config.productVariables.BoardPlatVendorPolicy
1616}
1617
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001618func (c *deviceConfig) BoardReqdMaskPolicy() []string {
1619 return c.config.productVariables.BoardReqdMaskPolicy
1620}
1621
Inseob Kim0f46e7c2021-12-15 22:48:14 +09001622func (c *deviceConfig) BoardSystemExtPublicPrebuiltDirs() []string {
1623 return c.config.productVariables.BoardSystemExtPublicPrebuiltDirs
1624}
1625
1626func (c *deviceConfig) BoardSystemExtPrivatePrebuiltDirs() []string {
1627 return c.config.productVariables.BoardSystemExtPrivatePrebuiltDirs
1628}
1629
1630func (c *deviceConfig) BoardProductPublicPrebuiltDirs() []string {
1631 return c.config.productVariables.BoardProductPublicPrebuiltDirs
1632}
1633
1634func (c *deviceConfig) BoardProductPrivatePrebuiltDirs() []string {
1635 return c.config.productVariables.BoardProductPrivatePrebuiltDirs
1636}
1637
Inseob Kim1a0afcc2022-02-14 23:10:51 +09001638func (c *deviceConfig) SystemExtSepolicyPrebuiltApiDir() string {
1639 return String(c.config.productVariables.SystemExtSepolicyPrebuiltApiDir)
1640}
1641
1642func (c *deviceConfig) ProductSepolicyPrebuiltApiDir() string {
1643 return String(c.config.productVariables.ProductSepolicyPrebuiltApiDir)
1644}
1645
1646func (c *deviceConfig) IsPartnerTrebleSepolicyTestEnabled() bool {
1647 return c.SystemExtSepolicyPrebuiltApiDir() != "" || c.ProductSepolicyPrebuiltApiDir() != ""
1648}
1649
Inseob Kim7cf14652021-01-06 23:06:52 +09001650func (c *deviceConfig) DirectedVendorSnapshot() bool {
1651 return c.config.productVariables.DirectedVendorSnapshot
1652}
1653
1654func (c *deviceConfig) VendorSnapshotModules() map[string]bool {
1655 return c.config.productVariables.VendorSnapshotModules
1656}
1657
Jose Galmes4c6895e2021-02-09 07:44:30 -08001658func (c *deviceConfig) DirectedRecoverySnapshot() bool {
1659 return c.config.productVariables.DirectedRecoverySnapshot
1660}
1661
1662func (c *deviceConfig) RecoverySnapshotModules() map[string]bool {
1663 return c.config.productVariables.RecoverySnapshotModules
1664}
1665
Justin DeMartino383bfb32021-02-24 10:49:43 -08001666func createDirsMap(previous map[string]bool, dirs []string) (map[string]bool, error) {
1667 var ret = make(map[string]bool)
1668 for _, dir := range dirs {
1669 clean := filepath.Clean(dir)
1670 if previous[clean] || ret[clean] {
1671 return nil, fmt.Errorf("Duplicate entry %s", dir)
1672 }
1673 ret[clean] = true
1674 }
1675 return ret, nil
1676}
1677
1678func (c *deviceConfig) createDirsMapOnce(onceKey OnceKey, previous map[string]bool, dirs []string) map[string]bool {
1679 dirMap := c.Once(onceKey, func() interface{} {
1680 ret, err := createDirsMap(previous, dirs)
1681 if err != nil {
1682 panic(fmt.Errorf("%s: %w", onceKey.key, err))
1683 }
1684 return ret
1685 })
1686 if dirMap == nil {
1687 return nil
1688 }
1689 return dirMap.(map[string]bool)
1690}
1691
1692var vendorSnapshotDirsExcludedKey = NewOnceKey("VendorSnapshotDirsExcludedMap")
1693
1694func (c *deviceConfig) VendorSnapshotDirsExcludedMap() map[string]bool {
1695 return c.createDirsMapOnce(vendorSnapshotDirsExcludedKey, nil,
1696 c.config.productVariables.VendorSnapshotDirsExcluded)
1697}
1698
1699var vendorSnapshotDirsIncludedKey = NewOnceKey("VendorSnapshotDirsIncludedMap")
1700
1701func (c *deviceConfig) VendorSnapshotDirsIncludedMap() map[string]bool {
1702 excludedMap := c.VendorSnapshotDirsExcludedMap()
1703 return c.createDirsMapOnce(vendorSnapshotDirsIncludedKey, excludedMap,
1704 c.config.productVariables.VendorSnapshotDirsIncluded)
1705}
1706
1707var recoverySnapshotDirsExcludedKey = NewOnceKey("RecoverySnapshotDirsExcludedMap")
1708
1709func (c *deviceConfig) RecoverySnapshotDirsExcludedMap() map[string]bool {
1710 return c.createDirsMapOnce(recoverySnapshotDirsExcludedKey, nil,
1711 c.config.productVariables.RecoverySnapshotDirsExcluded)
1712}
1713
1714var recoverySnapshotDirsIncludedKey = NewOnceKey("RecoverySnapshotDirsIncludedMap")
1715
1716func (c *deviceConfig) RecoverySnapshotDirsIncludedMap() map[string]bool {
1717 excludedMap := c.RecoverySnapshotDirsExcludedMap()
1718 return c.createDirsMapOnce(recoverySnapshotDirsIncludedKey, excludedMap,
1719 c.config.productVariables.RecoverySnapshotDirsIncluded)
1720}
1721
Rob Seymour925aa092021-08-10 20:42:03 +00001722func (c *deviceConfig) HostFakeSnapshotEnabled() bool {
1723 return c.config.productVariables.HostFakeSnapshotEnabled
1724}
1725
Inseob Kim60c32f02020-12-21 22:53:05 +09001726func (c *deviceConfig) ShippingApiLevel() ApiLevel {
1727 if c.config.productVariables.ShippingApiLevel == nil {
1728 return NoneApiLevel
1729 }
1730 apiLevel, _ := strconv.Atoi(*c.config.productVariables.ShippingApiLevel)
1731 return uncheckedFinalApiLevel(apiLevel)
1732}
1733
Alix Espinoef47e542022-09-14 19:10:51 +00001734func (c *deviceConfig) BuildBrokenClangAsFlags() bool {
1735 return c.config.productVariables.BuildBrokenClangAsFlags
1736}
1737
1738func (c *deviceConfig) BuildBrokenClangCFlags() bool {
1739 return c.config.productVariables.BuildBrokenClangCFlags
1740}
1741
Alixb5f6d9e2022-04-20 23:00:58 +00001742func (c *deviceConfig) BuildBrokenClangProperty() bool {
1743 return c.config.productVariables.BuildBrokenClangProperty
1744}
1745
Inseob Kim67e5add192021-03-17 18:05:33 +09001746func (c *deviceConfig) BuildBrokenEnforceSyspropOwner() bool {
1747 return c.config.productVariables.BuildBrokenEnforceSyspropOwner
1748}
1749
1750func (c *deviceConfig) BuildBrokenTrebleSyspropNeverallow() bool {
1751 return c.config.productVariables.BuildBrokenTrebleSyspropNeverallow
1752}
1753
Hridya Valsaraju5a5c7d52021-04-02 16:45:24 -07001754func (c *deviceConfig) BuildDebugfsRestrictionsEnabled() bool {
1755 return c.config.productVariables.BuildDebugfsRestrictionsEnabled
1756}
1757
Inseob Kim0cac7b42021-02-03 18:16:46 +09001758func (c *deviceConfig) BuildBrokenVendorPropertyNamespace() bool {
1759 return c.config.productVariables.BuildBrokenVendorPropertyNamespace
1760}
1761
Liz Kammer619be462022-01-28 15:13:39 -05001762func (c *deviceConfig) BuildBrokenInputDir(name string) bool {
1763 return InList(name, c.config.productVariables.BuildBrokenInputDirModules)
1764}
1765
Vinh Tran140d5882022-06-10 14:23:27 -04001766func (c *deviceConfig) BuildBrokenDepfile() bool {
1767 return Bool(c.config.productVariables.BuildBrokenDepfile)
1768}
1769
Inseob Kim67e5add192021-03-17 18:05:33 +09001770func (c *deviceConfig) RequiresInsecureExecmemForSwiftshader() bool {
1771 return c.config.productVariables.RequiresInsecureExecmemForSwiftshader
1772}
1773
1774func (c *config) SelinuxIgnoreNeverallows() bool {
1775 return c.productVariables.SelinuxIgnoreNeverallows
1776}
1777
1778func (c *deviceConfig) SepolicySplit() bool {
1779 return c.config.productVariables.SepolicySplit
1780}
1781
Inseob Kima10ef272021-09-15 03:04:53 +00001782func (c *deviceConfig) SepolicyFreezeTestExtraDirs() []string {
1783 return c.config.productVariables.SepolicyFreezeTestExtraDirs
1784}
1785
1786func (c *deviceConfig) SepolicyFreezeTestExtraPrebuiltDirs() []string {
1787 return c.config.productVariables.SepolicyFreezeTestExtraPrebuiltDirs
1788}
1789
Jiyong Parkd163d4d2021-10-12 16:47:43 +09001790func (c *deviceConfig) GenerateAidlNdkPlatformBackend() bool {
1791 return c.config.productVariables.GenerateAidlNdkPlatformBackend
1792}
1793
Christopher Ferris98f10222022-07-13 23:16:52 -07001794func (c *config) IgnorePrefer32OnDevice() bool {
1795 return c.productVariables.IgnorePrefer32OnDevice
1796}
1797
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001798func (c *config) BootJars() []string {
1799 return c.Once(earlyBootJarsKey, func() interface{} {
Paul Duffin69d1fb12020-10-23 21:14:20 +01001800 list := c.productVariables.BootJars.CopyOfJars()
satayevd604b212021-07-21 14:23:52 +01001801 return append(list, c.productVariables.ApexBootJars.CopyOfJars()...)
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001802 }).([]string)
1803}
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001804
satayevd604b212021-07-21 14:23:52 +01001805func (c *config) NonApexBootJars() ConfiguredJarList {
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001806 return c.productVariables.BootJars
1807}
1808
satayevd604b212021-07-21 14:23:52 +01001809func (c *config) ApexBootJars() ConfiguredJarList {
1810 return c.productVariables.ApexBootJars
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001811}
Colin Cross77cdcfd2021-03-12 11:28:25 -08001812
1813func (c *config) RBEWrapper() string {
1814 return c.GetenvWithDefault("RBE_WRAPPER", remoteexec.DefaultWrapperPath)
1815}
Colin Cross9b698b62021-12-22 09:55:32 -08001816
1817// UseHostMusl returns true if the host target has been configured to build against musl libc.
1818func (c *config) UseHostMusl() bool {
1819 return Bool(c.productVariables.HostMusl)
1820}
MarkDacekff851b82022-04-21 18:33:17 +00001821
Chris Parsonsf874e462022-05-10 13:50:12 -04001822func (c *config) LogMixedBuild(ctx BaseModuleContext, useBazel bool) {
MarkDacekff851b82022-04-21 18:33:17 +00001823 moduleName := ctx.Module().Name()
1824 c.mixedBuildsLock.Lock()
1825 defer c.mixedBuildsLock.Unlock()
1826 if useBazel {
1827 c.mixedBuildEnabledModules[moduleName] = struct{}{}
1828 } else {
1829 c.mixedBuildDisabledModules[moduleName] = struct{}{}
1830 }
1831}