blob: 687cf9b8c96f1b797fdd61327e9c61449f188b1c [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
17import (
Colin Cross3f40fa42015-01-30 17:27:36 -080018 "encoding/json"
19 "fmt"
Colin Crossd8f20142016-11-03 09:43:26 -070020 "io/ioutil"
Colin Cross3f40fa42015-01-30 17:27:36 -080021 "os"
Colin Cross35cec122015-04-02 14:37:16 -070022 "path/filepath"
Colin Cross3f40fa42015-01-30 17:27:36 -080023 "runtime"
Dan Willemsen5951c8a2016-07-19 19:08:14 -070024 "strconv"
Dan Willemsen34cc69e2015-09-23 15:26:20 -070025 "strings"
Colin Crossc1e86a32015-04-15 12:33:28 -070026 "sync"
Colin Cross6ff51382015-12-17 16:39:19 -080027
Colin Crosse87040b2017-12-11 15:52:26 -080028 "github.com/google/blueprint/bootstrap"
Colin Cross6ff51382015-12-17 16:39:19 -080029 "github.com/google/blueprint/proptools"
Colin Cross3f40fa42015-01-30 17:27:36 -080030)
31
Colin Cross6ff51382015-12-17 16:39:19 -080032var Bool = proptools.Bool
Jack He8cc71432016-12-08 15:45:07 -080033var String = proptools.String
Jiyong Park1a5d7b12018-01-15 15:05:10 +090034var FutureApiLevel = 10000
Colin Cross6ff51382015-12-17 16:39:19 -080035
Colin Cross3f40fa42015-01-30 17:27:36 -080036// The configuration file name
Dan Willemsen87b17d12015-07-14 00:39:06 -070037const configFileName = "soong.config"
38const productVariablesFileName = "soong.variables"
Colin Cross3f40fa42015-01-30 17:27:36 -080039
40// A FileConfigurableOptions contains options which can be configured by the
41// config file. These will be included in the config struct.
42type FileConfigurableOptions struct {
Dan Willemsen322acaf2016-01-12 23:07:05 -080043 Mega_device *bool `json:",omitempty"`
Dan Willemsen01a405a2016-06-13 17:19:03 -070044 Host_bionic *bool `json:",omitempty"`
Colin Cross3f40fa42015-01-30 17:27:36 -080045}
46
Colin Cross27385972015-09-18 10:57:10 -070047func (f *FileConfigurableOptions) SetDefaultConfig() {
48 *f = FileConfigurableOptions{}
Colin Cross3f40fa42015-01-30 17:27:36 -080049}
50
Colin Cross9272ade2016-08-17 15:24:12 -070051// A Config object represents the entire build configuration for Android.
Colin Crossc3c0a492015-04-10 15:43:55 -070052type Config struct {
53 *config
54}
55
Jeff Gastonefc1b412017-03-29 17:29:06 -070056func (c Config) BuildDir() string {
57 return c.buildDir
58}
59
Colin Cross9272ade2016-08-17 15:24:12 -070060// A DeviceConfig object represents the configuration for a particular device being built. For
61// now there will only be one of these, but in the future there may be multiple devices being
62// built
63type DeviceConfig struct {
64 *deviceConfig
65}
66
Dan Willemsen0fe78662018-03-26 12:41:18 -070067type VendorConfig interface {
68 // Bool interprets the variable named `name` as a boolean, returning true if, after
69 // lowercasing, it matches one of "1", "y", "yes", "on", or "true". Unset, or any other
70 // value will return false.
71 Bool(name string) bool
72
73 // String returns the string value of `name`. If the variable was not set, it will
74 // return the empty string.
75 String(name string) string
76
77 // IsSet returns whether the variable `name` was set by Make.
78 IsSet(name string) bool
79}
80
Colin Cross1332b002015-04-07 17:11:30 -070081type config struct {
Colin Cross3f40fa42015-01-30 17:27:36 -080082 FileConfigurableOptions
Dan Willemsen45133ac2018-03-09 21:22:06 -080083 productVariables productVariables
Colin Cross3f40fa42015-01-30 17:27:36 -080084
Dan Willemsen674dc7f2018-03-12 18:06:05 -070085 // Only available on configs created by TestConfig
86 TestProductVariables *productVariables
87
Colin Crosse87040b2017-12-11 15:52:26 -080088 PrimaryBuilder string
Dan Willemsen87b17d12015-07-14 00:39:06 -070089 ConfigFileName string
90 ProductVariablesFileName string
91
Colin Cross0f7d2ef2019-10-16 11:03:10 -070092 Targets map[OsType][]Target
93 BuildOSTarget Target // the Target for tools run on the build machine
94 BuildOSCommonTarget Target // the Target for common (java) tools run on the build machine
95 AndroidCommonTarget Target // the Target for common modules for the Android device
Dan Willemsen218f6562015-07-08 18:13:11 -070096
Colin Cross3b19f5d2019-09-17 14:45:31 -070097 // multilibConflicts for an ArchType is true if there is earlier configured device architecture with the same
98 // multilib value.
99 multilibConflicts map[ArchType]bool
100
Colin Cross9272ade2016-08-17 15:24:12 -0700101 deviceConfig *deviceConfig
102
Dan Willemsen87b17d12015-07-14 00:39:06 -0700103 srcDir string // the path of the root source directory
104 buildDir string // the path of the build output directory
Colin Crossc1e86a32015-04-15 12:33:28 -0700105
Colin Cross6ccbc912017-10-10 23:07:38 -0700106 env map[string]string
Dan Willemsene7680ba2015-09-11 17:06:19 -0700107 envLock sync.Mutex
108 envDeps map[string]string
109 envFrozen bool
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800110
111 inMake bool
Colin Cross1e7d3702016-08-24 15:25:47 -0700112
Colin Cross32616ed2017-09-05 21:56:44 -0700113 captureBuild bool // true for tests, saves build parameters for each module
114 ignoreEnvironment bool // true for tests, returns empty from all Getenv calls
Colin Crosscec81712017-07-13 14:43:27 -0700115
Colin Crosse87040b2017-12-11 15:52:26 -0800116 stopBefore bootstrap.StopBefore
117
Colin Cross9272ade2016-08-17 15:24:12 -0700118 OncePer
119}
120
121type deviceConfig struct {
Dan Willemsen00269f22017-07-06 16:59:48 -0700122 config *config
Colin Cross9272ade2016-08-17 15:24:12 -0700123 OncePer
Colin Cross3f40fa42015-01-30 17:27:36 -0800124}
125
Dan Willemsen0fe78662018-03-26 12:41:18 -0700126type vendorConfig map[string]string
127
Colin Cross485e5722015-08-27 13:28:01 -0700128type jsonConfigurable interface {
Colin Cross27385972015-09-18 10:57:10 -0700129 SetDefaultConfig()
Colin Cross485e5722015-08-27 13:28:01 -0700130}
Colin Cross3f40fa42015-01-30 17:27:36 -0800131
Colin Cross485e5722015-08-27 13:28:01 -0700132func loadConfig(config *config) error {
Dan Willemsen87b17d12015-07-14 00:39:06 -0700133 err := loadFromConfigFile(&config.FileConfigurableOptions, config.ConfigFileName)
Colin Cross485e5722015-08-27 13:28:01 -0700134 if err != nil {
135 return err
136 }
137
Dan Willemsen45133ac2018-03-09 21:22:06 -0800138 return loadFromConfigFile(&config.productVariables, config.ProductVariablesFileName)
Colin Cross485e5722015-08-27 13:28:01 -0700139}
140
141// loads configuration options from a JSON file in the cwd.
142func loadFromConfigFile(configurable jsonConfigurable, filename string) error {
Colin Cross3f40fa42015-01-30 17:27:36 -0800143 // Try to open the file
Colin Cross485e5722015-08-27 13:28:01 -0700144 configFileReader, err := os.Open(filename)
Colin Cross3f40fa42015-01-30 17:27:36 -0800145 defer configFileReader.Close()
146 if os.IsNotExist(err) {
147 // Need to create a file, so that blueprint & ninja don't get in
148 // a dependency tracking loop.
149 // Make a file-configurable-options with defaults, write it out using
150 // a json writer.
Colin Cross27385972015-09-18 10:57:10 -0700151 configurable.SetDefaultConfig()
152 err = saveToConfigFile(configurable, filename)
Colin Cross3f40fa42015-01-30 17:27:36 -0800153 if err != nil {
154 return err
155 }
Colin Cross15cd21a2018-02-27 11:26:02 -0800156 } else if err != nil {
157 return fmt.Errorf("config file: could not open %s: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800158 } else {
159 // Make a decoder for it
160 jsonDecoder := json.NewDecoder(configFileReader)
Colin Cross485e5722015-08-27 13:28:01 -0700161 err = jsonDecoder.Decode(configurable)
Colin Cross3f40fa42015-01-30 17:27:36 -0800162 if err != nil {
Colin Cross15cd21a2018-02-27 11:26:02 -0800163 return fmt.Errorf("config file: %s did not parse correctly: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800164 }
165 }
166
Colin Cross3f40fa42015-01-30 17:27:36 -0800167 // No error
168 return nil
169}
170
Colin Crossd8f20142016-11-03 09:43:26 -0700171// atomically writes the config file in case two copies of soong_build are running simultaneously
172// (for example, docs generation and ninja manifest generation)
Colin Cross485e5722015-08-27 13:28:01 -0700173func saveToConfigFile(config jsonConfigurable, filename string) error {
Colin Cross3f40fa42015-01-30 17:27:36 -0800174 data, err := json.MarshalIndent(&config, "", " ")
175 if err != nil {
176 return fmt.Errorf("cannot marshal config data: %s", err.Error())
177 }
178
Colin Crossd8f20142016-11-03 09:43:26 -0700179 f, err := ioutil.TempFile(filepath.Dir(filename), "config")
Colin Cross3f40fa42015-01-30 17:27:36 -0800180 if err != nil {
Colin Cross485e5722015-08-27 13:28:01 -0700181 return fmt.Errorf("cannot create empty config file %s: %s\n", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800182 }
Colin Crossd8f20142016-11-03 09:43:26 -0700183 defer os.Remove(f.Name())
184 defer f.Close()
Colin Cross3f40fa42015-01-30 17:27:36 -0800185
Colin Crossd8f20142016-11-03 09:43:26 -0700186 _, err = f.Write(data)
Colin Cross3f40fa42015-01-30 17:27:36 -0800187 if err != nil {
Colin Cross485e5722015-08-27 13:28:01 -0700188 return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error())
189 }
190
Colin Crossd8f20142016-11-03 09:43:26 -0700191 _, err = f.WriteString("\n")
Colin Cross485e5722015-08-27 13:28:01 -0700192 if err != nil {
193 return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800194 }
195
Colin Crossd8f20142016-11-03 09:43:26 -0700196 f.Close()
197 os.Rename(f.Name(), filename)
198
Colin Cross3f40fa42015-01-30 17:27:36 -0800199 return nil
200}
201
Colin Crossce75d2c2016-10-06 16:12:58 -0700202// TestConfig returns a Config object suitable for using for tests
Colin Cross6ccbc912017-10-10 23:07:38 -0700203func TestConfig(buildDir string, env map[string]string) Config {
Colin Cross9c6241f2019-04-22 15:51:26 -0700204 envCopy := make(map[string]string)
205 for k, v := range env {
206 envCopy[k] = v
207 }
208
209 // Copy the real PATH value to the test environment, it's needed by HostSystemTool() used in x86_darwin_host.go
210 envCopy["PATH"] = originalEnv["PATH"]
211
Dan Willemsen00269f22017-07-06 16:59:48 -0700212 config := &config{
Dan Willemsen45133ac2018-03-09 21:22:06 -0800213 productVariables: productVariables{
Colin Crossff0daf42019-04-02 16:10:56 -0700214 DeviceName: stringPtr("test_device"),
Colin Cross74362a42019-10-28 08:05:02 -0700215 Platform_sdk_version: intPtr(30),
Colin Crossff0daf42019-04-02 16:10:56 -0700216 DeviceSystemSdkVersions: []string{"14", "15"},
Colin Cross74362a42019-10-28 08:05:02 -0700217 Platform_systemsdk_versions: []string{"29", "30"},
Colin Crossff0daf42019-04-02 16:10:56 -0700218 AAPTConfig: []string{"normal", "large", "xlarge", "hdpi", "xhdpi", "xxhdpi"},
219 AAPTPreferredConfig: stringPtr("xhdpi"),
220 AAPTCharacteristics: stringPtr("nosdcard"),
221 AAPTPrebuiltDPI: []string{"xhdpi", "xxhdpi"},
Colin Cross53a87f52019-06-25 13:35:30 -0700222 UncompressPrivAppDex: boolPtr(true),
Dan Willemsen00269f22017-07-06 16:59:48 -0700223 },
224
Colin Cross6ccbc912017-10-10 23:07:38 -0700225 buildDir: buildDir,
226 captureBuild: true,
Colin Cross9c6241f2019-04-22 15:51:26 -0700227 env: envCopy,
Dan Willemsen00269f22017-07-06 16:59:48 -0700228 }
229 config.deviceConfig = &deviceConfig{
230 config: config,
231 }
Dan Willemsen45133ac2018-03-09 21:22:06 -0800232 config.TestProductVariables = &config.productVariables
Dan Willemsen00269f22017-07-06 16:59:48 -0700233
Colin Cross1369cdb2017-09-29 17:58:17 -0700234 if err := config.fromEnv(); err != nil {
235 panic(err)
236 }
237
Dan Willemsen00269f22017-07-06 16:59:48 -0700238 return Config{config}
Colin Crossce75d2c2016-10-06 16:12:58 -0700239}
240
dimitry1f33e402019-03-26 12:39:31 +0100241func TestArchConfigNativeBridge(buildDir string, env map[string]string) Config {
Colin Cross0d99f7c2019-05-14 16:01:24 -0700242 testConfig := TestArchConfig(buildDir, env)
dimitry1f33e402019-03-26 12:39:31 +0100243 config := testConfig.config
244
Colin Cross0d99f7c2019-05-14 16:01:24 -0700245 config.Targets[Android] = []Target{
Colin Cross3b19f5d2019-09-17 14:45:31 -0700246 {Android, Arch{ArchType: X86_64, ArchVariant: "silvermont", Abi: []string{"arm64-v8a"}}, NativeBridgeDisabled, "", ""},
247 {Android, Arch{ArchType: X86, ArchVariant: "silvermont", Abi: []string{"armeabi-v7a"}}, NativeBridgeDisabled, "", ""},
248 {Android, Arch{ArchType: Arm64, ArchVariant: "armv8-a", Abi: []string{"arm64-v8a"}}, NativeBridgeEnabled, "x86_64", "arm64"},
249 {Android, Arch{ArchType: Arm, ArchVariant: "armv7-a-neon", Abi: []string{"armeabi-v7a"}}, NativeBridgeEnabled, "x86", "arm"},
dimitry1f33e402019-03-26 12:39:31 +0100250 }
251
252 return testConfig
253}
254
Doug Hornc32c6b02019-01-17 14:44:05 -0800255func TestArchConfigFuchsia(buildDir string, env map[string]string) Config {
256 testConfig := TestConfig(buildDir, env)
257 config := testConfig.config
258
259 config.Targets = map[OsType][]Target{
260 Fuchsia: []Target{
Colin Cross3b19f5d2019-09-17 14:45:31 -0700261 {Fuchsia, Arch{ArchType: Arm64, ArchVariant: ""}, NativeBridgeDisabled, "", ""},
Doug Hornc32c6b02019-01-17 14:44:05 -0800262 },
263 BuildOs: []Target{
dimitry8d6dde82019-07-11 10:23:53 +0200264 {BuildOs, Arch{ArchType: X86_64}, NativeBridgeDisabled, "", ""},
Doug Hornc32c6b02019-01-17 14:44:05 -0800265 },
266 }
267
268 return testConfig
269}
270
Colin Crossae4c6182017-09-15 17:33:55 -0700271// TestConfig returns a Config object suitable for using for tests that need to run the arch mutator
Colin Cross6ccbc912017-10-10 23:07:38 -0700272func TestArchConfig(buildDir string, env map[string]string) Config {
273 testConfig := TestConfig(buildDir, env)
Colin Crossae4c6182017-09-15 17:33:55 -0700274 config := testConfig.config
275
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700276 config.Targets = map[OsType][]Target{
277 Android: []Target{
Colin Cross3b19f5d2019-09-17 14:45:31 -0700278 {Android, Arch{ArchType: Arm64, ArchVariant: "armv8-a", Abi: []string{"arm64-v8a"}}, NativeBridgeDisabled, "", ""},
279 {Android, Arch{ArchType: Arm, ArchVariant: "armv7-a-neon", Abi: []string{"armeabi-v7a"}}, NativeBridgeDisabled, "", ""},
Colin Crossae4c6182017-09-15 17:33:55 -0700280 },
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700281 BuildOs: []Target{
dimitry8d6dde82019-07-11 10:23:53 +0200282 {BuildOs, Arch{ArchType: X86_64}, NativeBridgeDisabled, "", ""},
283 {BuildOs, Arch{ArchType: X86}, NativeBridgeDisabled, "", ""},
Colin Crossae4c6182017-09-15 17:33:55 -0700284 },
285 }
286
Colin Cross0d99f7c2019-05-14 16:01:24 -0700287 if runtime.GOOS == "darwin" {
288 config.Targets[BuildOs] = config.Targets[BuildOs][:1]
289 }
290
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700291 config.BuildOSTarget = config.Targets[BuildOs][0]
292 config.BuildOSCommonTarget = getCommonTargets(config.Targets[BuildOs])[0]
293 config.AndroidCommonTarget = getCommonTargets(config.Targets[Android])[0]
Inseob Kim1f086e22019-05-09 13:29:15 +0900294 config.TestProductVariables.DeviceArch = proptools.StringPtr("arm64")
295 config.TestProductVariables.DeviceArchVariant = proptools.StringPtr("armv8-a")
296 config.TestProductVariables.DeviceSecondaryArch = proptools.StringPtr("arm")
297 config.TestProductVariables.DeviceSecondaryArchVariant = proptools.StringPtr("armv7-a-neon")
Colin Cross2a076922018-10-04 23:28:25 -0700298
Colin Crossae4c6182017-09-15 17:33:55 -0700299 return testConfig
300}
301
Colin Cross3f40fa42015-01-30 17:27:36 -0800302// New creates a new Config object. The srcDir argument specifies the path to
303// the root source directory. It also loads the config file, if found.
Dan Willemsen87b17d12015-07-14 00:39:06 -0700304func NewConfig(srcDir, buildDir string) (Config, error) {
Colin Cross3f40fa42015-01-30 17:27:36 -0800305 // Make a config with default options
Colin Cross9272ade2016-08-17 15:24:12 -0700306 config := &config{
307 ConfigFileName: filepath.Join(buildDir, configFileName),
308 ProductVariablesFileName: filepath.Join(buildDir, productVariablesFileName),
Dan Willemsen87b17d12015-07-14 00:39:06 -0700309
Colin Cross6ccbc912017-10-10 23:07:38 -0700310 env: originalEnv,
311
Colin Cross3b19f5d2019-09-17 14:45:31 -0700312 srcDir: srcDir,
313 buildDir: buildDir,
314 multilibConflicts: make(map[ArchType]bool),
Colin Cross68f55102015-03-25 14:43:57 -0700315 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800316
Dan Willemsen00269f22017-07-06 16:59:48 -0700317 config.deviceConfig = &deviceConfig{
Colin Cross9272ade2016-08-17 15:24:12 -0700318 config: config,
319 }
320
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700321 // Sanity check the build and source directories. This won't catch strange
322 // configurations with symlinks, but at least checks the obvious cases.
323 absBuildDir, err := filepath.Abs(buildDir)
324 if err != nil {
325 return Config{}, err
326 }
327
328 absSrcDir, err := filepath.Abs(srcDir)
329 if err != nil {
330 return Config{}, err
331 }
332
333 if strings.HasPrefix(absSrcDir, absBuildDir) {
334 return Config{}, fmt.Errorf("Build dir must not contain source directory")
335 }
336
Colin Cross3f40fa42015-01-30 17:27:36 -0800337 // Load any configurable options from the configuration file
Colin Cross9272ade2016-08-17 15:24:12 -0700338 err = loadConfig(config)
Colin Cross3f40fa42015-01-30 17:27:36 -0800339 if err != nil {
Colin Crossc3c0a492015-04-10 15:43:55 -0700340 return Config{}, err
Colin Cross3f40fa42015-01-30 17:27:36 -0800341 }
342
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800343 inMakeFile := filepath.Join(buildDir, ".soong.in_make")
344 if _, err := os.Stat(inMakeFile); err == nil {
345 config.inMake = true
346 }
347
Colin Crossa1ad8d12016-06-01 17:09:44 -0700348 targets, err := decodeTargetProductVariables(config)
Dan Willemsen218f6562015-07-08 18:13:11 -0700349 if err != nil {
350 return Config{}, err
351 }
352
Dan Albert4098deb2016-10-19 14:04:41 -0700353 var archConfig []archConfig
Dan Willemsen322acaf2016-01-12 23:07:05 -0800354 if Bool(config.Mega_device) {
Dan Albert4098deb2016-10-19 14:04:41 -0700355 archConfig = getMegaDeviceConfig()
Colin Cross395f2cf2018-10-24 16:10:32 -0700356 } else if config.NdkAbis() {
Dan Albert4098deb2016-10-19 14:04:41 -0700357 archConfig = getNdkAbisConfig()
358 }
359
360 if archConfig != nil {
Dan Willemsen01a3c252019-01-11 19:02:16 -0800361 androidTargets, err := decodeArchSettings(Android, archConfig)
Dan Willemsen322acaf2016-01-12 23:07:05 -0800362 if err != nil {
363 return Config{}, err
364 }
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700365 targets[Android] = androidTargets
Dan Willemsen322acaf2016-01-12 23:07:05 -0800366 }
367
Colin Cross3b19f5d2019-09-17 14:45:31 -0700368 multilib := make(map[string]bool)
369 for _, target := range targets[Android] {
370 if seen := multilib[target.Arch.ArchType.Multilib]; seen {
371 config.multilibConflicts[target.Arch.ArchType] = true
372 }
373 multilib[target.Arch.ArchType.Multilib] = true
374 }
375
Colin Crossa1ad8d12016-06-01 17:09:44 -0700376 config.Targets = targets
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700377 config.BuildOSTarget = config.Targets[BuildOs][0]
378 config.BuildOSCommonTarget = getCommonTargets(config.Targets[BuildOs])[0]
379 if len(config.Targets[Android]) > 0 {
380 config.AndroidCommonTarget = getCommonTargets(config.Targets[Android])[0]
381 }
Dan Willemsen218f6562015-07-08 18:13:11 -0700382
Colin Cross1369cdb2017-09-29 17:58:17 -0700383 if err := config.fromEnv(); err != nil {
384 return Config{}, err
385 }
386
Colin Cross9272ade2016-08-17 15:24:12 -0700387 return Config{config}, nil
Colin Cross3f40fa42015-01-30 17:27:36 -0800388}
389
Colin Cross1369cdb2017-09-29 17:58:17 -0700390func (c *config) fromEnv() error {
Pete Gillin0c2143e2019-05-02 15:32:11 +0100391 switch c.Getenv("EXPERIMENTAL_JAVA_LANGUAGE_LEVEL_9") {
Pete Gillin1b3370f2019-10-01 13:57:31 +0100392 case "", "true":
Pete Gillina1c9e9d2019-10-17 14:52:07 +0100393 // Do nothing
Colin Cross1369cdb2017-09-29 17:58:17 -0700394 default:
Pete Gillina1c9e9d2019-10-17 14:52:07 +0100395 return fmt.Errorf("The environment variable EXPERIMENTAL_JAVA_LANGUAGE_LEVEL_9 is no longer supported. Java language level 9 is now the global default.")
Colin Cross1369cdb2017-09-29 17:58:17 -0700396 }
397
398 return nil
399}
400
Colin Crosse87040b2017-12-11 15:52:26 -0800401func (c *config) StopBefore() bootstrap.StopBefore {
402 return c.stopBefore
Dan Willemsen218f6562015-07-08 18:13:11 -0700403}
404
Colin Crosse87040b2017-12-11 15:52:26 -0800405func (c *config) SetStopBefore(stopBefore bootstrap.StopBefore) {
406 c.stopBefore = stopBefore
407}
408
409var _ bootstrap.ConfigStopBefore = (*config)(nil)
410
Dan Willemsenc2aa4a92016-05-26 15:13:03 -0700411func (c *config) BlueprintToolLocation() string {
412 return filepath.Join(c.buildDir, "host", c.PrebuiltOS(), "bin")
413}
414
Colin Crosse87040b2017-12-11 15:52:26 -0800415var _ bootstrap.ConfigBlueprintToolLocation = (*config)(nil)
416
Dan Willemsen60e62f02018-11-16 21:05:32 -0800417func (c *config) HostToolPath(ctx PathContext, tool string) Path {
418 return PathForOutput(ctx, "host", c.PrebuiltOS(), "bin", tool)
419}
420
Dan Willemsen66068722017-05-08 21:15:59 +0000421// HostSystemTool looks for non-hermetic tools from the system we're running on.
422// Generally shouldn't be used, but useful to find the XCode SDK, etc.
423func (c *config) HostSystemTool(name string) string {
424 for _, dir := range filepath.SplitList(c.Getenv("PATH")) {
425 path := filepath.Join(dir, name)
426 if s, err := os.Stat(path); err != nil {
427 continue
428 } else if m := s.Mode(); !s.IsDir() && m&0111 != 0 {
429 return path
430 }
431 }
432 return name
433}
434
Colin Cross3f40fa42015-01-30 17:27:36 -0800435// PrebuiltOS returns the name of the host OS used in prebuilts directories
Colin Cross1332b002015-04-07 17:11:30 -0700436func (c *config) PrebuiltOS() string {
Colin Cross3f40fa42015-01-30 17:27:36 -0800437 switch runtime.GOOS {
438 case "linux":
439 return "linux-x86"
440 case "darwin":
441 return "darwin-x86"
442 default:
443 panic("Unknown GOOS")
444 }
445}
446
447// GoRoot returns the path to the root directory of the Go toolchain.
Colin Cross1332b002015-04-07 17:11:30 -0700448func (c *config) GoRoot() string {
Colin Cross3f40fa42015-01-30 17:27:36 -0800449 return fmt.Sprintf("%s/prebuilts/go/%s", c.srcDir, c.PrebuiltOS())
450}
451
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700452func (c *config) PrebuiltBuildTool(ctx PathContext, tool string) Path {
453 return PathForSource(ctx, "prebuilts/build-tools", c.PrebuiltOS(), "bin", tool)
454}
455
Colin Cross1332b002015-04-07 17:11:30 -0700456func (c *config) CpPreserveSymlinksFlags() string {
Colin Cross485e5722015-08-27 13:28:01 -0700457 switch runtime.GOOS {
Colin Cross3f40fa42015-01-30 17:27:36 -0800458 case "darwin":
459 return "-R"
460 case "linux":
461 return "-d"
462 default:
463 return ""
464 }
465}
Colin Cross68f55102015-03-25 14:43:57 -0700466
Colin Cross1332b002015-04-07 17:11:30 -0700467func (c *config) Getenv(key string) string {
Colin Cross68f55102015-03-25 14:43:57 -0700468 var val string
469 var exists bool
Colin Crossc1e86a32015-04-15 12:33:28 -0700470 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800471 defer c.envLock.Unlock()
472 if c.envDeps == nil {
473 c.envDeps = make(map[string]string)
474 }
Colin Cross68f55102015-03-25 14:43:57 -0700475 if val, exists = c.envDeps[key]; !exists {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700476 if c.envFrozen {
477 panic("Cannot access new environment variables after envdeps are frozen")
478 }
Colin Cross6ccbc912017-10-10 23:07:38 -0700479 val, _ = c.env[key]
Colin Cross68f55102015-03-25 14:43:57 -0700480 c.envDeps[key] = val
481 }
482 return val
483}
484
Colin Cross99d7c232016-11-23 16:52:04 -0800485func (c *config) GetenvWithDefault(key string, defaultValue string) string {
486 ret := c.Getenv(key)
487 if ret == "" {
488 return defaultValue
489 }
490 return ret
491}
492
493func (c *config) IsEnvTrue(key string) bool {
494 value := c.Getenv(key)
495 return value == "1" || value == "y" || value == "yes" || value == "on" || value == "true"
496}
497
498func (c *config) IsEnvFalse(key string) bool {
499 value := c.Getenv(key)
500 return value == "0" || value == "n" || value == "no" || value == "off" || value == "false"
501}
502
Colin Cross1332b002015-04-07 17:11:30 -0700503func (c *config) EnvDeps() map[string]string {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700504 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800505 defer c.envLock.Unlock()
Dan Willemsene7680ba2015-09-11 17:06:19 -0700506 c.envFrozen = true
Colin Cross68f55102015-03-25 14:43:57 -0700507 return c.envDeps
508}
Colin Cross35cec122015-04-02 14:37:16 -0700509
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800510func (c *config) EmbeddedInMake() bool {
511 return c.inMake
512}
513
Nan Zhang581fd212018-01-10 16:06:12 -0800514func (c *config) BuildId() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800515 return String(c.productVariables.BuildId)
Nan Zhang581fd212018-01-10 16:06:12 -0800516}
517
518func (c *config) BuildNumberFromFile() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800519 return String(c.productVariables.BuildNumberFromFile)
Nan Zhang581fd212018-01-10 16:06:12 -0800520}
521
Colin Cross35cec122015-04-02 14:37:16 -0700522// DeviceName returns the name of the current device target
523// TODO: take an AndroidModuleContext to select the device name for multi-device builds
Colin Cross1332b002015-04-07 17:11:30 -0700524func (c *config) DeviceName() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800525 return *c.productVariables.DeviceName
Colin Cross35cec122015-04-02 14:37:16 -0700526}
527
Anton Hansson53c88442019-03-18 15:53:16 +0000528func (c *config) DeviceResourceOverlays() []string {
529 return c.productVariables.DeviceResourceOverlays
530}
531
532func (c *config) ProductResourceOverlays() []string {
533 return c.productVariables.ProductResourceOverlays
Colin Cross30e076a2015-04-13 13:58:27 -0700534}
535
Colin Crossbfd347d2018-05-09 11:11:35 -0700536func (c *config) PlatformVersionName() string {
537 return String(c.productVariables.Platform_version_name)
538}
539
Dan Albert073379e2016-11-10 10:46:36 -0800540func (c *config) PlatformSdkVersionInt() int {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800541 return *c.productVariables.Platform_sdk_version
Dan Albert073379e2016-11-10 10:46:36 -0800542}
543
Colin Cross30e076a2015-04-13 13:58:27 -0700544func (c *config) PlatformSdkVersion() string {
Dan Albert073379e2016-11-10 10:46:36 -0800545 return strconv.Itoa(c.PlatformSdkVersionInt())
Colin Cross30e076a2015-04-13 13:58:27 -0700546}
547
Colin Crossd09b0b62018-04-18 11:06:47 -0700548func (c *config) PlatformSdkCodename() string {
549 return String(c.productVariables.Platform_sdk_codename)
550}
551
Colin Cross092c9da2019-04-02 22:56:43 -0700552func (c *config) PlatformSecurityPatch() string {
553 return String(c.productVariables.Platform_security_patch)
554}
555
556func (c *config) PlatformPreviewSdkVersion() string {
557 return String(c.productVariables.Platform_preview_sdk_version)
558}
559
560func (c *config) PlatformMinSupportedTargetSdkVersion() string {
561 return String(c.productVariables.Platform_min_supported_target_sdk_version)
562}
563
564func (c *config) PlatformBaseOS() string {
565 return String(c.productVariables.Platform_base_os)
566}
567
Dan Albertf5415d72017-08-17 16:19:59 -0700568func (c *config) MinSupportedSdkVersion() int {
Dan Alberta3b83662018-11-15 11:28:28 -0800569 return 16
Dan Albertf5415d72017-08-17 16:19:59 -0700570}
571
Colin Cross595a4062017-08-31 12:30:37 -0700572func (c *config) DefaultAppTargetSdkInt() int {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800573 if Bool(c.productVariables.Platform_sdk_final) {
Colin Cross595a4062017-08-31 12:30:37 -0700574 return c.PlatformSdkVersionInt()
575 } else {
Jiyong Park1a5d7b12018-01-15 15:05:10 +0900576 return FutureApiLevel
Colin Cross595a4062017-08-31 12:30:37 -0700577 }
578}
579
Colin Crossd09b0b62018-04-18 11:06:47 -0700580func (c *config) DefaultAppTargetSdk() string {
581 if Bool(c.productVariables.Platform_sdk_final) {
582 return c.PlatformSdkVersion()
583 } else {
584 return c.PlatformSdkCodename()
585 }
586}
587
Colin Cross3bc7ffa2017-11-22 16:19:37 -0800588func (c *config) AppsDefaultVersionName() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800589 return String(c.productVariables.AppsDefaultVersionName)
Colin Cross3bc7ffa2017-11-22 16:19:37 -0800590}
591
Dan Albert31384de2017-07-28 12:39:46 -0700592// Codenames that are active in the current lunch target.
593func (c *config) PlatformVersionActiveCodenames() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800594 return c.productVariables.Platform_version_active_codenames
Dan Albert31384de2017-07-28 12:39:46 -0700595}
596
597// Codenames that are available in the branch but not included in the current
598// lunch target.
599func (c *config) PlatformVersionFutureCodenames() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800600 return c.productVariables.Platform_version_future_codenames
Dan Albert31384de2017-07-28 12:39:46 -0700601}
602
603// All possible codenames in the current branch. NB: Not named AllCodenames
604// because "all" has historically meant "active" in make, and still does in
605// build.prop.
606func (c *config) PlatformVersionCombinedCodenames() []string {
607 combined := []string{}
608 combined = append(combined, c.PlatformVersionActiveCodenames()...)
609 combined = append(combined, c.PlatformVersionFutureCodenames()...)
610 return combined
Dan Albert30c9d6e2017-03-28 14:54:55 -0700611}
612
Colin Crossface4e42017-10-30 17:32:15 -0700613func (c *config) ProductAAPTConfig() []string {
Colin Crossa74ca042019-01-31 14:31:51 -0800614 return c.productVariables.AAPTConfig
Colin Cross30e076a2015-04-13 13:58:27 -0700615}
616
Colin Crossface4e42017-10-30 17:32:15 -0700617func (c *config) ProductAAPTPreferredConfig() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800618 return String(c.productVariables.AAPTPreferredConfig)
Colin Cross30e076a2015-04-13 13:58:27 -0700619}
620
Colin Crossface4e42017-10-30 17:32:15 -0700621func (c *config) ProductAAPTCharacteristics() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800622 return String(c.productVariables.AAPTCharacteristics)
Colin Crossface4e42017-10-30 17:32:15 -0700623}
624
625func (c *config) ProductAAPTPrebuiltDPI() []string {
Colin Crossa74ca042019-01-31 14:31:51 -0800626 return c.productVariables.AAPTPrebuiltDPI
Colin Cross30e076a2015-04-13 13:58:27 -0700627}
628
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700629func (c *config) DefaultAppCertificateDir(ctx PathContext) SourcePath {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800630 defaultCert := String(c.productVariables.DefaultAppCertificate)
Colin Cross61ae0b72017-12-01 17:16:02 -0800631 if defaultCert != "" {
632 return PathForSource(ctx, filepath.Dir(defaultCert))
633 } else {
Dan Willemsen412160e2019-04-09 21:36:26 -0700634 return PathForSource(ctx, "build/make/target/product/security")
Colin Cross61ae0b72017-12-01 17:16:02 -0800635 }
Colin Cross30e076a2015-04-13 13:58:27 -0700636}
637
Colin Crosse1731a52017-12-14 11:22:55 -0800638func (c *config) DefaultAppCertificate(ctx PathContext) (pem, key SourcePath) {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800639 defaultCert := String(c.productVariables.DefaultAppCertificate)
Colin Cross61ae0b72017-12-01 17:16:02 -0800640 if defaultCert != "" {
Colin Crosse1731a52017-12-14 11:22:55 -0800641 return PathForSource(ctx, defaultCert+".x509.pem"), PathForSource(ctx, defaultCert+".pk8")
Colin Cross61ae0b72017-12-01 17:16:02 -0800642 } else {
Colin Crosse1731a52017-12-14 11:22:55 -0800643 defaultDir := c.DefaultAppCertificateDir(ctx)
644 return defaultDir.Join(ctx, "testkey.x509.pem"), defaultDir.Join(ctx, "testkey.pk8")
Colin Cross61ae0b72017-12-01 17:16:02 -0800645 }
Colin Cross30e076a2015-04-13 13:58:27 -0700646}
Colin Cross6ff51382015-12-17 16:39:19 -0800647
Jiyong Park9335a262018-12-24 11:31:58 +0900648func (c *config) ApexKeyDir(ctx ModuleContext) SourcePath {
649 // TODO(b/121224311): define another variable such as TARGET_APEX_KEY_OVERRIDE
650 defaultCert := String(c.productVariables.DefaultAppCertificate)
Dan Willemsen412160e2019-04-09 21:36:26 -0700651 if defaultCert == "" || filepath.Dir(defaultCert) == "build/make/target/product/security" {
Jiyong Park9335a262018-12-24 11:31:58 +0900652 // When defaultCert is unset or is set to the testkeys path, use the APEX keys
653 // that is under the module dir
Colin Cross07e51612019-03-05 12:46:40 -0800654 return pathForModuleSrc(ctx)
Jiyong Park9335a262018-12-24 11:31:58 +0900655 } else {
656 // If not, APEX keys are under the specified directory
657 return PathForSource(ctx, filepath.Dir(defaultCert))
658 }
659}
660
Colin Cross6ff51382015-12-17 16:39:19 -0800661func (c *config) AllowMissingDependencies() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800662 return Bool(c.productVariables.Allow_missing_dependencies)
Colin Cross6ff51382015-12-17 16:39:19 -0800663}
Dan Willemsen322acaf2016-01-12 23:07:05 -0800664
Colin Crossfc3674a2017-09-18 17:41:52 -0700665func (c *config) UnbundledBuild() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800666 return Bool(c.productVariables.Unbundled_build)
Colin Crossfc3674a2017-09-18 17:41:52 -0700667}
668
Colin Cross10932872019-04-18 14:27:12 -0700669func (c *config) UnbundledBuildUsePrebuiltSdks() bool {
Colin Cross1f367bf2018-12-18 22:46:24 -0800670 return Bool(c.productVariables.Unbundled_build) && !Bool(c.productVariables.Unbundled_build_sdks_from_source)
671}
672
Doug Horn21b94272019-01-16 12:06:11 -0800673func (c *config) Fuchsia() bool {
674 return Bool(c.productVariables.Fuchsia)
675}
676
Colin Cross0d3f8c02017-10-24 10:51:45 -0700677func (c *config) IsPdkBuild() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800678 return Bool(c.productVariables.Pdk)
Colin Cross0d3f8c02017-10-24 10:51:45 -0700679}
680
Colin Cross126a25c2017-10-31 13:55:34 -0700681func (c *config) MinimizeJavaDebugInfo() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800682 return Bool(c.productVariables.MinimizeJavaDebugInfo) && !Bool(c.productVariables.Eng)
Colin Cross126a25c2017-10-31 13:55:34 -0700683}
684
Colin Crossed064c02018-09-05 16:28:13 -0700685func (c *config) Debuggable() bool {
686 return Bool(c.productVariables.Debuggable)
687}
688
Jaewoong Jung1d6eb682018-11-29 15:08:44 -0800689func (c *config) Eng() bool {
690 return Bool(c.productVariables.Eng)
691}
692
Colin Cross88da24e2018-10-01 15:30:23 -0700693func (c *config) DevicePrefer32BitApps() bool {
694 return Bool(c.productVariables.DevicePrefer32BitApps)
695}
696
Colin Cross1e7d3702016-08-24 15:25:47 -0700697func (c *config) DevicePrefer32BitExecutables() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800698 return Bool(c.productVariables.DevicePrefer32BitExecutables)
Colin Cross1e7d3702016-08-24 15:25:47 -0700699}
700
Jiyong Park8d52f862018-07-07 18:02:07 +0900701func (c *config) DevicePrimaryArchType() ArchType {
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700702 return c.Targets[Android][0].Arch.ArchType
Jiyong Park8d52f862018-07-07 18:02:07 +0900703}
704
Colin Cross893d8162017-04-26 17:34:03 -0700705func (c *config) SkipMegaDeviceInstall(path string) bool {
706 return Bool(c.Mega_device) &&
707 strings.HasPrefix(path, filepath.Join(c.buildDir, "target", "product"))
Dan Willemsen322acaf2016-01-12 23:07:05 -0800708}
Colin Cross16b23492016-01-06 14:41:07 -0800709
710func (c *config) SanitizeHost() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800711 return append([]string(nil), c.productVariables.SanitizeHost...)
Colin Cross16b23492016-01-06 14:41:07 -0800712}
713
714func (c *config) SanitizeDevice() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800715 return append([]string(nil), c.productVariables.SanitizeDevice...)
Colin Cross23ae82a2016-11-02 14:34:39 -0700716}
717
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700718func (c *config) SanitizeDeviceDiag() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800719 return append([]string(nil), c.productVariables.SanitizeDeviceDiag...)
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700720}
721
Colin Cross23ae82a2016-11-02 14:34:39 -0700722func (c *config) SanitizeDeviceArch() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800723 return append([]string(nil), c.productVariables.SanitizeDeviceArch...)
Colin Cross16b23492016-01-06 14:41:07 -0800724}
Colin Crossa1ad8d12016-06-01 17:09:44 -0700725
Vishwath Mohan1b017a72017-01-19 13:54:55 -0800726func (c *config) EnableCFI() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800727 if c.productVariables.EnableCFI == nil {
Vishwath Mohanc32c3eb2017-01-24 14:20:54 -0800728 return true
729 } else {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800730 return *c.productVariables.EnableCFI
Vishwath Mohanc32c3eb2017-01-24 14:20:54 -0800731 }
Vishwath Mohan1b017a72017-01-19 13:54:55 -0800732}
733
Kostya Kortchinskyd5275c82019-02-01 08:42:56 -0800734func (c *config) DisableScudo() bool {
735 return Bool(c.productVariables.DisableScudo)
736}
737
Ivan Lozano074ec482018-11-21 08:59:37 -0800738func (c *config) EnableXOM() bool {
739 if c.productVariables.EnableXOM == nil {
Ivan Lozanob84fc9d2019-01-10 09:46:00 -0800740 return true
Ivan Lozano074ec482018-11-21 08:59:37 -0800741 } else {
742 return Bool(c.productVariables.EnableXOM)
743 }
744}
745
Colin Crossa1ad8d12016-06-01 17:09:44 -0700746func (c *config) Android64() bool {
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700747 for _, t := range c.Targets[Android] {
Colin Crossa1ad8d12016-06-01 17:09:44 -0700748 if t.Arch.ArchType.Multilib == "lib64" {
749 return true
750 }
751 }
752
753 return false
754}
Colin Cross9272ade2016-08-17 15:24:12 -0700755
Colin Cross9d45bb72016-08-29 16:14:13 -0700756func (c *config) UseGoma() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800757 return Bool(c.productVariables.UseGoma)
Colin Cross9d45bb72016-08-29 16:14:13 -0700758}
759
Ramy Medhatbbf25672019-07-17 12:30:04 +0000760func (c *config) UseRBE() bool {
761 return Bool(c.productVariables.UseRBE)
762}
763
Colin Cross66548102018-06-19 22:47:35 -0700764func (c *config) RunErrorProne() bool {
765 return c.IsEnvTrue("RUN_ERROR_PRONE")
766}
767
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800768func (c *config) XrefCorpusName() string {
769 return c.Getenv("XREF_CORPUS")
770}
771
772func (c *config) EmitXrefRules() bool {
773 return c.XrefCorpusName() != ""
774}
775
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700776func (c *config) ClangTidy() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800777 return Bool(c.productVariables.ClangTidy)
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700778}
779
780func (c *config) TidyChecks() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800781 if c.productVariables.TidyChecks == nil {
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700782 return ""
783 }
Dan Willemsen45133ac2018-03-09 21:22:06 -0800784 return *c.productVariables.TidyChecks
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700785}
786
Colin Cross0f4e0d62016-07-27 10:56:55 -0700787func (c *config) LibartImgHostBaseAddress() string {
788 return "0x60000000"
789}
790
791func (c *config) LibartImgDeviceBaseAddress() string {
Mathieu Chartierd42f19c2018-09-18 07:09:16 +0000792 archType := Common
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700793 if len(c.Targets[Android]) > 0 {
794 archType = c.Targets[Android][0].Arch.ArchType
Mathieu Chartierd42f19c2018-09-18 07:09:16 +0000795 }
796 switch archType {
797 default:
798 return "0x70000000"
799 case Mips, Mips64:
800 return "0x5C000000"
801 }
Colin Cross0f4e0d62016-07-27 10:56:55 -0700802}
803
Hiroshi Yamauchie2a10632016-12-19 13:44:41 -0800804func (c *config) ArtUseReadBarrier() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800805 return Bool(c.productVariables.ArtUseReadBarrier)
Hiroshi Yamauchie2a10632016-12-19 13:44:41 -0800806}
807
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700808func (c *config) EnforceRROForModule(name string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800809 enforceList := c.productVariables.EnforceRROTargets
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700810 if enforceList != nil {
Yo Chiang4ebd06a2019-10-01 13:13:41 +0800811 if InList("*", enforceList) {
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700812 return true
813 }
Colin Crossa74ca042019-01-31 14:31:51 -0800814 return InList(name, enforceList)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700815 }
816 return false
817}
818
819func (c *config) EnforceRROExcludedOverlay(path string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800820 excluded := c.productVariables.EnforceRROExcludedOverlays
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700821 if excluded != nil {
Colin Crossa74ca042019-01-31 14:31:51 -0800822 for _, exclude := range excluded {
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700823 if strings.HasPrefix(path, exclude) {
824 return true
825 }
826 }
827 }
828 return false
829}
830
831func (c *config) ExportedNamespaces() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800832 return append([]string(nil), c.productVariables.NamespacesToExport...)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700833}
834
835func (c *config) HostStaticBinaries() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800836 return Bool(c.productVariables.HostStaticBinaries)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -0700837}
838
Colin Cross5a0dcd52018-10-05 14:20:06 -0700839func (c *config) UncompressPrivAppDex() bool {
840 return Bool(c.productVariables.UncompressPrivAppDex)
841}
842
843func (c *config) ModulesLoadedByPrivilegedModules() []string {
844 return c.productVariables.ModulesLoadedByPrivilegedModules
845}
846
Vladimir Markoe8b00d62018-12-21 15:54:16 +0000847func (c *config) BootJars() []string {
848 return c.productVariables.BootJars
849}
850
Colin Cross43f08db2018-11-12 10:13:39 -0800851func (c *config) DexpreoptGlobalConfig() string {
852 return String(c.productVariables.DexpreoptGlobalConfig)
853}
854
David Brazdil91b4e3e2019-01-23 21:04:05 +0000855func (c *config) FrameworksBaseDirExists(ctx PathContext) bool {
856 return ExistentPathForSource(ctx, "frameworks", "base").Valid()
857}
858
Inseob Kimae553032019-05-14 18:52:49 +0900859func (c *config) VndkSnapshotBuildArtifacts() bool {
860 return Bool(c.productVariables.VndkSnapshotBuildArtifacts)
861}
862
Colin Cross3b19f5d2019-09-17 14:45:31 -0700863func (c *config) HasMultilibConflict(arch ArchType) bool {
864 return c.multilibConflicts[arch]
865}
866
Colin Cross9272ade2016-08-17 15:24:12 -0700867func (c *deviceConfig) Arches() []Arch {
868 var arches []Arch
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700869 for _, target := range c.config.Targets[Android] {
Colin Cross9272ade2016-08-17 15:24:12 -0700870 arches = append(arches, target.Arch)
871 }
872 return arches
873}
Dan Willemsend2ede872016-11-18 14:54:24 -0800874
Jayant Chowdhary34ce67d2018-03-08 11:00:50 -0800875func (c *deviceConfig) BinderBitness() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800876 is32BitBinder := c.config.productVariables.Binder32bit
Jayant Chowdhary34ce67d2018-03-08 11:00:50 -0800877 if is32BitBinder != nil && *is32BitBinder {
878 return "32"
879 }
880 return "64"
881}
882
Dan Willemsen4353bc42016-12-05 17:16:02 -0800883func (c *deviceConfig) VendorPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800884 if c.config.productVariables.VendorPath != nil {
885 return *c.config.productVariables.VendorPath
Dan Willemsen4353bc42016-12-05 17:16:02 -0800886 }
887 return "vendor"
888}
889
Justin Yun71549282017-11-17 12:10:28 +0900890func (c *deviceConfig) VndkVersion() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800891 return String(c.config.productVariables.DeviceVndkVersion)
Justin Yun71549282017-11-17 12:10:28 +0900892}
893
Justin Yun8fe12122017-12-07 17:18:15 +0900894func (c *deviceConfig) PlatformVndkVersion() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800895 return String(c.config.productVariables.Platform_vndk_version)
Justin Yun8fe12122017-12-07 17:18:15 +0900896}
897
Justin Yun71549282017-11-17 12:10:28 +0900898func (c *deviceConfig) ExtraVndkVersions() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800899 return c.config.productVariables.ExtraVndkVersions
Dan Willemsend2ede872016-11-18 14:54:24 -0800900}
Jack He8cc71432016-12-08 15:45:07 -0800901
Vic Yangefd249e2018-11-12 20:19:56 -0800902func (c *deviceConfig) VndkUseCoreVariant() bool {
903 return Bool(c.config.productVariables.VndkUseCoreVariant)
904}
905
Jiyong Park1a5d7b12018-01-15 15:05:10 +0900906func (c *deviceConfig) SystemSdkVersions() []string {
Colin Crossa74ca042019-01-31 14:31:51 -0800907 return c.config.productVariables.DeviceSystemSdkVersions
Jiyong Park1a5d7b12018-01-15 15:05:10 +0900908}
909
910func (c *deviceConfig) PlatformSystemSdkVersions() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800911 return c.config.productVariables.Platform_systemsdk_versions
Jiyong Park1a5d7b12018-01-15 15:05:10 +0900912}
913
Jiyong Park2db76922017-11-08 16:03:48 +0900914func (c *deviceConfig) OdmPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800915 if c.config.productVariables.OdmPath != nil {
916 return *c.config.productVariables.OdmPath
Jiyong Park2db76922017-11-08 16:03:48 +0900917 }
918 return "odm"
919}
920
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +0900921func (c *deviceConfig) ProductPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800922 if c.config.productVariables.ProductPath != nil {
923 return *c.config.productVariables.ProductPath
Jiyong Park2db76922017-11-08 16:03:48 +0900924 }
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +0900925 return "product"
Jiyong Park2db76922017-11-08 16:03:48 +0900926}
927
Justin Yund5f6c822019-06-25 16:47:17 +0900928func (c *deviceConfig) SystemExtPath() string {
929 if c.config.productVariables.SystemExtPath != nil {
930 return *c.config.productVariables.SystemExtPath
Dario Frenifd05a742018-05-29 13:28:54 +0100931 }
Justin Yund5f6c822019-06-25 16:47:17 +0900932 return "system_ext"
Dario Frenifd05a742018-05-29 13:28:54 +0100933}
934
Jack He8cc71432016-12-08 15:45:07 -0800935func (c *deviceConfig) BtConfigIncludeDir() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800936 return String(c.config.productVariables.BtConfigIncludeDir)
Jack He8cc71432016-12-08 15:45:07 -0800937}
Dan Willemsen581341d2017-02-09 16:16:31 -0800938
Jiyong Parkd773eb32017-07-03 13:18:12 +0900939func (c *deviceConfig) DeviceKernelHeaderDirs() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800940 return c.config.productVariables.DeviceKernelHeaders
Jiyong Parkd773eb32017-07-03 13:18:12 +0900941}
942
Dan Willemsen581341d2017-02-09 16:16:31 -0800943func (c *deviceConfig) NativeCoverageEnabled() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800944 return Bool(c.config.productVariables.NativeCoverage)
Dan Willemsen581341d2017-02-09 16:16:31 -0800945}
946
947func (c *deviceConfig) CoverageEnabledForPath(path string) bool {
Ryan Campbell469a18a2017-02-27 09:01:54 -0800948 coverage := false
Dan Willemsen45133ac2018-03-09 21:22:06 -0800949 if c.config.productVariables.CoveragePaths != nil {
Pirama Arumuga Nainar4e128282019-03-01 14:43:39 -0800950 if InList("*", c.config.productVariables.CoveragePaths) || PrefixInList(path, c.config.productVariables.CoveragePaths) {
Ivan Lozano5f595532017-07-13 14:46:05 -0700951 coverage = true
Dan Willemsen581341d2017-02-09 16:16:31 -0800952 }
953 }
Dan Willemsen45133ac2018-03-09 21:22:06 -0800954 if coverage && c.config.productVariables.CoverageExcludePaths != nil {
Colin Crossa74ca042019-01-31 14:31:51 -0800955 if PrefixInList(path, c.config.productVariables.CoverageExcludePaths) {
Ivan Lozano5f595532017-07-13 14:46:05 -0700956 coverage = false
Ryan Campbell469a18a2017-02-27 09:01:54 -0800957 }
958 }
959 return coverage
Dan Willemsen581341d2017-02-09 16:16:31 -0800960}
Ivan Lozano5f595532017-07-13 14:46:05 -0700961
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -0800962func (c *deviceConfig) PgoAdditionalProfileDirs() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800963 return c.config.productVariables.PgoAdditionalProfileDirs
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -0800964}
965
Tri Vo35a51432018-03-25 20:00:00 -0700966func (c *deviceConfig) VendorSepolicyDirs() []string {
967 return c.config.productVariables.BoardVendorSepolicyDirs
968}
969
970func (c *deviceConfig) OdmSepolicyDirs() []string {
971 return c.config.productVariables.BoardOdmSepolicyDirs
972}
973
Tri Vof544fe32018-05-20 14:34:48 -0700974func (c *deviceConfig) PlatPublicSepolicyDirs() []string {
975 return c.config.productVariables.BoardPlatPublicSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -0700976}
977
Tri Vof544fe32018-05-20 14:34:48 -0700978func (c *deviceConfig) PlatPrivateSepolicyDirs() []string {
979 return c.config.productVariables.BoardPlatPrivateSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -0700980}
981
Inseob Kim0866b002019-04-15 20:21:29 +0900982func (c *deviceConfig) SepolicyM4Defs() []string {
983 return c.config.productVariables.BoardSepolicyM4Defs
984}
985
Jiyong Park7f67f482019-01-05 12:57:48 +0900986func (c *deviceConfig) OverrideManifestPackageNameFor(name string) (manifestName string, overridden bool) {
Jaewoong Jung2ad817c2019-01-18 14:27:16 -0800987 return findOverrideValue(c.config.productVariables.ManifestPackageNameOverrides, name,
988 "invalid override rule %q in PRODUCT_MANIFEST_PACKAGE_NAME_OVERRIDES should be <module_name>:<manifest_name>")
989}
990
991func (c *deviceConfig) OverrideCertificateFor(name string) (certificatePath string, overridden bool) {
Jaewoong Jungacb6db32019-02-28 16:22:30 +0000992 return findOverrideValue(c.config.productVariables.CertificateOverrides, name,
Jaewoong Jung2ad817c2019-01-18 14:27:16 -0800993 "invalid override rule %q in PRODUCT_CERTIFICATE_OVERRIDES should be <module_name>:<certificate_module_name>")
994}
995
Jaewoong Jung9d22a912019-01-23 16:27:47 -0800996func (c *deviceConfig) OverridePackageNameFor(name string) string {
997 newName, overridden := findOverrideValue(
998 c.config.productVariables.PackageNameOverrides,
999 name,
1000 "invalid override rule %q in PRODUCT_PACKAGE_NAME_OVERRIDES should be <module_name>:<package_name>")
1001 if overridden {
1002 return newName
1003 }
1004 return name
1005}
1006
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001007func findOverrideValue(overrides []string, name string, errorMsg string) (newValue string, overridden bool) {
Jiyong Park7f67f482019-01-05 12:57:48 +09001008 if overrides == nil || len(overrides) == 0 {
1009 return "", false
1010 }
1011 for _, o := range overrides {
1012 split := strings.Split(o, ":")
1013 if len(split) != 2 {
1014 // This shouldn't happen as this is first checked in make, but just in case.
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001015 panic(fmt.Errorf(errorMsg, o))
Jiyong Park7f67f482019-01-05 12:57:48 +09001016 }
1017 if matchPattern(split[0], name) {
1018 return substPattern(split[0], split[1], name), true
1019 }
1020 }
1021 return "", false
1022}
1023
Ivan Lozano5f595532017-07-13 14:46:05 -07001024func (c *config) IntegerOverflowDisabledForPath(path string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001025 if c.productVariables.IntegerOverflowExcludePaths == nil {
Ivan Lozano5f595532017-07-13 14:46:05 -07001026 return false
1027 }
Colin Crossa74ca042019-01-31 14:31:51 -08001028 return PrefixInList(path, c.productVariables.IntegerOverflowExcludePaths)
Ivan Lozano5f595532017-07-13 14:46:05 -07001029}
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001030
1031func (c *config) CFIDisabledForPath(path string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001032 if c.productVariables.CFIExcludePaths == nil {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001033 return false
1034 }
Colin Crossa74ca042019-01-31 14:31:51 -08001035 return PrefixInList(path, c.productVariables.CFIExcludePaths)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001036}
1037
1038func (c *config) CFIEnabledForPath(path string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001039 if c.productVariables.CFIIncludePaths == nil {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001040 return false
1041 }
Colin Crossa74ca042019-01-31 14:31:51 -08001042 return PrefixInList(path, c.productVariables.CFIIncludePaths)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001043}
Colin Crosse15ddaf2017-12-04 11:24:31 -08001044
Ivan Lozano074ec482018-11-21 08:59:37 -08001045func (c *config) XOMDisabledForPath(path string) bool {
1046 if c.productVariables.XOMExcludePaths == nil {
1047 return false
1048 }
Colin Crossa74ca042019-01-31 14:31:51 -08001049 return PrefixInList(path, c.productVariables.XOMExcludePaths)
Ivan Lozano074ec482018-11-21 08:59:37 -08001050}
1051
Dan Willemsen0fe78662018-03-26 12:41:18 -07001052func (c *config) VendorConfig(name string) VendorConfig {
1053 return vendorConfig(c.productVariables.VendorVars[name])
1054}
1055
1056func (c vendorConfig) Bool(name string) bool {
1057 v := strings.ToLower(c[name])
1058 return v == "1" || v == "y" || v == "yes" || v == "on" || v == "true"
1059}
1060
1061func (c vendorConfig) String(name string) string {
1062 return c[name]
1063}
1064
1065func (c vendorConfig) IsSet(name string) bool {
1066 _, ok := c[name]
1067 return ok
1068}
1069
Colin Cross395f2cf2018-10-24 16:10:32 -07001070func (c *config) NdkAbis() bool {
1071 return Bool(c.productVariables.Ndk_abis)
1072}
1073
Dan Albert23d37e02018-11-28 08:30:10 -08001074func (c *config) ExcludeDraftNdkApis() bool {
1075 return Bool(c.productVariables.Exclude_draft_ndk_apis)
1076}
1077
Jiyong Park8fd61922018-11-08 02:50:25 +09001078func (c *config) FlattenApex() bool {
Roland Levillaina3863212019-08-12 19:56:16 +01001079 return Bool(c.productVariables.Flatten_apex)
Jiyong Park8fd61922018-11-08 02:50:25 +09001080}
1081
Jeongik Chac9464142019-01-07 12:07:27 +09001082func (c *config) EnforceSystemCertificate() bool {
1083 return Bool(c.productVariables.EnforceSystemCertificate)
1084}
1085
1086func (c *config) EnforceSystemCertificateWhitelist() []string {
1087 return c.productVariables.EnforceSystemCertificateWhitelist
1088}
1089
Jeongik Cha2cc570d2019-10-29 15:44:45 +09001090func (c *config) EnforceProductPartitionInterface() bool {
1091 return Bool(c.productVariables.EnforceProductPartitionInterface)
1092}
1093
Jooyung Han3ab2c3e2019-12-05 16:27:44 +09001094func (c *config) InstallExtraFlattenedApexes() bool {
1095 return Bool(c.productVariables.InstallExtraFlattenedApexes)
1096}
1097
Colin Crossf24a22a2019-01-31 14:12:44 -08001098func (c *config) ProductHiddenAPIStubs() []string {
1099 return c.productVariables.ProductHiddenAPIStubs
Colin Cross8faf8fc2019-01-16 15:15:52 -08001100}
1101
Colin Crossf24a22a2019-01-31 14:12:44 -08001102func (c *config) ProductHiddenAPIStubsSystem() []string {
1103 return c.productVariables.ProductHiddenAPIStubsSystem
Colin Cross8faf8fc2019-01-16 15:15:52 -08001104}
1105
Colin Crossf24a22a2019-01-31 14:12:44 -08001106func (c *config) ProductHiddenAPIStubsTest() []string {
1107 return c.productVariables.ProductHiddenAPIStubsTest
Colin Cross8faf8fc2019-01-16 15:15:52 -08001108}
Dan Willemsen71c74602019-04-10 12:27:35 -07001109
Dan Willemsen54879d12019-04-18 10:08:46 -07001110func (c *deviceConfig) TargetFSConfigGen() []string {
Dan Willemsen71c74602019-04-10 12:27:35 -07001111 return c.config.productVariables.TargetFSConfigGen
1112}
Inseob Kim0866b002019-04-15 20:21:29 +09001113
1114func (c *config) ProductPublicSepolicyDirs() []string {
1115 return c.productVariables.ProductPublicSepolicyDirs
1116}
1117
1118func (c *config) ProductPrivateSepolicyDirs() []string {
1119 return c.productVariables.ProductPrivateSepolicyDirs
1120}
1121
1122func (c *config) ProductCompatibleProperty() bool {
1123 return Bool(c.productVariables.ProductCompatibleProperty)
1124}
Inseob Kim1f086e22019-05-09 13:29:15 +09001125
Colin Cross50ddcc42019-05-16 12:28:22 -07001126func (c *config) MissingUsesLibraries() []string {
1127 return c.productVariables.MissingUsesLibraries
1128}
1129
Inseob Kim1f086e22019-05-09 13:29:15 +09001130func (c *deviceConfig) BoardVndkRuntimeDisable() bool {
1131 return Bool(c.config.productVariables.BoardVndkRuntimeDisable)
1132}
1133
1134func (c *deviceConfig) DeviceArch() string {
1135 return String(c.config.productVariables.DeviceArch)
1136}
1137
1138func (c *deviceConfig) DeviceArchVariant() string {
1139 return String(c.config.productVariables.DeviceArchVariant)
1140}
1141
1142func (c *deviceConfig) DeviceSecondaryArch() string {
1143 return String(c.config.productVariables.DeviceSecondaryArch)
1144}
1145
1146func (c *deviceConfig) DeviceSecondaryArchVariant() string {
1147 return String(c.config.productVariables.DeviceSecondaryArchVariant)
1148}