blob: eb894932f57250748935b5b5edf184b35e659880 [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 (
Colin Cross3f40fa42015-01-30 17:27:36 -080021 "encoding/json"
22 "fmt"
23 "os"
Colin Cross35cec122015-04-02 14:37:16 -070024 "path/filepath"
Sam Delmerico5c32bbf2022-01-20 20:15:02 +000025 "reflect"
Colin Cross3f40fa42015-01-30 17:27:36 -080026 "runtime"
Inseob Kim60c32f02020-12-21 22:53:05 +090027 "strconv"
Dan Willemsen34cc69e2015-09-23 15:26:20 -070028 "strings"
Colin Crossc1e86a32015-04-15 12:33:28 -070029 "sync"
Colin Cross6ff51382015-12-17 16:39:19 -080030
Colin Cross98be1bb2019-12-13 20:41:13 -080031 "github.com/google/blueprint"
Colin Crosse87040b2017-12-11 15:52:26 -080032 "github.com/google/blueprint/bootstrap"
Colin Cross98be1bb2019-12-13 20:41:13 -080033 "github.com/google/blueprint/pathtools"
Colin Cross6ff51382015-12-17 16:39:19 -080034 "github.com/google/blueprint/proptools"
Colin Cross9d34f352019-11-22 16:03:51 -080035
36 "android/soong/android/soongconfig"
Liz Kammer09f947d2021-05-12 14:51:49 -040037 "android/soong/bazel"
Colin Cross77cdcfd2021-03-12 11:28:25 -080038 "android/soong/remoteexec"
Liz Kammer72beb342022-02-03 08:42:10 -050039 "android/soong/starlark_fmt"
Colin Cross3f40fa42015-01-30 17:27:36 -080040)
41
Jingwen Chenc711fec2020-11-22 23:52:50 -050042// Bool re-exports proptools.Bool for the android package.
Colin Cross6ff51382015-12-17 16:39:19 -080043var Bool = proptools.Bool
Jingwen Chenc711fec2020-11-22 23:52:50 -050044
45// String re-exports proptools.String for the android package.
Jack He8cc71432016-12-08 15:45:07 -080046var String = proptools.String
Jingwen Chenc711fec2020-11-22 23:52:50 -050047
48// StringDefault re-exports proptools.StringDefault for the android package.
Jeongik Cha219141c2020-08-06 23:00:37 +090049var StringDefault = proptools.StringDefault
Jiyong Park6a927c42020-01-21 02:03:43 +090050
Jingwen Chenc711fec2020-11-22 23:52:50 -050051// FutureApiLevelInt is a placeholder constant for unreleased API levels.
Dan Albert0b176c82020-07-23 16:43:25 -070052const FutureApiLevelInt = 10000
53
Spandan Das15da5882023-03-02 23:36:39 +000054// PrivateApiLevel represents the api level of SdkSpecPrivate (sdk_version: "")
55// This api_level exists to differentiate user-provided "" from "current" sdk_version
56// The differentiation is necessary to enable different validation rules for these two possible values.
57var PrivateApiLevel = ApiLevel{
58 value: "current", // The value is current since aidl expects `current` as the default (TestAidlFlagsWithMinSdkVersion)
59 number: FutureApiLevelInt + 1, // This is used to differentiate it from FutureApiLevel
60 isPreview: true,
61}
62
Jingwen Chenc711fec2020-11-22 23:52:50 -050063// FutureApiLevel represents unreleased API levels.
Dan Albert0b176c82020-07-23 16:43:25 -070064var FutureApiLevel = ApiLevel{
65 value: "current",
66 number: FutureApiLevelInt,
67 isPreview: true,
68}
Colin Cross6ff51382015-12-17 16:39:19 -080069
Jingwen Chenc4d91bc2020-11-24 22:59:26 -050070// The product variables file name, containing product config from Kati.
Dan Willemsen87b17d12015-07-14 00:39:06 -070071const productVariablesFileName = "soong.variables"
Colin Cross3f40fa42015-01-30 17:27:36 -080072
Colin Cross9272ade2016-08-17 15:24:12 -070073// A Config object represents the entire build configuration for Android.
Colin Crossc3c0a492015-04-10 15:43:55 -070074type Config struct {
75 *config
76}
77
Chris Parsonsad876012022-08-20 14:48:32 -040078type SoongBuildMode int
79
Sasha Smundakaf5ca922022-12-12 21:23:34 -080080type CmdArgs struct {
81 bootstrap.Args
Kiyoung Kima37d9ba2023-04-19 13:13:45 +090082 RunGoTests bool
83 OutDir string
84 SoongOutDir string
85 SoongVariables string
Sasha Smundakaf5ca922022-12-12 21:23:34 -080086
87 SymlinkForestMarker string
88 Bp2buildMarker string
89 BazelQueryViewDir string
90 BazelApiBp2buildDir string
91 ModuleGraphFile string
92 ModuleActionsFile string
93 DocFile string
94
LaMont Jones52a72432023-03-09 18:19:35 +000095 MultitreeBuild bool
96
Sasha Smundakaf5ca922022-12-12 21:23:34 -080097 BazelMode bool
Sasha Smundakaf5ca922022-12-12 21:23:34 -080098 BazelModeStaging bool
99 BazelForceEnabledModules string
Chris Parsons9402ca82023-02-23 17:28:06 -0500100
101 UseBazelProxy bool
Jihoon Kang1bff0342023-01-17 20:40:22 +0000102
103 BuildFromTextStub bool
MarkDacekf47e1422023-04-19 16:47:36 +0000104
105 EnsureAllowlistIntegrity bool
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800106}
107
Chris Parsonsad876012022-08-20 14:48:32 -0400108// Build modes that soong_build can run as.
109const (
110 // Don't use bazel at all during module analysis.
111 AnalysisNoBazel SoongBuildMode = iota
112
Lukacs T. Berkic541cd22022-10-26 07:26:50 +0000113 // Symlink fores mode: merge two directory trees into a symlink forest
114 SymlinkForest
115
Chris Parsonsad876012022-08-20 14:48:32 -0400116 // Bp2build mode: Generate BUILD files from blueprint files and exit.
117 Bp2build
118
119 // Generate BUILD files which faithfully represent the dependency graph of
120 // blueprint modules. Individual BUILD targets will not, however, faitfhully
121 // express build semantics.
122 GenerateQueryView
123
Spandan Das5af0bd32022-09-28 20:43:08 +0000124 // Generate BUILD files for API contributions to API surfaces
125 ApiBp2build
126
Chris Parsonsad876012022-08-20 14:48:32 -0400127 // Create a JSON representation of the module graph and exit.
128 GenerateModuleGraph
129
130 // Generate a documentation file for module type definitions and exit.
131 GenerateDocFile
132
MarkDacekb78465d2022-10-18 20:10:16 +0000133 // Use bazel during analysis of a few allowlisted build modules. The allowlist
134 // is considered "staging, as these are modules being prepared to be released
135 // into prod mode shortly after.
136 BazelStagingMode
137
Chris Parsonsad876012022-08-20 14:48:32 -0400138 // Use bazel during analysis of build modules from an allowlist carefully
139 // curated by the build team to be proven stable.
Chris Parsonsad876012022-08-20 14:48:32 -0400140 BazelProdMode
141)
142
Lukacs T. Berkib078ade2021-08-31 10:42:08 +0200143// SoongOutDir returns the build output directory for the configuration.
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200144func (c Config) SoongOutDir() string {
145 return c.soongOutDir
Jeff Gastonefc1b412017-03-29 17:29:06 -0700146}
147
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200148func (c Config) OutDir() string {
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200149 return c.outDir
Lukacs T. Berki89e9a162021-03-12 08:31:32 +0100150}
151
Lukacs T. Berkiea1a31c2021-09-02 09:58:09 +0200152func (c Config) RunGoTests() bool {
153 return c.runGoTests
154}
155
Lukacs T. Berki5f6cb1d2021-03-17 15:03:14 +0100156func (c Config) DebugCompilation() bool {
157 return false // Never compile Go code in the main build for debugging
158}
159
Lukacs T. Berkiea1a31c2021-09-02 09:58:09 +0200160func (c Config) Subninjas() []string {
161 return []string{}
162}
163
164func (c Config) PrimaryBuilderInvocations() []bootstrap.PrimaryBuilderInvocation {
165 return []bootstrap.PrimaryBuilderInvocation{}
166}
167
Paul Duffin74135582022-10-06 11:01:59 +0100168// RunningInsideUnitTest returns true if this code is being run as part of a Soong unit test.
169func (c Config) RunningInsideUnitTest() bool {
170 return c.config.TestProductVariables != nil
171}
172
Pratyushfaec4db2023-07-20 11:19:04 +0000173// DisableHiddenApiChecks returns true if hiddenapi checks have been disabled.
174// For 'eng' target variant hiddenapi checks are disabled by default for performance optimisation,
175// but can be enabled by setting environment variable ENABLE_HIDDENAPI_FLAGS=true.
176// For other target variants hiddenapi check are enabled by default but can be disabled by
177// setting environment variable UNSAFE_DISABLE_HIDDENAPI_FLAGS=true.
178// If both ENABLE_HIDDENAPI_FLAGS=true and UNSAFE_DISABLE_HIDDENAPI_FLAGS=true, then
179// ENABLE_HIDDENAPI_FLAGS=true will be triggered and hiddenapi checks will be considered enabled.
180func (c Config) DisableHiddenApiChecks() bool {
181 return !c.IsEnvTrue("ENABLE_HIDDENAPI_FLAGS") &&
182 (c.IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") ||
183 Bool(c.productVariables.Eng))
184}
185
Juan Yescas05d4d902023-04-07 10:35:35 -0700186// MaxPageSizeSupported returns the max page size supported by the device. This
187// value will define the ELF segment alignment for binaries (executables and
188// shared libraries).
189func (c Config) MaxPageSizeSupported() string {
190 return String(c.config.productVariables.DeviceMaxPageSizeSupported)
191}
192
Joe Onoratofee845a2023-05-09 08:14:14 -0700193// The release version passed to aconfig, derived from RELEASE_VERSION
194func (c Config) ReleaseVersion() string {
195 return c.config.productVariables.ReleaseVersion
196}
197
198// The flag values files passed to aconfig, derived from RELEASE_VERSION
Joe Onorato981c9262023-06-21 15:16:23 -0700199func (c Config) ReleaseAconfigValueSets() []string {
200 return c.config.productVariables.ReleaseAconfigValueSets
Joe Onoratofee845a2023-05-09 08:14:14 -0700201}
202
Jingwen Chenc711fec2020-11-22 23:52:50 -0500203// A DeviceConfig object represents the configuration for a particular device
204// being built. For now there will only be one of these, but in the future there
205// may be multiple devices being built.
Colin Cross9272ade2016-08-17 15:24:12 -0700206type DeviceConfig struct {
207 *deviceConfig
208}
209
Jingwen Chenc711fec2020-11-22 23:52:50 -0500210// VendorConfig represents the configuration for vendor-specific behavior.
Colin Cross9d34f352019-11-22 16:03:51 -0800211type VendorConfig soongconfig.SoongConfig
Dan Willemsen0fe78662018-03-26 12:41:18 -0700212
Jingwen Chenc711fec2020-11-22 23:52:50 -0500213// Definition of general build configuration for soong_build. Some of these
Jingwen Chenc4d91bc2020-11-24 22:59:26 -0500214// product configuration values are read from Kati-generated soong.variables.
Colin Cross1332b002015-04-07 17:11:30 -0700215type config struct {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500216 // Options configurable with soong.variables
Cole Faustf8231dd2023-04-21 17:37:11 -0700217 productVariables ProductVariables
Colin Cross3f40fa42015-01-30 17:27:36 -0800218
Dan Willemsen674dc7f2018-03-12 18:06:05 -0700219 // Only available on configs created by TestConfig
Cole Faustf8231dd2023-04-21 17:37:11 -0700220 TestProductVariables *ProductVariables
Dan Willemsen674dc7f2018-03-12 18:06:05 -0700221
Jingwen Chenc711fec2020-11-22 23:52:50 -0500222 // A specialized context object for Bazel/Soong mixed builds and migration
223 // purposes.
Chris Parsonsf3c96ef2020-09-29 02:23:17 -0400224 BazelContext BazelContext
225
Dan Willemsen87b17d12015-07-14 00:39:06 -0700226 ProductVariablesFileName string
227
Colin Cross0c66bc62021-07-20 09:47:41 -0700228 // BuildOS stores the OsType for the OS that the build is running on.
229 BuildOS OsType
230
231 // BuildArch stores the ArchType for the CPU that the build is running on.
232 BuildArch ArchType
233
Jaewoong Jung642916f2020-10-09 17:25:15 -0700234 Targets map[OsType][]Target
235 BuildOSTarget Target // the Target for tools run on the build machine
236 BuildOSCommonTarget Target // the Target for common (java) tools run on the build machine
237 AndroidCommonTarget Target // the Target for common modules for the Android device
238 AndroidFirstDeviceTarget Target // the first Target for modules for the Android device
Dan Willemsen218f6562015-07-08 18:13:11 -0700239
Jingwen Chenc711fec2020-11-22 23:52:50 -0500240 // multilibConflicts for an ArchType is true if there is earlier configured
241 // device architecture with the same multilib value.
Colin Cross3b19f5d2019-09-17 14:45:31 -0700242 multilibConflicts map[ArchType]bool
243
Colin Cross9272ade2016-08-17 15:24:12 -0700244 deviceConfig *deviceConfig
245
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200246 outDir string // The output directory (usually out/)
247 soongOutDir string
Chris Parsons8f232a22020-06-23 17:37:05 -0400248 moduleListFile string // the path to the file which lists blueprint files to parse.
Colin Crossc1e86a32015-04-15 12:33:28 -0700249
Lukacs T. Berkie1df43f2021-09-08 15:31:14 +0200250 runGoTests bool
Lukacs T. Berkiea1a31c2021-09-02 09:58:09 +0200251
Colin Cross6ccbc912017-10-10 23:07:38 -0700252 env map[string]string
Dan Willemsene7680ba2015-09-11 17:06:19 -0700253 envLock sync.Mutex
254 envDeps map[string]string
255 envFrozen bool
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800256
Jingwen Chencda22c92020-11-23 00:22:30 -0500257 // Changes behavior based on whether Kati runs after soong_build, or if soong_build
258 // runs standalone.
259 katiEnabled bool
Colin Cross1e7d3702016-08-24 15:25:47 -0700260
Colin Cross32616ed2017-09-05 21:56:44 -0700261 captureBuild bool // true for tests, saves build parameters for each module
262 ignoreEnvironment bool // true for tests, returns empty from all Getenv calls
Colin Crosscec81712017-07-13 14:43:27 -0700263
Colin Cross98be1bb2019-12-13 20:41:13 -0800264 fs pathtools.FileSystem
265 mockBpList string
266
Chris Parsonsad876012022-08-20 14:48:32 -0400267 BuildMode SoongBuildMode
Cole Faust324a92e2022-08-23 15:29:05 -0700268 Bp2buildPackageConfig Bp2BuildConversionAllowlist
Jingwen Chen01812022021-11-19 14:29:43 +0000269 Bp2buildSoongConfigDefinitions soongconfig.Bp2BuildSoongConfigDefinitions
Jingwen Chen12b4c272021-03-10 02:05:59 -0500270
LaMont Jones52a72432023-03-09 18:19:35 +0000271 // If MultitreeBuild is true then this is one inner tree of a multitree
272 // build directed by the multitree orchestrator.
273 MultitreeBuild bool
274
Colin Cross5e6a7972020-06-07 16:56:32 -0700275 // If testAllowNonExistentPaths is true then PathForSource and PathForModuleSrc won't error
276 // in tests when a path doesn't exist.
Pedro Loureiro5d190cc2021-02-15 15:41:33 +0000277 TestAllowNonExistentPaths bool
Colin Cross5e6a7972020-06-07 16:56:32 -0700278
Jingwen Chenc711fec2020-11-22 23:52:50 -0500279 // The list of files that when changed, must invalidate soong_build to
280 // regenerate build.ninja.
Colin Cross12129292020-10-29 18:23:58 -0700281 ninjaFileDepsSet sync.Map
282
Colin Cross9272ade2016-08-17 15:24:12 -0700283 OncePer
MarkDacekff851b82022-04-21 18:33:17 +0000284
Chris Parsonsad876012022-08-20 14:48:32 -0400285 // These fields are only used for metrics collection. A module should be added
286 // to these maps only if its implementation supports Bazel handling in mixed
287 // builds. A module being in the "enabled" list indicates that there is a
288 // variant of that module for which bazel-handling actually took place.
289 // A module being in the "disabled" list indicates that there is a variant of
290 // that module for which bazel-handling was denied.
MarkDacekff851b82022-04-21 18:33:17 +0000291 mixedBuildsLock sync.Mutex
292 mixedBuildEnabledModules map[string]struct{}
293 mixedBuildDisabledModules map[string]struct{}
MarkDacekd06db5d2022-11-29 00:47:59 +0000294
295 // These are modules to be built with Bazel beyond the allowlisted/build-mode
296 // specified modules. They are passed via the command-line flag
297 // "--bazel-force-enabled-modules"
298 bazelForceEnabledModules map[string]struct{}
Chris Parsons9402ca82023-02-23 17:28:06 -0500299
Chris Parsons8152a942023-06-06 16:17:50 +0000300 // Names of Bazel targets as defined by BUILD files in the source tree,
301 // keyed by the directory in which they are defined.
302 bazelTargetsByDir map[string][]string
303
Chris Parsons9402ca82023-02-23 17:28:06 -0500304 // If true, for any requests to Bazel, communicate with a Bazel proxy using
305 // unix sockets, instead of spawning Bazel as a subprocess.
306 UseBazelProxy bool
Jihoon Kang1bff0342023-01-17 20:40:22 +0000307
308 // If buildFromTextStub is true then the Java API stubs are
309 // built from the signature text files, not the source Java files.
310 buildFromTextStub bool
MarkDacekf47e1422023-04-19 16:47:36 +0000311
312 // If ensureAllowlistIntegrity is true, then the presence of any allowlisted
313 // modules that aren't mixed-built for at least one variant will cause a build
314 // failure
315 ensureAllowlistIntegrity bool
Jihoon Kang1c92c3e2023-03-23 17:44:51 +0000316
317 // List of Api libraries that contribute to Api surfaces.
318 apiLibraries map[string]struct{}
Colin Cross9272ade2016-08-17 15:24:12 -0700319}
320
321type deviceConfig struct {
Dan Willemsen00269f22017-07-06 16:59:48 -0700322 config *config
Colin Cross9272ade2016-08-17 15:24:12 -0700323 OncePer
Colin Cross3f40fa42015-01-30 17:27:36 -0800324}
325
Colin Cross485e5722015-08-27 13:28:01 -0700326type jsonConfigurable interface {
Colin Cross27385972015-09-18 10:57:10 -0700327 SetDefaultConfig()
Colin Cross485e5722015-08-27 13:28:01 -0700328}
Colin Cross3f40fa42015-01-30 17:27:36 -0800329
Colin Cross485e5722015-08-27 13:28:01 -0700330func loadConfig(config *config) error {
Colin Cross988414c2020-01-11 01:11:46 +0000331 return loadFromConfigFile(&config.productVariables, absolutePath(config.ProductVariablesFileName))
Colin Cross485e5722015-08-27 13:28:01 -0700332}
333
Jingwen Chenc711fec2020-11-22 23:52:50 -0500334// loadFromConfigFile loads and decodes configuration options from a JSON file
335// in the current working directory.
Cole Faustf8231dd2023-04-21 17:37:11 -0700336func loadFromConfigFile(configurable *ProductVariables, filename string) error {
Colin Cross3f40fa42015-01-30 17:27:36 -0800337 // Try to open the file
Colin Cross485e5722015-08-27 13:28:01 -0700338 configFileReader, err := os.Open(filename)
Colin Cross3f40fa42015-01-30 17:27:36 -0800339 defer configFileReader.Close()
340 if os.IsNotExist(err) {
341 // Need to create a file, so that blueprint & ninja don't get in
342 // a dependency tracking loop.
343 // Make a file-configurable-options with defaults, write it out using
344 // a json writer.
Colin Cross27385972015-09-18 10:57:10 -0700345 configurable.SetDefaultConfig()
346 err = saveToConfigFile(configurable, filename)
Colin Cross3f40fa42015-01-30 17:27:36 -0800347 if err != nil {
348 return err
349 }
Colin Cross15cd21a2018-02-27 11:26:02 -0800350 } else if err != nil {
351 return fmt.Errorf("config file: could not open %s: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800352 } else {
353 // Make a decoder for it
354 jsonDecoder := json.NewDecoder(configFileReader)
Colin Cross485e5722015-08-27 13:28:01 -0700355 err = jsonDecoder.Decode(configurable)
Colin Cross3f40fa42015-01-30 17:27:36 -0800356 if err != nil {
Colin Cross15cd21a2018-02-27 11:26:02 -0800357 return fmt.Errorf("config file: %s did not parse correctly: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800358 }
359 }
360
Liz Kammer09f947d2021-05-12 14:51:49 -0400361 if Bool(configurable.GcovCoverage) && Bool(configurable.ClangCoverage) {
362 return fmt.Errorf("GcovCoverage and ClangCoverage cannot both be set")
363 }
364
365 configurable.Native_coverage = proptools.BoolPtr(
366 Bool(configurable.GcovCoverage) ||
367 Bool(configurable.ClangCoverage))
368
Yuntao Xu402e9b02021-08-09 15:44:44 -0700369 // when Platform_sdk_final is true (or PLATFORM_VERSION_CODENAME is REL), use Platform_sdk_version;
370 // if false (pre-released version, for example), use Platform_sdk_codename.
371 if Bool(configurable.Platform_sdk_final) {
372 if configurable.Platform_sdk_version != nil {
373 configurable.Platform_sdk_version_or_codename =
374 proptools.StringPtr(strconv.Itoa(*(configurable.Platform_sdk_version)))
375 } else {
376 return fmt.Errorf("Platform_sdk_version cannot be pointed by a NULL pointer")
377 }
378 } else {
379 configurable.Platform_sdk_version_or_codename =
380 proptools.StringPtr(String(configurable.Platform_sdk_codename))
381 }
382
Liz Kammer09f947d2021-05-12 14:51:49 -0400383 return saveToBazelConfigFile(configurable, filepath.Dir(filename))
Colin Cross3f40fa42015-01-30 17:27:36 -0800384}
385
Colin Crossd8f20142016-11-03 09:43:26 -0700386// atomically writes the config file in case two copies of soong_build are running simultaneously
387// (for example, docs generation and ninja manifest generation)
Cole Faustf8231dd2023-04-21 17:37:11 -0700388func saveToConfigFile(config *ProductVariables, filename string) error {
Colin Cross3f40fa42015-01-30 17:27:36 -0800389 data, err := json.MarshalIndent(&config, "", " ")
390 if err != nil {
391 return fmt.Errorf("cannot marshal config data: %s", err.Error())
392 }
393
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800394 f, err := os.CreateTemp(filepath.Dir(filename), "config")
Colin Cross3f40fa42015-01-30 17:27:36 -0800395 if err != nil {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500396 return fmt.Errorf("cannot create empty config file %s: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800397 }
Colin Crossd8f20142016-11-03 09:43:26 -0700398 defer os.Remove(f.Name())
399 defer f.Close()
Colin Cross3f40fa42015-01-30 17:27:36 -0800400
Colin Crossd8f20142016-11-03 09:43:26 -0700401 _, err = f.Write(data)
Colin Cross3f40fa42015-01-30 17:27:36 -0800402 if err != nil {
Colin Cross485e5722015-08-27 13:28:01 -0700403 return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error())
404 }
405
Colin Crossd8f20142016-11-03 09:43:26 -0700406 _, err = f.WriteString("\n")
Colin Cross485e5722015-08-27 13:28:01 -0700407 if err != nil {
408 return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error())
Colin Cross3f40fa42015-01-30 17:27:36 -0800409 }
410
Colin Crossd8f20142016-11-03 09:43:26 -0700411 f.Close()
412 os.Rename(f.Name(), filename)
413
Colin Cross3f40fa42015-01-30 17:27:36 -0800414 return nil
415}
416
Cole Faust87c0c332023-07-31 12:10:12 -0700417type productVariableStarlarkRepresentation struct {
418 soongType string
419 selectable bool
420 archVariant bool
421}
422
Cole Faustf8231dd2023-04-21 17:37:11 -0700423func saveToBazelConfigFile(config *ProductVariables, outDir string) error {
Liz Kammer09f947d2021-05-12 14:51:49 -0400424 dir := filepath.Join(outDir, bazel.SoongInjectionDirName, "product_config")
425 err := createDirIfNonexistent(dir, os.ModePerm)
426 if err != nil {
427 return fmt.Errorf("Could not create dir %s: %s", dir, err)
428 }
429
Cole Faust87c0c332023-07-31 12:10:12 -0700430 allProductVariablesType := reflect.TypeOf((*ProductVariables)(nil)).Elem()
431 productVariablesInfo := make(map[string]productVariableStarlarkRepresentation)
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000432 p := variableProperties{}
433 t := reflect.TypeOf(p.Product_variables)
434 for i := 0; i < t.NumField(); i++ {
435 f := t.Field(i)
Cole Faust87c0c332023-07-31 12:10:12 -0700436 if f.Name == "Pdk" {
437 // Pdk is deprecated and has no effect as of aosp/1319667
438 continue
439 }
440 archVariant := proptools.HasTag(f, "android", "arch_variant")
441 if mainProductVariablesStructField, ok := allProductVariablesType.FieldByName(f.Name); ok {
442 productVariablesInfo[f.Name] = productVariableStarlarkRepresentation{
443 soongType: stringRepresentationOfSimpleType(mainProductVariablesStructField.Type),
444 selectable: true,
445 archVariant: archVariant,
446 }
447 } else {
448 panic("Unknown variable " + f.Name)
Sam Delmerico5c32bbf2022-01-20 20:15:02 +0000449 }
450 }
451
Cole Fausteb644cf2023-04-11 13:48:17 -0700452 err = pathtools.WriteFileIfChanged(filepath.Join(dir, "product_variable_constants.bzl"), []byte(fmt.Sprintf(`
Cole Faust87c0c332023-07-31 12:10:12 -0700453# product_var_constant_info is a map of product variables to information about them. The fields are:
454# - soongType: The type of the product variable as it appears in soong's ProductVariables struct.
455# examples are string, bool, int, *bool, *string, []string, etc. This may be an overly
456# conservative estimation of the type, for example a *bool could oftentimes just be a
457# bool that defaults to false.
458# - selectable: if this product variable can be selected on in Android.bp/build files. This means
459# it's listed in the "variableProperties" soong struct. Currently all variables in
460# this list are selectable because we only need the selectable ones at the moment,
461# but the list may be expanded later.
462# - archVariant: If the variable is tagged as arch variant in the "variableProperties" struct.
463product_var_constant_info = %s
464product_var_constraints = [k for k, v in product_var_constant_info.items() if v.selectable]
465arch_variant_product_var_constraints = [k for k, v in product_var_constant_info.items() if v.selectable and v.archVariant]
466`, starlark_fmt.PrintAny(productVariablesInfo, 0))), 0644)
Cole Fausteb644cf2023-04-11 13:48:17 -0700467 if err != nil {
468 return fmt.Errorf("Could not write .bzl config file %s", err)
469 }
Chris Parsons0008cf82023-02-03 18:45:43 -0500470 err = pathtools.WriteFileIfChanged(filepath.Join(dir, "BUILD"),
471 []byte(bazel.GeneratedBazelFileWarning), 0644)
Liz Kammer09f947d2021-05-12 14:51:49 -0400472 if err != nil {
473 return fmt.Errorf("Could not write BUILD config file %s", err)
474 }
475
476 return nil
477}
478
Cole Faust87c0c332023-07-31 12:10:12 -0700479func stringRepresentationOfSimpleType(ty reflect.Type) string {
480 switch ty.Kind() {
481 case reflect.String:
482 return "string"
483 case reflect.Bool:
484 return "bool"
485 case reflect.Int:
486 return "int"
487 case reflect.Slice:
488 return "[]" + stringRepresentationOfSimpleType(ty.Elem())
489 case reflect.Pointer:
490 return "*" + stringRepresentationOfSimpleType(ty.Elem())
491 default:
492 panic("unimplemented type: " + ty.Kind().String())
493 }
494}
495
Colin Cross988414c2020-01-11 01:11:46 +0000496// NullConfig returns a mostly empty Config for use by standalone tools like dexpreopt_gen that
497// use the android package.
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200498func NullConfig(outDir, soongOutDir string) Config {
Colin Cross988414c2020-01-11 01:11:46 +0000499 return Config{
500 config: &config{
Lukacs T. Berkid6cee7e2021-09-01 16:25:51 +0200501 outDir: outDir,
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +0200502 soongOutDir: soongOutDir,
503 fs: pathtools.OsFs,
Colin Cross988414c2020-01-11 01:11:46 +0000504 },
505 }
506}
507
Jingwen Chenc711fec2020-11-22 23:52:50 -0500508// NewConfig creates a new Config object. The srcDir argument specifies the path
509// to the root source directory. It also loads the config file, if found.
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800510func NewConfig(cmdArgs CmdArgs, availableEnv map[string]string) (Config, error) {
Jingwen Chenc711fec2020-11-22 23:52:50 -0500511 // Make a config with default options.
Colin Cross9272ade2016-08-17 15:24:12 -0700512 config := &config{
Kiyoung Kima37d9ba2023-04-19 13:13:45 +0900513 ProductVariablesFileName: cmdArgs.SoongVariables,
Dan Willemsen87b17d12015-07-14 00:39:06 -0700514
Lukacs T. Berki53b2f362021-04-12 14:04:24 +0200515 env: availableEnv,
Colin Cross6ccbc912017-10-10 23:07:38 -0700516
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800517 outDir: cmdArgs.OutDir,
518 soongOutDir: cmdArgs.SoongOutDir,
519 runGoTests: cmdArgs.RunGoTests,
Lukacs T. Berkie1df43f2021-09-08 15:31:14 +0200520 multilibConflicts: make(map[ArchType]bool),
Colin Cross98be1bb2019-12-13 20:41:13 -0800521
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800522 moduleListFile: cmdArgs.ModuleListFile,
MarkDacekff851b82022-04-21 18:33:17 +0000523 fs: pathtools.NewOsFs(absSrcDir),
524 mixedBuildDisabledModules: make(map[string]struct{}),
525 mixedBuildEnabledModules: make(map[string]struct{}),
MarkDacekd06db5d2022-11-29 00:47:59 +0000526 bazelForceEnabledModules: make(map[string]struct{}),
Chris Parsons9402ca82023-02-23 17:28:06 -0500527
LaMont Jones52a72432023-03-09 18:19:35 +0000528 MultitreeBuild: cmdArgs.MultitreeBuild,
529 UseBazelProxy: cmdArgs.UseBazelProxy,
Jihoon Kang1bff0342023-01-17 20:40:22 +0000530
531 buildFromTextStub: cmdArgs.BuildFromTextStub,
Colin Cross68f55102015-03-25 14:43:57 -0700532 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800533
Dan Willemsen00269f22017-07-06 16:59:48 -0700534 config.deviceConfig = &deviceConfig{
Colin Cross9272ade2016-08-17 15:24:12 -0700535 config: config,
536 }
537
Jihoon Kangcbcad7c2023-06-01 22:31:52 +0000538 config.productVariables.Build_from_text_stub = boolPtr(config.buildFromTextStub)
539
Liz Kammer7941b302020-07-28 13:27:34 -0700540 // Soundness check of the build and source directories. This won't catch strange
541 // configurations with symlinks, but at least checks the obvious case.
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800542 absBuildDir, err := filepath.Abs(cmdArgs.SoongOutDir)
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700543 if err != nil {
544 return Config{}, err
545 }
546
Lukacs T. Berkif7e36d82021-08-16 17:05:09 +0200547 absSrcDir, err := filepath.Abs(".")
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700548 if err != nil {
549 return Config{}, err
550 }
551
552 if strings.HasPrefix(absSrcDir, absBuildDir) {
553 return Config{}, fmt.Errorf("Build dir must not contain source directory")
554 }
555
Colin Cross3f40fa42015-01-30 17:27:36 -0800556 // Load any configurable options from the configuration file
Colin Cross9272ade2016-08-17 15:24:12 -0700557 err = loadConfig(config)
Colin Cross3f40fa42015-01-30 17:27:36 -0800558 if err != nil {
Colin Crossc3c0a492015-04-10 15:43:55 -0700559 return Config{}, err
Colin Cross3f40fa42015-01-30 17:27:36 -0800560 }
561
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800562 KatiEnabledMarkerFile := filepath.Join(cmdArgs.SoongOutDir, ".soong.kati_enabled")
Jingwen Chencda22c92020-11-23 00:22:30 -0500563 if _, err := os.Stat(absolutePath(KatiEnabledMarkerFile)); err == nil {
564 config.katiEnabled = true
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800565 }
566
Colin Cross0c66bc62021-07-20 09:47:41 -0700567 determineBuildOS(config)
568
Jingwen Chenc711fec2020-11-22 23:52:50 -0500569 // Sets up the map of target OSes to the finer grained compilation targets
570 // that are configured from the product variables.
Colin Crossa1ad8d12016-06-01 17:09:44 -0700571 targets, err := decodeTargetProductVariables(config)
Dan Willemsen218f6562015-07-08 18:13:11 -0700572 if err != nil {
573 return Config{}, err
574 }
575
Paul Duffin1356d8c2020-02-25 19:26:33 +0000576 // Make the CommonOS OsType available for all products.
577 targets[CommonOS] = []Target{commonTargetMap[CommonOS.Name]}
578
Dan Albert4098deb2016-10-19 14:04:41 -0700579 var archConfig []archConfig
Jingwen Chenc4d91bc2020-11-24 22:59:26 -0500580 if config.NdkAbis() {
Dan Albert4098deb2016-10-19 14:04:41 -0700581 archConfig = getNdkAbisConfig()
Martin Stjernholmc1ecc432019-11-15 15:00:31 +0000582 } else if config.AmlAbis() {
583 archConfig = getAmlAbisConfig()
Dan Albert4098deb2016-10-19 14:04:41 -0700584 }
585
586 if archConfig != nil {
Liz Kammerb7f33662022-02-28 14:16:16 -0500587 androidTargets, err := decodeAndroidArchSettings(archConfig)
Dan Willemsen322acaf2016-01-12 23:07:05 -0800588 if err != nil {
589 return Config{}, err
590 }
Dan Willemsen0ef639b2018-10-10 17:02:29 -0700591 targets[Android] = androidTargets
Dan Willemsen322acaf2016-01-12 23:07:05 -0800592 }
593
Colin Cross3b19f5d2019-09-17 14:45:31 -0700594 multilib := make(map[string]bool)
595 for _, target := range targets[Android] {
596 if seen := multilib[target.Arch.ArchType.Multilib]; seen {
597 config.multilibConflicts[target.Arch.ArchType] = true
598 }
599 multilib[target.Arch.ArchType.Multilib] = true
600 }
601
Jingwen Chenc711fec2020-11-22 23:52:50 -0500602 // Map of OS to compilation targets.
Colin Crossa1ad8d12016-06-01 17:09:44 -0700603 config.Targets = targets
Jingwen Chenc711fec2020-11-22 23:52:50 -0500604
605 // Compilation targets for host tools.
Colin Cross0c66bc62021-07-20 09:47:41 -0700606 config.BuildOSTarget = config.Targets[config.BuildOS][0]
607 config.BuildOSCommonTarget = getCommonTargets(config.Targets[config.BuildOS])[0]
Jingwen Chenc711fec2020-11-22 23:52:50 -0500608
609 // Compilation targets for Android.
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700610 if len(config.Targets[Android]) > 0 {
611 config.AndroidCommonTarget = getCommonTargets(config.Targets[Android])[0]
Sam Delmericocc271e22022-06-01 15:45:02 +0000612 config.AndroidFirstDeviceTarget = FirstTarget(config.Targets[Android], "lib64", "lib32")[0]
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700613 }
Dan Willemsen218f6562015-07-08 18:13:11 -0700614
Usta Shresthacae3bfa2022-12-21 11:44:26 -0500615 setBuildMode := func(arg string, mode SoongBuildMode) {
616 if arg != "" {
617 if config.BuildMode != AnalysisNoBazel {
618 fmt.Fprintf(os.Stderr, "buildMode is already set, illegal argument: %s", arg)
619 os.Exit(1)
620 }
621 config.BuildMode = mode
622 }
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800623 }
Usta Shresthacae3bfa2022-12-21 11:44:26 -0500624 setBazelMode := func(arg bool, argName string, mode SoongBuildMode) {
625 if arg {
626 if config.BuildMode != AnalysisNoBazel {
627 fmt.Fprintf(os.Stderr, "buildMode is already set, illegal argument: %s", argName)
628 os.Exit(1)
629 }
630 config.BuildMode = mode
631 }
632 }
633 setBuildMode(cmdArgs.SymlinkForestMarker, SymlinkForest)
634 setBuildMode(cmdArgs.Bp2buildMarker, Bp2build)
635 setBuildMode(cmdArgs.BazelQueryViewDir, GenerateQueryView)
636 setBuildMode(cmdArgs.BazelApiBp2buildDir, ApiBp2build)
637 setBuildMode(cmdArgs.ModuleGraphFile, GenerateModuleGraph)
638 setBuildMode(cmdArgs.DocFile, GenerateDocFile)
Usta Shresthacae3bfa2022-12-21 11:44:26 -0500639 setBazelMode(cmdArgs.BazelMode, "--bazel-mode", BazelProdMode)
640 setBazelMode(cmdArgs.BazelModeStaging, "--bazel-mode-staging", BazelStagingMode)
Sasha Smundakaf5ca922022-12-12 21:23:34 -0800641
MarkDacek1de78f32023-05-02 21:00:48 +0000642 for _, module := range getForceEnabledModulesFromFlag(cmdArgs.BazelForceEnabledModules) {
MarkDacekd06db5d2022-11-29 00:47:59 +0000643 config.bazelForceEnabledModules[module] = struct{}{}
644 }
MarkDacek9c094ca2023-03-16 19:15:19 +0000645 config.BazelContext, err = NewBazelContext(config)
646 config.Bp2buildPackageConfig = GetBp2BuildAllowList()
MarkDacekd06db5d2022-11-29 00:47:59 +0000647
Jihoon Kang1c92c3e2023-03-23 17:44:51 +0000648 // TODO(b/276958307): Replace the hardcoded list to a sdk_library local prop.
649 config.apiLibraries = map[string]struct{}{
650 "android.net.ipsec.ike": {},
651 "art.module.public.api": {},
652 "conscrypt.module.public.api": {},
653 "framework-adservices": {},
654 "framework-appsearch": {},
655 "framework-bluetooth": {},
656 "framework-connectivity": {},
657 "framework-connectivity-t": {},
658 "framework-graphics": {},
659 "framework-media": {},
660 "framework-mediaprovider": {},
661 "framework-ondevicepersonalization": {},
662 "framework-permission": {},
663 "framework-permission-s": {},
664 "framework-scheduling": {},
665 "framework-sdkextensions": {},
666 "framework-statsd": {},
667 "framework-sdksandbox": {},
668 "framework-tethering": {},
669 "framework-uwb": {},
670 "framework-virtualization": {},
671 "framework-wifi": {},
672 "i18n.module.public.api": {},
673 }
674
Jingwen Chenc711fec2020-11-22 23:52:50 -0500675 return Config{config}, err
676}
Colin Cross988414c2020-01-11 01:11:46 +0000677
MarkDacek1de78f32023-05-02 21:00:48 +0000678func getForceEnabledModulesFromFlag(forceEnabledFlag string) []string {
679 if forceEnabledFlag == "" {
680 return []string{}
681 }
682 return strings.Split(forceEnabledFlag, ",")
683}
684
Colin Cross98be1bb2019-12-13 20:41:13 -0800685// mockFileSystem replaces all reads with accesses to the provided map of
686// filenames to contents stored as a byte slice.
687func (c *config) mockFileSystem(bp string, fs map[string][]byte) {
688 mockFS := map[string][]byte{}
689
690 if _, exists := mockFS["Android.bp"]; !exists {
691 mockFS["Android.bp"] = []byte(bp)
692 }
693
694 for k, v := range fs {
695 mockFS[k] = v
696 }
697
698 // no module list file specified; find every file named Blueprints or Android.bp
699 pathsToParse := []string{}
700 for candidate := range mockFS {
701 base := filepath.Base(candidate)
Lukacs T. Berkib838b0a2021-09-02 11:46:24 +0200702 if base == "Android.bp" {
Colin Cross98be1bb2019-12-13 20:41:13 -0800703 pathsToParse = append(pathsToParse, candidate)
704 }
705 }
706 if len(pathsToParse) < 1 {
707 panic(fmt.Sprintf("No Blueprint or Android.bp files found in mock filesystem: %v\n", mockFS))
708 }
709 mockFS[blueprint.MockModuleListFile] = []byte(strings.Join(pathsToParse, "\n"))
710
711 c.fs = pathtools.MockFs(mockFS)
712 c.mockBpList = blueprint.MockModuleListFile
713}
714
Jason Wuff1bb312022-12-21 09:57:26 -0500715// TODO(b/265062549): Add a field to our collected (and uploaded) metrics which
716// describes a reason that we fell back to non-mixed builds.
Chris Parsonsad876012022-08-20 14:48:32 -0400717// Returns true if "Bazel builds" is enabled. In this mode, part of build
718// analysis is handled by Bazel.
719func (c *config) IsMixedBuildsEnabled() bool {
Chris Parsons428c30f2022-11-29 14:14:52 -0500720 globalMixedBuildsSupport := c.Once(OnceKey{"globalMixedBuildsSupport"}, func() interface{} {
721 if c.productVariables.DeviceArch != nil && *c.productVariables.DeviceArch == "riscv64" {
Chris Parsons428c30f2022-11-29 14:14:52 -0500722 return false
723 }
Liz Kammer36ba6b22023-06-29 10:18:39 -0400724 // Disable Bazel when Kythe is running
725 if c.EmitXrefRules() {
726 return false
727 }
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500728 if c.IsEnvTrue("GLOBAL_THINLTO") {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500729 return false
730 }
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500731 if len(c.productVariables.SanitizeHost) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500732 return false
733 }
734 if len(c.productVariables.SanitizeDevice) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500735 return false
736 }
737 if len(c.productVariables.SanitizeDeviceDiag) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500738 return false
739 }
740 if len(c.productVariables.SanitizeDeviceArch) > 0 {
Sam Delmerico5150d0d2022-11-15 17:44:44 -0500741 return false
742 }
Chris Parsons428c30f2022-11-29 14:14:52 -0500743 return true
744 }).(bool)
745
Chris Parsons21f80272023-06-15 04:02:28 +0000746 bazelModeEnabled := c.BuildMode == BazelProdMode || c.BuildMode == BazelStagingMode
Chris Parsons428c30f2022-11-29 14:14:52 -0500747 return globalMixedBuildsSupport && bazelModeEnabled
Chris Parsonsad876012022-08-20 14:48:32 -0400748}
749
Lukacs T. Berkid1e3f1f2021-03-16 08:55:23 +0100750func (c *config) SetAllowMissingDependencies() {
751 c.productVariables.Allow_missing_dependencies = proptools.BoolPtr(true)
752}
753
Jingwen Chenc711fec2020-11-22 23:52:50 -0500754// BlueprintToolLocation returns the directory containing build system tools
755// from Blueprint, like soong_zip and merge_zips.
Lukacs T. Berkia806e412021-09-01 08:57:48 +0200756func (c *config) HostToolDir() string {
Colin Crossacfcc1f2021-10-25 15:40:32 -0700757 if c.KatiEnabled() {
758 return filepath.Join(c.outDir, "host", c.PrebuiltOS(), "bin")
759 } else {
760 return filepath.Join(c.soongOutDir, "host", c.PrebuiltOS(), "bin")
761 }
Dan Willemsenc2aa4a92016-05-26 15:13:03 -0700762}
763
Dan Willemsen60e62f02018-11-16 21:05:32 -0800764func (c *config) HostToolPath(ctx PathContext, tool string) Path {
Colin Cross790ef352021-10-25 19:15:55 -0700765 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "bin", false, tool)
766 return path
Dan Willemsen60e62f02018-11-16 21:05:32 -0800767}
768
Colin Cross790ef352021-10-25 19:15:55 -0700769func (c *config) HostJNIToolPath(ctx PathContext, lib string) Path {
Martin Stjernholm7260d062019-12-09 21:47:14 +0000770 ext := ".so"
771 if runtime.GOOS == "darwin" {
772 ext = ".dylib"
773 }
Colin Cross790ef352021-10-25 19:15:55 -0700774 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "lib64", false, lib+ext)
775 return path
Martin Stjernholm7260d062019-12-09 21:47:14 +0000776}
777
Colin Crossae5330a2021-11-03 13:31:22 -0700778func (c *config) HostJavaToolPath(ctx PathContext, tool string) Path {
779 path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "framework", false, tool)
Colin Cross3e3eda62021-11-04 10:22:51 -0700780 return path
781}
782
Vinh Tran09581952023-05-16 16:03:20 -0400783func (c *config) HostCcSharedLibPath(ctx PathContext, lib string) Path {
784 libDir := "lib"
785 if ctx.Config().BuildArch.Multilib == "lib64" {
786 libDir = "lib64"
787 }
788 return pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, libDir, false, lib+".so")
789}
790
Jingwen Chenc711fec2020-11-22 23:52:50 -0500791// PrebuiltOS returns the name of the host OS used in prebuilts directories.
Colin Cross1332b002015-04-07 17:11:30 -0700792func (c *config) PrebuiltOS() string {
Colin Cross3f40fa42015-01-30 17:27:36 -0800793 switch runtime.GOOS {
794 case "linux":
795 return "linux-x86"
796 case "darwin":
797 return "darwin-x86"
798 default:
799 panic("Unknown GOOS")
800 }
801}
802
803// GoRoot returns the path to the root directory of the Go toolchain.
Colin Cross1332b002015-04-07 17:11:30 -0700804func (c *config) GoRoot() string {
Lukacs T. Berkif7e36d82021-08-16 17:05:09 +0200805 return fmt.Sprintf("prebuilts/go/%s", c.PrebuiltOS())
Colin Cross3f40fa42015-01-30 17:27:36 -0800806}
807
Jingwen Chenc711fec2020-11-22 23:52:50 -0500808// PrebuiltBuildTool returns the path to a tool in the prebuilts directory containing
809// checked-in tools, like Kati, Ninja or Toybox, for the current host OS.
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700810func (c *config) PrebuiltBuildTool(ctx PathContext, tool string) Path {
811 return PathForSource(ctx, "prebuilts/build-tools", c.PrebuiltOS(), "bin", tool)
812}
813
Jingwen Chenc711fec2020-11-22 23:52:50 -0500814// CpPreserveSymlinksFlags returns the host-specific flag for the cp(1) command
815// to preserve symlinks.
Colin Cross1332b002015-04-07 17:11:30 -0700816func (c *config) CpPreserveSymlinksFlags() string {
Colin Cross485e5722015-08-27 13:28:01 -0700817 switch runtime.GOOS {
Colin Cross3f40fa42015-01-30 17:27:36 -0800818 case "darwin":
819 return "-R"
820 case "linux":
821 return "-d"
822 default:
823 return ""
824 }
825}
Colin Cross68f55102015-03-25 14:43:57 -0700826
Colin Cross1332b002015-04-07 17:11:30 -0700827func (c *config) Getenv(key string) string {
Colin Cross68f55102015-03-25 14:43:57 -0700828 var val string
829 var exists bool
Colin Crossc1e86a32015-04-15 12:33:28 -0700830 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800831 defer c.envLock.Unlock()
832 if c.envDeps == nil {
833 c.envDeps = make(map[string]string)
834 }
Colin Cross68f55102015-03-25 14:43:57 -0700835 if val, exists = c.envDeps[key]; !exists {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700836 if c.envFrozen {
837 panic("Cannot access new environment variables after envdeps are frozen")
838 }
Colin Cross6ccbc912017-10-10 23:07:38 -0700839 val, _ = c.env[key]
Colin Cross68f55102015-03-25 14:43:57 -0700840 c.envDeps[key] = val
841 }
842 return val
843}
844
Colin Cross99d7c232016-11-23 16:52:04 -0800845func (c *config) GetenvWithDefault(key string, defaultValue string) string {
846 ret := c.Getenv(key)
847 if ret == "" {
848 return defaultValue
849 }
850 return ret
851}
852
853func (c *config) IsEnvTrue(key string) bool {
854 value := c.Getenv(key)
855 return value == "1" || value == "y" || value == "yes" || value == "on" || value == "true"
856}
857
858func (c *config) IsEnvFalse(key string) bool {
859 value := c.Getenv(key)
860 return value == "0" || value == "n" || value == "no" || value == "off" || value == "false"
861}
862
Jingwen Chenc711fec2020-11-22 23:52:50 -0500863// EnvDeps returns the environment variables this build depends on. The first
864// call to this function blocks future reads from the environment.
Colin Cross1332b002015-04-07 17:11:30 -0700865func (c *config) EnvDeps() map[string]string {
Dan Willemsene7680ba2015-09-11 17:06:19 -0700866 c.envLock.Lock()
Colin Crossc0d58b42017-02-06 15:40:41 -0800867 defer c.envLock.Unlock()
Dan Willemsene7680ba2015-09-11 17:06:19 -0700868 c.envFrozen = true
Colin Cross68f55102015-03-25 14:43:57 -0700869 return c.envDeps
870}
Colin Cross35cec122015-04-02 14:37:16 -0700871
Jingwen Chencda22c92020-11-23 00:22:30 -0500872func (c *config) KatiEnabled() bool {
873 return c.katiEnabled
Dan Willemsen5ba07e82015-12-11 13:51:06 -0800874}
875
Nan Zhang581fd212018-01-10 16:06:12 -0800876func (c *config) BuildId() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800877 return String(c.productVariables.BuildId)
Nan Zhang581fd212018-01-10 16:06:12 -0800878}
879
Jingwen Chenc711fec2020-11-22 23:52:50 -0500880// BuildNumberFile returns the path to a text file containing metadata
881// representing the current build's number.
882//
883// Rules that want to reference the build number should read from this file
884// without depending on it. They will run whenever their other dependencies
885// require them to run and get the current build number. This ensures they don't
886// rebuild on every incremental build when the build number changes.
Colin Cross2a2e0db2020-02-21 16:55:46 -0800887func (c *config) BuildNumberFile(ctx PathContext) Path {
888 return PathForOutput(ctx, String(c.productVariables.BuildNumberFile))
Nan Zhang581fd212018-01-10 16:06:12 -0800889}
890
Jingwen Chenc711fec2020-11-22 23:52:50 -0500891// DeviceName returns the name of the current device target.
Colin Cross35cec122015-04-02 14:37:16 -0700892// TODO: take an AndroidModuleContext to select the device name for multi-device builds
Colin Cross1332b002015-04-07 17:11:30 -0700893func (c *config) DeviceName() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -0800894 return *c.productVariables.DeviceName
Colin Cross35cec122015-04-02 14:37:16 -0700895}
896
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000897// DeviceProduct returns the current product target. There could be multiple of
898// these per device type.
899//
Chris Parsonsef615e52022-08-18 22:04:11 -0400900// NOTE: Do not base conditional logic on this value. It may break product inheritance.
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000901func (c *config) DeviceProduct() string {
902 return *c.productVariables.DeviceProduct
903}
904
Cole Faustb85d1a12022-11-08 18:14:01 -0800905// HasDeviceProduct returns if the build has a product. A build will not
906// necessarily have a product when --skip-config is passed to soong, like it is
907// in prebuilts/build-tools/build-prebuilts.sh
908func (c *config) HasDeviceProduct() bool {
909 return c.productVariables.DeviceProduct != nil
910}
911
Anton Hansson53c88442019-03-18 15:53:16 +0000912func (c *config) DeviceResourceOverlays() []string {
913 return c.productVariables.DeviceResourceOverlays
914}
915
916func (c *config) ProductResourceOverlays() []string {
917 return c.productVariables.ProductResourceOverlays
Colin Cross30e076a2015-04-13 13:58:27 -0700918}
919
Colin Crossbfd347d2018-05-09 11:11:35 -0700920func (c *config) PlatformVersionName() string {
921 return String(c.productVariables.Platform_version_name)
922}
923
Dan Albert4f378d72020-07-23 17:32:15 -0700924func (c *config) PlatformSdkVersion() ApiLevel {
925 return uncheckedFinalApiLevel(*c.productVariables.Platform_sdk_version)
Colin Cross30e076a2015-04-13 13:58:27 -0700926}
927
Cole Faust37d27c42023-04-12 10:27:45 -0700928func (c *config) RawPlatformSdkVersion() *int {
929 return c.productVariables.Platform_sdk_version
930}
931
Mu-Le Lee5e047532022-07-27 02:32:03 +0000932func (c *config) PlatformSdkFinal() bool {
933 return Bool(c.productVariables.Platform_sdk_final)
934}
935
Colin Crossd09b0b62018-04-18 11:06:47 -0700936func (c *config) PlatformSdkCodename() string {
937 return String(c.productVariables.Platform_sdk_codename)
938}
939
Anton Hansson97d0bae2022-02-16 16:15:10 +0000940func (c *config) PlatformSdkExtensionVersion() int {
941 return *c.productVariables.Platform_sdk_extension_version
942}
943
944func (c *config) PlatformBaseSdkExtensionVersion() int {
945 return *c.productVariables.Platform_base_sdk_extension_version
946}
947
Colin Cross092c9da2019-04-02 22:56:43 -0700948func (c *config) PlatformSecurityPatch() string {
949 return String(c.productVariables.Platform_security_patch)
950}
951
952func (c *config) PlatformPreviewSdkVersion() string {
953 return String(c.productVariables.Platform_preview_sdk_version)
954}
955
956func (c *config) PlatformMinSupportedTargetSdkVersion() string {
957 return String(c.productVariables.Platform_min_supported_target_sdk_version)
958}
959
960func (c *config) PlatformBaseOS() string {
961 return String(c.productVariables.Platform_base_os)
962}
963
Inseob Kim4f1f3d92022-04-25 18:23:58 +0900964func (c *config) PlatformVersionLastStable() string {
965 return String(c.productVariables.Platform_version_last_stable)
966}
967
Jiyong Park37073842022-06-21 10:13:42 +0900968func (c *config) PlatformVersionKnownCodenames() string {
969 return String(c.productVariables.Platform_version_known_codenames)
970}
971
Dan Albert1a246272020-07-06 14:49:35 -0700972func (c *config) MinSupportedSdkVersion() ApiLevel {
Dan Albert6bfb6bb2022-08-17 20:11:57 +0000973 return uncheckedFinalApiLevel(21)
Dan Albert1a246272020-07-06 14:49:35 -0700974}
975
976func (c *config) FinalApiLevels() []ApiLevel {
977 var levels []ApiLevel
Dan Albert4f378d72020-07-23 17:32:15 -0700978 for i := 1; i <= c.PlatformSdkVersion().FinalOrFutureInt(); i++ {
Dan Albert1a246272020-07-06 14:49:35 -0700979 levels = append(levels, uncheckedFinalApiLevel(i))
980 }
981 return levels
982}
983
984func (c *config) PreviewApiLevels() []ApiLevel {
985 var levels []ApiLevel
986 for i, codename := range c.PlatformVersionActiveCodenames() {
987 levels = append(levels, ApiLevel{
988 value: codename,
989 number: i,
990 isPreview: true,
991 })
992 }
993 return levels
994}
995
satayevcca4ab72021-11-30 12:33:55 +0000996func (c *config) LatestPreviewApiLevel() ApiLevel {
997 level := NoneApiLevel
998 for _, l := range c.PreviewApiLevels() {
999 if l.GreaterThan(level) {
1000 level = l
1001 }
1002 }
1003 return level
1004}
1005
Dan Albert1a246272020-07-06 14:49:35 -07001006func (c *config) AllSupportedApiLevels() []ApiLevel {
1007 var levels []ApiLevel
1008 levels = append(levels, c.FinalApiLevels()...)
1009 return append(levels, c.PreviewApiLevels()...)
Dan Albertf5415d72017-08-17 16:19:59 -07001010}
1011
Jingwen Chenc711fec2020-11-22 23:52:50 -05001012// DefaultAppTargetSdk returns the API level that platform apps are targeting.
1013// This converts a codename to the exact ApiLevel it represents.
Dan Albert4f378d72020-07-23 17:32:15 -07001014func (c *config) DefaultAppTargetSdk(ctx EarlyModuleContext) ApiLevel {
Alixfb7f7b92023-03-02 19:35:02 +00001015 // This logic is replicated in starlark, if changing logic here update starlark code too
1016 // https://cs.android.com/android/platform/superproject/+/master:build/bazel/rules/common/api.bzl;l=72;drc=231c7e8c8038fd478a79eb68aa5b9f5c64e0e061
Colin Crossd09b0b62018-04-18 11:06:47 -07001017 if Bool(c.productVariables.Platform_sdk_final) {
1018 return c.PlatformSdkVersion()
Colin Crossd09b0b62018-04-18 11:06:47 -07001019 }
Jingwen Chenc711fec2020-11-22 23:52:50 -05001020 codename := c.PlatformSdkCodename()
Jiyong Park3a00e3d2023-03-27 17:39:48 +09001021 hostOnlyBuild := c.productVariables.DeviceArch == nil
Jingwen Chenc711fec2020-11-22 23:52:50 -05001022 if codename == "" {
Jiyong Park3a00e3d2023-03-27 17:39:48 +09001023 // There are some host-only builds (those are invoked by build-prebuilts.sh) which
1024 // don't set platform sdk codename. Platform sdk codename makes sense only when we
1025 // are building the platform. So we don't enforce the below panic for the host-only
1026 // builds.
1027 if hostOnlyBuild {
1028 return NoneApiLevel
1029 }
1030 panic("Platform_sdk_codename must be set")
Jingwen Chenc711fec2020-11-22 23:52:50 -05001031 }
1032 if codename == "REL" {
1033 panic("Platform_sdk_codename should not be REL when Platform_sdk_final is true")
1034 }
1035 return ApiLevelOrPanic(ctx, codename)
Colin Crossd09b0b62018-04-18 11:06:47 -07001036}
1037
Colin Cross3bc7ffa2017-11-22 16:19:37 -08001038func (c *config) AppsDefaultVersionName() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001039 return String(c.productVariables.AppsDefaultVersionName)
Colin Cross3bc7ffa2017-11-22 16:19:37 -08001040}
1041
Dan Albert31384de2017-07-28 12:39:46 -07001042// Codenames that are active in the current lunch target.
1043func (c *config) PlatformVersionActiveCodenames() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001044 return c.productVariables.Platform_version_active_codenames
Dan Albert31384de2017-07-28 12:39:46 -07001045}
1046
Dan Albert8c7a9942023-03-27 20:34:01 +00001047// All unreleased codenames.
1048func (c *config) PlatformVersionAllPreviewCodenames() []string {
1049 return c.productVariables.Platform_version_all_preview_codenames
1050}
1051
Colin Crossface4e42017-10-30 17:32:15 -07001052func (c *config) ProductAAPTConfig() []string {
Colin Crossa74ca042019-01-31 14:31:51 -08001053 return c.productVariables.AAPTConfig
Colin Cross30e076a2015-04-13 13:58:27 -07001054}
1055
Colin Crossface4e42017-10-30 17:32:15 -07001056func (c *config) ProductAAPTPreferredConfig() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001057 return String(c.productVariables.AAPTPreferredConfig)
Colin Cross30e076a2015-04-13 13:58:27 -07001058}
1059
Colin Crossface4e42017-10-30 17:32:15 -07001060func (c *config) ProductAAPTCharacteristics() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001061 return String(c.productVariables.AAPTCharacteristics)
Colin Crossface4e42017-10-30 17:32:15 -07001062}
1063
1064func (c *config) ProductAAPTPrebuiltDPI() []string {
Colin Crossa74ca042019-01-31 14:31:51 -08001065 return c.productVariables.AAPTPrebuiltDPI
Colin Cross30e076a2015-04-13 13:58:27 -07001066}
1067
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001068func (c *config) DefaultAppCertificateDir(ctx PathContext) SourcePath {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001069 defaultCert := String(c.productVariables.DefaultAppCertificate)
Colin Cross61ae0b72017-12-01 17:16:02 -08001070 if defaultCert != "" {
1071 return PathForSource(ctx, filepath.Dir(defaultCert))
Colin Cross61ae0b72017-12-01 17:16:02 -08001072 }
Jingwen Chenc711fec2020-11-22 23:52:50 -05001073 return PathForSource(ctx, "build/make/target/product/security")
Colin Cross30e076a2015-04-13 13:58:27 -07001074}
1075
Colin Crosse1731a52017-12-14 11:22:55 -08001076func (c *config) DefaultAppCertificate(ctx PathContext) (pem, key SourcePath) {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001077 defaultCert := String(c.productVariables.DefaultAppCertificate)
Colin Cross61ae0b72017-12-01 17:16:02 -08001078 if defaultCert != "" {
Colin Crosse1731a52017-12-14 11:22:55 -08001079 return PathForSource(ctx, defaultCert+".x509.pem"), PathForSource(ctx, defaultCert+".pk8")
Colin Cross61ae0b72017-12-01 17:16:02 -08001080 }
Jingwen Chenc711fec2020-11-22 23:52:50 -05001081 defaultDir := c.DefaultAppCertificateDir(ctx)
1082 return defaultDir.Join(ctx, "testkey.x509.pem"), defaultDir.Join(ctx, "testkey.pk8")
Colin Cross30e076a2015-04-13 13:58:27 -07001083}
Colin Cross6ff51382015-12-17 16:39:19 -08001084
Jiyong Park9335a262018-12-24 11:31:58 +09001085func (c *config) ApexKeyDir(ctx ModuleContext) SourcePath {
1086 // TODO(b/121224311): define another variable such as TARGET_APEX_KEY_OVERRIDE
1087 defaultCert := String(c.productVariables.DefaultAppCertificate)
Dan Willemsen412160e2019-04-09 21:36:26 -07001088 if defaultCert == "" || filepath.Dir(defaultCert) == "build/make/target/product/security" {
Jiyong Park9335a262018-12-24 11:31:58 +09001089 // When defaultCert is unset or is set to the testkeys path, use the APEX keys
1090 // that is under the module dir
Colin Cross07e51612019-03-05 12:46:40 -08001091 return pathForModuleSrc(ctx)
Jiyong Park9335a262018-12-24 11:31:58 +09001092 }
Jingwen Chenc711fec2020-11-22 23:52:50 -05001093 // If not, APEX keys are under the specified directory
1094 return PathForSource(ctx, filepath.Dir(defaultCert))
Jiyong Park9335a262018-12-24 11:31:58 +09001095}
1096
Inseob Kim80fa7982022-08-12 21:36:25 +09001097// Certificate for the NetworkStack sepolicy context
1098func (c *config) MainlineSepolicyDevCertificatesDir(ctx ModuleContext) SourcePath {
1099 cert := String(c.productVariables.MainlineSepolicyDevCertificates)
1100 if cert != "" {
1101 return PathForSource(ctx, cert)
1102 }
1103 return c.DefaultAppCertificateDir(ctx)
1104}
1105
Jingwen Chenc711fec2020-11-22 23:52:50 -05001106// AllowMissingDependencies configures Blueprint/Soong to not fail when modules
1107// are configured to depend on non-existent modules. Note that this does not
1108// affect missing input dependencies at the Ninja level.
Colin Cross6ff51382015-12-17 16:39:19 -08001109func (c *config) AllowMissingDependencies() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001110 return Bool(c.productVariables.Allow_missing_dependencies)
Colin Cross6ff51382015-12-17 16:39:19 -08001111}
Dan Willemsen322acaf2016-01-12 23:07:05 -08001112
Jeongik Cha816a23a2020-07-08 01:09:23 +09001113// Returns true if a full platform source tree cannot be assumed.
Colin Crossfc3674a2017-09-18 17:41:52 -07001114func (c *config) UnbundledBuild() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001115 return Bool(c.productVariables.Unbundled_build)
Colin Crossfc3674a2017-09-18 17:41:52 -07001116}
1117
Martin Stjernholmfd9eb4b2020-06-17 01:13:15 +01001118// Returns true if building apps that aren't bundled with the platform.
1119// UnbundledBuild() is always true when this is true.
1120func (c *config) UnbundledBuildApps() bool {
Cole Faust701ca252021-11-23 19:02:08 -08001121 return len(c.productVariables.Unbundled_build_apps) > 0
Martin Stjernholmfd9eb4b2020-06-17 01:13:15 +01001122}
1123
Jeongik Cha4b073cd2021-06-08 11:35:00 +09001124// Returns true if building image that aren't bundled with the platform.
1125// UnbundledBuild() is always true when this is true.
1126func (c *config) UnbundledBuildImage() bool {
1127 return Bool(c.productVariables.Unbundled_build_image)
1128}
1129
Jeongik Cha816a23a2020-07-08 01:09:23 +09001130// Returns true if building modules against prebuilt SDKs.
1131func (c *config) AlwaysUsePrebuiltSdks() bool {
1132 return Bool(c.productVariables.Always_use_prebuilt_sdks)
Colin Cross1f367bf2018-12-18 22:46:24 -08001133}
1134
Colin Cross126a25c2017-10-31 13:55:34 -07001135func (c *config) MinimizeJavaDebugInfo() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001136 return Bool(c.productVariables.MinimizeJavaDebugInfo) && !Bool(c.productVariables.Eng)
Colin Cross126a25c2017-10-31 13:55:34 -07001137}
1138
Colin Crossed064c02018-09-05 16:28:13 -07001139func (c *config) Debuggable() bool {
1140 return Bool(c.productVariables.Debuggable)
1141}
1142
Jaewoong Jung1d6eb682018-11-29 15:08:44 -08001143func (c *config) Eng() bool {
1144 return Bool(c.productVariables.Eng)
1145}
1146
Colin Crossc53c37f2021-12-08 15:42:22 -08001147// DevicePrimaryArchType returns the ArchType for the first configured device architecture, or
1148// Common if there are no device architectures.
Jiyong Park8d52f862018-07-07 18:02:07 +09001149func (c *config) DevicePrimaryArchType() ArchType {
Colin Crossc53c37f2021-12-08 15:42:22 -08001150 if androidTargets := c.Targets[Android]; len(androidTargets) > 0 {
1151 return androidTargets[0].Arch.ArchType
1152 }
1153 return Common
Jiyong Park8d52f862018-07-07 18:02:07 +09001154}
1155
Colin Cross16b23492016-01-06 14:41:07 -08001156func (c *config) SanitizeHost() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001157 return append([]string(nil), c.productVariables.SanitizeHost...)
Colin Cross16b23492016-01-06 14:41:07 -08001158}
1159
1160func (c *config) SanitizeDevice() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001161 return append([]string(nil), c.productVariables.SanitizeDevice...)
Colin Cross23ae82a2016-11-02 14:34:39 -07001162}
1163
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -07001164func (c *config) SanitizeDeviceDiag() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001165 return append([]string(nil), c.productVariables.SanitizeDeviceDiag...)
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -07001166}
1167
Colin Cross23ae82a2016-11-02 14:34:39 -07001168func (c *config) SanitizeDeviceArch() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001169 return append([]string(nil), c.productVariables.SanitizeDeviceArch...)
Colin Cross16b23492016-01-06 14:41:07 -08001170}
Colin Crossa1ad8d12016-06-01 17:09:44 -07001171
Vishwath Mohan1b017a72017-01-19 13:54:55 -08001172func (c *config) EnableCFI() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001173 if c.productVariables.EnableCFI == nil {
Vishwath Mohanc32c3eb2017-01-24 14:20:54 -08001174 return true
Vishwath Mohanc32c3eb2017-01-24 14:20:54 -08001175 }
Jingwen Chenc711fec2020-11-22 23:52:50 -05001176 return *c.productVariables.EnableCFI
Vishwath Mohan1b017a72017-01-19 13:54:55 -08001177}
1178
Kostya Kortchinskyd5275c82019-02-01 08:42:56 -08001179func (c *config) DisableScudo() bool {
1180 return Bool(c.productVariables.DisableScudo)
1181}
1182
Colin Crossa1ad8d12016-06-01 17:09:44 -07001183func (c *config) Android64() bool {
Dan Willemsen0ef639b2018-10-10 17:02:29 -07001184 for _, t := range c.Targets[Android] {
Colin Crossa1ad8d12016-06-01 17:09:44 -07001185 if t.Arch.ArchType.Multilib == "lib64" {
1186 return true
1187 }
1188 }
1189
1190 return false
1191}
Colin Cross9272ade2016-08-17 15:24:12 -07001192
Colin Cross9d45bb72016-08-29 16:14:13 -07001193func (c *config) UseGoma() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001194 return Bool(c.productVariables.UseGoma)
Colin Cross9d45bb72016-08-29 16:14:13 -07001195}
1196
Ramy Medhatbbf25672019-07-17 12:30:04 +00001197func (c *config) UseRBE() bool {
1198 return Bool(c.productVariables.UseRBE)
1199}
1200
Ramy Medhat8ea054a2020-01-27 14:19:44 -05001201func (c *config) UseRBEJAVAC() bool {
1202 return Bool(c.productVariables.UseRBEJAVAC)
1203}
1204
1205func (c *config) UseRBER8() bool {
1206 return Bool(c.productVariables.UseRBER8)
1207}
1208
1209func (c *config) UseRBED8() bool {
1210 return Bool(c.productVariables.UseRBED8)
1211}
1212
Colin Cross8b8bec32019-11-15 13:18:43 -08001213func (c *config) UseRemoteBuild() bool {
1214 return c.UseGoma() || c.UseRBE()
1215}
1216
Colin Cross66548102018-06-19 22:47:35 -07001217func (c *config) RunErrorProne() bool {
1218 return c.IsEnvTrue("RUN_ERROR_PRONE")
1219}
1220
Jingwen Chenc711fec2020-11-22 23:52:50 -05001221// XrefCorpusName returns the Kythe cross-reference corpus name.
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001222func (c *config) XrefCorpusName() string {
1223 return c.Getenv("XREF_CORPUS")
1224}
1225
Jingwen Chenc711fec2020-11-22 23:52:50 -05001226// XrefCuEncoding returns the compilation unit encoding to use for Kythe code
1227// xrefs. Can be 'json' (default), 'proto' or 'all'.
Sasha Smundak6c2d4f92020-01-09 17:34:23 -08001228func (c *config) XrefCuEncoding() string {
1229 if enc := c.Getenv("KYTHE_KZIP_ENCODING"); enc != "" {
1230 return enc
1231 }
1232 return "json"
1233}
1234
Sasha Smundakb0addaf2021-02-16 10:39:40 -08001235// XrefCuJavaSourceMax returns the maximum number of the Java source files
1236// in a single compilation unit
1237const xrefJavaSourceFileMaxDefault = "1000"
1238
1239func (c Config) XrefCuJavaSourceMax() string {
1240 v := c.Getenv("KYTHE_JAVA_SOURCE_BATCH_SIZE")
1241 if v == "" {
1242 return xrefJavaSourceFileMaxDefault
1243 }
1244 if _, err := strconv.ParseUint(v, 0, 0); err != nil {
1245 fmt.Fprintf(os.Stderr,
1246 "bad KYTHE_JAVA_SOURCE_BATCH_SIZE value: %s, will use %s",
1247 err, xrefJavaSourceFileMaxDefault)
1248 return xrefJavaSourceFileMaxDefault
1249 }
1250 return v
1251
1252}
1253
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001254func (c *config) EmitXrefRules() bool {
1255 return c.XrefCorpusName() != ""
1256}
1257
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001258func (c *config) ClangTidy() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001259 return Bool(c.productVariables.ClangTidy)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001260}
1261
1262func (c *config) TidyChecks() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001263 if c.productVariables.TidyChecks == nil {
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001264 return ""
1265 }
Dan Willemsen45133ac2018-03-09 21:22:06 -08001266 return *c.productVariables.TidyChecks
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001267}
1268
Colin Cross0f4e0d62016-07-27 10:56:55 -07001269func (c *config) LibartImgHostBaseAddress() string {
1270 return "0x60000000"
1271}
1272
1273func (c *config) LibartImgDeviceBaseAddress() string {
Elliott Hughesda3a0712020-03-06 16:55:28 -08001274 return "0x70000000"
Colin Cross0f4e0d62016-07-27 10:56:55 -07001275}
1276
Hiroshi Yamauchie2a10632016-12-19 13:44:41 -08001277func (c *config) ArtUseReadBarrier() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001278 return Bool(c.productVariables.ArtUseReadBarrier)
Hiroshi Yamauchie2a10632016-12-19 13:44:41 -08001279}
1280
Jingwen Chenc711fec2020-11-22 23:52:50 -05001281// Enforce Runtime Resource Overlays for a module. RROs supersede static RROs,
1282// but some modules still depend on it.
1283//
1284// More info: https://source.android.com/devices/architecture/rros
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001285func (c *config) EnforceRROForModule(name string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001286 enforceList := c.productVariables.EnforceRROTargets
Jeongik Chacee5ba92021-02-19 12:11:51 +09001287
Roland Levillainf6cc2612020-07-09 16:58:14 +01001288 if len(enforceList) > 0 {
Yo Chiang4ebd06a2019-10-01 13:13:41 +08001289 if InList("*", enforceList) {
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001290 return true
1291 }
Colin Crossa74ca042019-01-31 14:31:51 -08001292 return InList(name, enforceList)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001293 }
1294 return false
1295}
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001296func (c *config) EnforceRROExcludedOverlay(path string) bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001297 excluded := c.productVariables.EnforceRROExcludedOverlays
Roland Levillainf6cc2612020-07-09 16:58:14 +01001298 if len(excluded) > 0 {
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001299 return HasAnyPrefix(path, excluded)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001300 }
1301 return false
1302}
1303
1304func (c *config) ExportedNamespaces() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001305 return append([]string(nil), c.productVariables.NamespacesToExport...)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001306}
1307
Sam Delmerico98a73292023-02-21 11:50:29 -05001308func (c *config) SourceRootDirs() []string {
1309 return c.productVariables.SourceRootDirs
1310}
1311
Spandan Dasc5763832022-11-08 18:42:16 +00001312func (c *config) IncludeTags() []string {
1313 return c.productVariables.IncludeTags
1314}
1315
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001316func (c *config) HostStaticBinaries() bool {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001317 return Bool(c.productVariables.HostStaticBinaries)
Dan Willemsen3fb1fae2018-03-12 15:30:26 -07001318}
1319
Colin Cross5a0dcd52018-10-05 14:20:06 -07001320func (c *config) UncompressPrivAppDex() bool {
1321 return Bool(c.productVariables.UncompressPrivAppDex)
1322}
1323
1324func (c *config) ModulesLoadedByPrivilegedModules() []string {
1325 return c.productVariables.ModulesLoadedByPrivilegedModules
1326}
1327
Jingwen Chenc711fec2020-11-22 23:52:50 -05001328// DexpreoptGlobalConfigPath returns the path to the dexpreopt.config file in
1329// the output directory, if it was created during the product configuration
1330// phase by Kati.
Jingwen Chenebb0b572020-11-02 00:24:57 -05001331func (c *config) DexpreoptGlobalConfigPath(ctx PathContext) OptionalPath {
Colin Cross988414c2020-01-11 01:11:46 +00001332 if c.productVariables.DexpreoptGlobalConfig == nil {
Jingwen Chenebb0b572020-11-02 00:24:57 -05001333 return OptionalPathForPath(nil)
1334 }
1335 return OptionalPathForPath(
1336 pathForBuildToolDep(ctx, *c.productVariables.DexpreoptGlobalConfig))
1337}
1338
Jingwen Chenc711fec2020-11-22 23:52:50 -05001339// DexpreoptGlobalConfig returns the raw byte contents of the dexpreopt global
1340// configuration. Since the configuration file was created by Kati during
1341// product configuration (externally of soong_build), it's not tracked, so we
1342// also manually add a Ninja file dependency on the configuration file to the
1343// rule that creates the main build.ninja file. This ensures that build.ninja is
1344// regenerated correctly if dexpreopt.config changes.
Jingwen Chenebb0b572020-11-02 00:24:57 -05001345func (c *config) DexpreoptGlobalConfig(ctx PathContext) ([]byte, error) {
1346 path := c.DexpreoptGlobalConfigPath(ctx)
1347 if !path.Valid() {
Colin Cross988414c2020-01-11 01:11:46 +00001348 return nil, nil
1349 }
Jingwen Chenebb0b572020-11-02 00:24:57 -05001350 ctx.AddNinjaFileDeps(path.String())
Sasha Smundakaf5ca922022-12-12 21:23:34 -08001351 return os.ReadFile(absolutePath(path.String()))
Colin Cross43f08db2018-11-12 10:13:39 -08001352}
1353
Inseob Kim7b85eeb2021-03-23 20:52:24 +09001354func (c *deviceConfig) WithDexpreopt() bool {
1355 return c.config.productVariables.WithDexpreopt
1356}
1357
Colin Cross662d6142022-11-03 20:38:01 -07001358func (c *config) FrameworksBaseDirExists(ctx PathGlobContext) bool {
Colin Cross5a756a62021-03-16 16:34:46 -07001359 return ExistentPathForSource(ctx, "frameworks", "base", "Android.bp").Valid()
David Brazdil91b4e3e2019-01-23 21:04:05 +00001360}
1361
Inseob Kimae553032019-05-14 18:52:49 +09001362func (c *config) VndkSnapshotBuildArtifacts() bool {
1363 return Bool(c.productVariables.VndkSnapshotBuildArtifacts)
1364}
1365
Colin Cross3b19f5d2019-09-17 14:45:31 -07001366func (c *config) HasMultilibConflict(arch ArchType) bool {
1367 return c.multilibConflicts[arch]
1368}
1369
Sasha Smundakaf5ca922022-12-12 21:23:34 -08001370func (c *config) PrebuiltHiddenApiDir(_ PathContext) string {
Bill Peckhambae47492021-01-08 09:34:44 -08001371 return String(c.productVariables.PrebuiltHiddenApiDir)
1372}
1373
MarkDacekd06db5d2022-11-29 00:47:59 +00001374func (c *config) BazelModulesForceEnabledByFlag() map[string]struct{} {
1375 return c.bazelForceEnabledModules
1376}
1377
Kiyoung Kime623c582023-07-06 16:43:44 +09001378func (c *config) IsVndkDeprecated() bool {
1379 return !Bool(c.productVariables.KeepVndk)
1380}
1381
Colin Cross9272ade2016-08-17 15:24:12 -07001382func (c *deviceConfig) Arches() []Arch {
1383 var arches []Arch
Dan Willemsen0ef639b2018-10-10 17:02:29 -07001384 for _, target := range c.config.Targets[Android] {
Colin Cross9272ade2016-08-17 15:24:12 -07001385 arches = append(arches, target.Arch)
1386 }
1387 return arches
1388}
Dan Willemsend2ede872016-11-18 14:54:24 -08001389
Jayant Chowdhary34ce67d2018-03-08 11:00:50 -08001390func (c *deviceConfig) BinderBitness() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001391 is32BitBinder := c.config.productVariables.Binder32bit
Jayant Chowdhary34ce67d2018-03-08 11:00:50 -08001392 if is32BitBinder != nil && *is32BitBinder {
1393 return "32"
1394 }
1395 return "64"
1396}
1397
Dan Willemsen4353bc42016-12-05 17:16:02 -08001398func (c *deviceConfig) VendorPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001399 if c.config.productVariables.VendorPath != nil {
1400 return *c.config.productVariables.VendorPath
Dan Willemsen4353bc42016-12-05 17:16:02 -08001401 }
1402 return "vendor"
1403}
1404
Justin Yun71549282017-11-17 12:10:28 +09001405func (c *deviceConfig) VndkVersion() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001406 return String(c.config.productVariables.DeviceVndkVersion)
Justin Yun71549282017-11-17 12:10:28 +09001407}
1408
Jose Galmes6f843bc2020-12-11 13:36:29 -08001409func (c *deviceConfig) RecoverySnapshotVersion() string {
1410 return String(c.config.productVariables.RecoverySnapshotVersion)
1411}
1412
Jeongik Cha219141c2020-08-06 23:00:37 +09001413func (c *deviceConfig) CurrentApiLevelForVendorModules() string {
1414 return StringDefault(c.config.productVariables.DeviceCurrentApiLevelForVendorModules, "current")
1415}
1416
Justin Yun8fe12122017-12-07 17:18:15 +09001417func (c *deviceConfig) PlatformVndkVersion() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001418 return String(c.config.productVariables.Platform_vndk_version)
Justin Yun8fe12122017-12-07 17:18:15 +09001419}
1420
Justin Yun5f7f7e82019-11-18 19:52:14 +09001421func (c *deviceConfig) ProductVndkVersion() string {
1422 return String(c.config.productVariables.ProductVndkVersion)
1423}
1424
Justin Yun71549282017-11-17 12:10:28 +09001425func (c *deviceConfig) ExtraVndkVersions() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001426 return c.config.productVariables.ExtraVndkVersions
Dan Willemsend2ede872016-11-18 14:54:24 -08001427}
Jack He8cc71432016-12-08 15:45:07 -08001428
Vic Yangefd249e2018-11-12 20:19:56 -08001429func (c *deviceConfig) VndkUseCoreVariant() bool {
1430 return Bool(c.config.productVariables.VndkUseCoreVariant)
1431}
1432
Jiyong Park1a5d7b12018-01-15 15:05:10 +09001433func (c *deviceConfig) SystemSdkVersions() []string {
Colin Crossa74ca042019-01-31 14:31:51 -08001434 return c.config.productVariables.DeviceSystemSdkVersions
Jiyong Park1a5d7b12018-01-15 15:05:10 +09001435}
1436
1437func (c *deviceConfig) PlatformSystemSdkVersions() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001438 return c.config.productVariables.Platform_systemsdk_versions
Jiyong Park1a5d7b12018-01-15 15:05:10 +09001439}
1440
Jiyong Park2db76922017-11-08 16:03:48 +09001441func (c *deviceConfig) OdmPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001442 if c.config.productVariables.OdmPath != nil {
1443 return *c.config.productVariables.OdmPath
Jiyong Park2db76922017-11-08 16:03:48 +09001444 }
1445 return "odm"
1446}
1447
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +09001448func (c *deviceConfig) ProductPath() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001449 if c.config.productVariables.ProductPath != nil {
1450 return *c.config.productVariables.ProductPath
Jiyong Park2db76922017-11-08 16:03:48 +09001451 }
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +09001452 return "product"
Jiyong Park2db76922017-11-08 16:03:48 +09001453}
1454
Justin Yund5f6c822019-06-25 16:47:17 +09001455func (c *deviceConfig) SystemExtPath() string {
1456 if c.config.productVariables.SystemExtPath != nil {
1457 return *c.config.productVariables.SystemExtPath
Dario Frenifd05a742018-05-29 13:28:54 +01001458 }
Justin Yund5f6c822019-06-25 16:47:17 +09001459 return "system_ext"
Dario Frenifd05a742018-05-29 13:28:54 +01001460}
1461
Jack He8cc71432016-12-08 15:45:07 -08001462func (c *deviceConfig) BtConfigIncludeDir() string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001463 return String(c.config.productVariables.BtConfigIncludeDir)
Jack He8cc71432016-12-08 15:45:07 -08001464}
Dan Willemsen581341d2017-02-09 16:16:31 -08001465
Jiyong Parkd773eb32017-07-03 13:18:12 +09001466func (c *deviceConfig) DeviceKernelHeaderDirs() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001467 return c.config.productVariables.DeviceKernelHeaders
Jiyong Parkd773eb32017-07-03 13:18:12 +09001468}
1469
Roland Levillainada12702020-06-09 13:07:36 +01001470// JavaCoverageEnabledForPath returns whether Java code coverage is enabled for
1471// path. Coverage is enabled by default when the product variable
1472// JavaCoveragePaths is empty. If JavaCoveragePaths is not empty, coverage is
1473// enabled for any path which is part of this variable (and not part of the
1474// JavaCoverageExcludePaths product variable). Value "*" in JavaCoveragePaths
1475// represents any path.
1476func (c *deviceConfig) JavaCoverageEnabledForPath(path string) bool {
1477 coverage := false
Chris Gross2f748692020-06-24 20:36:59 +00001478 if len(c.config.productVariables.JavaCoveragePaths) == 0 ||
Roland Levillainada12702020-06-09 13:07:36 +01001479 InList("*", c.config.productVariables.JavaCoveragePaths) ||
1480 HasAnyPrefix(path, c.config.productVariables.JavaCoveragePaths) {
1481 coverage = true
1482 }
Roland Levillainf6cc2612020-07-09 16:58:14 +01001483 if coverage && len(c.config.productVariables.JavaCoverageExcludePaths) > 0 {
Roland Levillainada12702020-06-09 13:07:36 +01001484 if HasAnyPrefix(path, c.config.productVariables.JavaCoverageExcludePaths) {
1485 coverage = false
1486 }
1487 }
1488 return coverage
1489}
1490
Colin Cross1a6acd42020-06-16 17:51:46 -07001491// Returns true if gcov or clang coverage is enabled.
Dan Willemsen581341d2017-02-09 16:16:31 -08001492func (c *deviceConfig) NativeCoverageEnabled() bool {
Colin Cross1a6acd42020-06-16 17:51:46 -07001493 return Bool(c.config.productVariables.GcovCoverage) ||
1494 Bool(c.config.productVariables.ClangCoverage)
Dan Willemsen581341d2017-02-09 16:16:31 -08001495}
1496
Oliver Nguyen1382ab62019-12-06 15:22:41 -08001497func (c *deviceConfig) ClangCoverageEnabled() bool {
1498 return Bool(c.config.productVariables.ClangCoverage)
1499}
1500
Pirama Arumuga Nainarb37ae582022-01-26 22:14:32 -08001501func (c *deviceConfig) ClangCoverageContinuousMode() bool {
1502 return Bool(c.config.productVariables.ClangCoverageContinuousMode)
1503}
1504
Colin Cross1a6acd42020-06-16 17:51:46 -07001505func (c *deviceConfig) GcovCoverageEnabled() bool {
1506 return Bool(c.config.productVariables.GcovCoverage)
1507}
1508
Roland Levillain4f5297b2020-06-09 12:44:06 +01001509// NativeCoverageEnabledForPath returns whether (GCOV- or Clang-based) native
1510// code coverage is enabled for path. By default, coverage is not enabled for a
1511// given path unless it is part of the NativeCoveragePaths product variable (and
1512// not part of the NativeCoverageExcludePaths product variable). Value "*" in
1513// NativeCoveragePaths represents any path.
1514func (c *deviceConfig) NativeCoverageEnabledForPath(path string) bool {
Ryan Campbell469a18a2017-02-27 09:01:54 -08001515 coverage := false
Roland Levillainf6cc2612020-07-09 16:58:14 +01001516 if len(c.config.productVariables.NativeCoveragePaths) > 0 {
Roland Levillain4f5297b2020-06-09 12:44:06 +01001517 if InList("*", c.config.productVariables.NativeCoveragePaths) || HasAnyPrefix(path, c.config.productVariables.NativeCoveragePaths) {
Ivan Lozano5f595532017-07-13 14:46:05 -07001518 coverage = true
Dan Willemsen581341d2017-02-09 16:16:31 -08001519 }
1520 }
Roland Levillainf6cc2612020-07-09 16:58:14 +01001521 if coverage && len(c.config.productVariables.NativeCoverageExcludePaths) > 0 {
Yi Kongfd07ed22023-02-16 17:42:27 +09001522 // Workaround coverage boot failure.
1523 // http://b/269981180
1524 if strings.HasPrefix(path, "external/protobuf") {
1525 coverage = false
1526 }
Roland Levillain4f5297b2020-06-09 12:44:06 +01001527 if HasAnyPrefix(path, c.config.productVariables.NativeCoverageExcludePaths) {
Ivan Lozano5f595532017-07-13 14:46:05 -07001528 coverage = false
Ryan Campbell469a18a2017-02-27 09:01:54 -08001529 }
1530 }
1531 return coverage
Dan Willemsen581341d2017-02-09 16:16:31 -08001532}
Ivan Lozano5f595532017-07-13 14:46:05 -07001533
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -08001534func (c *deviceConfig) PgoAdditionalProfileDirs() []string {
Dan Willemsen45133ac2018-03-09 21:22:06 -08001535 return c.config.productVariables.PgoAdditionalProfileDirs
Pirama Arumuga Nainar49540802018-01-29 23:11:42 -08001536}
1537
Vinh Tran44cb78c2023-03-09 22:07:19 -05001538// AfdoProfile returns fully qualified path associated to the given module name
1539func (c *deviceConfig) AfdoProfile(name string) (*string, error) {
1540 for _, afdoProfile := range c.config.productVariables.AfdoProfiles {
1541 split := strings.Split(afdoProfile, ":")
1542 if len(split) != 3 {
1543 return nil, fmt.Errorf("AFDO_PROFILES has invalid value: %s. "+
1544 "The expected format is <module>:<fully-qualified-path-to-fdo_profile>", afdoProfile)
1545 }
1546 if split[0] == name {
1547 return proptools.StringPtr(strings.Join([]string{split[1], split[2]}, ":")), nil
1548 }
1549 }
1550 return nil, nil
1551}
1552
Tri Vo35a51432018-03-25 20:00:00 -07001553func (c *deviceConfig) VendorSepolicyDirs() []string {
1554 return c.config.productVariables.BoardVendorSepolicyDirs
1555}
1556
1557func (c *deviceConfig) OdmSepolicyDirs() []string {
1558 return c.config.productVariables.BoardOdmSepolicyDirs
1559}
1560
Felixa20a8752020-05-17 18:28:35 +02001561func (c *deviceConfig) SystemExtPublicSepolicyDirs() []string {
1562 return c.config.productVariables.SystemExtPublicSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -07001563}
1564
Felixa20a8752020-05-17 18:28:35 +02001565func (c *deviceConfig) SystemExtPrivateSepolicyDirs() []string {
1566 return c.config.productVariables.SystemExtPrivateSepolicyDirs
Tri Vo35a51432018-03-25 20:00:00 -07001567}
1568
Inseob Kim0866b002019-04-15 20:21:29 +09001569func (c *deviceConfig) SepolicyM4Defs() []string {
1570 return c.config.productVariables.BoardSepolicyM4Defs
1571}
1572
Jiyong Park7f67f482019-01-05 12:57:48 +09001573func (c *deviceConfig) OverrideManifestPackageNameFor(name string) (manifestName string, overridden bool) {
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001574 return findOverrideValue(c.config.productVariables.ManifestPackageNameOverrides, name,
1575 "invalid override rule %q in PRODUCT_MANIFEST_PACKAGE_NAME_OVERRIDES should be <module_name>:<manifest_name>")
1576}
1577
1578func (c *deviceConfig) OverrideCertificateFor(name string) (certificatePath string, overridden bool) {
Jaewoong Jungacb6db32019-02-28 16:22:30 +00001579 return findOverrideValue(c.config.productVariables.CertificateOverrides, name,
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001580 "invalid override rule %q in PRODUCT_CERTIFICATE_OVERRIDES should be <module_name>:<certificate_module_name>")
1581}
1582
Jaewoong Jung9d22a912019-01-23 16:27:47 -08001583func (c *deviceConfig) OverridePackageNameFor(name string) string {
1584 newName, overridden := findOverrideValue(
1585 c.config.productVariables.PackageNameOverrides,
1586 name,
1587 "invalid override rule %q in PRODUCT_PACKAGE_NAME_OVERRIDES should be <module_name>:<package_name>")
1588 if overridden {
1589 return newName
1590 }
1591 return name
1592}
1593
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001594func findOverrideValue(overrides []string, name string, errorMsg string) (newValue string, overridden bool) {
Jiyong Park7f67f482019-01-05 12:57:48 +09001595 if overrides == nil || len(overrides) == 0 {
1596 return "", false
1597 }
1598 for _, o := range overrides {
1599 split := strings.Split(o, ":")
1600 if len(split) != 2 {
1601 // This shouldn't happen as this is first checked in make, but just in case.
Jaewoong Jung2ad817c2019-01-18 14:27:16 -08001602 panic(fmt.Errorf(errorMsg, o))
Jiyong Park7f67f482019-01-05 12:57:48 +09001603 }
1604 if matchPattern(split[0], name) {
1605 return substPattern(split[0], split[1], name), true
1606 }
1607 }
1608 return "", false
1609}
1610
Albert Martineefabcf2022-03-21 20:11:16 +00001611func (c *deviceConfig) ApexGlobalMinSdkVersionOverride() string {
1612 return String(c.config.productVariables.ApexGlobalMinSdkVersionOverride)
1613}
1614
Ivan Lozano5f595532017-07-13 14:46:05 -07001615func (c *config) IntegerOverflowDisabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001616 if len(c.productVariables.IntegerOverflowExcludePaths) == 0 {
Ivan Lozano5f595532017-07-13 14:46:05 -07001617 return false
1618 }
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001619 return HasAnyPrefix(path, c.productVariables.IntegerOverflowExcludePaths)
Ivan Lozano5f595532017-07-13 14:46:05 -07001620}
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001621
1622func (c *config) CFIDisabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001623 if len(c.productVariables.CFIExcludePaths) == 0 {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001624 return false
1625 }
Jaewoong Jung3aff5782020-02-11 07:54:35 -08001626 return HasAnyPrefix(path, c.productVariables.CFIExcludePaths)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001627}
1628
1629func (c *config) CFIEnabledForPath(path string) bool {
Roland Levillainf6cc2612020-07-09 16:58:14 +01001630 if len(c.productVariables.CFIIncludePaths) == 0 {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001631 return false
1632 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001633 return HasAnyPrefix(path, c.productVariables.CFIIncludePaths) && !c.CFIDisabledForPath(path)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -07001634}
Colin Crosse15ddaf2017-12-04 11:24:31 -08001635
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001636func (c *config) MemtagHeapDisabledForPath(path string) bool {
1637 if len(c.productVariables.MemtagHeapExcludePaths) == 0 {
1638 return false
1639 }
1640 return HasAnyPrefix(path, c.productVariables.MemtagHeapExcludePaths)
1641}
1642
1643func (c *config) MemtagHeapAsyncEnabledForPath(path string) bool {
1644 if len(c.productVariables.MemtagHeapAsyncIncludePaths) == 0 {
1645 return false
1646 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001647 return HasAnyPrefix(path, c.productVariables.MemtagHeapAsyncIncludePaths) && !c.MemtagHeapDisabledForPath(path)
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001648}
1649
1650func (c *config) MemtagHeapSyncEnabledForPath(path string) bool {
1651 if len(c.productVariables.MemtagHeapSyncIncludePaths) == 0 {
1652 return false
1653 }
Evgenii Stepanov779b64e2021-04-09 14:33:10 -07001654 return HasAnyPrefix(path, c.productVariables.MemtagHeapSyncIncludePaths) && !c.MemtagHeapDisabledForPath(path)
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -08001655}
1656
Hang Lua98aab92023-03-17 13:17:22 +08001657func (c *config) HWASanEnabledForPath(path string) bool {
1658 if len(c.productVariables.HWASanIncludePaths) == 0 {
1659 return false
1660 }
1661 return HasAnyPrefix(path, c.productVariables.HWASanIncludePaths)
1662}
1663
Dan Willemsen0fe78662018-03-26 12:41:18 -07001664func (c *config) VendorConfig(name string) VendorConfig {
Colin Cross9d34f352019-11-22 16:03:51 -08001665 return soongconfig.Config(c.productVariables.VendorVars[name])
Dan Willemsen0fe78662018-03-26 12:41:18 -07001666}
1667
Colin Cross395f2cf2018-10-24 16:10:32 -07001668func (c *config) NdkAbis() bool {
1669 return Bool(c.productVariables.Ndk_abis)
1670}
1671
Martin Stjernholmc1ecc432019-11-15 15:00:31 +00001672func (c *config) AmlAbis() bool {
1673 return Bool(c.productVariables.Aml_abis)
1674}
1675
Jiyong Park4da07972021-01-05 21:01:11 +09001676func (c *config) ForceApexSymlinkOptimization() bool {
1677 return Bool(c.productVariables.ForceApexSymlinkOptimization)
1678}
1679
Sasha Smundakfe9a5b82022-07-27 14:51:45 -07001680func (c *config) ApexCompressionEnabled() bool {
1681 return Bool(c.productVariables.CompressedApex) && !c.UnbundledBuildApps()
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +00001682}
1683
Dennis Shene2ed70c2023-01-11 14:15:43 +00001684func (c *config) ApexTrimEnabled() bool {
1685 return Bool(c.productVariables.TrimmedApex)
1686}
1687
Jeongik Chac9464142019-01-07 12:07:27 +09001688func (c *config) EnforceSystemCertificate() bool {
1689 return Bool(c.productVariables.EnforceSystemCertificate)
1690}
1691
Colin Cross440e0d02020-06-11 11:32:11 -07001692func (c *config) EnforceSystemCertificateAllowList() []string {
1693 return c.productVariables.EnforceSystemCertificateAllowList
Jeongik Chac9464142019-01-07 12:07:27 +09001694}
1695
Jeongik Cha2cc570d2019-10-29 15:44:45 +09001696func (c *config) EnforceProductPartitionInterface() bool {
1697 return Bool(c.productVariables.EnforceProductPartitionInterface)
1698}
1699
JaeMan Parkff715562020-10-19 17:25:58 +09001700func (c *config) EnforceInterPartitionJavaSdkLibrary() bool {
1701 return Bool(c.productVariables.EnforceInterPartitionJavaSdkLibrary)
1702}
1703
1704func (c *config) InterPartitionJavaLibraryAllowList() []string {
1705 return c.productVariables.InterPartitionJavaLibraryAllowList
1706}
1707
Colin Crossf24a22a2019-01-31 14:12:44 -08001708func (c *config) ProductHiddenAPIStubs() []string {
1709 return c.productVariables.ProductHiddenAPIStubs
Colin Cross8faf8fc2019-01-16 15:15:52 -08001710}
1711
Colin Crossf24a22a2019-01-31 14:12:44 -08001712func (c *config) ProductHiddenAPIStubsSystem() []string {
1713 return c.productVariables.ProductHiddenAPIStubsSystem
Colin Cross8faf8fc2019-01-16 15:15:52 -08001714}
1715
Colin Crossf24a22a2019-01-31 14:12:44 -08001716func (c *config) ProductHiddenAPIStubsTest() []string {
1717 return c.productVariables.ProductHiddenAPIStubsTest
Colin Cross8faf8fc2019-01-16 15:15:52 -08001718}
Dan Willemsen71c74602019-04-10 12:27:35 -07001719
Dan Willemsen54879d12019-04-18 10:08:46 -07001720func (c *deviceConfig) TargetFSConfigGen() []string {
Dan Willemsen71c74602019-04-10 12:27:35 -07001721 return c.config.productVariables.TargetFSConfigGen
1722}
Inseob Kim0866b002019-04-15 20:21:29 +09001723
1724func (c *config) ProductPublicSepolicyDirs() []string {
1725 return c.productVariables.ProductPublicSepolicyDirs
1726}
1727
1728func (c *config) ProductPrivateSepolicyDirs() []string {
1729 return c.productVariables.ProductPrivateSepolicyDirs
1730}
1731
Inseob Kim5eb7ee92022-04-27 10:30:34 +09001732func (c *config) TargetMultitreeUpdateMeta() bool {
1733 return c.productVariables.MultitreeUpdateMeta
1734}
1735
Inseob Kim1f086e22019-05-09 13:29:15 +09001736func (c *deviceConfig) DeviceArch() string {
1737 return String(c.config.productVariables.DeviceArch)
1738}
1739
1740func (c *deviceConfig) DeviceArchVariant() string {
1741 return String(c.config.productVariables.DeviceArchVariant)
1742}
1743
1744func (c *deviceConfig) DeviceSecondaryArch() string {
1745 return String(c.config.productVariables.DeviceSecondaryArch)
1746}
1747
1748func (c *deviceConfig) DeviceSecondaryArchVariant() string {
1749 return String(c.config.productVariables.DeviceSecondaryArchVariant)
1750}
Yifan Hong82db7352020-01-21 16:12:26 -08001751
1752func (c *deviceConfig) BoardUsesRecoveryAsBoot() bool {
1753 return Bool(c.config.productVariables.BoardUsesRecoveryAsBoot)
1754}
Yifan Hong97365ee2020-07-29 09:51:57 -07001755
1756func (c *deviceConfig) BoardKernelBinaries() []string {
1757 return c.config.productVariables.BoardKernelBinaries
1758}
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001759
Yifan Hong42bef8d2020-08-05 14:36:09 -07001760func (c *deviceConfig) BoardKernelModuleInterfaceVersions() []string {
1761 return c.config.productVariables.BoardKernelModuleInterfaceVersions
1762}
1763
Yifan Hongdd8dacc2020-10-21 15:40:17 -07001764func (c *deviceConfig) BoardMoveRecoveryResourcesToVendorBoot() bool {
1765 return Bool(c.config.productVariables.BoardMoveRecoveryResourcesToVendorBoot)
1766}
1767
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001768func (c *deviceConfig) PlatformSepolicyVersion() string {
1769 return String(c.config.productVariables.PlatformSepolicyVersion)
1770}
1771
Inseob Kima10ef272021-09-15 03:04:53 +00001772func (c *deviceConfig) TotSepolicyVersion() string {
1773 return String(c.config.productVariables.TotSepolicyVersion)
1774}
1775
Inseob Kim843f6642022-01-07 09:11:23 +09001776func (c *deviceConfig) PlatformSepolicyCompatVersions() []string {
1777 return c.config.productVariables.PlatformSepolicyCompatVersions
1778}
1779
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001780func (c *deviceConfig) BoardSepolicyVers() string {
Inseob Kim0c4eec82021-03-22 22:33:40 +09001781 if ver := String(c.config.productVariables.BoardSepolicyVers); ver != "" {
1782 return ver
1783 }
1784 return c.PlatformSepolicyVersion()
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001785}
1786
Inseob Kim14178802021-12-08 22:53:31 +09001787func (c *deviceConfig) BoardPlatVendorPolicy() []string {
1788 return c.config.productVariables.BoardPlatVendorPolicy
1789}
1790
Inseob Kim16ebd5a2020-12-09 23:08:17 +09001791func (c *deviceConfig) BoardReqdMaskPolicy() []string {
1792 return c.config.productVariables.BoardReqdMaskPolicy
1793}
1794
Inseob Kim0f46e7c2021-12-15 22:48:14 +09001795func (c *deviceConfig) BoardSystemExtPublicPrebuiltDirs() []string {
1796 return c.config.productVariables.BoardSystemExtPublicPrebuiltDirs
1797}
1798
1799func (c *deviceConfig) BoardSystemExtPrivatePrebuiltDirs() []string {
1800 return c.config.productVariables.BoardSystemExtPrivatePrebuiltDirs
1801}
1802
1803func (c *deviceConfig) BoardProductPublicPrebuiltDirs() []string {
1804 return c.config.productVariables.BoardProductPublicPrebuiltDirs
1805}
1806
1807func (c *deviceConfig) BoardProductPrivatePrebuiltDirs() []string {
1808 return c.config.productVariables.BoardProductPrivatePrebuiltDirs
1809}
1810
Inseob Kim1a0afcc2022-02-14 23:10:51 +09001811func (c *deviceConfig) SystemExtSepolicyPrebuiltApiDir() string {
1812 return String(c.config.productVariables.SystemExtSepolicyPrebuiltApiDir)
1813}
1814
1815func (c *deviceConfig) ProductSepolicyPrebuiltApiDir() string {
1816 return String(c.config.productVariables.ProductSepolicyPrebuiltApiDir)
1817}
1818
1819func (c *deviceConfig) IsPartnerTrebleSepolicyTestEnabled() bool {
1820 return c.SystemExtSepolicyPrebuiltApiDir() != "" || c.ProductSepolicyPrebuiltApiDir() != ""
1821}
1822
Inseob Kim7cf14652021-01-06 23:06:52 +09001823func (c *deviceConfig) DirectedVendorSnapshot() bool {
1824 return c.config.productVariables.DirectedVendorSnapshot
1825}
1826
1827func (c *deviceConfig) VendorSnapshotModules() map[string]bool {
1828 return c.config.productVariables.VendorSnapshotModules
1829}
1830
Jose Galmes4c6895e2021-02-09 07:44:30 -08001831func (c *deviceConfig) DirectedRecoverySnapshot() bool {
1832 return c.config.productVariables.DirectedRecoverySnapshot
1833}
1834
1835func (c *deviceConfig) RecoverySnapshotModules() map[string]bool {
1836 return c.config.productVariables.RecoverySnapshotModules
1837}
1838
Justin DeMartino383bfb32021-02-24 10:49:43 -08001839func createDirsMap(previous map[string]bool, dirs []string) (map[string]bool, error) {
1840 var ret = make(map[string]bool)
1841 for _, dir := range dirs {
1842 clean := filepath.Clean(dir)
1843 if previous[clean] || ret[clean] {
1844 return nil, fmt.Errorf("Duplicate entry %s", dir)
1845 }
1846 ret[clean] = true
1847 }
1848 return ret, nil
1849}
1850
1851func (c *deviceConfig) createDirsMapOnce(onceKey OnceKey, previous map[string]bool, dirs []string) map[string]bool {
1852 dirMap := c.Once(onceKey, func() interface{} {
1853 ret, err := createDirsMap(previous, dirs)
1854 if err != nil {
1855 panic(fmt.Errorf("%s: %w", onceKey.key, err))
1856 }
1857 return ret
1858 })
1859 if dirMap == nil {
1860 return nil
1861 }
1862 return dirMap.(map[string]bool)
1863}
1864
1865var vendorSnapshotDirsExcludedKey = NewOnceKey("VendorSnapshotDirsExcludedMap")
1866
1867func (c *deviceConfig) VendorSnapshotDirsExcludedMap() map[string]bool {
1868 return c.createDirsMapOnce(vendorSnapshotDirsExcludedKey, nil,
1869 c.config.productVariables.VendorSnapshotDirsExcluded)
1870}
1871
1872var vendorSnapshotDirsIncludedKey = NewOnceKey("VendorSnapshotDirsIncludedMap")
1873
1874func (c *deviceConfig) VendorSnapshotDirsIncludedMap() map[string]bool {
1875 excludedMap := c.VendorSnapshotDirsExcludedMap()
1876 return c.createDirsMapOnce(vendorSnapshotDirsIncludedKey, excludedMap,
1877 c.config.productVariables.VendorSnapshotDirsIncluded)
1878}
1879
1880var recoverySnapshotDirsExcludedKey = NewOnceKey("RecoverySnapshotDirsExcludedMap")
1881
1882func (c *deviceConfig) RecoverySnapshotDirsExcludedMap() map[string]bool {
1883 return c.createDirsMapOnce(recoverySnapshotDirsExcludedKey, nil,
1884 c.config.productVariables.RecoverySnapshotDirsExcluded)
1885}
1886
1887var recoverySnapshotDirsIncludedKey = NewOnceKey("RecoverySnapshotDirsIncludedMap")
1888
1889func (c *deviceConfig) RecoverySnapshotDirsIncludedMap() map[string]bool {
1890 excludedMap := c.RecoverySnapshotDirsExcludedMap()
1891 return c.createDirsMapOnce(recoverySnapshotDirsIncludedKey, excludedMap,
1892 c.config.productVariables.RecoverySnapshotDirsIncluded)
1893}
1894
Rob Seymour925aa092021-08-10 20:42:03 +00001895func (c *deviceConfig) HostFakeSnapshotEnabled() bool {
1896 return c.config.productVariables.HostFakeSnapshotEnabled
1897}
1898
Inseob Kim60c32f02020-12-21 22:53:05 +09001899func (c *deviceConfig) ShippingApiLevel() ApiLevel {
1900 if c.config.productVariables.ShippingApiLevel == nil {
1901 return NoneApiLevel
1902 }
1903 apiLevel, _ := strconv.Atoi(*c.config.productVariables.ShippingApiLevel)
1904 return uncheckedFinalApiLevel(apiLevel)
1905}
1906
Liz Kammer33cc80e2023-05-18 18:20:28 +00001907func (c *deviceConfig) BuildBrokenPluginValidation() []string {
1908 return c.config.productVariables.BuildBrokenPluginValidation
1909}
1910
Alix Espinoef47e542022-09-14 19:10:51 +00001911func (c *deviceConfig) BuildBrokenClangAsFlags() bool {
1912 return c.config.productVariables.BuildBrokenClangAsFlags
1913}
1914
1915func (c *deviceConfig) BuildBrokenClangCFlags() bool {
1916 return c.config.productVariables.BuildBrokenClangCFlags
1917}
1918
Alixb5f6d9e2022-04-20 23:00:58 +00001919func (c *deviceConfig) BuildBrokenClangProperty() bool {
1920 return c.config.productVariables.BuildBrokenClangProperty
1921}
1922
Inseob Kim67e5add192021-03-17 18:05:33 +09001923func (c *deviceConfig) BuildBrokenEnforceSyspropOwner() bool {
1924 return c.config.productVariables.BuildBrokenEnforceSyspropOwner
1925}
1926
1927func (c *deviceConfig) BuildBrokenTrebleSyspropNeverallow() bool {
1928 return c.config.productVariables.BuildBrokenTrebleSyspropNeverallow
1929}
1930
Cole Faustedc4c502022-09-09 19:39:25 -07001931func (c *deviceConfig) BuildBrokenUsesSoongPython2Modules() bool {
1932 return c.config.productVariables.BuildBrokenUsesSoongPython2Modules
1933}
1934
Hridya Valsaraju5a5c7d52021-04-02 16:45:24 -07001935func (c *deviceConfig) BuildDebugfsRestrictionsEnabled() bool {
1936 return c.config.productVariables.BuildDebugfsRestrictionsEnabled
1937}
1938
Inseob Kim0cac7b42021-02-03 18:16:46 +09001939func (c *deviceConfig) BuildBrokenVendorPropertyNamespace() bool {
1940 return c.config.productVariables.BuildBrokenVendorPropertyNamespace
1941}
1942
Liz Kammer619be462022-01-28 15:13:39 -05001943func (c *deviceConfig) BuildBrokenInputDir(name string) bool {
1944 return InList(name, c.config.productVariables.BuildBrokenInputDirModules)
1945}
1946
Jiakai Zhang48203e32023-06-02 23:42:21 +01001947func (c *config) BuildWarningBadOptionalUsesLibsAllowlist() []string {
1948 return c.productVariables.BuildWarningBadOptionalUsesLibsAllowlist
1949}
1950
Yu Liu6a7940c2023-05-09 17:12:22 -07001951func (c *deviceConfig) GenruleSandboxing() bool {
1952 return Bool(c.config.productVariables.GenruleSandboxing)
Vinh Tran140d5882022-06-10 14:23:27 -04001953}
1954
Inseob Kim67e5add192021-03-17 18:05:33 +09001955func (c *deviceConfig) RequiresInsecureExecmemForSwiftshader() bool {
1956 return c.config.productVariables.RequiresInsecureExecmemForSwiftshader
1957}
1958
Devin Moorec381e102023-07-06 22:03:58 +00001959func (c *deviceConfig) Release_aidl_use_unfrozen() bool {
1960 return Bool(c.config.productVariables.Release_aidl_use_unfrozen)
1961}
1962
Inseob Kim67e5add192021-03-17 18:05:33 +09001963func (c *config) SelinuxIgnoreNeverallows() bool {
1964 return c.productVariables.SelinuxIgnoreNeverallows
1965}
1966
Inseob Kima10ef272021-09-15 03:04:53 +00001967func (c *deviceConfig) SepolicyFreezeTestExtraDirs() []string {
1968 return c.config.productVariables.SepolicyFreezeTestExtraDirs
1969}
1970
1971func (c *deviceConfig) SepolicyFreezeTestExtraPrebuiltDirs() []string {
1972 return c.config.productVariables.SepolicyFreezeTestExtraPrebuiltDirs
1973}
1974
Jiyong Parkd163d4d2021-10-12 16:47:43 +09001975func (c *deviceConfig) GenerateAidlNdkPlatformBackend() bool {
1976 return c.config.productVariables.GenerateAidlNdkPlatformBackend
1977}
1978
Christopher Ferris98f10222022-07-13 23:16:52 -07001979func (c *config) IgnorePrefer32OnDevice() bool {
1980 return c.productVariables.IgnorePrefer32OnDevice
1981}
1982
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001983func (c *config) BootJars() []string {
1984 return c.Once(earlyBootJarsKey, func() interface{} {
Paul Duffin69d1fb12020-10-23 21:14:20 +01001985 list := c.productVariables.BootJars.CopyOfJars()
satayevd604b212021-07-21 14:23:52 +01001986 return append(list, c.productVariables.ApexBootJars.CopyOfJars()...)
Ulya Trafimovich249386a2020-07-01 14:31:13 +01001987 }).([]string)
1988}
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001989
satayevd604b212021-07-21 14:23:52 +01001990func (c *config) NonApexBootJars() ConfiguredJarList {
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001991 return c.productVariables.BootJars
1992}
1993
satayevd604b212021-07-21 14:23:52 +01001994func (c *config) ApexBootJars() ConfiguredJarList {
1995 return c.productVariables.ApexBootJars
Paul Duffin9a89a2a2020-10-28 19:20:06 +00001996}
Colin Cross77cdcfd2021-03-12 11:28:25 -08001997
1998func (c *config) RBEWrapper() string {
1999 return c.GetenvWithDefault("RBE_WRAPPER", remoteexec.DefaultWrapperPath)
2000}
Colin Cross9b698b62021-12-22 09:55:32 -08002001
2002// UseHostMusl returns true if the host target has been configured to build against musl libc.
2003func (c *config) UseHostMusl() bool {
2004 return Bool(c.productVariables.HostMusl)
2005}
MarkDacekff851b82022-04-21 18:33:17 +00002006
MarkDacekf47e1422023-04-19 16:47:36 +00002007func (c *config) GetMixedBuildsEnabledModules() map[string]struct{} {
2008 return c.mixedBuildEnabledModules
2009}
2010
MarkDacek6f6b9622023-05-02 16:28:55 +00002011func (c *config) GetMixedBuildsDisabledModules() map[string]struct{} {
2012 return c.mixedBuildDisabledModules
2013}
2014
Chris Parsonsf874e462022-05-10 13:50:12 -04002015func (c *config) LogMixedBuild(ctx BaseModuleContext, useBazel bool) {
MarkDacekff851b82022-04-21 18:33:17 +00002016 moduleName := ctx.Module().Name()
2017 c.mixedBuildsLock.Lock()
2018 defer c.mixedBuildsLock.Unlock()
2019 if useBazel {
2020 c.mixedBuildEnabledModules[moduleName] = struct{}{}
2021 } else {
2022 c.mixedBuildDisabledModules[moduleName] = struct{}{}
2023 }
2024}
Spandan Das9e93d3d2023-03-08 05:47:29 +00002025
Chris Parsons8152a942023-06-06 16:17:50 +00002026func (c *config) HasBazelBuildTargetInSource(ctx BaseModuleContext) bool {
2027 moduleName := ctx.Module().Name()
2028 for _, buildTarget := range c.bazelTargetsByDir[ctx.ModuleDir()] {
2029 if moduleName == buildTarget {
2030 return true
2031 }
2032 }
2033 return false
2034}
2035
2036func (c *config) SetBazelBuildFileTargets(bazelTargetsByDir map[string][]string) {
2037 c.bazelTargetsByDir = bazelTargetsByDir
2038}
2039
Spandan Das9e93d3d2023-03-08 05:47:29 +00002040// ApiSurfaces directory returns the source path inside the api_surfaces repo
2041// (relative to workspace root).
2042func (c *config) ApiSurfacesDir(s ApiSurface, version string) string {
2043 return filepath.Join(
2044 "build",
2045 "bazel",
2046 "api_surfaces",
2047 s.String(),
2048 version)
2049}
Jihoon Kang1bff0342023-01-17 20:40:22 +00002050
2051func (c *config) BuildFromTextStub() bool {
2052 return c.buildFromTextStub
2053}
Spandan Das4deab282023-03-30 17:06:32 +00002054
2055func (c *config) SetBuildFromTextStub(b bool) {
2056 c.buildFromTextStub = b
Jihoon Kangcbcad7c2023-06-01 22:31:52 +00002057 c.productVariables.Build_from_text_stub = boolPtr(b)
Spandan Das4deab282023-03-30 17:06:32 +00002058}
Jihoon Kang1c92c3e2023-03-23 17:44:51 +00002059
MarkDacek9c094ca2023-03-16 19:15:19 +00002060func (c *config) AddForceEnabledModules(forceEnabled []string) {
2061 for _, forceEnabledModule := range forceEnabled {
2062 c.bazelForceEnabledModules[forceEnabledModule] = struct{}{}
2063 }
2064}
Jihoon Kang1c92c3e2023-03-23 17:44:51 +00002065
2066func (c *config) SetApiLibraries(libs []string) {
2067 c.apiLibraries = make(map[string]struct{})
2068 for _, lib := range libs {
2069 c.apiLibraries[lib] = struct{}{}
2070 }
2071}
2072
2073func (c *config) GetApiLibraries() map[string]struct{} {
2074 return c.apiLibraries
2075}