blob: 8886f554d5178af7995384ef50d46920e42038ab [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 }
Chris Parsons0008cf82023-02-03 18:45:43 -0500400 err = pathtools.WriteFileIfChanged(filepath.Join(dir, "product_variables.bzl"),
401 []byte(strings.Join(bzl, "\n")), 0644)
Liz Kammer09f947d2021-05-12 14:51:49 -0400402 if err != nil {
403 return fmt.Errorf("Could not write .bzl config file %s", err)
404 }
Chris Parsons0008cf82023-02-03 18:45:43 -0500405 err = pathtools.WriteFileIfChanged(filepath.Join(dir, "BUILD"),
406 []byte(bazel.GeneratedBazelFileWarning), 0644)
Liz Kammer09f947d2021-05-12 14:51:49 -0400407 if err != nil {
408 return fmt.Errorf("Could not write BUILD config file %s", err)
409 }
410
411 return nil
412}
413
Colin Cross988414c2020-01-11 01:11:46 +0000414// NullConfig returns a mostly empty Config for use by standalone tools like dexpreopt_gen that
415// use the android package.
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200416func NullConfig(outDir, soongOutDir string) Config {
Colin Cross988414c2020-01-11 01:11:46 +0000417 return Config{
418 config: &config{
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200419 outDir: outDir,
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200420 soongOutDir: soongOutDir,
421 fs: pathtools.OsFs,
Colin Cross988414c2020-01-11 01:11:46 +0000422 },
423 }
424}
425
Jingwen Chenc711fec2020-11-22 23:52:50 -0500426// NewConfig creates a new Config object. The srcDir argument specifies the path
427// to the root source directory. It also loads the config file, if found.
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800428func NewConfig(cmdArgs CmdArgs, availableEnv map[string]string) (Config, error) {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500429 // Make a config with default options.
Colin Cross9272ade2016-08-17 15:24:12 -0700430 config := &config{
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800431 ProductVariablesFileName: filepath.Join(cmdArgs.SoongOutDir, productVariablesFileName),
Dan Willemsen87b17d12015-07-14 00:39:06 -0700432
Lukacs T. Berki53b2f362021-04-12 14:04:24 +0200433 env: availableEnv,
Colin Cross6ccbc912017-10-10 23:07:38 -0700434
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800435 outDir: cmdArgs.OutDir,
436 soongOutDir: cmdArgs.SoongOutDir,
437 runGoTests: cmdArgs.RunGoTests,
Lukacs T. Berkie1df43f2021-09-08 15:31:14 +0200438 multilibConflicts: make(map[ArchType]bool),
Colin Cross98be1bb2019-12-13 20:41:13 -0800439
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800440 moduleListFile: cmdArgs.ModuleListFile,
MarkDacekff851b82022-04-21 18:33:17 +0000441 fs: pathtools.NewOsFs(absSrcDir),
442 mixedBuildDisabledModules: make(map[string]struct{}),
443 mixedBuildEnabledModules: make(map[string]struct{}),
MarkDacekd06db5d2022-11-29 00:47:59 +0000444 bazelForceEnabledModules: make(map[string]struct{}),
Colin Cross68f55102015-03-25 14:43:57 -0700445 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800446
Dan Willemsen00269f22017-07-06 16:59:48 -0700447 config.deviceConfig = &deviceConfig{
Colin Cross9272ade2016-08-17 15:24:12 -0700448 config: config,
449 }
450
Liz Kammer7941b302020-07-28 13:27:34 -0700451 // Soundness check of the build and source directories. This won't catch strange
452 // configurations with symlinks, but at least checks the obvious case.
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800453 absBuildDir, err := filepath.Abs(cmdArgs.SoongOutDir)
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700454 if err != nil {
455 return Config{}, err
456 }
457
Lukacs T. Berkif7e36d82021-08-16 17:05:09 +0200458 absSrcDir, err := filepath.Abs(".")
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700459 if err != nil {
460 return Config{}, err
461 }
462
463 if strings.HasPrefix(absSrcDir, absBuildDir) {
464 return Config{}, fmt.Errorf("Build dir must not contain source directory")
465 }
466
Colin Cross3f40fa42015-01-30 17:27:36 -0800467 // Load any configurable options from the configuration file
Colin Cross9272ade2016-08-17 15:24:12 -0700468 err = loadConfig(config)
Colin Cross3f40fa42015-01-30 17:27:36 -0800469 if err != nil {
Colin Crossc3c0a492015-04-10 15:43:55 -0700470 return Config{}, err
Colin Cross3f40fa42015-01-30 17:27:36 -0800471 }
472
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800473 KatiEnabledMarkerFile := filepath.Join(cmdArgs.SoongOutDir, ".soong.kati_enabled")
Jingwen Chencda22c92020-11-23 00:22:30 -0500474 if _, err := os.Stat(absolutePath(KatiEnabledMarkerFile)); err == nil {
475 config.katiEnabled = true
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800476 }
477
Colin Cross0c66bc62021-07-20 09:47:41 -0700478 determineBuildOS(config)
479
Jingwen Chenc711fec2020-11-22 23:52:50 -0500480 // Sets up the map of target OSes to the finer grained compilation targets
481 // that are configured from the product variables.
Colin Crossa1ad8d12016-06-01 17:09:44 -0700482 targets, err := decodeTargetProductVariables(config)
Dan Willemsen218f6562015-07-08 18:13:11 -0700483 if err != nil {
484 return Config{}, err
485 }
486
Paul Duffin1356d8c2020-02-25 19:26:33 +0000487 // Make the CommonOS OsType available for all products.
488 targets[CommonOS] = []Target{commonTargetMap[CommonOS.Name]}
489
Dan Albert4098deb2016-10-19 14:04:41 -0700490 var archConfig []archConfig
Jingwen Chenc4d91bc2020-11-24 22:59:26 -0500491 if config.NdkAbis() {
Dan Albert4098deb2016-10-19 14:04:41 -0700492 archConfig = getNdkAbisConfig()
Martin Stjernholmc1ecc432019-11-15 15:00:31 +0000493 } else if config.AmlAbis() {
494 archConfig = getAmlAbisConfig()
Dan Albert4098deb2016-10-19 14:04:41 -0700495 }
496
497 if archConfig != nil {
Liz Kammerb7f33662022-02-28 14:16:16 -0500498 androidTargets, err := decodeAndroidArchSettings(archConfig)
Dan Willemsen322acaf2016-01-12 23:07:05 -0800499 if err != nil {
500 return Config{}, err
501 }
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700502 targets[Android] = androidTargets
Dan Willemsen322acaf2016-01-12 23:07:05 -0800503 }
504
Colin Cross3b19f5d2019-09-17 14:45:31 -0700505 multilib := make(map[string]bool)
506 for _, target := range targets[Android] {
507 if seen := multilib[target.Arch.ArchType.Multilib]; seen {
508 config.multilibConflicts[target.Arch.ArchType] = true
509 }
510 multilib[target.Arch.ArchType.Multilib] = true
511 }
512
Jingwen Chenc711fec2020-11-22 23:52:50 -0500513 // Map of OS to compilation targets.
Colin Crossa1ad8d12016-06-01 17:09:44 -0700514 config.Targets = targets
Jingwen Chenc711fec2020-11-22 23:52:50 -0500515
516 // Compilation targets for host tools.
Colin Cross0c66bc62021-07-20 09:47:41 -0700517 config.BuildOSTarget = config.Targets[config.BuildOS][0]
518 config.BuildOSCommonTarget = getCommonTargets(config.Targets[config.BuildOS])[0]
Jingwen Chenc711fec2020-11-22 23:52:50 -0500519
520 // Compilation targets for Android.
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700521 if len(config.Targets[Android]) > 0 {
522 config.AndroidCommonTarget = getCommonTargets(config.Targets[Android])[0]
Sam Delmericocc271e22022-06-01 15:45:02 +0000523 config.AndroidFirstDeviceTarget = FirstTarget(config.Targets[Android], "lib64", "lib32")[0]
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700524 }
Dan Willemsen218f6562015-07-08 18:13:11 -0700525
Usta Shresthacae3bfa2022-12-21 11:44:26 -0500526 setBuildMode := func(arg string, mode SoongBuildMode) {
527 if arg != "" {
528 if config.BuildMode != AnalysisNoBazel {
529 fmt.Fprintf(os.Stderr, "buildMode is already set, illegal argument: %s", arg)
530 os.Exit(1)
531 }
532 config.BuildMode = mode
533 }
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800534 }
Usta Shresthacae3bfa2022-12-21 11:44:26 -0500535 setBazelMode := func(arg bool, argName string, mode SoongBuildMode) {
536 if arg {
537 if config.BuildMode != AnalysisNoBazel {
538 fmt.Fprintf(os.Stderr, "buildMode is already set, illegal argument: %s", argName)
539 os.Exit(1)
540 }
541 config.BuildMode = mode
542 }
543 }
544 setBuildMode(cmdArgs.SymlinkForestMarker, SymlinkForest)
545 setBuildMode(cmdArgs.Bp2buildMarker, Bp2build)
546 setBuildMode(cmdArgs.BazelQueryViewDir, GenerateQueryView)
547 setBuildMode(cmdArgs.BazelApiBp2buildDir, ApiBp2build)
548 setBuildMode(cmdArgs.ModuleGraphFile, GenerateModuleGraph)
549 setBuildMode(cmdArgs.DocFile, GenerateDocFile)
550 setBazelMode(cmdArgs.BazelModeDev, "--bazel-mode-dev", BazelDevMode)
551 setBazelMode(cmdArgs.BazelMode, "--bazel-mode", BazelProdMode)
552 setBazelMode(cmdArgs.BazelModeStaging, "--bazel-mode-staging", BazelStagingMode)
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800553
Chris Parsonsf3c96ef2020-09-29 02:23:17 -0400554 config.BazelContext, err = NewBazelContext(config)
Cole Faust324a92e2022-08-23 15:29:05 -0700555 config.Bp2buildPackageConfig = GetBp2BuildAllowList()
Colin Cross3f40fa42015-01-30 17:27:36 -0800556
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800557 for _, module := range strings.Split(cmdArgs.BazelForceEnabledModules, ",") {
MarkDacekd06db5d2022-11-29 00:47:59 +0000558 config.bazelForceEnabledModules[module] = struct{}{}
559 }
560
Jingwen Chenc711fec2020-11-22 23:52:50 -0500561 return Config{config}, err
562}
Colin Cross988414c2020-01-11 01:11:46 +0000563
Colin Cross98be1bb2019-12-13 20:41:13 -0800564// mockFileSystem replaces all reads with accesses to the provided map of
565// filenames to contents stored as a byte slice.
566func (c *config) mockFileSystem(bp string, fs map[string][]byte) {
567 mockFS := map[string][]byte{}
568
569 if _, exists := mockFS["Android.bp"]; !exists {
570 mockFS["Android.bp"] = []byte(bp)
571 }
572
573 for k, v := range fs {
574 mockFS[k] = v
575 }
576
577 // no module list file specified; find every file named Blueprints or Android.bp
578 pathsToParse := []string{}
579 for candidate := range mockFS {
580 base := filepath.Base(candidate)
Lukacs T. Berkib838b0a2021-09-02 11:46:24 +0200581 if base == "Android.bp" {
Colin Cross98be1bb2019-12-13 20:41:13 -0800582 pathsToParse = append(pathsToParse, candidate)
583 }
584 }
585 if len(pathsToParse) < 1 {
586 panic(fmt.Sprintf("No Blueprint or Android.bp files found in mock filesystem: %v\n", mockFS))
587 }
588 mockFS[blueprint.MockModuleListFile] = []byte(strings.Join(pathsToParse, "\n"))
589
590 c.fs = pathtools.MockFs(mockFS)
591 c.mockBpList = blueprint.MockModuleListFile
592}
593
Jason Wuff1bb312022-12-21 09:57:26 -0500594// TODO(b/265062549): Add a field to our collected (and uploaded) metrics which
595// describes a reason that we fell back to non-mixed builds.
Chris Parsonsad876012022-08-20 14:48:32 -0400596// Returns true if "Bazel builds" is enabled. In this mode, part of build
597// analysis is handled by Bazel.
598func (c *config) IsMixedBuildsEnabled() bool {
Chris Parsons428c30f2022-11-29 14:14:52 -0500599 globalMixedBuildsSupport := c.Once(OnceKey{"globalMixedBuildsSupport"}, func() interface{} {
600 if c.productVariables.DeviceArch != nil && *c.productVariables.DeviceArch == "riscv64" {
Chris Parsons428c30f2022-11-29 14:14:52 -0500601 return false
602 }
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500603 if c.IsEnvTrue("GLOBAL_THINLTO") {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500604 return false
605 }
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500606 if len(c.productVariables.SanitizeHost) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500607 return false
608 }
609 if len(c.productVariables.SanitizeDevice) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500610 return false
611 }
612 if len(c.productVariables.SanitizeDeviceDiag) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500613 return false
614 }
615 if len(c.productVariables.SanitizeDeviceArch) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500616 return false
617 }
Chris Parsons428c30f2022-11-29 14:14:52 -0500618 return true
619 }).(bool)
620
621 bazelModeEnabled := c.BuildMode == BazelProdMode || c.BuildMode == BazelDevMode || c.BuildMode == BazelStagingMode
622 return globalMixedBuildsSupport && bazelModeEnabled
Chris Parsonsad876012022-08-20 14:48:32 -0400623}
624
Lukacs T. Berkid1e3f1f2021-03-16 08:55:23 +0100625func (c *config) SetAllowMissingDependencies() {
626 c.productVariables.Allow_missing_dependencies = proptools.BoolPtr(true)
627}
628
Jingwen Chenc711fec2020-11-22 23:52:50 -0500629// BlueprintToolLocation returns the directory containing build system tools
630// from Blueprint, like soong_zip and merge_zips.
Lukacs T. Berkia806e412021-09-01 08:57:48 +0200631func (c *config) HostToolDir() string {
Colin Crossacfcc1f2021-10-25 15:40:32 -0700632 if c.KatiEnabled() {
633 return filepath.Join(c.outDir, "host", c.PrebuiltOS(), "bin")
634 } else {
635 return filepath.Join(c.soongOutDir, "host", c.PrebuiltOS(), "bin")
636 }
Dan Willemsenc2aa4a92016-05-26 15:13:03 -0700637}
638
Dan Willemsen60e62f02018-11-16 21:05:32 -0800639func (c *config) HostToolPath(ctx PathContext, tool string) Path {
Colin Cross790ef352021-10-25 19:15:55 -0700640 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "bin", false, tool)
641 return path
Dan Willemsen60e62f02018-11-16 21:05:32 -0800642}
643
Colin Cross790ef352021-10-25 19:15:55 -0700644func (c *config) HostJNIToolPath(ctx PathContext, lib string) Path {
Martin Stjernholm7260d062019-12-09 21:47:14 +0000645 ext := ".so"
646 if runtime.GOOS == "darwin" {
647 ext = ".dylib"
648 }
Colin Cross790ef352021-10-25 19:15:55 -0700649 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "lib64", false, lib+ext)
650 return path
Martin Stjernholm7260d062019-12-09 21:47:14 +0000651}
652
Colin Crossae5330a2021-11-03 13:31:22 -0700653func (c *config) HostJavaToolPath(ctx PathContext, tool string) Path {
654 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "framework", false, tool)
Colin Cross3e3eda62021-11-04 10:22:51 -0700655 return path
656}
657
Jingwen Chenc711fec2020-11-22 23:52:50 -0500658// PrebuiltOS returns the name of the host OS used in prebuilts directories.
Colin Cross1332b002015-04-07 17:11:30 -0700659func (c *config) PrebuiltOS() string {
Colin Cross3f40fa42015-01-30 17:27:36 -0800660 switch runtime.GOOS {
661 case "linux":
662 return "linux-x86"
663 case "darwin":
664 return "darwin-x86"
665 default:
666 panic("Unknown GOOS")
667 }
668}
669
670// GoRoot returns the path to the root directory of the Go toolchain.
Colin Cross1332b002015-04-07 17:11:30 -0700671func (c *config) GoRoot() string {
Lukacs T. Berkif7e36d82021-08-16 17:05:09 +0200672 return fmt.Sprintf("prebuilts/go/%s", c.PrebuiltOS())
Colin Cross3f40fa42015-01-30 17:27:36 -0800673}
674
Jingwen Chenc711fec2020-11-22 23:52:50 -0500675// PrebuiltBuildTool returns the path to a tool in the prebuilts directory containing
676// checked-in tools, like Kati, Ninja or Toybox, for the current host OS.
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700677func (c *config) PrebuiltBuildTool(ctx PathContext, tool string) Path {
678 return PathForSource(ctx, "prebuilts/build-tools", c.PrebuiltOS(), "bin", tool)
679}
680
Jingwen Chenc711fec2020-11-22 23:52:50 -0500681// CpPreserveSymlinksFlags returns the host-specific flag for the cp(1) command
682// to preserve symlinks.
Colin Cross1332b002015-04-07 17:11:30 -0700683func (c *config) CpPreserveSymlinksFlags() string {
Colin Cross485e5722015-08-27 13:28:01 -0700684 switch runtime.GOOS {
Colin Cross3f40fa42015-01-30 17:27:36 -0800685 case "darwin":
686 return "-R"
687 case "linux":
688 return "-d"
689 default:
690 return ""
691 }
692}
Colin Cross68f55102015-03-25 14:43:57 -0700693
Colin Cross1332b002015-04-07 17:11:30 -0700694func (c *config) Getenv(key string) string {
Colin Cross68f55102015-03-25 14:43:57 -0700695 var val string
696 var exists bool
Colin Crossc1e86a32015-04-15 12:33:28 -0700697 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800698 defer c.envLock.Unlock()
699 if c.envDeps == nil {
700 c.envDeps = make(map[string]string)
701 }
Colin Cross68f55102015-03-25 14:43:57 -0700702 if val, exists = c.envDeps[key]; !exists {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700703 if c.envFrozen {
704 panic("Cannot access new environment variables after envdeps are frozen")
705 }
Colin Cross6ccbc912017-10-10 23:07:38 -0700706 val, _ = c.env[key]
Colin Cross68f55102015-03-25 14:43:57 -0700707 c.envDeps[key] = val
708 }
709 return val
710}
711
Colin Cross99d7c232016-11-23 16:52:04 -0800712func (c *config) GetenvWithDefault(key string, defaultValue string) string {
713 ret := c.Getenv(key)
714 if ret == "" {
715 return defaultValue
716 }
717 return ret
718}
719
720func (c *config) IsEnvTrue(key string) bool {
721 value := c.Getenv(key)
722 return value == "1" || value == "y" || value == "yes" || value == "on" || value == "true"
723}
724
725func (c *config) IsEnvFalse(key string) bool {
726 value := c.Getenv(key)
727 return value == "0" || value == "n" || value == "no" || value == "off" || value == "false"
728}
729
Jingwen Chenc711fec2020-11-22 23:52:50 -0500730// EnvDeps returns the environment variables this build depends on. The first
731// call to this function blocks future reads from the environment.
Colin Cross1332b002015-04-07 17:11:30 -0700732func (c *config) EnvDeps() map[string]string {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700733 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800734 defer c.envLock.Unlock()
Dan Willemsene7680ba2015-09-11 17:06:19 -0700735 c.envFrozen = true
Colin Cross68f55102015-03-25 14:43:57 -0700736 return c.envDeps
737}
Colin Cross35cec122015-04-02 14:37:16 -0700738
Jingwen Chencda22c92020-11-23 00:22:30 -0500739func (c *config) KatiEnabled() bool {
740 return c.katiEnabled
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800741}
742
Nan Zhang581fd212018-01-10 16:06:12 -0800743func (c *config) BuildId() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800744 return String(c.productVariables.BuildId)
Nan Zhang581fd212018-01-10 16:06:12 -0800745}
746
Jingwen Chenc711fec2020-11-22 23:52:50 -0500747// BuildNumberFile returns the path to a text file containing metadata
748// representing the current build's number.
749//
750// Rules that want to reference the build number should read from this file
751// without depending on it. They will run whenever their other dependencies
752// require them to run and get the current build number. This ensures they don't
753// rebuild on every incremental build when the build number changes.
Colin Cross2a2e0db2020-02-21 16:55:46 -0800754func (c *config) BuildNumberFile(ctx PathContext) Path {
755 return PathForOutput(ctx, String(c.productVariables.BuildNumberFile))
Nan Zhang581fd212018-01-10 16:06:12 -0800756}
757
Jingwen Chenc711fec2020-11-22 23:52:50 -0500758// DeviceName returns the name of the current device target.
Colin Cross35cec122015-04-02 14:37:16 -0700759// TODO: take an AndroidModuleContext to select the device name for multi-device builds
Colin Cross1332b002015-04-07 17:11:30 -0700760func (c *config) DeviceName() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800761 return *c.productVariables.DeviceName
Colin Cross35cec122015-04-02 14:37:16 -0700762}
763
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000764// DeviceProduct returns the current product target. There could be multiple of
765// these per device type.
766//
Chris Parsonsef615e52022-08-18 22:04:11 -0400767// NOTE: Do not base conditional logic on this value. It may break product inheritance.
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000768func (c *config) DeviceProduct() string {
769 return *c.productVariables.DeviceProduct
770}
771
Cole Faustb85d1a12022-11-08 18:14:01 -0800772// HasDeviceProduct returns if the build has a product. A build will not
773// necessarily have a product when --skip-config is passed to soong, like it is
774// in prebuilts/build-tools/build-prebuilts.sh
775func (c *config) HasDeviceProduct() bool {
776 return c.productVariables.DeviceProduct != nil
777}
778
Anton Hansson53c88442019-03-18 15:53:16 +0000779func (c *config) DeviceResourceOverlays() []string {
780 return c.productVariables.DeviceResourceOverlays
781}
782
783func (c *config) ProductResourceOverlays() []string {
784 return c.productVariables.ProductResourceOverlays
Colin Cross30e076a2015-04-13 13:58:27 -0700785}
786
Colin Crossbfd347d2018-05-09 11:11:35 -0700787func (c *config) PlatformVersionName() string {
788 return String(c.productVariables.Platform_version_name)
789}
790
Dan Albert4f378d72020-07-23 17:32:15 -0700791func (c *config) PlatformSdkVersion() ApiLevel {
792 return uncheckedFinalApiLevel(*c.productVariables.Platform_sdk_version)
Colin Cross30e076a2015-04-13 13:58:27 -0700793}
794
Mu-Le Lee5e047532022-07-27 02:32:03 +0000795func (c *config) PlatformSdkFinal() bool {
796 return Bool(c.productVariables.Platform_sdk_final)
797}
798
Colin Crossd09b0b62018-04-18 11:06:47 -0700799func (c *config) PlatformSdkCodename() string {
800 return String(c.productVariables.Platform_sdk_codename)
801}
802
Anton Hansson97d0bae2022-02-16 16:15:10 +0000803func (c *config) PlatformSdkExtensionVersion() int {
804 return *c.productVariables.Platform_sdk_extension_version
805}
806
807func (c *config) PlatformBaseSdkExtensionVersion() int {
808 return *c.productVariables.Platform_base_sdk_extension_version
809}
810
Colin Cross092c9da2019-04-02 22:56:43 -0700811func (c *config) PlatformSecurityPatch() string {
812 return String(c.productVariables.Platform_security_patch)
813}
814
815func (c *config) PlatformPreviewSdkVersion() string {
816 return String(c.productVariables.Platform_preview_sdk_version)
817}
818
819func (c *config) PlatformMinSupportedTargetSdkVersion() string {
820 return String(c.productVariables.Platform_min_supported_target_sdk_version)
821}
822
823func (c *config) PlatformBaseOS() string {
824 return String(c.productVariables.Platform_base_os)
825}
826
Inseob Kim4f1f3d92022-04-25 18:23:58 +0900827func (c *config) PlatformVersionLastStable() string {
828 return String(c.productVariables.Platform_version_last_stable)
829}
830
Jiyong Park37073842022-06-21 10:13:42 +0900831func (c *config) PlatformVersionKnownCodenames() string {
832 return String(c.productVariables.Platform_version_known_codenames)
833}
834
Dan Albert1a246272020-07-06 14:49:35 -0700835func (c *config) MinSupportedSdkVersion() ApiLevel {
Dan Albert6bfb6bb2022-08-17 20:11:57 +0000836 return uncheckedFinalApiLevel(21)
Dan Albert1a246272020-07-06 14:49:35 -0700837}
838
839func (c *config) FinalApiLevels() []ApiLevel {
840 var levels []ApiLevel
Dan Albert4f378d72020-07-23 17:32:15 -0700841 for i := 1; i <= c.PlatformSdkVersion().FinalOrFutureInt(); i++ {
Dan Albert1a246272020-07-06 14:49:35 -0700842 levels = append(levels, uncheckedFinalApiLevel(i))
843 }
844 return levels
845}
846
847func (c *config) PreviewApiLevels() []ApiLevel {
848 var levels []ApiLevel
849 for i, codename := range c.PlatformVersionActiveCodenames() {
850 levels = append(levels, ApiLevel{
851 value: codename,
852 number: i,
853 isPreview: true,
854 })
855 }
856 return levels
857}
858
satayevcca4ab72021-11-30 12:33:55 +0000859func (c *config) LatestPreviewApiLevel() ApiLevel {
860 level := NoneApiLevel
861 for _, l := range c.PreviewApiLevels() {
862 if l.GreaterThan(level) {
863 level = l
864 }
865 }
866 return level
867}
868
Dan Albert1a246272020-07-06 14:49:35 -0700869func (c *config) AllSupportedApiLevels() []ApiLevel {
870 var levels []ApiLevel
871 levels = append(levels, c.FinalApiLevels()...)
872 return append(levels, c.PreviewApiLevels()...)
Dan Albertf5415d72017-08-17 16:19:59 -0700873}
874
Jingwen Chenc711fec2020-11-22 23:52:50 -0500875// DefaultAppTargetSdk returns the API level that platform apps are targeting.
876// This converts a codename to the exact ApiLevel it represents.
Dan Albert4f378d72020-07-23 17:32:15 -0700877func (c *config) DefaultAppTargetSdk(ctx EarlyModuleContext) ApiLevel {
Alixfb7f7b92023-03-02 19:35:02 +0000878 // This logic is replicated in starlark, if changing logic here update starlark code too
879 // https://cs.android.com/android/platform/superproject/+/master:build/bazel/rules/common/api.bzl;l=72;drc=231c7e8c8038fd478a79eb68aa5b9f5c64e0e061
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 {
Yi Kong836690b2023-02-16 17:42:27 +09001364 // Workaround coverage boot failure.
1365 // http://b/269981180
1366 if strings.HasPrefix(path, "external/protobuf") {
1367 coverage = false
1368 }
Roland Levillain4f5297b2020-06-09 12:44:06 +01001369 if HasAnyPrefix(path, c.config.productVariables.NativeCoverageExcludePaths) {
Ivan Lozano5f595532017-07-13 14:46:05 -07001370 coverage = false
Ryan Campbell469a18a2017-02-27 09:01:54 -08001371 }
1372 }
1373 return coverage
Dan Willemsen581341d2017-02-09 16:16:31 -08001374}
Ivan Lozano5f595532017-07-13 14:46:05 -07001375
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -08001376func (c *deviceConfig) PgoAdditionalProfileDirs() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001377 return c.config.productVariables.PgoAdditionalProfileDirs
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -08001378}
1379
Tri Vo35a51432018-03-25 20:00:00 -07001380func (c *deviceConfig) VendorSepolicyDirs() []string {
1381 return c.config.productVariables.BoardVendorSepolicyDirs
1382}
1383
1384func (c *deviceConfig) OdmSepolicyDirs() []string {
1385 return c.config.productVariables.BoardOdmSepolicyDirs
1386}
1387
Felixa20a8752020-05-17 18:28:35 +02001388func (c *deviceConfig) SystemExtPublicSepolicyDirs() []string {
1389 return c.config.productVariables.SystemExtPublicSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -07001390}
1391
Felixa20a8752020-05-17 18:28:35 +02001392func (c *deviceConfig) SystemExtPrivateSepolicyDirs() []string {
1393 return c.config.productVariables.SystemExtPrivateSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -07001394}
1395
Inseob Kim0866b002019-04-15 20:21:29 +09001396func (c *deviceConfig) SepolicyM4Defs() []string {
1397 return c.config.productVariables.BoardSepolicyM4Defs
1398}
1399
Jiyong Park7f67f482019-01-05 12:57:48 +09001400func (c *deviceConfig) OverrideManifestPackageNameFor(name string) (manifestName string, overridden bool) {
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001401 return findOverrideValue(c.config.productVariables.ManifestPackageNameOverrides, name,
1402 "invalid override rule %q in PRODUCT_MANIFEST_PACKAGE_NAME_OVERRIDES should be <module_name>:<manifest_name>")
1403}
1404
1405func (c *deviceConfig) OverrideCertificateFor(name string) (certificatePath string, overridden bool) {
Jaewoong Jungacb6db32019-02-28 16:22:30 +00001406 return findOverrideValue(c.config.productVariables.CertificateOverrides, name,
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001407 "invalid override rule %q in PRODUCT_CERTIFICATE_OVERRIDES should be <module_name>:<certificate_module_name>")
1408}
1409
Jaewoong Jung9d22a912019-01-23 16:27:47 -08001410func (c *deviceConfig) OverridePackageNameFor(name string) string {
1411 newName, overridden := findOverrideValue(
1412 c.config.productVariables.PackageNameOverrides,
1413 name,
1414 "invalid override rule %q in PRODUCT_PACKAGE_NAME_OVERRIDES should be <module_name>:<package_name>")
1415 if overridden {
1416 return newName
1417 }
1418 return name
1419}
1420
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001421func findOverrideValue(overrides []string, name string, errorMsg string) (newValue string, overridden bool) {
Jiyong Park7f67f482019-01-05 12:57:48 +09001422 if overrides == nil || len(overrides) == 0 {
1423 return "", false
1424 }
1425 for _, o := range overrides {
1426 split := strings.Split(o, ":")
1427 if len(split) != 2 {
1428 // This shouldn't happen as this is first checked in make, but just in case.
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001429 panic(fmt.Errorf(errorMsg, o))
Jiyong Park7f67f482019-01-05 12:57:48 +09001430 }
1431 if matchPattern(split[0], name) {
1432 return substPattern(split[0], split[1], name), true
1433 }
1434 }
1435 return "", false
1436}
1437
Albert Martineefabcf2022-03-21 20:11:16 +00001438func (c *deviceConfig) ApexGlobalMinSdkVersionOverride() string {
1439 return String(c.config.productVariables.ApexGlobalMinSdkVersionOverride)
1440}
1441
Ivan Lozano5f595532017-07-13 14:46:05 -07001442func (c *config) IntegerOverflowDisabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001443 if len(c.productVariables.IntegerOverflowExcludePaths) == 0 {
Ivan Lozano5f595532017-07-13 14:46:05 -07001444 return false
1445 }
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001446 return HasAnyPrefix(path, c.productVariables.IntegerOverflowExcludePaths)
Ivan Lozano5f595532017-07-13 14:46:05 -07001447}
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001448
1449func (c *config) CFIDisabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001450 if len(c.productVariables.CFIExcludePaths) == 0 {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001451 return false
1452 }
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001453 return HasAnyPrefix(path, c.productVariables.CFIExcludePaths)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001454}
1455
1456func (c *config) CFIEnabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001457 if len(c.productVariables.CFIIncludePaths) == 0 {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001458 return false
1459 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001460 return HasAnyPrefix(path, c.productVariables.CFIIncludePaths) && !c.CFIDisabledForPath(path)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001461}
Colin Crosse15ddaf2017-12-04 11:24:31 -08001462
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001463func (c *config) MemtagHeapDisabledForPath(path string) bool {
1464 if len(c.productVariables.MemtagHeapExcludePaths) == 0 {
1465 return false
1466 }
1467 return HasAnyPrefix(path, c.productVariables.MemtagHeapExcludePaths)
1468}
1469
1470func (c *config) MemtagHeapAsyncEnabledForPath(path string) bool {
1471 if len(c.productVariables.MemtagHeapAsyncIncludePaths) == 0 {
1472 return false
1473 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001474 return HasAnyPrefix(path, c.productVariables.MemtagHeapAsyncIncludePaths) && !c.MemtagHeapDisabledForPath(path)
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001475}
1476
1477func (c *config) MemtagHeapSyncEnabledForPath(path string) bool {
1478 if len(c.productVariables.MemtagHeapSyncIncludePaths) == 0 {
1479 return false
1480 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001481 return HasAnyPrefix(path, c.productVariables.MemtagHeapSyncIncludePaths) && !c.MemtagHeapDisabledForPath(path)
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001482}
1483
Dan Willemsen0fe78662018-03-26 12:41:18 -07001484func (c *config) VendorConfig(name string) VendorConfig {
Colin Cross9d34f352019-11-22 16:03:51 -08001485 return soongconfig.Config(c.productVariables.VendorVars[name])
Dan Willemsen0fe78662018-03-26 12:41:18 -07001486}
1487
Colin Cross395f2cf2018-10-24 16:10:32 -07001488func (c *config) NdkAbis() bool {
1489 return Bool(c.productVariables.Ndk_abis)
1490}
1491
Martin Stjernholmc1ecc432019-11-15 15:00:31 +00001492func (c *config) AmlAbis() bool {
1493 return Bool(c.productVariables.Aml_abis)
1494}
1495
Jiyong Park8fd61922018-11-08 02:50:25 +09001496func (c *config) FlattenApex() bool {
Roland Levillaina3863212019-08-12 19:56:16 +01001497 return Bool(c.productVariables.Flatten_apex)
Jiyong Park8fd61922018-11-08 02:50:25 +09001498}
1499
Jiyong Park4da07972021-01-05 21:01:11 +09001500func (c *config) ForceApexSymlinkOptimization() bool {
1501 return Bool(c.productVariables.ForceApexSymlinkOptimization)
1502}
1503
Sasha Smundakfe9a5b82022-07-27 14:51:45 -07001504func (c *config) ApexCompressionEnabled() bool {
1505 return Bool(c.productVariables.CompressedApex) && !c.UnbundledBuildApps()
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +00001506}
1507
Dennis Shene2ed70c2023-01-11 14:15:43 +00001508func (c *config) ApexTrimEnabled() bool {
1509 return Bool(c.productVariables.TrimmedApex)
1510}
1511
Jeongik Chac9464142019-01-07 12:07:27 +09001512func (c *config) EnforceSystemCertificate() bool {
1513 return Bool(c.productVariables.EnforceSystemCertificate)
1514}
1515
Colin Cross440e0d02020-06-11 11:32:11 -07001516func (c *config) EnforceSystemCertificateAllowList() []string {
1517 return c.productVariables.EnforceSystemCertificateAllowList
Jeongik Chac9464142019-01-07 12:07:27 +09001518}
1519
Jeongik Cha2cc570d2019-10-29 15:44:45 +09001520func (c *config) EnforceProductPartitionInterface() bool {
1521 return Bool(c.productVariables.EnforceProductPartitionInterface)
1522}
1523
JaeMan Parkff715562020-10-19 17:25:58 +09001524func (c *config) EnforceInterPartitionJavaSdkLibrary() bool {
1525 return Bool(c.productVariables.EnforceInterPartitionJavaSdkLibrary)
1526}
1527
1528func (c *config) InterPartitionJavaLibraryAllowList() []string {
1529 return c.productVariables.InterPartitionJavaLibraryAllowList
1530}
1531
Jooyung Han3ab2c3e2019-12-05 16:27:44 +09001532func (c *config) InstallExtraFlattenedApexes() bool {
1533 return Bool(c.productVariables.InstallExtraFlattenedApexes)
1534}
1535
Colin Crossf24a22a2019-01-31 14:12:44 -08001536func (c *config) ProductHiddenAPIStubs() []string {
1537 return c.productVariables.ProductHiddenAPIStubs
Colin Cross8faf8fc2019-01-16 15:15:52 -08001538}
1539
Colin Crossf24a22a2019-01-31 14:12:44 -08001540func (c *config) ProductHiddenAPIStubsSystem() []string {
1541 return c.productVariables.ProductHiddenAPIStubsSystem
Colin Cross8faf8fc2019-01-16 15:15:52 -08001542}
1543
Colin Crossf24a22a2019-01-31 14:12:44 -08001544func (c *config) ProductHiddenAPIStubsTest() []string {
1545 return c.productVariables.ProductHiddenAPIStubsTest
Colin Cross8faf8fc2019-01-16 15:15:52 -08001546}
Dan Willemsen71c74602019-04-10 12:27:35 -07001547
Dan Willemsen54879d12019-04-18 10:08:46 -07001548func (c *deviceConfig) TargetFSConfigGen() []string {
Dan Willemsen71c74602019-04-10 12:27:35 -07001549 return c.config.productVariables.TargetFSConfigGen
1550}
Inseob Kim0866b002019-04-15 20:21:29 +09001551
1552func (c *config) ProductPublicSepolicyDirs() []string {
1553 return c.productVariables.ProductPublicSepolicyDirs
1554}
1555
1556func (c *config) ProductPrivateSepolicyDirs() []string {
1557 return c.productVariables.ProductPrivateSepolicyDirs
1558}
1559
Colin Cross50ddcc42019-05-16 12:28:22 -07001560func (c *config) MissingUsesLibraries() []string {
1561 return c.productVariables.MissingUsesLibraries
1562}
1563
Inseob Kim5eb7ee92022-04-27 10:30:34 +09001564func (c *config) TargetMultitreeUpdateMeta() bool {
1565 return c.productVariables.MultitreeUpdateMeta
1566}
1567
Inseob Kim1f086e22019-05-09 13:29:15 +09001568func (c *deviceConfig) DeviceArch() string {
1569 return String(c.config.productVariables.DeviceArch)
1570}
1571
1572func (c *deviceConfig) DeviceArchVariant() string {
1573 return String(c.config.productVariables.DeviceArchVariant)
1574}
1575
1576func (c *deviceConfig) DeviceSecondaryArch() string {
1577 return String(c.config.productVariables.DeviceSecondaryArch)
1578}
1579
1580func (c *deviceConfig) DeviceSecondaryArchVariant() string {
1581 return String(c.config.productVariables.DeviceSecondaryArchVariant)
1582}
Yifan Hong82db7352020-01-21 16:12:26 -08001583
1584func (c *deviceConfig) BoardUsesRecoveryAsBoot() bool {
1585 return Bool(c.config.productVariables.BoardUsesRecoveryAsBoot)
1586}
Yifan Hong97365ee2020-07-29 09:51:57 -07001587
1588func (c *deviceConfig) BoardKernelBinaries() []string {
1589 return c.config.productVariables.BoardKernelBinaries
1590}
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001591
Yifan Hong42bef8d2020-08-05 14:36:09 -07001592func (c *deviceConfig) BoardKernelModuleInterfaceVersions() []string {
1593 return c.config.productVariables.BoardKernelModuleInterfaceVersions
1594}
1595
Yifan Hongdd8dacc2020-10-21 15:40:17 -07001596func (c *deviceConfig) BoardMoveRecoveryResourcesToVendorBoot() bool {
1597 return Bool(c.config.productVariables.BoardMoveRecoveryResourcesToVendorBoot)
1598}
1599
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001600func (c *deviceConfig) PlatformSepolicyVersion() string {
1601 return String(c.config.productVariables.PlatformSepolicyVersion)
1602}
1603
Inseob Kima10ef272021-09-15 03:04:53 +00001604func (c *deviceConfig) TotSepolicyVersion() string {
1605 return String(c.config.productVariables.TotSepolicyVersion)
1606}
1607
Inseob Kim843f6642022-01-07 09:11:23 +09001608func (c *deviceConfig) PlatformSepolicyCompatVersions() []string {
1609 return c.config.productVariables.PlatformSepolicyCompatVersions
1610}
1611
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001612func (c *deviceConfig) BoardSepolicyVers() string {
Inseob Kim0c4eec82021-03-22 22:33:40 +09001613 if ver := String(c.config.productVariables.BoardSepolicyVers); ver != "" {
1614 return ver
1615 }
1616 return c.PlatformSepolicyVersion()
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001617}
1618
Inseob Kim14178802021-12-08 22:53:31 +09001619func (c *deviceConfig) BoardPlatVendorPolicy() []string {
1620 return c.config.productVariables.BoardPlatVendorPolicy
1621}
1622
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001623func (c *deviceConfig) BoardReqdMaskPolicy() []string {
1624 return c.config.productVariables.BoardReqdMaskPolicy
1625}
1626
Inseob Kim0f46e7c2021-12-15 22:48:14 +09001627func (c *deviceConfig) BoardSystemExtPublicPrebuiltDirs() []string {
1628 return c.config.productVariables.BoardSystemExtPublicPrebuiltDirs
1629}
1630
1631func (c *deviceConfig) BoardSystemExtPrivatePrebuiltDirs() []string {
1632 return c.config.productVariables.BoardSystemExtPrivatePrebuiltDirs
1633}
1634
1635func (c *deviceConfig) BoardProductPublicPrebuiltDirs() []string {
1636 return c.config.productVariables.BoardProductPublicPrebuiltDirs
1637}
1638
1639func (c *deviceConfig) BoardProductPrivatePrebuiltDirs() []string {
1640 return c.config.productVariables.BoardProductPrivatePrebuiltDirs
1641}
1642
Inseob Kim1a0afcc2022-02-14 23:10:51 +09001643func (c *deviceConfig) SystemExtSepolicyPrebuiltApiDir() string {
1644 return String(c.config.productVariables.SystemExtSepolicyPrebuiltApiDir)
1645}
1646
1647func (c *deviceConfig) ProductSepolicyPrebuiltApiDir() string {
1648 return String(c.config.productVariables.ProductSepolicyPrebuiltApiDir)
1649}
1650
1651func (c *deviceConfig) IsPartnerTrebleSepolicyTestEnabled() bool {
1652 return c.SystemExtSepolicyPrebuiltApiDir() != "" || c.ProductSepolicyPrebuiltApiDir() != ""
1653}
1654
Inseob Kim7cf14652021-01-06 23:06:52 +09001655func (c *deviceConfig) DirectedVendorSnapshot() bool {
1656 return c.config.productVariables.DirectedVendorSnapshot
1657}
1658
1659func (c *deviceConfig) VendorSnapshotModules() map[string]bool {
1660 return c.config.productVariables.VendorSnapshotModules
1661}
1662
Jose Galmes4c6895e2021-02-09 07:44:30 -08001663func (c *deviceConfig) DirectedRecoverySnapshot() bool {
1664 return c.config.productVariables.DirectedRecoverySnapshot
1665}
1666
1667func (c *deviceConfig) RecoverySnapshotModules() map[string]bool {
1668 return c.config.productVariables.RecoverySnapshotModules
1669}
1670
Justin DeMartino383bfb32021-02-24 10:49:43 -08001671func createDirsMap(previous map[string]bool, dirs []string) (map[string]bool, error) {
1672 var ret = make(map[string]bool)
1673 for _, dir := range dirs {
1674 clean := filepath.Clean(dir)
1675 if previous[clean] || ret[clean] {
1676 return nil, fmt.Errorf("Duplicate entry %s", dir)
1677 }
1678 ret[clean] = true
1679 }
1680 return ret, nil
1681}
1682
1683func (c *deviceConfig) createDirsMapOnce(onceKey OnceKey, previous map[string]bool, dirs []string) map[string]bool {
1684 dirMap := c.Once(onceKey, func() interface{} {
1685 ret, err := createDirsMap(previous, dirs)
1686 if err != nil {
1687 panic(fmt.Errorf("%s: %w", onceKey.key, err))
1688 }
1689 return ret
1690 })
1691 if dirMap == nil {
1692 return nil
1693 }
1694 return dirMap.(map[string]bool)
1695}
1696
1697var vendorSnapshotDirsExcludedKey = NewOnceKey("VendorSnapshotDirsExcludedMap")
1698
1699func (c *deviceConfig) VendorSnapshotDirsExcludedMap() map[string]bool {
1700 return c.createDirsMapOnce(vendorSnapshotDirsExcludedKey, nil,
1701 c.config.productVariables.VendorSnapshotDirsExcluded)
1702}
1703
1704var vendorSnapshotDirsIncludedKey = NewOnceKey("VendorSnapshotDirsIncludedMap")
1705
1706func (c *deviceConfig) VendorSnapshotDirsIncludedMap() map[string]bool {
1707 excludedMap := c.VendorSnapshotDirsExcludedMap()
1708 return c.createDirsMapOnce(vendorSnapshotDirsIncludedKey, excludedMap,
1709 c.config.productVariables.VendorSnapshotDirsIncluded)
1710}
1711
1712var recoverySnapshotDirsExcludedKey = NewOnceKey("RecoverySnapshotDirsExcludedMap")
1713
1714func (c *deviceConfig) RecoverySnapshotDirsExcludedMap() map[string]bool {
1715 return c.createDirsMapOnce(recoverySnapshotDirsExcludedKey, nil,
1716 c.config.productVariables.RecoverySnapshotDirsExcluded)
1717}
1718
1719var recoverySnapshotDirsIncludedKey = NewOnceKey("RecoverySnapshotDirsIncludedMap")
1720
1721func (c *deviceConfig) RecoverySnapshotDirsIncludedMap() map[string]bool {
1722 excludedMap := c.RecoverySnapshotDirsExcludedMap()
1723 return c.createDirsMapOnce(recoverySnapshotDirsIncludedKey, excludedMap,
1724 c.config.productVariables.RecoverySnapshotDirsIncluded)
1725}
1726
Rob Seymour925aa092021-08-10 20:42:03 +00001727func (c *deviceConfig) HostFakeSnapshotEnabled() bool {
1728 return c.config.productVariables.HostFakeSnapshotEnabled
1729}
1730
Inseob Kim60c32f02020-12-21 22:53:05 +09001731func (c *deviceConfig) ShippingApiLevel() ApiLevel {
1732 if c.config.productVariables.ShippingApiLevel == nil {
1733 return NoneApiLevel
1734 }
1735 apiLevel, _ := strconv.Atoi(*c.config.productVariables.ShippingApiLevel)
1736 return uncheckedFinalApiLevel(apiLevel)
1737}
1738
Alix Espinoef47e542022-09-14 19:10:51 +00001739func (c *deviceConfig) BuildBrokenClangAsFlags() bool {
1740 return c.config.productVariables.BuildBrokenClangAsFlags
1741}
1742
1743func (c *deviceConfig) BuildBrokenClangCFlags() bool {
1744 return c.config.productVariables.BuildBrokenClangCFlags
1745}
1746
Alixb5f6d9e2022-04-20 23:00:58 +00001747func (c *deviceConfig) BuildBrokenClangProperty() bool {
1748 return c.config.productVariables.BuildBrokenClangProperty
1749}
1750
Inseob Kim67e5add2021-03-17 18:05:33 +09001751func (c *deviceConfig) BuildBrokenEnforceSyspropOwner() bool {
1752 return c.config.productVariables.BuildBrokenEnforceSyspropOwner
1753}
1754
1755func (c *deviceConfig) BuildBrokenTrebleSyspropNeverallow() bool {
1756 return c.config.productVariables.BuildBrokenTrebleSyspropNeverallow
1757}
1758
Hridya Valsaraju5a5c7d52021-04-02 16:45:24 -07001759func (c *deviceConfig) BuildDebugfsRestrictionsEnabled() bool {
1760 return c.config.productVariables.BuildDebugfsRestrictionsEnabled
1761}
1762
Inseob Kim0cac7b42021-02-03 18:16:46 +09001763func (c *deviceConfig) BuildBrokenVendorPropertyNamespace() bool {
1764 return c.config.productVariables.BuildBrokenVendorPropertyNamespace
1765}
1766
Liz Kammer619be462022-01-28 15:13:39 -05001767func (c *deviceConfig) BuildBrokenInputDir(name string) bool {
1768 return InList(name, c.config.productVariables.BuildBrokenInputDirModules)
1769}
1770
Vinh Tran140d5882022-06-10 14:23:27 -04001771func (c *deviceConfig) BuildBrokenDepfile() bool {
1772 return Bool(c.config.productVariables.BuildBrokenDepfile)
1773}
1774
Inseob Kim67e5add2021-03-17 18:05:33 +09001775func (c *deviceConfig) RequiresInsecureExecmemForSwiftshader() bool {
1776 return c.config.productVariables.RequiresInsecureExecmemForSwiftshader
1777}
1778
1779func (c *config) SelinuxIgnoreNeverallows() bool {
1780 return c.productVariables.SelinuxIgnoreNeverallows
1781}
1782
1783func (c *deviceConfig) SepolicySplit() bool {
1784 return c.config.productVariables.SepolicySplit
1785}
1786
Inseob Kima10ef272021-09-15 03:04:53 +00001787func (c *deviceConfig) SepolicyFreezeTestExtraDirs() []string {
1788 return c.config.productVariables.SepolicyFreezeTestExtraDirs
1789}
1790
1791func (c *deviceConfig) SepolicyFreezeTestExtraPrebuiltDirs() []string {
1792 return c.config.productVariables.SepolicyFreezeTestExtraPrebuiltDirs
1793}
1794
Jiyong Parkd163d4d2021-10-12 16:47:43 +09001795func (c *deviceConfig) GenerateAidlNdkPlatformBackend() bool {
1796 return c.config.productVariables.GenerateAidlNdkPlatformBackend
1797}
1798
Christopher Ferris98f10222022-07-13 23:16:52 -07001799func (c *config) IgnorePrefer32OnDevice() bool {
1800 return c.productVariables.IgnorePrefer32OnDevice
1801}
1802
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001803func (c *config) BootJars() []string {
1804 return c.Once(earlyBootJarsKey, func() interface{} {
Paul Duffin69d1fb12020-10-23 21:14:20 +01001805 list := c.productVariables.BootJars.CopyOfJars()
satayevd604b212021-07-21 14:23:52 +01001806 return append(list, c.productVariables.ApexBootJars.CopyOfJars()...)
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001807 }).([]string)
1808}
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001809
satayevd604b212021-07-21 14:23:52 +01001810func (c *config) NonApexBootJars() ConfiguredJarList {
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001811 return c.productVariables.BootJars
1812}
1813
satayevd604b212021-07-21 14:23:52 +01001814func (c *config) ApexBootJars() ConfiguredJarList {
1815 return c.productVariables.ApexBootJars
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001816}
Colin Cross77cdcfd2021-03-12 11:28:25 -08001817
1818func (c *config) RBEWrapper() string {
1819 return c.GetenvWithDefault("RBE_WRAPPER", remoteexec.DefaultWrapperPath)
1820}
Colin Cross9b698b62021-12-22 09:55:32 -08001821
1822// UseHostMusl returns true if the host target has been configured to build against musl libc.
1823func (c *config) UseHostMusl() bool {
1824 return Bool(c.productVariables.HostMusl)
1825}
MarkDacekff851b82022-04-21 18:33:17 +00001826
Chris Parsonsf874e462022-05-10 13:50:12 -04001827func (c *config) LogMixedBuild(ctx BaseModuleContext, useBazel bool) {
MarkDacekff851b82022-04-21 18:33:17 +00001828 moduleName := ctx.Module().Name()
1829 c.mixedBuildsLock.Lock()
1830 defer c.mixedBuildsLock.Unlock()
1831 if useBazel {
1832 c.mixedBuildEnabledModules[moduleName] = struct{}{}
1833 } else {
1834 c.mixedBuildDisabledModules[moduleName] = struct{}{}
1835 }
1836}