blob: 15707a5607451ed820c97ed384ff7ba965414806 [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"
Colin Crossd8f20142016-11-03 09:43:26 -070024 "io/ioutil"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "os"
Colin Cross35cec122015-04-02 14:37:16 -070026 "path/filepath"
Sam Delmerico5c32bbf2022-01-20 20:15:02 +000027 "reflect"
Colin Cross3f40fa42015-01-30 17:27:36 -080028 "runtime"
Inseob Kim60c32f02020-12-21 22:53:05 +090029 "strconv"
Dan Willemsen34cc69e2015-09-23 15:26:20 -070030 "strings"
Colin Crossc1e86a32015-04-15 12:33:28 -070031 "sync"
Colin Cross6ff51382015-12-17 16:39:19 -080032
Colin Cross98be1bb2019-12-13 20:41:13 -080033 "github.com/google/blueprint"
Colin Crosse87040b2017-12-11 15:52:26 -080034 "github.com/google/blueprint/bootstrap"
Colin Cross98be1bb2019-12-13 20:41:13 -080035 "github.com/google/blueprint/pathtools"
Colin Cross6ff51382015-12-17 16:39:19 -080036 "github.com/google/blueprint/proptools"
Colin Cross9d34f352019-11-22 16:03:51 -080037
38 "android/soong/android/soongconfig"
Liz Kammer09f947d2021-05-12 14:51:49 -040039 "android/soong/bazel"
Colin Cross77cdcfd2021-03-12 11:28:25 -080040 "android/soong/remoteexec"
Liz Kammer72beb342022-02-03 08:42:10 -050041 "android/soong/starlark_fmt"
Colin Cross3f40fa42015-01-30 17:27:36 -080042)
43
Jingwen Chenc711fec2020-11-22 23:52:50 -050044// Bool re-exports proptools.Bool for the android package.
Colin Cross6ff51382015-12-17 16:39:19 -080045var Bool = proptools.Bool
Jingwen Chenc711fec2020-11-22 23:52:50 -050046
47// String re-exports proptools.String for the android package.
Jack He8cc71432016-12-08 15:45:07 -080048var String = proptools.String
Jingwen Chenc711fec2020-11-22 23:52:50 -050049
50// StringDefault re-exports proptools.StringDefault for the android package.
Jeongik Cha219141c2020-08-06 23:00:37 +090051var StringDefault = proptools.StringDefault
Jiyong Park6a927c42020-01-21 02:03:43 +090052
Jingwen Chenc711fec2020-11-22 23:52:50 -050053// FutureApiLevelInt is a placeholder constant for unreleased API levels.
Dan Albert0b176c82020-07-23 16:43:25 -070054const FutureApiLevelInt = 10000
55
Jingwen Chenc711fec2020-11-22 23:52:50 -050056// FutureApiLevel represents unreleased API levels.
Dan Albert0b176c82020-07-23 16:43:25 -070057var FutureApiLevel = ApiLevel{
58 value: "current",
59 number: FutureApiLevelInt,
60 isPreview: true,
61}
Colin Cross6ff51382015-12-17 16:39:19 -080062
Jingwen Chenc4d91bc2020-11-24 22:59:26 -050063// The product variables file name, containing product config from Kati.
Dan Willemsen87b17d12015-07-14 00:39:06 -070064const productVariablesFileName = "soong.variables"
Colin Cross3f40fa42015-01-30 17:27:36 -080065
Colin Cross9272ade2016-08-17 15:24:12 -070066// A Config object represents the entire build configuration for Android.
Colin Crossc3c0a492015-04-10 15:43:55 -070067type Config struct {
68 *config
69}
70
Lukacs T. Berkib078ade2021-08-31 10:42:08 +020071// SoongOutDir returns the build output directory for the configuration.
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +020072func (c Config) SoongOutDir() string {
73 return c.soongOutDir
Jeff Gastonefc1b412017-03-29 17:29:06 -070074}
75
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +020076func (c Config) OutDir() string {
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +020077 return c.outDir
Lukacs T. Berki89e9a162021-03-12 08:31:32 +010078}
79
Lukacs T. Berkiea1a31c2021-09-02 09:58:09 +020080func (c Config) RunGoTests() bool {
81 return c.runGoTests
82}
83
Lukacs T. Berki5f6cb1d2021-03-17 15:03:14 +010084func (c Config) DebugCompilation() bool {
85 return false // Never compile Go code in the main build for debugging
86}
87
Lukacs T. Berkiea1a31c2021-09-02 09:58:09 +020088func (c Config) Subninjas() []string {
89 return []string{}
90}
91
92func (c Config) PrimaryBuilderInvocations() []bootstrap.PrimaryBuilderInvocation {
93 return []bootstrap.PrimaryBuilderInvocation{}
94}
95
Jingwen Chenc711fec2020-11-22 23:52:50 -050096// A DeviceConfig object represents the configuration for a particular device
97// being built. For now there will only be one of these, but in the future there
98// may be multiple devices being built.
Colin Cross9272ade2016-08-17 15:24:12 -070099type DeviceConfig struct {
100 *deviceConfig
101}
102
Jingwen Chenc711fec2020-11-22 23:52:50 -0500103// VendorConfig represents the configuration for vendor-specific behavior.
Colin Cross9d34f352019-11-22 16:03:51 -0800104type VendorConfig soongconfig.SoongConfig
Dan Willemsen0fe78662018-03-26 12:41:18 -0700105
Jingwen Chenc711fec2020-11-22 23:52:50 -0500106// Definition of general build configuration for soong_build. Some of these
Jingwen Chenc4d91bc2020-11-24 22:59:26 -0500107// product configuration values are read from Kati-generated soong.variables.
Colin Cross1332b002015-04-07 17:11:30 -0700108type config struct {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500109 // Options configurable with soong.variables
Dan Willemsen45133ac2018-03-09 21:22:06 -0800110 productVariables productVariables
Colin Cross3f40fa42015-01-30 17:27:36 -0800111
Dan Willemsen674dc7f2018-03-12 18:06:05 -0700112 // Only available on configs created by TestConfig
113 TestProductVariables *productVariables
114
Jingwen Chenc711fec2020-11-22 23:52:50 -0500115 // A specialized context object for Bazel/Soong mixed builds and migration
116 // purposes.
Chris Parsonsf3c96ef2020-09-29 02:23:17 -0400117 BazelContext BazelContext
118
Dan Willemsen87b17d12015-07-14 00:39:06 -0700119 ProductVariablesFileName string
120
Colin Cross0c66bc62021-07-20 09:47:41 -0700121 // BuildOS stores the OsType for the OS that the build is running on.
122 BuildOS OsType
123
124 // BuildArch stores the ArchType for the CPU that the build is running on.
125 BuildArch ArchType
126
Jaewoong Jung642916f2020-10-09 17:25:15 -0700127 Targets map[OsType][]Target
128 BuildOSTarget Target // the Target for tools run on the build machine
129 BuildOSCommonTarget Target // the Target for common (java) tools run on the build machine
130 AndroidCommonTarget Target // the Target for common modules for the Android device
131 AndroidFirstDeviceTarget Target // the first Target for modules for the Android device
Dan Willemsen218f6562015-07-08 18:13:11 -0700132
Jingwen Chenc711fec2020-11-22 23:52:50 -0500133 // multilibConflicts for an ArchType is true if there is earlier configured
134 // device architecture with the same multilib value.
Colin Cross3b19f5d2019-09-17 14:45:31 -0700135 multilibConflicts map[ArchType]bool
136
Colin Cross9272ade2016-08-17 15:24:12 -0700137 deviceConfig *deviceConfig
138
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200139 outDir string // The output directory (usually out/)
140 soongOutDir string
Chris Parsons8f232a22020-06-23 17:37:05 -0400141 moduleListFile string // the path to the file which lists blueprint files to parse.
Colin Crossc1e86a32015-04-15 12:33:28 -0700142
Lukacs T. Berkie1df43f2021-09-08 15:31:14 +0200143 runGoTests bool
Lukacs T. Berkiea1a31c2021-09-02 09:58:09 +0200144
Colin Cross6ccbc912017-10-10 23:07:38 -0700145 env map[string]string
Dan Willemsene7680ba2015-09-11 17:06:19 -0700146 envLock sync.Mutex
147 envDeps map[string]string
148 envFrozen bool
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800149
Jingwen Chencda22c92020-11-23 00:22:30 -0500150 // Changes behavior based on whether Kati runs after soong_build, or if soong_build
151 // runs standalone.
152 katiEnabled bool
Colin Cross1e7d3702016-08-24 15:25:47 -0700153
Colin Cross32616ed2017-09-05 21:56:44 -0700154 captureBuild bool // true for tests, saves build parameters for each module
155 ignoreEnvironment bool // true for tests, returns empty from all Getenv calls
Colin Crosscec81712017-07-13 14:43:27 -0700156
Colin Cross98be1bb2019-12-13 20:41:13 -0800157 fs pathtools.FileSystem
158 mockBpList string
159
Jingwen Chen01812022021-11-19 14:29:43 +0000160 runningAsBp2Build bool
Sam Delmerico24c56032022-03-28 19:53:03 +0000161 bp2buildPackageConfig bp2BuildConversionAllowlist
Jingwen Chen01812022021-11-19 14:29:43 +0000162 Bp2buildSoongConfigDefinitions soongconfig.Bp2BuildSoongConfigDefinitions
Jingwen Chen12b4c272021-03-10 02:05:59 -0500163
Colin Cross5e6a7972020-06-07 16:56:32 -0700164 // If testAllowNonExistentPaths is true then PathForSource and PathForModuleSrc won't error
165 // in tests when a path doesn't exist.
Pedro Loureiro5d190cc2021-02-15 15:41:33 +0000166 TestAllowNonExistentPaths bool
Colin Cross5e6a7972020-06-07 16:56:32 -0700167
Jingwen Chenc711fec2020-11-22 23:52:50 -0500168 // The list of files that when changed, must invalidate soong_build to
169 // regenerate build.ninja.
Colin Cross12129292020-10-29 18:23:58 -0700170 ninjaFileDepsSet sync.Map
171
Colin Cross9272ade2016-08-17 15:24:12 -0700172 OncePer
MarkDacekff851b82022-04-21 18:33:17 +0000173
174 mixedBuildsLock sync.Mutex
175 mixedBuildEnabledModules map[string]struct{}
176 mixedBuildDisabledModules map[string]struct{}
Colin Cross9272ade2016-08-17 15:24:12 -0700177}
178
179type deviceConfig struct {
Dan Willemsen00269f22017-07-06 16:59:48 -0700180 config *config
Colin Cross9272ade2016-08-17 15:24:12 -0700181 OncePer
Colin Cross3f40fa42015-01-30 17:27:36 -0800182}
183
Colin Cross485e5722015-08-27 13:28:01 -0700184type jsonConfigurable interface {
Colin Cross27385972015-09-18 10:57:10 -0700185 SetDefaultConfig()
Colin Cross485e5722015-08-27 13:28:01 -0700186}
Colin Cross3f40fa42015-01-30 17:27:36 -0800187
Colin Cross485e5722015-08-27 13:28:01 -0700188func loadConfig(config *config) error {
Colin Cross988414c2020-01-11 01:11:46 +0000189 return loadFromConfigFile(&config.productVariables, absolutePath(config.ProductVariablesFileName))
Colin Cross485e5722015-08-27 13:28:01 -0700190}
191
Jingwen Chenc711fec2020-11-22 23:52:50 -0500192// loadFromConfigFile loads and decodes configuration options from a JSON file
193// in the current working directory.
Liz Kammer09f947d2021-05-12 14:51:49 -0400194func loadFromConfigFile(configurable *productVariables, filename string) error {
Colin Cross3f40fa42015-01-30 17:27:36 -0800195 // Try to open the file
Colin Cross485e5722015-08-27 13:28:01 -0700196 configFileReader, err := os.Open(filename)
Colin Cross3f40fa42015-01-30 17:27:36 -0800197 defer configFileReader.Close()
198 if os.IsNotExist(err) {
199 // Need to create a file, so that blueprint & ninja don't get in
200 // a dependency tracking loop.
201 // Make a file-configurable-options with defaults, write it out using
202 // a json writer.
Colin Cross27385972015-09-18 10:57:10 -0700203 configurable.SetDefaultConfig()
204 err = saveToConfigFile(configurable, filename)
Colin Cross3f40fa42015-01-30 17:27:36 -0800205 if err != nil {
206 return err
207 }
Colin Cross15cd21a2018-02-27 11:26:02 -0800208 } else if err != nil {
209 return fmt.Errorf("config file: could not open %s: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800210 } else {
211 // Make a decoder for it
212 jsonDecoder := json.NewDecoder(configFileReader)
Colin Cross485e5722015-08-27 13:28:01 -0700213 err = jsonDecoder.Decode(configurable)
Colin Cross3f40fa42015-01-30 17:27:36 -0800214 if err != nil {
Colin Cross15cd21a2018-02-27 11:26:02 -0800215 return fmt.Errorf("config file: %s did not parse correctly: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800216 }
217 }
218
Liz Kammer09f947d2021-05-12 14:51:49 -0400219 if Bool(configurable.GcovCoverage) && Bool(configurable.ClangCoverage) {
220 return fmt.Errorf("GcovCoverage and ClangCoverage cannot both be set")
221 }
222
223 configurable.Native_coverage = proptools.BoolPtr(
224 Bool(configurable.GcovCoverage) ||
225 Bool(configurable.ClangCoverage))
226
Yuntao Xu402e9b02021-08-09 15:44:44 -0700227 // when Platform_sdk_final is true (or PLATFORM_VERSION_CODENAME is REL), use Platform_sdk_version;
228 // if false (pre-released version, for example), use Platform_sdk_codename.
229 if Bool(configurable.Platform_sdk_final) {
230 if configurable.Platform_sdk_version != nil {
231 configurable.Platform_sdk_version_or_codename =
232 proptools.StringPtr(strconv.Itoa(*(configurable.Platform_sdk_version)))
233 } else {
234 return fmt.Errorf("Platform_sdk_version cannot be pointed by a NULL pointer")
235 }
236 } else {
237 configurable.Platform_sdk_version_or_codename =
238 proptools.StringPtr(String(configurable.Platform_sdk_codename))
239 }
240
Liz Kammer09f947d2021-05-12 14:51:49 -0400241 return saveToBazelConfigFile(configurable, filepath.Dir(filename))
Colin Cross3f40fa42015-01-30 17:27:36 -0800242}
243
Colin Crossd8f20142016-11-03 09:43:26 -0700244// atomically writes the config file in case two copies of soong_build are running simultaneously
245// (for example, docs generation and ninja manifest generation)
Liz Kammer09f947d2021-05-12 14:51:49 -0400246func saveToConfigFile(config *productVariables, filename string) error {
Colin Cross3f40fa42015-01-30 17:27:36 -0800247 data, err := json.MarshalIndent(&config, "", " ")
248 if err != nil {
249 return fmt.Errorf("cannot marshal config data: %s", err.Error())
250 }
251
Colin Crossd8f20142016-11-03 09:43:26 -0700252 f, err := ioutil.TempFile(filepath.Dir(filename), "config")
Colin Cross3f40fa42015-01-30 17:27:36 -0800253 if err != nil {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500254 return fmt.Errorf("cannot create empty config file %s: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800255 }
Colin Crossd8f20142016-11-03 09:43:26 -0700256 defer os.Remove(f.Name())
257 defer f.Close()
Colin Cross3f40fa42015-01-30 17:27:36 -0800258
Colin Crossd8f20142016-11-03 09:43:26 -0700259 _, err = f.Write(data)
Colin Cross3f40fa42015-01-30 17:27:36 -0800260 if err != nil {
Colin Cross485e5722015-08-27 13:28:01 -0700261 return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error())
262 }
263
Colin Crossd8f20142016-11-03 09:43:26 -0700264 _, err = f.WriteString("\n")
Colin Cross485e5722015-08-27 13:28:01 -0700265 if err != nil {
266 return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800267 }
268
Colin Crossd8f20142016-11-03 09:43:26 -0700269 f.Close()
270 os.Rename(f.Name(), filename)
271
Colin Cross3f40fa42015-01-30 17:27:36 -0800272 return nil
273}
274
Liz Kammer09f947d2021-05-12 14:51:49 -0400275func saveToBazelConfigFile(config *productVariables, outDir string) error {
276 dir := filepath.Join(outDir, bazel.SoongInjectionDirName, "product_config")
277 err := createDirIfNonexistent(dir, os.ModePerm)
278 if err != nil {
279 return fmt.Errorf("Could not create dir %s: %s", dir, err)
280 }
281
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000282 nonArchVariantProductVariables := []string{}
283 archVariantProductVariables := []string{}
284 p := variableProperties{}
285 t := reflect.TypeOf(p.Product_variables)
286 for i := 0; i < t.NumField(); i++ {
287 f := t.Field(i)
288 nonArchVariantProductVariables = append(nonArchVariantProductVariables, strings.ToLower(f.Name))
289 if proptools.HasTag(f, "android", "arch_variant") {
290 archVariantProductVariables = append(archVariantProductVariables, strings.ToLower(f.Name))
291 }
292 }
293
Liz Kammer72beb342022-02-03 08:42:10 -0500294 nonArchVariantProductVariablesJson := starlark_fmt.PrintStringList(nonArchVariantProductVariables, 0)
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000295 if err != nil {
296 return fmt.Errorf("cannot marshal product variable data: %s", err.Error())
297 }
298
Liz Kammer72beb342022-02-03 08:42:10 -0500299 archVariantProductVariablesJson := starlark_fmt.PrintStringList(archVariantProductVariables, 0)
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000300 if err != nil {
301 return fmt.Errorf("cannot marshal arch variant product variable data: %s", err.Error())
302 }
303
304 configJson, err := json.MarshalIndent(&config, "", " ")
Liz Kammer09f947d2021-05-12 14:51:49 -0400305 if err != nil {
306 return fmt.Errorf("cannot marshal config data: %s", err.Error())
307 }
Cole Faust082c5f32022-08-04 15:49:20 -0700308 // The backslashes need to be escaped because this text is going to be put
309 // inside a Starlark string literal.
310 configJson = bytes.ReplaceAll(configJson, []byte("\\"), []byte("\\\\"))
Liz Kammer09f947d2021-05-12 14:51:49 -0400311
312 bzl := []string{
313 bazel.GeneratedBazelFileWarning,
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000314 fmt.Sprintf(`_product_vars = json.decode("""%s""")`, configJson),
315 fmt.Sprintf(`_product_var_constraints = %s`, nonArchVariantProductVariablesJson),
316 fmt.Sprintf(`_arch_variant_product_var_constraints = %s`, archVariantProductVariablesJson),
317 "\n", `
318product_vars = _product_vars
319product_var_constraints = _product_var_constraints
320arch_variant_product_var_constraints = _arch_variant_product_var_constraints
321`,
Liz Kammer09f947d2021-05-12 14:51:49 -0400322 }
Cole Faust082c5f32022-08-04 15:49:20 -0700323 err = os.WriteFile(filepath.Join(dir, "product_variables.bzl"), []byte(strings.Join(bzl, "\n")), 0644)
Liz Kammer09f947d2021-05-12 14:51:49 -0400324 if err != nil {
325 return fmt.Errorf("Could not write .bzl config file %s", err)
326 }
Cole Faust082c5f32022-08-04 15:49:20 -0700327 err = os.WriteFile(filepath.Join(dir, "BUILD"), []byte(bazel.GeneratedBazelFileWarning), 0644)
Liz Kammer09f947d2021-05-12 14:51:49 -0400328 if err != nil {
329 return fmt.Errorf("Could not write BUILD config file %s", err)
330 }
331
332 return nil
333}
334
Colin Cross988414c2020-01-11 01:11:46 +0000335// NullConfig returns a mostly empty Config for use by standalone tools like dexpreopt_gen that
336// use the android package.
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200337func NullConfig(outDir, soongOutDir string) Config {
Colin Cross988414c2020-01-11 01:11:46 +0000338 return Config{
339 config: &config{
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200340 outDir: outDir,
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200341 soongOutDir: soongOutDir,
342 fs: pathtools.OsFs,
Colin Cross988414c2020-01-11 01:11:46 +0000343 },
344 }
345}
346
Jingwen Chenc711fec2020-11-22 23:52:50 -0500347// NewConfig creates a new Config object. The srcDir argument specifies the path
348// to the root source directory. It also loads the config file, if found.
Lukacs T. Berki89fcdcb2021-09-07 09:10:33 +0200349func NewConfig(moduleListFile string, runGoTests bool, outDir, soongOutDir string, availableEnv map[string]string) (Config, error) {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500350 // Make a config with default options.
Colin Cross9272ade2016-08-17 15:24:12 -0700351 config := &config{
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200352 ProductVariablesFileName: filepath.Join(soongOutDir, productVariablesFileName),
Dan Willemsen87b17d12015-07-14 00:39:06 -0700353
Lukacs T. Berki53b2f362021-04-12 14:04:24 +0200354 env: availableEnv,
Colin Cross6ccbc912017-10-10 23:07:38 -0700355
Lukacs T. Berkie1df43f2021-09-08 15:31:14 +0200356 outDir: outDir,
357 soongOutDir: soongOutDir,
358 runGoTests: runGoTests,
359 multilibConflicts: make(map[ArchType]bool),
Colin Cross98be1bb2019-12-13 20:41:13 -0800360
MarkDacekff851b82022-04-21 18:33:17 +0000361 moduleListFile: moduleListFile,
362 fs: pathtools.NewOsFs(absSrcDir),
363 mixedBuildDisabledModules: make(map[string]struct{}),
364 mixedBuildEnabledModules: make(map[string]struct{}),
Colin Cross68f55102015-03-25 14:43:57 -0700365 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800366
Dan Willemsen00269f22017-07-06 16:59:48 -0700367 config.deviceConfig = &deviceConfig{
Colin Cross9272ade2016-08-17 15:24:12 -0700368 config: config,
369 }
370
Liz Kammer7941b302020-07-28 13:27:34 -0700371 // Soundness check of the build and source directories. This won't catch strange
372 // configurations with symlinks, but at least checks the obvious case.
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200373 absBuildDir, err := filepath.Abs(soongOutDir)
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700374 if err != nil {
375 return Config{}, err
376 }
377
Lukacs T. Berkif7e36d82021-08-16 17:05:09 +0200378 absSrcDir, err := filepath.Abs(".")
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700379 if err != nil {
380 return Config{}, err
381 }
382
383 if strings.HasPrefix(absSrcDir, absBuildDir) {
384 return Config{}, fmt.Errorf("Build dir must not contain source directory")
385 }
386
Colin Cross3f40fa42015-01-30 17:27:36 -0800387 // Load any configurable options from the configuration file
Colin Cross9272ade2016-08-17 15:24:12 -0700388 err = loadConfig(config)
Colin Cross3f40fa42015-01-30 17:27:36 -0800389 if err != nil {
Colin Crossc3c0a492015-04-10 15:43:55 -0700390 return Config{}, err
Colin Cross3f40fa42015-01-30 17:27:36 -0800391 }
392
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200393 KatiEnabledMarkerFile := filepath.Join(soongOutDir, ".soong.kati_enabled")
Jingwen Chencda22c92020-11-23 00:22:30 -0500394 if _, err := os.Stat(absolutePath(KatiEnabledMarkerFile)); err == nil {
395 config.katiEnabled = true
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800396 }
397
Colin Cross0c66bc62021-07-20 09:47:41 -0700398 determineBuildOS(config)
399
Jingwen Chenc711fec2020-11-22 23:52:50 -0500400 // Sets up the map of target OSes to the finer grained compilation targets
401 // that are configured from the product variables.
Colin Crossa1ad8d12016-06-01 17:09:44 -0700402 targets, err := decodeTargetProductVariables(config)
Dan Willemsen218f6562015-07-08 18:13:11 -0700403 if err != nil {
404 return Config{}, err
405 }
406
Paul Duffin1356d8c2020-02-25 19:26:33 +0000407 // Make the CommonOS OsType available for all products.
408 targets[CommonOS] = []Target{commonTargetMap[CommonOS.Name]}
409
Dan Albert4098deb2016-10-19 14:04:41 -0700410 var archConfig []archConfig
Jingwen Chenc4d91bc2020-11-24 22:59:26 -0500411 if config.NdkAbis() {
Dan Albert4098deb2016-10-19 14:04:41 -0700412 archConfig = getNdkAbisConfig()
Martin Stjernholmc1ecc432019-11-15 15:00:31 +0000413 } else if config.AmlAbis() {
414 archConfig = getAmlAbisConfig()
Dan Albert4098deb2016-10-19 14:04:41 -0700415 }
416
417 if archConfig != nil {
Liz Kammerb7f33662022-02-28 14:16:16 -0500418 androidTargets, err := decodeAndroidArchSettings(archConfig)
Dan Willemsen322acaf2016-01-12 23:07:05 -0800419 if err != nil {
420 return Config{}, err
421 }
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700422 targets[Android] = androidTargets
Dan Willemsen322acaf2016-01-12 23:07:05 -0800423 }
424
Colin Cross3b19f5d2019-09-17 14:45:31 -0700425 multilib := make(map[string]bool)
426 for _, target := range targets[Android] {
427 if seen := multilib[target.Arch.ArchType.Multilib]; seen {
428 config.multilibConflicts[target.Arch.ArchType] = true
429 }
430 multilib[target.Arch.ArchType.Multilib] = true
431 }
432
Jingwen Chenc711fec2020-11-22 23:52:50 -0500433 // Map of OS to compilation targets.
Colin Crossa1ad8d12016-06-01 17:09:44 -0700434 config.Targets = targets
Jingwen Chenc711fec2020-11-22 23:52:50 -0500435
436 // Compilation targets for host tools.
Colin Cross0c66bc62021-07-20 09:47:41 -0700437 config.BuildOSTarget = config.Targets[config.BuildOS][0]
438 config.BuildOSCommonTarget = getCommonTargets(config.Targets[config.BuildOS])[0]
Jingwen Chenc711fec2020-11-22 23:52:50 -0500439
440 // Compilation targets for Android.
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700441 if len(config.Targets[Android]) > 0 {
442 config.AndroidCommonTarget = getCommonTargets(config.Targets[Android])[0]
Sam Delmericocc271e22022-06-01 15:45:02 +0000443 config.AndroidFirstDeviceTarget = FirstTarget(config.Targets[Android], "lib64", "lib32")[0]
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700444 }
Dan Willemsen218f6562015-07-08 18:13:11 -0700445
Chris Parsonsf3c96ef2020-09-29 02:23:17 -0400446 config.BazelContext, err = NewBazelContext(config)
Wei Lid7736ec2022-05-12 23:37:53 -0700447 config.bp2buildPackageConfig = getBp2BuildAllowList()
Colin Cross3f40fa42015-01-30 17:27:36 -0800448
Jingwen Chenc711fec2020-11-22 23:52:50 -0500449 return Config{config}, err
450}
Colin Cross988414c2020-01-11 01:11:46 +0000451
Colin Cross98be1bb2019-12-13 20:41:13 -0800452// mockFileSystem replaces all reads with accesses to the provided map of
453// filenames to contents stored as a byte slice.
454func (c *config) mockFileSystem(bp string, fs map[string][]byte) {
455 mockFS := map[string][]byte{}
456
457 if _, exists := mockFS["Android.bp"]; !exists {
458 mockFS["Android.bp"] = []byte(bp)
459 }
460
461 for k, v := range fs {
462 mockFS[k] = v
463 }
464
465 // no module list file specified; find every file named Blueprints or Android.bp
466 pathsToParse := []string{}
467 for candidate := range mockFS {
468 base := filepath.Base(candidate)
Lukacs T. Berkib838b0a2021-09-02 11:46:24 +0200469 if base == "Android.bp" {
Colin Cross98be1bb2019-12-13 20:41:13 -0800470 pathsToParse = append(pathsToParse, candidate)
471 }
472 }
473 if len(pathsToParse) < 1 {
474 panic(fmt.Sprintf("No Blueprint or Android.bp files found in mock filesystem: %v\n", mockFS))
475 }
476 mockFS[blueprint.MockModuleListFile] = []byte(strings.Join(pathsToParse, "\n"))
477
478 c.fs = pathtools.MockFs(mockFS)
479 c.mockBpList = blueprint.MockModuleListFile
480}
481
Lukacs T. Berkid1e3f1f2021-03-16 08:55:23 +0100482func (c *config) SetAllowMissingDependencies() {
483 c.productVariables.Allow_missing_dependencies = proptools.BoolPtr(true)
484}
485
Jingwen Chenc711fec2020-11-22 23:52:50 -0500486// BlueprintToolLocation returns the directory containing build system tools
487// from Blueprint, like soong_zip and merge_zips.
Lukacs T. Berkia806e412021-09-01 08:57:48 +0200488func (c *config) HostToolDir() string {
Colin Crossacfcc1f2021-10-25 15:40:32 -0700489 if c.KatiEnabled() {
490 return filepath.Join(c.outDir, "host", c.PrebuiltOS(), "bin")
491 } else {
492 return filepath.Join(c.soongOutDir, "host", c.PrebuiltOS(), "bin")
493 }
Dan Willemsenc2aa4a92016-05-26 15:13:03 -0700494}
495
Dan Willemsen60e62f02018-11-16 21:05:32 -0800496func (c *config) HostToolPath(ctx PathContext, tool string) Path {
Colin Cross790ef352021-10-25 19:15:55 -0700497 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "bin", false, tool)
498 return path
Dan Willemsen60e62f02018-11-16 21:05:32 -0800499}
500
Colin Cross790ef352021-10-25 19:15:55 -0700501func (c *config) HostJNIToolPath(ctx PathContext, lib string) Path {
Martin Stjernholm7260d062019-12-09 21:47:14 +0000502 ext := ".so"
503 if runtime.GOOS == "darwin" {
504 ext = ".dylib"
505 }
Colin Cross790ef352021-10-25 19:15:55 -0700506 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "lib64", false, lib+ext)
507 return path
Martin Stjernholm7260d062019-12-09 21:47:14 +0000508}
509
Colin Crossae5330a2021-11-03 13:31:22 -0700510func (c *config) HostJavaToolPath(ctx PathContext, tool string) Path {
511 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "framework", false, tool)
Colin Cross3e3eda62021-11-04 10:22:51 -0700512 return path
513}
514
Jingwen Chenc711fec2020-11-22 23:52:50 -0500515// PrebuiltOS returns the name of the host OS used in prebuilts directories.
Colin Cross1332b002015-04-07 17:11:30 -0700516func (c *config) PrebuiltOS() string {
Colin Cross3f40fa42015-01-30 17:27:36 -0800517 switch runtime.GOOS {
518 case "linux":
519 return "linux-x86"
520 case "darwin":
521 return "darwin-x86"
522 default:
523 panic("Unknown GOOS")
524 }
525}
526
527// GoRoot returns the path to the root directory of the Go toolchain.
Colin Cross1332b002015-04-07 17:11:30 -0700528func (c *config) GoRoot() string {
Lukacs T. Berkif7e36d82021-08-16 17:05:09 +0200529 return fmt.Sprintf("prebuilts/go/%s", c.PrebuiltOS())
Colin Cross3f40fa42015-01-30 17:27:36 -0800530}
531
Jingwen Chenc711fec2020-11-22 23:52:50 -0500532// PrebuiltBuildTool returns the path to a tool in the prebuilts directory containing
533// checked-in tools, like Kati, Ninja or Toybox, for the current host OS.
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700534func (c *config) PrebuiltBuildTool(ctx PathContext, tool string) Path {
535 return PathForSource(ctx, "prebuilts/build-tools", c.PrebuiltOS(), "bin", tool)
536}
537
Jingwen Chenc711fec2020-11-22 23:52:50 -0500538// CpPreserveSymlinksFlags returns the host-specific flag for the cp(1) command
539// to preserve symlinks.
Colin Cross1332b002015-04-07 17:11:30 -0700540func (c *config) CpPreserveSymlinksFlags() string {
Colin Cross485e5722015-08-27 13:28:01 -0700541 switch runtime.GOOS {
Colin Cross3f40fa42015-01-30 17:27:36 -0800542 case "darwin":
543 return "-R"
544 case "linux":
545 return "-d"
546 default:
547 return ""
548 }
549}
Colin Cross68f55102015-03-25 14:43:57 -0700550
Colin Cross1332b002015-04-07 17:11:30 -0700551func (c *config) Getenv(key string) string {
Colin Cross68f55102015-03-25 14:43:57 -0700552 var val string
553 var exists bool
Colin Crossc1e86a32015-04-15 12:33:28 -0700554 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800555 defer c.envLock.Unlock()
556 if c.envDeps == nil {
557 c.envDeps = make(map[string]string)
558 }
Colin Cross68f55102015-03-25 14:43:57 -0700559 if val, exists = c.envDeps[key]; !exists {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700560 if c.envFrozen {
561 panic("Cannot access new environment variables after envdeps are frozen")
562 }
Colin Cross6ccbc912017-10-10 23:07:38 -0700563 val, _ = c.env[key]
Colin Cross68f55102015-03-25 14:43:57 -0700564 c.envDeps[key] = val
565 }
566 return val
567}
568
Colin Cross99d7c232016-11-23 16:52:04 -0800569func (c *config) GetenvWithDefault(key string, defaultValue string) string {
570 ret := c.Getenv(key)
571 if ret == "" {
572 return defaultValue
573 }
574 return ret
575}
576
577func (c *config) IsEnvTrue(key string) bool {
578 value := c.Getenv(key)
579 return value == "1" || value == "y" || value == "yes" || value == "on" || value == "true"
580}
581
582func (c *config) IsEnvFalse(key string) bool {
583 value := c.Getenv(key)
584 return value == "0" || value == "n" || value == "no" || value == "off" || value == "false"
585}
586
Sorin Bascace720c32022-05-24 12:13:50 +0100587func (c *config) TargetsJava17() bool {
588 return c.IsEnvTrue("EXPERIMENTAL_TARGET_JAVA_VERSION_17")
589}
590
Jingwen Chenc711fec2020-11-22 23:52:50 -0500591// EnvDeps returns the environment variables this build depends on. The first
592// call to this function blocks future reads from the environment.
Colin Cross1332b002015-04-07 17:11:30 -0700593func (c *config) EnvDeps() map[string]string {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700594 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800595 defer c.envLock.Unlock()
Dan Willemsene7680ba2015-09-11 17:06:19 -0700596 c.envFrozen = true
Colin Cross68f55102015-03-25 14:43:57 -0700597 return c.envDeps
598}
Colin Cross35cec122015-04-02 14:37:16 -0700599
Jingwen Chencda22c92020-11-23 00:22:30 -0500600func (c *config) KatiEnabled() bool {
601 return c.katiEnabled
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800602}
603
Nan Zhang581fd212018-01-10 16:06:12 -0800604func (c *config) BuildId() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800605 return String(c.productVariables.BuildId)
Nan Zhang581fd212018-01-10 16:06:12 -0800606}
607
Jingwen Chenc711fec2020-11-22 23:52:50 -0500608// BuildNumberFile returns the path to a text file containing metadata
609// representing the current build's number.
610//
611// Rules that want to reference the build number should read from this file
612// without depending on it. They will run whenever their other dependencies
613// require them to run and get the current build number. This ensures they don't
614// rebuild on every incremental build when the build number changes.
Colin Cross2a2e0db2020-02-21 16:55:46 -0800615func (c *config) BuildNumberFile(ctx PathContext) Path {
616 return PathForOutput(ctx, String(c.productVariables.BuildNumberFile))
Nan Zhang581fd212018-01-10 16:06:12 -0800617}
618
Jingwen Chenc711fec2020-11-22 23:52:50 -0500619// DeviceName returns the name of the current device target.
Colin Cross35cec122015-04-02 14:37:16 -0700620// TODO: take an AndroidModuleContext to select the device name for multi-device builds
Colin Cross1332b002015-04-07 17:11:30 -0700621func (c *config) DeviceName() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800622 return *c.productVariables.DeviceName
Colin Cross35cec122015-04-02 14:37:16 -0700623}
624
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000625// DeviceProduct returns the current product target. There could be multiple of
626// these per device type.
627//
628// NOTE: Do not base conditional logic on this value. It may break product
Liz Kammer7ec40cc2022-07-29 10:44:23 -0400629//
630// inheritance.
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000631func (c *config) DeviceProduct() string {
632 return *c.productVariables.DeviceProduct
633}
634
Anton Hansson53c88442019-03-18 15:53:16 +0000635func (c *config) DeviceResourceOverlays() []string {
636 return c.productVariables.DeviceResourceOverlays
637}
638
639func (c *config) ProductResourceOverlays() []string {
640 return c.productVariables.ProductResourceOverlays
Colin Cross30e076a2015-04-13 13:58:27 -0700641}
642
Colin Crossbfd347d2018-05-09 11:11:35 -0700643func (c *config) PlatformVersionName() string {
644 return String(c.productVariables.Platform_version_name)
645}
646
Dan Albert4f378d72020-07-23 17:32:15 -0700647func (c *config) PlatformSdkVersion() ApiLevel {
648 return uncheckedFinalApiLevel(*c.productVariables.Platform_sdk_version)
Colin Cross30e076a2015-04-13 13:58:27 -0700649}
650
Mu-Le Lee5e047532022-07-27 02:32:03 +0000651func (c *config) PlatformSdkFinal() bool {
652 return Bool(c.productVariables.Platform_sdk_final)
653}
654
Colin Crossd09b0b62018-04-18 11:06:47 -0700655func (c *config) PlatformSdkCodename() string {
656 return String(c.productVariables.Platform_sdk_codename)
657}
658
Anton Hansson97d0bae2022-02-16 16:15:10 +0000659func (c *config) PlatformSdkExtensionVersion() int {
660 return *c.productVariables.Platform_sdk_extension_version
661}
662
663func (c *config) PlatformBaseSdkExtensionVersion() int {
664 return *c.productVariables.Platform_base_sdk_extension_version
665}
666
Colin Cross092c9da2019-04-02 22:56:43 -0700667func (c *config) PlatformSecurityPatch() string {
668 return String(c.productVariables.Platform_security_patch)
669}
670
671func (c *config) PlatformPreviewSdkVersion() string {
672 return String(c.productVariables.Platform_preview_sdk_version)
673}
674
675func (c *config) PlatformMinSupportedTargetSdkVersion() string {
676 return String(c.productVariables.Platform_min_supported_target_sdk_version)
677}
678
679func (c *config) PlatformBaseOS() string {
680 return String(c.productVariables.Platform_base_os)
681}
682
Inseob Kim4f1f3d92022-04-25 18:23:58 +0900683func (c *config) PlatformVersionLastStable() string {
684 return String(c.productVariables.Platform_version_last_stable)
685}
686
Jiyong Park37073842022-06-21 10:13:42 +0900687func (c *config) PlatformVersionKnownCodenames() string {
688 return String(c.productVariables.Platform_version_known_codenames)
689}
690
Dan Albert1a246272020-07-06 14:49:35 -0700691func (c *config) MinSupportedSdkVersion() ApiLevel {
Dan Albert6bfb6bb2022-08-17 20:11:57 +0000692 return uncheckedFinalApiLevel(21)
Dan Albert1a246272020-07-06 14:49:35 -0700693}
694
695func (c *config) FinalApiLevels() []ApiLevel {
696 var levels []ApiLevel
Dan Albert4f378d72020-07-23 17:32:15 -0700697 for i := 1; i <= c.PlatformSdkVersion().FinalOrFutureInt(); i++ {
Dan Albert1a246272020-07-06 14:49:35 -0700698 levels = append(levels, uncheckedFinalApiLevel(i))
699 }
700 return levels
701}
702
703func (c *config) PreviewApiLevels() []ApiLevel {
704 var levels []ApiLevel
705 for i, codename := range c.PlatformVersionActiveCodenames() {
706 levels = append(levels, ApiLevel{
707 value: codename,
708 number: i,
709 isPreview: true,
710 })
711 }
712 return levels
713}
714
satayevcca4ab72021-11-30 12:33:55 +0000715func (c *config) LatestPreviewApiLevel() ApiLevel {
716 level := NoneApiLevel
717 for _, l := range c.PreviewApiLevels() {
718 if l.GreaterThan(level) {
719 level = l
720 }
721 }
722 return level
723}
724
Dan Albert1a246272020-07-06 14:49:35 -0700725func (c *config) AllSupportedApiLevels() []ApiLevel {
726 var levels []ApiLevel
727 levels = append(levels, c.FinalApiLevels()...)
728 return append(levels, c.PreviewApiLevels()...)
Dan Albertf5415d72017-08-17 16:19:59 -0700729}
730
Jingwen Chenc711fec2020-11-22 23:52:50 -0500731// DefaultAppTargetSdk returns the API level that platform apps are targeting.
732// This converts a codename to the exact ApiLevel it represents.
Dan Albert4f378d72020-07-23 17:32:15 -0700733func (c *config) DefaultAppTargetSdk(ctx EarlyModuleContext) ApiLevel {
Colin Crossd09b0b62018-04-18 11:06:47 -0700734 if Bool(c.productVariables.Platform_sdk_final) {
735 return c.PlatformSdkVersion()
Colin Crossd09b0b62018-04-18 11:06:47 -0700736 }
Jingwen Chenc711fec2020-11-22 23:52:50 -0500737 codename := c.PlatformSdkCodename()
738 if codename == "" {
739 return NoneApiLevel
740 }
741 if codename == "REL" {
742 panic("Platform_sdk_codename should not be REL when Platform_sdk_final is true")
743 }
744 return ApiLevelOrPanic(ctx, codename)
Colin Crossd09b0b62018-04-18 11:06:47 -0700745}
746
Colin Cross3bc7ffa2017-11-22 16:19:37 -0800747func (c *config) AppsDefaultVersionName() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800748 return String(c.productVariables.AppsDefaultVersionName)
Colin Cross3bc7ffa2017-11-22 16:19:37 -0800749}
750
Dan Albert31384de2017-07-28 12:39:46 -0700751// Codenames that are active in the current lunch target.
752func (c *config) PlatformVersionActiveCodenames() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800753 return c.productVariables.Platform_version_active_codenames
Dan Albert31384de2017-07-28 12:39:46 -0700754}
755
Colin Crossface4e42017-10-30 17:32:15 -0700756func (c *config) ProductAAPTConfig() []string {
Colin Crossa74ca042019-01-31 14:31:51 -0800757 return c.productVariables.AAPTConfig
Colin Cross30e076a2015-04-13 13:58:27 -0700758}
759
Colin Crossface4e42017-10-30 17:32:15 -0700760func (c *config) ProductAAPTPreferredConfig() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800761 return String(c.productVariables.AAPTPreferredConfig)
Colin Cross30e076a2015-04-13 13:58:27 -0700762}
763
Colin Crossface4e42017-10-30 17:32:15 -0700764func (c *config) ProductAAPTCharacteristics() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800765 return String(c.productVariables.AAPTCharacteristics)
Colin Crossface4e42017-10-30 17:32:15 -0700766}
767
768func (c *config) ProductAAPTPrebuiltDPI() []string {
Colin Crossa74ca042019-01-31 14:31:51 -0800769 return c.productVariables.AAPTPrebuiltDPI
Colin Cross30e076a2015-04-13 13:58:27 -0700770}
771
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700772func (c *config) DefaultAppCertificateDir(ctx PathContext) SourcePath {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800773 defaultCert := String(c.productVariables.DefaultAppCertificate)
Colin Cross61ae0b72017-12-01 17:16:02 -0800774 if defaultCert != "" {
775 return PathForSource(ctx, filepath.Dir(defaultCert))
Colin Cross61ae0b72017-12-01 17:16:02 -0800776 }
Jingwen Chenc711fec2020-11-22 23:52:50 -0500777 return PathForSource(ctx, "build/make/target/product/security")
Colin Cross30e076a2015-04-13 13:58:27 -0700778}
779
Colin Crosse1731a52017-12-14 11:22:55 -0800780func (c *config) DefaultAppCertificate(ctx PathContext) (pem, key SourcePath) {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800781 defaultCert := String(c.productVariables.DefaultAppCertificate)
Colin Cross61ae0b72017-12-01 17:16:02 -0800782 if defaultCert != "" {
Colin Crosse1731a52017-12-14 11:22:55 -0800783 return PathForSource(ctx, defaultCert+".x509.pem"), PathForSource(ctx, defaultCert+".pk8")
Colin Cross61ae0b72017-12-01 17:16:02 -0800784 }
Jingwen Chenc711fec2020-11-22 23:52:50 -0500785 defaultDir := c.DefaultAppCertificateDir(ctx)
786 return defaultDir.Join(ctx, "testkey.x509.pem"), defaultDir.Join(ctx, "testkey.pk8")
Colin Cross30e076a2015-04-13 13:58:27 -0700787}
Colin Cross6ff51382015-12-17 16:39:19 -0800788
Jiyong Park9335a262018-12-24 11:31:58 +0900789func (c *config) ApexKeyDir(ctx ModuleContext) SourcePath {
790 // TODO(b/121224311): define another variable such as TARGET_APEX_KEY_OVERRIDE
791 defaultCert := String(c.productVariables.DefaultAppCertificate)
Dan Willemsen412160e2019-04-09 21:36:26 -0700792 if defaultCert == "" || filepath.Dir(defaultCert) == "build/make/target/product/security" {
Jiyong Park9335a262018-12-24 11:31:58 +0900793 // When defaultCert is unset or is set to the testkeys path, use the APEX keys
794 // that is under the module dir
Colin Cross07e51612019-03-05 12:46:40 -0800795 return pathForModuleSrc(ctx)
Jiyong Park9335a262018-12-24 11:31:58 +0900796 }
Jingwen Chenc711fec2020-11-22 23:52:50 -0500797 // If not, APEX keys are under the specified directory
798 return PathForSource(ctx, filepath.Dir(defaultCert))
Jiyong Park9335a262018-12-24 11:31:58 +0900799}
800
Inseob Kim80fa7982022-08-12 21:36:25 +0900801// Certificate for the NetworkStack sepolicy context
802func (c *config) MainlineSepolicyDevCertificatesDir(ctx ModuleContext) SourcePath {
803 cert := String(c.productVariables.MainlineSepolicyDevCertificates)
804 if cert != "" {
805 return PathForSource(ctx, cert)
806 }
807 return c.DefaultAppCertificateDir(ctx)
808}
809
Jingwen Chenc711fec2020-11-22 23:52:50 -0500810// AllowMissingDependencies configures Blueprint/Soong to not fail when modules
811// are configured to depend on non-existent modules. Note that this does not
812// affect missing input dependencies at the Ninja level.
Colin Cross6ff51382015-12-17 16:39:19 -0800813func (c *config) AllowMissingDependencies() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800814 return Bool(c.productVariables.Allow_missing_dependencies)
Colin Cross6ff51382015-12-17 16:39:19 -0800815}
Dan Willemsen322acaf2016-01-12 23:07:05 -0800816
Jeongik Cha816a23a2020-07-08 01:09:23 +0900817// Returns true if a full platform source tree cannot be assumed.
Colin Crossfc3674a2017-09-18 17:41:52 -0700818func (c *config) UnbundledBuild() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800819 return Bool(c.productVariables.Unbundled_build)
Colin Crossfc3674a2017-09-18 17:41:52 -0700820}
821
Martin Stjernholmfd9eb4b2020-06-17 01:13:15 +0100822// Returns true if building apps that aren't bundled with the platform.
823// UnbundledBuild() is always true when this is true.
824func (c *config) UnbundledBuildApps() bool {
Cole Faust701ca252021-11-23 19:02:08 -0800825 return len(c.productVariables.Unbundled_build_apps) > 0
Martin Stjernholmfd9eb4b2020-06-17 01:13:15 +0100826}
827
Jeongik Cha4b073cd2021-06-08 11:35:00 +0900828// Returns true if building image that aren't bundled with the platform.
829// UnbundledBuild() is always true when this is true.
830func (c *config) UnbundledBuildImage() bool {
831 return Bool(c.productVariables.Unbundled_build_image)
832}
833
Jeongik Cha816a23a2020-07-08 01:09:23 +0900834// Returns true if building modules against prebuilt SDKs.
835func (c *config) AlwaysUsePrebuiltSdks() bool {
836 return Bool(c.productVariables.Always_use_prebuilt_sdks)
Colin Cross1f367bf2018-12-18 22:46:24 -0800837}
838
Colin Cross126a25c2017-10-31 13:55:34 -0700839func (c *config) MinimizeJavaDebugInfo() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800840 return Bool(c.productVariables.MinimizeJavaDebugInfo) && !Bool(c.productVariables.Eng)
Colin Cross126a25c2017-10-31 13:55:34 -0700841}
842
Colin Crossed064c02018-09-05 16:28:13 -0700843func (c *config) Debuggable() bool {
844 return Bool(c.productVariables.Debuggable)
845}
846
Jaewoong Jung1d6eb682018-11-29 15:08:44 -0800847func (c *config) Eng() bool {
848 return Bool(c.productVariables.Eng)
849}
850
Colin Crossc53c37f2021-12-08 15:42:22 -0800851// DevicePrimaryArchType returns the ArchType for the first configured device architecture, or
852// Common if there are no device architectures.
Jiyong Park8d52f862018-07-07 18:02:07 +0900853func (c *config) DevicePrimaryArchType() ArchType {
Colin Crossc53c37f2021-12-08 15:42:22 -0800854 if androidTargets := c.Targets[Android]; len(androidTargets) > 0 {
855 return androidTargets[0].Arch.ArchType
856 }
857 return Common
Jiyong Park8d52f862018-07-07 18:02:07 +0900858}
859
Colin Cross16b23492016-01-06 14:41:07 -0800860func (c *config) SanitizeHost() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800861 return append([]string(nil), c.productVariables.SanitizeHost...)
Colin Cross16b23492016-01-06 14:41:07 -0800862}
863
864func (c *config) SanitizeDevice() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800865 return append([]string(nil), c.productVariables.SanitizeDevice...)
Colin Cross23ae82a2016-11-02 14:34:39 -0700866}
867
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700868func (c *config) SanitizeDeviceDiag() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800869 return append([]string(nil), c.productVariables.SanitizeDeviceDiag...)
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700870}
871
Colin Cross23ae82a2016-11-02 14:34:39 -0700872func (c *config) SanitizeDeviceArch() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800873 return append([]string(nil), c.productVariables.SanitizeDeviceArch...)
Colin Cross16b23492016-01-06 14:41:07 -0800874}
Colin Crossa1ad8d12016-06-01 17:09:44 -0700875
Vishwath Mohan1b017a72017-01-19 13:54:55 -0800876func (c *config) EnableCFI() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800877 if c.productVariables.EnableCFI == nil {
Vishwath Mohanc32c3eb2017-01-24 14:20:54 -0800878 return true
Vishwath Mohanc32c3eb2017-01-24 14:20:54 -0800879 }
Jingwen Chenc711fec2020-11-22 23:52:50 -0500880 return *c.productVariables.EnableCFI
Vishwath Mohan1b017a72017-01-19 13:54:55 -0800881}
882
Kostya Kortchinskyd5275c82019-02-01 08:42:56 -0800883func (c *config) DisableScudo() bool {
884 return Bool(c.productVariables.DisableScudo)
885}
886
Colin Crossa1ad8d12016-06-01 17:09:44 -0700887func (c *config) Android64() bool {
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700888 for _, t := range c.Targets[Android] {
Colin Crossa1ad8d12016-06-01 17:09:44 -0700889 if t.Arch.ArchType.Multilib == "lib64" {
890 return true
891 }
892 }
893
894 return false
895}
Colin Cross9272ade2016-08-17 15:24:12 -0700896
Colin Cross9d45bb72016-08-29 16:14:13 -0700897func (c *config) UseGoma() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800898 return Bool(c.productVariables.UseGoma)
Colin Cross9d45bb72016-08-29 16:14:13 -0700899}
900
Ramy Medhatbbf25672019-07-17 12:30:04 +0000901func (c *config) UseRBE() bool {
902 return Bool(c.productVariables.UseRBE)
903}
904
Ramy Medhat8ea054a2020-01-27 14:19:44 -0500905func (c *config) UseRBEJAVAC() bool {
906 return Bool(c.productVariables.UseRBEJAVAC)
907}
908
909func (c *config) UseRBER8() bool {
910 return Bool(c.productVariables.UseRBER8)
911}
912
913func (c *config) UseRBED8() bool {
914 return Bool(c.productVariables.UseRBED8)
915}
916
Colin Cross8b8bec32019-11-15 13:18:43 -0800917func (c *config) UseRemoteBuild() bool {
918 return c.UseGoma() || c.UseRBE()
919}
920
Colin Cross66548102018-06-19 22:47:35 -0700921func (c *config) RunErrorProne() bool {
922 return c.IsEnvTrue("RUN_ERROR_PRONE")
923}
924
Jingwen Chenc711fec2020-11-22 23:52:50 -0500925// XrefCorpusName returns the Kythe cross-reference corpus name.
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800926func (c *config) XrefCorpusName() string {
927 return c.Getenv("XREF_CORPUS")
928}
929
Jingwen Chenc711fec2020-11-22 23:52:50 -0500930// XrefCuEncoding returns the compilation unit encoding to use for Kythe code
931// xrefs. Can be 'json' (default), 'proto' or 'all'.
Sasha Smundak6c2d4f92020-01-09 17:34:23 -0800932func (c *config) XrefCuEncoding() string {
933 if enc := c.Getenv("KYTHE_KZIP_ENCODING"); enc != "" {
934 return enc
935 }
936 return "json"
937}
938
Sasha Smundakb0addaf2021-02-16 10:39:40 -0800939// XrefCuJavaSourceMax returns the maximum number of the Java source files
940// in a single compilation unit
941const xrefJavaSourceFileMaxDefault = "1000"
942
943func (c Config) XrefCuJavaSourceMax() string {
944 v := c.Getenv("KYTHE_JAVA_SOURCE_BATCH_SIZE")
945 if v == "" {
946 return xrefJavaSourceFileMaxDefault
947 }
948 if _, err := strconv.ParseUint(v, 0, 0); err != nil {
949 fmt.Fprintf(os.Stderr,
950 "bad KYTHE_JAVA_SOURCE_BATCH_SIZE value: %s, will use %s",
951 err, xrefJavaSourceFileMaxDefault)
952 return xrefJavaSourceFileMaxDefault
953 }
954 return v
955
956}
957
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800958func (c *config) EmitXrefRules() bool {
959 return c.XrefCorpusName() != ""
960}
961
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700962func (c *config) ClangTidy() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800963 return Bool(c.productVariables.ClangTidy)
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700964}
965
966func (c *config) TidyChecks() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800967 if c.productVariables.TidyChecks == nil {
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700968 return ""
969 }
Dan Willemsen45133ac2018-03-09 21:22:06 -0800970 return *c.productVariables.TidyChecks
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700971}
972
Colin Cross0f4e0d62016-07-27 10:56:55 -0700973func (c *config) LibartImgHostBaseAddress() string {
974 return "0x60000000"
975}
976
977func (c *config) LibartImgDeviceBaseAddress() string {
Elliott Hughesda3a0712020-03-06 16:55:28 -0800978 return "0x70000000"
Colin Cross0f4e0d62016-07-27 10:56:55 -0700979}
980
Hiroshi Yamauchie2a10632016-12-19 13:44:41 -0800981func (c *config) ArtUseReadBarrier() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800982 return Bool(c.productVariables.ArtUseReadBarrier)
Hiroshi Yamauchie2a10632016-12-19 13:44:41 -0800983}
984
Jingwen Chenc711fec2020-11-22 23:52:50 -0500985// Enforce Runtime Resource Overlays for a module. RROs supersede static RROs,
986// but some modules still depend on it.
987//
988// More info: https://source.android.com/devices/architecture/rros
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700989func (c *config) EnforceRROForModule(name string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800990 enforceList := c.productVariables.EnforceRROTargets
Jeongik Chacee5ba92021-02-19 12:11:51 +0900991
Roland Levillainf6cc2612020-07-09 16:58:14 +0100992 if len(enforceList) > 0 {
Yo Chiang4ebd06a2019-10-01 13:13:41 +0800993 if InList("*", enforceList) {
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700994 return true
995 }
Colin Crossa74ca042019-01-31 14:31:51 -0800996 return InList(name, enforceList)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700997 }
998 return false
999}
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001000func (c *config) EnforceRROExcludedOverlay(path string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001001 excluded := c.productVariables.EnforceRROExcludedOverlays
Roland Levillainf6cc2612020-07-09 16:58:14 +01001002 if len(excluded) > 0 {
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001003 return HasAnyPrefix(path, excluded)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001004 }
1005 return false
1006}
1007
1008func (c *config) ExportedNamespaces() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001009 return append([]string(nil), c.productVariables.NamespacesToExport...)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001010}
1011
1012func (c *config) HostStaticBinaries() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001013 return Bool(c.productVariables.HostStaticBinaries)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001014}
1015
Colin Cross5a0dcd52018-10-05 14:20:06 -07001016func (c *config) UncompressPrivAppDex() bool {
1017 return Bool(c.productVariables.UncompressPrivAppDex)
1018}
1019
1020func (c *config) ModulesLoadedByPrivilegedModules() []string {
1021 return c.productVariables.ModulesLoadedByPrivilegedModules
1022}
1023
Jingwen Chenc711fec2020-11-22 23:52:50 -05001024// DexpreoptGlobalConfigPath returns the path to the dexpreopt.config file in
1025// the output directory, if it was created during the product configuration
1026// phase by Kati.
Jingwen Chenebb0b572020-11-02 00:24:57 -05001027func (c *config) DexpreoptGlobalConfigPath(ctx PathContext) OptionalPath {
Colin Cross988414c2020-01-11 01:11:46 +00001028 if c.productVariables.DexpreoptGlobalConfig == nil {
Jingwen Chenebb0b572020-11-02 00:24:57 -05001029 return OptionalPathForPath(nil)
1030 }
1031 return OptionalPathForPath(
1032 pathForBuildToolDep(ctx, *c.productVariables.DexpreoptGlobalConfig))
1033}
1034
Jingwen Chenc711fec2020-11-22 23:52:50 -05001035// DexpreoptGlobalConfig returns the raw byte contents of the dexpreopt global
1036// configuration. Since the configuration file was created by Kati during
1037// product configuration (externally of soong_build), it's not tracked, so we
1038// also manually add a Ninja file dependency on the configuration file to the
1039// rule that creates the main build.ninja file. This ensures that build.ninja is
1040// regenerated correctly if dexpreopt.config changes.
Jingwen Chenebb0b572020-11-02 00:24:57 -05001041func (c *config) DexpreoptGlobalConfig(ctx PathContext) ([]byte, error) {
1042 path := c.DexpreoptGlobalConfigPath(ctx)
1043 if !path.Valid() {
Colin Cross988414c2020-01-11 01:11:46 +00001044 return nil, nil
1045 }
Jingwen Chenebb0b572020-11-02 00:24:57 -05001046 ctx.AddNinjaFileDeps(path.String())
1047 return ioutil.ReadFile(absolutePath(path.String()))
Colin Cross43f08db2018-11-12 10:13:39 -08001048}
1049
Inseob Kim7b85eeb2021-03-23 20:52:24 +09001050func (c *deviceConfig) WithDexpreopt() bool {
1051 return c.config.productVariables.WithDexpreopt
1052}
1053
David Brazdil91b4e3e2019-01-23 21:04:05 +00001054func (c *config) FrameworksBaseDirExists(ctx PathContext) bool {
Colin Cross5a756a62021-03-16 16:34:46 -07001055 return ExistentPathForSource(ctx, "frameworks", "base", "Android.bp").Valid()
David Brazdil91b4e3e2019-01-23 21:04:05 +00001056}
1057
Inseob Kimae553032019-05-14 18:52:49 +09001058func (c *config) VndkSnapshotBuildArtifacts() bool {
1059 return Bool(c.productVariables.VndkSnapshotBuildArtifacts)
1060}
1061
Colin Cross3b19f5d2019-09-17 14:45:31 -07001062func (c *config) HasMultilibConflict(arch ArchType) bool {
1063 return c.multilibConflicts[arch]
1064}
1065
Bill Peckhambae47492021-01-08 09:34:44 -08001066func (c *config) PrebuiltHiddenApiDir(ctx PathContext) string {
1067 return String(c.productVariables.PrebuiltHiddenApiDir)
1068}
1069
Colin Cross9272ade2016-08-17 15:24:12 -07001070func (c *deviceConfig) Arches() []Arch {
1071 var arches []Arch
Dan Willemsen0ef639b2018-10-10 17:02:29 -07001072 for _, target := range c.config.Targets[Android] {
Colin Cross9272ade2016-08-17 15:24:12 -07001073 arches = append(arches, target.Arch)
1074 }
1075 return arches
1076}
Dan Willemsend2ede872016-11-18 14:54:24 -08001077
Jayant Chowdhary34ce67d2018-03-08 11:00:50 -08001078func (c *deviceConfig) BinderBitness() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001079 is32BitBinder := c.config.productVariables.Binder32bit
Jayant Chowdhary34ce67d2018-03-08 11:00:50 -08001080 if is32BitBinder != nil && *is32BitBinder {
1081 return "32"
1082 }
1083 return "64"
1084}
1085
Dan Willemsen4353bc42016-12-05 17:16:02 -08001086func (c *deviceConfig) VendorPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001087 if c.config.productVariables.VendorPath != nil {
1088 return *c.config.productVariables.VendorPath
Dan Willemsen4353bc42016-12-05 17:16:02 -08001089 }
1090 return "vendor"
1091}
1092
Justin Yun71549282017-11-17 12:10:28 +09001093func (c *deviceConfig) VndkVersion() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001094 return String(c.config.productVariables.DeviceVndkVersion)
Justin Yun71549282017-11-17 12:10:28 +09001095}
1096
Jose Galmes6f843bc2020-12-11 13:36:29 -08001097func (c *deviceConfig) RecoverySnapshotVersion() string {
1098 return String(c.config.productVariables.RecoverySnapshotVersion)
1099}
1100
Jeongik Cha219141c2020-08-06 23:00:37 +09001101func (c *deviceConfig) CurrentApiLevelForVendorModules() string {
1102 return StringDefault(c.config.productVariables.DeviceCurrentApiLevelForVendorModules, "current")
1103}
1104
Justin Yun8fe12122017-12-07 17:18:15 +09001105func (c *deviceConfig) PlatformVndkVersion() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001106 return String(c.config.productVariables.Platform_vndk_version)
Justin Yun8fe12122017-12-07 17:18:15 +09001107}
1108
Justin Yun5f7f7e82019-11-18 19:52:14 +09001109func (c *deviceConfig) ProductVndkVersion() string {
1110 return String(c.config.productVariables.ProductVndkVersion)
1111}
1112
Justin Yun71549282017-11-17 12:10:28 +09001113func (c *deviceConfig) ExtraVndkVersions() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001114 return c.config.productVariables.ExtraVndkVersions
Dan Willemsend2ede872016-11-18 14:54:24 -08001115}
Jack He8cc71432016-12-08 15:45:07 -08001116
Vic Yangefd249e2018-11-12 20:19:56 -08001117func (c *deviceConfig) VndkUseCoreVariant() bool {
1118 return Bool(c.config.productVariables.VndkUseCoreVariant)
1119}
1120
Jiyong Park1a5d7b12018-01-15 15:05:10 +09001121func (c *deviceConfig) SystemSdkVersions() []string {
Colin Crossa74ca042019-01-31 14:31:51 -08001122 return c.config.productVariables.DeviceSystemSdkVersions
Jiyong Park1a5d7b12018-01-15 15:05:10 +09001123}
1124
1125func (c *deviceConfig) PlatformSystemSdkVersions() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001126 return c.config.productVariables.Platform_systemsdk_versions
Jiyong Park1a5d7b12018-01-15 15:05:10 +09001127}
1128
Jiyong Park2db76922017-11-08 16:03:48 +09001129func (c *deviceConfig) OdmPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001130 if c.config.productVariables.OdmPath != nil {
1131 return *c.config.productVariables.OdmPath
Jiyong Park2db76922017-11-08 16:03:48 +09001132 }
1133 return "odm"
1134}
1135
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +09001136func (c *deviceConfig) ProductPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001137 if c.config.productVariables.ProductPath != nil {
1138 return *c.config.productVariables.ProductPath
Jiyong Park2db76922017-11-08 16:03:48 +09001139 }
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +09001140 return "product"
Jiyong Park2db76922017-11-08 16:03:48 +09001141}
1142
Justin Yund5f6c822019-06-25 16:47:17 +09001143func (c *deviceConfig) SystemExtPath() string {
1144 if c.config.productVariables.SystemExtPath != nil {
1145 return *c.config.productVariables.SystemExtPath
Dario Frenifd05a742018-05-29 13:28:54 +01001146 }
Justin Yund5f6c822019-06-25 16:47:17 +09001147 return "system_ext"
Dario Frenifd05a742018-05-29 13:28:54 +01001148}
1149
Jack He8cc71432016-12-08 15:45:07 -08001150func (c *deviceConfig) BtConfigIncludeDir() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001151 return String(c.config.productVariables.BtConfigIncludeDir)
Jack He8cc71432016-12-08 15:45:07 -08001152}
Dan Willemsen581341d2017-02-09 16:16:31 -08001153
Jiyong Parkd773eb32017-07-03 13:18:12 +09001154func (c *deviceConfig) DeviceKernelHeaderDirs() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001155 return c.config.productVariables.DeviceKernelHeaders
Jiyong Parkd773eb32017-07-03 13:18:12 +09001156}
1157
Roland Levillainada12702020-06-09 13:07:36 +01001158// JavaCoverageEnabledForPath returns whether Java code coverage is enabled for
1159// path. Coverage is enabled by default when the product variable
1160// JavaCoveragePaths is empty. If JavaCoveragePaths is not empty, coverage is
1161// enabled for any path which is part of this variable (and not part of the
1162// JavaCoverageExcludePaths product variable). Value "*" in JavaCoveragePaths
1163// represents any path.
1164func (c *deviceConfig) JavaCoverageEnabledForPath(path string) bool {
1165 coverage := false
Chris Gross2f748692020-06-24 20:36:59 +00001166 if len(c.config.productVariables.JavaCoveragePaths) == 0 ||
Roland Levillainada12702020-06-09 13:07:36 +01001167 InList("*", c.config.productVariables.JavaCoveragePaths) ||
1168 HasAnyPrefix(path, c.config.productVariables.JavaCoveragePaths) {
1169 coverage = true
1170 }
Roland Levillainf6cc2612020-07-09 16:58:14 +01001171 if coverage && len(c.config.productVariables.JavaCoverageExcludePaths) > 0 {
Roland Levillainada12702020-06-09 13:07:36 +01001172 if HasAnyPrefix(path, c.config.productVariables.JavaCoverageExcludePaths) {
1173 coverage = false
1174 }
1175 }
1176 return coverage
1177}
1178
Colin Cross1a6acd42020-06-16 17:51:46 -07001179// Returns true if gcov or clang coverage is enabled.
Dan Willemsen581341d2017-02-09 16:16:31 -08001180func (c *deviceConfig) NativeCoverageEnabled() bool {
Colin Cross1a6acd42020-06-16 17:51:46 -07001181 return Bool(c.config.productVariables.GcovCoverage) ||
1182 Bool(c.config.productVariables.ClangCoverage)
Dan Willemsen581341d2017-02-09 16:16:31 -08001183}
1184
Oliver Nguyen1382ab62019-12-06 15:22:41 -08001185func (c *deviceConfig) ClangCoverageEnabled() bool {
1186 return Bool(c.config.productVariables.ClangCoverage)
1187}
1188
Pirama Arumuga Nainarb37ae582022-01-26 22:14:32 -08001189func (c *deviceConfig) ClangCoverageContinuousMode() bool {
1190 return Bool(c.config.productVariables.ClangCoverageContinuousMode)
1191}
1192
Colin Cross1a6acd42020-06-16 17:51:46 -07001193func (c *deviceConfig) GcovCoverageEnabled() bool {
1194 return Bool(c.config.productVariables.GcovCoverage)
1195}
1196
Roland Levillain4f5297b2020-06-09 12:44:06 +01001197// NativeCoverageEnabledForPath returns whether (GCOV- or Clang-based) native
1198// code coverage is enabled for path. By default, coverage is not enabled for a
1199// given path unless it is part of the NativeCoveragePaths product variable (and
1200// not part of the NativeCoverageExcludePaths product variable). Value "*" in
1201// NativeCoveragePaths represents any path.
1202func (c *deviceConfig) NativeCoverageEnabledForPath(path string) bool {
Ryan Campbell469a18a2017-02-27 09:01:54 -08001203 coverage := false
Roland Levillainf6cc2612020-07-09 16:58:14 +01001204 if len(c.config.productVariables.NativeCoveragePaths) > 0 {
Roland Levillain4f5297b2020-06-09 12:44:06 +01001205 if InList("*", c.config.productVariables.NativeCoveragePaths) || HasAnyPrefix(path, c.config.productVariables.NativeCoveragePaths) {
Ivan Lozano5f595532017-07-13 14:46:05 -07001206 coverage = true
Dan Willemsen581341d2017-02-09 16:16:31 -08001207 }
1208 }
Roland Levillainf6cc2612020-07-09 16:58:14 +01001209 if coverage && len(c.config.productVariables.NativeCoverageExcludePaths) > 0 {
Roland Levillain4f5297b2020-06-09 12:44:06 +01001210 if HasAnyPrefix(path, c.config.productVariables.NativeCoverageExcludePaths) {
Ivan Lozano5f595532017-07-13 14:46:05 -07001211 coverage = false
Ryan Campbell469a18a2017-02-27 09:01:54 -08001212 }
1213 }
1214 return coverage
Dan Willemsen581341d2017-02-09 16:16:31 -08001215}
Ivan Lozano5f595532017-07-13 14:46:05 -07001216
Yi Kongeb8efc92021-12-09 18:06:29 +08001217func (c *deviceConfig) AfdoAdditionalProfileDirs() []string {
1218 return c.config.productVariables.AfdoAdditionalProfileDirs
1219}
1220
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -08001221func (c *deviceConfig) PgoAdditionalProfileDirs() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001222 return c.config.productVariables.PgoAdditionalProfileDirs
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -08001223}
1224
Tri Vo35a51432018-03-25 20:00:00 -07001225func (c *deviceConfig) VendorSepolicyDirs() []string {
1226 return c.config.productVariables.BoardVendorSepolicyDirs
1227}
1228
1229func (c *deviceConfig) OdmSepolicyDirs() []string {
1230 return c.config.productVariables.BoardOdmSepolicyDirs
1231}
1232
Felixa20a8752020-05-17 18:28:35 +02001233func (c *deviceConfig) SystemExtPublicSepolicyDirs() []string {
1234 return c.config.productVariables.SystemExtPublicSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -07001235}
1236
Felixa20a8752020-05-17 18:28:35 +02001237func (c *deviceConfig) SystemExtPrivateSepolicyDirs() []string {
1238 return c.config.productVariables.SystemExtPrivateSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -07001239}
1240
Inseob Kim0866b002019-04-15 20:21:29 +09001241func (c *deviceConfig) SepolicyM4Defs() []string {
1242 return c.config.productVariables.BoardSepolicyM4Defs
1243}
1244
Jiyong Park7f67f482019-01-05 12:57:48 +09001245func (c *deviceConfig) OverrideManifestPackageNameFor(name string) (manifestName string, overridden bool) {
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001246 return findOverrideValue(c.config.productVariables.ManifestPackageNameOverrides, name,
1247 "invalid override rule %q in PRODUCT_MANIFEST_PACKAGE_NAME_OVERRIDES should be <module_name>:<manifest_name>")
1248}
1249
1250func (c *deviceConfig) OverrideCertificateFor(name string) (certificatePath string, overridden bool) {
Jaewoong Jungacb6db32019-02-28 16:22:30 +00001251 return findOverrideValue(c.config.productVariables.CertificateOverrides, name,
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001252 "invalid override rule %q in PRODUCT_CERTIFICATE_OVERRIDES should be <module_name>:<certificate_module_name>")
1253}
1254
Jaewoong Jung9d22a912019-01-23 16:27:47 -08001255func (c *deviceConfig) OverridePackageNameFor(name string) string {
1256 newName, overridden := findOverrideValue(
1257 c.config.productVariables.PackageNameOverrides,
1258 name,
1259 "invalid override rule %q in PRODUCT_PACKAGE_NAME_OVERRIDES should be <module_name>:<package_name>")
1260 if overridden {
1261 return newName
1262 }
1263 return name
1264}
1265
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001266func findOverrideValue(overrides []string, name string, errorMsg string) (newValue string, overridden bool) {
Jiyong Park7f67f482019-01-05 12:57:48 +09001267 if overrides == nil || len(overrides) == 0 {
1268 return "", false
1269 }
1270 for _, o := range overrides {
1271 split := strings.Split(o, ":")
1272 if len(split) != 2 {
1273 // This shouldn't happen as this is first checked in make, but just in case.
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001274 panic(fmt.Errorf(errorMsg, o))
Jiyong Park7f67f482019-01-05 12:57:48 +09001275 }
1276 if matchPattern(split[0], name) {
1277 return substPattern(split[0], split[1], name), true
1278 }
1279 }
1280 return "", false
1281}
1282
Albert Martineefabcf2022-03-21 20:11:16 +00001283func (c *deviceConfig) ApexGlobalMinSdkVersionOverride() string {
1284 return String(c.config.productVariables.ApexGlobalMinSdkVersionOverride)
1285}
1286
Ivan Lozano5f595532017-07-13 14:46:05 -07001287func (c *config) IntegerOverflowDisabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001288 if len(c.productVariables.IntegerOverflowExcludePaths) == 0 {
Ivan Lozano5f595532017-07-13 14:46:05 -07001289 return false
1290 }
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001291 return HasAnyPrefix(path, c.productVariables.IntegerOverflowExcludePaths)
Ivan Lozano5f595532017-07-13 14:46:05 -07001292}
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001293
1294func (c *config) CFIDisabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001295 if len(c.productVariables.CFIExcludePaths) == 0 {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001296 return false
1297 }
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001298 return HasAnyPrefix(path, c.productVariables.CFIExcludePaths)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001299}
1300
1301func (c *config) CFIEnabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001302 if len(c.productVariables.CFIIncludePaths) == 0 {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001303 return false
1304 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001305 return HasAnyPrefix(path, c.productVariables.CFIIncludePaths) && !c.CFIDisabledForPath(path)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001306}
Colin Crosse15ddaf2017-12-04 11:24:31 -08001307
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001308func (c *config) MemtagHeapDisabledForPath(path string) bool {
1309 if len(c.productVariables.MemtagHeapExcludePaths) == 0 {
1310 return false
1311 }
1312 return HasAnyPrefix(path, c.productVariables.MemtagHeapExcludePaths)
1313}
1314
1315func (c *config) MemtagHeapAsyncEnabledForPath(path string) bool {
1316 if len(c.productVariables.MemtagHeapAsyncIncludePaths) == 0 {
1317 return false
1318 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001319 return HasAnyPrefix(path, c.productVariables.MemtagHeapAsyncIncludePaths) && !c.MemtagHeapDisabledForPath(path)
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001320}
1321
1322func (c *config) MemtagHeapSyncEnabledForPath(path string) bool {
1323 if len(c.productVariables.MemtagHeapSyncIncludePaths) == 0 {
1324 return false
1325 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001326 return HasAnyPrefix(path, c.productVariables.MemtagHeapSyncIncludePaths) && !c.MemtagHeapDisabledForPath(path)
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001327}
1328
Dan Willemsen0fe78662018-03-26 12:41:18 -07001329func (c *config) VendorConfig(name string) VendorConfig {
Colin Cross9d34f352019-11-22 16:03:51 -08001330 return soongconfig.Config(c.productVariables.VendorVars[name])
Dan Willemsen0fe78662018-03-26 12:41:18 -07001331}
1332
Colin Cross395f2cf2018-10-24 16:10:32 -07001333func (c *config) NdkAbis() bool {
1334 return Bool(c.productVariables.Ndk_abis)
1335}
1336
Martin Stjernholmc1ecc432019-11-15 15:00:31 +00001337func (c *config) AmlAbis() bool {
1338 return Bool(c.productVariables.Aml_abis)
1339}
1340
Jiyong Park8fd61922018-11-08 02:50:25 +09001341func (c *config) FlattenApex() bool {
Roland Levillaina3863212019-08-12 19:56:16 +01001342 return Bool(c.productVariables.Flatten_apex)
Jiyong Park8fd61922018-11-08 02:50:25 +09001343}
1344
Jiyong Park4da07972021-01-05 21:01:11 +09001345func (c *config) ForceApexSymlinkOptimization() bool {
1346 return Bool(c.productVariables.ForceApexSymlinkOptimization)
1347}
1348
Sasha Smundakfe9a5b82022-07-27 14:51:45 -07001349func (c *config) ApexCompressionEnabled() bool {
1350 return Bool(c.productVariables.CompressedApex) && !c.UnbundledBuildApps()
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +00001351}
1352
Jeongik Chac9464142019-01-07 12:07:27 +09001353func (c *config) EnforceSystemCertificate() bool {
1354 return Bool(c.productVariables.EnforceSystemCertificate)
1355}
1356
Colin Cross440e0d02020-06-11 11:32:11 -07001357func (c *config) EnforceSystemCertificateAllowList() []string {
1358 return c.productVariables.EnforceSystemCertificateAllowList
Jeongik Chac9464142019-01-07 12:07:27 +09001359}
1360
Jeongik Cha2cc570d2019-10-29 15:44:45 +09001361func (c *config) EnforceProductPartitionInterface() bool {
1362 return Bool(c.productVariables.EnforceProductPartitionInterface)
1363}
1364
JaeMan Parkff715562020-10-19 17:25:58 +09001365func (c *config) EnforceInterPartitionJavaSdkLibrary() bool {
1366 return Bool(c.productVariables.EnforceInterPartitionJavaSdkLibrary)
1367}
1368
1369func (c *config) InterPartitionJavaLibraryAllowList() []string {
1370 return c.productVariables.InterPartitionJavaLibraryAllowList
1371}
1372
Jooyung Han3ab2c3e2019-12-05 16:27:44 +09001373func (c *config) InstallExtraFlattenedApexes() bool {
1374 return Bool(c.productVariables.InstallExtraFlattenedApexes)
1375}
1376
Colin Crossf24a22a2019-01-31 14:12:44 -08001377func (c *config) ProductHiddenAPIStubs() []string {
1378 return c.productVariables.ProductHiddenAPIStubs
Colin Cross8faf8fc2019-01-16 15:15:52 -08001379}
1380
Colin Crossf24a22a2019-01-31 14:12:44 -08001381func (c *config) ProductHiddenAPIStubsSystem() []string {
1382 return c.productVariables.ProductHiddenAPIStubsSystem
Colin Cross8faf8fc2019-01-16 15:15:52 -08001383}
1384
Colin Crossf24a22a2019-01-31 14:12:44 -08001385func (c *config) ProductHiddenAPIStubsTest() []string {
1386 return c.productVariables.ProductHiddenAPIStubsTest
Colin Cross8faf8fc2019-01-16 15:15:52 -08001387}
Dan Willemsen71c74602019-04-10 12:27:35 -07001388
Dan Willemsen54879d12019-04-18 10:08:46 -07001389func (c *deviceConfig) TargetFSConfigGen() []string {
Dan Willemsen71c74602019-04-10 12:27:35 -07001390 return c.config.productVariables.TargetFSConfigGen
1391}
Inseob Kim0866b002019-04-15 20:21:29 +09001392
1393func (c *config) ProductPublicSepolicyDirs() []string {
1394 return c.productVariables.ProductPublicSepolicyDirs
1395}
1396
1397func (c *config) ProductPrivateSepolicyDirs() []string {
1398 return c.productVariables.ProductPrivateSepolicyDirs
1399}
1400
Colin Cross50ddcc42019-05-16 12:28:22 -07001401func (c *config) MissingUsesLibraries() []string {
1402 return c.productVariables.MissingUsesLibraries
1403}
1404
Inseob Kim5eb7ee92022-04-27 10:30:34 +09001405func (c *config) TargetMultitreeUpdateMeta() bool {
1406 return c.productVariables.MultitreeUpdateMeta
1407}
1408
Inseob Kim1f086e22019-05-09 13:29:15 +09001409func (c *deviceConfig) DeviceArch() string {
1410 return String(c.config.productVariables.DeviceArch)
1411}
1412
1413func (c *deviceConfig) DeviceArchVariant() string {
1414 return String(c.config.productVariables.DeviceArchVariant)
1415}
1416
1417func (c *deviceConfig) DeviceSecondaryArch() string {
1418 return String(c.config.productVariables.DeviceSecondaryArch)
1419}
1420
1421func (c *deviceConfig) DeviceSecondaryArchVariant() string {
1422 return String(c.config.productVariables.DeviceSecondaryArchVariant)
1423}
Yifan Hong82db7352020-01-21 16:12:26 -08001424
1425func (c *deviceConfig) BoardUsesRecoveryAsBoot() bool {
1426 return Bool(c.config.productVariables.BoardUsesRecoveryAsBoot)
1427}
Yifan Hong97365ee2020-07-29 09:51:57 -07001428
1429func (c *deviceConfig) BoardKernelBinaries() []string {
1430 return c.config.productVariables.BoardKernelBinaries
1431}
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001432
Yifan Hong42bef8d2020-08-05 14:36:09 -07001433func (c *deviceConfig) BoardKernelModuleInterfaceVersions() []string {
1434 return c.config.productVariables.BoardKernelModuleInterfaceVersions
1435}
1436
Yifan Hongdd8dacc2020-10-21 15:40:17 -07001437func (c *deviceConfig) BoardMoveRecoveryResourcesToVendorBoot() bool {
1438 return Bool(c.config.productVariables.BoardMoveRecoveryResourcesToVendorBoot)
1439}
1440
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001441func (c *deviceConfig) PlatformSepolicyVersion() string {
1442 return String(c.config.productVariables.PlatformSepolicyVersion)
1443}
1444
Inseob Kima10ef272021-09-15 03:04:53 +00001445func (c *deviceConfig) TotSepolicyVersion() string {
1446 return String(c.config.productVariables.TotSepolicyVersion)
1447}
1448
Inseob Kim843f6642022-01-07 09:11:23 +09001449func (c *deviceConfig) PlatformSepolicyCompatVersions() []string {
1450 return c.config.productVariables.PlatformSepolicyCompatVersions
1451}
1452
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001453func (c *deviceConfig) BoardSepolicyVers() string {
Inseob Kim0c4eec82021-03-22 22:33:40 +09001454 if ver := String(c.config.productVariables.BoardSepolicyVers); ver != "" {
1455 return ver
1456 }
1457 return c.PlatformSepolicyVersion()
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001458}
1459
Inseob Kim14178802021-12-08 22:53:31 +09001460func (c *deviceConfig) BoardPlatVendorPolicy() []string {
1461 return c.config.productVariables.BoardPlatVendorPolicy
1462}
1463
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001464func (c *deviceConfig) BoardReqdMaskPolicy() []string {
1465 return c.config.productVariables.BoardReqdMaskPolicy
1466}
1467
Inseob Kim0f46e7c2021-12-15 22:48:14 +09001468func (c *deviceConfig) BoardSystemExtPublicPrebuiltDirs() []string {
1469 return c.config.productVariables.BoardSystemExtPublicPrebuiltDirs
1470}
1471
1472func (c *deviceConfig) BoardSystemExtPrivatePrebuiltDirs() []string {
1473 return c.config.productVariables.BoardSystemExtPrivatePrebuiltDirs
1474}
1475
1476func (c *deviceConfig) BoardProductPublicPrebuiltDirs() []string {
1477 return c.config.productVariables.BoardProductPublicPrebuiltDirs
1478}
1479
1480func (c *deviceConfig) BoardProductPrivatePrebuiltDirs() []string {
1481 return c.config.productVariables.BoardProductPrivatePrebuiltDirs
1482}
1483
Inseob Kim1a0afcc2022-02-14 23:10:51 +09001484func (c *deviceConfig) SystemExtSepolicyPrebuiltApiDir() string {
1485 return String(c.config.productVariables.SystemExtSepolicyPrebuiltApiDir)
1486}
1487
1488func (c *deviceConfig) ProductSepolicyPrebuiltApiDir() string {
1489 return String(c.config.productVariables.ProductSepolicyPrebuiltApiDir)
1490}
1491
1492func (c *deviceConfig) IsPartnerTrebleSepolicyTestEnabled() bool {
1493 return c.SystemExtSepolicyPrebuiltApiDir() != "" || c.ProductSepolicyPrebuiltApiDir() != ""
1494}
1495
Inseob Kim7cf14652021-01-06 23:06:52 +09001496func (c *deviceConfig) DirectedVendorSnapshot() bool {
1497 return c.config.productVariables.DirectedVendorSnapshot
1498}
1499
1500func (c *deviceConfig) VendorSnapshotModules() map[string]bool {
1501 return c.config.productVariables.VendorSnapshotModules
1502}
1503
Jose Galmes4c6895e2021-02-09 07:44:30 -08001504func (c *deviceConfig) DirectedRecoverySnapshot() bool {
1505 return c.config.productVariables.DirectedRecoverySnapshot
1506}
1507
1508func (c *deviceConfig) RecoverySnapshotModules() map[string]bool {
1509 return c.config.productVariables.RecoverySnapshotModules
1510}
1511
Justin DeMartino383bfb32021-02-24 10:49:43 -08001512func createDirsMap(previous map[string]bool, dirs []string) (map[string]bool, error) {
1513 var ret = make(map[string]bool)
1514 for _, dir := range dirs {
1515 clean := filepath.Clean(dir)
1516 if previous[clean] || ret[clean] {
1517 return nil, fmt.Errorf("Duplicate entry %s", dir)
1518 }
1519 ret[clean] = true
1520 }
1521 return ret, nil
1522}
1523
1524func (c *deviceConfig) createDirsMapOnce(onceKey OnceKey, previous map[string]bool, dirs []string) map[string]bool {
1525 dirMap := c.Once(onceKey, func() interface{} {
1526 ret, err := createDirsMap(previous, dirs)
1527 if err != nil {
1528 panic(fmt.Errorf("%s: %w", onceKey.key, err))
1529 }
1530 return ret
1531 })
1532 if dirMap == nil {
1533 return nil
1534 }
1535 return dirMap.(map[string]bool)
1536}
1537
1538var vendorSnapshotDirsExcludedKey = NewOnceKey("VendorSnapshotDirsExcludedMap")
1539
1540func (c *deviceConfig) VendorSnapshotDirsExcludedMap() map[string]bool {
1541 return c.createDirsMapOnce(vendorSnapshotDirsExcludedKey, nil,
1542 c.config.productVariables.VendorSnapshotDirsExcluded)
1543}
1544
1545var vendorSnapshotDirsIncludedKey = NewOnceKey("VendorSnapshotDirsIncludedMap")
1546
1547func (c *deviceConfig) VendorSnapshotDirsIncludedMap() map[string]bool {
1548 excludedMap := c.VendorSnapshotDirsExcludedMap()
1549 return c.createDirsMapOnce(vendorSnapshotDirsIncludedKey, excludedMap,
1550 c.config.productVariables.VendorSnapshotDirsIncluded)
1551}
1552
1553var recoverySnapshotDirsExcludedKey = NewOnceKey("RecoverySnapshotDirsExcludedMap")
1554
1555func (c *deviceConfig) RecoverySnapshotDirsExcludedMap() map[string]bool {
1556 return c.createDirsMapOnce(recoverySnapshotDirsExcludedKey, nil,
1557 c.config.productVariables.RecoverySnapshotDirsExcluded)
1558}
1559
1560var recoverySnapshotDirsIncludedKey = NewOnceKey("RecoverySnapshotDirsIncludedMap")
1561
1562func (c *deviceConfig) RecoverySnapshotDirsIncludedMap() map[string]bool {
1563 excludedMap := c.RecoverySnapshotDirsExcludedMap()
1564 return c.createDirsMapOnce(recoverySnapshotDirsIncludedKey, excludedMap,
1565 c.config.productVariables.RecoverySnapshotDirsIncluded)
1566}
1567
Rob Seymour925aa092021-08-10 20:42:03 +00001568func (c *deviceConfig) HostFakeSnapshotEnabled() bool {
1569 return c.config.productVariables.HostFakeSnapshotEnabled
1570}
1571
Inseob Kim60c32f02020-12-21 22:53:05 +09001572func (c *deviceConfig) ShippingApiLevel() ApiLevel {
1573 if c.config.productVariables.ShippingApiLevel == nil {
1574 return NoneApiLevel
1575 }
1576 apiLevel, _ := strconv.Atoi(*c.config.productVariables.ShippingApiLevel)
1577 return uncheckedFinalApiLevel(apiLevel)
1578}
1579
Inseob Kim67e5add192021-03-17 18:05:33 +09001580func (c *deviceConfig) BuildBrokenEnforceSyspropOwner() bool {
1581 return c.config.productVariables.BuildBrokenEnforceSyspropOwner
1582}
1583
1584func (c *deviceConfig) BuildBrokenTrebleSyspropNeverallow() bool {
1585 return c.config.productVariables.BuildBrokenTrebleSyspropNeverallow
1586}
1587
Hridya Valsaraju5a5c7d52021-04-02 16:45:24 -07001588func (c *deviceConfig) BuildDebugfsRestrictionsEnabled() bool {
1589 return c.config.productVariables.BuildDebugfsRestrictionsEnabled
1590}
1591
Inseob Kim0cac7b42021-02-03 18:16:46 +09001592func (c *deviceConfig) BuildBrokenVendorPropertyNamespace() bool {
1593 return c.config.productVariables.BuildBrokenVendorPropertyNamespace
1594}
1595
Liz Kammer619be462022-01-28 15:13:39 -05001596func (c *deviceConfig) BuildBrokenInputDir(name string) bool {
1597 return InList(name, c.config.productVariables.BuildBrokenInputDirModules)
1598}
1599
Vinh Tran140d5882022-06-10 14:23:27 -04001600func (c *deviceConfig) BuildBrokenDepfile() bool {
1601 return Bool(c.config.productVariables.BuildBrokenDepfile)
1602}
1603
Inseob Kim67e5add192021-03-17 18:05:33 +09001604func (c *deviceConfig) RequiresInsecureExecmemForSwiftshader() bool {
1605 return c.config.productVariables.RequiresInsecureExecmemForSwiftshader
1606}
1607
1608func (c *config) SelinuxIgnoreNeverallows() bool {
1609 return c.productVariables.SelinuxIgnoreNeverallows
1610}
1611
1612func (c *deviceConfig) SepolicySplit() bool {
1613 return c.config.productVariables.SepolicySplit
1614}
1615
Inseob Kima10ef272021-09-15 03:04:53 +00001616func (c *deviceConfig) SepolicyFreezeTestExtraDirs() []string {
1617 return c.config.productVariables.SepolicyFreezeTestExtraDirs
1618}
1619
1620func (c *deviceConfig) SepolicyFreezeTestExtraPrebuiltDirs() []string {
1621 return c.config.productVariables.SepolicyFreezeTestExtraPrebuiltDirs
1622}
1623
Jiyong Parkd163d4d2021-10-12 16:47:43 +09001624func (c *deviceConfig) GenerateAidlNdkPlatformBackend() bool {
1625 return c.config.productVariables.GenerateAidlNdkPlatformBackend
1626}
1627
Christopher Ferris98f10222022-07-13 23:16:52 -07001628func (c *config) IgnorePrefer32OnDevice() bool {
1629 return c.productVariables.IgnorePrefer32OnDevice
1630}
1631
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001632func (c *config) BootJars() []string {
1633 return c.Once(earlyBootJarsKey, func() interface{} {
Paul Duffin69d1fb12020-10-23 21:14:20 +01001634 list := c.productVariables.BootJars.CopyOfJars()
satayevd604b212021-07-21 14:23:52 +01001635 return append(list, c.productVariables.ApexBootJars.CopyOfJars()...)
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001636 }).([]string)
1637}
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001638
satayevd604b212021-07-21 14:23:52 +01001639func (c *config) NonApexBootJars() ConfiguredJarList {
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001640 return c.productVariables.BootJars
1641}
1642
satayevd604b212021-07-21 14:23:52 +01001643func (c *config) ApexBootJars() ConfiguredJarList {
1644 return c.productVariables.ApexBootJars
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001645}
Colin Cross77cdcfd2021-03-12 11:28:25 -08001646
1647func (c *config) RBEWrapper() string {
1648 return c.GetenvWithDefault("RBE_WRAPPER", remoteexec.DefaultWrapperPath)
1649}
Colin Cross9b698b62021-12-22 09:55:32 -08001650
1651// UseHostMusl returns true if the host target has been configured to build against musl libc.
1652func (c *config) UseHostMusl() bool {
1653 return Bool(c.productVariables.HostMusl)
1654}
MarkDacekff851b82022-04-21 18:33:17 +00001655
Chris Parsonsf874e462022-05-10 13:50:12 -04001656func (c *config) LogMixedBuild(ctx BaseModuleContext, useBazel bool) {
MarkDacekff851b82022-04-21 18:33:17 +00001657 moduleName := ctx.Module().Name()
1658 c.mixedBuildsLock.Lock()
1659 defer c.mixedBuildsLock.Unlock()
1660 if useBazel {
1661 c.mixedBuildEnabledModules[moduleName] = struct{}{}
1662 } else {
1663 c.mixedBuildDisabledModules[moduleName] = struct{}{}
1664 }
1665}